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, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
6 Rewritten by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
35 #include "pointer-set.h"
39 #include "cp-objcp-common.h"
40 #include "tree-inline.h"
47 #include "tree-iterator.h"
50 /* The type of functions taking a tree, and some additional data, and
52 typedef int (*tree_fn_t) (tree, void*);
54 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work. */
57 struct GTY (()) pending_template {
58 struct pending_template *next;
59 struct tinst_level *tinst;
62 static GTY(()) struct pending_template *pending_templates;
63 static GTY(()) struct pending_template *last_pending_template;
65 int processing_template_parmlist;
66 static int template_header_count;
68 static GTY(()) tree saved_trees;
69 static VEC(int,heap) *inline_parm_levels;
71 static GTY(()) struct tinst_level *current_tinst_level;
73 static GTY(()) tree saved_access_scope;
75 /* Live only within one (recursive) call to tsubst_expr. We use
76 this to pass the statement expression node from the STMT_EXPR
77 to the EXPR_STMT that is its result. */
78 static tree cur_stmt_expr;
80 /* A map from local variable declarations in the body of the template
81 presently being instantiated to the corresponding instantiated
83 static htab_t local_specializations;
85 typedef struct GTY(()) spec_entry
92 static GTY ((param_is (spec_entry)))
93 htab_t decl_specializations;
95 static GTY ((param_is (spec_entry)))
96 htab_t type_specializations;
98 /* Contains canonical template parameter types. The vector is indexed by
99 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
100 TREE_LIST, whose TREE_VALUEs contain the canonical template
101 parameters of various types and levels. */
102 static GTY(()) VEC(tree,gc) *canonical_template_parms;
104 #define UNIFY_ALLOW_NONE 0
105 #define UNIFY_ALLOW_MORE_CV_QUAL 1
106 #define UNIFY_ALLOW_LESS_CV_QUAL 2
107 #define UNIFY_ALLOW_DERIVED 4
108 #define UNIFY_ALLOW_INTEGER 8
109 #define UNIFY_ALLOW_OUTER_LEVEL 16
110 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
111 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
113 static void push_access_scope (tree);
114 static void pop_access_scope (tree);
115 static bool resolve_overloaded_unification (tree, tree, tree, tree,
116 unification_kind_t, int);
117 static int try_one_overload (tree, tree, tree, tree, tree,
118 unification_kind_t, int, bool);
119 static int unify (tree, tree, tree, tree, int);
120 static void add_pending_template (tree);
121 static int push_tinst_level (tree);
122 static void pop_tinst_level (void);
123 static tree reopen_tinst_level (struct tinst_level *);
124 static tree tsubst_initializer_list (tree, tree);
125 static tree get_class_bindings (tree, tree, tree);
126 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
128 static void tsubst_enum (tree, tree, tree);
129 static tree add_to_template_args (tree, tree);
130 static tree add_outermost_template_args (tree, tree);
131 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
132 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
134 static int type_unification_real (tree, tree, tree, const tree *,
135 unsigned int, int, unification_kind_t, int);
136 static void note_template_header (int);
137 static tree convert_nontype_argument_function (tree, tree);
138 static tree convert_nontype_argument (tree, tree);
139 static tree convert_template_argument (tree, tree, tree,
140 tsubst_flags_t, int, tree);
141 static int for_each_template_parm (tree, tree_fn_t, void*,
142 struct pointer_set_t*, bool);
143 static tree expand_template_argument_pack (tree);
144 static tree build_template_parm_index (int, int, int, tree, tree);
145 static bool inline_needs_template_parms (tree);
146 static void push_inline_template_parms_recursive (tree, int);
147 static tree retrieve_local_specialization (tree);
148 static void register_local_specialization (tree, tree);
149 static hashval_t hash_specialization (const void *p);
150 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
151 static int mark_template_parm (tree, void *);
152 static int template_parm_this_level_p (tree, void *);
153 static tree tsubst_friend_function (tree, tree);
154 static tree tsubst_friend_class (tree, tree);
155 static int can_complete_type_without_circularity (tree);
156 static tree get_bindings (tree, tree, tree, bool);
157 static int template_decl_level (tree);
158 static int check_cv_quals_for_unify (int, tree, tree);
159 static void template_parm_level_and_index (tree, int*, int*);
160 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
161 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
162 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
163 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
164 static void regenerate_decl_from_template (tree, tree);
165 static tree most_specialized_class (tree, tree);
166 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
167 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
168 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
169 static bool check_specialization_scope (void);
170 static tree process_partial_specialization (tree);
171 static void set_current_access_from_decl (tree);
172 static tree get_template_base (tree, tree, tree, tree);
173 static tree try_class_unification (tree, tree, tree, tree);
174 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
176 static bool template_template_parm_bindings_ok_p (tree, tree);
177 static int template_args_equal (tree, tree);
178 static void tsubst_default_arguments (tree);
179 static tree for_each_template_parm_r (tree *, int *, void *);
180 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
181 static void copy_default_args_to_explicit_spec (tree);
182 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
183 static int eq_local_specializations (const void *, const void *);
184 static bool dependent_template_arg_p (tree);
185 static bool any_template_arguments_need_structural_equality_p (tree);
186 static bool dependent_type_p_r (tree);
187 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
188 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
189 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
190 static tree tsubst_decl (tree, tree, tsubst_flags_t);
191 static void perform_typedefs_access_check (tree tmpl, tree targs);
192 static void append_type_to_template_for_access_check_1 (tree, tree, tree);
193 static hashval_t iterative_hash_template_arg (tree arg, hashval_t val);
194 static tree listify (tree);
195 static tree listify_autos (tree, tree);
197 /* Make the current scope suitable for access checking when we are
198 processing T. T can be FUNCTION_DECL for instantiated function
199 template, or VAR_DECL for static member variable (need by
200 instantiate_decl). */
203 push_access_scope (tree t)
205 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
206 || TREE_CODE (t) == VAR_DECL);
208 if (DECL_FRIEND_CONTEXT (t))
209 push_nested_class (DECL_FRIEND_CONTEXT (t));
210 else if (DECL_CLASS_SCOPE_P (t))
211 push_nested_class (DECL_CONTEXT (t));
213 push_to_top_level ();
215 if (TREE_CODE (t) == FUNCTION_DECL)
217 saved_access_scope = tree_cons
218 (NULL_TREE, current_function_decl, saved_access_scope);
219 current_function_decl = t;
223 /* Restore the scope set up by push_access_scope. T is the node we
227 pop_access_scope (tree t)
229 if (TREE_CODE (t) == FUNCTION_DECL)
231 current_function_decl = TREE_VALUE (saved_access_scope);
232 saved_access_scope = TREE_CHAIN (saved_access_scope);
235 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
238 pop_from_top_level ();
241 /* Do any processing required when DECL (a member template
242 declaration) is finished. Returns the TEMPLATE_DECL corresponding
243 to DECL, unless it is a specialization, in which case the DECL
244 itself is returned. */
247 finish_member_template_decl (tree decl)
249 if (decl == error_mark_node)
250 return error_mark_node;
252 gcc_assert (DECL_P (decl));
254 if (TREE_CODE (decl) == TYPE_DECL)
258 type = TREE_TYPE (decl);
259 if (type == error_mark_node)
260 return error_mark_node;
261 if (MAYBE_CLASS_TYPE_P (type)
262 && CLASSTYPE_TEMPLATE_INFO (type)
263 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
265 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
266 check_member_template (tmpl);
271 else if (TREE_CODE (decl) == FIELD_DECL)
272 error ("data member %qD cannot be a member template", decl);
273 else if (DECL_TEMPLATE_INFO (decl))
275 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
277 check_member_template (DECL_TI_TEMPLATE (decl));
278 return DECL_TI_TEMPLATE (decl);
284 error ("invalid member template declaration %qD", decl);
286 return error_mark_node;
289 /* Return the template info node corresponding to T, whatever T is. */
292 get_template_info (const_tree t)
294 tree tinfo = NULL_TREE;
296 if (!t || t == error_mark_node)
299 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
300 tinfo = DECL_TEMPLATE_INFO (t);
302 if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
305 if (TAGGED_TYPE_P (t))
306 tinfo = TYPE_TEMPLATE_INFO (t);
311 /* Returns the template nesting level of the indicated class TYPE.
321 A<T>::B<U> has depth two, while A<T> has depth one.
322 Both A<T>::B<int> and A<int>::B<U> have depth one, if
323 they are instantiations, not specializations.
325 This function is guaranteed to return 0 if passed NULL_TREE so
326 that, for example, `template_class_depth (current_class_type)' is
330 template_class_depth (tree type)
335 type && TREE_CODE (type) != NAMESPACE_DECL;
336 type = (TREE_CODE (type) == FUNCTION_DECL)
337 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
339 tree tinfo = get_template_info (type);
341 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
342 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
349 /* Subroutine of maybe_begin_member_template_processing.
350 Returns true if processing DECL needs us to push template parms. */
353 inline_needs_template_parms (tree decl)
355 if (! DECL_TEMPLATE_INFO (decl))
358 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
359 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
362 /* Subroutine of maybe_begin_member_template_processing.
363 Push the template parms in PARMS, starting from LEVELS steps into the
364 chain, and ending at the beginning, since template parms are listed
368 push_inline_template_parms_recursive (tree parmlist, int levels)
370 tree parms = TREE_VALUE (parmlist);
374 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
376 ++processing_template_decl;
377 current_template_parms
378 = tree_cons (size_int (processing_template_decl),
379 parms, current_template_parms);
380 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
382 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
384 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
386 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
388 if (parm == error_mark_node)
391 gcc_assert (DECL_P (parm));
393 switch (TREE_CODE (parm))
402 /* Make a CONST_DECL as is done in process_template_parm.
403 It is ugly that we recreate this here; the original
404 version built in process_template_parm is no longer
406 tree decl = build_decl (DECL_SOURCE_LOCATION (parm),
407 CONST_DECL, DECL_NAME (parm),
409 DECL_ARTIFICIAL (decl) = 1;
410 TREE_CONSTANT (decl) = 1;
411 TREE_READONLY (decl) = 1;
412 DECL_INITIAL (decl) = DECL_INITIAL (parm);
413 SET_DECL_TEMPLATE_PARM_P (decl);
424 /* Restore the template parameter context for a member template or
425 a friend template defined in a class definition. */
428 maybe_begin_member_template_processing (tree decl)
433 if (inline_needs_template_parms (decl))
435 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
436 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
438 if (DECL_TEMPLATE_SPECIALIZATION (decl))
441 parms = TREE_CHAIN (parms);
444 push_inline_template_parms_recursive (parms, levels);
447 /* Remember how many levels of template parameters we pushed so that
448 we can pop them later. */
449 VEC_safe_push (int, heap, inline_parm_levels, levels);
452 /* Undo the effects of maybe_begin_member_template_processing. */
455 maybe_end_member_template_processing (void)
460 if (VEC_length (int, inline_parm_levels) == 0)
463 last = VEC_pop (int, inline_parm_levels);
464 for (i = 0; i < last; ++i)
466 --processing_template_decl;
467 current_template_parms = TREE_CHAIN (current_template_parms);
472 /* Return a new template argument vector which contains all of ARGS,
473 but has as its innermost set of arguments the EXTRA_ARGS. */
476 add_to_template_args (tree args, tree extra_args)
483 extra_depth = TMPL_ARGS_DEPTH (extra_args);
484 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
486 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
487 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
489 for (j = 1; j <= extra_depth; ++j, ++i)
490 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
495 /* Like add_to_template_args, but only the outermost ARGS are added to
496 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
497 (EXTRA_ARGS) levels are added. This function is used to combine
498 the template arguments from a partial instantiation with the
499 template arguments used to attain the full instantiation from the
500 partial instantiation. */
503 add_outermost_template_args (tree args, tree extra_args)
507 /* If there are more levels of EXTRA_ARGS than there are ARGS,
508 something very fishy is going on. */
509 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
511 /* If *all* the new arguments will be the EXTRA_ARGS, just return
513 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
516 /* For the moment, we make ARGS look like it contains fewer levels. */
517 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
519 new_args = add_to_template_args (args, extra_args);
521 /* Now, we restore ARGS to its full dimensions. */
522 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
527 /* Return the N levels of innermost template arguments from the ARGS. */
530 get_innermost_template_args (tree args, int n)
538 /* If N is 1, just return the innermost set of template arguments. */
540 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
542 /* If we're not removing anything, just return the arguments we were
544 extra_levels = TMPL_ARGS_DEPTH (args) - n;
545 gcc_assert (extra_levels >= 0);
546 if (extra_levels == 0)
549 /* Make a new set of arguments, not containing the outer arguments. */
550 new_args = make_tree_vec (n);
551 for (i = 1; i <= n; ++i)
552 SET_TMPL_ARGS_LEVEL (new_args, i,
553 TMPL_ARGS_LEVEL (args, i + extra_levels));
558 /* The inverse of get_innermost_template_args: Return all but the innermost
559 EXTRA_LEVELS levels of template arguments from the ARGS. */
562 strip_innermost_template_args (tree args, int extra_levels)
565 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
570 /* If N is 1, just return the outermost set of template arguments. */
572 return TMPL_ARGS_LEVEL (args, 1);
574 /* If we're not removing anything, just return the arguments we were
576 gcc_assert (extra_levels >= 0);
577 if (extra_levels == 0)
580 /* Make a new set of arguments, not containing the inner arguments. */
581 new_args = make_tree_vec (n);
582 for (i = 1; i <= n; ++i)
583 SET_TMPL_ARGS_LEVEL (new_args, i,
584 TMPL_ARGS_LEVEL (args, i));
589 /* We've got a template header coming up; push to a new level for storing
593 begin_template_parm_list (void)
595 /* We use a non-tag-transparent scope here, which causes pushtag to
596 put tags in this scope, rather than in the enclosing class or
597 namespace scope. This is the right thing, since we want
598 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
599 global template class, push_template_decl handles putting the
600 TEMPLATE_DECL into top-level scope. For a nested template class,
603 template <class T> struct S1 {
604 template <class T> struct S2 {};
607 pushtag contains special code to call pushdecl_with_scope on the
608 TEMPLATE_DECL for S2. */
609 begin_scope (sk_template_parms, NULL);
610 ++processing_template_decl;
611 ++processing_template_parmlist;
612 note_template_header (0);
615 /* This routine is called when a specialization is declared. If it is
616 invalid to declare a specialization here, an error is reported and
617 false is returned, otherwise this routine will return true. */
620 check_specialization_scope (void)
622 tree scope = current_scope ();
626 An explicit specialization shall be declared in the namespace of
627 which the template is a member, or, for member templates, in the
628 namespace of which the enclosing class or enclosing class
629 template is a member. An explicit specialization of a member
630 function, member class or static data member of a class template
631 shall be declared in the namespace of which the class template
633 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
635 error ("explicit specialization in non-namespace scope %qD", scope);
641 In an explicit specialization declaration for a member of a class
642 template or a member template that appears in namespace scope,
643 the member template and some of its enclosing class templates may
644 remain unspecialized, except that the declaration shall not
645 explicitly specialize a class member template if its enclosing
646 class templates are not explicitly specialized as well. */
647 if (current_template_parms)
649 error ("enclosing class templates are not explicitly specialized");
656 /* We've just seen template <>. */
659 begin_specialization (void)
661 begin_scope (sk_template_spec, NULL);
662 note_template_header (1);
663 return check_specialization_scope ();
666 /* Called at then end of processing a declaration preceded by
670 end_specialization (void)
673 reset_specialization ();
676 /* Any template <>'s that we have seen thus far are not referring to a
677 function specialization. */
680 reset_specialization (void)
682 processing_specialization = 0;
683 template_header_count = 0;
686 /* We've just seen a template header. If SPECIALIZATION is nonzero,
687 it was of the form template <>. */
690 note_template_header (int specialization)
692 processing_specialization = specialization;
693 template_header_count++;
696 /* We're beginning an explicit instantiation. */
699 begin_explicit_instantiation (void)
701 gcc_assert (!processing_explicit_instantiation);
702 processing_explicit_instantiation = true;
707 end_explicit_instantiation (void)
709 gcc_assert (processing_explicit_instantiation);
710 processing_explicit_instantiation = false;
713 /* An explicit specialization or partial specialization TMPL is being
714 declared. Check that the namespace in which the specialization is
715 occurring is permissible. Returns false iff it is invalid to
716 specialize TMPL in the current namespace. */
719 check_specialization_namespace (tree tmpl)
721 tree tpl_ns = decl_namespace_context (tmpl);
725 An explicit specialization shall be declared in the namespace of
726 which the template is a member, or, for member templates, in the
727 namespace of which the enclosing class or enclosing class
728 template is a member. An explicit specialization of a member
729 function, member class or static data member of a class template
730 shall be declared in the namespace of which the class template is
732 if (is_associated_namespace (current_namespace, tpl_ns))
733 /* Same or super-using namespace. */
737 permerror (input_location, "specialization of %qD in different namespace", tmpl);
738 permerror (input_location, " from definition of %q+#D", tmpl);
743 /* SPEC is an explicit instantiation. Check that it is valid to
744 perform this explicit instantiation in the current namespace. */
747 check_explicit_instantiation_namespace (tree spec)
751 /* DR 275: An explicit instantiation shall appear in an enclosing
752 namespace of its template. */
753 ns = decl_namespace_context (spec);
754 if (!is_ancestor (current_namespace, ns))
755 permerror (input_location, "explicit instantiation of %qD in namespace %qD "
756 "(which does not enclose namespace %qD)",
757 spec, current_namespace, ns);
760 /* The TYPE is being declared. If it is a template type, that means it
761 is a partial specialization. Do appropriate error-checking. */
764 maybe_process_partial_specialization (tree type)
768 if (type == error_mark_node)
769 return error_mark_node;
771 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
773 error ("name of class shadows template template parameter %qD",
775 return error_mark_node;
778 context = TYPE_CONTEXT (type);
780 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
782 /* This is for ordinary explicit specialization and partial
783 specialization of a template class such as:
785 template <> class C<int>;
789 template <class T> class C<T*>;
791 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
793 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
794 && !COMPLETE_TYPE_P (type))
796 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
797 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
798 if (processing_template_decl)
800 if (push_template_decl (TYPE_MAIN_DECL (type))
802 return error_mark_node;
805 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
806 error ("specialization of %qT after instantiation", type);
808 else if (CLASS_TYPE_P (type)
809 && !CLASSTYPE_USE_TEMPLATE (type)
810 && CLASSTYPE_TEMPLATE_INFO (type)
811 && context && CLASS_TYPE_P (context)
812 && CLASSTYPE_TEMPLATE_INFO (context))
814 /* This is for an explicit specialization of member class
815 template according to [temp.expl.spec/18]:
817 template <> template <class U> class C<int>::D;
819 The context `C<int>' must be an implicit instantiation.
820 Otherwise this is just a member class template declared
823 template <> class C<int> { template <class U> class D; };
824 template <> template <class U> class C<int>::D;
826 In the first case, `C<int>::D' is a specialization of `C<T>::D'
827 while in the second case, `C<int>::D' is a primary template
828 and `C<T>::D' may not exist. */
830 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
831 && !COMPLETE_TYPE_P (type))
834 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
836 if (current_namespace
837 != decl_namespace_context (tmpl))
839 permerror (input_location, "specializing %q#T in different namespace", type);
840 permerror (input_location, " from definition of %q+#D", tmpl);
843 /* Check for invalid specialization after instantiation:
845 template <> template <> class C<int>::D<int>;
846 template <> template <class U> class C<int>::D; */
848 for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
849 t; t = TREE_CHAIN (t))
851 tree inst = TREE_VALUE (t);
852 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst))
854 /* We already have a full specialization of this partial
855 instantiation. Reassign it to the new member
856 specialization template. */
860 elt.tmpl = most_general_template (tmpl);
861 elt.args = CLASSTYPE_TI_ARGS (inst);
864 htab_remove_elt (type_specializations, &elt);
867 elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
869 slot = (spec_entry **)
870 htab_find_slot (type_specializations, &elt, INSERT);
871 *slot = GGC_NEW (spec_entry);
874 else if (COMPLETE_TYPE_P (inst) || TYPE_BEING_DEFINED (inst))
875 /* But if we've had an implicit instantiation, that's a
876 problem ([temp.expl.spec]/6). */
877 error ("specialization %qT after instantiation %qT",
881 /* Mark TYPE as a specialization. And as a result, we only
882 have one level of template argument for the innermost
884 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
885 CLASSTYPE_TI_ARGS (type)
886 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
889 else if (processing_specialization)
891 error ("explicit specialization of non-template %qT", type);
892 return error_mark_node;
898 /* Returns nonzero if we can optimize the retrieval of specializations
899 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
900 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
903 optimize_specialization_lookup_p (tree tmpl)
905 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
906 && DECL_CLASS_SCOPE_P (tmpl)
907 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
909 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
910 /* The optimized lookup depends on the fact that the
911 template arguments for the member function template apply
912 purely to the containing class, which is not true if the
913 containing class is an explicit or partial
915 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
916 && !DECL_MEMBER_TEMPLATE_P (tmpl)
917 && !DECL_CONV_FN_P (tmpl)
918 /* It is possible to have a template that is not a member
919 template and is not a member of a template class:
921 template <typename T>
922 struct S { friend A::f(); };
924 Here, the friend function is a template, but the context does
925 not have template information. The optimized lookup relies
926 on having ARGS be the template arguments for both the class
927 and the function template. */
928 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
931 /* Retrieve the specialization (in the sense of [temp.spec] - a
932 specialization is either an instantiation or an explicit
933 specialization) of TMPL for the given template ARGS. If there is
934 no such specialization, return NULL_TREE. The ARGS are a vector of
935 arguments, or a vector of vectors of arguments, in the case of
936 templates with more than one level of parameters.
938 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
939 then we search for a partial specialization matching ARGS. This
940 parameter is ignored if TMPL is not a class template. */
943 retrieve_specialization (tree tmpl, tree args, hashval_t hash)
945 if (args == error_mark_node)
948 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
950 /* There should be as many levels of arguments as there are
951 levels of parameters. */
952 gcc_assert (TMPL_ARGS_DEPTH (args)
953 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
955 if (optimize_specialization_lookup_p (tmpl))
958 tree class_specialization;
959 VEC(tree,gc) *methods;
963 /* The template arguments actually apply to the containing
964 class. Find the class specialization with those
966 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
968 = retrieve_specialization (class_template, args, 0);
969 if (!class_specialization)
971 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
972 for the specialization. */
973 idx = class_method_index_for_fn (class_specialization, tmpl);
976 /* Iterate through the methods with the indicated name, looking
977 for the one that has an instance of TMPL. */
978 methods = CLASSTYPE_METHOD_VEC (class_specialization);
979 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
981 tree fn = OVL_CURRENT (fns);
982 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl
983 /* using-declarations can add base methods to the method vec,
984 and we don't want those here. */
985 && DECL_CONTEXT (fn) == class_specialization)
994 htab_t specializations;
998 elt.spec = NULL_TREE;
1000 if (DECL_CLASS_TEMPLATE_P (tmpl))
1001 specializations = type_specializations;
1003 specializations = decl_specializations;
1006 hash = hash_specialization (&elt);
1007 found = (spec_entry *) htab_find_with_hash (specializations, &elt, hash);
1015 /* Like retrieve_specialization, but for local declarations. */
1018 retrieve_local_specialization (tree tmpl)
1022 if (local_specializations == NULL)
1025 spec = (tree) htab_find_with_hash (local_specializations, tmpl,
1026 htab_hash_pointer (tmpl));
1027 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
1030 /* Returns nonzero iff DECL is a specialization of TMPL. */
1033 is_specialization_of (tree decl, tree tmpl)
1037 if (TREE_CODE (decl) == FUNCTION_DECL)
1041 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1047 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1049 for (t = TREE_TYPE (decl);
1051 t = CLASSTYPE_USE_TEMPLATE (t)
1052 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1053 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1060 /* Returns nonzero iff DECL is a specialization of friend declaration
1061 FRIEND_DECL according to [temp.friend]. */
1064 is_specialization_of_friend (tree decl, tree friend_decl)
1066 bool need_template = true;
1069 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1070 || TREE_CODE (decl) == TYPE_DECL);
1072 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1073 of a template class, we want to check if DECL is a specialization
1075 if (TREE_CODE (friend_decl) == FUNCTION_DECL
1076 && DECL_TEMPLATE_INFO (friend_decl)
1077 && !DECL_USE_TEMPLATE (friend_decl))
1079 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1080 friend_decl = DECL_TI_TEMPLATE (friend_decl);
1081 need_template = false;
1083 else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1084 && !PRIMARY_TEMPLATE_P (friend_decl))
1085 need_template = false;
1087 /* There is nothing to do if this is not a template friend. */
1088 if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1091 if (is_specialization_of (decl, friend_decl))
1095 A member of a class template may be declared to be a friend of a
1096 non-template class. In this case, the corresponding member of
1097 every specialization of the class template is a friend of the
1098 class granting friendship.
1100 For example, given a template friend declaration
1102 template <class T> friend void A<T>::f();
1104 the member function below is considered a friend
1106 template <> struct A<int> {
1110 For this type of template friend, TEMPLATE_DEPTH below will be
1111 nonzero. To determine if DECL is a friend of FRIEND, we first
1112 check if the enclosing class is a specialization of another. */
1114 template_depth = template_class_depth (DECL_CONTEXT (friend_decl));
1116 && DECL_CLASS_SCOPE_P (decl)
1117 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1118 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1120 /* Next, we check the members themselves. In order to handle
1121 a few tricky cases, such as when FRIEND_DECL's are
1123 template <class T> friend void A<T>::g(T t);
1124 template <class T> template <T t> friend void A<T>::h();
1128 void A<int>::g(int);
1129 template <int> void A<int>::h();
1131 we need to figure out ARGS, the template arguments from
1132 the context of DECL. This is required for template substitution
1133 of `T' in the function parameter of `g' and template parameter
1134 of `h' in the above examples. Here ARGS corresponds to `int'. */
1136 tree context = DECL_CONTEXT (decl);
1137 tree args = NULL_TREE;
1138 int current_depth = 0;
1140 while (current_depth < template_depth)
1142 if (CLASSTYPE_TEMPLATE_INFO (context))
1144 if (current_depth == 0)
1145 args = TYPE_TI_ARGS (context);
1147 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1150 context = TYPE_CONTEXT (context);
1153 if (TREE_CODE (decl) == FUNCTION_DECL)
1158 tree friend_args_type;
1159 tree decl_args_type;
1161 /* Make sure that both DECL and FRIEND_DECL are templates or
1163 is_template = DECL_TEMPLATE_INFO (decl)
1164 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1165 if (need_template ^ is_template)
1167 else if (is_template)
1169 /* If both are templates, check template parameter list. */
1171 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1173 if (!comp_template_parms
1174 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1178 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1181 decl_type = TREE_TYPE (decl);
1183 friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1184 tf_none, NULL_TREE);
1185 if (friend_type == error_mark_node)
1188 /* Check if return types match. */
1189 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1192 /* Check if function parameter types match, ignoring the
1193 `this' parameter. */
1194 friend_args_type = TYPE_ARG_TYPES (friend_type);
1195 decl_args_type = TYPE_ARG_TYPES (decl_type);
1196 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1197 friend_args_type = TREE_CHAIN (friend_args_type);
1198 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1199 decl_args_type = TREE_CHAIN (decl_args_type);
1201 return compparms (decl_args_type, friend_args_type);
1205 /* DECL is a TYPE_DECL */
1207 tree decl_type = TREE_TYPE (decl);
1209 /* Make sure that both DECL and FRIEND_DECL are templates or
1212 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1213 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1215 if (need_template ^ is_template)
1217 else if (is_template)
1220 /* If both are templates, check the name of the two
1221 TEMPLATE_DECL's first because is_friend didn't. */
1222 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1223 != DECL_NAME (friend_decl))
1226 /* Now check template parameter list. */
1228 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1230 return comp_template_parms
1231 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1235 return (DECL_NAME (decl)
1236 == DECL_NAME (friend_decl));
1242 /* Register the specialization SPEC as a specialization of TMPL with
1243 the indicated ARGS. IS_FRIEND indicates whether the specialization
1244 is actually just a friend declaration. Returns SPEC, or an
1245 equivalent prior declaration, if available. */
1248 register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1252 spec_entry **slot = NULL;
1255 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec));
1257 if (TREE_CODE (spec) == FUNCTION_DECL
1258 && uses_template_parms (DECL_TI_ARGS (spec)))
1259 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1260 register it; we want the corresponding TEMPLATE_DECL instead.
1261 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1262 the more obvious `uses_template_parms (spec)' to avoid problems
1263 with default function arguments. In particular, given
1264 something like this:
1266 template <class T> void f(T t1, T t = T())
1268 the default argument expression is not substituted for in an
1269 instantiation unless and until it is actually needed. */
1272 if (optimize_specialization_lookup_p (tmpl))
1273 /* We don't put these specializations in the hash table, but we might
1274 want to give an error about a mismatch. */
1275 fn = retrieve_specialization (tmpl, args, 0);
1283 hash = hash_specialization (&elt);
1285 slot = (spec_entry **)
1286 htab_find_slot_with_hash (decl_specializations, &elt, hash, INSERT);
1293 /* We can sometimes try to re-register a specialization that we've
1294 already got. In particular, regenerate_decl_from_template calls
1295 duplicate_decls which will update the specialization list. But,
1296 we'll still get called again here anyhow. It's more convenient
1297 to simply allow this than to try to prevent it. */
1300 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1302 if (DECL_TEMPLATE_INSTANTIATION (fn))
1304 if (DECL_ODR_USED (fn)
1305 || DECL_EXPLICIT_INSTANTIATION (fn))
1307 error ("specialization of %qD after instantiation",
1309 return error_mark_node;
1314 /* This situation should occur only if the first
1315 specialization is an implicit instantiation, the
1316 second is an explicit specialization, and the
1317 implicit instantiation has not yet been used. That
1318 situation can occur if we have implicitly
1319 instantiated a member function and then specialized
1322 We can also wind up here if a friend declaration that
1323 looked like an instantiation turns out to be a
1326 template <class T> void foo(T);
1327 class S { friend void foo<>(int) };
1328 template <> void foo(int);
1330 We transform the existing DECL in place so that any
1331 pointers to it become pointers to the updated
1334 If there was a definition for the template, but not
1335 for the specialization, we want this to look as if
1336 there were no definition, and vice versa. */
1337 DECL_INITIAL (fn) = NULL_TREE;
1338 duplicate_decls (spec, fn, is_friend);
1339 /* The call to duplicate_decls will have applied
1342 An explicit specialization of a function template
1343 is inline only if it is explicitly declared to be,
1344 and independently of whether its function template
1347 to the primary function; now copy the inline bits to
1348 the various clones. */
1349 FOR_EACH_CLONE (clone, fn)
1351 DECL_DECLARED_INLINE_P (clone)
1352 = DECL_DECLARED_INLINE_P (fn);
1353 DECL_SOURCE_LOCATION (clone)
1354 = DECL_SOURCE_LOCATION (fn);
1356 check_specialization_namespace (fn);
1361 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1363 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1364 /* Dup decl failed, but this is a new definition. Set the
1365 line number so any errors match this new
1367 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1373 return duplicate_decls (spec, fn, is_friend);
1375 /* A specialization must be declared in the same namespace as the
1376 template it is specializing. */
1377 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1378 && !check_specialization_namespace (tmpl))
1379 DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1381 if (!optimize_specialization_lookup_p (tmpl))
1383 gcc_assert (tmpl && args && spec);
1384 *slot = GGC_NEW (spec_entry);
1386 if (TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1387 && PRIMARY_TEMPLATE_P (tmpl)
1388 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1389 /* TMPL is a forward declaration of a template function; keep a list
1390 of all specializations in case we need to reassign them to a friend
1391 template later in tsubst_friend_function. */
1392 DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1393 = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1399 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1400 TMPL and ARGS members, ignores SPEC. */
1403 eq_specializations (const void *p1, const void *p2)
1405 const spec_entry *e1 = (const spec_entry *)p1;
1406 const spec_entry *e2 = (const spec_entry *)p2;
1408 return (e1->tmpl == e2->tmpl
1409 && comp_template_args (e1->args, e2->args));
1412 /* Returns a hash for a template TMPL and template arguments ARGS. */
1415 hash_tmpl_and_args (tree tmpl, tree args)
1417 hashval_t val = DECL_UID (tmpl);
1418 return iterative_hash_template_arg (args, val);
1421 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1425 hash_specialization (const void *p)
1427 const spec_entry *e = (const spec_entry *)p;
1428 return hash_tmpl_and_args (e->tmpl, e->args);
1431 /* Recursively calculate a hash value for a template argument ARG, for use
1432 in the hash tables of template specializations. */
1435 iterative_hash_template_arg (tree arg, hashval_t val)
1437 unsigned HOST_WIDE_INT i;
1438 enum tree_code code;
1441 if (arg == NULL_TREE)
1442 return iterative_hash_object (arg, val);
1447 code = TREE_CODE (arg);
1448 tclass = TREE_CODE_CLASS (code);
1450 val = iterative_hash_object (code, val);
1457 case IDENTIFIER_NODE:
1458 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1462 int i, len = TREE_VEC_LENGTH (arg);
1463 for (i = 0; i < len; ++i)
1464 val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
1468 case TYPE_PACK_EXPANSION:
1469 case EXPR_PACK_EXPANSION:
1470 return iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1472 case ARGUMENT_PACK_SELECT:
1473 /* We can get one of these when re-hashing a previous entry in the middle
1474 of substituting into a pack expansion. Just look through it... */
1475 arg = ARGUMENT_PACK_SELECT_FROM_PACK (arg);
1476 /* ...and fall through. */
1477 case TYPE_ARGUMENT_PACK:
1478 case NONTYPE_ARGUMENT_PACK:
1479 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1482 for (; arg; arg = TREE_CHAIN (arg))
1483 val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1487 for (; arg; arg = OVL_CHAIN (arg))
1488 val = iterative_hash_template_arg (OVL_FUNCTION (arg), val);
1494 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
1496 val = iterative_hash_template_arg (field, val);
1497 val = iterative_hash_template_arg (value, val);
1503 if (!DECL_ARTIFICIAL (arg))
1504 val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1505 return iterative_hash_template_arg (TREE_TYPE (arg), val);
1508 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1511 val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1512 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1514 case TEMPLATE_PARM_INDEX:
1515 val = iterative_hash_template_arg
1516 (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1517 val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1518 return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1521 val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1522 val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1523 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1526 val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1528 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1532 val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1533 code = TREE_CODE (TREE_OPERAND (arg, 1));
1534 val = iterative_hash_object (code, val);
1535 return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1541 if (TYPE_CANONICAL (arg))
1542 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
1544 else if (TREE_CODE (arg) == DECLTYPE_TYPE)
1545 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1546 /* Otherwise just compare the types during lookup. */
1549 case tcc_declaration:
1551 return iterative_hash_expr (arg, val);
1554 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1556 unsigned n = TREE_OPERAND_LENGTH (arg);
1557 for (i = 0; i < n; ++i)
1558 val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1567 /* Unregister the specialization SPEC as a specialization of TMPL.
1568 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1569 if the SPEC was listed as a specialization of TMPL.
1571 Note that SPEC has been ggc_freed, so we can't look inside it. */
1574 reregister_specialization (tree spec, tree tinfo, tree new_spec)
1579 elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1580 elt.args = TI_ARGS (tinfo);
1581 elt.spec = NULL_TREE;
1583 slot = (spec_entry **) htab_find_slot (decl_specializations, &elt, INSERT);
1586 gcc_assert ((*slot)->spec == spec || (*slot)->spec == new_spec);
1587 gcc_assert (new_spec != NULL_TREE);
1588 (*slot)->spec = new_spec;
1595 /* Compare an entry in the local specializations hash table P1 (which
1596 is really a pointer to a TREE_LIST) with P2 (which is really a
1600 eq_local_specializations (const void *p1, const void *p2)
1602 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1605 /* Hash P1, an entry in the local specializations table. */
1608 hash_local_specialization (const void* p1)
1610 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1613 /* Like register_specialization, but for local declarations. We are
1614 registering SPEC, an instantiation of TMPL. */
1617 register_local_specialization (tree spec, tree tmpl)
1621 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1622 htab_hash_pointer (tmpl), INSERT);
1623 *slot = build_tree_list (spec, tmpl);
1626 /* TYPE is a class type. Returns true if TYPE is an explicitly
1627 specialized class. */
1630 explicit_class_specialization_p (tree type)
1632 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1634 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1637 /* Print the list of candidate FNS in an error message. */
1640 print_candidates (tree fns)
1645 const char *str = "candidates are:";
1647 if (is_overloaded_fn (fns))
1649 for (f = fns; f; f = OVL_NEXT (f))
1651 error ("%s %+#D", str, OVL_CURRENT (f));
1655 else for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1657 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1658 error ("%s %+#D", str, OVL_CURRENT (f));
1663 /* Returns the template (one of the functions given by TEMPLATE_ID)
1664 which can be specialized to match the indicated DECL with the
1665 explicit template args given in TEMPLATE_ID. The DECL may be
1666 NULL_TREE if none is available. In that case, the functions in
1667 TEMPLATE_ID are non-members.
1669 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1670 specialization of a member template.
1672 The TEMPLATE_COUNT is the number of references to qualifying
1673 template classes that appeared in the name of the function. See
1674 check_explicit_specialization for a more accurate description.
1676 TSK indicates what kind of template declaration (if any) is being
1677 declared. TSK_TEMPLATE indicates that the declaration given by
1678 DECL, though a FUNCTION_DECL, has template parameters, and is
1679 therefore a template function.
1681 The template args (those explicitly specified and those deduced)
1682 are output in a newly created vector *TARGS_OUT.
1684 If it is impossible to determine the result, an error message is
1685 issued. The error_mark_node is returned to indicate failure. */
1688 determine_specialization (tree template_id,
1691 int need_member_template,
1697 tree explicit_targs;
1698 tree candidates = NULL_TREE;
1699 /* A TREE_LIST of templates of which DECL may be a specialization.
1700 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1701 corresponding TREE_PURPOSE is the set of template arguments that,
1702 when used to instantiate the template, would produce a function
1703 with the signature of DECL. */
1704 tree templates = NULL_TREE;
1706 struct cp_binding_level *b;
1708 *targs_out = NULL_TREE;
1710 if (template_id == error_mark_node || decl == error_mark_node)
1711 return error_mark_node;
1713 fns = TREE_OPERAND (template_id, 0);
1714 explicit_targs = TREE_OPERAND (template_id, 1);
1716 if (fns == error_mark_node)
1717 return error_mark_node;
1719 /* Check for baselinks. */
1720 if (BASELINK_P (fns))
1721 fns = BASELINK_FUNCTIONS (fns);
1723 if (!is_overloaded_fn (fns))
1725 error ("%qD is not a function template", fns);
1726 return error_mark_node;
1729 /* Count the number of template headers specified for this
1732 for (b = current_binding_level;
1733 b->kind == sk_template_parms;
1737 for (; fns; fns = OVL_NEXT (fns))
1739 tree fn = OVL_CURRENT (fns);
1741 if (TREE_CODE (fn) == TEMPLATE_DECL)
1743 tree decl_arg_types;
1746 /* In case of explicit specialization, we need to check if
1747 the number of template headers appearing in the specialization
1748 is correct. This is usually done in check_explicit_specialization,
1749 but the check done there cannot be exhaustive when specializing
1750 member functions. Consider the following code:
1752 template <> void A<int>::f(int);
1753 template <> template <> void A<int>::f(int);
1755 Assuming that A<int> is not itself an explicit specialization
1756 already, the first line specializes "f" which is a non-template
1757 member function, whilst the second line specializes "f" which
1758 is a template member function. So both lines are syntactically
1759 correct, and check_explicit_specialization does not reject
1762 Here, we can do better, as we are matching the specialization
1763 against the declarations. We count the number of template
1764 headers, and we check if they match TEMPLATE_COUNT + 1
1765 (TEMPLATE_COUNT is the number of qualifying template classes,
1766 plus there must be another header for the member template
1769 Notice that if header_count is zero, this is not a
1770 specialization but rather a template instantiation, so there
1771 is no check we can perform here. */
1772 if (header_count && header_count != template_count + 1)
1775 /* Check that the number of template arguments at the
1776 innermost level for DECL is the same as for FN. */
1777 if (current_binding_level->kind == sk_template_parms
1778 && !current_binding_level->explicit_spec_p
1779 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1780 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1781 (current_template_parms))))
1784 /* DECL might be a specialization of FN. */
1785 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1786 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1788 /* For a non-static member function, we need to make sure
1789 that the const qualification is the same. Since
1790 get_bindings does not try to merge the "this" parameter,
1791 we must do the comparison explicitly. */
1792 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1793 && !same_type_p (TREE_VALUE (fn_arg_types),
1794 TREE_VALUE (decl_arg_types)))
1797 /* Skip the "this" parameter and, for constructors of
1798 classes with virtual bases, the VTT parameter. A
1799 full specialization of a constructor will have a VTT
1800 parameter, but a template never will. */
1802 = skip_artificial_parms_for (decl, decl_arg_types);
1804 = skip_artificial_parms_for (fn, fn_arg_types);
1806 /* Check that the number of function parameters matches.
1808 template <class T> void f(int i = 0);
1809 template <> void f<int>();
1810 The specialization f<int> is invalid but is not caught
1811 by get_bindings below. */
1812 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1815 /* Function templates cannot be specializations; there are
1816 no partial specializations of functions. Therefore, if
1817 the type of DECL does not match FN, there is no
1819 if (tsk == tsk_template)
1821 if (compparms (fn_arg_types, decl_arg_types))
1822 candidates = tree_cons (NULL_TREE, fn, candidates);
1826 /* See whether this function might be a specialization of this
1828 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1831 /* We cannot deduce template arguments that when used to
1832 specialize TMPL will produce DECL. */
1835 /* Save this template, and the arguments deduced. */
1836 templates = tree_cons (targs, fn, templates);
1838 else if (need_member_template)
1839 /* FN is an ordinary member function, and we need a
1840 specialization of a member template. */
1842 else if (TREE_CODE (fn) != FUNCTION_DECL)
1843 /* We can get IDENTIFIER_NODEs here in certain erroneous
1846 else if (!DECL_FUNCTION_MEMBER_P (fn))
1847 /* This is just an ordinary non-member function. Nothing can
1848 be a specialization of that. */
1850 else if (DECL_ARTIFICIAL (fn))
1851 /* Cannot specialize functions that are created implicitly. */
1855 tree decl_arg_types;
1857 /* This is an ordinary member function. However, since
1858 we're here, we can assume it's enclosing class is a
1859 template class. For example,
1861 template <typename T> struct S { void f(); };
1862 template <> void S<int>::f() {}
1864 Here, S<int>::f is a non-template, but S<int> is a
1865 template class. If FN has the same type as DECL, we
1866 might be in business. */
1868 if (!DECL_TEMPLATE_INFO (fn))
1869 /* Its enclosing class is an explicit specialization
1870 of a template class. This is not a candidate. */
1873 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1874 TREE_TYPE (TREE_TYPE (fn))))
1875 /* The return types differ. */
1878 /* Adjust the type of DECL in case FN is a static member. */
1879 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1880 if (DECL_STATIC_FUNCTION_P (fn)
1881 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1882 decl_arg_types = TREE_CHAIN (decl_arg_types);
1884 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1887 candidates = tree_cons (NULL_TREE, fn, candidates);
1891 if (templates && TREE_CHAIN (templates))
1897 It is possible for a specialization with a given function
1898 signature to be instantiated from more than one function
1899 template. In such cases, explicit specification of the
1900 template arguments must be used to uniquely identify the
1901 function template specialization being specialized.
1903 Note that here, there's no suggestion that we're supposed to
1904 determine which of the candidate templates is most
1905 specialized. However, we, also have:
1909 Partial ordering of overloaded function template
1910 declarations is used in the following contexts to select
1911 the function template to which a function template
1912 specialization refers:
1914 -- when an explicit specialization refers to a function
1917 So, we do use the partial ordering rules, at least for now.
1918 This extension can only serve to make invalid programs valid,
1919 so it's safe. And, there is strong anecdotal evidence that
1920 the committee intended the partial ordering rules to apply;
1921 the EDG front end has that behavior, and John Spicer claims
1922 that the committee simply forgot to delete the wording in
1923 [temp.expl.spec]. */
1924 tree tmpl = most_specialized_instantiation (templates);
1925 if (tmpl != error_mark_node)
1928 TREE_CHAIN (templates) = NULL_TREE;
1932 if (templates == NULL_TREE && candidates == NULL_TREE)
1934 error ("template-id %qD for %q+D does not match any template "
1935 "declaration", template_id, decl);
1936 return error_mark_node;
1938 else if ((templates && TREE_CHAIN (templates))
1939 || (candidates && TREE_CHAIN (candidates))
1940 || (templates && candidates))
1942 error ("ambiguous template specialization %qD for %q+D",
1944 chainon (candidates, templates);
1945 print_candidates (candidates);
1946 return error_mark_node;
1949 /* We have one, and exactly one, match. */
1952 tree fn = TREE_VALUE (candidates);
1953 *targs_out = copy_node (DECL_TI_ARGS (fn));
1954 /* DECL is a re-declaration or partial instantiation of a template
1956 if (TREE_CODE (fn) == TEMPLATE_DECL)
1958 /* It was a specialization of an ordinary member function in a
1960 return DECL_TI_TEMPLATE (fn);
1963 /* It was a specialization of a template. */
1964 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1965 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1967 *targs_out = copy_node (targs);
1968 SET_TMPL_ARGS_LEVEL (*targs_out,
1969 TMPL_ARGS_DEPTH (*targs_out),
1970 TREE_PURPOSE (templates));
1973 *targs_out = TREE_PURPOSE (templates);
1974 return TREE_VALUE (templates);
1977 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1978 but with the default argument values filled in from those in the
1982 copy_default_args_to_explicit_spec_1 (tree spec_types,
1985 tree new_spec_types;
1990 if (spec_types == void_list_node)
1991 return void_list_node;
1993 /* Substitute into the rest of the list. */
1995 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1996 TREE_CHAIN (tmpl_types));
1998 /* Add the default argument for this parameter. */
1999 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2000 TREE_VALUE (spec_types),
2004 /* DECL is an explicit specialization. Replicate default arguments
2005 from the template it specializes. (That way, code like:
2007 template <class T> void f(T = 3);
2008 template <> void f(double);
2011 works, as required.) An alternative approach would be to look up
2012 the correct default arguments at the call-site, but this approach
2013 is consistent with how implicit instantiations are handled. */
2016 copy_default_args_to_explicit_spec (tree decl)
2021 tree new_spec_types;
2025 tree object_type = NULL_TREE;
2026 tree in_charge = NULL_TREE;
2027 tree vtt = NULL_TREE;
2029 /* See if there's anything we need to do. */
2030 tmpl = DECL_TI_TEMPLATE (decl);
2031 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2032 for (t = tmpl_types; t; t = TREE_CHAIN (t))
2033 if (TREE_PURPOSE (t))
2038 old_type = TREE_TYPE (decl);
2039 spec_types = TYPE_ARG_TYPES (old_type);
2041 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2043 /* Remove the this pointer, but remember the object's type for
2045 object_type = TREE_TYPE (TREE_VALUE (spec_types));
2046 spec_types = TREE_CHAIN (spec_types);
2047 tmpl_types = TREE_CHAIN (tmpl_types);
2049 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2051 /* DECL may contain more parameters than TMPL due to the extra
2052 in-charge parameter in constructors and destructors. */
2053 in_charge = spec_types;
2054 spec_types = TREE_CHAIN (spec_types);
2056 if (DECL_HAS_VTT_PARM_P (decl))
2059 spec_types = TREE_CHAIN (spec_types);
2063 /* Compute the merged default arguments. */
2065 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2067 /* Compute the new FUNCTION_TYPE. */
2071 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2076 /* Put the in-charge parameter back. */
2077 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2078 TREE_VALUE (in_charge),
2081 new_type = build_method_type_directly (object_type,
2082 TREE_TYPE (old_type),
2086 new_type = build_function_type (TREE_TYPE (old_type),
2088 new_type = cp_build_type_attribute_variant (new_type,
2089 TYPE_ATTRIBUTES (old_type));
2090 new_type = build_exception_variant (new_type,
2091 TYPE_RAISES_EXCEPTIONS (old_type));
2092 TREE_TYPE (decl) = new_type;
2095 /* Check to see if the function just declared, as indicated in
2096 DECLARATOR, and in DECL, is a specialization of a function
2097 template. We may also discover that the declaration is an explicit
2098 instantiation at this point.
2100 Returns DECL, or an equivalent declaration that should be used
2101 instead if all goes well. Issues an error message if something is
2102 amiss. Returns error_mark_node if the error is not easily
2105 FLAGS is a bitmask consisting of the following flags:
2107 2: The function has a definition.
2108 4: The function is a friend.
2110 The TEMPLATE_COUNT is the number of references to qualifying
2111 template classes that appeared in the name of the function. For
2114 template <class T> struct S { void f(); };
2117 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2118 classes are not counted in the TEMPLATE_COUNT, so that in
2120 template <class T> struct S {};
2121 template <> struct S<int> { void f(); }
2122 template <> void S<int>::f();
2124 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2125 invalid; there should be no template <>.)
2127 If the function is a specialization, it is marked as such via
2128 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2129 is set up correctly, and it is added to the list of specializations
2130 for that template. */
2133 check_explicit_specialization (tree declarator,
2138 int have_def = flags & 2;
2139 int is_friend = flags & 4;
2140 int specialization = 0;
2141 int explicit_instantiation = 0;
2142 int member_specialization = 0;
2143 tree ctype = DECL_CLASS_CONTEXT (decl);
2144 tree dname = DECL_NAME (decl);
2149 if (!processing_specialization)
2152 tsk = tsk_excessive_parms;
2155 tsk = current_tmpl_spec_kind (template_count);
2160 if (processing_specialization)
2163 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2165 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2168 /* This could be something like:
2170 template <class T> void f(T);
2171 class S { friend void f<>(int); } */
2175 /* This case handles bogus declarations like template <>
2176 template <class T> void f<int>(); */
2178 error ("template-id %qD in declaration of primary template",
2185 case tsk_invalid_member_spec:
2186 /* The error has already been reported in
2187 check_specialization_scope. */
2188 return error_mark_node;
2190 case tsk_invalid_expl_inst:
2191 error ("template parameter list used in explicit instantiation");
2197 error ("definition provided for explicit instantiation");
2199 explicit_instantiation = 1;
2202 case tsk_excessive_parms:
2203 case tsk_insufficient_parms:
2204 if (tsk == tsk_excessive_parms)
2205 error ("too many template parameter lists in declaration of %qD",
2207 else if (template_header_count)
2208 error("too few template parameter lists in declaration of %qD", decl);
2210 error("explicit specialization of %qD must be introduced by "
2211 "%<template <>%>", decl);
2215 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2217 member_specialization = 1;
2223 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2225 /* This case handles bogus declarations like template <>
2226 template <class T> void f<int>(); */
2228 if (uses_template_parms (declarator))
2229 error ("function template partial specialization %qD "
2230 "is not allowed", declarator);
2232 error ("template-id %qD in declaration of primary template",
2237 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2238 /* This is a specialization of a member template, without
2239 specialization the containing class. Something like:
2241 template <class T> struct S {
2242 template <class U> void f (U);
2244 template <> template <class U> void S<int>::f(U) {}
2246 That's a specialization -- but of the entire template. */
2254 if (specialization || member_specialization)
2256 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2257 for (; t; t = TREE_CHAIN (t))
2258 if (TREE_PURPOSE (t))
2260 permerror (input_location,
2261 "default argument specified in explicit specialization");
2266 if (specialization || member_specialization || explicit_instantiation)
2268 tree tmpl = NULL_TREE;
2269 tree targs = NULL_TREE;
2271 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2272 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2276 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2281 /* If there is no class context, the explicit instantiation
2282 must be at namespace scope. */
2283 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2285 /* Find the namespace binding, using the declaration
2287 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2289 if (fns == error_mark_node || !is_overloaded_fn (fns))
2291 error ("%qD is not a template function", dname);
2292 fns = error_mark_node;
2296 tree fn = OVL_CURRENT (fns);
2297 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2298 CP_DECL_CONTEXT (fn)))
2299 error ("%qD is not declared in %qD",
2300 decl, current_namespace);
2304 declarator = lookup_template_function (fns, NULL_TREE);
2307 if (declarator == error_mark_node)
2308 return error_mark_node;
2310 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2312 if (!explicit_instantiation)
2313 /* A specialization in class scope. This is invalid,
2314 but the error will already have been flagged by
2315 check_specialization_scope. */
2316 return error_mark_node;
2319 /* It's not valid to write an explicit instantiation in
2322 class C { template void f(); }
2324 This case is caught by the parser. However, on
2327 template class C { void f(); };
2329 (which is invalid) we can get here. The error will be
2336 else if (ctype != NULL_TREE
2337 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2340 /* Find the list of functions in ctype that have the same
2341 name as the declared function. */
2342 tree name = TREE_OPERAND (declarator, 0);
2343 tree fns = NULL_TREE;
2346 if (constructor_name_p (name, ctype))
2348 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2350 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2351 : !CLASSTYPE_DESTRUCTORS (ctype))
2353 /* From [temp.expl.spec]:
2355 If such an explicit specialization for the member
2356 of a class template names an implicitly-declared
2357 special member function (clause _special_), the
2358 program is ill-formed.
2360 Similar language is found in [temp.explicit]. */
2361 error ("specialization of implicitly-declared special member function");
2362 return error_mark_node;
2365 name = is_constructor ? ctor_identifier : dtor_identifier;
2368 if (!DECL_CONV_FN_P (decl))
2370 idx = lookup_fnfields_1 (ctype, name);
2372 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2376 VEC(tree,gc) *methods;
2379 /* For a type-conversion operator, we cannot do a
2380 name-based lookup. We might be looking for `operator
2381 int' which will be a specialization of `operator T'.
2382 So, we find *all* the conversion operators, and then
2383 select from them. */
2386 methods = CLASSTYPE_METHOD_VEC (ctype);
2388 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2389 VEC_iterate (tree, methods, idx, ovl);
2392 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2393 /* There are no more conversion functions. */
2396 /* Glue all these conversion functions together
2397 with those we already have. */
2398 for (; ovl; ovl = OVL_NEXT (ovl))
2399 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2403 if (fns == NULL_TREE)
2405 error ("no member function %qD declared in %qT", name, ctype);
2406 return error_mark_node;
2409 TREE_OPERAND (declarator, 0) = fns;
2412 /* Figure out what exactly is being specialized at this point.
2413 Note that for an explicit instantiation, even one for a
2414 member function, we cannot tell apriori whether the
2415 instantiation is for a member template, or just a member
2416 function of a template class. Even if a member template is
2417 being instantiated, the member template arguments may be
2418 elided if they can be deduced from the rest of the
2420 tmpl = determine_specialization (declarator, decl,
2422 member_specialization,
2426 if (!tmpl || tmpl == error_mark_node)
2427 /* We couldn't figure out what this declaration was
2429 return error_mark_node;
2432 tree gen_tmpl = most_general_template (tmpl);
2434 if (explicit_instantiation)
2436 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2437 is done by do_decl_instantiation later. */
2439 int arg_depth = TMPL_ARGS_DEPTH (targs);
2440 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2442 if (arg_depth > parm_depth)
2444 /* If TMPL is not the most general template (for
2445 example, if TMPL is a friend template that is
2446 injected into namespace scope), then there will
2447 be too many levels of TARGS. Remove some of them
2452 new_targs = make_tree_vec (parm_depth);
2453 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2454 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2455 = TREE_VEC_ELT (targs, i);
2459 return instantiate_template (tmpl, targs, tf_error);
2462 /* If we thought that the DECL was a member function, but it
2463 turns out to be specializing a static member function,
2464 make DECL a static member function as well. */
2465 if (DECL_STATIC_FUNCTION_P (tmpl)
2466 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2467 revert_static_member_fn (decl);
2469 /* If this is a specialization of a member template of a
2470 template class, we want to return the TEMPLATE_DECL, not
2471 the specialization of it. */
2472 if (tsk == tsk_template)
2474 tree result = DECL_TEMPLATE_RESULT (tmpl);
2475 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2476 DECL_INITIAL (result) = NULL_TREE;
2480 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2481 DECL_SOURCE_LOCATION (result)
2482 = DECL_SOURCE_LOCATION (decl);
2483 /* We want to use the argument list specified in the
2484 definition, not in the original declaration. */
2485 DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
2486 for (parm = DECL_ARGUMENTS (result); parm;
2487 parm = TREE_CHAIN (parm))
2488 DECL_CONTEXT (parm) = result;
2490 return register_specialization (tmpl, gen_tmpl, targs,
2494 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2495 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2497 /* Inherit default function arguments from the template
2498 DECL is specializing. */
2499 copy_default_args_to_explicit_spec (decl);
2501 /* This specialization has the same protection as the
2502 template it specializes. */
2503 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2504 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2506 /* 7.1.1-1 [dcl.stc]
2508 A storage-class-specifier shall not be specified in an
2509 explicit specialization...
2511 The parser rejects these, so unless action is taken here,
2512 explicit function specializations will always appear with
2515 The action recommended by the C++ CWG in response to C++
2516 defect report 605 is to make the storage class and linkage
2517 of the explicit specialization match the templated function:
2519 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2521 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2523 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2524 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2526 /* This specialization has the same linkage and visibility as
2527 the function template it specializes. */
2528 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2529 if (! TREE_PUBLIC (decl))
2531 DECL_INTERFACE_KNOWN (decl) = 1;
2532 DECL_NOT_REALLY_EXTERN (decl) = 1;
2534 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2535 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2537 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2538 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2542 /* If DECL is a friend declaration, declared using an
2543 unqualified name, the namespace associated with DECL may
2544 have been set incorrectly. For example, in:
2546 template <typename T> void f(T);
2548 struct S { friend void f<int>(int); }
2551 we will have set the DECL_CONTEXT for the friend
2552 declaration to N, rather than to the global namespace. */
2553 if (DECL_NAMESPACE_SCOPE_P (decl))
2554 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2556 if (is_friend && !have_def)
2557 /* This is not really a declaration of a specialization.
2558 It's just the name of an instantiation. But, it's not
2559 a request for an instantiation, either. */
2560 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2561 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2562 /* This is indeed a specialization. In case of constructors
2563 and destructors, we need in-charge and not-in-charge
2564 versions in V3 ABI. */
2565 clone_function_decl (decl, /*update_method_vec_p=*/0);
2567 /* Register this specialization so that we can find it
2569 decl = register_specialization (decl, gen_tmpl, targs, is_friend, 0);
2576 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2577 parameters. These are represented in the same format used for
2578 DECL_TEMPLATE_PARMS. */
2581 comp_template_parms (const_tree parms1, const_tree parms2)
2586 if (parms1 == parms2)
2589 for (p1 = parms1, p2 = parms2;
2590 p1 != NULL_TREE && p2 != NULL_TREE;
2591 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2593 tree t1 = TREE_VALUE (p1);
2594 tree t2 = TREE_VALUE (p2);
2597 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2598 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2600 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2603 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2605 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2606 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2608 /* If either of the template parameters are invalid, assume
2609 they match for the sake of error recovery. */
2610 if (parm1 == error_mark_node || parm2 == error_mark_node)
2613 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2616 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2617 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2618 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2620 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2625 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2626 /* One set of parameters has more parameters lists than the
2633 /* Determine whether PARM is a parameter pack. */
2636 template_parameter_pack_p (const_tree parm)
2638 /* Determine if we have a non-type template parameter pack. */
2639 if (TREE_CODE (parm) == PARM_DECL)
2640 return (DECL_TEMPLATE_PARM_P (parm)
2641 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2643 /* If this is a list of template parameters, we could get a
2644 TYPE_DECL or a TEMPLATE_DECL. */
2645 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2646 parm = TREE_TYPE (parm);
2648 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2649 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2650 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2653 /* Determine if T is a function parameter pack. */
2656 function_parameter_pack_p (const_tree t)
2658 if (t && TREE_CODE (t) == PARM_DECL)
2659 return FUNCTION_PARAMETER_PACK_P (t);
2663 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2664 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2667 get_function_template_decl (const_tree primary_func_tmpl_inst)
2669 if (! primary_func_tmpl_inst
2670 || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
2671 || ! primary_template_instantiation_p (primary_func_tmpl_inst))
2674 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
2677 /* Return true iff the function parameter PARAM_DECL was expanded
2678 from the function parameter pack PACK. */
2681 function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
2683 if (DECL_ARTIFICIAL (param_decl)
2684 || !function_parameter_pack_p (pack))
2687 gcc_assert (DECL_NAME (param_decl) && DECL_NAME (pack));
2689 /* The parameter pack and its pack arguments have the same
2691 return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
2694 /* Determine whether ARGS describes a variadic template args list,
2695 i.e., one that is terminated by a template argument pack. */
2698 template_args_variadic_p (tree args)
2703 if (args == NULL_TREE)
2706 args = INNERMOST_TEMPLATE_ARGS (args);
2707 nargs = TREE_VEC_LENGTH (args);
2712 last_parm = TREE_VEC_ELT (args, nargs - 1);
2714 return ARGUMENT_PACK_P (last_parm);
2717 /* Generate a new name for the parameter pack name NAME (an
2718 IDENTIFIER_NODE) that incorporates its */
2721 make_ith_pack_parameter_name (tree name, int i)
2723 /* Munge the name to include the parameter index. */
2724 #define NUMBUF_LEN 128
2725 char numbuf[NUMBUF_LEN];
2729 snprintf (numbuf, NUMBUF_LEN, "%i", i);
2730 newname_len = IDENTIFIER_LENGTH (name)
2731 + strlen (numbuf) + 2;
2732 newname = (char*)alloca (newname_len);
2733 snprintf (newname, newname_len,
2734 "%s#%i", IDENTIFIER_POINTER (name), i);
2735 return get_identifier (newname);
2738 /* Return true if T is a primary function
2739 or class template instantiation. */
2742 primary_template_instantiation_p (const_tree t)
2747 if (TREE_CODE (t) == FUNCTION_DECL)
2748 return DECL_LANG_SPECIFIC (t)
2749 && DECL_TEMPLATE_INSTANTIATION (t)
2750 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t));
2751 else if (CLASS_TYPE_P (t))
2752 return CLASSTYPE_TEMPLATE_INSTANTIATION (t)
2753 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t));
2757 /* Return true if PARM is a template template parameter. */
2760 template_template_parameter_p (const_tree parm)
2762 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
2765 /* Return the template parameters of T if T is a
2766 primary template instantiation, NULL otherwise. */
2769 get_primary_template_innermost_parameters (const_tree t)
2771 tree parms = NULL, template_info = NULL;
2773 if ((template_info = get_template_info (t))
2774 && primary_template_instantiation_p (t))
2775 parms = INNERMOST_TEMPLATE_PARMS
2776 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
2781 /* Returns the template arguments of T if T is a template instantiation,
2785 get_template_innermost_arguments (const_tree t)
2787 tree args = NULL, template_info = NULL;
2789 if ((template_info = get_template_info (t))
2790 && TI_ARGS (template_info))
2791 args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
2796 /* Return the argument pack elements of T if T is a template argument pack,
2800 get_template_argument_pack_elems (const_tree t)
2802 if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
2803 && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
2806 return ARGUMENT_PACK_ARGS (t);
2809 /* Structure used to track the progress of find_parameter_packs_r. */
2810 struct find_parameter_pack_data
2812 /* TREE_LIST that will contain all of the parameter packs found by
2814 tree* parameter_packs;
2816 /* Set of AST nodes that have been visited by the traversal. */
2817 struct pointer_set_t *visited;
2820 /* Identifies all of the argument packs that occur in a template
2821 argument and appends them to the TREE_LIST inside DATA, which is a
2822 find_parameter_pack_data structure. This is a subroutine of
2823 make_pack_expansion and uses_parameter_packs. */
2825 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2828 struct find_parameter_pack_data* ppd =
2829 (struct find_parameter_pack_data*)data;
2830 bool parameter_pack_p = false;
2832 /* Identify whether this is a parameter pack or not. */
2833 switch (TREE_CODE (t))
2835 case TEMPLATE_PARM_INDEX:
2836 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2837 parameter_pack_p = true;
2840 case TEMPLATE_TYPE_PARM:
2841 case TEMPLATE_TEMPLATE_PARM:
2842 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2843 parameter_pack_p = true;
2847 if (FUNCTION_PARAMETER_PACK_P (t))
2849 /* We don't want to walk into the type of a PARM_DECL,
2850 because we don't want to see the type parameter pack. */
2852 parameter_pack_p = true;
2857 /* Not a parameter pack. */
2861 if (parameter_pack_p)
2863 /* Add this parameter pack to the list. */
2864 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2868 cp_walk_tree (&TYPE_CONTEXT (t),
2869 &find_parameter_packs_r, ppd, ppd->visited);
2871 /* This switch statement will return immediately if we don't find a
2873 switch (TREE_CODE (t))
2875 case TEMPLATE_PARM_INDEX:
2878 case BOUND_TEMPLATE_TEMPLATE_PARM:
2879 /* Check the template itself. */
2880 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2881 &find_parameter_packs_r, ppd, ppd->visited);
2882 /* Check the template arguments. */
2883 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2888 case TEMPLATE_TYPE_PARM:
2889 case TEMPLATE_TEMPLATE_PARM:
2896 if (TYPE_PTRMEMFUNC_P (t))
2902 if (TYPE_TEMPLATE_INFO (t))
2903 cp_walk_tree (&TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
2904 &find_parameter_packs_r, ppd, ppd->visited);
2910 cp_walk_tree (&TREE_TYPE (t),
2911 &find_parameter_packs_r, ppd, ppd->visited);
2915 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
2920 case TYPE_PACK_EXPANSION:
2921 case EXPR_PACK_EXPANSION:
2926 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2931 case IDENTIFIER_NODE:
2932 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
2944 /* Determines if the expression or type T uses any parameter packs. */
2946 uses_parameter_packs (tree t)
2948 tree parameter_packs = NULL_TREE;
2949 struct find_parameter_pack_data ppd;
2950 ppd.parameter_packs = ¶meter_packs;
2951 ppd.visited = pointer_set_create ();
2952 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2953 pointer_set_destroy (ppd.visited);
2954 return parameter_packs != NULL_TREE;
2957 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2958 representation a base-class initializer into a parameter pack
2959 expansion. If all goes well, the resulting node will be an
2960 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2963 make_pack_expansion (tree arg)
2966 tree parameter_packs = NULL_TREE;
2967 bool for_types = false;
2968 struct find_parameter_pack_data ppd;
2970 if (!arg || arg == error_mark_node)
2973 if (TREE_CODE (arg) == TREE_LIST)
2975 /* The only time we will see a TREE_LIST here is for a base
2976 class initializer. In this case, the TREE_PURPOSE will be a
2977 _TYPE node (representing the base class expansion we're
2978 initializing) and the TREE_VALUE will be a TREE_LIST
2979 containing the initialization arguments.
2981 The resulting expansion looks somewhat different from most
2982 expansions. Rather than returning just one _EXPANSION, we
2983 return a TREE_LIST whose TREE_PURPOSE is a
2984 TYPE_PACK_EXPANSION containing the bases that will be
2985 initialized. The TREE_VALUE will be identical to the
2986 original TREE_VALUE, which is a list of arguments that will
2987 be passed to each base. We do not introduce any new pack
2988 expansion nodes into the TREE_VALUE (although it is possible
2989 that some already exist), because the TREE_PURPOSE and
2990 TREE_VALUE all need to be expanded together with the same
2991 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2992 resulting TREE_PURPOSE will mention the parameter packs in
2993 both the bases and the arguments to the bases. */
2996 tree parameter_packs = NULL_TREE;
2998 /* Determine which parameter packs will be used by the base
3000 ppd.visited = pointer_set_create ();
3001 ppd.parameter_packs = ¶meter_packs;
3002 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
3005 if (parameter_packs == NULL_TREE)
3007 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
3008 pointer_set_destroy (ppd.visited);
3009 return error_mark_node;
3012 if (TREE_VALUE (arg) != void_type_node)
3014 /* Collect the sets of parameter packs used in each of the
3015 initialization arguments. */
3016 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
3018 /* Determine which parameter packs will be expanded in this
3020 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
3025 pointer_set_destroy (ppd.visited);
3027 /* Create the pack expansion type for the base type. */
3028 purpose = cxx_make_type (TYPE_PACK_EXPANSION);
3029 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
3030 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
3032 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3033 they will rarely be compared to anything. */
3034 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
3036 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
3039 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
3042 /* Build the PACK_EXPANSION_* node. */
3044 ? cxx_make_type (TYPE_PACK_EXPANSION)
3045 : make_node (EXPR_PACK_EXPANSION);
3046 SET_PACK_EXPANSION_PATTERN (result, arg);
3047 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
3049 /* Propagate type and const-expression information. */
3050 TREE_TYPE (result) = TREE_TYPE (arg);
3051 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
3054 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3055 they will rarely be compared to anything. */
3056 SET_TYPE_STRUCTURAL_EQUALITY (result);
3058 /* Determine which parameter packs will be expanded. */
3059 ppd.parameter_packs = ¶meter_packs;
3060 ppd.visited = pointer_set_create ();
3061 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
3062 pointer_set_destroy (ppd.visited);
3064 /* Make sure we found some parameter packs. */
3065 if (parameter_packs == NULL_TREE)
3068 error ("expansion pattern %<%T%> contains no argument packs", arg);
3070 error ("expansion pattern %<%E%> contains no argument packs", arg);
3071 return error_mark_node;
3073 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
3078 /* Checks T for any "bare" parameter packs, which have not yet been
3079 expanded, and issues an error if any are found. This operation can
3080 only be done on full expressions or types (e.g., an expression
3081 statement, "if" condition, etc.), because we could have expressions like:
3083 foo(f(g(h(args)))...)
3085 where "args" is a parameter pack. check_for_bare_parameter_packs
3086 should not be called for the subexpressions args, h(args),
3087 g(h(args)), or f(g(h(args))), because we would produce erroneous
3090 Returns TRUE and emits an error if there were bare parameter packs,
3091 returns FALSE otherwise. */
3093 check_for_bare_parameter_packs (tree t)
3095 tree parameter_packs = NULL_TREE;
3096 struct find_parameter_pack_data ppd;
3098 if (!processing_template_decl || !t || t == error_mark_node)
3101 if (TREE_CODE (t) == TYPE_DECL)
3104 ppd.parameter_packs = ¶meter_packs;
3105 ppd.visited = pointer_set_create ();
3106 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3107 pointer_set_destroy (ppd.visited);
3109 if (parameter_packs)
3111 error ("parameter packs not expanded with %<...%>:");
3112 while (parameter_packs)
3114 tree pack = TREE_VALUE (parameter_packs);
3115 tree name = NULL_TREE;
3117 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
3118 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
3119 name = TYPE_NAME (pack);
3120 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
3121 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
3123 name = DECL_NAME (pack);
3126 inform (input_location, " %qD", name);
3128 inform (input_location, " <anonymous>");
3130 parameter_packs = TREE_CHAIN (parameter_packs);
3139 /* Expand any parameter packs that occur in the template arguments in
3142 expand_template_argument_pack (tree args)
3144 tree result_args = NULL_TREE;
3145 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
3146 int num_result_args = -1;
3148 /* First, determine if we need to expand anything, and the number of
3149 slots we'll need. */
3150 for (in_arg = 0; in_arg < nargs; ++in_arg)
3152 tree arg = TREE_VEC_ELT (args, in_arg);
3153 if (ARGUMENT_PACK_P (arg))
3155 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
3156 if (num_result_args < 0)
3157 num_result_args = in_arg + num_packed;
3159 num_result_args += num_packed;
3163 if (num_result_args >= 0)
3168 /* If no expansion is necessary, we're done. */
3169 if (num_result_args < 0)
3172 /* Expand arguments. */
3173 result_args = make_tree_vec (num_result_args);
3174 for (in_arg = 0; in_arg < nargs; ++in_arg)
3176 tree arg = TREE_VEC_ELT (args, in_arg);
3177 if (ARGUMENT_PACK_P (arg))
3179 tree packed = ARGUMENT_PACK_ARGS (arg);
3180 int i, num_packed = TREE_VEC_LENGTH (packed);
3181 for (i = 0; i < num_packed; ++i, ++out_arg)
3182 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
3186 TREE_VEC_ELT (result_args, out_arg) = arg;
3194 /* Checks if DECL shadows a template parameter.
3196 [temp.local]: A template-parameter shall not be redeclared within its
3197 scope (including nested scopes).
3199 Emits an error and returns TRUE if the DECL shadows a parameter,
3200 returns FALSE otherwise. */
3203 check_template_shadow (tree decl)
3207 /* If we're not in a template, we can't possibly shadow a template
3209 if (!current_template_parms)
3212 /* Figure out what we're shadowing. */
3213 if (TREE_CODE (decl) == OVERLOAD)
3214 decl = OVL_CURRENT (decl);
3215 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
3217 /* If there's no previous binding for this name, we're not shadowing
3218 anything, let alone a template parameter. */
3222 /* If we're not shadowing a template parameter, we're done. Note
3223 that OLDDECL might be an OVERLOAD (or perhaps even an
3224 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3226 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
3229 /* We check for decl != olddecl to avoid bogus errors for using a
3230 name inside a class. We check TPFI to avoid duplicate errors for
3231 inline member templates. */
3233 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
3236 error ("declaration of %q+#D", decl);
3237 error (" shadows template parm %q+#D", olddecl);
3241 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3242 ORIG_LEVEL, DECL, and TYPE. */
3245 build_template_parm_index (int index,
3251 tree t = make_node (TEMPLATE_PARM_INDEX);
3252 TEMPLATE_PARM_IDX (t) = index;
3253 TEMPLATE_PARM_LEVEL (t) = level;
3254 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
3255 TEMPLATE_PARM_DECL (t) = decl;
3256 TREE_TYPE (t) = type;
3257 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
3258 TREE_READONLY (t) = TREE_READONLY (decl);
3263 /* Find the canonical type parameter for the given template type
3264 parameter. Returns the canonical type parameter, which may be TYPE
3265 if no such parameter existed. */
3267 canonical_type_parameter (tree type)
3270 int idx = TEMPLATE_TYPE_IDX (type);
3271 if (!canonical_template_parms)
3272 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
3274 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
3275 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
3277 list = VEC_index (tree, canonical_template_parms, idx);
3278 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
3279 list = TREE_CHAIN (list);
3282 return TREE_VALUE (list);
3285 VEC_replace(tree, canonical_template_parms, idx,
3286 tree_cons (NULL_TREE, type,
3287 VEC_index (tree, canonical_template_parms, idx)));
3292 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3293 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3294 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3295 new one is created. */
3298 reduce_template_parm_level (tree index, tree type, int levels, tree args,
3299 tsubst_flags_t complain)
3301 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
3302 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
3303 != TEMPLATE_PARM_LEVEL (index) - levels))
3305 tree orig_decl = TEMPLATE_PARM_DECL (index);
3308 decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
3309 TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
3310 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
3311 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
3312 DECL_ARTIFICIAL (decl) = 1;
3313 SET_DECL_TEMPLATE_PARM_P (decl);
3315 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
3316 TEMPLATE_PARM_LEVEL (index) - levels,
3317 TEMPLATE_PARM_ORIG_LEVEL (index),
3319 TEMPLATE_PARM_DESCENDANTS (index) = t;
3320 TEMPLATE_PARM_PARAMETER_PACK (t)
3321 = TEMPLATE_PARM_PARAMETER_PACK (index);
3323 /* Template template parameters need this. */
3324 if (TREE_CODE (decl) == TEMPLATE_DECL)
3325 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
3326 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
3330 return TEMPLATE_PARM_DESCENDANTS (index);
3333 /* Process information from new template parameter PARM and append it to the
3334 LIST being built. This new parameter is a non-type parameter iff
3335 IS_NON_TYPE is true. This new parameter is a parameter
3336 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3340 process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_type,
3341 bool is_parameter_pack)
3348 gcc_assert (TREE_CODE (parm) == TREE_LIST);
3349 defval = TREE_PURPOSE (parm);
3353 tree p = tree_last (list);
3355 if (p && TREE_VALUE (p) != error_mark_node)
3358 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3359 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3361 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3371 parm = TREE_VALUE (parm);
3373 SET_DECL_TEMPLATE_PARM_P (parm);
3375 if (TREE_TYPE (parm) == error_mark_node)
3377 err_parm_list = build_tree_list (defval, parm);
3378 TREE_VALUE (err_parm_list) = error_mark_node;
3379 return chainon (list, err_parm_list);
3385 The top-level cv-qualifiers on the template-parameter are
3386 ignored when determining its type. */
3387 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3388 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3390 err_parm_list = build_tree_list (defval, parm);
3391 TREE_VALUE (err_parm_list) = error_mark_node;
3392 return chainon (list, err_parm_list);
3395 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3397 /* This template parameter is not a parameter pack, but it
3398 should be. Complain about "bare" parameter packs. */
3399 check_for_bare_parameter_packs (TREE_TYPE (parm));
3401 /* Recover by calling this a parameter pack. */
3402 is_parameter_pack = true;
3406 /* A template parameter is not modifiable. */
3407 TREE_CONSTANT (parm) = 1;
3408 TREE_READONLY (parm) = 1;
3409 decl = build_decl (parm_loc,
3410 CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3411 TREE_CONSTANT (decl) = 1;
3412 TREE_READONLY (decl) = 1;
3413 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3414 = build_template_parm_index (idx, processing_template_decl,
3415 processing_template_decl,
3416 decl, TREE_TYPE (parm));
3418 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3419 = is_parameter_pack;
3424 parm = TREE_VALUE (TREE_VALUE (parm));
3426 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3428 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3429 /* This is for distinguishing between real templates and template
3430 template parameters */
3431 TREE_TYPE (parm) = t;
3432 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3437 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3438 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3439 decl = build_decl (parm_loc,
3440 TYPE_DECL, parm, t);
3443 TYPE_NAME (t) = decl;
3444 TYPE_STUB_DECL (t) = decl;
3446 TEMPLATE_TYPE_PARM_INDEX (t)
3447 = build_template_parm_index (idx, processing_template_decl,
3448 processing_template_decl,
3449 decl, TREE_TYPE (parm));
3450 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3451 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3453 DECL_ARTIFICIAL (decl) = 1;
3454 SET_DECL_TEMPLATE_PARM_P (decl);
3456 parm = build_tree_list (defval, parm);
3457 return chainon (list, parm);
3460 /* The end of a template parameter list has been reached. Process the
3461 tree list into a parameter vector, converting each parameter into a more
3462 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3466 end_template_parm_list (tree parms)
3470 tree saved_parmlist = make_tree_vec (list_length (parms));
3472 current_template_parms
3473 = tree_cons (size_int (processing_template_decl),
3474 saved_parmlist, current_template_parms);
3476 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3478 next = TREE_CHAIN (parm);
3479 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3480 TREE_CHAIN (parm) = NULL_TREE;
3483 --processing_template_parmlist;
3485 return saved_parmlist;
3488 /* end_template_decl is called after a template declaration is seen. */
3491 end_template_decl (void)
3493 reset_specialization ();
3495 if (! processing_template_decl)
3498 /* This matches the pushlevel in begin_template_parm_list. */
3501 --processing_template_decl;
3502 current_template_parms = TREE_CHAIN (current_template_parms);
3505 /* Within the declaration of a template, return all levels of template
3506 parameters that apply. The template parameters are represented as
3507 a TREE_VEC, in the form documented in cp-tree.h for template
3511 current_template_args (void)
3514 tree args = NULL_TREE;
3515 int length = TMPL_PARMS_DEPTH (current_template_parms);
3518 /* If there is only one level of template parameters, we do not
3519 create a TREE_VEC of TREE_VECs. Instead, we return a single
3520 TREE_VEC containing the arguments. */
3522 args = make_tree_vec (length);
3524 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3526 tree a = copy_node (TREE_VALUE (header));
3529 TREE_TYPE (a) = NULL_TREE;
3530 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3532 tree t = TREE_VEC_ELT (a, i);
3534 /* T will be a list if we are called from within a
3535 begin/end_template_parm_list pair, but a vector directly
3536 if within a begin/end_member_template_processing pair. */
3537 if (TREE_CODE (t) == TREE_LIST)
3541 if (!error_operand_p (t))
3543 if (TREE_CODE (t) == TYPE_DECL
3544 || TREE_CODE (t) == TEMPLATE_DECL)
3548 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3550 /* Turn this argument into a TYPE_ARGUMENT_PACK
3551 with a single element, which expands T. */
3552 tree vec = make_tree_vec (1);
3553 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3555 t = cxx_make_type (TYPE_ARGUMENT_PACK);
3556 SET_ARGUMENT_PACK_ARGS (t, vec);
3561 t = DECL_INITIAL (t);
3563 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3565 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3566 with a single element, which expands T. */
3567 tree vec = make_tree_vec (1);
3568 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3569 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3571 t = make_node (NONTYPE_ARGUMENT_PACK);
3572 SET_ARGUMENT_PACK_ARGS (t, vec);
3573 TREE_TYPE (t) = type;
3576 TREE_VEC_ELT (a, i) = t;
3582 TREE_VEC_ELT (args, --l) = a;
3590 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3591 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3592 a member template. Used by push_template_decl below. */
3595 build_template_decl (tree decl, tree parms, bool member_template_p)
3597 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3598 DECL_TEMPLATE_PARMS (tmpl) = parms;
3599 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3600 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3605 struct template_parm_data
3607 /* The level of the template parameters we are currently
3611 /* The index of the specialization argument we are currently
3615 /* An array whose size is the number of template parameters. The
3616 elements are nonzero if the parameter has been used in any one
3617 of the arguments processed so far. */
3620 /* An array whose size is the number of template arguments. The
3621 elements are nonzero if the argument makes use of template
3622 parameters of this level. */
3623 int* arg_uses_template_parms;
3626 /* Subroutine of push_template_decl used to see if each template
3627 parameter in a partial specialization is used in the explicit
3628 argument list. If T is of the LEVEL given in DATA (which is
3629 treated as a template_parm_data*), then DATA->PARMS is marked
3633 mark_template_parm (tree t, void* data)
3637 struct template_parm_data* tpd = (struct template_parm_data*) data;
3639 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3641 level = TEMPLATE_PARM_LEVEL (t);
3642 idx = TEMPLATE_PARM_IDX (t);
3646 level = TEMPLATE_TYPE_LEVEL (t);
3647 idx = TEMPLATE_TYPE_IDX (t);
3650 if (level == tpd->level)
3652 tpd->parms[idx] = 1;
3653 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3656 /* Return zero so that for_each_template_parm will continue the
3657 traversal of the tree; we want to mark *every* template parm. */
3661 /* Process the partial specialization DECL. */
3664 process_partial_specialization (tree decl)
3666 tree type = TREE_TYPE (decl);
3667 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3668 tree specargs = CLASSTYPE_TI_ARGS (type);
3669 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3670 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3672 int nargs = TREE_VEC_LENGTH (inner_args);
3675 int did_error_intro = 0;
3676 struct template_parm_data tpd;
3677 struct template_parm_data tpd2;
3679 gcc_assert (current_template_parms);
3681 inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3682 ntparms = TREE_VEC_LENGTH (inner_parms);
3684 /* We check that each of the template parameters given in the
3685 partial specialization is used in the argument list to the
3686 specialization. For example:
3688 template <class T> struct S;
3689 template <class T> struct S<T*>;
3691 The second declaration is OK because `T*' uses the template
3692 parameter T, whereas
3694 template <class T> struct S<int>;
3696 is no good. Even trickier is:
3707 The S2<T> declaration is actually invalid; it is a
3708 full-specialization. Of course,
3711 struct S2<T (*)(U)>;
3713 or some such would have been OK. */
3714 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3715 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3716 memset (tpd.parms, 0, sizeof (int) * ntparms);
3718 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3719 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3720 for (i = 0; i < nargs; ++i)
3722 tpd.current_arg = i;
3723 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3724 &mark_template_parm,
3727 /*include_nondeduced_p=*/false);
3729 for (i = 0; i < ntparms; ++i)
3730 if (tpd.parms[i] == 0)
3732 /* One of the template parms was not used in the
3734 if (!did_error_intro)
3736 error ("template parameters not used in partial specialization:");
3737 did_error_intro = 1;
3740 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3743 /* [temp.class.spec]
3745 The argument list of the specialization shall not be identical to
3746 the implicit argument list of the primary template. */
3747 if (comp_template_args
3749 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3751 error ("partial specialization %qT does not specialize any template arguments", type);
3753 /* [temp.class.spec]
3755 A partially specialized non-type argument expression shall not
3756 involve template parameters of the partial specialization except
3757 when the argument expression is a simple identifier.
3759 The type of a template parameter corresponding to a specialized
3760 non-type argument shall not be dependent on a parameter of the
3763 Also, we verify that pack expansions only occur at the
3764 end of the argument list. */
3765 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3767 for (i = 0; i < nargs; ++i)
3769 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3770 tree arg = TREE_VEC_ELT (inner_args, i);
3771 tree packed_args = NULL_TREE;
3774 if (ARGUMENT_PACK_P (arg))
3776 /* Extract the arguments from the argument pack. We'll be
3777 iterating over these in the following loop. */
3778 packed_args = ARGUMENT_PACK_ARGS (arg);
3779 len = TREE_VEC_LENGTH (packed_args);
3782 for (j = 0; j < len; j++)
3785 /* Get the Jth argument in the parameter pack. */
3786 arg = TREE_VEC_ELT (packed_args, j);
3788 if (PACK_EXPANSION_P (arg))
3790 /* Pack expansions must come at the end of the
3792 if ((packed_args && j < len - 1)
3793 || (!packed_args && i < nargs - 1))
3795 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3796 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3798 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3801 TREE_VEC_ELT (packed_args, j) = error_mark_node;
3805 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3806 /* We only care about the pattern. */
3807 arg = PACK_EXPANSION_PATTERN (arg);
3809 if (/* These first two lines are the `non-type' bit. */
3811 && TREE_CODE (arg) != TEMPLATE_DECL
3812 /* This next line is the `argument expression is not just a
3813 simple identifier' condition and also the `specialized
3814 non-type argument' bit. */
3815 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3817 if ((!packed_args && tpd.arg_uses_template_parms[i])
3818 || (packed_args && uses_template_parms (arg)))
3819 error ("template argument %qE involves template parameter(s)",
3823 /* Look at the corresponding template parameter,
3824 marking which template parameters its type depends
3826 tree type = TREE_TYPE (parm);
3830 /* We haven't yet initialized TPD2. Do so now. */
3831 tpd2.arg_uses_template_parms
3832 = (int *) alloca (sizeof (int) * nargs);
3833 /* The number of parameters here is the number in the
3834 main template, which, as checked in the assertion
3836 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3838 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3841 /* Mark the template parameters. But this time, we're
3842 looking for the template parameters of the main
3843 template, not in the specialization. */
3844 tpd2.current_arg = i;
3845 tpd2.arg_uses_template_parms[i] = 0;
3846 memset (tpd2.parms, 0, sizeof (int) * nargs);
3847 for_each_template_parm (type,
3848 &mark_template_parm,
3851 /*include_nondeduced_p=*/false);
3853 if (tpd2.arg_uses_template_parms [i])
3855 /* The type depended on some template parameters.
3856 If they are fully specialized in the
3857 specialization, that's OK. */
3859 for (j = 0; j < nargs; ++j)
3860 if (tpd2.parms[j] != 0
3861 && tpd.arg_uses_template_parms [j])
3863 error ("type %qT of template argument %qE depends "
3864 "on template parameter(s)",
3875 /* We should only get here once. */
3876 gcc_assert (!COMPLETE_TYPE_P (type));
3878 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3879 = tree_cons (specargs, inner_parms,
3880 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3881 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3885 /* Check that a template declaration's use of default arguments and
3886 parameter packs is not invalid. Here, PARMS are the template
3887 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3888 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3892 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3893 declaration (but not a definition); 1 indicates a declaration, 2
3894 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3895 emitted for extraneous default arguments.
3897 Returns TRUE if there were no errors found, FALSE otherwise. */
3900 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3901 int is_partial, int is_friend_decl)
3904 int last_level_to_check;
3906 bool no_errors = true;
3910 A default template-argument shall not be specified in a
3911 function template declaration or a function template definition, nor
3912 in the template-parameter-list of the definition of a member of a
3915 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3916 /* You can't have a function template declaration in a local
3917 scope, nor you can you define a member of a class template in a
3921 if (current_class_type
3922 && !TYPE_BEING_DEFINED (current_class_type)
3923 && DECL_LANG_SPECIFIC (decl)
3924 && DECL_DECLARES_FUNCTION_P (decl)
3925 /* If this is either a friend defined in the scope of the class
3926 or a member function. */
3927 && (DECL_FUNCTION_MEMBER_P (decl)
3928 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3929 : DECL_FRIEND_CONTEXT (decl)
3930 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3932 /* And, if it was a member function, it really was defined in
3933 the scope of the class. */
3934 && (!DECL_FUNCTION_MEMBER_P (decl)
3935 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3936 /* We already checked these parameters when the template was
3937 declared, so there's no need to do it again now. This function
3938 was defined in class scope, but we're processing it's body now
3939 that the class is complete. */
3942 /* Core issue 226 (C++0x only): the following only applies to class
3944 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3948 If a template-parameter has a default template-argument, all
3949 subsequent template-parameters shall have a default
3950 template-argument supplied. */
3951 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3953 tree inner_parms = TREE_VALUE (parm_level);
3954 int ntparms = TREE_VEC_LENGTH (inner_parms);
3955 int seen_def_arg_p = 0;
3958 for (i = 0; i < ntparms; ++i)
3960 tree parm = TREE_VEC_ELT (inner_parms, i);
3962 if (parm == error_mark_node)
3965 if (TREE_PURPOSE (parm))
3967 else if (seen_def_arg_p
3968 && !template_parameter_pack_p (TREE_VALUE (parm)))
3970 error ("no default argument for %qD", TREE_VALUE (parm));
3971 /* For better subsequent error-recovery, we indicate that
3972 there should have been a default argument. */
3973 TREE_PURPOSE (parm) = error_mark_node;
3979 /* Don't complain about an enclosing partial
3981 && parm_level == parms
3982 && TREE_CODE (decl) == TYPE_DECL
3984 && template_parameter_pack_p (TREE_VALUE (parm)))
3986 /* A primary class template can only have one
3987 parameter pack, at the end of the template
3990 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
3991 error ("parameter pack %qE must be at the end of the"
3992 " template parameter list", TREE_VALUE (parm));
3994 error ("parameter pack %qT must be at the end of the"
3995 " template parameter list",
3996 TREE_TYPE (TREE_VALUE (parm)));
3998 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
4006 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
4010 /* For an ordinary class template, default template arguments are
4011 allowed at the innermost level, e.g.:
4012 template <class T = int>
4014 but, in a partial specialization, they're not allowed even
4015 there, as we have in [temp.class.spec]:
4017 The template parameter list of a specialization shall not
4018 contain default template argument values.
4020 So, for a partial specialization, or for a function template
4021 (in C++98/C++03), we look at all of them. */
4024 /* But, for a primary class template that is not a partial
4025 specialization we look at all template parameters except the
4027 parms = TREE_CHAIN (parms);
4029 /* Figure out what error message to issue. */
4030 if (is_friend_decl == 2)
4031 msg = "default template arguments may not be used in function template friend re-declaration";
4032 else if (is_friend_decl)
4033 msg = "default template arguments may not be used in function template friend declarations";
4034 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
4035 msg = ("default template arguments may not be used in function templates "
4036 "without -std=c++0x or -std=gnu++0x");
4037 else if (is_partial)
4038 msg = "default template arguments may not be used in partial specializations";
4040 msg = "default argument for template parameter for class enclosing %qD";
4042 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
4043 /* If we're inside a class definition, there's no need to
4044 examine the parameters to the class itself. On the one
4045 hand, they will be checked when the class is defined, and,
4046 on the other, default arguments are valid in things like:
4047 template <class T = double>
4048 struct S { template <class U> void f(U); };
4049 Here the default argument for `S' has no bearing on the
4050 declaration of `f'. */
4051 last_level_to_check = template_class_depth (current_class_type) + 1;
4053 /* Check everything. */
4054 last_level_to_check = 0;
4056 for (parm_level = parms;
4057 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
4058 parm_level = TREE_CHAIN (parm_level))
4060 tree inner_parms = TREE_VALUE (parm_level);
4064 ntparms = TREE_VEC_LENGTH (inner_parms);
4065 for (i = 0; i < ntparms; ++i)
4067 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
4070 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
4075 if (is_friend_decl == 2)
4082 /* Clear out the default argument so that we are not
4084 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
4088 /* At this point, if we're still interested in issuing messages,
4089 they must apply to classes surrounding the object declared. */
4091 msg = "default argument for template parameter for class enclosing %qD";
4097 /* Worker for push_template_decl_real, called via
4098 for_each_template_parm. DATA is really an int, indicating the
4099 level of the parameters we are interested in. If T is a template
4100 parameter of that level, return nonzero. */
4103 template_parm_this_level_p (tree t, void* data)
4105 int this_level = *(int *)data;
4108 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
4109 level = TEMPLATE_PARM_LEVEL (t);
4111 level = TEMPLATE_TYPE_LEVEL (t);
4112 return level == this_level;
4115 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4116 parameters given by current_template_args, or reuses a
4117 previously existing one, if appropriate. Returns the DECL, or an
4118 equivalent one, if it is replaced via a call to duplicate_decls.
4120 If IS_FRIEND is true, DECL is a friend declaration. */
4123 push_template_decl_real (tree decl, bool is_friend)
4131 int new_template_p = 0;
4132 /* True if the template is a member template, in the sense of
4134 bool member_template_p = false;
4136 if (decl == error_mark_node || !current_template_parms)
4137 return error_mark_node;
4139 /* See if this is a partial specialization. */
4140 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
4141 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
4142 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
4144 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
4148 /* For a friend, we want the context of the friend function, not
4149 the type of which it is a friend. */
4150 ctx = DECL_CONTEXT (decl);
4151 else if (CP_DECL_CONTEXT (decl)
4152 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4153 /* In the case of a virtual function, we want the class in which
4155 ctx = CP_DECL_CONTEXT (decl);
4157 /* Otherwise, if we're currently defining some class, the DECL
4158 is assumed to be a member of the class. */
4159 ctx = current_scope ();
4161 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
4164 if (!DECL_CONTEXT (decl))
4165 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
4167 /* See if this is a primary template. */
4168 if (is_friend && ctx)
4169 /* A friend template that specifies a class context, i.e.
4170 template <typename T> friend void A<T>::f();
4174 primary = template_parm_scope_p ();
4178 if (DECL_CLASS_SCOPE_P (decl))
4179 member_template_p = true;
4180 if (TREE_CODE (decl) == TYPE_DECL
4181 && ANON_AGGRNAME_P (DECL_NAME (decl)))
4183 error ("template class without a name");
4184 return error_mark_node;
4186 else if (TREE_CODE (decl) == FUNCTION_DECL)
4188 if (DECL_DESTRUCTOR_P (decl))
4192 A destructor shall not be a member template. */
4193 error ("destructor %qD declared as member template", decl);
4194 return error_mark_node;
4196 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
4197 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
4198 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
4199 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
4200 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
4201 == void_list_node)))
4203 /* [basic.stc.dynamic.allocation]
4205 An allocation function can be a function
4206 template. ... Template allocation functions shall
4207 have two or more parameters. */
4208 error ("invalid template declaration of %qD", decl);
4209 return error_mark_node;
4212 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4213 && CLASS_TYPE_P (TREE_TYPE (decl)))
4217 error ("template declaration of %q#D", decl);
4218 return error_mark_node;
4222 /* Check to see that the rules regarding the use of default
4223 arguments are not being violated. */
4224 check_default_tmpl_args (decl, current_template_parms,
4225 primary, is_partial, /*is_friend_decl=*/0);
4227 /* Ensure that there are no parameter packs in the type of this
4228 declaration that have not been expanded. */
4229 if (TREE_CODE (decl) == FUNCTION_DECL)
4231 /* Check each of the arguments individually to see if there are
4232 any bare parameter packs. */
4233 tree type = TREE_TYPE (decl);
4234 tree arg = DECL_ARGUMENTS (decl);
4235 tree argtype = TYPE_ARG_TYPES (type);
4237 while (arg && argtype)
4239 if (!FUNCTION_PARAMETER_PACK_P (arg)
4240 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
4242 /* This is a PARM_DECL that contains unexpanded parameter
4243 packs. We have already complained about this in the
4244 check_for_bare_parameter_packs call, so just replace
4245 these types with ERROR_MARK_NODE. */
4246 TREE_TYPE (arg) = error_mark_node;
4247 TREE_VALUE (argtype) = error_mark_node;
4250 arg = TREE_CHAIN (arg);
4251 argtype = TREE_CHAIN (argtype);
4254 /* Check for bare parameter packs in the return type and the
4255 exception specifiers. */
4256 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
4257 /* Errors were already issued, set return type to int
4258 as the frontend doesn't expect error_mark_node as
4260 TREE_TYPE (type) = integer_type_node;
4261 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
4262 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
4264 else if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
4266 TREE_TYPE (decl) = error_mark_node;
4267 return error_mark_node;
4271 return process_partial_specialization (decl);
4273 args = current_template_args ();
4276 || TREE_CODE (ctx) == FUNCTION_DECL
4277 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
4278 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
4280 if (DECL_LANG_SPECIFIC (decl)
4281 && DECL_TEMPLATE_INFO (decl)
4282 && DECL_TI_TEMPLATE (decl))
4283 tmpl = DECL_TI_TEMPLATE (decl);
4284 /* If DECL is a TYPE_DECL for a class-template, then there won't
4285 be DECL_LANG_SPECIFIC. The information equivalent to
4286 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4287 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4288 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
4289 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
4291 /* Since a template declaration already existed for this
4292 class-type, we must be redeclaring it here. Make sure
4293 that the redeclaration is valid. */
4294 redeclare_class_template (TREE_TYPE (decl),
4295 current_template_parms);
4296 /* We don't need to create a new TEMPLATE_DECL; just use the
4297 one we already had. */
4298 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
4302 tmpl = build_template_decl (decl, current_template_parms,
4306 if (DECL_LANG_SPECIFIC (decl)
4307 && DECL_TEMPLATE_SPECIALIZATION (decl))
4309 /* A specialization of a member template of a template
4311 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4312 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
4313 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
4319 tree a, t, current, parms;
4321 tree tinfo = get_template_info (decl);
4325 error ("template definition of non-template %q#D", decl);
4326 return error_mark_node;
4329 tmpl = TI_TEMPLATE (tinfo);
4331 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
4332 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
4333 && DECL_TEMPLATE_SPECIALIZATION (decl)
4334 && DECL_MEMBER_TEMPLATE_P (tmpl))
4338 /* The declaration is a specialization of a member
4339 template, declared outside the class. Therefore, the
4340 innermost template arguments will be NULL, so we
4341 replace them with the arguments determined by the
4342 earlier call to check_explicit_specialization. */
4343 args = DECL_TI_ARGS (decl);
4346 = build_template_decl (decl, current_template_parms,
4348 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
4349 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
4350 DECL_TI_TEMPLATE (decl) = new_tmpl;
4351 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
4352 DECL_TEMPLATE_INFO (new_tmpl)
4353 = tree_cons (tmpl, args, NULL_TREE);
4355 register_specialization (new_tmpl,
4356 most_general_template (tmpl),
4362 /* Make sure the template headers we got make sense. */
4364 parms = DECL_TEMPLATE_PARMS (tmpl);
4365 i = TMPL_PARMS_DEPTH (parms);
4366 if (TMPL_ARGS_DEPTH (args) != i)
4368 error ("expected %d levels of template parms for %q#D, got %d",
4369 i, decl, TMPL_ARGS_DEPTH (args));
4372 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
4374 a = TMPL_ARGS_LEVEL (args, i);
4375 t = INNERMOST_TEMPLATE_PARMS (parms);
4377 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
4379 if (current == decl)
4380 error ("got %d template parameters for %q#D",
4381 TREE_VEC_LENGTH (a), decl);
4383 error ("got %d template parameters for %q#T",
4384 TREE_VEC_LENGTH (a), current);
4385 error (" but %d required", TREE_VEC_LENGTH (t));
4386 return error_mark_node;
4389 if (current == decl)
4392 current = (TYPE_P (current)
4393 ? TYPE_CONTEXT (current)
4394 : DECL_CONTEXT (current));
4397 /* Check that the parms are used in the appropriate qualifying scopes
4398 in the declarator. */
4399 if (!comp_template_args
4401 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4404 template arguments to %qD do not match original template %qD",
4405 decl, DECL_TEMPLATE_RESULT (tmpl));
4406 if (!uses_template_parms (TI_ARGS (tinfo)))
4407 inform (input_location, "use template<> for an explicit specialization");
4408 /* Avoid crash in import_export_decl. */
4409 DECL_INTERFACE_KNOWN (decl) = 1;
4410 return error_mark_node;
4414 DECL_TEMPLATE_RESULT (tmpl) = decl;
4415 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4417 /* Push template declarations for global functions and types. Note
4418 that we do not try to push a global template friend declared in a
4419 template class; such a thing may well depend on the template
4420 parameters of the class. */
4421 if (new_template_p && !ctx
4422 && !(is_friend && template_class_depth (current_class_type) > 0))
4424 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4425 if (tmpl == error_mark_node)
4426 return error_mark_node;
4428 /* Hide template friend classes that haven't been declared yet. */
4429 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4431 DECL_ANTICIPATED (tmpl) = 1;
4432 DECL_FRIEND_P (tmpl) = 1;
4438 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4441 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4442 if (DECL_CONV_FN_P (tmpl))
4444 int depth = TMPL_PARMS_DEPTH (parms);
4446 /* It is a conversion operator. See if the type converted to
4447 depends on innermost template operands. */
4449 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4451 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4454 /* Give template template parms a DECL_CONTEXT of the template
4455 for which they are a parameter. */
4456 parms = INNERMOST_TEMPLATE_PARMS (parms);
4457 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4459 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4460 if (TREE_CODE (parm) == TEMPLATE_DECL)
4461 DECL_CONTEXT (parm) = tmpl;
4465 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4466 back to its most general template. If TMPL is a specialization,
4467 ARGS may only have the innermost set of arguments. Add the missing
4468 argument levels if necessary. */
4469 if (DECL_TEMPLATE_INFO (tmpl))
4470 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4472 info = tree_cons (tmpl, args, NULL_TREE);
4474 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4475 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4476 else if (DECL_LANG_SPECIFIC (decl))
4477 DECL_TEMPLATE_INFO (decl) = info;
4479 return DECL_TEMPLATE_RESULT (tmpl);
4483 push_template_decl (tree decl)
4485 return push_template_decl_real (decl, false);
4488 /* Called when a class template TYPE is redeclared with the indicated
4489 template PARMS, e.g.:
4491 template <class T> struct S;
4492 template <class T> struct S {}; */
4495 redeclare_class_template (tree type, tree parms)
4501 if (!TYPE_TEMPLATE_INFO (type))
4503 error ("%qT is not a template type", type);
4507 tmpl = TYPE_TI_TEMPLATE (type);
4508 if (!PRIMARY_TEMPLATE_P (tmpl))
4509 /* The type is nested in some template class. Nothing to worry
4510 about here; there are no new template parameters for the nested
4516 error ("template specifiers not specified in declaration of %qD",
4521 parms = INNERMOST_TEMPLATE_PARMS (parms);
4522 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4524 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4526 error ("redeclared with %d template parameter(s)",
4527 TREE_VEC_LENGTH (parms));
4528 inform (input_location, "previous declaration %q+D used %d template parameter(s)",
4529 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4533 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4540 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4541 || TREE_VEC_ELT (parms, i) == error_mark_node)
4544 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4545 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4546 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4547 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4549 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4551 if (tmpl_parm != error_mark_node
4552 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4553 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4554 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
4555 || (TREE_CODE (tmpl_parm) != PARM_DECL
4556 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
4557 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
4558 || (TREE_CODE (tmpl_parm) == PARM_DECL
4559 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
4560 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))))))
4562 error ("template parameter %q+#D", tmpl_parm);
4563 error ("redeclared here as %q#D", parm);
4567 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4569 /* We have in [temp.param]:
4571 A template-parameter may not be given default arguments
4572 by two different declarations in the same scope. */
4573 error_at (input_location, "redefinition of default argument for %q#D", parm);
4574 inform (DECL_SOURCE_LOCATION (tmpl_parm),
4575 "original definition appeared here");
4579 if (parm_default != NULL_TREE)
4580 /* Update the previous template parameters (which are the ones
4581 that will really count) with the new default value. */
4582 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4583 else if (tmpl_default != NULL_TREE)
4584 /* Update the new parameters, too; they'll be used as the
4585 parameters for any members. */
4586 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4592 /* Simplify EXPR if it is a non-dependent expression. Returns the
4593 (possibly simplified) expression. */
4596 fold_non_dependent_expr (tree expr)
4598 if (expr == NULL_TREE)
4601 /* If we're in a template, but EXPR isn't value dependent, simplify
4602 it. We're supposed to treat:
4604 template <typename T> void f(T[1 + 1]);
4605 template <typename T> void f(T[2]);
4607 as two declarations of the same function, for example. */
4608 if (processing_template_decl
4609 && !type_dependent_expression_p (expr)
4610 && !value_dependent_expression_p (expr))
4612 HOST_WIDE_INT saved_processing_template_decl;
4614 saved_processing_template_decl = processing_template_decl;
4615 processing_template_decl = 0;
4616 expr = tsubst_copy_and_build (expr,
4619 /*in_decl=*/NULL_TREE,
4620 /*function_p=*/false,
4621 /*integral_constant_expression_p=*/true);
4622 processing_template_decl = saved_processing_template_decl;
4627 /* EXPR is an expression which is used in a constant-expression context.
4628 For instance, it could be a VAR_DECL with a constant initializer.
4629 Extract the innermost constant expression.
4631 This is basically a more powerful version of
4632 integral_constant_value, which can be used also in templates where
4633 initializers can maintain a syntactic rather than semantic form
4634 (even if they are non-dependent, for access-checking purposes). */
4637 fold_decl_constant_value (tree expr)
4639 tree const_expr = expr;
4642 expr = fold_non_dependent_expr (const_expr);
4643 const_expr = integral_constant_value (expr);
4645 while (expr != const_expr);
4650 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4651 must be a function or a pointer-to-function type, as specified
4652 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4653 and check that the resulting function has external linkage. */
4656 convert_nontype_argument_function (tree type, tree expr)
4661 fn = instantiate_type (type, fns, tf_none);
4662 if (fn == error_mark_node)
4663 return error_mark_node;
4666 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4667 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4668 if (TREE_CODE (fn_no_ptr) == BASELINK)
4669 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4671 /* [temp.arg.nontype]/1
4673 A template-argument for a non-type, non-template template-parameter
4676 -- the address of an object or function with external linkage. */
4677 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4679 error ("%qE is not a valid template argument for type %qT "
4680 "because function %qD has not external linkage",
4681 expr, type, fn_no_ptr);
4688 /* Subroutine of convert_nontype_argument.
4689 Check if EXPR of type TYPE is a valid pointer-to-member constant.
4690 Emit an error otherwise. */
4693 check_valid_ptrmem_cst_expr (tree type, tree expr)
4696 if (expr && (null_ptr_cst_p (expr) || TREE_CODE (expr) == PTRMEM_CST))
4698 error ("%qE is not a valid template argument for type %qT",
4700 error ("it must be a pointer-to-member of the form `&X::Y'");
4704 /* Attempt to convert the non-type template parameter EXPR to the
4705 indicated TYPE. If the conversion is successful, return the
4706 converted value. If the conversion is unsuccessful, return
4707 NULL_TREE if we issued an error message, or error_mark_node if we
4708 did not. We issue error messages for out-and-out bad template
4709 parameters, but not simply because the conversion failed, since we
4710 might be just trying to do argument deduction. Both TYPE and EXPR
4711 must be non-dependent.
4713 The conversion follows the special rules described in
4714 [temp.arg.nontype], and it is much more strict than an implicit
4717 This function is called twice for each template argument (see
4718 lookup_template_class for a more accurate description of this
4719 problem). This means that we need to handle expressions which
4720 are not valid in a C++ source, but can be created from the
4721 first call (for instance, casts to perform conversions). These
4722 hacks can go away after we fix the double coercion problem. */
4725 convert_nontype_argument (tree type, tree expr)
4729 /* Detect immediately string literals as invalid non-type argument.
4730 This special-case is not needed for correctness (we would easily
4731 catch this later), but only to provide better diagnostic for this
4732 common user mistake. As suggested by DR 100, we do not mention
4733 linkage issues in the diagnostic as this is not the point. */
4734 if (TREE_CODE (expr) == STRING_CST)
4736 error ("%qE is not a valid template argument for type %qT "
4737 "because string literals can never be used in this context",
4742 /* If we are in a template, EXPR may be non-dependent, but still
4743 have a syntactic, rather than semantic, form. For example, EXPR
4744 might be a SCOPE_REF, rather than the VAR_DECL to which the
4745 SCOPE_REF refers. Preserving the qualifying scope is necessary
4746 so that access checking can be performed when the template is
4747 instantiated -- but here we need the resolved form so that we can
4748 convert the argument. */
4749 expr = fold_non_dependent_expr (expr);
4750 if (error_operand_p (expr))
4751 return error_mark_node;
4752 expr_type = TREE_TYPE (expr);
4754 /* HACK: Due to double coercion, we can get a
4755 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4756 which is the tree that we built on the first call (see
4757 below when coercing to reference to object or to reference to
4758 function). We just strip everything and get to the arg.
4759 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4761 if (TREE_CODE (expr) == NOP_EXPR)
4763 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4765 /* ??? Maybe we could use convert_from_reference here, but we
4766 would need to relax its constraints because the NOP_EXPR
4767 could actually change the type to something more cv-qualified,
4768 and this is not folded by convert_from_reference. */
4769 tree addr = TREE_OPERAND (expr, 0);
4770 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4771 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4772 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4773 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4774 (TREE_TYPE (expr_type),
4775 TREE_TYPE (TREE_TYPE (addr))));
4777 expr = TREE_OPERAND (addr, 0);
4778 expr_type = TREE_TYPE (expr);
4781 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4782 parameter is a pointer to object, through decay and
4783 qualification conversion. Let's strip everything. */
4784 else if (TYPE_PTROBV_P (type))
4787 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4788 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4789 /* Skip the ADDR_EXPR only if it is part of the decay for
4790 an array. Otherwise, it is part of the original argument
4791 in the source code. */
4792 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4793 expr = TREE_OPERAND (expr, 0);
4794 expr_type = TREE_TYPE (expr);
4798 /* [temp.arg.nontype]/5, bullet 1
4800 For a non-type template-parameter of integral or enumeration type,
4801 integral promotions (_conv.prom_) and integral conversions
4802 (_conv.integral_) are applied. */
4803 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
4805 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (expr_type))
4806 return error_mark_node;
4808 expr = fold_decl_constant_value (expr);
4809 /* Notice that there are constant expressions like '4 % 0' which
4810 do not fold into integer constants. */
4811 if (TREE_CODE (expr) != INTEGER_CST)
4813 error ("%qE is not a valid template argument for type %qT "
4814 "because it is a non-constant expression", expr, type);
4818 /* At this point, an implicit conversion does what we want,
4819 because we already know that the expression is of integral
4821 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4822 if (expr == error_mark_node)
4823 return error_mark_node;
4825 /* Conversion was allowed: fold it to a bare integer constant. */
4828 /* [temp.arg.nontype]/5, bullet 2
4830 For a non-type template-parameter of type pointer to object,
4831 qualification conversions (_conv.qual_) and the array-to-pointer
4832 conversion (_conv.array_) are applied. */
4833 else if (TYPE_PTROBV_P (type))
4835 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4837 A template-argument for a non-type, non-template template-parameter
4838 shall be one of: [...]
4840 -- the name of a non-type template-parameter;
4841 -- the address of an object or function with external linkage, [...]
4842 expressed as "& id-expression" where the & is optional if the name
4843 refers to a function or array, or if the corresponding
4844 template-parameter is a reference.
4846 Here, we do not care about functions, as they are invalid anyway
4847 for a parameter of type pointer-to-object. */
4849 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4850 /* Non-type template parameters are OK. */
4852 else if (TREE_CODE (expr) != ADDR_EXPR
4853 && TREE_CODE (expr_type) != ARRAY_TYPE)
4855 if (TREE_CODE (expr) == VAR_DECL)
4857 error ("%qD is not a valid template argument "
4858 "because %qD is a variable, not the address of "
4863 /* Other values, like integer constants, might be valid
4864 non-type arguments of some other type. */
4865 return error_mark_node;
4871 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4872 ? TREE_OPERAND (expr, 0) : expr);
4873 if (TREE_CODE (decl) != VAR_DECL)
4875 error ("%qE is not a valid template argument of type %qT "
4876 "because %qE is not a variable",
4880 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4882 error ("%qE is not a valid template argument of type %qT "
4883 "because %qD does not have external linkage",
4889 expr = decay_conversion (expr);
4890 if (expr == error_mark_node)
4891 return error_mark_node;
4893 expr = perform_qualification_conversions (type, expr);
4894 if (expr == error_mark_node)
4895 return error_mark_node;
4897 /* [temp.arg.nontype]/5, bullet 3
4899 For a non-type template-parameter of type reference to object, no
4900 conversions apply. The type referred to by the reference may be more
4901 cv-qualified than the (otherwise identical) type of the
4902 template-argument. The template-parameter is bound directly to the
4903 template-argument, which must be an lvalue. */
4904 else if (TYPE_REF_OBJ_P (type))
4906 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4908 return error_mark_node;
4910 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4912 error ("%qE is not a valid template argument for type %qT "
4913 "because of conflicts in cv-qualification", expr, type);
4917 if (!real_lvalue_p (expr))
4919 error ("%qE is not a valid template argument for type %qT "
4920 "because it is not an lvalue", expr, type);
4924 /* [temp.arg.nontype]/1
4926 A template-argument for a non-type, non-template template-parameter
4927 shall be one of: [...]
4929 -- the address of an object or function with external linkage. */
4930 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4932 error ("%qE is not a valid template argument for type %qT "
4933 "because object %qD has not external linkage",
4938 expr = build_nop (type, build_address (expr));
4940 /* [temp.arg.nontype]/5, bullet 4
4942 For a non-type template-parameter of type pointer to function, only
4943 the function-to-pointer conversion (_conv.func_) is applied. If the
4944 template-argument represents a set of overloaded functions (or a
4945 pointer to such), the matching function is selected from the set
4947 else if (TYPE_PTRFN_P (type))
4949 /* If the argument is a template-id, we might not have enough
4950 context information to decay the pointer. */
4951 if (!type_unknown_p (expr_type))
4953 expr = decay_conversion (expr);
4954 if (expr == error_mark_node)
4955 return error_mark_node;
4958 expr = convert_nontype_argument_function (type, expr);
4959 if (!expr || expr == error_mark_node)
4962 if (TREE_CODE (expr) != ADDR_EXPR)
4964 error ("%qE is not a valid template argument for type %qT", expr, type);
4965 error ("it must be the address of a function with external linkage");
4969 /* [temp.arg.nontype]/5, bullet 5
4971 For a non-type template-parameter of type reference to function, no
4972 conversions apply. If the template-argument represents a set of
4973 overloaded functions, the matching function is selected from the set
4975 else if (TYPE_REFFN_P (type))
4977 if (TREE_CODE (expr) == ADDR_EXPR)
4979 error ("%qE is not a valid template argument for type %qT "
4980 "because it is a pointer", expr, type);
4981 inform (input_location, "try using %qE instead", TREE_OPERAND (expr, 0));
4985 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4986 if (!expr || expr == error_mark_node)
4989 expr = build_nop (type, build_address (expr));
4991 /* [temp.arg.nontype]/5, bullet 6
4993 For a non-type template-parameter of type pointer to member function,
4994 no conversions apply. If the template-argument represents a set of
4995 overloaded member functions, the matching member function is selected
4996 from the set (_over.over_). */
4997 else if (TYPE_PTRMEMFUNC_P (type))
4999 expr = instantiate_type (type, expr, tf_none);
5000 if (expr == error_mark_node)
5001 return error_mark_node;
5003 /* [temp.arg.nontype] bullet 1 says the pointer to member
5004 expression must be a pointer-to-member constant. */
5005 if (!check_valid_ptrmem_cst_expr (type, expr))
5006 return error_mark_node;
5008 /* There is no way to disable standard conversions in
5009 resolve_address_of_overloaded_function (called by
5010 instantiate_type). It is possible that the call succeeded by
5011 converting &B::I to &D::I (where B is a base of D), so we need
5012 to reject this conversion here.
5014 Actually, even if there was a way to disable standard conversions,
5015 it would still be better to reject them here so that we can
5016 provide a superior diagnostic. */
5017 if (!same_type_p (TREE_TYPE (expr), type))
5019 /* Make sure we are just one standard conversion off. */
5020 gcc_assert (can_convert (type, TREE_TYPE (expr)));
5021 error ("%qE is not a valid template argument for type %qT "
5022 "because it is of type %qT", expr, type,
5024 inform (input_location, "standard conversions are not allowed in this context");
5028 /* [temp.arg.nontype]/5, bullet 7
5030 For a non-type template-parameter of type pointer to data member,
5031 qualification conversions (_conv.qual_) are applied. */
5032 else if (TYPE_PTRMEM_P (type))
5034 /* [temp.arg.nontype] bullet 1 says the pointer to member
5035 expression must be a pointer-to-member constant. */
5036 if (!check_valid_ptrmem_cst_expr (type, expr))
5037 return error_mark_node;
5039 expr = perform_qualification_conversions (type, expr);
5040 if (expr == error_mark_node)
5043 /* A template non-type parameter must be one of the above. */
5047 /* Sanity check: did we actually convert the argument to the
5049 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
5053 /* Subroutine of coerce_template_template_parms, which returns 1 if
5054 PARM_PARM and ARG_PARM match using the rule for the template
5055 parameters of template template parameters. Both PARM and ARG are
5056 template parameters; the rest of the arguments are the same as for
5057 coerce_template_template_parms.
5060 coerce_template_template_parm (tree parm,
5062 tsubst_flags_t complain,
5066 if (arg == NULL_TREE || arg == error_mark_node
5067 || parm == NULL_TREE || parm == error_mark_node)
5070 if (TREE_CODE (arg) != TREE_CODE (parm))
5073 switch (TREE_CODE (parm))
5076 /* We encounter instantiations of templates like
5077 template <template <template <class> class> class TT>
5080 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5081 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5083 if (!coerce_template_template_parms
5084 (parmparm, argparm, complain, in_decl, outer_args))
5090 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
5091 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5092 /* Argument is a parameter pack but parameter is not. */
5097 /* The tsubst call is used to handle cases such as
5099 template <int> class C {};
5100 template <class T, template <T> class TT> class D {};
5103 i.e. the parameter list of TT depends on earlier parameters. */
5104 if (!uses_template_parms (TREE_TYPE (arg))
5106 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
5110 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
5111 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5112 /* Argument is a parameter pack but parameter is not. */
5125 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5126 template template parameters. Both PARM_PARMS and ARG_PARMS are
5127 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5130 Consider the example:
5131 template <class T> class A;
5132 template<template <class U> class TT> class B;
5134 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5135 the parameters to A, and OUTER_ARGS contains A. */
5138 coerce_template_template_parms (tree parm_parms,
5140 tsubst_flags_t complain,
5144 int nparms, nargs, i;
5148 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
5149 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
5151 nparms = TREE_VEC_LENGTH (parm_parms);
5152 nargs = TREE_VEC_LENGTH (arg_parms);
5154 /* Determine whether we have a parameter pack at the end of the
5155 template template parameter's template parameter list. */
5156 if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
5158 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
5160 if (parm == error_mark_node)
5163 switch (TREE_CODE (parm))
5167 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5172 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5182 && !(variadic_p && nargs >= nparms - 1))
5185 /* Check all of the template parameters except the parameter pack at
5186 the end (if any). */
5187 for (i = 0; i < nparms - variadic_p; ++i)
5189 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
5190 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5193 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5194 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5196 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5204 /* Check each of the template parameters in the template
5205 argument against the template parameter pack at the end of
5206 the template template parameter. */
5207 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
5210 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5212 for (; i < nargs; ++i)
5214 if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5217 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5219 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5228 /* Verifies that the deduced template arguments (in TARGS) for the
5229 template template parameters (in TPARMS) represent valid bindings,
5230 by comparing the template parameter list of each template argument
5231 to the template parameter list of its corresponding template
5232 template parameter, in accordance with DR150. This
5233 routine can only be called after all template arguments have been
5234 deduced. It will return TRUE if all of the template template
5235 parameter bindings are okay, FALSE otherwise. */
5237 template_template_parm_bindings_ok_p (tree tparms, tree targs)
5239 int i, ntparms = TREE_VEC_LENGTH (tparms);
5242 /* We're dealing with template parms in this process. */
5243 ++processing_template_decl;
5245 targs = INNERMOST_TEMPLATE_ARGS (targs);
5247 for (i = 0; i < ntparms; ++i)
5249 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
5250 tree targ = TREE_VEC_ELT (targs, i);
5252 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
5254 tree packed_args = NULL_TREE;
5257 if (ARGUMENT_PACK_P (targ))
5259 /* Look inside the argument pack. */
5260 packed_args = ARGUMENT_PACK_ARGS (targ);
5261 len = TREE_VEC_LENGTH (packed_args);
5264 for (idx = 0; idx < len; ++idx)
5266 tree targ_parms = NULL_TREE;
5269 /* Extract the next argument from the argument
5271 targ = TREE_VEC_ELT (packed_args, idx);
5273 if (PACK_EXPANSION_P (targ))
5274 /* Look at the pattern of the pack expansion. */
5275 targ = PACK_EXPANSION_PATTERN (targ);
5277 /* Extract the template parameters from the template
5279 if (TREE_CODE (targ) == TEMPLATE_DECL)
5280 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
5281 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
5282 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
5284 /* Verify that we can coerce the template template
5285 parameters from the template argument to the template
5286 parameter. This requires an exact match. */
5288 && !coerce_template_template_parms
5289 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
5304 --processing_template_decl;
5308 /* Convert the indicated template ARG as necessary to match the
5309 indicated template PARM. Returns the converted ARG, or
5310 error_mark_node if the conversion was unsuccessful. Error and
5311 warning messages are issued under control of COMPLAIN. This
5312 conversion is for the Ith parameter in the parameter list. ARGS is
5313 the full set of template arguments deduced so far. */
5316 convert_template_argument (tree parm,
5319 tsubst_flags_t complain,
5325 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
5327 if (TREE_CODE (arg) == TREE_LIST
5328 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
5330 /* The template argument was the name of some
5331 member function. That's usually
5332 invalid, but static members are OK. In any
5333 case, grab the underlying fields/functions
5334 and issue an error later if required. */
5335 orig_arg = TREE_VALUE (arg);
5336 TREE_TYPE (arg) = unknown_type_node;
5341 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
5342 requires_type = (TREE_CODE (parm) == TYPE_DECL
5343 || requires_tmpl_type);
5345 /* When determining whether an argument pack expansion is a template,
5346 look at the pattern. */
5347 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
5348 arg = PACK_EXPANSION_PATTERN (arg);
5351 ((TREE_CODE (arg) == TEMPLATE_DECL
5352 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
5353 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5354 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
5357 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5358 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
5359 arg = TYPE_STUB_DECL (arg);
5361 is_type = TYPE_P (arg) || is_tmpl_type;
5363 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
5364 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
5366 permerror (input_location, "to refer to a type member of a template parameter, "
5367 "use %<typename %E%>", orig_arg);
5369 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
5370 TREE_OPERAND (arg, 1),
5372 complain & tf_error);
5376 if (is_type != requires_type)
5380 if (complain & tf_error)
5382 error ("type/value mismatch at argument %d in template "
5383 "parameter list for %qD",
5386 error (" expected a constant of type %qT, got %qT",
5388 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
5389 else if (requires_tmpl_type)
5390 error (" expected a class template, got %qE", orig_arg);
5392 error (" expected a type, got %qE", orig_arg);
5395 return error_mark_node;
5397 if (is_tmpl_type ^ requires_tmpl_type)
5399 if (in_decl && (complain & tf_error))
5401 error ("type/value mismatch at argument %d in template "
5402 "parameter list for %qD",
5405 error (" expected a type, got %qT", DECL_NAME (arg));
5407 error (" expected a class template, got %qT", orig_arg);
5409 return error_mark_node;
5414 if (requires_tmpl_type)
5416 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
5417 /* The number of argument required is not known yet.
5418 Just accept it for now. */
5419 val = TREE_TYPE (arg);
5422 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5425 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5427 if (coerce_template_template_parms (parmparm, argparm,
5433 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5435 if (val != error_mark_node)
5437 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
5438 val = TREE_TYPE (val);
5439 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
5440 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
5442 val = TREE_TYPE (arg);
5443 val = make_pack_expansion (val);
5449 if (in_decl && (complain & tf_error))
5451 error ("type/value mismatch at argument %d in "
5452 "template parameter list for %qD",
5454 error (" expected a template of type %qD, got %qD",
5458 val = error_mark_node;
5464 /* We only form one instance of each template specialization.
5465 Therefore, if we use a non-canonical variant (i.e., a
5466 typedef), any future messages referring to the type will use
5467 the typedef, which is confusing if those future uses do not
5468 themselves also use the typedef. */
5470 val = strip_typedefs (val);
5474 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
5476 if (invalid_nontype_parm_type_p (t, complain))
5477 return error_mark_node;
5479 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
5481 if (same_type_p (t, TREE_TYPE (orig_arg)))
5485 /* Not sure if this is reachable, but it doesn't hurt
5487 error ("type mismatch in nontype parameter pack");
5488 val = error_mark_node;
5491 else if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
5492 /* We used to call digest_init here. However, digest_init
5493 will report errors, which we don't want when complain
5494 is zero. More importantly, digest_init will try too
5495 hard to convert things: for example, `0' should not be
5496 converted to pointer type at this point according to
5497 the standard. Accepting this is not merely an
5498 extension, since deciding whether or not these
5499 conversions can occur is part of determining which
5500 function template to call, or whether a given explicit
5501 argument specification is valid. */
5502 val = convert_nontype_argument (t, orig_arg);
5506 if (val == NULL_TREE)
5507 val = error_mark_node;
5508 else if (val == error_mark_node && (complain & tf_error))
5509 error ("could not convert template argument %qE to %qT", orig_arg, t);
5515 /* Coerces the remaining template arguments in INNER_ARGS (from
5516 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5517 Returns the coerced argument pack. PARM_IDX is the position of this
5518 parameter in the template parameter list. ARGS is the original
5519 template argument list. */
5521 coerce_template_parameter_pack (tree parms,
5529 tsubst_flags_t complain)
5531 tree parm = TREE_VEC_ELT (parms, parm_idx);
5532 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5535 tree packed_types = NULL_TREE;
5537 if (arg_idx > nargs)
5540 packed_args = make_tree_vec (nargs - arg_idx);
5542 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
5543 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
5545 /* When the template parameter is a non-type template
5546 parameter pack whose type uses parameter packs, we need
5547 to look at each of the template arguments
5548 separately. Build a vector of the types for these
5549 non-type template parameters in PACKED_TYPES. */
5551 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
5552 packed_types = tsubst_pack_expansion (expansion, args,
5555 if (packed_types == error_mark_node)
5556 return error_mark_node;
5558 /* Check that we have the right number of arguments. */
5560 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
5561 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
5564 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
5565 error ("wrong number of template arguments (%d, should be %d)",
5566 nargs, needed_parms);
5567 return error_mark_node;
5570 /* If we aren't able to check the actual arguments now
5571 (because they haven't been expanded yet), we can at least
5572 verify that all of the types used for the non-type
5573 template parameter pack are, in fact, valid for non-type
5574 template parameters. */
5576 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5578 int j, len = TREE_VEC_LENGTH (packed_types);
5579 for (j = 0; j < len; ++j)
5581 tree t = TREE_VEC_ELT (packed_types, j);
5582 if (invalid_nontype_parm_type_p (t, complain))
5583 return error_mark_node;
5588 /* Convert the remaining arguments, which will be a part of the
5589 parameter pack "parm". */
5590 for (; arg_idx < nargs; ++arg_idx)
5592 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5593 tree actual_parm = TREE_VALUE (parm);
5595 if (packed_types && !PACK_EXPANSION_P (arg))
5597 /* When we have a vector of types (corresponding to the
5598 non-type template parameter pack that uses parameter
5599 packs in its type, as mention above), and the
5600 argument is not an expansion (which expands to a
5601 currently unknown number of arguments), clone the
5602 parm and give it the next type in PACKED_TYPES. */
5603 actual_parm = copy_node (actual_parm);
5604 TREE_TYPE (actual_parm) =
5605 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5608 if (arg != error_mark_node)
5609 arg = convert_template_argument (actual_parm,
5610 arg, new_args, complain, parm_idx,
5612 if (arg == error_mark_node)
5614 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5617 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5618 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5619 argument_pack = cxx_make_type (TYPE_ARGUMENT_PACK);
5622 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5623 TREE_TYPE (argument_pack)
5624 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
5625 TREE_CONSTANT (argument_pack) = 1;
5628 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5629 return argument_pack;
5632 /* Convert all template arguments to their appropriate types, and
5633 return a vector containing the innermost resulting template
5634 arguments. If any error occurs, return error_mark_node. Error and
5635 warning messages are issued under control of COMPLAIN.
5637 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5638 for arguments not specified in ARGS. Otherwise, if
5639 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5640 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5641 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5645 coerce_template_parms (tree parms,
5648 tsubst_flags_t complain,
5649 bool require_all_args,
5650 bool use_default_args)
5652 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5655 tree new_inner_args;
5656 int saved_unevaluated_operand;
5657 int saved_inhibit_evaluation_warnings;
5659 /* When used as a boolean value, indicates whether this is a
5660 variadic template parameter list. Since it's an int, we can also
5661 subtract it from nparms to get the number of non-variadic
5665 nparms = TREE_VEC_LENGTH (parms);
5667 /* Determine if there are any parameter packs. */
5668 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5670 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5671 if (template_parameter_pack_p (tparm))
5675 inner_args = INNERMOST_TEMPLATE_ARGS (args);
5676 /* If there are 0 or 1 parameter packs, we need to expand any argument
5677 packs so that we can deduce a parameter pack from some non-packed args
5678 followed by an argument pack, as in variadic85.C. If there are more
5679 than that, we need to leave argument packs intact so the arguments are
5680 assigned to the right parameter packs. This should only happen when
5681 dealing with a nested class inside a partial specialization of a class
5682 template, as in variadic92.C. */
5683 if (variadic_p <= 1)
5684 inner_args = expand_template_argument_pack (inner_args);
5686 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5687 if ((nargs > nparms && !variadic_p)
5688 || (nargs < nparms - variadic_p
5690 && (!use_default_args
5691 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5692 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5694 if (complain & tf_error)
5696 const char *or_more = "";
5699 or_more = " or more";
5703 error ("wrong number of template arguments (%d, should be %d%s)",
5704 nargs, nparms, or_more);
5707 error ("provided for %q+D", in_decl);
5710 return error_mark_node;
5713 /* We need to evaluate the template arguments, even though this
5714 template-id may be nested within a "sizeof". */
5715 saved_unevaluated_operand = cp_unevaluated_operand;
5716 cp_unevaluated_operand = 0;
5717 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5718 c_inhibit_evaluation_warnings = 0;
5719 new_inner_args = make_tree_vec (nparms);
5720 new_args = add_outermost_template_args (args, new_inner_args);
5721 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5726 /* Get the Ith template parameter. */
5727 parm = TREE_VEC_ELT (parms, parm_idx);
5729 if (parm == error_mark_node)
5731 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5735 /* Calculate the next argument. */
5736 if (arg_idx < nargs)
5737 arg = TREE_VEC_ELT (inner_args, arg_idx);
5741 if (template_parameter_pack_p (TREE_VALUE (parm))
5742 && !(arg && ARGUMENT_PACK_P (arg)))
5744 /* All remaining arguments will be placed in the
5745 template parameter pack PARM. */
5746 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5747 inner_args, arg_idx,
5751 /* Store this argument. */
5752 if (arg == error_mark_node)
5754 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5756 /* We are done with all of the arguments. */
5763 if (PACK_EXPANSION_P (arg))
5765 if (complain & tf_error)
5767 /* FIXME this restriction was removed by N2555; see
5769 /* If ARG is a pack expansion, but PARM is not a
5770 template parameter pack (if it were, we would have
5771 handled it above), we're trying to expand into a
5772 fixed-length argument list. */
5773 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5774 sorry ("cannot expand %<%E%> into a fixed-length "
5775 "argument list", arg);
5777 sorry ("cannot expand %<%T%> into a fixed-length "
5778 "argument list", arg);
5780 return error_mark_node;
5783 else if (require_all_args)
5784 /* There must be a default arg in this case. */
5785 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5790 if (arg == error_mark_node)
5792 if (complain & tf_error)
5793 error ("template argument %d is invalid", arg_idx + 1);
5796 /* This only occurs if there was an error in the template
5797 parameter list itself (which we would already have
5798 reported) that we are trying to recover from, e.g., a class
5799 template with a parameter list such as
5800 template<typename..., typename>. */
5801 return error_mark_node;
5803 arg = convert_template_argument (TREE_VALUE (parm),
5804 arg, new_args, complain,
5807 if (arg == error_mark_node)
5809 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5811 cp_unevaluated_operand = saved_unevaluated_operand;
5812 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
5815 return error_mark_node;
5817 return new_inner_args;
5820 /* Returns 1 if template args OT and NT are equivalent. */
5823 template_args_equal (tree ot, tree nt)
5828 if (TREE_CODE (nt) == TREE_VEC)
5829 /* For member templates */
5830 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5831 else if (PACK_EXPANSION_P (ot))
5832 return PACK_EXPANSION_P (nt)
5833 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5834 PACK_EXPANSION_PATTERN (nt));
5835 else if (ARGUMENT_PACK_P (ot))
5840 if (!ARGUMENT_PACK_P (nt))
5843 opack = ARGUMENT_PACK_ARGS (ot);
5844 npack = ARGUMENT_PACK_ARGS (nt);
5845 len = TREE_VEC_LENGTH (opack);
5846 if (TREE_VEC_LENGTH (npack) != len)
5848 for (i = 0; i < len; ++i)
5849 if (!template_args_equal (TREE_VEC_ELT (opack, i),
5850 TREE_VEC_ELT (npack, i)))
5854 else if (ot && TREE_CODE (ot) == ARGUMENT_PACK_SELECT)
5856 /* We get here probably because we are in the middle of substituting
5857 into the pattern of a pack expansion. In that case the
5858 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
5859 interested in. So we want to use the initial pack argument for
5861 ot = ARGUMENT_PACK_SELECT_FROM_PACK (ot);
5862 if (nt && TREE_CODE (nt) == ARGUMENT_PACK_SELECT)
5863 nt = ARGUMENT_PACK_SELECT_FROM_PACK (nt);
5864 return template_args_equal (ot, nt);
5866 else if (TYPE_P (nt))
5867 return TYPE_P (ot) && same_type_p (ot, nt);
5868 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5871 return cp_tree_equal (ot, nt);
5874 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5875 of template arguments. Returns 0 otherwise. */
5878 comp_template_args (tree oldargs, tree newargs)
5882 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5885 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5887 tree nt = TREE_VEC_ELT (newargs, i);
5888 tree ot = TREE_VEC_ELT (oldargs, i);
5890 if (! template_args_equal (ot, nt))
5897 add_pending_template (tree d)
5899 tree ti = (TYPE_P (d)
5900 ? CLASSTYPE_TEMPLATE_INFO (d)
5901 : DECL_TEMPLATE_INFO (d));
5902 struct pending_template *pt;
5905 if (TI_PENDING_TEMPLATE_FLAG (ti))
5908 /* We are called both from instantiate_decl, where we've already had a
5909 tinst_level pushed, and instantiate_template, where we haven't.
5911 level = !current_tinst_level || current_tinst_level->decl != d;
5914 push_tinst_level (d);
5916 pt = GGC_NEW (struct pending_template);
5918 pt->tinst = current_tinst_level;
5919 if (last_pending_template)
5920 last_pending_template->next = pt;
5922 pending_templates = pt;
5924 last_pending_template = pt;
5926 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5933 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5934 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5935 documentation for TEMPLATE_ID_EXPR. */
5938 lookup_template_function (tree fns, tree arglist)
5942 if (fns == error_mark_node || arglist == error_mark_node)
5943 return error_mark_node;
5945 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5946 gcc_assert (fns && (is_overloaded_fn (fns)
5947 || TREE_CODE (fns) == IDENTIFIER_NODE));
5949 if (BASELINK_P (fns))
5951 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5953 BASELINK_FUNCTIONS (fns),
5958 type = TREE_TYPE (fns);
5959 if (TREE_CODE (fns) == OVERLOAD || !type)
5960 type = unknown_type_node;
5962 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5965 /* Within the scope of a template class S<T>, the name S gets bound
5966 (in build_self_reference) to a TYPE_DECL for the class, not a
5967 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5968 or one of its enclosing classes, and that type is a template,
5969 return the associated TEMPLATE_DECL. Otherwise, the original
5970 DECL is returned. */
5973 maybe_get_template_decl_from_type_decl (tree decl)
5975 return (decl != NULL_TREE
5976 && TREE_CODE (decl) == TYPE_DECL
5977 && DECL_ARTIFICIAL (decl)
5978 && CLASS_TYPE_P (TREE_TYPE (decl))
5979 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5980 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5983 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5984 parameters, find the desired type.
5986 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5988 IN_DECL, if non-NULL, is the template declaration we are trying to
5991 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5992 the class we are looking up.
5994 Issue error and warning messages under control of COMPLAIN.
5996 If the template class is really a local class in a template
5997 function, then the FUNCTION_CONTEXT is the function in which it is
6000 ??? Note that this function is currently called *twice* for each
6001 template-id: the first time from the parser, while creating the
6002 incomplete type (finish_template_type), and the second type during the
6003 real instantiation (instantiate_template_class). This is surely something
6004 that we want to avoid. It also causes some problems with argument
6005 coercion (see convert_nontype_argument for more information on this). */
6008 lookup_template_class (tree d1,
6013 tsubst_flags_t complain)
6015 tree templ = NULL_TREE, parmlist;
6022 timevar_push (TV_NAME_LOOKUP);
6024 if (TREE_CODE (d1) == IDENTIFIER_NODE)
6026 tree value = innermost_non_namespace_value (d1);
6027 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
6032 push_decl_namespace (context);
6033 templ = lookup_name (d1);
6034 templ = maybe_get_template_decl_from_type_decl (templ);
6036 pop_decl_namespace ();
6039 context = DECL_CONTEXT (templ);
6041 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
6043 tree type = TREE_TYPE (d1);
6045 /* If we are declaring a constructor, say A<T>::A<T>, we will get
6046 an implicit typename for the second A. Deal with it. */
6047 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6048 type = TREE_TYPE (type);
6050 if (CLASSTYPE_TEMPLATE_INFO (type))
6052 templ = CLASSTYPE_TI_TEMPLATE (type);
6053 d1 = DECL_NAME (templ);
6056 else if (TREE_CODE (d1) == ENUMERAL_TYPE
6057 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
6059 templ = TYPE_TI_TEMPLATE (d1);
6060 d1 = DECL_NAME (templ);
6062 else if (TREE_CODE (d1) == TEMPLATE_DECL
6063 && DECL_TEMPLATE_RESULT (d1)
6064 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
6067 d1 = DECL_NAME (templ);
6068 context = DECL_CONTEXT (templ);
6071 /* Issue an error message if we didn't find a template. */
6074 if (complain & tf_error)
6075 error ("%qT is not a template", d1);
6076 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6079 if (TREE_CODE (templ) != TEMPLATE_DECL
6080 /* Make sure it's a user visible template, if it was named by
6082 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
6083 && !PRIMARY_TEMPLATE_P (templ)))
6085 if (complain & tf_error)
6087 error ("non-template type %qT used as a template", d1);
6089 error ("for template declaration %q+D", in_decl);
6091 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6094 complain &= ~tf_user;
6096 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
6098 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
6099 template arguments */
6105 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
6107 /* Consider an example where a template template parameter declared as
6109 template <class T, class U = std::allocator<T> > class TT
6111 The template parameter level of T and U are one level larger than
6112 of TT. To proper process the default argument of U, say when an
6113 instantiation `TT<int>' is seen, we need to build the full
6114 arguments containing {int} as the innermost level. Outer levels,
6115 available when not appearing as default template argument, can be
6116 obtained from the arguments of the enclosing template.
6118 Suppose that TT is later substituted with std::vector. The above
6119 instantiation is `TT<int, std::allocator<T> >' with TT at
6120 level 1, and T at level 2, while the template arguments at level 1
6121 becomes {std::vector} and the inner level 2 is {int}. */
6123 outer = DECL_CONTEXT (templ);
6125 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
6126 else if (current_template_parms)
6127 /* This is an argument of the current template, so we haven't set
6128 DECL_CONTEXT yet. */
6129 outer = current_template_args ();
6132 arglist = add_to_template_args (outer, arglist);
6134 arglist2 = coerce_template_parms (parmlist, arglist, templ,
6136 /*require_all_args=*/true,
6137 /*use_default_args=*/true);
6138 if (arglist2 == error_mark_node
6139 || (!uses_template_parms (arglist2)
6140 && check_instantiated_args (templ, arglist2, complain)))
6141 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6143 parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
6144 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
6148 tree template_type = TREE_TYPE (templ);
6151 tree found = NULL_TREE;
6154 int is_partial_instantiation;
6156 gen_tmpl = most_general_template (templ);
6157 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
6158 parm_depth = TMPL_PARMS_DEPTH (parmlist);
6159 arg_depth = TMPL_ARGS_DEPTH (arglist);
6161 if (arg_depth == 1 && parm_depth > 1)
6163 /* We've been given an incomplete set of template arguments.
6166 template <class T> struct S1 {
6167 template <class U> struct S2 {};
6168 template <class U> struct S2<U*> {};
6171 we will be called with an ARGLIST of `U*', but the
6172 TEMPLATE will be `template <class T> template
6173 <class U> struct S1<T>::S2'. We must fill in the missing
6176 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
6178 arg_depth = TMPL_ARGS_DEPTH (arglist);
6181 /* Now we should have enough arguments. */
6182 gcc_assert (parm_depth == arg_depth);
6184 /* From here on, we're only interested in the most general
6187 /* Calculate the BOUND_ARGS. These will be the args that are
6188 actually tsubst'd into the definition to create the
6192 /* We have multiple levels of arguments to coerce, at once. */
6194 int saved_depth = TMPL_ARGS_DEPTH (arglist);
6196 tree bound_args = make_tree_vec (parm_depth);
6198 for (i = saved_depth,
6199 t = DECL_TEMPLATE_PARMS (gen_tmpl);
6200 i > 0 && t != NULL_TREE;
6201 --i, t = TREE_CHAIN (t))
6203 tree a = coerce_template_parms (TREE_VALUE (t),
6206 /*require_all_args=*/true,
6207 /*use_default_args=*/true);
6209 /* Don't process further if one of the levels fails. */
6210 if (a == error_mark_node)
6212 /* Restore the ARGLIST to its full size. */
6213 TREE_VEC_LENGTH (arglist) = saved_depth;
6214 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6217 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
6219 /* We temporarily reduce the length of the ARGLIST so
6220 that coerce_template_parms will see only the arguments
6221 corresponding to the template parameters it is
6223 TREE_VEC_LENGTH (arglist)--;
6226 /* Restore the ARGLIST to its full size. */
6227 TREE_VEC_LENGTH (arglist) = saved_depth;
6229 arglist = bound_args;
6233 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
6234 INNERMOST_TEMPLATE_ARGS (arglist),
6237 /*require_all_args=*/true,
6238 /*use_default_args=*/true);
6240 if (arglist == error_mark_node)
6241 /* We were unable to bind the arguments. */
6242 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6244 /* In the scope of a template class, explicit references to the
6245 template class refer to the type of the template, not any
6246 instantiation of it. For example, in:
6248 template <class T> class C { void f(C<T>); }
6250 the `C<T>' is just the same as `C'. Outside of the
6251 class, however, such a reference is an instantiation. */
6253 || !PRIMARY_TEMPLATE_P (gen_tmpl)
6254 || currently_open_class (template_type))
6255 /* comp_template_args is expensive, check it last. */
6256 && comp_template_args (TYPE_TI_ARGS (template_type),
6258 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, template_type);
6260 /* If we already have this specialization, return it. */
6261 elt.tmpl = gen_tmpl;
6263 hash = hash_specialization (&elt);
6264 entry = (spec_entry *) htab_find_with_hash (type_specializations,
6268 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->spec);
6270 /* This type is a "partial instantiation" if any of the template
6271 arguments still involve template parameters. Note that we set
6272 IS_PARTIAL_INSTANTIATION for partial specializations as
6274 is_partial_instantiation = uses_template_parms (arglist);
6276 /* If the deduced arguments are invalid, then the binding
6278 if (!is_partial_instantiation
6279 && check_instantiated_args (gen_tmpl,
6280 INNERMOST_TEMPLATE_ARGS (arglist),
6282 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6284 if (!is_partial_instantiation
6285 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6286 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl))
6287 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl)) == NAMESPACE_DECL)
6289 found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
6290 DECL_NAME (gen_tmpl),
6291 /*tag_scope=*/ts_global);
6292 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
6295 context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
6298 context = global_namespace;
6300 /* Create the type. */
6301 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
6303 if (!is_partial_instantiation)
6305 set_current_access_from_decl (TYPE_NAME (template_type));
6306 t = start_enum (TYPE_IDENTIFIER (template_type),
6307 tsubst (ENUM_UNDERLYING_TYPE (template_type),
6308 arglist, complain, in_decl),
6309 SCOPED_ENUM_P (template_type));
6313 /* We don't want to call start_enum for this type, since
6314 the values for the enumeration constants may involve
6315 template parameters. And, no one should be interested
6316 in the enumeration constants for such a type. */
6317 t = cxx_make_type (ENUMERAL_TYPE);
6318 SET_SCOPED_ENUM_P (t, SCOPED_ENUM_P (template_type));
6323 t = make_class_type (TREE_CODE (template_type));
6324 CLASSTYPE_DECLARED_CLASS (t)
6325 = CLASSTYPE_DECLARED_CLASS (template_type);
6326 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
6327 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
6329 /* A local class. Make sure the decl gets registered properly. */
6330 if (context == current_function_decl)
6331 pushtag (DECL_NAME (gen_tmpl), t, /*tag_scope=*/ts_current);
6333 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
6334 /* This instantiation is another name for the primary
6335 template type. Set the TYPE_CANONICAL field
6337 TYPE_CANONICAL (t) = template_type;
6338 else if (any_template_arguments_need_structural_equality_p (arglist))
6339 /* Some of the template arguments require structural
6340 equality testing, so this template class requires
6341 structural equality testing. */
6342 SET_TYPE_STRUCTURAL_EQUALITY (t);
6345 /* If we called start_enum or pushtag above, this information
6346 will already be set up. */
6349 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
6351 type_decl = create_implicit_typedef (DECL_NAME (gen_tmpl), t);
6352 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
6353 TYPE_STUB_DECL (t) = type_decl;
6354 DECL_SOURCE_LOCATION (type_decl)
6355 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
6358 type_decl = TYPE_NAME (t);
6360 TREE_PRIVATE (type_decl)
6361 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
6362 TREE_PROTECTED (type_decl)
6363 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
6364 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
6366 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
6367 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
6370 /* Set up the template information. We have to figure out which
6371 template is the immediate parent if this is a full
6373 if (parm_depth == 1 || is_partial_instantiation
6374 || !PRIMARY_TEMPLATE_P (gen_tmpl))
6375 /* This case is easy; there are no member templates involved. */
6379 /* This is a full instantiation of a member template. Find
6380 the partial instantiation of which this is an instance. */
6382 /* Temporarily reduce by one the number of levels in the ARGLIST
6383 so as to avoid comparing the last set of arguments. */
6384 TREE_VEC_LENGTH (arglist)--;
6385 found = tsubst (gen_tmpl, arglist, complain, NULL_TREE);
6386 TREE_VEC_LENGTH (arglist)++;
6387 found = CLASSTYPE_TI_TEMPLATE (found);
6390 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
6393 slot = (spec_entry **) htab_find_slot_with_hash (type_specializations,
6394 &elt, hash, INSERT);
6395 *slot = GGC_NEW (spec_entry);
6398 /* Note this use of the partial instantiation so we can check it
6399 later in maybe_process_partial_specialization. */
6400 DECL_TEMPLATE_INSTANTIATIONS (templ)
6401 = tree_cons (arglist, t,
6402 DECL_TEMPLATE_INSTANTIATIONS (templ));
6404 if (TREE_CODE (t) == ENUMERAL_TYPE
6405 && !is_partial_instantiation)
6406 /* Now that the type has been registered on the instantiations
6407 list, we set up the enumerators. Because the enumeration
6408 constants may involve the enumeration type itself, we make
6409 sure to register the type first, and then create the
6410 constants. That way, doing tsubst_expr for the enumeration
6411 constants won't result in recursive calls here; we'll find
6412 the instantiation and exit above. */
6413 tsubst_enum (template_type, t, arglist);
6415 if (is_partial_instantiation)
6416 /* If the type makes use of template parameters, the
6417 code that generates debugging information will crash. */
6418 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
6420 /* Possibly limit visibility based on template args. */
6421 TREE_PUBLIC (type_decl) = 1;
6422 determine_visibility (type_decl);
6424 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6426 timevar_pop (TV_NAME_LOOKUP);
6433 /* True when we should also visit template parameters that occur in
6434 non-deduced contexts. */
6435 bool include_nondeduced_p;
6436 struct pointer_set_t *visited;
6439 /* Called from for_each_template_parm via walk_tree. */
6442 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
6445 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
6446 tree_fn_t fn = pfd->fn;
6447 void *data = pfd->data;
6450 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
6451 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
6452 pfd->include_nondeduced_p))
6453 return error_mark_node;
6455 switch (TREE_CODE (t))
6458 if (TYPE_PTRMEMFUNC_P (t))
6464 if (!TYPE_TEMPLATE_INFO (t))
6466 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
6467 fn, data, pfd->visited,
6468 pfd->include_nondeduced_p))
6469 return error_mark_node;
6473 if (for_each_template_parm (TYPE_MIN_VALUE (t),
6474 fn, data, pfd->visited,
6475 pfd->include_nondeduced_p)
6476 || for_each_template_parm (TYPE_MAX_VALUE (t),
6477 fn, data, pfd->visited,
6478 pfd->include_nondeduced_p))
6479 return error_mark_node;
6483 /* Since we're not going to walk subtrees, we have to do this
6485 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
6486 pfd->visited, pfd->include_nondeduced_p))
6487 return error_mark_node;
6491 /* Check the return type. */
6492 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6493 pfd->include_nondeduced_p))
6494 return error_mark_node;
6496 /* Check the parameter types. Since default arguments are not
6497 instantiated until they are needed, the TYPE_ARG_TYPES may
6498 contain expressions that involve template parameters. But,
6499 no-one should be looking at them yet. And, once they're
6500 instantiated, they don't contain template parameters, so
6501 there's no point in looking at them then, either. */
6505 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
6506 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
6507 pfd->visited, pfd->include_nondeduced_p))
6508 return error_mark_node;
6510 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6511 want walk_tree walking into them itself. */
6517 if (pfd->include_nondeduced_p
6518 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
6520 pfd->include_nondeduced_p))
6521 return error_mark_node;
6526 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
6527 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
6528 pfd->visited, pfd->include_nondeduced_p))
6529 return error_mark_node;
6534 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
6535 && for_each_template_parm (DECL_INITIAL (t), fn, data,
6536 pfd->visited, pfd->include_nondeduced_p))
6537 return error_mark_node;
6538 if (DECL_CONTEXT (t)
6539 && pfd->include_nondeduced_p
6540 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
6541 pfd->visited, pfd->include_nondeduced_p))
6542 return error_mark_node;
6545 case BOUND_TEMPLATE_TEMPLATE_PARM:
6546 /* Record template parameters such as `T' inside `TT<T>'. */
6547 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
6548 pfd->include_nondeduced_p))
6549 return error_mark_node;
6552 case TEMPLATE_TEMPLATE_PARM:
6553 case TEMPLATE_TYPE_PARM:
6554 case TEMPLATE_PARM_INDEX:
6555 if (fn && (*fn)(t, data))
6556 return error_mark_node;
6558 return error_mark_node;
6562 /* A template template parameter is encountered. */
6563 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
6564 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6565 pfd->include_nondeduced_p))
6566 return error_mark_node;
6568 /* Already substituted template template parameter */
6574 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
6576 pfd->include_nondeduced_p))
6577 return error_mark_node;
6581 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
6582 && pfd->include_nondeduced_p
6583 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6584 (TREE_TYPE (t)), fn, data,
6585 pfd->visited, pfd->include_nondeduced_p))
6586 return error_mark_node;
6591 /* If there's no type, then this thing must be some expression
6592 involving template parameters. */
6593 if (!fn && !TREE_TYPE (t))
6594 return error_mark_node;
6599 case REINTERPRET_CAST_EXPR:
6600 case CONST_CAST_EXPR:
6601 case STATIC_CAST_EXPR:
6602 case DYNAMIC_CAST_EXPR:
6606 case PSEUDO_DTOR_EXPR:
6608 return error_mark_node;
6615 /* We didn't find any template parameters we liked. */
6619 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6620 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6621 call FN with the parameter and the DATA.
6622 If FN returns nonzero, the iteration is terminated, and
6623 for_each_template_parm returns 1. Otherwise, the iteration
6624 continues. If FN never returns a nonzero value, the value
6625 returned by for_each_template_parm is 0. If FN is NULL, it is
6626 considered to be the function which always returns 1.
6628 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6629 parameters that occur in non-deduced contexts. When false, only
6630 visits those template parameters that can be deduced. */
6633 for_each_template_parm (tree t, tree_fn_t fn, void* data,
6634 struct pointer_set_t *visited,
6635 bool include_nondeduced_p)
6637 struct pair_fn_data pfd;
6643 pfd.include_nondeduced_p = include_nondeduced_p;
6645 /* Walk the tree. (Conceptually, we would like to walk without
6646 duplicates, but for_each_template_parm_r recursively calls
6647 for_each_template_parm, so we would need to reorganize a fair
6648 bit to use walk_tree_without_duplicates, so we keep our own
6651 pfd.visited = visited;
6653 pfd.visited = pointer_set_create ();
6654 result = cp_walk_tree (&t,
6655 for_each_template_parm_r,
6657 pfd.visited) != NULL_TREE;
6662 pointer_set_destroy (pfd.visited);
6669 /* Returns true if T depends on any template parameter. */
6672 uses_template_parms (tree t)
6675 int saved_processing_template_decl;
6677 saved_processing_template_decl = processing_template_decl;
6678 if (!saved_processing_template_decl)
6679 processing_template_decl = 1;
6681 dependent_p = dependent_type_p (t);
6682 else if (TREE_CODE (t) == TREE_VEC)
6683 dependent_p = any_dependent_template_arguments_p (t);
6684 else if (TREE_CODE (t) == TREE_LIST)
6685 dependent_p = (uses_template_parms (TREE_VALUE (t))
6686 || uses_template_parms (TREE_CHAIN (t)));
6687 else if (TREE_CODE (t) == TYPE_DECL)
6688 dependent_p = dependent_type_p (TREE_TYPE (t));
6691 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
6692 || TREE_CODE (t) == OVERLOAD
6693 || TREE_CODE (t) == BASELINK
6694 || TREE_CODE (t) == IDENTIFIER_NODE
6695 || TREE_CODE (t) == TRAIT_EXPR
6696 || TREE_CODE (t) == CONSTRUCTOR
6697 || CONSTANT_CLASS_P (t))
6698 dependent_p = (type_dependent_expression_p (t)
6699 || value_dependent_expression_p (t));
6702 gcc_assert (t == error_mark_node);
6703 dependent_p = false;
6706 processing_template_decl = saved_processing_template_decl;
6711 /* Returns true if T depends on any template parameter with level LEVEL. */
6714 uses_template_parms_level (tree t, int level)
6716 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
6717 /*include_nondeduced_p=*/true);
6720 static int tinst_depth;
6721 extern int max_tinst_depth;
6722 #ifdef GATHER_STATISTICS
6725 static int tinst_level_tick;
6726 static int last_template_error_tick;
6728 /* We're starting to instantiate D; record the template instantiation context
6729 for diagnostics and to restore it later. */
6732 push_tinst_level (tree d)
6734 struct tinst_level *new_level;
6736 if (tinst_depth >= max_tinst_depth)
6738 /* If the instantiation in question still has unbound template parms,
6739 we don't really care if we can't instantiate it, so just return.
6740 This happens with base instantiation for implicit `typename'. */
6741 if (uses_template_parms (d))
6744 last_template_error_tick = tinst_level_tick;
6745 error ("template instantiation depth exceeds maximum of %d (use "
6746 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6747 max_tinst_depth, d);
6749 print_instantiation_context ();
6754 new_level = GGC_NEW (struct tinst_level);
6755 new_level->decl = d;
6756 new_level->locus = input_location;
6757 new_level->in_system_header_p = in_system_header;
6758 new_level->next = current_tinst_level;
6759 current_tinst_level = new_level;
6762 #ifdef GATHER_STATISTICS
6763 if (tinst_depth > depth_reached)
6764 depth_reached = tinst_depth;
6771 /* We're done instantiating this template; return to the instantiation
6775 pop_tinst_level (void)
6777 /* Restore the filename and line number stashed away when we started
6778 this instantiation. */
6779 input_location = current_tinst_level->locus;
6780 current_tinst_level = current_tinst_level->next;
6785 /* We're instantiating a deferred template; restore the template
6786 instantiation context in which the instantiation was requested, which
6787 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6790 reopen_tinst_level (struct tinst_level *level)
6792 struct tinst_level *t;
6795 for (t = level; t; t = t->next)
6798 current_tinst_level = level;
6803 /* Returns the TINST_LEVEL which gives the original instantiation
6806 struct tinst_level *
6807 outermost_tinst_level (void)
6809 struct tinst_level *level = current_tinst_level;
6812 level = level->next;
6816 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
6819 parameter_of_template_p (tree parm, tree templ)
6824 if (!parm || !templ)
6827 gcc_assert (DECL_TEMPLATE_PARM_P (parm));
6828 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
6830 parms = DECL_TEMPLATE_PARMS (templ);
6831 parms = INNERMOST_TEMPLATE_PARMS (parms);
6833 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
6834 if (parm == TREE_VALUE (TREE_VEC_ELT (parms, i)))
6840 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6841 vector of template arguments, as for tsubst.
6843 Returns an appropriate tsubst'd friend declaration. */
6846 tsubst_friend_function (tree decl, tree args)
6850 if (TREE_CODE (decl) == FUNCTION_DECL
6851 && DECL_TEMPLATE_INSTANTIATION (decl)
6852 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6853 /* This was a friend declared with an explicit template
6854 argument list, e.g.:
6858 to indicate that f was a template instantiation, not a new
6859 function declaration. Now, we have to figure out what
6860 instantiation of what template. */
6862 tree template_id, arglist, fns;
6865 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6867 /* Friend functions are looked up in the containing namespace scope.
6868 We must enter that scope, to avoid finding member functions of the
6869 current class with same name. */
6870 push_nested_namespace (ns);
6871 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6872 tf_warning_or_error, NULL_TREE,
6873 /*integral_constant_expression_p=*/false);
6874 pop_nested_namespace (ns);
6875 arglist = tsubst (DECL_TI_ARGS (decl), args,
6876 tf_warning_or_error, NULL_TREE);
6877 template_id = lookup_template_function (fns, arglist);
6879 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6880 tmpl = determine_specialization (template_id, new_friend,
6882 /*need_member_template=*/0,
6883 TREE_VEC_LENGTH (args),
6885 return instantiate_template (tmpl, new_args, tf_error);
6888 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6890 /* The NEW_FRIEND will look like an instantiation, to the
6891 compiler, but is not an instantiation from the point of view of
6892 the language. For example, we might have had:
6894 template <class T> struct S {
6895 template <class U> friend void f(T, U);
6898 Then, in S<int>, template <class U> void f(int, U) is not an
6899 instantiation of anything. */
6900 if (new_friend == error_mark_node)
6901 return error_mark_node;
6903 DECL_USE_TEMPLATE (new_friend) = 0;
6904 if (TREE_CODE (decl) == TEMPLATE_DECL)
6906 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6907 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6908 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6911 /* The mangled name for the NEW_FRIEND is incorrect. The function
6912 is not a template instantiation and should not be mangled like
6913 one. Therefore, we forget the mangling here; we'll recompute it
6914 later if we need it. */
6915 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6917 SET_DECL_RTL (new_friend, NULL_RTX);
6918 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6921 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6924 tree new_friend_template_info;
6925 tree new_friend_result_template_info;
6927 int new_friend_is_defn;
6929 /* We must save some information from NEW_FRIEND before calling
6930 duplicate decls since that function will free NEW_FRIEND if
6932 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6933 new_friend_is_defn =
6934 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6935 (template_for_substitution (new_friend)))
6937 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6939 /* This declaration is a `primary' template. */
6940 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6942 new_friend_result_template_info
6943 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6946 new_friend_result_template_info = NULL_TREE;
6948 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6949 if (new_friend_is_defn)
6950 DECL_INITIAL (new_friend) = error_mark_node;
6952 /* Inside pushdecl_namespace_level, we will push into the
6953 current namespace. However, the friend function should go
6954 into the namespace of the template. */
6955 ns = decl_namespace_context (new_friend);
6956 push_nested_namespace (ns);
6957 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6958 pop_nested_namespace (ns);
6960 if (old_decl == error_mark_node)
6961 return error_mark_node;
6963 if (old_decl != new_friend)
6965 /* This new friend declaration matched an existing
6966 declaration. For example, given:
6968 template <class T> void f(T);
6969 template <class U> class C {
6970 template <class T> friend void f(T) {}
6973 the friend declaration actually provides the definition
6974 of `f', once C has been instantiated for some type. So,
6975 old_decl will be the out-of-class template declaration,
6976 while new_friend is the in-class definition.
6978 But, if `f' was called before this point, the
6979 instantiation of `f' will have DECL_TI_ARGS corresponding
6980 to `T' but not to `U', references to which might appear
6981 in the definition of `f'. Previously, the most general
6982 template for an instantiation of `f' was the out-of-class
6983 version; now it is the in-class version. Therefore, we
6984 run through all specialization of `f', adding to their
6985 DECL_TI_ARGS appropriately. In particular, they need a
6986 new set of outer arguments, corresponding to the
6987 arguments for this class instantiation.
6989 The same situation can arise with something like this:
6992 template <class T> class C {
6996 when `C<int>' is instantiated. Now, `f(int)' is defined
6999 if (!new_friend_is_defn)
7000 /* On the other hand, if the in-class declaration does
7001 *not* provide a definition, then we don't want to alter
7002 existing definitions. We can just leave everything
7007 tree new_template = TI_TEMPLATE (new_friend_template_info);
7008 tree new_args = TI_ARGS (new_friend_template_info);
7010 /* Overwrite whatever template info was there before, if
7011 any, with the new template information pertaining to
7013 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
7015 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
7016 /* We should have called reregister_specialization in
7018 gcc_assert (retrieve_specialization (new_template,
7025 /* Indicate that the old function template is a partial
7027 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
7028 = new_friend_result_template_info;
7030 gcc_assert (new_template
7031 == most_general_template (new_template));
7032 gcc_assert (new_template != old_decl);
7034 /* Reassign any specializations already in the hash table
7035 to the new more general template, and add the
7036 additional template args. */
7037 for (t = DECL_TEMPLATE_INSTANTIATIONS (old_decl);
7041 tree spec = TREE_VALUE (t);
7044 elt.tmpl = old_decl;
7045 elt.args = DECL_TI_ARGS (spec);
7046 elt.spec = NULL_TREE;
7048 htab_remove_elt (decl_specializations, &elt);
7051 = add_outermost_template_args (new_args,
7052 DECL_TI_ARGS (spec));
7054 register_specialization
7055 (spec, new_template, DECL_TI_ARGS (spec), true, 0);
7058 DECL_TEMPLATE_INSTANTIATIONS (old_decl) = NULL_TREE;
7062 /* The information from NEW_FRIEND has been merged into OLD_DECL
7063 by duplicate_decls. */
7064 new_friend = old_decl;
7069 tree context = DECL_CONTEXT (new_friend);
7073 template <class T> class C {
7074 template <class U> friend void C1<U>::f (); // case 1
7075 friend void C2<T>::f (); // case 2
7077 we only need to make sure CONTEXT is a complete type for
7078 case 2. To distinguish between the two cases, we note that
7079 CONTEXT of case 1 remains dependent type after tsubst while
7080 this isn't true for case 2. */
7081 ++processing_template_decl;
7082 dependent_p = dependent_type_p (context);
7083 --processing_template_decl;
7086 && !complete_type_or_else (context, NULL_TREE))
7087 return error_mark_node;
7089 if (COMPLETE_TYPE_P (context))
7091 /* Check to see that the declaration is really present, and,
7092 possibly obtain an improved declaration. */
7093 tree fn = check_classfn (context,
7094 new_friend, NULL_TREE);
7104 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
7105 template arguments, as for tsubst.
7107 Returns an appropriate tsubst'd friend type or error_mark_node on
7111 tsubst_friend_class (tree friend_tmpl, tree args)
7117 context = DECL_CONTEXT (friend_tmpl);
7121 if (TREE_CODE (context) == NAMESPACE_DECL)
7122 push_nested_namespace (context);
7124 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
7127 /* Look for a class template declaration. We look for hidden names
7128 because two friend declarations of the same template are the
7129 same. For example, in:
7132 template <typename> friend class F;
7134 template <typename> struct B {
7135 template <typename> friend class F;
7138 both F templates are the same. */
7139 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
7140 /*block_p=*/true, 0,
7141 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
7143 /* But, if we don't find one, it might be because we're in a
7144 situation like this:
7152 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
7153 for `S<int>', not the TEMPLATE_DECL. */
7154 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
7156 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
7157 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
7160 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
7162 /* The friend template has already been declared. Just
7163 check to see that the declarations match, and install any new
7164 default parameters. We must tsubst the default parameters,
7165 of course. We only need the innermost template parameters
7166 because that is all that redeclare_class_template will look
7168 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
7169 > TMPL_ARGS_DEPTH (args))
7172 location_t saved_input_location;
7173 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
7174 args, tf_warning_or_error);
7176 saved_input_location = input_location;
7177 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
7178 redeclare_class_template (TREE_TYPE (tmpl), parms);
7179 input_location = saved_input_location;
7183 friend_type = TREE_TYPE (tmpl);
7187 /* The friend template has not already been declared. In this
7188 case, the instantiation of the template class will cause the
7189 injection of this template into the global scope. */
7190 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
7191 if (tmpl == error_mark_node)
7192 return error_mark_node;
7194 /* The new TMPL is not an instantiation of anything, so we
7195 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7196 the new type because that is supposed to be the corresponding
7197 template decl, i.e., TMPL. */
7198 DECL_USE_TEMPLATE (tmpl) = 0;
7199 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
7200 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
7201 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
7202 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
7204 /* Inject this template into the global scope. */
7205 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
7210 if (TREE_CODE (context) == NAMESPACE_DECL)
7211 pop_nested_namespace (context);
7213 pop_nested_class ();
7219 /* Returns zero if TYPE cannot be completed later due to circularity.
7220 Otherwise returns one. */
7223 can_complete_type_without_circularity (tree type)
7225 if (type == NULL_TREE || type == error_mark_node)
7227 else if (COMPLETE_TYPE_P (type))
7229 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
7230 return can_complete_type_without_circularity (TREE_TYPE (type));
7231 else if (CLASS_TYPE_P (type)
7232 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
7238 /* Apply any attributes which had to be deferred until instantiation
7239 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7240 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7243 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
7244 tree args, tsubst_flags_t complain, tree in_decl)
7246 tree last_dep = NULL_TREE;
7250 for (t = attributes; t; t = TREE_CHAIN (t))
7251 if (ATTR_IS_DEPENDENT (t))
7254 attributes = copy_list (attributes);
7258 if (DECL_P (*decl_p))
7260 if (TREE_TYPE (*decl_p) == error_mark_node)
7262 p = &DECL_ATTRIBUTES (*decl_p);
7265 p = &TYPE_ATTRIBUTES (*decl_p);
7269 tree late_attrs = NULL_TREE;
7270 tree *q = &late_attrs;
7272 for (*p = attributes; *p; )
7275 if (ATTR_IS_DEPENDENT (t))
7277 *p = TREE_CHAIN (t);
7278 TREE_CHAIN (t) = NULL_TREE;
7279 /* If the first attribute argument is an identifier, don't
7280 pass it through tsubst. Attributes like mode, format,
7281 cleanup and several target specific attributes expect it
7284 && TREE_CODE (TREE_VALUE (t)) == TREE_LIST
7285 && TREE_VALUE (TREE_VALUE (t))
7286 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t)))
7287 == IDENTIFIER_NODE))
7290 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain,
7292 /*integral_constant_expression_p=*/false);
7293 if (chain != TREE_CHAIN (TREE_VALUE (t)))
7295 = tree_cons (NULL_TREE, TREE_VALUE (TREE_VALUE (t)),
7300 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
7301 /*integral_constant_expression_p=*/false);
7303 q = &TREE_CHAIN (t);
7306 p = &TREE_CHAIN (t);
7309 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
7313 /* Perform (or defer) access check for typedefs that were referenced
7314 from within the template TMPL code.
7315 This is a subroutine of instantiate_template and instantiate_class_template.
7316 TMPL is the template to consider and TARGS is the list of arguments of
7320 perform_typedefs_access_check (tree tmpl, tree targs)
7325 || (!CLASS_TYPE_P (tmpl)
7326 && TREE_CODE (tmpl) != FUNCTION_DECL))
7329 for (t = get_types_needing_access_check (tmpl); t; t = TREE_CHAIN (t))
7331 tree type_decl = TREE_PURPOSE (t);
7332 tree type_scope = TREE_VALUE (t);
7334 if (!type_decl || !type_scope || !CLASS_TYPE_P (type_scope))
7337 if (uses_template_parms (type_decl))
7338 type_decl = tsubst (type_decl, targs, tf_error, NULL_TREE);
7339 if (uses_template_parms (type_scope))
7340 type_scope = tsubst (type_scope, targs, tf_error, NULL_TREE);
7342 perform_or_defer_access_check (TYPE_BINFO (type_scope),
7343 type_decl, type_decl);
7348 instantiate_class_template (tree type)
7350 tree templ, args, pattern, t, member;
7354 unsigned int saved_maximum_field_alignment;
7356 if (type == error_mark_node)
7357 return error_mark_node;
7359 if (TYPE_BEING_DEFINED (type)
7360 || COMPLETE_TYPE_P (type)
7361 || uses_template_parms (type))
7364 /* Figure out which template is being instantiated. */
7365 templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
7366 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
7368 /* Determine what specialization of the original template to
7370 t = most_specialized_class (type, templ);
7371 if (t == error_mark_node)
7373 TYPE_BEING_DEFINED (type) = 1;
7374 return error_mark_node;
7378 /* This TYPE is actually an instantiation of a partial
7379 specialization. We replace the innermost set of ARGS with
7380 the arguments appropriate for substitution. For example,
7383 template <class T> struct S {};
7384 template <class T> struct S<T*> {};
7386 and supposing that we are instantiating S<int*>, ARGS will
7387 presently be {int*} -- but we need {int}. */
7388 pattern = TREE_TYPE (t);
7389 args = TREE_PURPOSE (t);
7393 pattern = TREE_TYPE (templ);
7394 args = CLASSTYPE_TI_ARGS (type);
7397 /* If the template we're instantiating is incomplete, then clearly
7398 there's nothing we can do. */
7399 if (!COMPLETE_TYPE_P (pattern))
7402 /* If we've recursively instantiated too many templates, stop. */
7403 if (! push_tinst_level (type))
7406 /* Now we're really doing the instantiation. Mark the type as in
7407 the process of being defined. */
7408 TYPE_BEING_DEFINED (type) = 1;
7410 /* We may be in the middle of deferred access check. Disable
7412 push_deferring_access_checks (dk_no_deferred);
7414 push_to_top_level ();
7415 /* Use #pragma pack from the template context. */
7416 saved_maximum_field_alignment = maximum_field_alignment;
7417 maximum_field_alignment = TYPE_PRECISION (pattern);
7419 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
7421 /* Set the input location to the most specialized template definition.
7422 This is needed if tsubsting causes an error. */
7423 typedecl = TYPE_MAIN_DECL (pattern);
7424 input_location = DECL_SOURCE_LOCATION (typedecl);
7426 TYPE_HAS_USER_CONSTRUCTOR (type) = TYPE_HAS_USER_CONSTRUCTOR (pattern);
7427 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
7428 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
7429 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
7430 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
7431 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
7432 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
7433 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
7434 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
7435 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
7436 TYPE_PACKED (type) = TYPE_PACKED (pattern);
7437 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
7438 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
7439 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
7440 if (ANON_AGGR_TYPE_P (pattern))
7441 SET_ANON_AGGR_TYPE_P (type);
7442 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
7444 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
7445 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
7448 pbinfo = TYPE_BINFO (pattern);
7450 /* We should never instantiate a nested class before its enclosing
7451 class; we need to look up the nested class by name before we can
7452 instantiate it, and that lookup should instantiate the enclosing
7454 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
7455 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
7456 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
7458 base_list = NULL_TREE;
7459 if (BINFO_N_BASE_BINFOS (pbinfo))
7462 tree context = TYPE_CONTEXT (type);
7466 /* We must enter the scope containing the type, as that is where
7467 the accessibility of types named in dependent bases are
7469 pushed_scope = push_scope (context ? context : global_namespace);
7471 /* Substitute into each of the bases to determine the actual
7473 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
7476 tree access = BINFO_BASE_ACCESS (pbinfo, i);
7477 tree expanded_bases = NULL_TREE;
7480 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
7483 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
7484 args, tf_error, NULL_TREE);
7485 if (expanded_bases == error_mark_node)
7488 len = TREE_VEC_LENGTH (expanded_bases);
7491 for (idx = 0; idx < len; idx++)
7494 /* Extract the already-expanded base class. */
7495 base = TREE_VEC_ELT (expanded_bases, idx);
7497 /* Substitute to figure out the base class. */
7498 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
7501 if (base == error_mark_node)
7504 base_list = tree_cons (access, base, base_list);
7505 if (BINFO_VIRTUAL_P (pbase_binfo))
7506 TREE_TYPE (base_list) = integer_type_node;
7510 /* The list is now in reverse order; correct that. */
7511 base_list = nreverse (base_list);
7514 pop_scope (pushed_scope);
7516 /* Now call xref_basetypes to set up all the base-class
7518 xref_basetypes (type, base_list);
7520 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
7521 (int) ATTR_FLAG_TYPE_IN_PLACE,
7522 args, tf_error, NULL_TREE);
7524 /* Now that our base classes are set up, enter the scope of the
7525 class, so that name lookups into base classes, etc. will work
7526 correctly. This is precisely analogous to what we do in
7527 begin_class_definition when defining an ordinary non-template
7528 class, except we also need to push the enclosing classes. */
7529 push_nested_class (type);
7531 /* Now members are processed in the order of declaration. */
7532 for (member = CLASSTYPE_DECL_LIST (pattern);
7533 member; member = TREE_CHAIN (member))
7535 tree t = TREE_VALUE (member);
7537 if (TREE_PURPOSE (member))
7541 /* Build new CLASSTYPE_NESTED_UTDS. */
7544 bool class_template_p;
7546 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
7547 && TYPE_LANG_SPECIFIC (t)
7548 && CLASSTYPE_IS_TEMPLATE (t));
7549 /* If the member is a class template, then -- even after
7550 substitution -- there may be dependent types in the
7551 template argument list for the class. We increment
7552 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7553 that function will assume that no types are dependent
7554 when outside of a template. */
7555 if (class_template_p)
7556 ++processing_template_decl;
7557 newtag = tsubst (t, args, tf_error, NULL_TREE);
7558 if (class_template_p)
7559 --processing_template_decl;
7560 if (newtag == error_mark_node)
7563 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
7565 tree name = TYPE_IDENTIFIER (t);
7567 if (class_template_p)
7568 /* Unfortunately, lookup_template_class sets
7569 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7570 instantiation (i.e., for the type of a member
7571 template class nested within a template class.)
7572 This behavior is required for
7573 maybe_process_partial_specialization to work
7574 correctly, but is not accurate in this case;
7575 the TAG is not an instantiation of anything.
7576 (The corresponding TEMPLATE_DECL is an
7577 instantiation, but the TYPE is not.) */
7578 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
7580 /* Now, we call pushtag to put this NEWTAG into the scope of
7581 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7582 pushtag calling push_template_decl. We don't have to do
7583 this for enums because it will already have been done in
7586 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
7587 pushtag (name, newtag, /*tag_scope=*/ts_current);
7590 else if (TREE_CODE (t) == FUNCTION_DECL
7591 || DECL_FUNCTION_TEMPLATE_P (t))
7593 /* Build new TYPE_METHODS. */
7596 if (TREE_CODE (t) == TEMPLATE_DECL)
7597 ++processing_template_decl;
7598 r = tsubst (t, args, tf_error, NULL_TREE);
7599 if (TREE_CODE (t) == TEMPLATE_DECL)
7600 --processing_template_decl;
7601 set_current_access_from_decl (r);
7602 finish_member_declaration (r);
7606 /* Build new TYPE_FIELDS. */
7607 if (TREE_CODE (t) == STATIC_ASSERT)
7610 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
7611 tf_warning_or_error, NULL_TREE,
7612 /*integral_constant_expression_p=*/true);
7613 finish_static_assert (condition,
7614 STATIC_ASSERT_MESSAGE (t),
7615 STATIC_ASSERT_SOURCE_LOCATION (t),
7618 else if (TREE_CODE (t) != CONST_DECL)
7622 /* The file and line for this declaration, to
7623 assist in error message reporting. Since we
7624 called push_tinst_level above, we don't need to
7626 input_location = DECL_SOURCE_LOCATION (t);
7628 if (TREE_CODE (t) == TEMPLATE_DECL)
7629 ++processing_template_decl;
7630 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
7631 if (TREE_CODE (t) == TEMPLATE_DECL)
7632 --processing_template_decl;
7633 if (TREE_CODE (r) == VAR_DECL)
7637 [t]he initialization (and any associated
7638 side-effects) of a static data member does
7639 not occur unless the static data member is
7640 itself used in a way that requires the
7641 definition of the static data member to
7644 Therefore, we do not substitute into the
7645 initialized for the static data member here. */
7646 finish_static_data_member_decl
7649 /*init_const_expr_p=*/false,
7650 /*asmspec_tree=*/NULL_TREE,
7652 if (DECL_INITIALIZED_IN_CLASS_P (r))
7653 check_static_variable_definition (r, TREE_TYPE (r));
7655 else if (TREE_CODE (r) == FIELD_DECL)
7657 /* Determine whether R has a valid type and can be
7658 completed later. If R is invalid, then it is
7659 replaced by error_mark_node so that it will not be
7660 added to TYPE_FIELDS. */
7661 tree rtype = TREE_TYPE (r);
7662 if (can_complete_type_without_circularity (rtype))
7663 complete_type (rtype);
7665 if (!COMPLETE_TYPE_P (rtype))
7667 cxx_incomplete_type_error (r, rtype);
7668 r = error_mark_node;
7672 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7673 such a thing will already have been added to the field
7674 list by tsubst_enum in finish_member_declaration in the
7675 CLASSTYPE_NESTED_UTDS case above. */
7676 if (!(TREE_CODE (r) == TYPE_DECL
7677 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
7678 && DECL_ARTIFICIAL (r)))
7680 set_current_access_from_decl (r);
7681 finish_member_declaration (r);
7688 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
7690 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7692 tree friend_type = t;
7693 bool adjust_processing_template_decl = false;
7695 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7697 /* template <class T> friend class C; */
7698 friend_type = tsubst_friend_class (friend_type, args);
7699 adjust_processing_template_decl = true;
7701 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
7703 /* template <class T> friend class C::D; */
7704 friend_type = tsubst (friend_type, args,
7705 tf_warning_or_error, NULL_TREE);
7706 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7707 friend_type = TREE_TYPE (friend_type);
7708 adjust_processing_template_decl = true;
7710 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
7712 /* This could be either
7716 when dependent_type_p is false or
7718 template <class U> friend class T::C;
7721 friend_type = tsubst (friend_type, args,
7722 tf_warning_or_error, NULL_TREE);
7723 /* Bump processing_template_decl for correct
7724 dependent_type_p calculation. */
7725 ++processing_template_decl;
7726 if (dependent_type_p (friend_type))
7727 adjust_processing_template_decl = true;
7728 --processing_template_decl;
7730 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
7731 && hidden_name_p (TYPE_NAME (friend_type)))
7735 where C hasn't been declared yet. Let's lookup name
7736 from namespace scope directly, bypassing any name that
7737 come from dependent base class. */
7738 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
7740 /* The call to xref_tag_from_type does injection for friend
7742 push_nested_namespace (ns);
7744 xref_tag_from_type (friend_type, NULL_TREE,
7745 /*tag_scope=*/ts_current);
7746 pop_nested_namespace (ns);
7748 else if (uses_template_parms (friend_type))
7749 /* friend class C<T>; */
7750 friend_type = tsubst (friend_type, args,
7751 tf_warning_or_error, NULL_TREE);
7756 where C is already declared or
7758 friend class C<int>;
7760 We don't have to do anything in these cases. */
7762 if (adjust_processing_template_decl)
7763 /* Trick make_friend_class into realizing that the friend
7764 we're adding is a template, not an ordinary class. It's
7765 important that we use make_friend_class since it will
7766 perform some error-checking and output cross-reference
7768 ++processing_template_decl;
7770 if (friend_type != error_mark_node)
7771 make_friend_class (type, friend_type, /*complain=*/false);
7773 if (adjust_processing_template_decl)
7774 --processing_template_decl;
7778 /* Build new DECL_FRIENDLIST. */
7781 /* The file and line for this declaration, to
7782 assist in error message reporting. Since we
7783 called push_tinst_level above, we don't need to
7785 input_location = DECL_SOURCE_LOCATION (t);
7787 if (TREE_CODE (t) == TEMPLATE_DECL)
7789 ++processing_template_decl;
7790 push_deferring_access_checks (dk_no_check);
7793 r = tsubst_friend_function (t, args);
7794 add_friend (type, r, /*complain=*/false);
7795 if (TREE_CODE (t) == TEMPLATE_DECL)
7797 pop_deferring_access_checks ();
7798 --processing_template_decl;
7804 /* Set the file and line number information to whatever is given for
7805 the class itself. This puts error messages involving generated
7806 implicit functions at a predictable point, and the same point
7807 that would be used for non-template classes. */
7808 input_location = DECL_SOURCE_LOCATION (typedecl);
7810 unreverse_member_declarations (type);
7811 finish_struct_1 (type);
7812 TYPE_BEING_DEFINED (type) = 0;
7814 /* Now that the class is complete, instantiate default arguments for
7815 any member functions. We don't do this earlier because the
7816 default arguments may reference members of the class. */
7817 if (!PRIMARY_TEMPLATE_P (templ))
7818 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
7819 if (TREE_CODE (t) == FUNCTION_DECL
7820 /* Implicitly generated member functions will not have template
7821 information; they are not instantiations, but instead are
7822 created "fresh" for each instantiation. */
7823 && DECL_TEMPLATE_INFO (t))
7824 tsubst_default_arguments (t);
7826 /* Some typedefs referenced from within the template code need to be access
7827 checked at template instantiation time, i.e now. These types were
7828 added to the template at parsing time. Let's get those and perform
7829 the access checks then. */
7830 perform_typedefs_access_check (pattern, args);
7831 perform_deferred_access_checks ();
7832 pop_nested_class ();
7833 maximum_field_alignment = saved_maximum_field_alignment;
7834 pop_from_top_level ();
7835 pop_deferring_access_checks ();
7838 /* The vtable for a template class can be emitted in any translation
7839 unit in which the class is instantiated. When there is no key
7840 method, however, finish_struct_1 will already have added TYPE to
7841 the keyed_classes list. */
7842 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
7843 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
7849 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7855 else if (TYPE_P (t))
7856 r = tsubst (t, args, complain, in_decl);
7859 r = tsubst_expr (t, args, complain, in_decl,
7860 /*integral_constant_expression_p=*/true);
7861 r = fold_non_dependent_expr (r);
7866 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
7867 NONTYPE_ARGUMENT_PACK. */
7870 make_fnparm_pack (tree spec_parm)
7872 /* Collect all of the extra "packed" parameters into an
7876 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
7877 tree argtypepack = cxx_make_type (TYPE_ARGUMENT_PACK);
7878 int i, len = list_length (spec_parm);
7880 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
7881 parmvec = make_tree_vec (len);
7882 parmtypevec = make_tree_vec (len);
7883 for (i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
7885 TREE_VEC_ELT (parmvec, i) = spec_parm;
7886 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
7889 /* Build the argument packs. */
7890 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
7891 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
7892 TREE_TYPE (argpack) = argtypepack;
7897 /* Substitute ARGS into T, which is an pack expansion
7898 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7899 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7900 (if only a partial substitution could be performed) or
7901 ERROR_MARK_NODE if there was an error. */
7903 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
7907 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
7908 tree first_arg_pack; int i, len = -1;
7911 bool very_local_specializations = false;
7913 gcc_assert (PACK_EXPANSION_P (t));
7914 pattern = PACK_EXPANSION_PATTERN (t);
7916 /* Determine the argument packs that will instantiate the parameter
7917 packs used in the expansion expression. While we're at it,
7918 compute the number of arguments to be expanded and make sure it
7920 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
7921 pack = TREE_CHAIN (pack))
7923 tree parm_pack = TREE_VALUE (pack);
7924 tree arg_pack = NULL_TREE;
7925 tree orig_arg = NULL_TREE;
7927 if (TREE_CODE (parm_pack) == PARM_DECL)
7929 arg_pack = retrieve_local_specialization (parm_pack);
7930 if (arg_pack == NULL_TREE)
7932 /* This can happen for a parameter name used later in a function
7933 declaration (such as in a late-specified return type). Just
7934 make a dummy decl, since it's only used for its type. */
7935 gcc_assert (cp_unevaluated_operand != 0);
7936 arg_pack = tsubst_decl (parm_pack, args, complain);
7937 arg_pack = make_fnparm_pack (arg_pack);
7942 int level, idx, levels;
7943 template_parm_level_and_index (parm_pack, &level, &idx);
7945 levels = TMPL_ARGS_DEPTH (args);
7946 if (level <= levels)
7947 arg_pack = TMPL_ARG (args, level, idx);
7950 orig_arg = arg_pack;
7951 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
7952 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
7954 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
7955 /* This can only happen if we forget to expand an argument
7956 pack somewhere else. Just return an error, silently. */
7958 result = make_tree_vec (1);
7959 TREE_VEC_ELT (result, 0) = error_mark_node;
7964 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
7965 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
7967 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
7968 tree pattern = PACK_EXPANSION_PATTERN (expansion);
7969 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
7970 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
7971 /* The argument pack that the parameter maps to is just an
7972 expansion of the parameter itself, such as one would
7973 find in the implicit typedef of a class inside the
7974 class itself. Consider this parameter "unsubstituted",
7975 so that we will maintain the outer pack expansion. */
7976 arg_pack = NULL_TREE;
7982 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7984 /* It's all-or-nothing with incomplete argument packs. */
7985 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7986 return error_mark_node;
7988 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7994 first_arg_pack = arg_pack;
7996 else if (len != my_len)
7999 /* We got explicit args for some packs but not others;
8000 do nothing now and try again after deduction. */
8002 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
8003 error ("mismatched argument pack lengths while expanding "
8007 error ("mismatched argument pack lengths while expanding "
8010 return error_mark_node;
8013 /* Keep track of the parameter packs and their corresponding
8015 packs = tree_cons (parm_pack, arg_pack, packs);
8016 TREE_TYPE (packs) = orig_arg;
8019 /* We can't substitute for this parameter pack. */
8020 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
8022 unsubstituted_packs);
8025 /* We cannot expand this expansion expression, because we don't have
8026 all of the argument packs we need. Substitute into the pattern
8027 and return a PACK_EXPANSION_*. The caller will need to deal with
8029 if (unsubstituted_packs)
8032 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
8033 new_pat = tsubst_expr (pattern, args, complain, in_decl,
8034 /*integral_constant_expression_p=*/false);
8036 new_pat = tsubst (pattern, args, complain, in_decl);
8037 return make_pack_expansion (new_pat);
8040 /* We could not find any argument packs that work. */
8042 return error_mark_node;
8044 if (!local_specializations)
8046 /* We're in a late-specified return type, so we don't have a local
8047 specializations table. Create one for doing this expansion. */
8048 very_local_specializations = true;
8049 local_specializations = htab_create (37,
8050 hash_local_specialization,
8051 eq_local_specializations,
8055 /* For each argument in each argument pack, substitute into the
8057 result = make_tree_vec (len + incomplete);
8058 for (i = 0; i < len + incomplete; ++i)
8060 /* For parameter pack, change the substitution of the parameter
8061 pack to the ith argument in its argument pack, then expand
8063 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8065 tree parm = TREE_PURPOSE (pack);
8067 if (TREE_CODE (parm) == PARM_DECL)
8069 /* Select the Ith argument from the pack. */
8070 tree arg = make_node (ARGUMENT_PACK_SELECT);
8071 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
8072 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
8074 register_local_specialization (arg, parm);
8080 template_parm_level_and_index (parm, &level, &idx);
8084 /* Select the Ith argument from the pack. */
8085 value = make_node (ARGUMENT_PACK_SELECT);
8086 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
8087 ARGUMENT_PACK_SELECT_INDEX (value) = i;
8090 /* Update the corresponding argument. */
8091 TMPL_ARG (args, level, idx) = value;
8095 /* Substitute into the PATTERN with the altered arguments. */
8096 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
8097 TREE_VEC_ELT (result, i) =
8098 tsubst_expr (pattern, args, complain, in_decl,
8099 /*integral_constant_expression_p=*/false);
8101 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
8104 /* When we have incomplete argument packs, the last "expanded"
8105 result is itself a pack expansion, which allows us
8106 to deduce more arguments. */
8107 TREE_VEC_ELT (result, i) =
8108 make_pack_expansion (TREE_VEC_ELT (result, i));
8110 if (TREE_VEC_ELT (result, i) == error_mark_node)
8112 result = error_mark_node;
8117 /* Update ARGS to restore the substitution from parameter packs to
8118 their argument packs. */
8119 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8121 tree parm = TREE_PURPOSE (pack);
8123 if (TREE_CODE (parm) == PARM_DECL)
8124 register_local_specialization (TREE_TYPE (pack), parm);
8128 template_parm_level_and_index (parm, &level, &idx);
8130 /* Update the corresponding argument. */
8131 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
8132 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
8135 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
8139 if (very_local_specializations)
8141 htab_delete (local_specializations);
8142 local_specializations = NULL;
8148 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
8149 TMPL. We do this using DECL_PARM_INDEX, which should work even with
8150 parameter packs; all parms generated from a function parameter pack will
8151 have the same DECL_PARM_INDEX. */
8154 get_pattern_parm (tree parm, tree tmpl)
8156 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
8159 if (DECL_ARTIFICIAL (parm))
8161 for (patparm = DECL_ARGUMENTS (pattern);
8162 patparm; patparm = TREE_CHAIN (patparm))
8163 if (DECL_ARTIFICIAL (patparm)
8164 && DECL_NAME (parm) == DECL_NAME (patparm))
8169 patparm = FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl));
8170 patparm = chain_index (DECL_PARM_INDEX (parm)-1, patparm);
8171 gcc_assert (DECL_PARM_INDEX (patparm)
8172 == DECL_PARM_INDEX (parm));
8178 /* Substitute ARGS into the vector or list of template arguments T. */
8181 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8184 int len = TREE_VEC_LENGTH (t);
8185 int need_new = 0, i, expanded_len_adjust = 0, out;
8186 tree *elts = (tree *) alloca (len * sizeof (tree));
8188 for (i = 0; i < len; i++)
8190 tree orig_arg = TREE_VEC_ELT (t, i);
8193 if (TREE_CODE (orig_arg) == TREE_VEC)
8194 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
8195 else if (PACK_EXPANSION_P (orig_arg))
8197 /* Substitute into an expansion expression. */
8198 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
8200 if (TREE_CODE (new_arg) == TREE_VEC)
8201 /* Add to the expanded length adjustment the number of
8202 expanded arguments. We subtract one from this
8203 measurement, because the argument pack expression
8204 itself is already counted as 1 in
8205 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
8206 the argument pack is empty. */
8207 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
8209 else if (ARGUMENT_PACK_P (orig_arg))
8211 /* Substitute into each of the arguments. */
8212 new_arg = TYPE_P (orig_arg)
8213 ? cxx_make_type (TREE_CODE (orig_arg))
8214 : make_node (TREE_CODE (orig_arg));
8216 SET_ARGUMENT_PACK_ARGS (
8218 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
8219 args, complain, in_decl));
8221 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
8222 new_arg = error_mark_node;
8224 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
8225 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
8227 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
8229 if (TREE_TYPE (new_arg) == error_mark_node)
8230 new_arg = error_mark_node;
8234 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
8236 if (new_arg == error_mark_node)
8237 return error_mark_node;
8240 if (new_arg != orig_arg)
8247 /* Make space for the expanded arguments coming from template
8249 t = make_tree_vec (len + expanded_len_adjust);
8250 for (i = 0, out = 0; i < len; i++)
8252 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
8253 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
8254 && TREE_CODE (elts[i]) == TREE_VEC)
8258 /* Now expand the template argument pack "in place". */
8259 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
8260 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
8264 TREE_VEC_ELT (t, out) = elts[i];
8272 /* Return the result of substituting ARGS into the template parameters
8273 given by PARMS. If there are m levels of ARGS and m + n levels of
8274 PARMS, then the result will contain n levels of PARMS. For
8275 example, if PARMS is `template <class T> template <class U>
8276 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8277 result will be `template <int*, double, class V>'. */
8280 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
8285 /* When substituting into a template, we must set
8286 PROCESSING_TEMPLATE_DECL as the template parameters may be
8287 dependent if they are based on one-another, and the dependency
8288 predicates are short-circuit outside of templates. */
8289 ++processing_template_decl;
8291 for (new_parms = &r;
8292 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
8293 new_parms = &(TREE_CHAIN (*new_parms)),
8294 parms = TREE_CHAIN (parms))
8297 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
8300 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
8306 if (parms == error_mark_node)
8309 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
8311 if (tuple == error_mark_node)
8314 default_value = TREE_PURPOSE (tuple);
8315 parm_decl = TREE_VALUE (tuple);
8317 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
8318 if (TREE_CODE (parm_decl) == PARM_DECL
8319 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
8320 parm_decl = error_mark_node;
8321 default_value = tsubst_template_arg (default_value, args,
8322 complain, NULL_TREE);
8324 tuple = build_tree_list (default_value, parm_decl);
8325 TREE_VEC_ELT (new_vec, i) = tuple;
8329 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
8330 - TMPL_ARGS_DEPTH (args)),
8331 new_vec, NULL_TREE);
8334 --processing_template_decl;
8339 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8340 type T. If T is not an aggregate or enumeration type, it is
8341 handled as if by tsubst. IN_DECL is as for tsubst. If
8342 ENTERING_SCOPE is nonzero, T is the context for a template which
8343 we are presently tsubst'ing. Return the substituted value. */
8346 tsubst_aggr_type (tree t,
8348 tsubst_flags_t complain,
8355 switch (TREE_CODE (t))
8358 if (TYPE_PTRMEMFUNC_P (t))
8359 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
8361 /* Else fall through. */
8364 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
8369 int saved_unevaluated_operand;
8370 int saved_inhibit_evaluation_warnings;
8372 /* In "sizeof(X<I>)" we need to evaluate "I". */
8373 saved_unevaluated_operand = cp_unevaluated_operand;
8374 cp_unevaluated_operand = 0;
8375 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
8376 c_inhibit_evaluation_warnings = 0;
8378 /* First, determine the context for the type we are looking
8380 context = TYPE_CONTEXT (t);
8383 context = tsubst_aggr_type (context, args, complain,
8384 in_decl, /*entering_scope=*/1);
8385 /* If context is a nested class inside a class template,
8386 it may still need to be instantiated (c++/33959). */
8387 if (TYPE_P (context))
8388 context = complete_type (context);
8391 /* Then, figure out what arguments are appropriate for the
8392 type we are trying to find. For example, given:
8394 template <class T> struct S;
8395 template <class T, class U> void f(T, U) { S<U> su; }
8397 and supposing that we are instantiating f<int, double>,
8398 then our ARGS will be {int, double}, but, when looking up
8399 S we only want {double}. */
8400 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
8402 if (argvec == error_mark_node)
8403 r = error_mark_node;
8406 r = lookup_template_class (t, argvec, in_decl, context,
8407 entering_scope, complain);
8408 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
8411 cp_unevaluated_operand = saved_unevaluated_operand;
8412 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
8417 /* This is not a template type, so there's nothing to do. */
8421 return tsubst (t, args, complain, in_decl);
8425 /* Substitute into the default argument ARG (a default argument for
8426 FN), which has the indicated TYPE. */
8429 tsubst_default_argument (tree fn, tree type, tree arg)
8431 tree saved_class_ptr = NULL_TREE;
8432 tree saved_class_ref = NULL_TREE;
8434 /* This default argument came from a template. Instantiate the
8435 default argument here, not in tsubst. In the case of
8444 we must be careful to do name lookup in the scope of S<T>,
8445 rather than in the current class. */
8446 push_access_scope (fn);
8447 /* The "this" pointer is not valid in a default argument. */
8450 saved_class_ptr = current_class_ptr;
8451 cp_function_chain->x_current_class_ptr = NULL_TREE;
8452 saved_class_ref = current_class_ref;
8453 cp_function_chain->x_current_class_ref = NULL_TREE;
8456 push_deferring_access_checks(dk_no_deferred);
8457 /* The default argument expression may cause implicitly defined
8458 member functions to be synthesized, which will result in garbage
8459 collection. We must treat this situation as if we were within
8460 the body of function so as to avoid collecting live data on the
8463 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
8464 tf_warning_or_error, NULL_TREE,
8465 /*integral_constant_expression_p=*/false);
8467 pop_deferring_access_checks();
8469 /* Restore the "this" pointer. */
8472 cp_function_chain->x_current_class_ptr = saved_class_ptr;
8473 cp_function_chain->x_current_class_ref = saved_class_ref;
8476 /* Make sure the default argument is reasonable. */
8477 arg = check_default_argument (type, arg);
8479 pop_access_scope (fn);
8484 /* Substitute into all the default arguments for FN. */
8487 tsubst_default_arguments (tree fn)
8492 tmpl_args = DECL_TI_ARGS (fn);
8494 /* If this function is not yet instantiated, we certainly don't need
8495 its default arguments. */
8496 if (uses_template_parms (tmpl_args))
8499 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
8501 arg = TREE_CHAIN (arg))
8502 if (TREE_PURPOSE (arg))
8503 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
8505 TREE_PURPOSE (arg));
8508 /* Substitute the ARGS into the T, which is a _DECL. Return the
8509 result of the substitution. Issue error and warning messages under
8510 control of COMPLAIN. */
8513 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
8515 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
8516 location_t saved_loc;
8521 /* Set the filename and linenumber to improve error-reporting. */
8522 saved_loc = input_location;
8523 input_location = DECL_SOURCE_LOCATION (t);
8525 switch (TREE_CODE (t))
8529 /* We can get here when processing a member function template,
8530 member class template, or template template parameter. */
8531 tree decl = DECL_TEMPLATE_RESULT (t);
8536 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8538 /* Template template parameter is treated here. */
8539 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8540 if (new_type == error_mark_node)
8541 RETURN (error_mark_node);
8544 TREE_CHAIN (r) = NULL_TREE;
8545 TREE_TYPE (r) = new_type;
8546 DECL_TEMPLATE_RESULT (r)
8547 = build_decl (DECL_SOURCE_LOCATION (decl),
8548 TYPE_DECL, DECL_NAME (decl), new_type);
8549 DECL_TEMPLATE_PARMS (r)
8550 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8552 TYPE_NAME (new_type) = r;
8556 /* We might already have an instance of this template.
8557 The ARGS are for the surrounding class type, so the
8558 full args contain the tsubst'd args for the context,
8559 plus the innermost args from the template decl. */
8560 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
8561 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
8562 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
8563 /* Because this is a template, the arguments will still be
8564 dependent, even after substitution. If
8565 PROCESSING_TEMPLATE_DECL is not set, the dependency
8566 predicates will short-circuit. */
8567 ++processing_template_decl;
8568 full_args = tsubst_template_args (tmpl_args, args,
8570 --processing_template_decl;
8571 if (full_args == error_mark_node)
8572 RETURN (error_mark_node);
8574 /* If this is a default template template argument,
8575 tsubst might not have changed anything. */
8576 if (full_args == tmpl_args)
8579 hash = hash_tmpl_and_args (t, full_args);
8580 spec = retrieve_specialization (t, full_args, hash);
8581 if (spec != NULL_TREE)
8587 /* Make a new template decl. It will be similar to the
8588 original, but will record the current template arguments.
8589 We also create a new function declaration, which is just
8590 like the old one, but points to this new template, rather
8591 than the old one. */
8593 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
8594 TREE_CHAIN (r) = NULL_TREE;
8596 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
8598 if (TREE_CODE (decl) == TYPE_DECL)
8601 ++processing_template_decl;
8602 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8603 --processing_template_decl;
8604 if (new_type == error_mark_node)
8605 RETURN (error_mark_node);
8607 TREE_TYPE (r) = new_type;
8608 CLASSTYPE_TI_TEMPLATE (new_type) = r;
8609 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
8610 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
8611 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
8616 ++processing_template_decl;
8617 new_decl = tsubst (decl, args, complain, in_decl);
8618 --processing_template_decl;
8619 if (new_decl == error_mark_node)
8620 RETURN (error_mark_node);
8622 DECL_TEMPLATE_RESULT (r) = new_decl;
8623 DECL_TI_TEMPLATE (new_decl) = r;
8624 TREE_TYPE (r) = TREE_TYPE (new_decl);
8625 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
8626 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
8629 SET_DECL_IMPLICIT_INSTANTIATION (r);
8630 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
8631 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
8633 /* The template parameters for this new template are all the
8634 template parameters for the old template, except the
8635 outermost level of parameters. */
8636 DECL_TEMPLATE_PARMS (r)
8637 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8640 if (PRIMARY_TEMPLATE_P (t))
8641 DECL_PRIMARY_TEMPLATE (r) = r;
8643 if (TREE_CODE (decl) != TYPE_DECL)
8644 /* Record this non-type partial instantiation. */
8645 register_specialization (r, t,
8646 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
8654 tree argvec = NULL_TREE;
8662 /* Nobody should be tsubst'ing into non-template functions. */
8663 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
8665 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
8670 /* If T is not dependent, just return it. We have to
8671 increment PROCESSING_TEMPLATE_DECL because
8672 value_dependent_expression_p assumes that nothing is
8673 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8674 ++processing_template_decl;
8675 dependent_p = value_dependent_expression_p (t);
8676 --processing_template_decl;
8680 /* Calculate the most general template of which R is a
8681 specialization, and the complete set of arguments used to
8683 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
8684 argvec = tsubst_template_args (DECL_TI_ARGS
8685 (DECL_TEMPLATE_RESULT (gen_tmpl)),
8686 args, complain, in_decl);
8688 /* Check to see if we already have this specialization. */
8689 hash = hash_tmpl_and_args (gen_tmpl, argvec);
8690 spec = retrieve_specialization (gen_tmpl, argvec, hash);
8698 /* We can see more levels of arguments than parameters if
8699 there was a specialization of a member template, like
8702 template <class T> struct S { template <class U> void f(); }
8703 template <> template <class U> void S<int>::f(U);
8705 Here, we'll be substituting into the specialization,
8706 because that's where we can find the code we actually
8707 want to generate, but we'll have enough arguments for
8708 the most general template.
8710 We also deal with the peculiar case:
8712 template <class T> struct S {
8713 template <class U> friend void f();
8715 template <class U> void f() {}
8717 template void f<double>();
8719 Here, the ARGS for the instantiation of will be {int,
8720 double}. But, we only need as many ARGS as there are
8721 levels of template parameters in CODE_PATTERN. We are
8722 careful not to get fooled into reducing the ARGS in
8725 template <class T> struct S { template <class U> void f(U); }
8726 template <class T> template <> void S<T>::f(int) {}
8728 which we can spot because the pattern will be a
8729 specialization in this case. */
8730 args_depth = TMPL_ARGS_DEPTH (args);
8732 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
8733 if (args_depth > parms_depth
8734 && !DECL_TEMPLATE_SPECIALIZATION (t))
8735 args = get_innermost_template_args (args, parms_depth);
8739 /* This special case arises when we have something like this:
8741 template <class T> struct S {
8742 friend void f<int>(int, double);
8745 Here, the DECL_TI_TEMPLATE for the friend declaration
8746 will be an IDENTIFIER_NODE. We are being called from
8747 tsubst_friend_function, and we want only to create a
8748 new decl (R) with appropriate types so that we can call
8749 determine_specialization. */
8750 gen_tmpl = NULL_TREE;
8753 if (DECL_CLASS_SCOPE_P (t))
8755 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
8759 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
8760 complain, t, /*entering_scope=*/1);
8765 ctx = DECL_CONTEXT (t);
8767 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8768 if (type == error_mark_node)
8769 RETURN (error_mark_node);
8771 /* We do NOT check for matching decls pushed separately at this
8772 point, as they may not represent instantiations of this
8773 template, and in any case are considered separate under the
8776 DECL_USE_TEMPLATE (r) = 0;
8777 TREE_TYPE (r) = type;
8778 /* Clear out the mangled name and RTL for the instantiation. */
8779 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8780 SET_DECL_RTL (r, NULL_RTX);
8781 /* Leave DECL_INITIAL set on deleted instantiations. */
8782 if (!DECL_DELETED_FN (r))
8783 DECL_INITIAL (r) = NULL_TREE;
8784 DECL_CONTEXT (r) = ctx;
8786 if (member && DECL_CONV_FN_P (r))
8787 /* Type-conversion operator. Reconstruct the name, in
8788 case it's the name of one of the template's parameters. */
8789 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
8791 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
8793 DECL_RESULT (r) = NULL_TREE;
8795 TREE_STATIC (r) = 0;
8796 TREE_PUBLIC (r) = TREE_PUBLIC (t);
8797 DECL_EXTERNAL (r) = 1;
8798 /* If this is an instantiation of a function with internal
8799 linkage, we already know what object file linkage will be
8800 assigned to the instantiation. */
8801 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
8802 DECL_DEFER_OUTPUT (r) = 0;
8803 TREE_CHAIN (r) = NULL_TREE;
8804 DECL_PENDING_INLINE_INFO (r) = 0;
8805 DECL_PENDING_INLINE_P (r) = 0;
8806 DECL_SAVED_TREE (r) = NULL_TREE;
8807 DECL_STRUCT_FUNCTION (r) = NULL;
8809 /* We'll re-clone as appropriate in instantiate_template. */
8810 DECL_CLONED_FUNCTION (r) = NULL_TREE;
8812 /* If we aren't complaining now, return on error before we register
8813 the specialization so that we'll complain eventually. */
8814 if ((complain & tf_error) == 0
8815 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
8816 && !grok_op_properties (r, /*complain=*/false))
8817 RETURN (error_mark_node);
8819 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8820 this in the special friend case mentioned above where
8821 GEN_TMPL is NULL. */
8824 DECL_TEMPLATE_INFO (r)
8825 = tree_cons (gen_tmpl, argvec, NULL_TREE);
8826 SET_DECL_IMPLICIT_INSTANTIATION (r);
8827 register_specialization (r, gen_tmpl, argvec, false, hash);
8829 /* We're not supposed to instantiate default arguments
8830 until they are called, for a template. But, for a
8833 template <class T> void f ()
8834 { extern void g(int i = T()); }
8836 we should do the substitution when the template is
8837 instantiated. We handle the member function case in
8838 instantiate_class_template since the default arguments
8839 might refer to other members of the class. */
8841 && !PRIMARY_TEMPLATE_P (gen_tmpl)
8842 && !uses_template_parms (argvec))
8843 tsubst_default_arguments (r);
8846 DECL_TEMPLATE_INFO (r) = NULL_TREE;
8848 /* Copy the list of befriending classes. */
8849 for (friends = &DECL_BEFRIENDING_CLASSES (r);
8851 friends = &TREE_CHAIN (*friends))
8853 *friends = copy_node (*friends);
8854 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
8859 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
8861 maybe_retrofit_in_chrg (r);
8862 if (DECL_CONSTRUCTOR_P (r))
8863 grok_ctor_properties (ctx, r);
8864 /* If this is an instantiation of a member template, clone it.
8865 If it isn't, that'll be handled by
8866 clone_constructors_and_destructors. */
8867 if (PRIMARY_TEMPLATE_P (gen_tmpl))
8868 clone_function_decl (r, /*update_method_vec_p=*/0);
8870 else if ((complain & tf_error) != 0
8871 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
8872 && !grok_op_properties (r, /*complain=*/true))
8873 RETURN (error_mark_node);
8875 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
8876 SET_DECL_FRIEND_CONTEXT (r,
8877 tsubst (DECL_FRIEND_CONTEXT (t),
8878 args, complain, in_decl));
8880 /* Possibly limit visibility based on template args. */
8881 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8882 if (DECL_VISIBILITY_SPECIFIED (t))
8884 DECL_VISIBILITY_SPECIFIED (r) = 0;
8886 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8888 determine_visibility (r);
8889 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r)
8890 && !processing_template_decl)
8891 defaulted_late_check (r);
8893 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8894 args, complain, in_decl);
8900 tree type = NULL_TREE;
8902 tree expanded_types = NULL_TREE;
8903 tree prev_r = NULL_TREE;
8904 tree first_r = NULL_TREE;
8906 if (FUNCTION_PARAMETER_PACK_P (t))
8908 /* If there is a local specialization that isn't a
8909 parameter pack, it means that we're doing a "simple"
8910 substitution from inside tsubst_pack_expansion. Just
8911 return the local specialization (which will be a single
8913 tree spec = retrieve_local_specialization (t);
8915 && TREE_CODE (spec) == PARM_DECL
8916 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
8919 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8920 the parameters in this function parameter pack. */
8921 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
8923 if (TREE_CODE (expanded_types) == TREE_VEC)
8925 len = TREE_VEC_LENGTH (expanded_types);
8927 /* Zero-length parameter packs are boring. Just substitute
8930 RETURN (tsubst (TREE_CHAIN (t), args, complain,
8935 /* All we did was update the type. Make a note of that. */
8936 type = expanded_types;
8937 expanded_types = NULL_TREE;
8941 /* Loop through all of the parameter's we'll build. When T is
8942 a function parameter pack, LEN is the number of expanded
8943 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8945 for (i = 0; i < len; ++i)
8949 if (DECL_TEMPLATE_PARM_P (t))
8950 SET_DECL_TEMPLATE_PARM_P (r);
8952 /* An argument of a function parameter pack is not a parameter
8954 FUNCTION_PARAMETER_PACK_P (r) = false;
8957 /* We're on the Ith parameter of the function parameter
8960 /* Get the Ith type. */
8961 type = TREE_VEC_ELT (expanded_types, i);
8964 /* Rename the parameter to include the index. */
8966 make_ith_pack_parameter_name (DECL_NAME (r), i);
8969 /* We're dealing with a normal parameter. */
8970 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8972 type = type_decays_to (type);
8973 TREE_TYPE (r) = type;
8974 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8976 if (DECL_INITIAL (r))
8978 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
8979 DECL_INITIAL (r) = TREE_TYPE (r);
8981 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
8985 DECL_CONTEXT (r) = NULL_TREE;
8987 if (!DECL_TEMPLATE_PARM_P (r))
8988 DECL_ARG_TYPE (r) = type_passed_as (type);
8990 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8991 args, complain, in_decl);
8993 /* Keep track of the first new parameter we
8994 generate. That's what will be returned to the
8999 /* Build a proper chain of parameters when substituting
9000 into a function parameter pack. */
9002 TREE_CHAIN (prev_r) = r;
9006 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
9007 complain, TREE_CHAIN (t));
9009 /* FIRST_R contains the start of the chain we've built. */
9019 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9020 if (type == error_mark_node)
9021 RETURN (error_mark_node);
9022 TREE_TYPE (r) = type;
9023 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9025 /* DECL_INITIAL gives the number of bits in a bit-field. */
9027 = tsubst_expr (DECL_INITIAL (t), args,
9029 /*integral_constant_expression_p=*/true);
9030 /* We don't have to set DECL_CONTEXT here; it is set by
9031 finish_member_declaration. */
9032 TREE_CHAIN (r) = NULL_TREE;
9033 if (VOID_TYPE_P (type))
9034 error ("instantiation of %q+D as type %qT", r, type);
9036 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
9037 args, complain, in_decl);
9042 /* We reach here only for member using decls. */
9043 if (DECL_DEPENDENT_P (t))
9045 r = do_class_using_decl
9046 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
9047 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
9049 r = error_mark_node;
9052 TREE_PROTECTED (r) = TREE_PROTECTED (t);
9053 TREE_PRIVATE (r) = TREE_PRIVATE (t);
9059 TREE_CHAIN (r) = NULL_TREE;
9066 tree argvec = NULL_TREE;
9067 tree gen_tmpl = NULL_TREE;
9069 tree tmpl = NULL_TREE;
9071 tree type = NULL_TREE;
9074 if (TREE_CODE (t) == TYPE_DECL
9075 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
9077 /* If this is the canonical decl, we don't have to
9078 mess with instantiations, and often we can't (for
9079 typename, template type parms and such). Note that
9080 TYPE_NAME is not correct for the above test if
9081 we've copied the type for a typedef. */
9082 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9083 if (type == error_mark_node)
9084 RETURN (error_mark_node);
9085 r = TYPE_NAME (type);
9089 /* Check to see if we already have the specialization we
9092 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
9094 /* T is a static data member or namespace-scope entity.
9095 We have to substitute into namespace-scope variables
9096 (even though such entities are never templates) because
9099 template <class T> void f() { extern T t; }
9101 where the entity referenced is not known until
9102 instantiation time. */
9104 ctx = DECL_CONTEXT (t);
9105 if (DECL_CLASS_SCOPE_P (t))
9107 ctx = tsubst_aggr_type (ctx, args,
9109 in_decl, /*entering_scope=*/1);
9110 /* If CTX is unchanged, then T is in fact the
9111 specialization we want. That situation occurs when
9112 referencing a static data member within in its own
9113 class. We can use pointer equality, rather than
9114 same_type_p, because DECL_CONTEXT is always
9116 if (ctx == DECL_CONTEXT (t))
9122 tmpl = DECL_TI_TEMPLATE (t);
9123 gen_tmpl = most_general_template (tmpl);
9124 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
9125 hash = hash_tmpl_and_args (gen_tmpl, argvec);
9126 spec = retrieve_specialization (gen_tmpl, argvec, hash);
9131 /* A local variable. */
9133 /* Subsequent calls to pushdecl will fill this in. */
9135 spec = retrieve_local_specialization (t);
9137 /* If we already have the specialization we need, there is
9138 nothing more to do. */
9145 /* Create a new node for the specialization we need. */
9147 if (type == NULL_TREE)
9148 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9149 if (TREE_CODE (r) == VAR_DECL)
9151 /* Even if the original location is out of scope, the
9152 newly substituted one is not. */
9153 DECL_DEAD_FOR_LOCAL (r) = 0;
9154 DECL_INITIALIZED_P (r) = 0;
9155 DECL_TEMPLATE_INSTANTIATED (r) = 0;
9156 if (type == error_mark_node)
9157 RETURN (error_mark_node);
9158 if (TREE_CODE (type) == FUNCTION_TYPE)
9160 /* It may seem that this case cannot occur, since:
9165 declares a function, not a variable. However:
9168 template <typename T> void g() { T t; }
9169 template void g<f>();
9171 is an attempt to declare a variable with function
9173 error ("variable %qD has function type",
9174 /* R is not yet sufficiently initialized, so we
9175 just use its name. */
9177 RETURN (error_mark_node);
9179 type = complete_type (type);
9180 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
9181 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
9182 type = check_var_type (DECL_NAME (r), type);
9184 if (DECL_HAS_VALUE_EXPR_P (t))
9186 tree ve = DECL_VALUE_EXPR (t);
9187 ve = tsubst_expr (ve, args, complain, in_decl,
9188 /*constant_expression_p=*/false);
9189 SET_DECL_VALUE_EXPR (r, ve);
9192 else if (DECL_SELF_REFERENCE_P (t))
9193 SET_DECL_SELF_REFERENCE_P (r);
9194 TREE_TYPE (r) = type;
9195 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9196 DECL_CONTEXT (r) = ctx;
9197 /* Clear out the mangled name and RTL for the instantiation. */
9198 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
9199 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9200 SET_DECL_RTL (r, NULL_RTX);
9201 /* The initializer must not be expanded until it is required;
9203 DECL_INITIAL (r) = NULL_TREE;
9204 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9205 SET_DECL_RTL (r, NULL_RTX);
9206 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
9207 if (TREE_CODE (r) == VAR_DECL)
9209 /* Possibly limit visibility based on template args. */
9210 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
9211 if (DECL_VISIBILITY_SPECIFIED (t))
9213 DECL_VISIBILITY_SPECIFIED (r) = 0;
9215 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
9217 determine_visibility (r);
9219 /* Preserve a typedef that names a type. */
9220 else if (TREE_CODE (r) == TYPE_DECL
9221 && DECL_ORIGINAL_TYPE (t)
9222 && type != error_mark_node)
9224 DECL_ORIGINAL_TYPE (r) = tsubst (DECL_ORIGINAL_TYPE (t),
9225 args, complain, in_decl);
9226 TREE_TYPE (r) = type = build_variant_type_copy (type);
9227 TYPE_NAME (type) = r;
9232 /* A static data member declaration is always marked
9233 external when it is declared in-class, even if an
9234 initializer is present. We mimic the non-template
9236 DECL_EXTERNAL (r) = 1;
9238 register_specialization (r, gen_tmpl, argvec, false, hash);
9239 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
9240 SET_DECL_IMPLICIT_INSTANTIATION (r);
9242 else if (cp_unevaluated_operand)
9244 /* We're substituting this var in a decltype outside of its
9245 scope, such as for a lambda return type. Don't add it to
9246 local_specializations, do perform auto deduction. */
9247 tree auto_node = type_uses_auto (type);
9249 = tsubst_expr (DECL_INITIAL (t), args, complain, in_decl,
9250 /*constant_expression_p=*/false);
9252 if (auto_node && init && describable_type (init))
9254 type = do_auto_deduction (type, init, auto_node);
9255 TREE_TYPE (r) = type;
9259 register_local_specialization (r, t);
9261 TREE_CHAIN (r) = NULL_TREE;
9263 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
9264 (int) ATTR_FLAG_TYPE_IN_PLACE,
9265 args, complain, in_decl);
9276 /* Restore the file and line information. */
9277 input_location = saved_loc;
9282 /* Substitute into the ARG_TYPES of a function type. */
9285 tsubst_arg_types (tree arg_types,
9287 tsubst_flags_t complain,
9290 tree remaining_arg_types;
9291 tree type = NULL_TREE;
9293 tree expanded_args = NULL_TREE;
9296 if (!arg_types || arg_types == void_list_node)
9299 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
9300 args, complain, in_decl);
9301 if (remaining_arg_types == error_mark_node)
9302 return error_mark_node;
9304 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
9306 /* For a pack expansion, perform substitution on the
9307 entire expression. Later on, we'll handle the arguments
9309 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
9310 args, complain, in_decl);
9312 if (TREE_CODE (expanded_args) == TREE_VEC)
9313 /* So that we'll spin through the parameters, one by one. */
9314 i = TREE_VEC_LENGTH (expanded_args);
9317 /* We only partially substituted into the parameter
9318 pack. Our type is TYPE_PACK_EXPANSION. */
9319 type = expanded_args;
9320 expanded_args = NULL_TREE;
9328 type = TREE_VEC_ELT (expanded_args, i);
9330 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
9332 if (type == error_mark_node)
9333 return error_mark_node;
9334 if (VOID_TYPE_P (type))
9336 if (complain & tf_error)
9338 error ("invalid parameter type %qT", type);
9340 error ("in declaration %q+D", in_decl);
9342 return error_mark_node;
9345 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9346 top-level qualifiers as required. */
9347 type = TYPE_MAIN_VARIANT (type_decays_to (type));
9349 /* We do not substitute into default arguments here. The standard
9350 mandates that they be instantiated only when needed, which is
9351 done in build_over_call. */
9352 default_arg = TREE_PURPOSE (arg_types);
9354 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
9356 /* We've instantiated a template before its default arguments
9357 have been parsed. This can happen for a nested template
9358 class, and is not an error unless we require the default
9359 argument in a call of this function. */
9360 remaining_arg_types =
9361 tree_cons (default_arg, type, remaining_arg_types);
9362 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
9363 remaining_arg_types);
9366 remaining_arg_types =
9367 hash_tree_cons (default_arg, type, remaining_arg_types);
9370 return remaining_arg_types;
9373 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9374 *not* handle the exception-specification for FNTYPE, because the
9375 initial substitution of explicitly provided template parameters
9376 during argument deduction forbids substitution into the
9377 exception-specification:
9381 All references in the function type of the function template to the
9382 corresponding template parameters are replaced by the specified tem-
9383 plate argument values. If a substitution in a template parameter or
9384 in the function type of the function template results in an invalid
9385 type, type deduction fails. [Note: The equivalent substitution in
9386 exception specifications is done only when the function is instanti-
9387 ated, at which point a program is ill-formed if the substitution
9388 results in an invalid type.] */
9391 tsubst_function_type (tree t,
9393 tsubst_flags_t complain,
9400 /* The TYPE_CONTEXT is not used for function/method types. */
9401 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
9403 /* Substitute the return type. */
9404 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9405 if (return_type == error_mark_node)
9406 return error_mark_node;
9407 /* The standard does not presently indicate that creation of a
9408 function type with an invalid return type is a deduction failure.
9409 However, that is clearly analogous to creating an array of "void"
9410 or a reference to a reference. This is core issue #486. */
9411 if (TREE_CODE (return_type) == ARRAY_TYPE
9412 || TREE_CODE (return_type) == FUNCTION_TYPE)
9414 if (complain & tf_error)
9416 if (TREE_CODE (return_type) == ARRAY_TYPE)
9417 error ("function returning an array");
9419 error ("function returning a function");
9421 return error_mark_node;
9424 /* Substitute the argument types. */
9425 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
9427 if (arg_types == error_mark_node)
9428 return error_mark_node;
9430 /* Construct a new type node and return it. */
9431 if (TREE_CODE (t) == FUNCTION_TYPE)
9432 fntype = build_function_type (return_type, arg_types);
9435 tree r = TREE_TYPE (TREE_VALUE (arg_types));
9436 if (! MAYBE_CLASS_TYPE_P (r))
9440 Type deduction may fail for any of the following
9443 -- Attempting to create "pointer to member of T" when T
9444 is not a class type. */
9445 if (complain & tf_error)
9446 error ("creating pointer to member function of non-class type %qT",
9448 return error_mark_node;
9451 fntype = build_method_type_directly (r, return_type,
9452 TREE_CHAIN (arg_types));
9454 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
9455 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
9460 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9461 ARGS into that specification, and return the substituted
9462 specification. If there is no specification, return NULL_TREE. */
9465 tsubst_exception_specification (tree fntype,
9467 tsubst_flags_t complain,
9473 specs = TYPE_RAISES_EXCEPTIONS (fntype);
9474 new_specs = NULL_TREE;
9477 if (! TREE_VALUE (specs))
9484 tree expanded_specs = NULL_TREE;
9486 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
9488 /* Expand the pack expansion type. */
9489 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
9493 if (expanded_specs == error_mark_node)
9494 return error_mark_node;
9495 else if (TREE_CODE (expanded_specs) == TREE_VEC)
9496 len = TREE_VEC_LENGTH (expanded_specs);
9499 /* We're substituting into a member template, so
9500 we got a TYPE_PACK_EXPANSION back. Add that
9501 expansion and move on. */
9502 gcc_assert (TREE_CODE (expanded_specs)
9503 == TYPE_PACK_EXPANSION);
9504 new_specs = add_exception_specifier (new_specs,
9507 specs = TREE_CHAIN (specs);
9512 for (i = 0; i < len; ++i)
9515 spec = TREE_VEC_ELT (expanded_specs, i);
9517 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
9518 if (spec == error_mark_node)
9520 new_specs = add_exception_specifier (new_specs, spec,
9524 specs = TREE_CHAIN (specs);
9530 /* Take the tree structure T and replace template parameters used
9531 therein with the argument vector ARGS. IN_DECL is an associated
9532 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9533 Issue error and warning messages under control of COMPLAIN. Note
9534 that we must be relatively non-tolerant of extensions here, in
9535 order to preserve conformance; if we allow substitutions that
9536 should not be allowed, we may allow argument deductions that should
9537 not succeed, and therefore report ambiguous overload situations
9538 where there are none. In theory, we could allow the substitution,
9539 but indicate that it should have failed, and allow our caller to
9540 make sure that the right thing happens, but we don't try to do this
9543 This function is used for dealing with types, decls and the like;
9544 for expressions, use tsubst_expr or tsubst_copy. */
9547 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9551 if (t == NULL_TREE || t == error_mark_node
9552 || t == integer_type_node
9553 || t == void_type_node
9554 || t == char_type_node
9555 || t == unknown_type_node
9556 || TREE_CODE (t) == NAMESPACE_DECL)
9560 return tsubst_decl (t, args, complain);
9562 if (args == NULL_TREE)
9565 if (TREE_CODE (t) == IDENTIFIER_NODE)
9566 type = IDENTIFIER_TYPE_VALUE (t);
9568 type = TREE_TYPE (t);
9570 gcc_assert (type != unknown_type_node);
9572 /* Reuse typedefs. We need to do this to handle dependent attributes,
9573 such as attribute aligned. */
9576 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
9578 tree decl = TYPE_NAME (t);
9580 if (DECL_CLASS_SCOPE_P (decl)
9581 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
9582 && uses_template_parms (DECL_CONTEXT (decl)))
9584 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
9585 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
9586 r = retrieve_specialization (tmpl, gen_args, 0);
9588 else if (DECL_FUNCTION_SCOPE_P (decl)
9589 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
9590 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
9591 r = retrieve_local_specialization (decl);
9593 /* The typedef is from a non-template context. */
9599 r = cp_build_qualified_type_real
9600 (r, cp_type_quals (t) | cp_type_quals (r),
9601 complain | tf_ignore_bad_quals);
9604 /* Else we must be instantiating the typedef, so fall through. */
9608 && TREE_CODE (t) != TYPENAME_TYPE
9609 && TREE_CODE (t) != IDENTIFIER_NODE
9610 && TREE_CODE (t) != FUNCTION_TYPE
9611 && TREE_CODE (t) != METHOD_TYPE)
9612 type = tsubst (type, args, complain, in_decl);
9613 if (type == error_mark_node)
9614 return error_mark_node;
9616 switch (TREE_CODE (t))
9621 return tsubst_aggr_type (t, args, complain, in_decl,
9622 /*entering_scope=*/0);
9625 case IDENTIFIER_NODE:
9637 if (t == integer_type_node)
9640 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
9641 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
9645 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
9647 max = tsubst_expr (omax, args, complain, in_decl,
9648 /*integral_constant_expression_p=*/false);
9650 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
9652 if (TREE_CODE (max) == NOP_EXPR
9653 && TREE_SIDE_EFFECTS (omax)
9654 && !TREE_TYPE (max))
9655 TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
9657 max = fold_decl_constant_value (max);
9659 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
9660 with TREE_SIDE_EFFECTS that indicates this is not an integral
9661 constant expression. */
9662 if (processing_template_decl
9663 && TREE_SIDE_EFFECTS (omax) && TREE_CODE (omax) == NOP_EXPR)
9665 gcc_assert (TREE_CODE (max) == NOP_EXPR);
9666 TREE_SIDE_EFFECTS (max) = 1;
9669 if (TREE_CODE (max) != INTEGER_CST
9670 && !at_function_scope_p ()
9671 && !TREE_SIDE_EFFECTS (max)
9672 && !value_dependent_expression_p (max))
9674 if (complain & tf_error)
9675 error ("array bound is not an integer constant");
9676 return error_mark_node;
9681 Type deduction may fail for any of the following
9684 Attempting to create an array with a size that is
9685 zero or negative. */
9686 if (integer_zerop (max) && !(complain & tf_error))
9687 /* We must fail if performing argument deduction (as
9688 indicated by the state of complain), so that
9689 another substitution can be found. */
9690 return error_mark_node;
9691 else if (TREE_CODE (max) == INTEGER_CST
9692 && INT_CST_LT (max, integer_zero_node))
9694 if (complain & tf_error)
9695 error ("creating array with negative size (%qE)", max);
9697 return error_mark_node;
9700 return compute_array_index_type (NULL_TREE, max);
9703 case TEMPLATE_TYPE_PARM:
9704 case TEMPLATE_TEMPLATE_PARM:
9705 case BOUND_TEMPLATE_TEMPLATE_PARM:
9706 case TEMPLATE_PARM_INDEX:
9711 tree arg = NULL_TREE;
9715 gcc_assert (TREE_VEC_LENGTH (args) > 0);
9716 template_parm_level_and_index (t, &level, &idx);
9718 levels = TMPL_ARGS_DEPTH (args);
9719 if (level <= levels)
9721 arg = TMPL_ARG (args, level, idx);
9723 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
9724 /* See through ARGUMENT_PACK_SELECT arguments. */
9725 arg = ARGUMENT_PACK_SELECT_ARG (arg);
9728 if (arg == error_mark_node)
9729 return error_mark_node;
9730 else if (arg != NULL_TREE)
9732 if (ARGUMENT_PACK_P (arg))
9733 /* If ARG is an argument pack, we don't actually want to
9734 perform a substitution here, because substitutions
9735 for argument packs are only done
9736 element-by-element. We can get to this point when
9737 substituting the type of a non-type template
9738 parameter pack, when that type actually contains
9739 template parameter packs from an outer template, e.g.,
9741 template<typename... Types> struct A {
9742 template<Types... Values> struct B { };
9746 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
9749 gcc_assert (TYPE_P (arg));
9751 /* cv-quals from the template are discarded when
9752 substituting in a function or reference type. */
9753 if (TREE_CODE (arg) == FUNCTION_TYPE
9754 || TREE_CODE (arg) == METHOD_TYPE
9755 || TREE_CODE (arg) == REFERENCE_TYPE)
9756 quals = cp_type_quals (arg);
9758 quals = cp_type_quals (arg) | cp_type_quals (t);
9760 return cp_build_qualified_type_real
9761 (arg, quals, complain | tf_ignore_bad_quals);
9763 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9765 /* We are processing a type constructed from a
9766 template template parameter. */
9767 tree argvec = tsubst (TYPE_TI_ARGS (t),
9768 args, complain, in_decl);
9769 if (argvec == error_mark_node)
9770 return error_mark_node;
9772 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9773 are resolving nested-types in the signature of a
9774 member function templates. Otherwise ARG is a
9775 TEMPLATE_DECL and is the real template to be
9777 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
9778 arg = TYPE_NAME (arg);
9780 r = lookup_template_class (arg,
9783 /*entering_scope=*/0,
9785 return cp_build_qualified_type_real
9786 (r, TYPE_QUALS (t), complain);
9789 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9794 /* This can happen during the attempted tsubst'ing in
9795 unify. This means that we don't yet have any information
9796 about the template parameter in question. */
9799 /* If we get here, we must have been looking at a parm for a
9800 more deeply nested template. Make a new version of this
9801 template parameter, but with a lower level. */
9802 switch (TREE_CODE (t))
9804 case TEMPLATE_TYPE_PARM:
9805 case TEMPLATE_TEMPLATE_PARM:
9806 case BOUND_TEMPLATE_TEMPLATE_PARM:
9807 if (cp_type_quals (t))
9809 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
9810 r = cp_build_qualified_type_real
9811 (r, cp_type_quals (t),
9812 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
9813 ? tf_ignore_bad_quals : 0));
9818 TEMPLATE_TYPE_PARM_INDEX (r)
9819 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
9820 r, levels, args, complain);
9821 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
9822 TYPE_MAIN_VARIANT (r) = r;
9823 TYPE_POINTER_TO (r) = NULL_TREE;
9824 TYPE_REFERENCE_TO (r) = NULL_TREE;
9826 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
9827 /* We have reduced the level of the template
9828 template parameter, but not the levels of its
9829 template parameters, so canonical_type_parameter
9830 will not be able to find the canonical template
9831 template parameter for this level. Thus, we
9832 require structural equality checking to compare
9833 TEMPLATE_TEMPLATE_PARMs. */
9834 SET_TYPE_STRUCTURAL_EQUALITY (r);
9835 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
9836 SET_TYPE_STRUCTURAL_EQUALITY (r);
9838 TYPE_CANONICAL (r) = canonical_type_parameter (r);
9840 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9842 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
9844 if (argvec == error_mark_node)
9845 return error_mark_node;
9847 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
9848 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
9853 case TEMPLATE_PARM_INDEX:
9854 r = reduce_template_parm_level (t, type, levels, args, complain);
9866 tree purpose, value, chain;
9868 if (t == void_list_node)
9871 purpose = TREE_PURPOSE (t);
9874 purpose = tsubst (purpose, args, complain, in_decl);
9875 if (purpose == error_mark_node)
9876 return error_mark_node;
9878 value = TREE_VALUE (t);
9881 value = tsubst (value, args, complain, in_decl);
9882 if (value == error_mark_node)
9883 return error_mark_node;
9885 chain = TREE_CHAIN (t);
9886 if (chain && chain != void_type_node)
9888 chain = tsubst (chain, args, complain, in_decl);
9889 if (chain == error_mark_node)
9890 return error_mark_node;
9892 if (purpose == TREE_PURPOSE (t)
9893 && value == TREE_VALUE (t)
9894 && chain == TREE_CHAIN (t))
9896 return hash_tree_cons (purpose, value, chain);
9900 /* We should never be tsubsting a binfo. */
9904 /* A vector of template arguments. */
9906 return tsubst_template_args (t, args, complain, in_decl);
9909 case REFERENCE_TYPE:
9911 enum tree_code code;
9913 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
9916 code = TREE_CODE (t);
9921 Type deduction may fail for any of the following
9924 -- Attempting to create a pointer to reference type.
9925 -- Attempting to create a reference to a reference type or
9926 a reference to void.
9928 Core issue 106 says that creating a reference to a reference
9929 during instantiation is no longer a cause for failure. We
9930 only enforce this check in strict C++98 mode. */
9931 if ((TREE_CODE (type) == REFERENCE_TYPE
9932 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
9933 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
9935 static location_t last_loc;
9937 /* We keep track of the last time we issued this error
9938 message to avoid spewing a ton of messages during a
9939 single bad template instantiation. */
9940 if (complain & tf_error
9941 && last_loc != input_location)
9943 if (TREE_CODE (type) == VOID_TYPE)
9944 error ("forming reference to void");
9946 error ("forming %s to reference type %qT",
9947 (code == POINTER_TYPE) ? "pointer" : "reference",
9949 last_loc = input_location;
9952 return error_mark_node;
9954 else if (code == POINTER_TYPE)
9956 r = build_pointer_type (type);
9957 if (TREE_CODE (type) == METHOD_TYPE)
9958 r = build_ptrmemfunc_type (r);
9960 else if (TREE_CODE (type) == REFERENCE_TYPE)
9961 /* In C++0x, during template argument substitution, when there is an
9962 attempt to create a reference to a reference type, reference
9963 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9965 "If a template-argument for a template-parameter T names a type
9966 that is a reference to a type A, an attempt to create the type
9967 'lvalue reference to cv T' creates the type 'lvalue reference to
9968 A,' while an attempt to create the type type rvalue reference to
9969 cv T' creates the type T"
9971 r = cp_build_reference_type
9973 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
9975 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
9976 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
9978 if (r != error_mark_node)
9979 /* Will this ever be needed for TYPE_..._TO values? */
9986 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9987 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
9991 Type deduction may fail for any of the following
9994 -- Attempting to create "pointer to member of T" when T
9995 is not a class type. */
9996 if (complain & tf_error)
9997 error ("creating pointer to member of non-class type %qT", r);
9998 return error_mark_node;
10000 if (TREE_CODE (type) == REFERENCE_TYPE)
10002 if (complain & tf_error)
10003 error ("creating pointer to member reference type %qT", type);
10004 return error_mark_node;
10006 if (TREE_CODE (type) == VOID_TYPE)
10008 if (complain & tf_error)
10009 error ("creating pointer to member of type void");
10010 return error_mark_node;
10012 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
10013 if (TREE_CODE (type) == FUNCTION_TYPE)
10015 /* The type of the implicit object parameter gets its
10016 cv-qualifiers from the FUNCTION_TYPE. */
10018 tree method_type = build_memfn_type (type, r, cp_type_quals (type));
10019 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
10020 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
10024 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
10028 case FUNCTION_TYPE:
10033 fntype = tsubst_function_type (t, args, complain, in_decl);
10034 if (fntype == error_mark_node)
10035 return error_mark_node;
10037 /* Substitute the exception specification. */
10038 specs = tsubst_exception_specification (t, args, complain,
10040 if (specs == error_mark_node)
10041 return error_mark_node;
10043 fntype = build_exception_variant (fntype, specs);
10048 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
10049 if (domain == error_mark_node)
10050 return error_mark_node;
10052 /* As an optimization, we avoid regenerating the array type if
10053 it will obviously be the same as T. */
10054 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
10057 /* These checks should match the ones in grokdeclarator.
10061 The deduction may fail for any of the following reasons:
10063 -- Attempting to create an array with an element type that
10064 is void, a function type, or a reference type, or [DR337]
10065 an abstract class type. */
10066 if (TREE_CODE (type) == VOID_TYPE
10067 || TREE_CODE (type) == FUNCTION_TYPE
10068 || TREE_CODE (type) == REFERENCE_TYPE)
10070 if (complain & tf_error)
10071 error ("creating array of %qT", type);
10072 return error_mark_node;
10074 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
10076 if (complain & tf_error)
10077 error ("creating array of %qT, which is an abstract class type",
10079 return error_mark_node;
10082 r = build_cplus_array_type (type, domain);
10084 if (TYPE_USER_ALIGN (t))
10086 TYPE_ALIGN (r) = TYPE_ALIGN (t);
10087 TYPE_USER_ALIGN (r) = 1;
10096 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10097 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10099 if (e1 == error_mark_node || e2 == error_mark_node)
10100 return error_mark_node;
10102 return fold_build2_loc (input_location,
10103 TREE_CODE (t), TREE_TYPE (t), e1, e2);
10109 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10110 if (e == error_mark_node)
10111 return error_mark_node;
10113 return fold_build1_loc (input_location, TREE_CODE (t), TREE_TYPE (t), e);
10116 case TYPENAME_TYPE:
10118 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10119 in_decl, /*entering_scope=*/1);
10120 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
10121 complain, in_decl);
10123 if (ctx == error_mark_node || f == error_mark_node)
10124 return error_mark_node;
10126 if (!MAYBE_CLASS_TYPE_P (ctx))
10128 if (complain & tf_error)
10129 error ("%qT is not a class, struct, or union type", ctx);
10130 return error_mark_node;
10132 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
10134 /* Normally, make_typename_type does not require that the CTX
10135 have complete type in order to allow things like:
10137 template <class T> struct S { typename S<T>::X Y; };
10139 But, such constructs have already been resolved by this
10140 point, so here CTX really should have complete type, unless
10141 it's a partial instantiation. */
10142 if (!(complain & tf_no_class_instantiations))
10143 ctx = complete_type (ctx);
10144 if (!COMPLETE_TYPE_P (ctx))
10146 if (complain & tf_error)
10147 cxx_incomplete_type_error (NULL_TREE, ctx);
10148 return error_mark_node;
10152 f = make_typename_type (ctx, f, typename_type,
10153 (complain & tf_error) | tf_keep_type_decl);
10154 if (f == error_mark_node)
10156 if (TREE_CODE (f) == TYPE_DECL)
10158 complain |= tf_ignore_bad_quals;
10162 if (TREE_CODE (f) != TYPENAME_TYPE)
10164 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
10165 error ("%qT resolves to %qT, which is not an enumeration type",
10167 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
10168 error ("%qT resolves to %qT, which is is not a class type",
10172 return cp_build_qualified_type_real
10173 (f, cp_type_quals (f) | cp_type_quals (t), complain);
10176 case UNBOUND_CLASS_TEMPLATE:
10178 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10179 in_decl, /*entering_scope=*/1);
10180 tree name = TYPE_IDENTIFIER (t);
10181 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
10183 if (ctx == error_mark_node || name == error_mark_node)
10184 return error_mark_node;
10187 parm_list = tsubst_template_parms (parm_list, args, complain);
10188 return make_unbound_class_template (ctx, name, parm_list, complain);
10194 gcc_unreachable ();
10198 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10199 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
10200 /*integral_constant_expression_p=*/false);
10201 if (e1 == error_mark_node || e2 == error_mark_node)
10202 return error_mark_node;
10204 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
10209 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10210 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10211 if (e1 == error_mark_node || e2 == error_mark_node)
10212 return error_mark_node;
10214 return build_qualified_name (/*type=*/NULL_TREE,
10215 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
10222 ++cp_unevaluated_operand;
10223 ++c_inhibit_evaluation_warnings;
10225 type = tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
10227 /*integral_constant_expression_p=*/false);
10229 --cp_unevaluated_operand;
10230 --c_inhibit_evaluation_warnings;
10232 type = finish_typeof (type);
10233 return cp_build_qualified_type_real (type,
10235 | cp_type_quals (type),
10239 case DECLTYPE_TYPE:
10243 ++cp_unevaluated_operand;
10244 ++c_inhibit_evaluation_warnings;
10246 type = tsubst_expr (DECLTYPE_TYPE_EXPR (t), args,
10248 /*integral_constant_expression_p=*/false);
10250 --cp_unevaluated_operand;
10251 --c_inhibit_evaluation_warnings;
10253 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t))
10254 type = lambda_capture_field_type (type);
10255 else if (DECLTYPE_FOR_LAMBDA_RETURN (t))
10256 type = lambda_return_type (type);
10258 type = finish_decltype_type
10259 (type, DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
10260 return cp_build_qualified_type_real (type,
10262 | cp_type_quals (type),
10266 case TYPE_ARGUMENT_PACK:
10267 case NONTYPE_ARGUMENT_PACK:
10269 tree r = TYPE_P (t)
10270 ? cxx_make_type (TREE_CODE (t))
10271 : make_node (TREE_CODE (t));
10273 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
10277 SET_ARGUMENT_PACK_ARGS (r, packed_out);
10279 /* For template nontype argument packs, also substitute into
10281 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
10282 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
10289 sorry ("use of %qs in template",
10290 tree_code_name [(int) TREE_CODE (t)]);
10291 return error_mark_node;
10295 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10296 type of the expression on the left-hand side of the "." or "->"
10300 tsubst_baselink (tree baselink, tree object_type,
10301 tree args, tsubst_flags_t complain, tree in_decl)
10304 tree qualifying_scope;
10307 tree template_args = 0;
10308 bool template_id_p = false;
10310 /* A baselink indicates a function from a base class. Both the
10311 BASELINK_ACCESS_BINFO and the base class referenced may
10312 indicate bases of the template class, rather than the
10313 instantiated class. In addition, lookups that were not
10314 ambiguous before may be ambiguous now. Therefore, we perform
10315 the lookup again. */
10316 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
10317 qualifying_scope = tsubst (qualifying_scope, args,
10318 complain, in_decl);
10319 fns = BASELINK_FUNCTIONS (baselink);
10320 optype = tsubst (BASELINK_OPTYPE (baselink), args, complain, in_decl);
10321 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
10323 template_id_p = true;
10324 template_args = TREE_OPERAND (fns, 1);
10325 fns = TREE_OPERAND (fns, 0);
10327 template_args = tsubst_template_args (template_args, args,
10328 complain, in_decl);
10330 name = DECL_NAME (get_first_fn (fns));
10331 if (IDENTIFIER_TYPENAME_P (name))
10332 name = mangle_conv_op_name_for_type (optype);
10333 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
10335 /* If lookup found a single function, mark it as used at this
10336 point. (If it lookup found multiple functions the one selected
10337 later by overload resolution will be marked as used at that
10339 if (BASELINK_P (baselink))
10340 fns = BASELINK_FUNCTIONS (baselink);
10341 if (!template_id_p && !really_overloaded_fn (fns))
10342 mark_used (OVL_CURRENT (fns));
10344 /* Add back the template arguments, if present. */
10345 if (BASELINK_P (baselink) && template_id_p)
10346 BASELINK_FUNCTIONS (baselink)
10347 = build_nt (TEMPLATE_ID_EXPR,
10348 BASELINK_FUNCTIONS (baselink),
10350 /* Update the conversion operator type. */
10351 BASELINK_OPTYPE (baselink) = optype;
10354 object_type = current_class_type;
10355 return adjust_result_of_qualified_name_lookup (baselink,
10360 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10361 true if the qualified-id will be a postfix-expression in-and-of
10362 itself; false if more of the postfix-expression follows the
10363 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10367 tsubst_qualified_id (tree qualified_id, tree args,
10368 tsubst_flags_t complain, tree in_decl,
10369 bool done, bool address_p)
10375 tree template_args;
10377 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
10379 /* Figure out what name to look up. */
10380 name = TREE_OPERAND (qualified_id, 1);
10381 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
10383 is_template = true;
10384 template_args = TREE_OPERAND (name, 1);
10386 template_args = tsubst_template_args (template_args, args,
10387 complain, in_decl);
10388 name = TREE_OPERAND (name, 0);
10392 is_template = false;
10393 template_args = NULL_TREE;
10396 /* Substitute into the qualifying scope. When there are no ARGS, we
10397 are just trying to simplify a non-dependent expression. In that
10398 case the qualifying scope may be dependent, and, in any case,
10399 substituting will not help. */
10400 scope = TREE_OPERAND (qualified_id, 0);
10403 scope = tsubst (scope, args, complain, in_decl);
10404 expr = tsubst_copy (name, args, complain, in_decl);
10409 if (dependent_type_p (scope))
10411 tree type = NULL_TREE;
10412 if (DECL_P (expr) && !dependent_scope_p (scope))
10413 type = TREE_TYPE (expr);
10414 return build_qualified_name (type, scope, expr,
10415 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
10418 if (!BASELINK_P (name) && !DECL_P (expr))
10420 if (TREE_CODE (expr) == BIT_NOT_EXPR)
10422 /* A BIT_NOT_EXPR is used to represent a destructor. */
10423 if (!check_dtor_name (scope, TREE_OPERAND (expr, 0)))
10425 error ("qualifying type %qT does not match destructor name ~%qT",
10426 scope, TREE_OPERAND (expr, 0));
10427 expr = error_mark_node;
10430 expr = lookup_qualified_name (scope, complete_dtor_identifier,
10431 /*is_type_p=*/0, false);
10434 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
10435 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
10436 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
10438 if (complain & tf_error)
10440 error ("dependent-name %qE is parsed as a non-type, but "
10441 "instantiation yields a type", qualified_id);
10442 inform (input_location, "say %<typename %E%> if a type is meant", qualified_id);
10444 return error_mark_node;
10450 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
10452 /* Remember that there was a reference to this entity. */
10456 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
10458 if (complain & tf_error)
10459 qualified_name_lookup_error (scope,
10460 TREE_OPERAND (qualified_id, 1),
10461 expr, input_location);
10462 return error_mark_node;
10466 expr = lookup_template_function (expr, template_args);
10468 if (expr == error_mark_node && complain & tf_error)
10469 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
10470 expr, input_location);
10471 else if (TYPE_P (scope))
10473 expr = (adjust_result_of_qualified_name_lookup
10474 (expr, scope, current_class_type));
10475 expr = (finish_qualified_id_expr
10476 (scope, expr, done, address_p,
10477 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
10478 /*template_arg_p=*/false));
10481 /* Expressions do not generally have reference type. */
10482 if (TREE_CODE (expr) != SCOPE_REF
10483 /* However, if we're about to form a pointer-to-member, we just
10484 want the referenced member referenced. */
10485 && TREE_CODE (expr) != OFFSET_REF)
10486 expr = convert_from_reference (expr);
10491 /* Like tsubst, but deals with expressions. This function just replaces
10492 template parms; to finish processing the resultant expression, use
10496 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
10498 enum tree_code code;
10501 if (t == NULL_TREE || t == error_mark_node || args == NULL_TREE)
10504 code = TREE_CODE (t);
10509 r = retrieve_local_specialization (t);
10514 /* This can happen for a parameter name used later in a function
10515 declaration (such as in a late-specified return type). Just
10516 make a dummy decl, since it's only used for its type. */
10517 gcc_assert (cp_unevaluated_operand != 0);
10518 /* We copy T because want to tsubst the PARM_DECL only,
10519 not the following PARM_DECLs that are chained to T. */
10521 r = tsubst_decl (c, args, complain);
10522 /* Give it the template pattern as its context; its true context
10523 hasn't been instantiated yet and this is good enough for
10525 DECL_CONTEXT (r) = DECL_CONTEXT (t);
10528 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
10529 r = ARGUMENT_PACK_SELECT_ARG (r);
10538 if (DECL_TEMPLATE_PARM_P (t))
10539 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
10540 /* There is no need to substitute into namespace-scope
10542 if (DECL_NAMESPACE_SCOPE_P (t))
10544 /* If ARGS is NULL, then T is known to be non-dependent. */
10545 if (args == NULL_TREE)
10546 return integral_constant_value (t);
10548 /* Unfortunately, we cannot just call lookup_name here.
10551 template <int I> int f() {
10553 struct S { void g() { E e = a; } };
10556 When we instantiate f<7>::S::g(), say, lookup_name is not
10557 clever enough to find f<7>::a. */
10559 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
10560 /*entering_scope=*/0);
10562 for (v = TYPE_VALUES (enum_type);
10564 v = TREE_CHAIN (v))
10565 if (TREE_PURPOSE (v) == DECL_NAME (t))
10566 return TREE_VALUE (v);
10568 /* We didn't find the name. That should never happen; if
10569 name-lookup found it during preliminary parsing, we
10570 should find it again here during instantiation. */
10571 gcc_unreachable ();
10576 if (DECL_CONTEXT (t))
10580 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
10581 /*entering_scope=*/1);
10582 if (ctx != DECL_CONTEXT (t))
10584 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
10587 if (complain & tf_error)
10588 error ("using invalid field %qD", t);
10589 return error_mark_node;
10598 case FUNCTION_DECL:
10599 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
10600 || local_variable_p (t))
10601 t = tsubst (t, args, complain, in_decl);
10606 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
10608 case TEMPLATE_DECL:
10609 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
10610 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
10611 args, complain, in_decl);
10612 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
10613 return tsubst (t, args, complain, in_decl);
10614 else if (DECL_CLASS_SCOPE_P (t)
10615 && uses_template_parms (DECL_CONTEXT (t)))
10617 /* Template template argument like the following example need
10620 template <template <class> class TT> struct C {};
10621 template <class T> struct D {
10622 template <class U> struct E {};
10627 We are processing the template argument `E' in #1 for
10628 the template instantiation #2. Originally, `E' is a
10629 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10630 have to substitute this with one having context `D<int>'. */
10632 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
10633 return lookup_field (context, DECL_NAME(t), 0, false);
10636 /* Ordinary template template argument. */
10640 case REINTERPRET_CAST_EXPR:
10641 case CONST_CAST_EXPR:
10642 case STATIC_CAST_EXPR:
10643 case DYNAMIC_CAST_EXPR:
10646 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
10647 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
10650 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10652 /* We only want to compute the number of arguments. */
10653 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10654 complain, in_decl);
10657 if (TREE_CODE (expanded) == TREE_VEC)
10658 len = TREE_VEC_LENGTH (expanded);
10660 if (expanded == error_mark_node)
10661 return error_mark_node;
10662 else if (PACK_EXPANSION_P (expanded)
10663 || (TREE_CODE (expanded) == TREE_VEC
10665 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
10667 if (TREE_CODE (expanded) == TREE_VEC)
10668 expanded = TREE_VEC_ELT (expanded, len - 1);
10670 if (TYPE_P (expanded))
10671 return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR,
10672 complain & tf_error);
10674 return cxx_sizeof_or_alignof_expr (expanded, SIZEOF_EXPR,
10675 complain & tf_error);
10678 return build_int_cst (size_type_node, len);
10684 case TRUTH_NOT_EXPR:
10687 case UNARY_PLUS_EXPR: /* Unary + */
10692 case REALPART_EXPR:
10693 case IMAGPART_EXPR:
10695 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
10696 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
10698 case COMPONENT_REF:
10703 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
10704 name = TREE_OPERAND (t, 1);
10705 if (TREE_CODE (name) == BIT_NOT_EXPR)
10707 name = tsubst_copy (TREE_OPERAND (name, 0), args,
10708 complain, in_decl);
10709 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
10711 else if (TREE_CODE (name) == SCOPE_REF
10712 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
10714 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
10715 complain, in_decl);
10716 name = TREE_OPERAND (name, 1);
10717 name = tsubst_copy (TREE_OPERAND (name, 0), args,
10718 complain, in_decl);
10719 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
10720 name = build_qualified_name (/*type=*/NULL_TREE,
10722 /*template_p=*/false);
10724 else if (TREE_CODE (name) == BASELINK)
10725 name = tsubst_baselink (name,
10726 non_reference (TREE_TYPE (object)),
10730 name = tsubst_copy (name, args, complain, in_decl);
10731 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
10737 case TRUNC_DIV_EXPR:
10738 case CEIL_DIV_EXPR:
10739 case FLOOR_DIV_EXPR:
10740 case ROUND_DIV_EXPR:
10741 case EXACT_DIV_EXPR:
10745 case TRUNC_MOD_EXPR:
10746 case FLOOR_MOD_EXPR:
10747 case TRUTH_ANDIF_EXPR:
10748 case TRUTH_ORIF_EXPR:
10749 case TRUTH_AND_EXPR:
10750 case TRUTH_OR_EXPR:
10763 case COMPOUND_EXPR:
10766 case PREDECREMENT_EXPR:
10767 case PREINCREMENT_EXPR:
10768 case POSTDECREMENT_EXPR:
10769 case POSTINCREMENT_EXPR:
10771 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10772 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
10775 return build_qualified_name (/*type=*/NULL_TREE,
10776 tsubst_copy (TREE_OPERAND (t, 0),
10777 args, complain, in_decl),
10778 tsubst_copy (TREE_OPERAND (t, 1),
10779 args, complain, in_decl),
10780 QUALIFIED_NAME_IS_TEMPLATE (t));
10785 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10786 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10787 NULL_TREE, NULL_TREE);
10791 int n = VL_EXP_OPERAND_LENGTH (t);
10792 tree result = build_vl_exp (CALL_EXPR, n);
10794 for (i = 0; i < n; i++)
10795 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
10796 complain, in_decl);
10802 case PSEUDO_DTOR_EXPR:
10805 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10806 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10807 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
10808 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10815 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10816 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10817 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
10818 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
10825 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10826 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
10827 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
10828 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
10832 case TEMPLATE_ID_EXPR:
10834 /* Substituted template arguments */
10835 tree fn = TREE_OPERAND (t, 0);
10836 tree targs = TREE_OPERAND (t, 1);
10838 fn = tsubst_copy (fn, args, complain, in_decl);
10840 targs = tsubst_template_args (targs, args, complain, in_decl);
10842 return lookup_template_function (fn, targs);
10847 tree purpose, value, chain;
10849 if (t == void_list_node)
10852 purpose = TREE_PURPOSE (t);
10854 purpose = tsubst_copy (purpose, args, complain, in_decl);
10855 value = TREE_VALUE (t);
10857 value = tsubst_copy (value, args, complain, in_decl);
10858 chain = TREE_CHAIN (t);
10859 if (chain && chain != void_type_node)
10860 chain = tsubst_copy (chain, args, complain, in_decl);
10861 if (purpose == TREE_PURPOSE (t)
10862 && value == TREE_VALUE (t)
10863 && chain == TREE_CHAIN (t))
10865 return tree_cons (purpose, value, chain);
10870 case ENUMERAL_TYPE:
10872 case TEMPLATE_TYPE_PARM:
10873 case TEMPLATE_TEMPLATE_PARM:
10874 case BOUND_TEMPLATE_TEMPLATE_PARM:
10875 case TEMPLATE_PARM_INDEX:
10877 case REFERENCE_TYPE:
10879 case FUNCTION_TYPE:
10882 case TYPENAME_TYPE:
10883 case UNBOUND_CLASS_TEMPLATE:
10885 case DECLTYPE_TYPE:
10887 return tsubst (t, args, complain, in_decl);
10889 case IDENTIFIER_NODE:
10890 if (IDENTIFIER_TYPENAME_P (t))
10892 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10893 return mangle_conv_op_name_for_type (new_type);
10899 /* This is handled by tsubst_copy_and_build. */
10900 gcc_unreachable ();
10903 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
10905 tsubst (TREE_TYPE (t), args, complain, in_decl));
10907 case CLEANUP_POINT_EXPR:
10908 /* We shouldn't have built any of these during initial template
10909 generation. Instead, they should be built during instantiation
10910 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10911 gcc_unreachable ();
10914 mark_used (TREE_OPERAND (t, 1));
10917 case EXPR_PACK_EXPANSION:
10918 error ("invalid use of pack expansion expression");
10919 return error_mark_node;
10921 case NONTYPE_ARGUMENT_PACK:
10922 error ("use %<...%> to expand argument pack");
10923 return error_mark_node;
10930 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10933 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
10936 tree new_clauses = NULL, nc, oc;
10938 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
10940 nc = copy_node (oc);
10941 OMP_CLAUSE_CHAIN (nc) = new_clauses;
10944 switch (OMP_CLAUSE_CODE (nc))
10946 case OMP_CLAUSE_LASTPRIVATE:
10947 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
10949 OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
10950 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
10951 in_decl, /*integral_constant_expression_p=*/false);
10952 OMP_CLAUSE_LASTPRIVATE_STMT (nc)
10953 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
10956 case OMP_CLAUSE_PRIVATE:
10957 case OMP_CLAUSE_SHARED:
10958 case OMP_CLAUSE_FIRSTPRIVATE:
10959 case OMP_CLAUSE_REDUCTION:
10960 case OMP_CLAUSE_COPYIN:
10961 case OMP_CLAUSE_COPYPRIVATE:
10962 case OMP_CLAUSE_IF:
10963 case OMP_CLAUSE_NUM_THREADS:
10964 case OMP_CLAUSE_SCHEDULE:
10965 case OMP_CLAUSE_COLLAPSE:
10966 OMP_CLAUSE_OPERAND (nc, 0)
10967 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
10968 in_decl, /*integral_constant_expression_p=*/false);
10970 case OMP_CLAUSE_NOWAIT:
10971 case OMP_CLAUSE_ORDERED:
10972 case OMP_CLAUSE_DEFAULT:
10973 case OMP_CLAUSE_UNTIED:
10976 gcc_unreachable ();
10980 return finish_omp_clauses (nreverse (new_clauses));
10983 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10986 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
10989 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10991 tree purpose, value, chain;
10996 if (TREE_CODE (t) != TREE_LIST)
10997 return tsubst_copy_and_build (t, args, complain, in_decl,
10998 /*function_p=*/false,
10999 /*integral_constant_expression_p=*/false);
11001 if (t == void_list_node)
11004 purpose = TREE_PURPOSE (t);
11006 purpose = RECUR (purpose);
11007 value = TREE_VALUE (t);
11008 if (value && TREE_CODE (value) != LABEL_DECL)
11009 value = RECUR (value);
11010 chain = TREE_CHAIN (t);
11011 if (chain && chain != void_type_node)
11012 chain = RECUR (chain);
11013 return tree_cons (purpose, value, chain);
11017 /* Substitute one OMP_FOR iterator. */
11020 tsubst_omp_for_iterator (tree t, int i, tree declv, tree initv,
11021 tree condv, tree incrv, tree *clauses,
11022 tree args, tsubst_flags_t complain, tree in_decl,
11023 bool integral_constant_expression_p)
11025 #define RECUR(NODE) \
11026 tsubst_expr ((NODE), args, complain, in_decl, \
11027 integral_constant_expression_p)
11028 tree decl, init, cond, incr, auto_node;
11030 init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
11031 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
11032 decl = RECUR (TREE_OPERAND (init, 0));
11033 init = TREE_OPERAND (init, 1);
11034 auto_node = type_uses_auto (TREE_TYPE (decl));
11035 if (auto_node && init)
11037 tree init_expr = init;
11038 if (TREE_CODE (init_expr) == DECL_EXPR)
11039 init_expr = DECL_INITIAL (DECL_EXPR_DECL (init_expr));
11040 init_expr = RECUR (init_expr);
11042 = do_auto_deduction (TREE_TYPE (decl), init_expr, auto_node);
11044 gcc_assert (!type_dependent_expression_p (decl));
11046 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
11048 cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i));
11049 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
11050 if (TREE_CODE (incr) == MODIFY_EXPR)
11051 incr = build_x_modify_expr (RECUR (TREE_OPERAND (incr, 0)), NOP_EXPR,
11052 RECUR (TREE_OPERAND (incr, 1)),
11055 incr = RECUR (incr);
11056 TREE_VEC_ELT (declv, i) = decl;
11057 TREE_VEC_ELT (initv, i) = init;
11058 TREE_VEC_ELT (condv, i) = cond;
11059 TREE_VEC_ELT (incrv, i) = incr;
11063 if (init && TREE_CODE (init) != DECL_EXPR)
11066 for (c = *clauses; c ; c = OMP_CLAUSE_CHAIN (c))
11068 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
11069 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
11070 && OMP_CLAUSE_DECL (c) == decl)
11072 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
11073 && OMP_CLAUSE_DECL (c) == decl)
11074 error ("iteration variable %qD should not be firstprivate", decl);
11075 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
11076 && OMP_CLAUSE_DECL (c) == decl)
11077 error ("iteration variable %qD should not be reduction", decl);
11081 c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
11082 OMP_CLAUSE_DECL (c) = decl;
11083 c = finish_omp_clauses (c);
11086 OMP_CLAUSE_CHAIN (c) = *clauses;
11091 cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
11092 if (COMPARISON_CLASS_P (cond))
11093 cond = build2 (TREE_CODE (cond), boolean_type_node,
11094 RECUR (TREE_OPERAND (cond, 0)),
11095 RECUR (TREE_OPERAND (cond, 1)));
11097 cond = RECUR (cond);
11098 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
11099 switch (TREE_CODE (incr))
11101 case PREINCREMENT_EXPR:
11102 case PREDECREMENT_EXPR:
11103 case POSTINCREMENT_EXPR:
11104 case POSTDECREMENT_EXPR:
11105 incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
11106 RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
11109 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11110 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11112 tree rhs = TREE_OPERAND (incr, 1);
11113 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11114 RECUR (TREE_OPERAND (incr, 0)),
11115 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11116 RECUR (TREE_OPERAND (rhs, 0)),
11117 RECUR (TREE_OPERAND (rhs, 1))));
11120 incr = RECUR (incr);
11123 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11124 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11126 tree lhs = RECUR (TREE_OPERAND (incr, 0));
11127 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
11128 build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
11129 TREE_TYPE (decl), lhs,
11130 RECUR (TREE_OPERAND (incr, 2))));
11132 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
11133 && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
11134 || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
11136 tree rhs = TREE_OPERAND (incr, 2);
11137 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11138 RECUR (TREE_OPERAND (incr, 0)),
11139 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11140 RECUR (TREE_OPERAND (rhs, 0)),
11141 RECUR (TREE_OPERAND (rhs, 1))));
11144 incr = RECUR (incr);
11147 incr = RECUR (incr);
11151 TREE_VEC_ELT (declv, i) = decl;
11152 TREE_VEC_ELT (initv, i) = init;
11153 TREE_VEC_ELT (condv, i) = cond;
11154 TREE_VEC_ELT (incrv, i) = incr;
11158 /* Like tsubst_copy for expressions, etc. but also does semantic
11162 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
11163 bool integral_constant_expression_p)
11165 #define RECUR(NODE) \
11166 tsubst_expr ((NODE), args, complain, in_decl, \
11167 integral_constant_expression_p)
11171 if (t == NULL_TREE || t == error_mark_node)
11174 if (EXPR_HAS_LOCATION (t))
11175 input_location = EXPR_LOCATION (t);
11176 if (STATEMENT_CODE_P (TREE_CODE (t)))
11177 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
11179 switch (TREE_CODE (t))
11181 case STATEMENT_LIST:
11183 tree_stmt_iterator i;
11184 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
11185 RECUR (tsi_stmt (i));
11189 case CTOR_INITIALIZER:
11190 finish_mem_initializers (tsubst_initializer_list
11191 (TREE_OPERAND (t, 0), args));
11195 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
11199 tmp = RECUR (EXPR_STMT_EXPR (t));
11200 if (EXPR_STMT_STMT_EXPR_RESULT (t))
11201 finish_stmt_expr_expr (tmp, cur_stmt_expr);
11203 finish_expr_stmt (tmp);
11207 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
11215 decl = DECL_EXPR_DECL (t);
11216 if (TREE_CODE (decl) == LABEL_DECL)
11217 finish_label_decl (DECL_NAME (decl));
11218 else if (TREE_CODE (decl) == USING_DECL)
11220 tree scope = USING_DECL_SCOPE (decl);
11221 tree name = DECL_NAME (decl);
11224 scope = RECUR (scope);
11225 decl = lookup_qualified_name (scope, name,
11226 /*is_type_p=*/false,
11227 /*complain=*/false);
11228 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
11229 qualified_name_lookup_error (scope, name, decl, input_location);
11231 do_local_using_decl (decl, scope, name);
11235 init = DECL_INITIAL (decl);
11236 decl = tsubst (decl, args, complain, in_decl);
11237 if (decl != error_mark_node)
11239 /* By marking the declaration as instantiated, we avoid
11240 trying to instantiate it. Since instantiate_decl can't
11241 handle local variables, and since we've already done
11242 all that needs to be done, that's the right thing to
11244 if (TREE_CODE (decl) == VAR_DECL)
11245 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11246 if (TREE_CODE (decl) == VAR_DECL
11247 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
11248 /* Anonymous aggregates are a special case. */
11249 finish_anon_union (decl);
11252 maybe_push_decl (decl);
11253 if (TREE_CODE (decl) == VAR_DECL
11254 && DECL_PRETTY_FUNCTION_P (decl))
11256 /* For __PRETTY_FUNCTION__ we have to adjust the
11258 const char *const name
11259 = cxx_printable_name (current_function_decl, 2);
11260 init = cp_fname_init (name, &TREE_TYPE (decl));
11264 tree t = RECUR (init);
11267 /* If we had an initializer but it
11268 instantiated to nothing,
11269 value-initialize the object. This will
11270 only occur when the initializer was a
11271 pack expansion where the parameter packs
11272 used in that expansion were of length
11274 init = build_value_init (TREE_TYPE (decl));
11279 cp_finish_decl (decl, init, false, NULL_TREE, 0);
11284 /* A DECL_EXPR can also be used as an expression, in the condition
11285 clause of an if/for/while construct. */
11290 stmt = begin_for_stmt ();
11291 RECUR (FOR_INIT_STMT (t));
11292 finish_for_init_stmt (stmt);
11293 tmp = RECUR (FOR_COND (t));
11294 finish_for_cond (tmp, stmt);
11295 tmp = RECUR (FOR_EXPR (t));
11296 finish_for_expr (tmp, stmt);
11297 RECUR (FOR_BODY (t));
11298 finish_for_stmt (stmt);
11302 stmt = begin_while_stmt ();
11303 tmp = RECUR (WHILE_COND (t));
11304 finish_while_stmt_cond (tmp, stmt);
11305 RECUR (WHILE_BODY (t));
11306 finish_while_stmt (stmt);
11310 stmt = begin_do_stmt ();
11311 RECUR (DO_BODY (t));
11312 finish_do_body (stmt);
11313 tmp = RECUR (DO_COND (t));
11314 finish_do_stmt (tmp, stmt);
11318 stmt = begin_if_stmt ();
11319 tmp = RECUR (IF_COND (t));
11320 finish_if_stmt_cond (tmp, stmt);
11321 RECUR (THEN_CLAUSE (t));
11322 finish_then_clause (stmt);
11324 if (ELSE_CLAUSE (t))
11326 begin_else_clause (stmt);
11327 RECUR (ELSE_CLAUSE (t));
11328 finish_else_clause (stmt);
11331 finish_if_stmt (stmt);
11335 if (BIND_EXPR_BODY_BLOCK (t))
11336 stmt = begin_function_body ();
11338 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
11339 ? BCS_TRY_BLOCK : 0);
11341 RECUR (BIND_EXPR_BODY (t));
11343 if (BIND_EXPR_BODY_BLOCK (t))
11344 finish_function_body (stmt);
11346 finish_compound_stmt (stmt);
11350 finish_break_stmt ();
11353 case CONTINUE_STMT:
11354 finish_continue_stmt ();
11358 stmt = begin_switch_stmt ();
11359 tmp = RECUR (SWITCH_STMT_COND (t));
11360 finish_switch_cond (tmp, stmt);
11361 RECUR (SWITCH_STMT_BODY (t));
11362 finish_switch_stmt (stmt);
11365 case CASE_LABEL_EXPR:
11366 finish_case_label (EXPR_LOCATION (t),
11367 RECUR (CASE_LOW (t)),
11368 RECUR (CASE_HIGH (t)));
11373 tree decl = LABEL_EXPR_LABEL (t);
11376 label = finish_label_stmt (DECL_NAME (decl));
11377 if (DECL_ATTRIBUTES (decl) != NULL_TREE)
11378 cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
11383 tmp = GOTO_DESTINATION (t);
11384 if (TREE_CODE (tmp) != LABEL_DECL)
11385 /* Computed goto's must be tsubst'd into. On the other hand,
11386 non-computed gotos must not be; the identifier in question
11387 will have no binding. */
11390 tmp = DECL_NAME (tmp);
11391 finish_goto_stmt (tmp);
11395 tmp = finish_asm_stmt
11396 (ASM_VOLATILE_P (t),
11397 RECUR (ASM_STRING (t)),
11398 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
11399 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
11400 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl),
11401 tsubst_copy_asm_operands (ASM_LABELS (t), args, complain, in_decl));
11403 tree asm_expr = tmp;
11404 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
11405 asm_expr = TREE_OPERAND (asm_expr, 0);
11406 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
11413 stmt = begin_try_block ();
11414 RECUR (TRY_STMTS (t));
11415 finish_cleanup_try_block (stmt);
11416 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
11420 tree compound_stmt = NULL_TREE;
11422 if (FN_TRY_BLOCK_P (t))
11423 stmt = begin_function_try_block (&compound_stmt);
11425 stmt = begin_try_block ();
11427 RECUR (TRY_STMTS (t));
11429 if (FN_TRY_BLOCK_P (t))
11430 finish_function_try_block (stmt);
11432 finish_try_block (stmt);
11434 RECUR (TRY_HANDLERS (t));
11435 if (FN_TRY_BLOCK_P (t))
11436 finish_function_handler_sequence (stmt, compound_stmt);
11438 finish_handler_sequence (stmt);
11444 tree decl = HANDLER_PARMS (t);
11448 decl = tsubst (decl, args, complain, in_decl);
11449 /* Prevent instantiate_decl from trying to instantiate
11450 this variable. We've already done all that needs to be
11452 if (decl != error_mark_node)
11453 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11455 stmt = begin_handler ();
11456 finish_handler_parms (decl, stmt);
11457 RECUR (HANDLER_BODY (t));
11458 finish_handler (stmt);
11463 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
11466 case STATIC_ASSERT:
11469 tsubst_expr (STATIC_ASSERT_CONDITION (t),
11472 /*integral_constant_expression_p=*/true);
11473 finish_static_assert (condition,
11474 STATIC_ASSERT_MESSAGE (t),
11475 STATIC_ASSERT_SOURCE_LOCATION (t),
11476 /*member_p=*/false);
11481 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
11482 args, complain, in_decl);
11483 stmt = begin_omp_parallel ();
11484 RECUR (OMP_PARALLEL_BODY (t));
11485 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
11486 = OMP_PARALLEL_COMBINED (t);
11490 tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t),
11491 args, complain, in_decl);
11492 stmt = begin_omp_task ();
11493 RECUR (OMP_TASK_BODY (t));
11494 finish_omp_task (tmp, stmt);
11499 tree clauses, body, pre_body;
11500 tree declv, initv, condv, incrv;
11503 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
11504 args, complain, in_decl);
11505 declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11506 initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11507 condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11508 incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11510 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
11511 tsubst_omp_for_iterator (t, i, declv, initv, condv, incrv,
11512 &clauses, args, complain, in_decl,
11513 integral_constant_expression_p);
11515 stmt = begin_omp_structured_block ();
11517 for (i = 0; i < TREE_VEC_LENGTH (initv); i++)
11518 if (TREE_VEC_ELT (initv, i) == NULL
11519 || TREE_CODE (TREE_VEC_ELT (initv, i)) != DECL_EXPR)
11520 TREE_VEC_ELT (initv, i) = RECUR (TREE_VEC_ELT (initv, i));
11521 else if (CLASS_TYPE_P (TREE_TYPE (TREE_VEC_ELT (initv, i))))
11523 tree init = RECUR (TREE_VEC_ELT (initv, i));
11524 gcc_assert (init == TREE_VEC_ELT (declv, i));
11525 TREE_VEC_ELT (initv, i) = NULL_TREE;
11529 tree decl_expr = TREE_VEC_ELT (initv, i);
11530 tree init = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
11531 gcc_assert (init != NULL);
11532 TREE_VEC_ELT (initv, i) = RECUR (init);
11533 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL;
11535 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init;
11538 pre_body = push_stmt_list ();
11539 RECUR (OMP_FOR_PRE_BODY (t));
11540 pre_body = pop_stmt_list (pre_body);
11542 body = push_stmt_list ();
11543 RECUR (OMP_FOR_BODY (t));
11544 body = pop_stmt_list (body);
11546 t = finish_omp_for (EXPR_LOCATION (t), declv, initv, condv, incrv,
11547 body, pre_body, clauses);
11549 add_stmt (finish_omp_structured_block (stmt));
11555 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
11556 stmt = push_stmt_list ();
11557 RECUR (OMP_BODY (t));
11558 stmt = pop_stmt_list (stmt);
11561 OMP_BODY (t) = stmt;
11562 OMP_CLAUSES (t) = tmp;
11570 stmt = push_stmt_list ();
11571 RECUR (OMP_BODY (t));
11572 stmt = pop_stmt_list (stmt);
11575 OMP_BODY (t) = stmt;
11580 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
11582 tree op1 = TREE_OPERAND (t, 1);
11583 tree lhs = RECUR (TREE_OPERAND (op1, 0));
11584 tree rhs = RECUR (TREE_OPERAND (op1, 1));
11585 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
11589 case EXPR_PACK_EXPANSION:
11590 error ("invalid use of pack expansion expression");
11591 return error_mark_node;
11593 case NONTYPE_ARGUMENT_PACK:
11594 error ("use %<...%> to expand argument pack");
11595 return error_mark_node;
11598 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
11600 return tsubst_copy_and_build (t, args, complain, in_decl,
11601 /*function_p=*/false,
11602 integral_constant_expression_p);
11609 /* T is a postfix-expression that is not being used in a function
11610 call. Return the substituted version of T. */
11613 tsubst_non_call_postfix_expression (tree t, tree args,
11614 tsubst_flags_t complain,
11617 if (TREE_CODE (t) == SCOPE_REF)
11618 t = tsubst_qualified_id (t, args, complain, in_decl,
11619 /*done=*/false, /*address_p=*/false);
11621 t = tsubst_copy_and_build (t, args, complain, in_decl,
11622 /*function_p=*/false,
11623 /*integral_constant_expression_p=*/false);
11628 /* Like tsubst but deals with expressions and performs semantic
11629 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11632 tsubst_copy_and_build (tree t,
11634 tsubst_flags_t complain,
11637 bool integral_constant_expression_p)
11639 #define RECUR(NODE) \
11640 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11641 /*function_p=*/false, \
11642 integral_constant_expression_p)
11646 if (t == NULL_TREE || t == error_mark_node)
11649 switch (TREE_CODE (t))
11653 /* Fall through. */
11654 case IDENTIFIER_NODE:
11658 bool non_integral_constant_expression_p;
11659 const char *error_msg;
11661 if (IDENTIFIER_TYPENAME_P (t))
11663 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11664 t = mangle_conv_op_name_for_type (new_type);
11667 /* Look up the name. */
11668 decl = lookup_name (t);
11670 /* By convention, expressions use ERROR_MARK_NODE to indicate
11671 failure, not NULL_TREE. */
11672 if (decl == NULL_TREE)
11673 decl = error_mark_node;
11675 decl = finish_id_expression (t, decl, NULL_TREE,
11677 integral_constant_expression_p,
11678 /*allow_non_integral_constant_expression_p=*/false,
11679 &non_integral_constant_expression_p,
11680 /*template_p=*/false,
11682 /*address_p=*/false,
11683 /*template_arg_p=*/false,
11688 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
11689 decl = unqualified_name_lookup_error (decl);
11693 case TEMPLATE_ID_EXPR:
11696 tree templ = RECUR (TREE_OPERAND (t, 0));
11697 tree targs = TREE_OPERAND (t, 1);
11700 targs = tsubst_template_args (targs, args, complain, in_decl);
11702 if (TREE_CODE (templ) == COMPONENT_REF)
11704 object = TREE_OPERAND (templ, 0);
11705 templ = TREE_OPERAND (templ, 1);
11708 object = NULL_TREE;
11709 templ = lookup_template_function (templ, targs);
11712 return build3 (COMPONENT_REF, TREE_TYPE (templ),
11713 object, templ, NULL_TREE);
11715 return baselink_for_fns (templ);
11720 tree r = RECUR (TREE_OPERAND (t, 0));
11722 if (REFERENCE_REF_P (t))
11724 /* A type conversion to reference type will be enclosed in
11725 such an indirect ref, but the substitution of the cast
11726 will have also added such an indirect ref. */
11727 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
11728 r = convert_from_reference (r);
11731 r = build_x_indirect_ref (r, "unary *", complain);
11737 (tsubst (TREE_TYPE (t), args, complain, in_decl),
11738 RECUR (TREE_OPERAND (t, 0)));
11741 case REINTERPRET_CAST_EXPR:
11742 case CONST_CAST_EXPR:
11743 case DYNAMIC_CAST_EXPR:
11744 case STATIC_CAST_EXPR:
11749 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11750 if (integral_constant_expression_p
11751 && !cast_valid_in_integral_constant_expression_p (type))
11753 if (complain & tf_error)
11754 error ("a cast to a type other than an integral or "
11755 "enumeration type cannot appear in a constant-expression");
11756 return error_mark_node;
11759 op = RECUR (TREE_OPERAND (t, 0));
11761 switch (TREE_CODE (t))
11764 return build_functional_cast (type, op, complain);
11765 case REINTERPRET_CAST_EXPR:
11766 return build_reinterpret_cast (type, op, complain);
11767 case CONST_CAST_EXPR:
11768 return build_const_cast (type, op, complain);
11769 case DYNAMIC_CAST_EXPR:
11770 return build_dynamic_cast (type, op, complain);
11771 case STATIC_CAST_EXPR:
11772 return build_static_cast (type, op, complain);
11774 gcc_unreachable ();
11778 case POSTDECREMENT_EXPR:
11779 case POSTINCREMENT_EXPR:
11780 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11781 args, complain, in_decl);
11782 return build_x_unary_op (TREE_CODE (t), op1, complain);
11784 case PREDECREMENT_EXPR:
11785 case PREINCREMENT_EXPR:
11789 case TRUTH_NOT_EXPR:
11790 case UNARY_PLUS_EXPR: /* Unary + */
11791 case REALPART_EXPR:
11792 case IMAGPART_EXPR:
11793 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)),
11797 op1 = TREE_OPERAND (t, 0);
11798 if (TREE_CODE (op1) == SCOPE_REF)
11799 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
11800 /*done=*/true, /*address_p=*/true);
11802 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
11804 if (TREE_CODE (op1) == LABEL_DECL)
11805 return finish_label_address_expr (DECL_NAME (op1),
11806 EXPR_LOCATION (op1));
11807 return build_x_unary_op (ADDR_EXPR, op1, complain);
11812 case TRUNC_DIV_EXPR:
11813 case CEIL_DIV_EXPR:
11814 case FLOOR_DIV_EXPR:
11815 case ROUND_DIV_EXPR:
11816 case EXACT_DIV_EXPR:
11820 case TRUNC_MOD_EXPR:
11821 case FLOOR_MOD_EXPR:
11822 case TRUTH_ANDIF_EXPR:
11823 case TRUTH_ORIF_EXPR:
11824 case TRUTH_AND_EXPR:
11825 case TRUTH_OR_EXPR:
11840 return build_x_binary_op
11842 RECUR (TREE_OPERAND (t, 0)),
11843 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
11845 : TREE_CODE (TREE_OPERAND (t, 0))),
11846 RECUR (TREE_OPERAND (t, 1)),
11847 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
11849 : TREE_CODE (TREE_OPERAND (t, 1))),
11850 /*overloaded_p=*/NULL,
11854 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
11855 /*address_p=*/false);
11857 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11858 args, complain, in_decl);
11859 return build_x_array_ref (op1, RECUR (TREE_OPERAND (t, 1)), complain);
11862 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
11863 return tsubst_copy (t, args, complain, in_decl);
11867 op1 = TREE_OPERAND (t, 0);
11870 /* When there are no ARGS, we are trying to evaluate a
11871 non-dependent expression from the parser. Trying to do
11872 the substitutions may not work. */
11874 op1 = TREE_TYPE (op1);
11878 ++cp_unevaluated_operand;
11879 ++c_inhibit_evaluation_warnings;
11880 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
11881 /*function_p=*/false,
11882 /*integral_constant_expression_p=*/false);
11883 --cp_unevaluated_operand;
11884 --c_inhibit_evaluation_warnings;
11887 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t),
11888 complain & tf_error);
11890 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t),
11891 complain & tf_error);
11895 tree r = build_x_modify_expr
11896 (RECUR (TREE_OPERAND (t, 0)),
11897 TREE_CODE (TREE_OPERAND (t, 1)),
11898 RECUR (TREE_OPERAND (t, 2)),
11900 /* TREE_NO_WARNING must be set if either the expression was
11901 parenthesized or it uses an operator such as >>= rather
11902 than plain assignment. In the former case, it was already
11903 set and must be copied. In the latter case,
11904 build_x_modify_expr sets it and it must not be reset
11906 if (TREE_NO_WARNING (t))
11907 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
11912 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11913 args, complain, in_decl);
11914 /* Remember that there was a reference to this entity. */
11917 return build_x_arrow (op1);
11921 tree placement = RECUR (TREE_OPERAND (t, 0));
11922 tree init = RECUR (TREE_OPERAND (t, 3));
11923 VEC(tree,gc) *placement_vec;
11924 VEC(tree,gc) *init_vec;
11927 if (placement == NULL_TREE)
11928 placement_vec = NULL;
11931 placement_vec = make_tree_vector ();
11932 for (; placement != NULL_TREE; placement = TREE_CHAIN (placement))
11933 VEC_safe_push (tree, gc, placement_vec, TREE_VALUE (placement));
11936 /* If there was an initializer in the original tree, but it
11937 instantiated to an empty list, then we should pass a
11938 non-NULL empty vector to tell build_new that it was an
11939 empty initializer() rather than no initializer. This can
11940 only happen when the initializer is a pack expansion whose
11941 parameter packs are of length zero. */
11942 if (init == NULL_TREE && TREE_OPERAND (t, 3) == NULL_TREE)
11946 init_vec = make_tree_vector ();
11947 if (init == void_zero_node)
11948 gcc_assert (init_vec != NULL);
11951 for (; init != NULL_TREE; init = TREE_CHAIN (init))
11952 VEC_safe_push (tree, gc, init_vec, TREE_VALUE (init));
11956 ret = build_new (&placement_vec,
11957 RECUR (TREE_OPERAND (t, 1)),
11958 RECUR (TREE_OPERAND (t, 2)),
11960 NEW_EXPR_USE_GLOBAL (t),
11963 if (placement_vec != NULL)
11964 release_tree_vector (placement_vec);
11965 if (init_vec != NULL)
11966 release_tree_vector (init_vec);
11972 return delete_sanity
11973 (RECUR (TREE_OPERAND (t, 0)),
11974 RECUR (TREE_OPERAND (t, 1)),
11975 DELETE_EXPR_USE_VEC (t),
11976 DELETE_EXPR_USE_GLOBAL (t));
11978 case COMPOUND_EXPR:
11979 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
11980 RECUR (TREE_OPERAND (t, 1)),
11986 VEC(tree,gc) *call_args;
11987 unsigned int nargs, i;
11992 function = CALL_EXPR_FN (t);
11993 /* When we parsed the expression, we determined whether or
11994 not Koenig lookup should be performed. */
11995 koenig_p = KOENIG_LOOKUP_P (t);
11996 if (TREE_CODE (function) == SCOPE_REF)
11998 qualified_p = true;
11999 function = tsubst_qualified_id (function, args, complain, in_decl,
12001 /*address_p=*/false);
12005 if (TREE_CODE (function) == COMPONENT_REF)
12007 tree op = TREE_OPERAND (function, 1);
12009 qualified_p = (TREE_CODE (op) == SCOPE_REF
12010 || (BASELINK_P (op)
12011 && BASELINK_QUALIFIED_P (op)));
12014 qualified_p = false;
12016 function = tsubst_copy_and_build (function, args, complain,
12019 integral_constant_expression_p);
12021 if (BASELINK_P (function))
12022 qualified_p = true;
12025 nargs = call_expr_nargs (t);
12026 call_args = make_tree_vector ();
12027 for (i = 0; i < nargs; ++i)
12029 tree arg = CALL_EXPR_ARG (t, i);
12031 if (!PACK_EXPANSION_P (arg))
12032 VEC_safe_push (tree, gc, call_args,
12033 RECUR (CALL_EXPR_ARG (t, i)));
12036 /* Expand the pack expansion and push each entry onto
12038 arg = tsubst_pack_expansion (arg, args, complain, in_decl);
12039 if (TREE_CODE (arg) == TREE_VEC)
12041 unsigned int len, j;
12043 len = TREE_VEC_LENGTH (arg);
12044 for (j = 0; j < len; ++j)
12046 tree value = TREE_VEC_ELT (arg, j);
12047 if (value != NULL_TREE)
12048 value = convert_from_reference (value);
12049 VEC_safe_push (tree, gc, call_args, value);
12054 /* A partial substitution. Add one entry. */
12055 VEC_safe_push (tree, gc, call_args, arg);
12060 /* We do not perform argument-dependent lookup if normal
12061 lookup finds a non-function, in accordance with the
12062 expected resolution of DR 218. */
12064 && ((is_overloaded_fn (function)
12065 /* If lookup found a member function, the Koenig lookup is
12066 not appropriate, even if an unqualified-name was used
12067 to denote the function. */
12068 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
12069 || TREE_CODE (function) == IDENTIFIER_NODE)
12070 /* Only do this when substitution turns a dependent call
12071 into a non-dependent call. */
12072 && type_dependent_expression_p_push (t)
12073 && !any_type_dependent_arguments_p (call_args))
12074 function = perform_koenig_lookup (function, call_args);
12076 if (TREE_CODE (function) == IDENTIFIER_NODE)
12078 unqualified_name_lookup_error (function);
12079 release_tree_vector (call_args);
12080 return error_mark_node;
12083 /* Remember that there was a reference to this entity. */
12084 if (DECL_P (function))
12085 mark_used (function);
12087 if (TREE_CODE (function) == OFFSET_REF)
12088 ret = build_offset_ref_call_from_tree (function, &call_args);
12089 else if (TREE_CODE (function) == COMPONENT_REF)
12091 if (!BASELINK_P (TREE_OPERAND (function, 1)))
12092 ret = finish_call_expr (function, &call_args,
12093 /*disallow_virtual=*/false,
12094 /*koenig_p=*/false,
12097 ret = (build_new_method_call
12098 (TREE_OPERAND (function, 0),
12099 TREE_OPERAND (function, 1),
12100 &call_args, NULL_TREE,
12101 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
12106 ret = finish_call_expr (function, &call_args,
12107 /*disallow_virtual=*/qualified_p,
12111 release_tree_vector (call_args);
12117 return build_x_conditional_expr
12118 (RECUR (TREE_OPERAND (t, 0)),
12119 RECUR (TREE_OPERAND (t, 1)),
12120 RECUR (TREE_OPERAND (t, 2)),
12123 case PSEUDO_DTOR_EXPR:
12124 return finish_pseudo_destructor_expr
12125 (RECUR (TREE_OPERAND (t, 0)),
12126 RECUR (TREE_OPERAND (t, 1)),
12127 RECUR (TREE_OPERAND (t, 2)));
12131 tree purpose, value, chain;
12133 if (t == void_list_node)
12136 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
12137 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
12139 /* We have pack expansions, so expand those and
12140 create a new list out of it. */
12141 tree purposevec = NULL_TREE;
12142 tree valuevec = NULL_TREE;
12146 /* Expand the argument expressions. */
12147 if (TREE_PURPOSE (t))
12148 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
12149 complain, in_decl);
12150 if (TREE_VALUE (t))
12151 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
12152 complain, in_decl);
12154 /* Build the rest of the list. */
12155 chain = TREE_CHAIN (t);
12156 if (chain && chain != void_type_node)
12157 chain = RECUR (chain);
12159 /* Determine the number of arguments. */
12160 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
12162 len = TREE_VEC_LENGTH (purposevec);
12163 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
12165 else if (TREE_CODE (valuevec) == TREE_VEC)
12166 len = TREE_VEC_LENGTH (valuevec);
12169 /* Since we only performed a partial substitution into
12170 the argument pack, we only return a single list
12172 if (purposevec == TREE_PURPOSE (t)
12173 && valuevec == TREE_VALUE (t)
12174 && chain == TREE_CHAIN (t))
12177 return tree_cons (purposevec, valuevec, chain);
12180 /* Convert the argument vectors into a TREE_LIST */
12184 /* Grab the Ith values. */
12186 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
12189 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
12192 /* Build the list (backwards). */
12193 chain = tree_cons (purpose, value, chain);
12199 purpose = TREE_PURPOSE (t);
12201 purpose = RECUR (purpose);
12202 value = TREE_VALUE (t);
12204 value = RECUR (value);
12205 chain = TREE_CHAIN (t);
12206 if (chain && chain != void_type_node)
12207 chain = RECUR (chain);
12208 if (purpose == TREE_PURPOSE (t)
12209 && value == TREE_VALUE (t)
12210 && chain == TREE_CHAIN (t))
12212 return tree_cons (purpose, value, chain);
12215 case COMPONENT_REF:
12221 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12222 args, complain, in_decl);
12223 /* Remember that there was a reference to this entity. */
12224 if (DECL_P (object))
12225 mark_used (object);
12226 object_type = TREE_TYPE (object);
12228 member = TREE_OPERAND (t, 1);
12229 if (BASELINK_P (member))
12230 member = tsubst_baselink (member,
12231 non_reference (TREE_TYPE (object)),
12232 args, complain, in_decl);
12234 member = tsubst_copy (member, args, complain, in_decl);
12235 if (member == error_mark_node)
12236 return error_mark_node;
12238 if (object_type && !CLASS_TYPE_P (object_type))
12240 if (SCALAR_TYPE_P (object_type))
12242 tree s = NULL_TREE;
12243 tree dtor = member;
12245 if (TREE_CODE (dtor) == SCOPE_REF)
12247 s = TREE_OPERAND (dtor, 0);
12248 dtor = TREE_OPERAND (dtor, 1);
12250 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
12252 dtor = TREE_OPERAND (dtor, 0);
12254 return finish_pseudo_destructor_expr (object, s, dtor);
12258 else if (TREE_CODE (member) == SCOPE_REF
12259 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
12264 /* Lookup the template functions now that we know what the
12266 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
12267 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
12268 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
12269 /*is_type_p=*/false,
12270 /*complain=*/false);
12271 if (BASELINK_P (member))
12273 BASELINK_FUNCTIONS (member)
12274 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
12276 member = (adjust_result_of_qualified_name_lookup
12277 (member, BINFO_TYPE (BASELINK_BINFO (member)),
12282 qualified_name_lookup_error (object_type, tmpl, member,
12284 return error_mark_node;
12287 else if (TREE_CODE (member) == SCOPE_REF
12288 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
12289 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
12291 if (complain & tf_error)
12293 if (TYPE_P (TREE_OPERAND (member, 0)))
12294 error ("%qT is not a class or namespace",
12295 TREE_OPERAND (member, 0));
12297 error ("%qD is not a class or namespace",
12298 TREE_OPERAND (member, 0));
12300 return error_mark_node;
12302 else if (TREE_CODE (member) == FIELD_DECL)
12303 return finish_non_static_data_member (member, object, NULL_TREE);
12305 return finish_class_member_access_expr (object, member,
12306 /*template_p=*/false,
12312 (RECUR (TREE_OPERAND (t, 0)));
12316 VEC(constructor_elt,gc) *n;
12317 constructor_elt *ce;
12318 unsigned HOST_WIDE_INT idx;
12319 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
12320 bool process_index_p;
12322 bool need_copy_p = false;
12325 if (type == error_mark_node)
12326 return error_mark_node;
12328 /* digest_init will do the wrong thing if we let it. */
12329 if (type && TYPE_PTRMEMFUNC_P (type))
12332 /* We do not want to process the index of aggregate
12333 initializers as they are identifier nodes which will be
12334 looked up by digest_init. */
12335 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
12337 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
12338 newlen = VEC_length (constructor_elt, n);
12339 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
12341 if (ce->index && process_index_p)
12342 ce->index = RECUR (ce->index);
12344 if (PACK_EXPANSION_P (ce->value))
12346 /* Substitute into the pack expansion. */
12347 ce->value = tsubst_pack_expansion (ce->value, args, complain,
12350 if (ce->value == error_mark_node)
12352 else if (TREE_VEC_LENGTH (ce->value) == 1)
12353 /* Just move the argument into place. */
12354 ce->value = TREE_VEC_ELT (ce->value, 0);
12357 /* Update the length of the final CONSTRUCTOR
12358 arguments vector, and note that we will need to
12360 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
12361 need_copy_p = true;
12365 ce->value = RECUR (ce->value);
12370 VEC(constructor_elt,gc) *old_n = n;
12372 n = VEC_alloc (constructor_elt, gc, newlen);
12373 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
12376 if (TREE_CODE (ce->value) == TREE_VEC)
12378 int i, len = TREE_VEC_LENGTH (ce->value);
12379 for (i = 0; i < len; ++i)
12380 CONSTRUCTOR_APPEND_ELT (n, 0,
12381 TREE_VEC_ELT (ce->value, i));
12384 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
12388 r = build_constructor (init_list_type_node, n);
12389 CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
12391 if (TREE_HAS_CONSTRUCTOR (t))
12392 return finish_compound_literal (type, r);
12399 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
12400 if (TYPE_P (operand_0))
12401 return get_typeid (operand_0);
12402 return build_typeid (operand_0);
12412 tree r = tsubst_copy (t, args, complain, in_decl);
12414 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
12415 /* If the original type was a reference, we'll be wrapped in
12416 the appropriate INDIRECT_REF. */
12417 r = convert_from_reference (r);
12422 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
12423 tsubst_copy (TREE_TYPE (t), args, complain,
12426 case OFFSETOF_EXPR:
12427 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
12431 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
12432 complain, in_decl);
12434 tree type2 = TRAIT_EXPR_TYPE2 (t);
12436 type2 = tsubst_copy (type2, args, complain, in_decl);
12438 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
12443 tree old_stmt_expr = cur_stmt_expr;
12444 tree stmt_expr = begin_stmt_expr ();
12446 cur_stmt_expr = stmt_expr;
12447 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
12448 integral_constant_expression_p);
12449 stmt_expr = finish_stmt_expr (stmt_expr, false);
12450 cur_stmt_expr = old_stmt_expr;
12456 t = tsubst_copy (t, args, complain, in_decl);
12457 /* As in finish_id_expression, we resolve enumeration constants
12458 to their underlying values. */
12459 if (TREE_CODE (t) == CONST_DECL)
12461 used_types_insert (TREE_TYPE (t));
12462 return DECL_INITIAL (t);
12468 tree r = build_lambda_expr ();
12470 tree type = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
12471 TREE_TYPE (r) = type;
12472 CLASSTYPE_LAMBDA_EXPR (type) = r;
12474 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r)
12475 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t);
12476 LAMBDA_EXPR_MUTABLE_P (r) = LAMBDA_EXPR_MUTABLE_P (t);
12477 LAMBDA_EXPR_DISCRIMINATOR (r)
12478 = (LAMBDA_EXPR_DISCRIMINATOR (t));
12479 LAMBDA_EXPR_CAPTURE_LIST (r)
12480 = RECUR (LAMBDA_EXPR_CAPTURE_LIST (t));
12481 LAMBDA_EXPR_THIS_CAPTURE (r)
12482 = RECUR (LAMBDA_EXPR_THIS_CAPTURE (t));
12483 LAMBDA_EXPR_EXTRA_SCOPE (r)
12484 = RECUR (LAMBDA_EXPR_EXTRA_SCOPE (t));
12486 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
12487 determine_visibility (TYPE_NAME (type));
12488 /* Now that we know visibility, instantiate the type so we have a
12489 declaration of the op() for later calls to lambda_function. */
12490 complete_type (type);
12492 type = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl);
12494 apply_lambda_return_type (r, type);
12496 return build_lambda_object (r);
12500 /* Handle Objective-C++ constructs, if appropriate. */
12503 = objcp_tsubst_copy_and_build (t, args, complain,
12504 in_decl, /*function_p=*/false);
12508 return tsubst_copy (t, args, complain, in_decl);
12514 /* Verify that the instantiated ARGS are valid. For type arguments,
12515 make sure that the type's linkage is ok. For non-type arguments,
12516 make sure they are constants if they are integral or enumerations.
12517 Emit an error under control of COMPLAIN, and return TRUE on error. */
12520 check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
12522 if (ARGUMENT_PACK_P (t))
12524 tree vec = ARGUMENT_PACK_ARGS (t);
12525 int len = TREE_VEC_LENGTH (vec);
12526 bool result = false;
12529 for (i = 0; i < len; ++i)
12530 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
12534 else if (TYPE_P (t))
12536 /* [basic.link]: A name with no linkage (notably, the name
12537 of a class or enumeration declared in a local scope)
12538 shall not be used to declare an entity with linkage.
12539 This implies that names with no linkage cannot be used as
12542 DR 757 relaxes this restriction for C++0x. */
12543 tree nt = (cxx_dialect > cxx98 ? NULL_TREE
12544 : no_linkage_check (t, /*relaxed_p=*/false));
12548 /* DR 488 makes use of a type with no linkage cause
12549 type deduction to fail. */
12550 if (complain & tf_error)
12552 if (TYPE_ANONYMOUS_P (nt))
12553 error ("%qT is/uses anonymous type", t);
12555 error ("template argument for %qD uses local type %qT",
12560 /* In order to avoid all sorts of complications, we do not
12561 allow variably-modified types as template arguments. */
12562 else if (variably_modified_type_p (t, NULL_TREE))
12564 if (complain & tf_error)
12565 error ("%qT is a variably modified type", t);
12569 /* A non-type argument of integral or enumerated type must be a
12571 else if (TREE_TYPE (t)
12572 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
12573 && !TREE_CONSTANT (t))
12575 if (complain & tf_error)
12576 error ("integral expression %qE is not constant", t);
12583 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
12585 int ix, len = DECL_NTPARMS (tmpl);
12586 bool result = false;
12588 for (ix = 0; ix != len; ix++)
12590 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
12593 if (result && (complain & tf_error))
12594 error (" trying to instantiate %qD", tmpl);
12598 /* Instantiate the indicated variable or function template TMPL with
12599 the template arguments in TARG_PTR. */
12602 instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
12604 tree targ_ptr = orig_args;
12608 HOST_WIDE_INT saved_processing_template_decl;
12610 if (tmpl == error_mark_node)
12611 return error_mark_node;
12613 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
12615 /* If this function is a clone, handle it specially. */
12616 if (DECL_CLONED_FUNCTION_P (tmpl))
12621 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
12622 DECL_CLONED_FUNCTION. */
12623 spec = instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl),
12624 targ_ptr, complain);
12625 if (spec == error_mark_node)
12626 return error_mark_node;
12628 /* Look for the clone. */
12629 FOR_EACH_CLONE (clone, spec)
12630 if (DECL_NAME (clone) == DECL_NAME (tmpl))
12632 /* We should always have found the clone by now. */
12633 gcc_unreachable ();
12637 /* Check to see if we already have this specialization. */
12638 gen_tmpl = most_general_template (tmpl);
12639 if (tmpl != gen_tmpl)
12640 /* The TMPL is a partial instantiation. To get a full set of
12641 arguments we must add the arguments used to perform the
12642 partial instantiation. */
12643 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
12646 /* It would be nice to avoid hashing here and then again in tsubst_decl,
12647 but it doesn't seem to be on the hot path. */
12648 spec = retrieve_specialization (gen_tmpl, targ_ptr, 0);
12650 gcc_assert (tmpl == gen_tmpl
12651 || ((fndecl = retrieve_specialization (tmpl, orig_args, 0))
12653 || fndecl == NULL_TREE);
12655 if (spec != NULL_TREE)
12658 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
12660 return error_mark_node;
12662 /* We are building a FUNCTION_DECL, during which the access of its
12663 parameters and return types have to be checked. However this
12664 FUNCTION_DECL which is the desired context for access checking
12665 is not built yet. We solve this chicken-and-egg problem by
12666 deferring all checks until we have the FUNCTION_DECL. */
12667 push_deferring_access_checks (dk_deferred);
12669 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
12670 (because, for example, we have encountered a non-dependent
12671 function call in the body of a template function and must now
12672 determine which of several overloaded functions will be called),
12673 within the instantiation itself we are not processing a
12675 saved_processing_template_decl = processing_template_decl;
12676 processing_template_decl = 0;
12677 /* Substitute template parameters to obtain the specialization. */
12678 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
12679 targ_ptr, complain, gen_tmpl);
12680 processing_template_decl = saved_processing_template_decl;
12681 if (fndecl == error_mark_node)
12682 return error_mark_node;
12684 /* Now we know the specialization, compute access previously
12686 push_access_scope (fndecl);
12688 /* Some typedefs referenced from within the template code need to be access
12689 checked at template instantiation time, i.e now. These types were
12690 added to the template at parsing time. Let's get those and perfom
12691 the acces checks then. */
12692 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (tmpl), targ_ptr);
12693 perform_deferred_access_checks ();
12694 pop_access_scope (fndecl);
12695 pop_deferring_access_checks ();
12697 /* The DECL_TI_TEMPLATE should always be the immediate parent
12698 template, not the most general template. */
12699 DECL_TI_TEMPLATE (fndecl) = tmpl;
12701 /* If we've just instantiated the main entry point for a function,
12702 instantiate all the alternate entry points as well. We do this
12703 by cloning the instantiation of the main entry point, not by
12704 instantiating the template clones. */
12705 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
12706 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
12711 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
12712 NARGS elements of the arguments that are being used when calling
12713 it. TARGS is a vector into which the deduced template arguments
12716 Return zero for success, 2 for an incomplete match that doesn't resolve
12717 all the types, and 1 for complete failure. An error message will be
12718 printed only for an incomplete match.
12720 If FN is a conversion operator, or we are trying to produce a specific
12721 specialization, RETURN_TYPE is the return type desired.
12723 The EXPLICIT_TARGS are explicit template arguments provided via a
12726 The parameter STRICT is one of:
12729 We are deducing arguments for a function call, as in
12730 [temp.deduct.call].
12733 We are deducing arguments for a conversion function, as in
12734 [temp.deduct.conv].
12737 We are deducing arguments when doing an explicit instantiation
12738 as in [temp.explicit], when determining an explicit specialization
12739 as in [temp.expl.spec], or when taking the address of a function
12740 template, as in [temp.deduct.funcaddr]. */
12743 fn_type_unification (tree fn,
12744 tree explicit_targs,
12747 unsigned int nargs,
12749 unification_kind_t strict,
12755 bool incomplete_argument_packs_p = false;
12757 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
12759 fntype = TREE_TYPE (fn);
12760 if (explicit_targs)
12764 The specified template arguments must match the template
12765 parameters in kind (i.e., type, nontype, template), and there
12766 must not be more arguments than there are parameters;
12767 otherwise type deduction fails.
12769 Nontype arguments must match the types of the corresponding
12770 nontype template parameters, or must be convertible to the
12771 types of the corresponding nontype parameters as specified in
12772 _temp.arg.nontype_, otherwise type deduction fails.
12774 All references in the function type of the function template
12775 to the corresponding template parameters are replaced by the
12776 specified template argument values. If a substitution in a
12777 template parameter or in the function type of the function
12778 template results in an invalid type, type deduction fails. */
12779 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
12780 int i, len = TREE_VEC_LENGTH (tparms);
12781 tree converted_args;
12782 bool incomplete = false;
12784 if (explicit_targs == error_mark_node)
12788 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
12789 /*require_all_args=*/false,
12790 /*use_default_args=*/false));
12791 if (converted_args == error_mark_node)
12794 /* Substitute the explicit args into the function type. This is
12795 necessary so that, for instance, explicitly declared function
12796 arguments can match null pointed constants. If we were given
12797 an incomplete set of explicit args, we must not do semantic
12798 processing during substitution as we could create partial
12800 for (i = 0; i < len; i++)
12802 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
12803 bool parameter_pack = false;
12805 /* Dig out the actual parm. */
12806 if (TREE_CODE (parm) == TYPE_DECL
12807 || TREE_CODE (parm) == TEMPLATE_DECL)
12809 parm = TREE_TYPE (parm);
12810 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
12812 else if (TREE_CODE (parm) == PARM_DECL)
12814 parm = DECL_INITIAL (parm);
12815 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
12818 if (parameter_pack)
12822 template_parm_level_and_index (parm, &level, &idx);
12824 /* Mark the argument pack as "incomplete". We could
12825 still deduce more arguments during unification. */
12826 targ = TMPL_ARG (converted_args, level, idx);
12829 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
12830 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
12831 = ARGUMENT_PACK_ARGS (targ);
12834 /* We have some incomplete argument packs. */
12835 incomplete_argument_packs_p = true;
12839 if (incomplete_argument_packs_p)
12840 /* Any substitution is guaranteed to be incomplete if there
12841 are incomplete argument packs, because we can still deduce
12845 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
12847 processing_template_decl += incomplete;
12848 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
12849 processing_template_decl -= incomplete;
12851 if (fntype == error_mark_node)
12854 /* Place the explicitly specified arguments in TARGS. */
12855 for (i = NUM_TMPL_ARGS (converted_args); i--;)
12856 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
12859 /* Never do unification on the 'this' parameter. */
12860 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
12866 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
12867 new_args = XALLOCAVEC (tree, nargs + 1);
12868 new_args[0] = return_type;
12869 memcpy (new_args + 1, args, nargs * sizeof (tree));
12874 /* We allow incomplete unification without an error message here
12875 because the standard doesn't seem to explicitly prohibit it. Our
12876 callers must be ready to deal with unification failures in any
12878 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
12879 targs, parms, args, nargs, /*subr=*/0,
12882 if (result == 0 && incomplete_argument_packs_p)
12884 int i, len = NUM_TMPL_ARGS (targs);
12886 /* Clear the "incomplete" flags on all argument packs. */
12887 for (i = 0; i < len; i++)
12889 tree arg = TREE_VEC_ELT (targs, i);
12890 if (ARGUMENT_PACK_P (arg))
12892 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
12893 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
12898 /* Now that we have bindings for all of the template arguments,
12899 ensure that the arguments deduced for the template template
12900 parameters have compatible template parameter lists. We cannot
12901 check this property before we have deduced all template
12902 arguments, because the template parameter types of a template
12903 template parameter might depend on prior template parameters
12904 deduced after the template template parameter. The following
12905 ill-formed example illustrates this issue:
12907 template<typename T, template<T> class C> void f(C<5>, T);
12909 template<int N> struct X {};
12912 f(X<5>(), 5l); // error: template argument deduction fails
12915 The template parameter list of 'C' depends on the template type
12916 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
12917 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
12918 time that we deduce 'C'. */
12920 && !template_template_parm_bindings_ok_p
12921 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
12925 /* All is well so far. Now, check:
12929 When all template arguments have been deduced, all uses of
12930 template parameters in nondeduced contexts are replaced with
12931 the corresponding deduced argument values. If the
12932 substitution results in an invalid type, as described above,
12933 type deduction fails. */
12935 tree substed = tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE);
12936 if (substed == error_mark_node)
12939 /* If we're looking for an exact match, check that what we got
12940 is indeed an exact match. It might not be if some template
12941 parameters are used in non-deduced contexts. */
12942 if (strict == DEDUCE_EXACT)
12947 = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (substed));
12949 sarg = tree_cons (NULL_TREE, TREE_TYPE (substed), sarg);
12950 for (i = 0; i < nargs && sarg; ++i, sarg = TREE_CHAIN (sarg))
12951 if (!same_type_p (args[i], TREE_VALUE (sarg)))
12959 /* Adjust types before performing type deduction, as described in
12960 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
12961 sections are symmetric. PARM is the type of a function parameter
12962 or the return type of the conversion function. ARG is the type of
12963 the argument passed to the call, or the type of the value
12964 initialized with the result of the conversion function.
12965 ARG_EXPR is the original argument expression, which may be null. */
12968 maybe_adjust_types_for_deduction (unification_kind_t strict,
12982 /* Swap PARM and ARG throughout the remainder of this
12983 function; the handling is precisely symmetric since PARM
12984 will initialize ARG rather than vice versa. */
12992 /* Core issue #873: Do the DR606 thing (see below) for these cases,
12993 too, but here handle it by stripping the reference from PARM
12994 rather than by adding it to ARG. */
12995 if (TREE_CODE (*parm) == REFERENCE_TYPE
12996 && TYPE_REF_IS_RVALUE (*parm)
12997 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
12998 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
12999 && TREE_CODE (*arg) == REFERENCE_TYPE
13000 && !TYPE_REF_IS_RVALUE (*arg))
13001 *parm = TREE_TYPE (*parm);
13002 /* Nothing else to do in this case. */
13006 gcc_unreachable ();
13009 if (TREE_CODE (*parm) != REFERENCE_TYPE)
13011 /* [temp.deduct.call]
13013 If P is not a reference type:
13015 --If A is an array type, the pointer type produced by the
13016 array-to-pointer standard conversion (_conv.array_) is
13017 used in place of A for type deduction; otherwise,
13019 --If A is a function type, the pointer type produced by
13020 the function-to-pointer standard conversion
13021 (_conv.func_) is used in place of A for type deduction;
13024 --If A is a cv-qualified type, the top level
13025 cv-qualifiers of A's type are ignored for type
13027 if (TREE_CODE (*arg) == ARRAY_TYPE)
13028 *arg = build_pointer_type (TREE_TYPE (*arg));
13029 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
13030 *arg = build_pointer_type (*arg);
13032 *arg = TYPE_MAIN_VARIANT (*arg);
13035 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
13036 of the form T&&, where T is a template parameter, and the argument
13037 is an lvalue, T is deduced as A& */
13038 if (TREE_CODE (*parm) == REFERENCE_TYPE
13039 && TYPE_REF_IS_RVALUE (*parm)
13040 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
13041 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
13042 && arg_expr && real_lvalue_p (arg_expr))
13043 *arg = build_reference_type (*arg);
13045 /* [temp.deduct.call]
13047 If P is a cv-qualified type, the top level cv-qualifiers
13048 of P's type are ignored for type deduction. If P is a
13049 reference type, the type referred to by P is used for
13051 *parm = TYPE_MAIN_VARIANT (*parm);
13052 if (TREE_CODE (*parm) == REFERENCE_TYPE)
13054 *parm = TREE_TYPE (*parm);
13055 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
13058 /* DR 322. For conversion deduction, remove a reference type on parm
13059 too (which has been swapped into ARG). */
13060 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
13061 *arg = TREE_TYPE (*arg);
13066 /* Most parms like fn_type_unification.
13068 If SUBR is 1, we're being called recursively (to unify the
13069 arguments of a function or method parameter of a function
13073 type_unification_real (tree tparms,
13077 unsigned int xnargs,
13079 unification_kind_t strict,
13082 tree parm, arg, arg_expr;
13084 int ntparms = TREE_VEC_LENGTH (tparms);
13086 int saw_undeduced = 0;
13089 unsigned int nargs;
13092 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
13093 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
13094 gcc_assert (ntparms > 0);
13099 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
13100 | UNIFY_ALLOW_DERIVED);
13104 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
13108 sub_strict = UNIFY_ALLOW_NONE;
13112 gcc_unreachable ();
13121 while (parms && parms != void_list_node
13124 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13127 parm = TREE_VALUE (parms);
13128 parms = TREE_CHAIN (parms);
13133 if (arg == error_mark_node)
13135 if (arg == unknown_type_node)
13136 /* We can't deduce anything from this, but we might get all the
13137 template args from other function args. */
13140 /* Conversions will be performed on a function argument that
13141 corresponds with a function parameter that contains only
13142 non-deducible template parameters and explicitly specified
13143 template parameters. */
13144 if (!uses_template_parms (parm))
13149 type = TREE_TYPE (arg);
13153 if (same_type_p (parm, type))
13155 if (strict != DEDUCE_EXACT
13156 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
13165 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
13166 if (type_unknown_p (arg))
13168 /* [temp.deduct.type]
13170 A template-argument can be deduced from a pointer to
13171 function or pointer to member function argument if
13172 the set of overloaded functions does not contain
13173 function templates and at most one of a set of
13174 overloaded functions provides a unique match. */
13175 if (resolve_overloaded_unification
13176 (tparms, targs, parm, arg, strict, sub_strict))
13182 arg = unlowered_expr_type (arg);
13183 if (arg == error_mark_node)
13188 int arg_strict = sub_strict;
13191 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
13194 if (arg == init_list_type_node && arg_expr)
13196 if (unify (tparms, targs, parm, arg, arg_strict))
13203 && parms != void_list_node
13204 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13206 /* Unify the remaining arguments with the pack expansion type. */
13208 tree parmvec = make_tree_vec (1);
13210 /* Allocate a TREE_VEC and copy in all of the arguments */
13211 argvec = make_tree_vec (nargs - ia);
13212 for (i = 0; ia < nargs; ++ia, ++i)
13213 TREE_VEC_ELT (argvec, i) = args[ia];
13215 /* Copy the parameter into parmvec. */
13216 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
13217 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
13218 /*call_args_p=*/true, /*subr=*/subr))
13221 /* Advance to the end of the list of parameters. */
13222 parms = TREE_CHAIN (parms);
13225 /* Fail if we've reached the end of the parm list, and more args
13226 are present, and the parm list isn't variadic. */
13227 if (ia < nargs && parms == void_list_node)
13229 /* Fail if parms are left and they don't have default values. */
13230 if (parms && parms != void_list_node
13231 && TREE_PURPOSE (parms) == NULL_TREE)
13235 for (i = 0; i < ntparms; i++)
13236 if (!TREE_VEC_ELT (targs, i))
13240 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
13243 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13245 /* If this is an undeduced nontype parameter that depends on
13246 a type parameter, try another pass; its type may have been
13247 deduced from a later argument than the one from which
13248 this parameter can be deduced. */
13249 if (TREE_CODE (tparm) == PARM_DECL
13250 && uses_template_parms (TREE_TYPE (tparm))
13251 && !saw_undeduced++)
13254 /* Core issue #226 (C++0x) [temp.deduct]:
13256 If a template argument has not been deduced, its
13257 default template argument, if any, is used.
13259 When we are in C++98 mode, TREE_PURPOSE will either
13260 be NULL_TREE or ERROR_MARK_NODE, so we do not need
13261 to explicitly check cxx_dialect here. */
13262 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
13264 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13265 tree arg = TREE_PURPOSE (TREE_VEC_ELT (tparms, i));
13266 arg = tsubst_template_arg (arg, targs, tf_none, NULL_TREE);
13267 arg = convert_template_argument (parm, arg, targs, tf_none,
13269 if (arg == error_mark_node)
13273 TREE_VEC_ELT (targs, i) = arg;
13278 /* If the type parameter is a parameter pack, then it will
13279 be deduced to an empty parameter pack. */
13280 if (template_parameter_pack_p (tparm))
13284 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
13286 arg = make_node (NONTYPE_ARGUMENT_PACK);
13287 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
13288 TREE_CONSTANT (arg) = 1;
13291 arg = cxx_make_type (TYPE_ARGUMENT_PACK);
13293 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
13295 TREE_VEC_ELT (targs, i) = arg;
13305 /* Subroutine of type_unification_real. Args are like the variables
13306 at the call site. ARG is an overloaded function (or template-id);
13307 we try deducing template args from each of the overloads, and if
13308 only one succeeds, we go with that. Modifies TARGS and returns
13309 true on success. */
13312 resolve_overloaded_unification (tree tparms,
13316 unification_kind_t strict,
13319 tree tempargs = copy_node (targs);
13321 tree goodfn = NULL_TREE;
13324 if (TREE_CODE (arg) == ADDR_EXPR)
13326 arg = TREE_OPERAND (arg, 0);
13332 if (TREE_CODE (arg) == COMPONENT_REF)
13333 /* Handle `&x' where `x' is some static or non-static member
13335 arg = TREE_OPERAND (arg, 1);
13337 if (TREE_CODE (arg) == OFFSET_REF)
13338 arg = TREE_OPERAND (arg, 1);
13340 /* Strip baselink information. */
13341 if (BASELINK_P (arg))
13342 arg = BASELINK_FUNCTIONS (arg);
13344 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
13346 /* If we got some explicit template args, we need to plug them into
13347 the affected templates before we try to unify, in case the
13348 explicit args will completely resolve the templates in question. */
13350 tree expl_subargs = TREE_OPERAND (arg, 1);
13351 arg = TREE_OPERAND (arg, 0);
13353 for (; arg; arg = OVL_NEXT (arg))
13355 tree fn = OVL_CURRENT (arg);
13356 tree subargs, elem;
13358 if (TREE_CODE (fn) != TEMPLATE_DECL)
13361 ++processing_template_decl;
13362 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
13363 expl_subargs, /*check_ret=*/false);
13366 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
13367 if (try_one_overload (tparms, targs, tempargs, parm,
13368 elem, strict, sub_strict, addr_p)
13369 && (!goodfn || !decls_match (goodfn, elem)))
13375 --processing_template_decl;
13378 else if (TREE_CODE (arg) != OVERLOAD
13379 && TREE_CODE (arg) != FUNCTION_DECL)
13380 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13381 -- but the deduction does not succeed because the expression is
13382 not just the function on its own. */
13385 for (; arg; arg = OVL_NEXT (arg))
13386 if (try_one_overload (tparms, targs, tempargs, parm,
13387 TREE_TYPE (OVL_CURRENT (arg)),
13388 strict, sub_strict, addr_p)
13389 && (!goodfn || !decls_match (goodfn, OVL_CURRENT (arg))))
13391 goodfn = OVL_CURRENT (arg);
13395 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13396 to function or pointer to member function argument if the set of
13397 overloaded functions does not contain function templates and at most
13398 one of a set of overloaded functions provides a unique match.
13400 So if we found multiple possibilities, we return success but don't
13401 deduce anything. */
13405 int i = TREE_VEC_LENGTH (targs);
13407 if (TREE_VEC_ELT (tempargs, i))
13408 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
13416 /* Core DR 115: In contexts where deduction is done and fails, or in
13417 contexts where deduction is not done, if a template argument list is
13418 specified and it, along with any default template arguments, identifies
13419 a single function template specialization, then the template-id is an
13420 lvalue for the function template specialization. */
13423 resolve_nondeduced_context (tree orig_expr)
13425 tree expr, offset, baselink;
13428 if (!type_unknown_p (orig_expr))
13433 offset = NULL_TREE;
13434 baselink = NULL_TREE;
13436 if (TREE_CODE (expr) == ADDR_EXPR)
13438 expr = TREE_OPERAND (expr, 0);
13441 if (TREE_CODE (expr) == OFFSET_REF)
13444 expr = TREE_OPERAND (expr, 1);
13446 if (TREE_CODE (expr) == BASELINK)
13449 expr = BASELINK_FUNCTIONS (expr);
13452 if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
13455 tree goodfn = NULL_TREE;
13457 /* If we got some explicit template args, we need to plug them into
13458 the affected templates before we try to unify, in case the
13459 explicit args will completely resolve the templates in question. */
13461 tree expl_subargs = TREE_OPERAND (expr, 1);
13462 tree arg = TREE_OPERAND (expr, 0);
13463 tree badfn = NULL_TREE;
13464 tree badargs = NULL_TREE;
13466 for (; arg; arg = OVL_NEXT (arg))
13468 tree fn = OVL_CURRENT (arg);
13469 tree subargs, elem;
13471 if (TREE_CODE (fn) != TEMPLATE_DECL)
13474 ++processing_template_decl;
13475 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
13476 expl_subargs, /*check_ret=*/false);
13477 if (subargs && !any_dependent_template_arguments_p (subargs))
13479 elem = instantiate_template (fn, subargs, tf_none);
13480 if (elem == error_mark_node)
13485 else if (elem && (!goodfn || !decls_match (goodfn, elem)))
13491 --processing_template_decl;
13497 expr = build_baselink (BASELINK_BINFO (baselink),
13498 BASELINK_ACCESS_BINFO (baselink),
13499 expr, BASELINK_OPTYPE (baselink));
13501 expr = build2 (OFFSET_REF, TREE_TYPE (expr),
13502 TREE_OPERAND (offset, 0), expr);
13504 expr = build_address (expr);
13507 else if (good == 0 && badargs)
13508 /* There were no good options and at least one bad one, so let the
13509 user know what the problem is. */
13510 instantiate_template (badfn, badargs, tf_warning_or_error);
13515 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13516 overload. Fills TARGS with any deduced arguments, or error_mark_node if
13517 different overloads deduce different arguments for a given parm.
13518 ADDR_P is true if the expression for which deduction is being
13519 performed was of the form "& fn" rather than simply "fn".
13521 Returns 1 on success. */
13524 try_one_overload (tree tparms,
13529 unification_kind_t strict,
13537 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13538 to function or pointer to member function argument if the set of
13539 overloaded functions does not contain function templates and at most
13540 one of a set of overloaded functions provides a unique match.
13542 So if this is a template, just return success. */
13544 if (uses_template_parms (arg))
13547 if (TREE_CODE (arg) == METHOD_TYPE)
13548 arg = build_ptrmemfunc_type (build_pointer_type (arg));
13550 arg = build_pointer_type (arg);
13552 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
13554 /* We don't copy orig_targs for this because if we have already deduced
13555 some template args from previous args, unify would complain when we
13556 try to deduce a template parameter for the same argument, even though
13557 there isn't really a conflict. */
13558 nargs = TREE_VEC_LENGTH (targs);
13559 tempargs = make_tree_vec (nargs);
13561 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
13564 /* First make sure we didn't deduce anything that conflicts with
13565 explicitly specified args. */
13566 for (i = nargs; i--; )
13568 tree elt = TREE_VEC_ELT (tempargs, i);
13569 tree oldelt = TREE_VEC_ELT (orig_targs, i);
13573 else if (uses_template_parms (elt))
13574 /* Since we're unifying against ourselves, we will fill in
13575 template args used in the function parm list with our own
13576 template parms. Discard them. */
13577 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
13578 else if (oldelt && !template_args_equal (oldelt, elt))
13582 for (i = nargs; i--; )
13584 tree elt = TREE_VEC_ELT (tempargs, i);
13587 TREE_VEC_ELT (targs, i) = elt;
13593 /* PARM is a template class (perhaps with unbound template
13594 parameters). ARG is a fully instantiated type. If ARG can be
13595 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
13596 TARGS are as for unify. */
13599 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
13601 tree copy_of_targs;
13603 if (!CLASSTYPE_TEMPLATE_INFO (arg)
13604 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
13605 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
13608 /* We need to make a new template argument vector for the call to
13609 unify. If we used TARGS, we'd clutter it up with the result of
13610 the attempted unification, even if this class didn't work out.
13611 We also don't want to commit ourselves to all the unifications
13612 we've already done, since unification is supposed to be done on
13613 an argument-by-argument basis. In other words, consider the
13614 following pathological case:
13616 template <int I, int J, int K>
13619 template <int I, int J>
13620 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
13622 template <int I, int J, int K>
13623 void f(S<I, J, K>, S<I, I, I>);
13632 Now, by the time we consider the unification involving `s2', we
13633 already know that we must have `f<0, 0, 0>'. But, even though
13634 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
13635 because there are two ways to unify base classes of S<0, 1, 2>
13636 with S<I, I, I>. If we kept the already deduced knowledge, we
13637 would reject the possibility I=1. */
13638 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
13640 /* If unification failed, we're done. */
13641 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
13642 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
13648 /* Given a template type PARM and a class type ARG, find the unique
13649 base type in ARG that is an instance of PARM. We do not examine
13650 ARG itself; only its base-classes. If there is not exactly one
13651 appropriate base class, return NULL_TREE. PARM may be the type of
13652 a partial specialization, as well as a plain template type. Used
13656 get_template_base (tree tparms, tree targs, tree parm, tree arg)
13658 tree rval = NULL_TREE;
13661 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
13663 binfo = TYPE_BINFO (complete_type (arg));
13665 /* The type could not be completed. */
13668 /* Walk in inheritance graph order. The search order is not
13669 important, and this avoids multiple walks of virtual bases. */
13670 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
13672 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
13676 /* If there is more than one satisfactory baseclass, then:
13680 If they yield more than one possible deduced A, the type
13684 if (rval && !same_type_p (r, rval))
13694 /* Returns the level of DECL, which declares a template parameter. */
13697 template_decl_level (tree decl)
13699 switch (TREE_CODE (decl))
13702 case TEMPLATE_DECL:
13703 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
13706 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
13709 gcc_unreachable ();
13714 /* Decide whether ARG can be unified with PARM, considering only the
13715 cv-qualifiers of each type, given STRICT as documented for unify.
13716 Returns nonzero iff the unification is OK on that basis. */
13719 check_cv_quals_for_unify (int strict, tree arg, tree parm)
13721 int arg_quals = cp_type_quals (arg);
13722 int parm_quals = cp_type_quals (parm);
13724 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
13725 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
13727 /* Although a CVR qualifier is ignored when being applied to a
13728 substituted template parameter ([8.3.2]/1 for example), that
13729 does not apply during deduction [14.8.2.4]/1, (even though
13730 that is not explicitly mentioned, [14.8.2.4]/9 indicates
13731 this). Except when we're allowing additional CV qualifiers
13732 at the outer level [14.8.2.1]/3,1st bullet. */
13733 if ((TREE_CODE (arg) == REFERENCE_TYPE
13734 || TREE_CODE (arg) == FUNCTION_TYPE
13735 || TREE_CODE (arg) == METHOD_TYPE)
13736 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
13739 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
13740 && (parm_quals & TYPE_QUAL_RESTRICT))
13744 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
13745 && (arg_quals & parm_quals) != parm_quals)
13748 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
13749 && (parm_quals & arg_quals) != arg_quals)
13755 /* Determines the LEVEL and INDEX for the template parameter PARM. */
13757 template_parm_level_and_index (tree parm, int* level, int* index)
13759 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
13760 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
13761 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
13763 *index = TEMPLATE_TYPE_IDX (parm);
13764 *level = TEMPLATE_TYPE_LEVEL (parm);
13768 *index = TEMPLATE_PARM_IDX (parm);
13769 *level = TEMPLATE_PARM_LEVEL (parm);
13773 /* Unifies the remaining arguments in PACKED_ARGS with the pack
13774 expansion at the end of PACKED_PARMS. Returns 0 if the type
13775 deduction succeeds, 1 otherwise. STRICT is the same as in
13776 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
13777 call argument list. We'll need to adjust the arguments to make them
13778 types. SUBR tells us if this is from a recursive call to
13779 type_unification_real. */
13781 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
13782 tree packed_args, int strict, bool call_args_p,
13786 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
13787 tree pattern = PACK_EXPANSION_PATTERN (parm);
13788 tree pack, packs = NULL_TREE;
13789 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
13790 int len = TREE_VEC_LENGTH (packed_args);
13792 /* Determine the parameter packs we will be deducing from the
13793 pattern, and record their current deductions. */
13794 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
13795 pack; pack = TREE_CHAIN (pack))
13797 tree parm_pack = TREE_VALUE (pack);
13800 /* Determine the index and level of this parameter pack. */
13801 template_parm_level_and_index (parm_pack, &level, &idx);
13803 /* Keep track of the parameter packs and their corresponding
13805 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
13806 TREE_TYPE (packs) = make_tree_vec (len - start);
13809 /* Loop through all of the arguments that have not yet been
13810 unified and unify each with the pattern. */
13811 for (i = start; i < len; i++)
13813 tree parm = pattern;
13815 /* For each parameter pack, clear out the deduced value so that
13816 we can deduce it again. */
13817 for (pack = packs; pack; pack = TREE_CHAIN (pack))
13820 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13822 TMPL_ARG (targs, level, idx) = NULL_TREE;
13825 /* Unify the pattern with the current argument. */
13827 tree arg = TREE_VEC_ELT (packed_args, i);
13828 tree arg_expr = NULL_TREE;
13829 int arg_strict = strict;
13830 bool skip_arg_p = false;
13836 /* This mirrors what we do in type_unification_real. */
13840 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
13841 | UNIFY_ALLOW_MORE_CV_QUAL
13842 | UNIFY_ALLOW_DERIVED);
13846 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
13850 sub_strict = UNIFY_ALLOW_NONE;
13854 gcc_unreachable ();
13859 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
13860 if (type_unknown_p (arg))
13862 /* [temp.deduct.type] A template-argument can be
13863 deduced from a pointer to function or pointer
13864 to member function argument if the set of
13865 overloaded functions does not contain function
13866 templates and at most one of a set of
13867 overloaded functions provides a unique
13870 if (resolve_overloaded_unification
13871 (tparms, targs, parm, arg,
13872 (unification_kind_t) strict,
13882 arg = unlowered_expr_type (arg);
13883 if (arg == error_mark_node)
13888 arg_strict = sub_strict;
13892 maybe_adjust_types_for_deduction ((unification_kind_t) strict,
13893 &parm, &arg, arg_expr);
13898 if (unify (tparms, targs, parm, arg, arg_strict))
13903 /* For each parameter pack, collect the deduced value. */
13904 for (pack = packs; pack; pack = TREE_CHAIN (pack))
13907 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13909 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
13910 TMPL_ARG (targs, level, idx);
13914 /* Verify that the results of unification with the parameter packs
13915 produce results consistent with what we've seen before, and make
13916 the deduced argument packs available. */
13917 for (pack = packs; pack; pack = TREE_CHAIN (pack))
13919 tree old_pack = TREE_VALUE (pack);
13920 tree new_args = TREE_TYPE (pack);
13921 int i, len = TREE_VEC_LENGTH (new_args);
13922 bool nondeduced_p = false;
13924 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
13925 actually deduce anything. */
13926 for (i = 0; i < len && !nondeduced_p; ++i)
13927 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
13928 nondeduced_p = true;
13932 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
13934 /* Prepend the explicit arguments onto NEW_ARGS. */
13935 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
13936 tree old_args = new_args;
13937 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
13938 int len = explicit_len + TREE_VEC_LENGTH (old_args);
13940 /* Copy the explicit arguments. */
13941 new_args = make_tree_vec (len);
13942 for (i = 0; i < explicit_len; i++)
13943 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
13945 /* Copy the deduced arguments. */
13946 for (; i < len; i++)
13947 TREE_VEC_ELT (new_args, i) =
13948 TREE_VEC_ELT (old_args, i - explicit_len);
13956 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13958 /* Build the deduced *_ARGUMENT_PACK. */
13959 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
13961 result = make_node (NONTYPE_ARGUMENT_PACK);
13962 TREE_TYPE (result) =
13963 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
13964 TREE_CONSTANT (result) = 1;
13967 result = cxx_make_type (TYPE_ARGUMENT_PACK);
13969 SET_ARGUMENT_PACK_ARGS (result, new_args);
13971 /* Note the deduced argument packs for this parameter
13973 TMPL_ARG (targs, level, idx) = result;
13975 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
13976 && (ARGUMENT_PACK_ARGS (old_pack)
13977 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
13979 /* We only had the explicitly-provided arguments before, but
13980 now we have a complete set of arguments. */
13982 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
13983 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13985 /* Keep the original deduced argument pack. */
13986 TMPL_ARG (targs, level, idx) = old_pack;
13988 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
13989 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
13990 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
13992 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
13994 /* Inconsistent unification of this parameter pack. */
14000 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
14002 /* Keep the original deduced argument pack. */
14003 TMPL_ARG (targs, level, idx) = old_pack;
14010 /* Deduce the value of template parameters. TPARMS is the (innermost)
14011 set of template parameters to a template. TARGS is the bindings
14012 for those template parameters, as determined thus far; TARGS may
14013 include template arguments for outer levels of template parameters
14014 as well. PARM is a parameter to a template function, or a
14015 subcomponent of that parameter; ARG is the corresponding argument.
14016 This function attempts to match PARM with ARG in a manner
14017 consistent with the existing assignments in TARGS. If more values
14018 are deduced, then TARGS is updated.
14020 Returns 0 if the type deduction succeeds, 1 otherwise. The
14021 parameter STRICT is a bitwise or of the following flags:
14024 Require an exact match between PARM and ARG.
14025 UNIFY_ALLOW_MORE_CV_QUAL:
14026 Allow the deduced ARG to be more cv-qualified (by qualification
14027 conversion) than ARG.
14028 UNIFY_ALLOW_LESS_CV_QUAL:
14029 Allow the deduced ARG to be less cv-qualified than ARG.
14030 UNIFY_ALLOW_DERIVED:
14031 Allow the deduced ARG to be a template base class of ARG,
14032 or a pointer to a template base class of the type pointed to by
14034 UNIFY_ALLOW_INTEGER:
14035 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
14036 case for more information.
14037 UNIFY_ALLOW_OUTER_LEVEL:
14038 This is the outermost level of a deduction. Used to determine validity
14039 of qualification conversions. A valid qualification conversion must
14040 have const qualified pointers leading up to the inner type which
14041 requires additional CV quals, except at the outer level, where const
14042 is not required [conv.qual]. It would be normal to set this flag in
14043 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
14044 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
14045 This is the outermost level of a deduction, and PARM can be more CV
14046 qualified at this point.
14047 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
14048 This is the outermost level of a deduction, and PARM can be less CV
14049 qualified at this point. */
14052 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
14057 int strict_in = strict;
14059 /* I don't think this will do the right thing with respect to types.
14060 But the only case I've seen it in so far has been array bounds, where
14061 signedness is the only information lost, and I think that will be
14063 while (TREE_CODE (parm) == NOP_EXPR)
14064 parm = TREE_OPERAND (parm, 0);
14066 if (arg == error_mark_node)
14068 if (arg == unknown_type_node
14069 || arg == init_list_type_node)
14070 /* We can't deduce anything from this, but we might get all the
14071 template args from other function args. */
14074 /* If PARM uses template parameters, then we can't bail out here,
14075 even if ARG == PARM, since we won't record unifications for the
14076 template parameters. We might need them if we're trying to
14077 figure out which of two things is more specialized. */
14078 if (arg == parm && !uses_template_parms (parm))
14081 /* Handle init lists early, so the rest of the function can assume
14082 we're dealing with a type. */
14083 if (BRACE_ENCLOSED_INITIALIZER_P (arg))
14087 tree orig_parm = parm;
14089 /* Replace T with std::initializer_list<T> for deduction. */
14090 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14091 && flag_deduce_init_list)
14092 parm = listify (parm);
14094 if (!is_std_init_list (parm))
14095 /* We can only deduce from an initializer list argument if the
14096 parameter is std::initializer_list; otherwise this is a
14097 non-deduced context. */
14100 elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
14102 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg), i, elt)
14104 int elt_strict = strict;
14105 if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
14107 tree type = TREE_TYPE (elt);
14108 /* It should only be possible to get here for a call. */
14109 gcc_assert (elt_strict & UNIFY_ALLOW_OUTER_LEVEL);
14110 elt_strict |= maybe_adjust_types_for_deduction
14111 (DEDUCE_CALL, &elttype, &type, elt);
14115 if (unify (tparms, targs, elttype, elt, elt_strict))
14119 /* If the std::initializer_list<T> deduction worked, replace the
14120 deduced A with std::initializer_list<A>. */
14121 if (orig_parm != parm)
14123 idx = TEMPLATE_TYPE_IDX (orig_parm);
14124 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14125 targ = listify (targ);
14126 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = targ;
14131 /* Immediately reject some pairs that won't unify because of
14132 cv-qualification mismatches. */
14133 if (TREE_CODE (arg) == TREE_CODE (parm)
14135 /* It is the elements of the array which hold the cv quals of an array
14136 type, and the elements might be template type parms. We'll check
14137 when we recurse. */
14138 && TREE_CODE (arg) != ARRAY_TYPE
14139 /* We check the cv-qualifiers when unifying with template type
14140 parameters below. We want to allow ARG `const T' to unify with
14141 PARM `T' for example, when computing which of two templates
14142 is more specialized, for example. */
14143 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
14144 && !check_cv_quals_for_unify (strict_in, arg, parm))
14147 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
14148 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
14149 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
14150 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
14151 strict &= ~UNIFY_ALLOW_DERIVED;
14152 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
14153 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
14155 switch (TREE_CODE (parm))
14157 case TYPENAME_TYPE:
14159 case UNBOUND_CLASS_TEMPLATE:
14160 /* In a type which contains a nested-name-specifier, template
14161 argument values cannot be deduced for template parameters used
14162 within the nested-name-specifier. */
14165 case TEMPLATE_TYPE_PARM:
14166 case TEMPLATE_TEMPLATE_PARM:
14167 case BOUND_TEMPLATE_TEMPLATE_PARM:
14168 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
14169 if (tparm == error_mark_node)
14172 if (TEMPLATE_TYPE_LEVEL (parm)
14173 != template_decl_level (tparm))
14174 /* The PARM is not one we're trying to unify. Just check
14175 to see if it matches ARG. */
14176 return (TREE_CODE (arg) == TREE_CODE (parm)
14177 && same_type_p (parm, arg)) ? 0 : 1;
14178 idx = TEMPLATE_TYPE_IDX (parm);
14179 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14180 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
14182 /* Check for mixed types and values. */
14183 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14184 && TREE_CODE (tparm) != TYPE_DECL)
14185 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14186 && TREE_CODE (tparm) != TEMPLATE_DECL))
14189 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14191 /* ARG must be constructed from a template class or a template
14192 template parameter. */
14193 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
14194 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
14198 tree parmvec = TYPE_TI_ARGS (parm);
14199 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
14201 = DECL_INNERMOST_TEMPLATE_PARMS
14202 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm));
14204 int parm_variadic_p = 0;
14206 /* The resolution to DR150 makes clear that default
14207 arguments for an N-argument may not be used to bind T
14208 to a template template parameter with fewer than N
14209 parameters. It is not safe to permit the binding of
14210 default arguments as an extension, as that may change
14211 the meaning of a conforming program. Consider:
14213 struct Dense { static const unsigned int dim = 1; };
14215 template <template <typename> class View,
14217 void operator+(float, View<Block> const&);
14219 template <typename Block,
14220 unsigned int Dim = Block::dim>
14221 struct Lvalue_proxy { operator float() const; };
14225 Lvalue_proxy<Dense> p;
14230 Here, if Lvalue_proxy is permitted to bind to View, then
14231 the global operator+ will be used; if they are not, the
14232 Lvalue_proxy will be converted to float. */
14233 if (coerce_template_parms (parm_parms,
14235 TYPE_TI_TEMPLATE (parm),
14237 /*require_all_args=*/true,
14238 /*use_default_args=*/false)
14239 == error_mark_node)
14242 /* Deduce arguments T, i from TT<T> or TT<i>.
14243 We check each element of PARMVEC and ARGVEC individually
14244 rather than the whole TREE_VEC since they can have
14245 different number of elements. */
14247 parmvec = expand_template_argument_pack (parmvec);
14248 argvec = expand_template_argument_pack (argvec);
14250 len = TREE_VEC_LENGTH (parmvec);
14252 /* Check if the parameters end in a pack, making them
14255 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
14256 parm_variadic_p = 1;
14258 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
14261 for (i = 0; i < len - parm_variadic_p; ++i)
14263 if (unify (tparms, targs,
14264 TREE_VEC_ELT (parmvec, i),
14265 TREE_VEC_ELT (argvec, i),
14270 if (parm_variadic_p
14271 && unify_pack_expansion (tparms, targs,
14274 /*call_args_p=*/false,
14278 arg = TYPE_TI_TEMPLATE (arg);
14280 /* Fall through to deduce template name. */
14283 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14284 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14286 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
14288 /* Simple cases: Value already set, does match or doesn't. */
14289 if (targ != NULL_TREE && template_args_equal (targ, arg))
14296 /* If PARM is `const T' and ARG is only `int', we don't have
14297 a match unless we are allowing additional qualification.
14298 If ARG is `const int' and PARM is just `T' that's OK;
14299 that binds `const int' to `T'. */
14300 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
14304 /* Consider the case where ARG is `const volatile int' and
14305 PARM is `const T'. Then, T should be `volatile int'. */
14306 arg = cp_build_qualified_type_real
14307 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
14308 if (arg == error_mark_node)
14311 /* Simple cases: Value already set, does match or doesn't. */
14312 if (targ != NULL_TREE && same_type_p (targ, arg))
14317 /* Make sure that ARG is not a variable-sized array. (Note
14318 that were talking about variable-sized arrays (like
14319 `int[n]'), rather than arrays of unknown size (like
14320 `int[]').) We'll get very confused by such a type since
14321 the bound of the array will not be computable in an
14322 instantiation. Besides, such types are not allowed in
14323 ISO C++, so we can do as we please here. */
14324 if (variably_modified_type_p (arg, NULL_TREE))
14327 /* Strip typedefs as in convert_template_argument. */
14328 arg = strip_typedefs (arg);
14331 /* If ARG is a parameter pack or an expansion, we cannot unify
14332 against it unless PARM is also a parameter pack. */
14333 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14334 && !template_parameter_pack_p (parm))
14337 /* If the argument deduction results is a METHOD_TYPE,
14338 then there is a problem.
14339 METHOD_TYPE doesn't map to any real C++ type the result of
14340 the deduction can not be of that type. */
14341 if (TREE_CODE (arg) == METHOD_TYPE)
14344 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14347 case TEMPLATE_PARM_INDEX:
14348 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
14349 if (tparm == error_mark_node)
14352 if (TEMPLATE_PARM_LEVEL (parm)
14353 != template_decl_level (tparm))
14354 /* The PARM is not one we're trying to unify. Just check
14355 to see if it matches ARG. */
14356 return !(TREE_CODE (arg) == TREE_CODE (parm)
14357 && cp_tree_equal (parm, arg));
14359 idx = TEMPLATE_PARM_IDX (parm);
14360 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14363 return !cp_tree_equal (targ, arg);
14365 /* [temp.deduct.type] If, in the declaration of a function template
14366 with a non-type template-parameter, the non-type
14367 template-parameter is used in an expression in the function
14368 parameter-list and, if the corresponding template-argument is
14369 deduced, the template-argument type shall match the type of the
14370 template-parameter exactly, except that a template-argument
14371 deduced from an array bound may be of any integral type.
14372 The non-type parameter might use already deduced type parameters. */
14373 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
14374 if (!TREE_TYPE (arg))
14375 /* Template-parameter dependent expression. Just accept it for now.
14376 It will later be processed in convert_template_argument. */
14378 else if (same_type_p (TREE_TYPE (arg), tparm))
14380 else if ((strict & UNIFY_ALLOW_INTEGER)
14381 && (TREE_CODE (tparm) == INTEGER_TYPE
14382 || TREE_CODE (tparm) == BOOLEAN_TYPE))
14383 /* Convert the ARG to the type of PARM; the deduced non-type
14384 template argument must exactly match the types of the
14385 corresponding parameter. */
14386 arg = fold (build_nop (tparm, arg));
14387 else if (uses_template_parms (tparm))
14388 /* We haven't deduced the type of this parameter yet. Try again
14394 /* If ARG is a parameter pack or an expansion, we cannot unify
14395 against it unless PARM is also a parameter pack. */
14396 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14397 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
14400 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14405 /* A pointer-to-member constant can be unified only with
14406 another constant. */
14407 if (TREE_CODE (arg) != PTRMEM_CST)
14410 /* Just unify the class member. It would be useless (and possibly
14411 wrong, depending on the strict flags) to unify also
14412 PTRMEM_CST_CLASS, because we want to be sure that both parm and
14413 arg refer to the same variable, even if through different
14414 classes. For instance:
14416 struct A { int x; };
14419 Unification of &A::x and &B::x must succeed. */
14420 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
14421 PTRMEM_CST_MEMBER (arg), strict);
14426 if (TREE_CODE (arg) != POINTER_TYPE)
14429 /* [temp.deduct.call]
14431 A can be another pointer or pointer to member type that can
14432 be converted to the deduced A via a qualification
14433 conversion (_conv.qual_).
14435 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14436 This will allow for additional cv-qualification of the
14437 pointed-to types if appropriate. */
14439 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
14440 /* The derived-to-base conversion only persists through one
14441 level of pointers. */
14442 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
14444 return unify (tparms, targs, TREE_TYPE (parm),
14445 TREE_TYPE (arg), strict);
14448 case REFERENCE_TYPE:
14449 if (TREE_CODE (arg) != REFERENCE_TYPE)
14451 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14452 strict & UNIFY_ALLOW_MORE_CV_QUAL);
14455 if (TREE_CODE (arg) != ARRAY_TYPE)
14457 if ((TYPE_DOMAIN (parm) == NULL_TREE)
14458 != (TYPE_DOMAIN (arg) == NULL_TREE))
14460 if (TYPE_DOMAIN (parm) != NULL_TREE)
14467 /* Our representation of array types uses "N - 1" as the
14468 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14469 not an integer constant. We cannot unify arbitrarily
14470 complex expressions, so we eliminate the MINUS_EXPRs
14472 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
14473 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
14476 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
14477 parm_max = TREE_OPERAND (parm_max, 0);
14479 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
14480 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
14483 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14484 trying to unify the type of a variable with the type
14485 of a template parameter. For example:
14487 template <unsigned int N>
14488 void f (char (&) [N]);
14495 Here, the type of the ARG will be "int [g(i)]", and
14496 may be a SAVE_EXPR, etc. */
14497 if (TREE_CODE (arg_max) != MINUS_EXPR)
14499 arg_max = TREE_OPERAND (arg_max, 0);
14502 /* If only one of the bounds used a MINUS_EXPR, compensate
14503 by adding one to the other bound. */
14504 if (parm_cst && !arg_cst)
14505 parm_max = fold_build2_loc (input_location, PLUS_EXPR,
14509 else if (arg_cst && !parm_cst)
14510 arg_max = fold_build2_loc (input_location, PLUS_EXPR,
14515 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
14518 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14519 strict & UNIFY_ALLOW_MORE_CV_QUAL);
14526 case ENUMERAL_TYPE:
14528 if (TREE_CODE (arg) != TREE_CODE (parm))
14531 /* We have already checked cv-qualification at the top of the
14533 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
14536 /* As far as unification is concerned, this wins. Later checks
14537 will invalidate it if necessary. */
14540 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
14541 /* Type INTEGER_CST can come from ordinary constant template args. */
14543 while (TREE_CODE (arg) == NOP_EXPR)
14544 arg = TREE_OPERAND (arg, 0);
14546 if (TREE_CODE (arg) != INTEGER_CST)
14548 return !tree_int_cst_equal (parm, arg);
14553 if (TREE_CODE (arg) != TREE_VEC)
14555 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
14557 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
14558 if (unify (tparms, targs,
14559 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
14567 if (TREE_CODE (arg) != TREE_CODE (parm))
14570 if (TYPE_PTRMEMFUNC_P (parm))
14572 if (!TYPE_PTRMEMFUNC_P (arg))
14575 return unify (tparms, targs,
14576 TYPE_PTRMEMFUNC_FN_TYPE (parm),
14577 TYPE_PTRMEMFUNC_FN_TYPE (arg),
14581 if (CLASSTYPE_TEMPLATE_INFO (parm))
14583 tree t = NULL_TREE;
14585 if (strict_in & UNIFY_ALLOW_DERIVED)
14587 /* First, we try to unify the PARM and ARG directly. */
14588 t = try_class_unification (tparms, targs,
14593 /* Fallback to the special case allowed in
14594 [temp.deduct.call]:
14596 If P is a class, and P has the form
14597 template-id, then A can be a derived class of
14598 the deduced A. Likewise, if P is a pointer to
14599 a class of the form template-id, A can be a
14600 pointer to a derived class pointed to by the
14602 t = get_template_base (tparms, targs, parm, arg);
14608 else if (CLASSTYPE_TEMPLATE_INFO (arg)
14609 && (CLASSTYPE_TI_TEMPLATE (parm)
14610 == CLASSTYPE_TI_TEMPLATE (arg)))
14611 /* Perhaps PARM is something like S<U> and ARG is S<int>.
14612 Then, we should unify `int' and `U'. */
14615 /* There's no chance of unification succeeding. */
14618 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
14619 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
14621 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
14626 case FUNCTION_TYPE:
14628 unsigned int nargs;
14633 if (TREE_CODE (arg) != TREE_CODE (parm))
14636 /* CV qualifications for methods can never be deduced, they must
14637 match exactly. We need to check them explicitly here,
14638 because type_unification_real treats them as any other
14639 cv-qualified parameter. */
14640 if (TREE_CODE (parm) == METHOD_TYPE
14641 && (!check_cv_quals_for_unify
14643 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
14644 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
14647 if (unify (tparms, targs, TREE_TYPE (parm),
14648 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
14651 nargs = list_length (TYPE_ARG_TYPES (arg));
14652 args = XALLOCAVEC (tree, nargs);
14653 for (a = TYPE_ARG_TYPES (arg), i = 0;
14654 a != NULL_TREE && a != void_list_node;
14655 a = TREE_CHAIN (a), ++i)
14656 args[i] = TREE_VALUE (a);
14659 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
14660 args, nargs, 1, DEDUCE_EXACT,
14665 /* Unify a pointer to member with a pointer to member function, which
14666 deduces the type of the member as a function type. */
14667 if (TYPE_PTRMEMFUNC_P (arg))
14671 cp_cv_quals cv_quals;
14673 /* Check top-level cv qualifiers */
14674 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
14677 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
14678 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
14681 /* Determine the type of the function we are unifying against. */
14682 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
14684 build_function_type (TREE_TYPE (method_type),
14685 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
14687 /* Extract the cv-qualifiers of the member function from the
14688 implicit object parameter and place them on the function
14689 type to be restored later. */
14691 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
14692 fntype = build_qualified_type (fntype, cv_quals);
14693 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
14696 if (TREE_CODE (arg) != OFFSET_TYPE)
14698 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
14699 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
14701 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14705 if (DECL_TEMPLATE_PARM_P (parm))
14706 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
14707 if (arg != integral_constant_value (parm))
14712 case TEMPLATE_DECL:
14713 /* Matched cases are handled by the ARG == PARM test above. */
14716 case TYPE_ARGUMENT_PACK:
14717 case NONTYPE_ARGUMENT_PACK:
14719 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
14720 tree packed_args = ARGUMENT_PACK_ARGS (arg);
14721 int i, len = TREE_VEC_LENGTH (packed_parms);
14722 int argslen = TREE_VEC_LENGTH (packed_args);
14723 int parm_variadic_p = 0;
14725 for (i = 0; i < len; ++i)
14727 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
14730 /* We can unify against something with a trailing
14732 parm_variadic_p = 1;
14734 /* Since there is something following the pack
14735 expansion, we cannot unify this template argument
14742 /* If we don't have enough arguments to satisfy the parameters
14743 (not counting the pack expression at the end), or we have
14744 too many arguments for a parameter list that doesn't end in
14745 a pack expression, we can't unify. */
14746 if (argslen < (len - parm_variadic_p)
14747 || (argslen > len && !parm_variadic_p))
14750 /* Unify all of the parameters that precede the (optional)
14751 pack expression. */
14752 for (i = 0; i < len - parm_variadic_p; ++i)
14754 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
14755 TREE_VEC_ELT (packed_args, i), strict))
14759 if (parm_variadic_p)
14760 return unify_pack_expansion (tparms, targs,
14761 packed_parms, packed_args,
14762 strict, /*call_args_p=*/false,
14770 case DECLTYPE_TYPE:
14771 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
14776 /* Unification fails if we hit an error node. */
14780 gcc_assert (EXPR_P (parm));
14782 /* We must be looking at an expression. This can happen with
14786 void foo(S<I>, S<I + 2>);
14788 This is a "nondeduced context":
14792 The nondeduced contexts are:
14794 --A type that is a template-id in which one or more of
14795 the template-arguments is an expression that references
14796 a template-parameter.
14798 In these cases, we assume deduction succeeded, but don't
14799 actually infer any unifications. */
14801 if (!uses_template_parms (parm)
14802 && !template_args_equal (parm, arg))
14809 /* Note that DECL can be defined in this translation unit, if
14813 mark_definable (tree decl)
14816 DECL_NOT_REALLY_EXTERN (decl) = 1;
14817 FOR_EACH_CLONE (clone, decl)
14818 DECL_NOT_REALLY_EXTERN (clone) = 1;
14821 /* Called if RESULT is explicitly instantiated, or is a member of an
14822 explicitly instantiated class. */
14825 mark_decl_instantiated (tree result, int extern_p)
14827 SET_DECL_EXPLICIT_INSTANTIATION (result);
14829 /* If this entity has already been written out, it's too late to
14830 make any modifications. */
14831 if (TREE_ASM_WRITTEN (result))
14834 if (TREE_CODE (result) != FUNCTION_DECL)
14835 /* The TREE_PUBLIC flag for function declarations will have been
14836 set correctly by tsubst. */
14837 TREE_PUBLIC (result) = 1;
14839 /* This might have been set by an earlier implicit instantiation. */
14840 DECL_COMDAT (result) = 0;
14843 DECL_NOT_REALLY_EXTERN (result) = 0;
14846 mark_definable (result);
14847 /* Always make artificials weak. */
14848 if (DECL_ARTIFICIAL (result) && flag_weak)
14849 comdat_linkage (result);
14850 /* For WIN32 we also want to put explicit instantiations in
14851 linkonce sections. */
14852 else if (TREE_PUBLIC (result))
14853 maybe_make_one_only (result);
14856 /* If EXTERN_P, then this function will not be emitted -- unless
14857 followed by an explicit instantiation, at which point its linkage
14858 will be adjusted. If !EXTERN_P, then this function will be
14859 emitted here. In neither circumstance do we want
14860 import_export_decl to adjust the linkage. */
14861 DECL_INTERFACE_KNOWN (result) = 1;
14864 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
14865 important template arguments. If any are missing, we check whether
14866 they're important by using error_mark_node for substituting into any
14867 args that were used for partial ordering (the ones between ARGS and END)
14868 and seeing if it bubbles up. */
14871 check_undeduced_parms (tree targs, tree args, tree end)
14873 bool found = false;
14875 for (i = TREE_VEC_LENGTH (targs) - 1; i >= 0; --i)
14876 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
14879 TREE_VEC_ELT (targs, i) = error_mark_node;
14883 for (; args != end; args = TREE_CHAIN (args))
14885 tree substed = tsubst (TREE_VALUE (args), targs, tf_none, NULL_TREE);
14886 if (substed == error_mark_node)
14893 /* Given two function templates PAT1 and PAT2, return:
14895 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
14896 -1 if PAT2 is more specialized than PAT1.
14897 0 if neither is more specialized.
14899 LEN indicates the number of parameters we should consider
14900 (defaulted parameters should not be considered).
14902 The 1998 std underspecified function template partial ordering, and
14903 DR214 addresses the issue. We take pairs of arguments, one from
14904 each of the templates, and deduce them against each other. One of
14905 the templates will be more specialized if all the *other*
14906 template's arguments deduce against its arguments and at least one
14907 of its arguments *does* *not* deduce against the other template's
14908 corresponding argument. Deduction is done as for class templates.
14909 The arguments used in deduction have reference and top level cv
14910 qualifiers removed. Iff both arguments were originally reference
14911 types *and* deduction succeeds in both directions, the template
14912 with the more cv-qualified argument wins for that pairing (if
14913 neither is more cv-qualified, they both are equal). Unlike regular
14914 deduction, after all the arguments have been deduced in this way,
14915 we do *not* verify the deduced template argument values can be
14916 substituted into non-deduced contexts.
14918 The logic can be a bit confusing here, because we look at deduce1 and
14919 targs1 to see if pat2 is at least as specialized, and vice versa; if we
14920 can find template arguments for pat1 to make arg1 look like arg2, that
14921 means that arg2 is at least as specialized as arg1. */
14924 more_specialized_fn (tree pat1, tree pat2, int len)
14926 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
14927 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
14928 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
14929 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
14930 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
14931 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
14932 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
14933 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
14934 tree origs1, origs2;
14935 bool lose1 = false;
14936 bool lose2 = false;
14938 /* Remove the this parameter from non-static member functions. If
14939 one is a non-static member function and the other is not a static
14940 member function, remove the first parameter from that function
14941 also. This situation occurs for operator functions where we
14942 locate both a member function (with this pointer) and non-member
14943 operator (with explicit first operand). */
14944 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
14946 len--; /* LEN is the number of significant arguments for DECL1 */
14947 args1 = TREE_CHAIN (args1);
14948 if (!DECL_STATIC_FUNCTION_P (decl2))
14949 args2 = TREE_CHAIN (args2);
14951 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
14953 args2 = TREE_CHAIN (args2);
14954 if (!DECL_STATIC_FUNCTION_P (decl1))
14957 args1 = TREE_CHAIN (args1);
14961 /* If only one is a conversion operator, they are unordered. */
14962 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
14965 /* Consider the return type for a conversion function */
14966 if (DECL_CONV_FN_P (decl1))
14968 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
14969 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
14973 processing_template_decl++;
14979 /* Stop when an ellipsis is seen. */
14980 && args1 != NULL_TREE && args2 != NULL_TREE)
14982 tree arg1 = TREE_VALUE (args1);
14983 tree arg2 = TREE_VALUE (args2);
14984 int deduce1, deduce2;
14988 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
14989 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
14991 /* When both arguments are pack expansions, we need only
14992 unify the patterns themselves. */
14993 arg1 = PACK_EXPANSION_PATTERN (arg1);
14994 arg2 = PACK_EXPANSION_PATTERN (arg2);
14996 /* This is the last comparison we need to do. */
15000 if (TREE_CODE (arg1) == REFERENCE_TYPE)
15002 arg1 = TREE_TYPE (arg1);
15003 quals1 = cp_type_quals (arg1);
15006 if (TREE_CODE (arg2) == REFERENCE_TYPE)
15008 arg2 = TREE_TYPE (arg2);
15009 quals2 = cp_type_quals (arg2);
15012 if ((quals1 < 0) != (quals2 < 0))
15014 /* Only of the args is a reference, see if we should apply
15015 array/function pointer decay to it. This is not part of
15016 DR214, but is, IMHO, consistent with the deduction rules
15017 for the function call itself, and with our earlier
15018 implementation of the underspecified partial ordering
15019 rules. (nathan). */
15022 switch (TREE_CODE (arg1))
15025 arg1 = TREE_TYPE (arg1);
15027 case FUNCTION_TYPE:
15028 arg1 = build_pointer_type (arg1);
15037 switch (TREE_CODE (arg2))
15040 arg2 = TREE_TYPE (arg2);
15042 case FUNCTION_TYPE:
15043 arg2 = build_pointer_type (arg2);
15052 arg1 = TYPE_MAIN_VARIANT (arg1);
15053 arg2 = TYPE_MAIN_VARIANT (arg2);
15055 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
15057 int i, len2 = list_length (args2);
15058 tree parmvec = make_tree_vec (1);
15059 tree argvec = make_tree_vec (len2);
15062 /* Setup the parameter vector, which contains only ARG1. */
15063 TREE_VEC_ELT (parmvec, 0) = arg1;
15065 /* Setup the argument vector, which contains the remaining
15067 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
15068 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
15070 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
15071 argvec, UNIFY_ALLOW_NONE,
15072 /*call_args_p=*/false,
15075 /* We cannot deduce in the other direction, because ARG1 is
15076 a pack expansion but ARG2 is not. */
15079 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15081 int i, len1 = list_length (args1);
15082 tree parmvec = make_tree_vec (1);
15083 tree argvec = make_tree_vec (len1);
15086 /* Setup the parameter vector, which contains only ARG1. */
15087 TREE_VEC_ELT (parmvec, 0) = arg2;
15089 /* Setup the argument vector, which contains the remaining
15091 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
15092 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
15094 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
15095 argvec, UNIFY_ALLOW_NONE,
15096 /*call_args_p=*/false,
15099 /* We cannot deduce in the other direction, because ARG2 is
15100 a pack expansion but ARG1 is not.*/
15106 /* The normal case, where neither argument is a pack
15108 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
15109 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
15112 /* If we couldn't deduce arguments for tparms1 to make arg1 match
15113 arg2, then arg2 is not as specialized as arg1. */
15119 /* "If, for a given type, deduction succeeds in both directions
15120 (i.e., the types are identical after the transformations above)
15121 and if the type from the argument template is more cv-qualified
15122 than the type from the parameter template (as described above)
15123 that type is considered to be more specialized than the other. If
15124 neither type is more cv-qualified than the other then neither type
15125 is more specialized than the other."
15127 We check same_type_p explicitly because deduction can also succeed
15128 in both directions when there is a nondeduced context. */
15129 if (deduce1 && deduce2
15130 && quals1 != quals2 && quals1 >= 0 && quals2 >= 0
15131 && same_type_p (arg1, arg2))
15133 if ((quals1 & quals2) == quals2)
15135 if ((quals1 & quals2) == quals1)
15139 if (lose1 && lose2)
15140 /* We've failed to deduce something in either direction.
15141 These must be unordered. */
15144 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
15145 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15146 /* We have already processed all of the arguments in our
15147 handing of the pack expansion type. */
15150 args1 = TREE_CHAIN (args1);
15151 args2 = TREE_CHAIN (args2);
15154 /* "In most cases, all template parameters must have values in order for
15155 deduction to succeed, but for partial ordering purposes a template
15156 parameter may remain without a value provided it is not used in the
15157 types being used for partial ordering."
15159 Thus, if we are missing any of the targs1 we need to substitute into
15160 origs1, then pat2 is not as specialized as pat1. This can happen when
15161 there is a nondeduced context. */
15162 if (!lose2 && check_undeduced_parms (targs1, origs1, args1))
15164 if (!lose1 && check_undeduced_parms (targs2, origs2, args2))
15167 processing_template_decl--;
15169 /* All things being equal, if the next argument is a pack expansion
15170 for one function but not for the other, prefer the
15171 non-variadic function. FIXME this is bogus; see c++/41958. */
15173 && args1 && TREE_VALUE (args1)
15174 && args2 && TREE_VALUE (args2))
15176 lose1 = TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION;
15177 lose2 = TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION;
15180 if (lose1 == lose2)
15188 /* Determine which of two partial specializations is more specialized.
15190 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
15191 to the first partial specialization. The TREE_VALUE is the
15192 innermost set of template parameters for the partial
15193 specialization. PAT2 is similar, but for the second template.
15195 Return 1 if the first partial specialization is more specialized;
15196 -1 if the second is more specialized; 0 if neither is more
15199 See [temp.class.order] for information about determining which of
15200 two templates is more specialized. */
15203 more_specialized_class (tree pat1, tree pat2)
15208 bool any_deductions = false;
15210 tmpl1 = TREE_TYPE (pat1);
15211 tmpl2 = TREE_TYPE (pat2);
15213 /* Just like what happens for functions, if we are ordering between
15214 different class template specializations, we may encounter dependent
15215 types in the arguments, and we need our dependency check functions
15216 to behave correctly. */
15217 ++processing_template_decl;
15218 targs = get_class_bindings (TREE_VALUE (pat1),
15219 CLASSTYPE_TI_ARGS (tmpl1),
15220 CLASSTYPE_TI_ARGS (tmpl2));
15224 any_deductions = true;
15227 targs = get_class_bindings (TREE_VALUE (pat2),
15228 CLASSTYPE_TI_ARGS (tmpl2),
15229 CLASSTYPE_TI_ARGS (tmpl1));
15233 any_deductions = true;
15235 --processing_template_decl;
15237 /* In the case of a tie where at least one of the class templates
15238 has a parameter pack at the end, the template with the most
15239 non-packed parameters wins. */
15242 && (template_args_variadic_p (TREE_PURPOSE (pat1))
15243 || template_args_variadic_p (TREE_PURPOSE (pat2))))
15245 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
15246 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
15247 int len1 = TREE_VEC_LENGTH (args1);
15248 int len2 = TREE_VEC_LENGTH (args2);
15250 /* We don't count the pack expansion at the end. */
15251 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
15253 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
15258 else if (len1 < len2)
15265 /* Return the template arguments that will produce the function signature
15266 DECL from the function template FN, with the explicit template
15267 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
15268 also match. Return NULL_TREE if no satisfactory arguments could be
15272 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
15274 int ntparms = DECL_NTPARMS (fn);
15275 tree targs = make_tree_vec (ntparms);
15277 tree decl_arg_types;
15279 unsigned int nargs, ix;
15282 /* Substitute the explicit template arguments into the type of DECL.
15283 The call to fn_type_unification will handle substitution into the
15285 decl_type = TREE_TYPE (decl);
15286 if (explicit_args && uses_template_parms (decl_type))
15289 tree converted_args;
15291 if (DECL_TEMPLATE_INFO (decl))
15292 tmpl = DECL_TI_TEMPLATE (decl);
15294 /* We can get here for some invalid specializations. */
15298 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
15299 explicit_args, NULL_TREE,
15301 /*require_all_args=*/false,
15302 /*use_default_args=*/false);
15303 if (converted_args == error_mark_node)
15306 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
15307 if (decl_type == error_mark_node)
15311 /* Never do unification on the 'this' parameter. */
15312 decl_arg_types = skip_artificial_parms_for (decl,
15313 TYPE_ARG_TYPES (decl_type));
15315 nargs = list_length (decl_arg_types);
15316 args = XALLOCAVEC (tree, nargs);
15317 for (arg = decl_arg_types, ix = 0;
15318 arg != NULL_TREE && arg != void_list_node;
15319 arg = TREE_CHAIN (arg), ++ix)
15320 args[ix] = TREE_VALUE (arg);
15322 if (fn_type_unification (fn, explicit_args, targs,
15324 (check_rettype || DECL_CONV_FN_P (fn)
15325 ? TREE_TYPE (decl_type) : NULL_TREE),
15326 DEDUCE_EXACT, LOOKUP_NORMAL))
15332 /* Return the innermost template arguments that, when applied to a
15333 template specialization whose innermost template parameters are
15334 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
15337 For example, suppose we have:
15339 template <class T, class U> struct S {};
15340 template <class T> struct S<T*, int> {};
15342 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
15343 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
15344 int}. The resulting vector will be {double}, indicating that `T'
15345 is bound to `double'. */
15348 get_class_bindings (tree tparms, tree spec_args, tree args)
15350 int i, ntparms = TREE_VEC_LENGTH (tparms);
15352 tree innermost_deduced_args;
15354 innermost_deduced_args = make_tree_vec (ntparms);
15355 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
15357 deduced_args = copy_node (args);
15358 SET_TMPL_ARGS_LEVEL (deduced_args,
15359 TMPL_ARGS_DEPTH (deduced_args),
15360 innermost_deduced_args);
15363 deduced_args = innermost_deduced_args;
15365 if (unify (tparms, deduced_args,
15366 INNERMOST_TEMPLATE_ARGS (spec_args),
15367 INNERMOST_TEMPLATE_ARGS (args),
15371 for (i = 0; i < ntparms; ++i)
15372 if (! TREE_VEC_ELT (innermost_deduced_args, i))
15375 /* Verify that nondeduced template arguments agree with the type
15376 obtained from argument deduction.
15380 struct A { typedef int X; };
15381 template <class T, class U> struct C {};
15382 template <class T> struct C<T, typename T::X> {};
15384 Then with the instantiation `C<A, int>', we can deduce that
15385 `T' is `A' but unify () does not check whether `typename T::X'
15387 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
15388 if (spec_args == error_mark_node
15389 /* We only need to check the innermost arguments; the other
15390 arguments will always agree. */
15391 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
15392 INNERMOST_TEMPLATE_ARGS (args)))
15395 /* Now that we have bindings for all of the template arguments,
15396 ensure that the arguments deduced for the template template
15397 parameters have compatible template parameter lists. See the use
15398 of template_template_parm_bindings_ok_p in fn_type_unification
15399 for more information. */
15400 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
15403 return deduced_args;
15406 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
15407 Return the TREE_LIST node with the most specialized template, if
15408 any. If there is no most specialized template, the error_mark_node
15411 Note that this function does not look at, or modify, the
15412 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
15413 returned is one of the elements of INSTANTIATIONS, callers may
15414 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
15415 and retrieve it from the value returned. */
15418 most_specialized_instantiation (tree templates)
15422 ++processing_template_decl;
15425 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
15429 if (get_bindings (TREE_VALUE (champ),
15430 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15431 NULL_TREE, /*check_ret=*/false))
15434 if (get_bindings (TREE_VALUE (fn),
15435 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15436 NULL_TREE, /*check_ret=*/false))
15443 /* Equally specialized, move to next function. If there
15444 is no next function, nothing's most specialized. */
15445 fn = TREE_CHAIN (fn);
15453 /* Now verify that champ is better than everything earlier in the
15454 instantiation list. */
15455 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
15456 if (get_bindings (TREE_VALUE (champ),
15457 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15458 NULL_TREE, /*check_ret=*/false)
15459 || !get_bindings (TREE_VALUE (fn),
15460 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15461 NULL_TREE, /*check_ret=*/false))
15467 processing_template_decl--;
15470 return error_mark_node;
15475 /* If DECL is a specialization of some template, return the most
15476 general such template. Otherwise, returns NULL_TREE.
15478 For example, given:
15480 template <class T> struct S { template <class U> void f(U); };
15482 if TMPL is `template <class U> void S<int>::f(U)' this will return
15483 the full template. This function will not trace past partial
15484 specializations, however. For example, given in addition:
15486 template <class T> struct S<T*> { template <class U> void f(U); };
15488 if TMPL is `template <class U> void S<int*>::f(U)' this will return
15489 `template <class T> template <class U> S<T*>::f(U)'. */
15492 most_general_template (tree decl)
15494 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15495 an immediate specialization. */
15496 if (TREE_CODE (decl) == FUNCTION_DECL)
15498 if (DECL_TEMPLATE_INFO (decl)) {
15499 decl = DECL_TI_TEMPLATE (decl);
15501 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15502 template friend. */
15503 if (TREE_CODE (decl) != TEMPLATE_DECL)
15509 /* Look for more and more general templates. */
15510 while (DECL_TEMPLATE_INFO (decl))
15512 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15513 (See cp-tree.h for details.) */
15514 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
15517 if (CLASS_TYPE_P (TREE_TYPE (decl))
15518 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
15521 /* Stop if we run into an explicitly specialized class template. */
15522 if (!DECL_NAMESPACE_SCOPE_P (decl)
15523 && DECL_CONTEXT (decl)
15524 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
15527 decl = DECL_TI_TEMPLATE (decl);
15533 /* Return the most specialized of the class template partial
15534 specializations of TMPL which can produce TYPE, a specialization of
15535 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
15536 a _TYPE node corresponding to the partial specialization, while the
15537 TREE_PURPOSE is the set of template arguments that must be
15538 substituted into the TREE_TYPE in order to generate TYPE.
15540 If the choice of partial specialization is ambiguous, a diagnostic
15541 is issued, and the error_mark_node is returned. If there are no
15542 partial specializations of TMPL matching TYPE, then NULL_TREE is
15546 most_specialized_class (tree type, tree tmpl)
15548 tree list = NULL_TREE;
15554 tree outer_args = NULL_TREE;
15556 tmpl = most_general_template (tmpl);
15557 args = CLASSTYPE_TI_ARGS (type);
15559 /* For determining which partial specialization to use, only the
15560 innermost args are interesting. */
15561 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
15563 outer_args = strip_innermost_template_args (args, 1);
15564 args = INNERMOST_TEMPLATE_ARGS (args);
15567 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
15569 tree partial_spec_args;
15571 tree parms = TREE_VALUE (t);
15573 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
15578 ++processing_template_decl;
15580 /* Discard the outer levels of args, and then substitute in the
15581 template args from the enclosing class. */
15582 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
15583 partial_spec_args = tsubst_template_args
15584 (partial_spec_args, outer_args, tf_none, NULL_TREE);
15586 /* PARMS already refers to just the innermost parms, but the
15587 template parms in partial_spec_args had their levels lowered
15588 by tsubst, so we need to do the same for the parm list. We
15589 can't just tsubst the TREE_VEC itself, as tsubst wants to
15590 treat a TREE_VEC as an argument vector. */
15591 parms = copy_node (parms);
15592 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
15593 TREE_VEC_ELT (parms, i) =
15594 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
15596 --processing_template_decl;
15598 spec_args = get_class_bindings (parms,
15604 spec_args = add_to_template_args (outer_args, spec_args);
15605 list = tree_cons (spec_args, TREE_VALUE (t), list);
15606 TREE_TYPE (list) = TREE_TYPE (t);
15613 ambiguous_p = false;
15616 t = TREE_CHAIN (t);
15617 for (; t; t = TREE_CHAIN (t))
15619 fate = more_specialized_class (champ, t);
15626 t = TREE_CHAIN (t);
15629 ambiguous_p = true;
15638 for (t = list; t && t != champ; t = TREE_CHAIN (t))
15640 fate = more_specialized_class (champ, t);
15643 ambiguous_p = true;
15650 const char *str = "candidates are:";
15651 error ("ambiguous class template instantiation for %q#T", type);
15652 for (t = list; t; t = TREE_CHAIN (t))
15654 error ("%s %+#T", str, TREE_TYPE (t));
15657 return error_mark_node;
15663 /* Explicitly instantiate DECL. */
15666 do_decl_instantiation (tree decl, tree storage)
15668 tree result = NULL_TREE;
15671 if (!decl || decl == error_mark_node)
15672 /* An error occurred, for which grokdeclarator has already issued
15673 an appropriate message. */
15675 else if (! DECL_LANG_SPECIFIC (decl))
15677 error ("explicit instantiation of non-template %q#D", decl);
15680 else if (TREE_CODE (decl) == VAR_DECL)
15682 /* There is an asymmetry here in the way VAR_DECLs and
15683 FUNCTION_DECLs are handled by grokdeclarator. In the case of
15684 the latter, the DECL we get back will be marked as a
15685 template instantiation, and the appropriate
15686 DECL_TEMPLATE_INFO will be set up. This does not happen for
15687 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
15688 should handle VAR_DECLs as it currently handles
15690 if (!DECL_CLASS_SCOPE_P (decl))
15692 error ("%qD is not a static data member of a class template", decl);
15695 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
15696 if (!result || TREE_CODE (result) != VAR_DECL)
15698 error ("no matching template for %qD found", decl);
15701 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
15703 error ("type %qT for explicit instantiation %qD does not match "
15704 "declared type %qT", TREE_TYPE (result), decl,
15709 else if (TREE_CODE (decl) != FUNCTION_DECL)
15711 error ("explicit instantiation of %q#D", decl);
15717 /* Check for various error cases. Note that if the explicit
15718 instantiation is valid the RESULT will currently be marked as an
15719 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
15720 until we get here. */
15722 if (DECL_TEMPLATE_SPECIALIZATION (result))
15724 /* DR 259 [temp.spec].
15726 Both an explicit instantiation and a declaration of an explicit
15727 specialization shall not appear in a program unless the explicit
15728 instantiation follows a declaration of the explicit specialization.
15730 For a given set of template parameters, if an explicit
15731 instantiation of a template appears after a declaration of an
15732 explicit specialization for that template, the explicit
15733 instantiation has no effect. */
15736 else if (DECL_EXPLICIT_INSTANTIATION (result))
15740 No program shall explicitly instantiate any template more
15743 We check DECL_NOT_REALLY_EXTERN so as not to complain when
15744 the first instantiation was `extern' and the second is not,
15745 and EXTERN_P for the opposite case. */
15746 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
15747 permerror (input_location, "duplicate explicit instantiation of %q#D", result);
15748 /* If an "extern" explicit instantiation follows an ordinary
15749 explicit instantiation, the template is instantiated. */
15753 else if (!DECL_IMPLICIT_INSTANTIATION (result))
15755 error ("no matching template for %qD found", result);
15758 else if (!DECL_TEMPLATE_INFO (result))
15760 permerror (input_location, "explicit instantiation of non-template %q#D", result);
15764 if (storage == NULL_TREE)
15766 else if (storage == ridpointers[(int) RID_EXTERN])
15768 if (!in_system_header && (cxx_dialect == cxx98))
15769 pedwarn (input_location, OPT_pedantic,
15770 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
15775 error ("storage class %qD applied to template instantiation", storage);
15777 check_explicit_instantiation_namespace (result);
15778 mark_decl_instantiated (result, extern_p);
15780 instantiate_decl (result, /*defer_ok=*/1,
15781 /*expl_inst_class_mem_p=*/false);
15785 mark_class_instantiated (tree t, int extern_p)
15787 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
15788 SET_CLASSTYPE_INTERFACE_KNOWN (t);
15789 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
15790 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
15793 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
15794 rest_of_type_compilation (t, 1);
15798 /* Called from do_type_instantiation through binding_table_foreach to
15799 do recursive instantiation for the type bound in ENTRY. */
15801 bt_instantiate_type_proc (binding_entry entry, void *data)
15803 tree storage = *(tree *) data;
15805 if (MAYBE_CLASS_TYPE_P (entry->type)
15806 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
15807 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
15810 /* Called from do_type_instantiation to instantiate a member
15811 (a member function or a static member variable) of an
15812 explicitly instantiated class template. */
15814 instantiate_class_member (tree decl, int extern_p)
15816 mark_decl_instantiated (decl, extern_p);
15818 instantiate_decl (decl, /*defer_ok=*/1,
15819 /*expl_inst_class_mem_p=*/true);
15822 /* Perform an explicit instantiation of template class T. STORAGE, if
15823 non-null, is the RID for extern, inline or static. COMPLAIN is
15824 nonzero if this is called from the parser, zero if called recursively,
15825 since the standard is unclear (as detailed below). */
15828 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
15833 int previous_instantiation_extern_p = 0;
15835 if (TREE_CODE (t) == TYPE_DECL)
15838 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
15840 error ("explicit instantiation of non-template type %qT", t);
15846 if (!COMPLETE_TYPE_P (t))
15848 if (complain & tf_error)
15849 error ("explicit instantiation of %q#T before definition of template",
15854 if (storage != NULL_TREE)
15856 if (!in_system_header)
15858 if (storage == ridpointers[(int) RID_EXTERN])
15860 if (cxx_dialect == cxx98)
15861 pedwarn (input_location, OPT_pedantic,
15862 "ISO C++ 1998 forbids the use of %<extern%> on "
15863 "explicit instantiations");
15866 pedwarn (input_location, OPT_pedantic,
15867 "ISO C++ forbids the use of %qE"
15868 " on explicit instantiations", storage);
15871 if (storage == ridpointers[(int) RID_INLINE])
15873 else if (storage == ridpointers[(int) RID_EXTERN])
15875 else if (storage == ridpointers[(int) RID_STATIC])
15879 error ("storage class %qD applied to template instantiation",
15885 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
15887 /* DR 259 [temp.spec].
15889 Both an explicit instantiation and a declaration of an explicit
15890 specialization shall not appear in a program unless the explicit
15891 instantiation follows a declaration of the explicit specialization.
15893 For a given set of template parameters, if an explicit
15894 instantiation of a template appears after a declaration of an
15895 explicit specialization for that template, the explicit
15896 instantiation has no effect. */
15899 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
15903 No program shall explicitly instantiate any template more
15906 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
15907 instantiation was `extern'. If EXTERN_P then the second is.
15908 These cases are OK. */
15909 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
15911 if (!previous_instantiation_extern_p && !extern_p
15912 && (complain & tf_error))
15913 permerror (input_location, "duplicate explicit instantiation of %q#T", t);
15915 /* If we've already instantiated the template, just return now. */
15916 if (!CLASSTYPE_INTERFACE_ONLY (t))
15920 check_explicit_instantiation_namespace (TYPE_NAME (t));
15921 mark_class_instantiated (t, extern_p);
15929 /* In contrast to implicit instantiation, where only the
15930 declarations, and not the definitions, of members are
15931 instantiated, we have here:
15935 The explicit instantiation of a class template specialization
15936 implies the instantiation of all of its members not
15937 previously explicitly specialized in the translation unit
15938 containing the explicit instantiation.
15940 Of course, we can't instantiate member template classes, since
15941 we don't have any arguments for them. Note that the standard
15942 is unclear on whether the instantiation of the members are
15943 *explicit* instantiations or not. However, the most natural
15944 interpretation is that it should be an explicit instantiation. */
15947 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
15948 if (TREE_CODE (tmp) == FUNCTION_DECL
15949 && DECL_TEMPLATE_INSTANTIATION (tmp))
15950 instantiate_class_member (tmp, extern_p);
15952 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
15953 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
15954 instantiate_class_member (tmp, extern_p);
15956 if (CLASSTYPE_NESTED_UTDS (t))
15957 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
15958 bt_instantiate_type_proc, &storage);
15962 /* Given a function DECL, which is a specialization of TMPL, modify
15963 DECL to be a re-instantiation of TMPL with the same template
15964 arguments. TMPL should be the template into which tsubst'ing
15965 should occur for DECL, not the most general template.
15967 One reason for doing this is a scenario like this:
15970 void f(const T&, int i);
15972 void g() { f(3, 7); }
15975 void f(const T& t, const int i) { }
15977 Note that when the template is first instantiated, with
15978 instantiate_template, the resulting DECL will have no name for the
15979 first parameter, and the wrong type for the second. So, when we go
15980 to instantiate the DECL, we regenerate it. */
15983 regenerate_decl_from_template (tree decl, tree tmpl)
15985 /* The arguments used to instantiate DECL, from the most general
15990 args = DECL_TI_ARGS (decl);
15991 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
15993 /* Make sure that we can see identifiers, and compute access
15995 push_access_scope (decl);
15997 if (TREE_CODE (decl) == FUNCTION_DECL)
16005 args_depth = TMPL_ARGS_DEPTH (args);
16006 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
16007 if (args_depth > parms_depth)
16008 args = get_innermost_template_args (args, parms_depth);
16010 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
16011 args, tf_error, NULL_TREE);
16013 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
16016 /* Merge parameter declarations. */
16017 decl_parm = skip_artificial_parms_for (decl,
16018 DECL_ARGUMENTS (decl));
16020 = skip_artificial_parms_for (code_pattern,
16021 DECL_ARGUMENTS (code_pattern));
16022 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
16027 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
16028 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
16029 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
16031 parm_type = type_decays_to (parm_type);
16032 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
16033 TREE_TYPE (decl_parm) = parm_type;
16034 attributes = DECL_ATTRIBUTES (pattern_parm);
16035 if (DECL_ATTRIBUTES (decl_parm) != attributes)
16037 DECL_ATTRIBUTES (decl_parm) = attributes;
16038 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
16040 decl_parm = TREE_CHAIN (decl_parm);
16041 pattern_parm = TREE_CHAIN (pattern_parm);
16043 /* Merge any parameters that match with the function parameter
16045 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
16048 tree expanded_types;
16049 /* Expand the TYPE_PACK_EXPANSION that provides the types for
16050 the parameters in this function parameter pack. */
16051 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
16052 args, tf_error, NULL_TREE);
16053 len = TREE_VEC_LENGTH (expanded_types);
16054 for (i = 0; i < len; i++)
16059 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
16060 /* Rename the parameter to include the index. */
16061 DECL_NAME (decl_parm) =
16062 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
16063 parm_type = TREE_VEC_ELT (expanded_types, i);
16064 parm_type = type_decays_to (parm_type);
16065 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
16066 TREE_TYPE (decl_parm) = parm_type;
16067 attributes = DECL_ATTRIBUTES (pattern_parm);
16068 if (DECL_ATTRIBUTES (decl_parm) != attributes)
16070 DECL_ATTRIBUTES (decl_parm) = attributes;
16071 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
16073 decl_parm = TREE_CHAIN (decl_parm);
16076 /* Merge additional specifiers from the CODE_PATTERN. */
16077 if (DECL_DECLARED_INLINE_P (code_pattern)
16078 && !DECL_DECLARED_INLINE_P (decl))
16079 DECL_DECLARED_INLINE_P (decl) = 1;
16081 else if (TREE_CODE (decl) == VAR_DECL)
16082 DECL_INITIAL (decl) =
16083 tsubst_expr (DECL_INITIAL (code_pattern), args,
16084 tf_error, DECL_TI_TEMPLATE (decl),
16085 /*integral_constant_expression_p=*/false);
16087 gcc_unreachable ();
16089 pop_access_scope (decl);
16092 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
16093 substituted to get DECL. */
16096 template_for_substitution (tree decl)
16098 tree tmpl = DECL_TI_TEMPLATE (decl);
16100 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
16101 for the instantiation. This is not always the most general
16102 template. Consider, for example:
16105 struct S { template <class U> void f();
16106 template <> void f<int>(); };
16108 and an instantiation of S<double>::f<int>. We want TD to be the
16109 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
16110 while (/* An instantiation cannot have a definition, so we need a
16111 more general template. */
16112 DECL_TEMPLATE_INSTANTIATION (tmpl)
16113 /* We must also deal with friend templates. Given:
16115 template <class T> struct S {
16116 template <class U> friend void f() {};
16119 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
16120 so far as the language is concerned, but that's still
16121 where we get the pattern for the instantiation from. On
16122 other hand, if the definition comes outside the class, say:
16124 template <class T> struct S {
16125 template <class U> friend void f();
16127 template <class U> friend void f() {}
16129 we don't need to look any further. That's what the check for
16130 DECL_INITIAL is for. */
16131 || (TREE_CODE (decl) == FUNCTION_DECL
16132 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
16133 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
16135 /* The present template, TD, should not be a definition. If it
16136 were a definition, we should be using it! Note that we
16137 cannot restructure the loop to just keep going until we find
16138 a template with a definition, since that might go too far if
16139 a specialization was declared, but not defined. */
16140 gcc_assert (TREE_CODE (decl) != VAR_DECL
16141 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
16143 /* Fetch the more general template. */
16144 tmpl = DECL_TI_TEMPLATE (tmpl);
16150 /* Returns true if we need to instantiate this template instance even if we
16151 know we aren't going to emit it.. */
16154 always_instantiate_p (tree decl)
16156 /* We always instantiate inline functions so that we can inline them. An
16157 explicit instantiation declaration prohibits implicit instantiation of
16158 non-inline functions. With high levels of optimization, we would
16159 normally inline non-inline functions -- but we're not allowed to do
16160 that for "extern template" functions. Therefore, we check
16161 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
16162 return ((TREE_CODE (decl) == FUNCTION_DECL
16163 && DECL_DECLARED_INLINE_P (decl))
16164 /* And we need to instantiate static data members so that
16165 their initializers are available in integral constant
16167 || (TREE_CODE (decl) == VAR_DECL
16168 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)));
16171 /* Produce the definition of D, a _DECL generated from a template. If
16172 DEFER_OK is nonzero, then we don't have to actually do the
16173 instantiation now; we just have to do it sometime. Normally it is
16174 an error if this is an explicit instantiation but D is undefined.
16175 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
16176 explicitly instantiated class template. */
16179 instantiate_decl (tree d, int defer_ok,
16180 bool expl_inst_class_mem_p)
16182 tree tmpl = DECL_TI_TEMPLATE (d);
16189 bool pattern_defined;
16191 location_t saved_loc = input_location;
16194 /* This function should only be used to instantiate templates for
16195 functions and static member variables. */
16196 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
16197 || TREE_CODE (d) == VAR_DECL);
16199 /* Variables are never deferred; if instantiation is required, they
16200 are instantiated right away. That allows for better code in the
16201 case that an expression refers to the value of the variable --
16202 if the variable has a constant value the referring expression can
16203 take advantage of that fact. */
16204 if (TREE_CODE (d) == VAR_DECL)
16207 /* Don't instantiate cloned functions. Instead, instantiate the
16208 functions they cloned. */
16209 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
16210 d = DECL_CLONED_FUNCTION (d);
16212 if (DECL_TEMPLATE_INSTANTIATED (d)
16213 || DECL_TEMPLATE_SPECIALIZATION (d))
16214 /* D has already been instantiated or explicitly specialized, so
16215 there's nothing for us to do here.
16217 It might seem reasonable to check whether or not D is an explicit
16218 instantiation, and, if so, stop here. But when an explicit
16219 instantiation is deferred until the end of the compilation,
16220 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
16221 the instantiation. */
16224 /* Check to see whether we know that this template will be
16225 instantiated in some other file, as with "extern template"
16227 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
16229 /* In general, we do not instantiate such templates. */
16230 if (external_p && !always_instantiate_p (d))
16233 gen_tmpl = most_general_template (tmpl);
16234 gen_args = DECL_TI_ARGS (d);
16236 if (tmpl != gen_tmpl)
16237 /* We should already have the extra args. */
16238 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))
16239 == TMPL_ARGS_DEPTH (gen_args));
16240 /* And what's in the hash table should match D. */
16241 gcc_assert ((spec = retrieve_specialization (gen_tmpl, gen_args, 0)) == d
16242 || spec == NULL_TREE);
16244 /* This needs to happen before any tsubsting. */
16245 if (! push_tinst_level (d))
16248 timevar_push (TV_PARSE);
16250 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
16251 for the instantiation. */
16252 td = template_for_substitution (d);
16253 code_pattern = DECL_TEMPLATE_RESULT (td);
16255 /* We should never be trying to instantiate a member of a class
16256 template or partial specialization. */
16257 gcc_assert (d != code_pattern);
16259 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
16260 || DECL_TEMPLATE_SPECIALIZATION (td))
16261 /* In the case of a friend template whose definition is provided
16262 outside the class, we may have too many arguments. Drop the
16263 ones we don't need. The same is true for specializations. */
16264 args = get_innermost_template_args
16265 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
16269 if (TREE_CODE (d) == FUNCTION_DECL)
16270 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
16272 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
16274 /* We may be in the middle of deferred access check. Disable it now. */
16275 push_deferring_access_checks (dk_no_deferred);
16277 /* Unless an explicit instantiation directive has already determined
16278 the linkage of D, remember that a definition is available for
16280 if (pattern_defined
16281 && !DECL_INTERFACE_KNOWN (d)
16282 && !DECL_NOT_REALLY_EXTERN (d))
16283 mark_definable (d);
16285 input_location = DECL_SOURCE_LOCATION (d);
16287 /* If D is a member of an explicitly instantiated class template,
16288 and no definition is available, treat it like an implicit
16290 if (!pattern_defined && expl_inst_class_mem_p
16291 && DECL_EXPLICIT_INSTANTIATION (d))
16293 DECL_NOT_REALLY_EXTERN (d) = 0;
16294 DECL_INTERFACE_KNOWN (d) = 0;
16295 SET_DECL_IMPLICIT_INSTANTIATION (d);
16298 /* Recheck the substitutions to obtain any warning messages
16299 about ignoring cv qualifiers. Don't do this for artificial decls,
16300 as it breaks the context-sensitive substitution for lambda op(). */
16301 if (!defer_ok && !DECL_ARTIFICIAL (d))
16303 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
16304 tree type = TREE_TYPE (gen);
16306 /* Make sure that we can see identifiers, and compute access
16307 correctly. D is already the target FUNCTION_DECL with the
16309 push_access_scope (d);
16311 if (TREE_CODE (gen) == FUNCTION_DECL)
16313 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
16314 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
16316 /* Don't simply tsubst the function type, as that will give
16317 duplicate warnings about poor parameter qualifications.
16318 The function arguments are the same as the decl_arguments
16319 without the top level cv qualifiers. */
16320 type = TREE_TYPE (type);
16322 tsubst (type, gen_args, tf_warning_or_error, d);
16324 pop_access_scope (d);
16327 /* Defer all other templates, unless we have been explicitly
16328 forbidden from doing so. */
16329 if (/* If there is no definition, we cannot instantiate the
16332 /* If it's OK to postpone instantiation, do so. */
16334 /* If this is a static data member that will be defined
16335 elsewhere, we don't want to instantiate the entire data
16336 member, but we do want to instantiate the initializer so that
16337 we can substitute that elsewhere. */
16338 || (external_p && TREE_CODE (d) == VAR_DECL))
16340 /* The definition of the static data member is now required so
16341 we must substitute the initializer. */
16342 if (TREE_CODE (d) == VAR_DECL
16343 && !DECL_INITIAL (d)
16344 && DECL_INITIAL (code_pattern))
16349 ns = decl_namespace_context (d);
16350 push_nested_namespace (ns);
16351 push_nested_class (DECL_CONTEXT (d));
16352 init = tsubst_expr (DECL_INITIAL (code_pattern),
16354 tf_warning_or_error, NULL_TREE,
16355 /*integral_constant_expression_p=*/false);
16356 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
16357 /*asmspec_tree=*/NULL_TREE,
16358 LOOKUP_ONLYCONVERTING);
16359 pop_nested_class ();
16360 pop_nested_namespace (ns);
16363 /* We restore the source position here because it's used by
16364 add_pending_template. */
16365 input_location = saved_loc;
16367 if (at_eof && !pattern_defined
16368 && DECL_EXPLICIT_INSTANTIATION (d)
16369 && DECL_NOT_REALLY_EXTERN (d))
16372 The definition of a non-exported function template, a
16373 non-exported member function template, or a non-exported
16374 member function or static data member of a class template
16375 shall be present in every translation unit in which it is
16376 explicitly instantiated. */
16377 permerror (input_location, "explicit instantiation of %qD "
16378 "but no definition available", d);
16380 /* ??? Historically, we have instantiated inline functions, even
16381 when marked as "extern template". */
16382 if (!(external_p && TREE_CODE (d) == VAR_DECL))
16383 add_pending_template (d);
16386 /* Tell the repository that D is available in this translation unit
16387 -- and see if it is supposed to be instantiated here. */
16388 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
16390 /* In a PCH file, despite the fact that the repository hasn't
16391 requested instantiation in the PCH it is still possible that
16392 an instantiation will be required in a file that includes the
16395 add_pending_template (d);
16396 /* Instantiate inline functions so that the inliner can do its
16397 job, even though we'll not be emitting a copy of this
16399 if (!(TREE_CODE (d) == FUNCTION_DECL && possibly_inlined_p (d)))
16403 need_push = !cfun || !global_bindings_p ();
16405 push_to_top_level ();
16407 /* Mark D as instantiated so that recursive calls to
16408 instantiate_decl do not try to instantiate it again. */
16409 DECL_TEMPLATE_INSTANTIATED (d) = 1;
16411 /* Regenerate the declaration in case the template has been modified
16412 by a subsequent redeclaration. */
16413 regenerate_decl_from_template (d, td);
16415 /* We already set the file and line above. Reset them now in case
16416 they changed as a result of calling regenerate_decl_from_template. */
16417 input_location = DECL_SOURCE_LOCATION (d);
16419 if (TREE_CODE (d) == VAR_DECL)
16423 /* Clear out DECL_RTL; whatever was there before may not be right
16424 since we've reset the type of the declaration. */
16425 SET_DECL_RTL (d, NULL_RTX);
16426 DECL_IN_AGGR_P (d) = 0;
16428 /* The initializer is placed in DECL_INITIAL by
16429 regenerate_decl_from_template. Pull it out so that
16430 cp_finish_decl can process it. */
16431 init = DECL_INITIAL (d);
16432 DECL_INITIAL (d) = NULL_TREE;
16433 DECL_INITIALIZED_P (d) = 0;
16435 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
16436 initializer. That function will defer actual emission until
16437 we have a chance to determine linkage. */
16438 DECL_EXTERNAL (d) = 0;
16440 /* Enter the scope of D so that access-checking works correctly. */
16441 push_nested_class (DECL_CONTEXT (d));
16442 cp_finish_decl (d, init, false, NULL_TREE, 0);
16443 pop_nested_class ();
16445 else if (TREE_CODE (d) == FUNCTION_DECL)
16447 htab_t saved_local_specializations;
16452 /* Save away the current list, in case we are instantiating one
16453 template from within the body of another. */
16454 saved_local_specializations = local_specializations;
16456 /* Set up the list of local specializations. */
16457 local_specializations = htab_create (37,
16458 hash_local_specialization,
16459 eq_local_specializations,
16462 /* Set up context. */
16463 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
16465 /* Create substitution entries for the parameters. */
16466 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
16467 tmpl_parm = DECL_ARGUMENTS (subst_decl);
16468 spec_parm = DECL_ARGUMENTS (d);
16469 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
16471 register_local_specialization (spec_parm, tmpl_parm);
16472 spec_parm = skip_artificial_parms_for (d, spec_parm);
16473 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
16475 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16477 register_local_specialization (spec_parm, tmpl_parm);
16478 tmpl_parm = TREE_CHAIN (tmpl_parm);
16479 spec_parm = TREE_CHAIN (spec_parm);
16481 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16483 /* Register the (value) argument pack as a specialization of
16484 TMPL_PARM, then move on. */
16485 tree argpack = make_fnparm_pack (spec_parm);
16486 register_local_specialization (argpack, tmpl_parm);
16487 tmpl_parm = TREE_CHAIN (tmpl_parm);
16488 spec_parm = NULL_TREE;
16490 gcc_assert (!spec_parm);
16492 /* Substitute into the body of the function. */
16493 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
16494 tf_warning_or_error, tmpl,
16495 /*integral_constant_expression_p=*/false);
16497 /* Set the current input_location to the end of the function
16498 so that finish_function knows where we are. */
16499 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
16501 /* We don't need the local specializations any more. */
16502 htab_delete (local_specializations);
16503 local_specializations = saved_local_specializations;
16505 /* Finish the function. */
16506 d = finish_function (0);
16507 expand_or_defer_fn (d);
16510 /* We're not deferring instantiation any more. */
16511 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
16514 pop_from_top_level ();
16517 input_location = saved_loc;
16518 pop_deferring_access_checks ();
16519 pop_tinst_level ();
16521 timevar_pop (TV_PARSE);
16526 /* Run through the list of templates that we wish we could
16527 instantiate, and instantiate any we can. RETRIES is the
16528 number of times we retry pending template instantiation. */
16531 instantiate_pending_templates (int retries)
16534 location_t saved_loc = input_location;
16536 /* Instantiating templates may trigger vtable generation. This in turn
16537 may require further template instantiations. We place a limit here
16538 to avoid infinite loop. */
16539 if (pending_templates && retries >= max_tinst_depth)
16541 tree decl = pending_templates->tinst->decl;
16543 error ("template instantiation depth exceeds maximum of %d"
16544 " instantiating %q+D, possibly from virtual table generation"
16545 " (use -ftemplate-depth-NN to increase the maximum)",
16546 max_tinst_depth, decl);
16547 if (TREE_CODE (decl) == FUNCTION_DECL)
16548 /* Pretend that we defined it. */
16549 DECL_INITIAL (decl) = error_mark_node;
16555 struct pending_template **t = &pending_templates;
16556 struct pending_template *last = NULL;
16560 tree instantiation = reopen_tinst_level ((*t)->tinst);
16561 bool complete = false;
16563 if (TYPE_P (instantiation))
16567 if (!COMPLETE_TYPE_P (instantiation))
16569 instantiate_class_template (instantiation);
16570 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
16571 for (fn = TYPE_METHODS (instantiation);
16573 fn = TREE_CHAIN (fn))
16574 if (! DECL_ARTIFICIAL (fn))
16575 instantiate_decl (fn,
16577 /*expl_inst_class_mem_p=*/false);
16578 if (COMPLETE_TYPE_P (instantiation))
16582 complete = COMPLETE_TYPE_P (instantiation);
16586 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
16587 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
16590 = instantiate_decl (instantiation,
16592 /*expl_inst_class_mem_p=*/false);
16593 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
16597 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
16598 || DECL_TEMPLATE_INSTANTIATED (instantiation));
16602 /* If INSTANTIATION has been instantiated, then we don't
16603 need to consider it again in the future. */
16611 current_tinst_level = NULL;
16613 last_pending_template = last;
16615 while (reconsider);
16617 input_location = saved_loc;
16620 /* Substitute ARGVEC into T, which is a list of initializers for
16621 either base class or a non-static data member. The TREE_PURPOSEs
16622 are DECLs, and the TREE_VALUEs are the initializer values. Used by
16623 instantiate_decl. */
16626 tsubst_initializer_list (tree t, tree argvec)
16628 tree inits = NULL_TREE;
16630 for (; t; t = TREE_CHAIN (t))
16634 tree expanded_bases = NULL_TREE;
16635 tree expanded_arguments = NULL_TREE;
16638 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
16643 /* Expand the base class expansion type into separate base
16645 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
16646 tf_warning_or_error,
16648 if (expanded_bases == error_mark_node)
16651 /* We'll be building separate TREE_LISTs of arguments for
16653 len = TREE_VEC_LENGTH (expanded_bases);
16654 expanded_arguments = make_tree_vec (len);
16655 for (i = 0; i < len; i++)
16656 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
16658 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
16659 expand each argument in the TREE_VALUE of t. */
16660 expr = make_node (EXPR_PACK_EXPANSION);
16661 PACK_EXPANSION_PARAMETER_PACKS (expr) =
16662 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
16664 if (TREE_VALUE (t) == void_type_node)
16665 /* VOID_TYPE_NODE is used to indicate
16666 value-initialization. */
16668 for (i = 0; i < len; i++)
16669 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
16673 /* Substitute parameter packs into each argument in the
16675 in_base_initializer = 1;
16676 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
16678 tree expanded_exprs;
16680 /* Expand the argument. */
16681 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
16683 = tsubst_pack_expansion (expr, argvec,
16684 tf_warning_or_error,
16686 if (expanded_exprs == error_mark_node)
16689 /* Prepend each of the expanded expressions to the
16690 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
16691 for (i = 0; i < len; i++)
16693 TREE_VEC_ELT (expanded_arguments, i) =
16694 tree_cons (NULL_TREE,
16695 TREE_VEC_ELT (expanded_exprs, i),
16696 TREE_VEC_ELT (expanded_arguments, i));
16699 in_base_initializer = 0;
16701 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
16702 since we built them backwards. */
16703 for (i = 0; i < len; i++)
16705 TREE_VEC_ELT (expanded_arguments, i) =
16706 nreverse (TREE_VEC_ELT (expanded_arguments, i));
16711 for (i = 0; i < len; ++i)
16713 if (expanded_bases)
16715 decl = TREE_VEC_ELT (expanded_bases, i);
16716 decl = expand_member_init (decl);
16717 init = TREE_VEC_ELT (expanded_arguments, i);
16721 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
16722 tf_warning_or_error, NULL_TREE);
16724 decl = expand_member_init (decl);
16725 if (decl && !DECL_P (decl))
16726 in_base_initializer = 1;
16728 init = tsubst_expr (TREE_VALUE (t), argvec,
16729 tf_warning_or_error, NULL_TREE,
16730 /*integral_constant_expression_p=*/false);
16731 in_base_initializer = 0;
16736 init = build_tree_list (decl, init);
16737 TREE_CHAIN (init) = inits;
16745 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
16748 set_current_access_from_decl (tree decl)
16750 if (TREE_PRIVATE (decl))
16751 current_access_specifier = access_private_node;
16752 else if (TREE_PROTECTED (decl))
16753 current_access_specifier = access_protected_node;
16755 current_access_specifier = access_public_node;
16758 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
16759 is the instantiation (which should have been created with
16760 start_enum) and ARGS are the template arguments to use. */
16763 tsubst_enum (tree tag, tree newtag, tree args)
16767 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
16772 decl = TREE_VALUE (e);
16773 /* Note that in a template enum, the TREE_VALUE is the
16774 CONST_DECL, not the corresponding INTEGER_CST. */
16775 value = tsubst_expr (DECL_INITIAL (decl),
16776 args, tf_warning_or_error, NULL_TREE,
16777 /*integral_constant_expression_p=*/true);
16779 /* Give this enumeration constant the correct access. */
16780 set_current_access_from_decl (decl);
16782 /* Actually build the enumerator itself. */
16783 build_enumerator (DECL_NAME (decl), value, newtag);
16786 finish_enum (newtag);
16787 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
16788 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
16791 /* DECL is a FUNCTION_DECL that is a template specialization. Return
16792 its type -- but without substituting the innermost set of template
16793 arguments. So, innermost set of template parameters will appear in
16797 get_mostly_instantiated_function_type (tree decl)
16805 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
16806 targs = DECL_TI_ARGS (decl);
16807 tparms = DECL_TEMPLATE_PARMS (tmpl);
16808 parm_depth = TMPL_PARMS_DEPTH (tparms);
16810 /* There should be as many levels of arguments as there are levels
16812 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
16814 fn_type = TREE_TYPE (tmpl);
16816 if (parm_depth == 1)
16817 /* No substitution is necessary. */
16821 int i, save_access_control;
16824 /* Replace the innermost level of the TARGS with NULL_TREEs to
16825 let tsubst know not to substitute for those parameters. */
16826 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
16827 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
16828 SET_TMPL_ARGS_LEVEL (partial_args, i,
16829 TMPL_ARGS_LEVEL (targs, i));
16830 SET_TMPL_ARGS_LEVEL (partial_args,
16831 TMPL_ARGS_DEPTH (targs),
16832 make_tree_vec (DECL_NTPARMS (tmpl)));
16834 /* Disable access control as this function is used only during
16836 save_access_control = flag_access_control;
16837 flag_access_control = 0;
16839 ++processing_template_decl;
16840 /* Now, do the (partial) substitution to figure out the
16841 appropriate function type. */
16842 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
16843 --processing_template_decl;
16845 /* Substitute into the template parameters to obtain the real
16846 innermost set of parameters. This step is important if the
16847 innermost set of template parameters contains value
16848 parameters whose types depend on outer template parameters. */
16849 TREE_VEC_LENGTH (partial_args)--;
16850 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
16852 flag_access_control = save_access_control;
16858 /* Return truthvalue if we're processing a template different from
16859 the last one involved in diagnostics. */
16861 problematic_instantiation_changed (void)
16863 return last_template_error_tick != tinst_level_tick;
16866 /* Remember current template involved in diagnostics. */
16868 record_last_problematic_instantiation (void)
16870 last_template_error_tick = tinst_level_tick;
16873 struct tinst_level *
16874 current_instantiation (void)
16876 return current_tinst_level;
16879 /* [temp.param] Check that template non-type parm TYPE is of an allowable
16880 type. Return zero for ok, nonzero for disallowed. Issue error and
16881 warning messages under control of COMPLAIN. */
16884 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
16886 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
16888 else if (POINTER_TYPE_P (type))
16890 else if (TYPE_PTR_TO_MEMBER_P (type))
16892 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
16894 else if (TREE_CODE (type) == TYPENAME_TYPE)
16897 if (complain & tf_error)
16898 error ("%q#T is not a valid type for a template constant parameter", type);
16902 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
16903 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
16906 dependent_type_p_r (tree type)
16912 A type is dependent if it is:
16914 -- a template parameter. Template template parameters are types
16915 for us (since TYPE_P holds true for them) so we handle
16917 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
16918 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
16920 /* -- a qualified-id with a nested-name-specifier which contains a
16921 class-name that names a dependent type or whose unqualified-id
16922 names a dependent type. */
16923 if (TREE_CODE (type) == TYPENAME_TYPE)
16925 /* -- a cv-qualified type where the cv-unqualified type is
16927 type = TYPE_MAIN_VARIANT (type);
16928 /* -- a compound type constructed from any dependent type. */
16929 if (TYPE_PTR_TO_MEMBER_P (type))
16930 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
16931 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
16933 else if (TREE_CODE (type) == POINTER_TYPE
16934 || TREE_CODE (type) == REFERENCE_TYPE)
16935 return dependent_type_p (TREE_TYPE (type));
16936 else if (TREE_CODE (type) == FUNCTION_TYPE
16937 || TREE_CODE (type) == METHOD_TYPE)
16941 if (dependent_type_p (TREE_TYPE (type)))
16943 for (arg_type = TYPE_ARG_TYPES (type);
16945 arg_type = TREE_CHAIN (arg_type))
16946 if (dependent_type_p (TREE_VALUE (arg_type)))
16950 /* -- an array type constructed from any dependent type or whose
16951 size is specified by a constant expression that is
16952 value-dependent. */
16953 if (TREE_CODE (type) == ARRAY_TYPE)
16955 if (TYPE_DOMAIN (type)
16956 && dependent_type_p (TYPE_DOMAIN (type)))
16958 return dependent_type_p (TREE_TYPE (type));
16960 else if (TREE_CODE (type) == INTEGER_TYPE
16961 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
16963 /* If this is the TYPE_DOMAIN of an array type, consider it
16964 dependent. We already checked for value-dependence in
16965 compute_array_index_type. */
16966 return type_dependent_expression_p (TYPE_MAX_VALUE (type));
16969 /* -- a template-id in which either the template name is a template
16971 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
16973 /* ... or any of the template arguments is a dependent type or
16974 an expression that is type-dependent or value-dependent. */
16975 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
16976 && (any_dependent_template_arguments_p
16977 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
16980 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
16981 argument of the `typeof' expression is not type-dependent, then
16982 it should already been have resolved. */
16983 if (TREE_CODE (type) == TYPEOF_TYPE
16984 || TREE_CODE (type) == DECLTYPE_TYPE)
16987 /* A template argument pack is dependent if any of its packed
16989 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
16991 tree args = ARGUMENT_PACK_ARGS (type);
16992 int i, len = TREE_VEC_LENGTH (args);
16993 for (i = 0; i < len; ++i)
16994 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
16998 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
16999 be template parameters. */
17000 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
17003 /* The standard does not specifically mention types that are local
17004 to template functions or local classes, but they should be
17005 considered dependent too. For example:
17007 template <int I> void f() {
17012 The size of `E' cannot be known until the value of `I' has been
17013 determined. Therefore, `E' must be considered dependent. */
17014 scope = TYPE_CONTEXT (type);
17015 if (scope && TYPE_P (scope))
17016 return dependent_type_p (scope);
17017 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
17018 return type_dependent_expression_p (scope);
17020 /* Other types are non-dependent. */
17024 /* Returns TRUE if TYPE is dependent, in the sense of
17025 [temp.dep.type]. */
17028 dependent_type_p (tree type)
17030 /* If there are no template parameters in scope, then there can't be
17031 any dependent types. */
17032 if (!processing_template_decl)
17034 /* If we are not processing a template, then nobody should be
17035 providing us with a dependent type. */
17037 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM || is_auto (type));
17041 /* If the type is NULL, we have not computed a type for the entity
17042 in question; in that case, the type is dependent. */
17046 /* Erroneous types can be considered non-dependent. */
17047 if (type == error_mark_node)
17050 /* If we have not already computed the appropriate value for TYPE,
17052 if (!TYPE_DEPENDENT_P_VALID (type))
17054 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
17055 TYPE_DEPENDENT_P_VALID (type) = 1;
17058 return TYPE_DEPENDENT_P (type);
17061 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
17062 lookup. In other words, a dependent type that is not the current
17066 dependent_scope_p (tree scope)
17068 return (scope && TYPE_P (scope) && dependent_type_p (scope)
17069 && !currently_open_class (scope));
17072 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
17075 dependent_scope_ref_p (tree expression, bool criterion (tree))
17080 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
17082 if (!TYPE_P (TREE_OPERAND (expression, 0)))
17085 scope = TREE_OPERAND (expression, 0);
17086 name = TREE_OPERAND (expression, 1);
17090 An id-expression is type-dependent if it contains a
17091 nested-name-specifier that contains a class-name that names a
17093 /* The suggested resolution to Core Issue 224 implies that if the
17094 qualifying type is the current class, then we must peek
17097 && currently_open_class (scope)
17098 && !criterion (name))
17100 if (dependent_type_p (scope))
17106 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
17107 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
17111 value_dependent_expression_p (tree expression)
17113 if (!processing_template_decl)
17116 /* A name declared with a dependent type. */
17117 if (DECL_P (expression) && type_dependent_expression_p (expression))
17120 switch (TREE_CODE (expression))
17122 case IDENTIFIER_NODE:
17123 /* A name that has not been looked up -- must be dependent. */
17126 case TEMPLATE_PARM_INDEX:
17127 /* A non-type template parm. */
17131 /* A non-type template parm. */
17132 if (DECL_TEMPLATE_PARM_P (expression))
17134 return value_dependent_expression_p (DECL_INITIAL (expression));
17137 /* A constant with integral or enumeration type and is initialized
17138 with an expression that is value-dependent. */
17139 if (DECL_INITIAL (expression)
17140 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
17141 && value_dependent_expression_p (DECL_INITIAL (expression)))
17145 case DYNAMIC_CAST_EXPR:
17146 case STATIC_CAST_EXPR:
17147 case CONST_CAST_EXPR:
17148 case REINTERPRET_CAST_EXPR:
17150 /* These expressions are value-dependent if the type to which
17151 the cast occurs is dependent or the expression being casted
17152 is value-dependent. */
17154 tree type = TREE_TYPE (expression);
17156 if (dependent_type_p (type))
17159 /* A functional cast has a list of operands. */
17160 expression = TREE_OPERAND (expression, 0);
17163 /* If there are no operands, it must be an expression such
17164 as "int()". This should not happen for aggregate types
17165 because it would form non-constant expressions. */
17166 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
17171 if (TREE_CODE (expression) == TREE_LIST)
17172 return any_value_dependent_elements_p (expression);
17174 return value_dependent_expression_p (expression);
17179 /* A `sizeof' expression is value-dependent if the operand is
17180 type-dependent or is a pack expansion. */
17181 expression = TREE_OPERAND (expression, 0);
17182 if (PACK_EXPANSION_P (expression))
17184 else if (TYPE_P (expression))
17185 return dependent_type_p (expression);
17186 return type_dependent_expression_p (expression);
17189 return dependent_scope_ref_p (expression, value_dependent_expression_p);
17191 case COMPONENT_REF:
17192 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
17193 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
17196 /* A CALL_EXPR may appear in a constant expression if it is a
17197 call to a builtin function, e.g., __builtin_constant_p. All
17198 such calls are value-dependent. */
17201 case NONTYPE_ARGUMENT_PACK:
17202 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
17203 is value-dependent. */
17205 tree values = ARGUMENT_PACK_ARGS (expression);
17206 int i, len = TREE_VEC_LENGTH (values);
17208 for (i = 0; i < len; ++i)
17209 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
17217 tree type2 = TRAIT_EXPR_TYPE2 (expression);
17218 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
17219 || (type2 ? dependent_type_p (type2) : false));
17223 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
17224 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
17227 /* A constant expression is value-dependent if any subexpression is
17228 value-dependent. */
17229 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
17231 case tcc_reference:
17233 return (value_dependent_expression_p
17234 (TREE_OPERAND (expression, 0)));
17236 case tcc_comparison:
17238 return ((value_dependent_expression_p
17239 (TREE_OPERAND (expression, 0)))
17240 || (value_dependent_expression_p
17241 (TREE_OPERAND (expression, 1))));
17243 case tcc_expression:
17247 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
17248 /* In some cases, some of the operands may be missing.
17249 (For example, in the case of PREDECREMENT_EXPR, the
17250 amount to increment by may be missing.) That doesn't
17251 make the expression dependent. */
17252 if (TREE_OPERAND (expression, i)
17253 && (value_dependent_expression_p
17254 (TREE_OPERAND (expression, i))))
17264 /* The expression is not value-dependent. */
17268 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
17269 [temp.dep.expr]. */
17272 type_dependent_expression_p (tree expression)
17274 if (!processing_template_decl)
17277 if (expression == error_mark_node)
17280 /* An unresolved name is always dependent. */
17281 if (TREE_CODE (expression) == IDENTIFIER_NODE
17282 || TREE_CODE (expression) == USING_DECL)
17285 /* Some expression forms are never type-dependent. */
17286 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
17287 || TREE_CODE (expression) == SIZEOF_EXPR
17288 || TREE_CODE (expression) == ALIGNOF_EXPR
17289 || TREE_CODE (expression) == TRAIT_EXPR
17290 || TREE_CODE (expression) == TYPEID_EXPR
17291 || TREE_CODE (expression) == DELETE_EXPR
17292 || TREE_CODE (expression) == VEC_DELETE_EXPR
17293 || TREE_CODE (expression) == THROW_EXPR)
17296 /* The types of these expressions depends only on the type to which
17297 the cast occurs. */
17298 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
17299 || TREE_CODE (expression) == STATIC_CAST_EXPR
17300 || TREE_CODE (expression) == CONST_CAST_EXPR
17301 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
17302 || TREE_CODE (expression) == CAST_EXPR)
17303 return dependent_type_p (TREE_TYPE (expression));
17305 /* The types of these expressions depends only on the type created
17306 by the expression. */
17307 if (TREE_CODE (expression) == NEW_EXPR
17308 || TREE_CODE (expression) == VEC_NEW_EXPR)
17310 /* For NEW_EXPR tree nodes created inside a template, either
17311 the object type itself or a TREE_LIST may appear as the
17313 tree type = TREE_OPERAND (expression, 1);
17314 if (TREE_CODE (type) == TREE_LIST)
17315 /* This is an array type. We need to check array dimensions
17317 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
17318 || value_dependent_expression_p
17319 (TREE_OPERAND (TREE_VALUE (type), 1));
17321 return dependent_type_p (type);
17324 if (TREE_CODE (expression) == SCOPE_REF
17325 && dependent_scope_ref_p (expression,
17326 type_dependent_expression_p))
17329 if (TREE_CODE (expression) == FUNCTION_DECL
17330 && DECL_LANG_SPECIFIC (expression)
17331 && DECL_TEMPLATE_INFO (expression)
17332 && (any_dependent_template_arguments_p
17333 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
17336 if (TREE_CODE (expression) == TEMPLATE_DECL
17337 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
17340 if (TREE_CODE (expression) == STMT_EXPR)
17341 expression = stmt_expr_value_expr (expression);
17343 if (BRACE_ENCLOSED_INITIALIZER_P (expression))
17348 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), i, elt)
17350 if (type_dependent_expression_p (elt))
17356 if (TREE_TYPE (expression) == unknown_type_node)
17358 if (TREE_CODE (expression) == ADDR_EXPR)
17359 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
17360 if (TREE_CODE (expression) == COMPONENT_REF
17361 || TREE_CODE (expression) == OFFSET_REF)
17363 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
17365 expression = TREE_OPERAND (expression, 1);
17366 if (TREE_CODE (expression) == IDENTIFIER_NODE)
17369 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
17370 if (TREE_CODE (expression) == SCOPE_REF)
17373 if (TREE_CODE (expression) == BASELINK)
17374 expression = BASELINK_FUNCTIONS (expression);
17376 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
17378 if (any_dependent_template_arguments_p
17379 (TREE_OPERAND (expression, 1)))
17381 expression = TREE_OPERAND (expression, 0);
17383 gcc_assert (TREE_CODE (expression) == OVERLOAD
17384 || TREE_CODE (expression) == FUNCTION_DECL);
17388 if (type_dependent_expression_p (OVL_CURRENT (expression)))
17390 expression = OVL_NEXT (expression);
17395 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
17397 return (dependent_type_p (TREE_TYPE (expression)));
17400 /* Like type_dependent_expression_p, but it also works while not processing
17401 a template definition, i.e. during substitution or mangling. */
17404 type_dependent_expression_p_push (tree expr)
17407 ++processing_template_decl;
17408 b = type_dependent_expression_p (expr);
17409 --processing_template_decl;
17413 /* Returns TRUE if ARGS contains a type-dependent expression. */
17416 any_type_dependent_arguments_p (const VEC(tree,gc) *args)
17421 for (i = 0; VEC_iterate (tree, args, i, arg); ++i)
17423 if (type_dependent_expression_p (arg))
17429 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
17430 expressions) contains any value-dependent expressions. */
17433 any_value_dependent_elements_p (const_tree list)
17435 for (; list; list = TREE_CHAIN (list))
17436 if (value_dependent_expression_p (TREE_VALUE (list)))
17442 /* Returns TRUE if the ARG (a template argument) is dependent. */
17445 dependent_template_arg_p (tree arg)
17447 if (!processing_template_decl)
17450 if (TREE_CODE (arg) == TEMPLATE_DECL
17451 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
17452 return dependent_template_p (arg);
17453 else if (ARGUMENT_PACK_P (arg))
17455 tree args = ARGUMENT_PACK_ARGS (arg);
17456 int i, len = TREE_VEC_LENGTH (args);
17457 for (i = 0; i < len; ++i)
17459 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
17465 else if (TYPE_P (arg))
17466 return dependent_type_p (arg);
17468 return (type_dependent_expression_p (arg)
17469 || value_dependent_expression_p (arg));
17472 /* Returns true if ARGS (a collection of template arguments) contains
17473 any types that require structural equality testing. */
17476 any_template_arguments_need_structural_equality_p (tree args)
17483 if (args == error_mark_node)
17486 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
17488 tree level = TMPL_ARGS_LEVEL (args, i + 1);
17489 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
17491 tree arg = TREE_VEC_ELT (level, j);
17492 tree packed_args = NULL_TREE;
17495 if (ARGUMENT_PACK_P (arg))
17497 /* Look inside the argument pack. */
17498 packed_args = ARGUMENT_PACK_ARGS (arg);
17499 len = TREE_VEC_LENGTH (packed_args);
17502 for (k = 0; k < len; ++k)
17505 arg = TREE_VEC_ELT (packed_args, k);
17507 if (error_operand_p (arg))
17509 else if (TREE_CODE (arg) == TEMPLATE_DECL
17510 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
17512 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
17514 else if (!TYPE_P (arg) && TREE_TYPE (arg)
17515 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
17524 /* Returns true if ARGS (a collection of template arguments) contains
17525 any dependent arguments. */
17528 any_dependent_template_arguments_p (const_tree args)
17535 if (args == error_mark_node)
17538 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
17540 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
17541 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
17542 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
17549 /* Returns TRUE if the template TMPL is dependent. */
17552 dependent_template_p (tree tmpl)
17554 if (TREE_CODE (tmpl) == OVERLOAD)
17558 if (dependent_template_p (OVL_FUNCTION (tmpl)))
17560 tmpl = OVL_CHAIN (tmpl);
17565 /* Template template parameters are dependent. */
17566 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
17567 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
17569 /* So are names that have not been looked up. */
17570 if (TREE_CODE (tmpl) == SCOPE_REF
17571 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
17573 /* So are member templates of dependent classes. */
17574 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
17575 return dependent_type_p (DECL_CONTEXT (tmpl));
17579 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
17582 dependent_template_id_p (tree tmpl, tree args)
17584 return (dependent_template_p (tmpl)
17585 || any_dependent_template_arguments_p (args));
17588 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
17592 dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv)
17596 if (!processing_template_decl)
17599 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
17601 tree decl = TREE_VEC_ELT (declv, i);
17602 tree init = TREE_VEC_ELT (initv, i);
17603 tree cond = TREE_VEC_ELT (condv, i);
17604 tree incr = TREE_VEC_ELT (incrv, i);
17606 if (type_dependent_expression_p (decl))
17609 if (init && type_dependent_expression_p (init))
17612 if (type_dependent_expression_p (cond))
17615 if (COMPARISON_CLASS_P (cond)
17616 && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
17617 || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
17620 if (TREE_CODE (incr) == MODOP_EXPR)
17622 if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
17623 || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
17626 else if (type_dependent_expression_p (incr))
17628 else if (TREE_CODE (incr) == MODIFY_EXPR)
17630 if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
17632 else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
17634 tree t = TREE_OPERAND (incr, 1);
17635 if (type_dependent_expression_p (TREE_OPERAND (t, 0))
17636 || type_dependent_expression_p (TREE_OPERAND (t, 1)))
17645 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
17646 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
17647 no such TYPE can be found. Note that this function peers inside
17648 uninstantiated templates and therefore should be used only in
17649 extremely limited situations. ONLY_CURRENT_P restricts this
17650 peering to the currently open classes hierarchy (which is required
17651 when comparing types). */
17654 resolve_typename_type (tree type, bool only_current_p)
17663 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
17665 scope = TYPE_CONTEXT (type);
17666 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
17667 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
17668 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
17669 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
17670 identifier of the TYPENAME_TYPE anymore.
17671 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
17672 TYPENAME_TYPE instead, we avoid messing up with a possible
17673 typedef variant case. */
17674 name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
17676 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
17677 it first before we can figure out what NAME refers to. */
17678 if (TREE_CODE (scope) == TYPENAME_TYPE)
17679 scope = resolve_typename_type (scope, only_current_p);
17680 /* If we don't know what SCOPE refers to, then we cannot resolve the
17682 if (TREE_CODE (scope) == TYPENAME_TYPE)
17684 /* If the SCOPE is a template type parameter, we have no way of
17685 resolving the name. */
17686 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
17688 /* If the SCOPE is not the current instantiation, there's no reason
17689 to look inside it. */
17690 if (only_current_p && !currently_open_class (scope))
17692 /* If this is a typedef, we don't want to look inside (c++/11987). */
17693 if (typedef_variant_p (type))
17695 /* If SCOPE isn't the template itself, it will not have a valid
17696 TYPE_FIELDS list. */
17697 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
17698 /* scope is either the template itself or a compatible instantiation
17699 like X<T>, so look up the name in the original template. */
17700 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
17702 /* scope is a partial instantiation, so we can't do the lookup or we
17703 will lose the template arguments. */
17705 /* Enter the SCOPE so that name lookup will be resolved as if we
17706 were in the class definition. In particular, SCOPE will no
17707 longer be considered a dependent type. */
17708 pushed_scope = push_scope (scope);
17709 /* Look up the declaration. */
17710 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
17712 result = NULL_TREE;
17714 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
17715 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
17718 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
17719 && TREE_CODE (decl) == TYPE_DECL)
17721 result = TREE_TYPE (decl);
17722 if (result == error_mark_node)
17723 result = NULL_TREE;
17725 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
17726 && DECL_CLASS_TEMPLATE_P (decl))
17730 /* Obtain the template and the arguments. */
17731 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
17732 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
17733 /* Instantiate the template. */
17734 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
17735 /*entering_scope=*/0,
17736 tf_error | tf_user);
17737 if (result == error_mark_node)
17738 result = NULL_TREE;
17741 /* Leave the SCOPE. */
17743 pop_scope (pushed_scope);
17745 /* If we failed to resolve it, return the original typename. */
17749 /* If lookup found a typename type, resolve that too. */
17750 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
17752 /* Ill-formed programs can cause infinite recursion here, so we
17753 must catch that. */
17754 TYPENAME_IS_RESOLVING_P (type) = 1;
17755 result = resolve_typename_type (result, only_current_p);
17756 TYPENAME_IS_RESOLVING_P (type) = 0;
17759 /* Qualify the resulting type. */
17760 quals = cp_type_quals (type);
17762 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
17767 /* EXPR is an expression which is not type-dependent. Return a proxy
17768 for EXPR that can be used to compute the types of larger
17769 expressions containing EXPR. */
17772 build_non_dependent_expr (tree expr)
17776 /* Preserve null pointer constants so that the type of things like
17777 "p == 0" where "p" is a pointer can be determined. */
17778 if (null_ptr_cst_p (expr))
17780 /* Preserve OVERLOADs; the functions must be available to resolve
17783 if (TREE_CODE (inner_expr) == STMT_EXPR)
17784 inner_expr = stmt_expr_value_expr (inner_expr);
17785 if (TREE_CODE (inner_expr) == ADDR_EXPR)
17786 inner_expr = TREE_OPERAND (inner_expr, 0);
17787 if (TREE_CODE (inner_expr) == COMPONENT_REF)
17788 inner_expr = TREE_OPERAND (inner_expr, 1);
17789 if (is_overloaded_fn (inner_expr)
17790 || TREE_CODE (inner_expr) == OFFSET_REF)
17792 /* There is no need to return a proxy for a variable. */
17793 if (TREE_CODE (expr) == VAR_DECL)
17795 /* Preserve string constants; conversions from string constants to
17796 "char *" are allowed, even though normally a "const char *"
17797 cannot be used to initialize a "char *". */
17798 if (TREE_CODE (expr) == STRING_CST)
17800 /* Preserve arithmetic constants, as an optimization -- there is no
17801 reason to create a new node. */
17802 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
17804 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
17805 There is at least one place where we want to know that a
17806 particular expression is a throw-expression: when checking a ?:
17807 expression, there are special rules if the second or third
17808 argument is a throw-expression. */
17809 if (TREE_CODE (expr) == THROW_EXPR)
17812 if (TREE_CODE (expr) == COND_EXPR)
17813 return build3 (COND_EXPR,
17815 TREE_OPERAND (expr, 0),
17816 (TREE_OPERAND (expr, 1)
17817 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
17818 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
17819 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
17820 if (TREE_CODE (expr) == COMPOUND_EXPR
17821 && !COMPOUND_EXPR_OVERLOADED (expr))
17822 return build2 (COMPOUND_EXPR,
17824 TREE_OPERAND (expr, 0),
17825 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
17827 /* If the type is unknown, it can't really be non-dependent */
17828 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
17830 /* Otherwise, build a NON_DEPENDENT_EXPR.
17832 REFERENCE_TYPEs are not stripped for expressions in templates
17833 because doing so would play havoc with mangling. Consider, for
17836 template <typename T> void f<T& g>() { g(); }
17838 In the body of "f", the expression for "g" will have
17839 REFERENCE_TYPE, even though the standard says that it should
17840 not. The reason is that we must preserve the syntactic form of
17841 the expression so that mangling (say) "f<g>" inside the body of
17842 "f" works out correctly. Therefore, the REFERENCE_TYPE is
17844 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
17847 /* ARGS is a vector of expressions as arguments to a function call.
17848 Replace the arguments with equivalent non-dependent expressions.
17849 This modifies ARGS in place. */
17852 make_args_non_dependent (VEC(tree,gc) *args)
17857 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
17859 tree newarg = build_non_dependent_expr (arg);
17861 VEC_replace (tree, args, ix, newarg);
17865 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
17866 with a level one deeper than the actual template parms. */
17871 tree au = cxx_make_type (TEMPLATE_TYPE_PARM);
17872 TYPE_NAME (au) = build_decl (BUILTINS_LOCATION,
17873 TYPE_DECL, get_identifier ("auto"), au);
17874 TYPE_STUB_DECL (au) = TYPE_NAME (au);
17875 TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index
17876 (0, processing_template_decl + 1, processing_template_decl + 1,
17877 TYPE_NAME (au), NULL_TREE);
17878 TYPE_CANONICAL (au) = canonical_type_parameter (au);
17879 DECL_ARTIFICIAL (TYPE_NAME (au)) = 1;
17880 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au));
17885 /* Given type ARG, return std::initializer_list<ARG>. */
17890 tree std_init_list = namespace_binding
17891 (get_identifier ("initializer_list"), std_node);
17893 if (!std_init_list || !DECL_CLASS_TEMPLATE_P (std_init_list))
17895 error ("deducing from brace-enclosed initializer list requires "
17896 "#include <initializer_list>");
17897 return error_mark_node;
17899 argvec = make_tree_vec (1);
17900 TREE_VEC_ELT (argvec, 0) = arg;
17901 return lookup_template_class (std_init_list, argvec, NULL_TREE,
17902 NULL_TREE, 0, tf_warning_or_error);
17905 /* Replace auto in TYPE with std::initializer_list<auto>. */
17908 listify_autos (tree type, tree auto_node)
17910 tree init_auto = listify (auto_node);
17911 tree argvec = make_tree_vec (1);
17912 TREE_VEC_ELT (argvec, 0) = init_auto;
17913 if (processing_template_decl)
17914 argvec = add_to_template_args (current_template_args (), argvec);
17915 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
17918 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
17919 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
17922 do_auto_deduction (tree type, tree init, tree auto_node)
17924 tree parms, tparms, targs;
17928 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
17929 with either a new invented type template parameter U or, if the
17930 initializer is a braced-init-list (8.5.4), with
17931 std::initializer_list<U>. */
17932 if (BRACE_ENCLOSED_INITIALIZER_P (init))
17933 type = listify_autos (type, auto_node);
17935 parms = build_tree_list (NULL_TREE, type);
17937 tparms = make_tree_vec (1);
17938 targs = make_tree_vec (1);
17939 TREE_VEC_ELT (tparms, 0)
17940 = build_tree_list (NULL_TREE, TYPE_NAME (auto_node));
17941 val = type_unification_real (tparms, targs, parms, args, 1, 0,
17942 DEDUCE_CALL, LOOKUP_NORMAL);
17945 error ("unable to deduce %qT from %qE", type, init);
17946 return error_mark_node;
17949 /* If the list of declarators contains more than one declarator, the type
17950 of each declared variable is determined as described above. If the
17951 type deduced for the template parameter U is not the same in each
17952 deduction, the program is ill-formed. */
17953 if (TREE_TYPE (auto_node)
17954 && !same_type_p (TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0)))
17956 error ("inconsistent deduction for %qT: %qT and then %qT",
17957 auto_node, TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0));
17958 return error_mark_node;
17960 TREE_TYPE (auto_node) = TREE_VEC_ELT (targs, 0);
17962 if (processing_template_decl)
17963 targs = add_to_template_args (current_template_args (), targs);
17964 return tsubst (type, targs, tf_warning_or_error, NULL_TREE);
17967 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
17971 splice_late_return_type (tree type, tree late_return_type)
17975 if (late_return_type == NULL_TREE)
17977 argvec = make_tree_vec (1);
17978 TREE_VEC_ELT (argvec, 0) = late_return_type;
17979 if (processing_template_decl)
17980 argvec = add_to_template_args (current_template_args (), argvec);
17981 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
17984 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
17987 is_auto (const_tree type)
17989 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
17990 && TYPE_IDENTIFIER (type) == get_identifier ("auto"))
17996 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
17997 appear as a type-specifier for the declaration in question, we don't
17998 have to look through the whole type. */
18001 type_uses_auto (tree type)
18003 enum tree_code code;
18004 if (is_auto (type))
18007 code = TREE_CODE (type);
18009 if (code == POINTER_TYPE || code == REFERENCE_TYPE
18010 || code == OFFSET_TYPE || code == FUNCTION_TYPE
18011 || code == METHOD_TYPE || code == ARRAY_TYPE)
18012 return type_uses_auto (TREE_TYPE (type));
18014 if (TYPE_PTRMEMFUNC_P (type))
18015 return type_uses_auto (TREE_TYPE (TREE_TYPE
18016 (TYPE_PTRMEMFUNC_FN_TYPE (type))));
18021 /* For a given template T, return the list of typedefs referenced
18022 in T for which access check is needed at T instantiation time.
18023 T is either a FUNCTION_DECL or a RECORD_TYPE.
18024 Those typedefs were added to T by the function
18025 append_type_to_template_for_access_check. */
18028 get_types_needing_access_check (tree t)
18030 tree ti, result = NULL_TREE;
18032 if (!t || t == error_mark_node)
18035 if (!(ti = get_template_info (t)))
18038 if (CLASS_TYPE_P (t)
18039 || TREE_CODE (t) == FUNCTION_DECL)
18041 if (!TI_TEMPLATE (ti))
18044 result = TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti);
18050 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
18051 tied to T. That list of typedefs will be access checked at
18052 T instantiation time.
18053 T is either a FUNCTION_DECL or a RECORD_TYPE.
18054 TYPE_DECL is a TYPE_DECL node representing a typedef.
18055 SCOPE is the scope through which TYPE_DECL is accessed.
18057 This function is a subroutine of
18058 append_type_to_template_for_access_check. */
18061 append_type_to_template_for_access_check_1 (tree t,
18067 if (!t || t == error_mark_node)
18070 gcc_assert ((TREE_CODE (t) == FUNCTION_DECL
18071 || CLASS_TYPE_P (t))
18073 && TREE_CODE (type_decl) == TYPE_DECL
18076 if (!(ti = get_template_info (t)))
18079 gcc_assert (TI_TEMPLATE (ti));
18081 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti) =
18082 tree_cons (type_decl, scope, TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti));
18085 /* Append TYPE_DECL to the template TEMPL.
18086 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
18087 At TEMPL instanciation time, TYPE_DECL will be checked to see
18088 if it can be accessed through SCOPE.
18090 e.g. consider the following code snippet:
18097 template<class U> struct S
18104 At S<char> instantiation time, we need to check the access of C::myint
18105 In other words, we need to check the access of the myint typedef through
18106 the C scope. For that purpose, this function will add the myint typedef
18107 and the scope C through which its being accessed to a list of typedefs
18108 tied to the template S. That list will be walked at template instantiation
18109 time and access check performed on each typedefs it contains.
18110 Note that this particular code snippet should yield an error because
18111 myint is private to C. */
18114 append_type_to_template_for_access_check (tree templ,
18120 gcc_assert (type_decl && (TREE_CODE (type_decl) == TYPE_DECL));
18122 /* Make sure we don't append the type to the template twice. */
18123 for (node = get_types_needing_access_check (templ);
18125 node = TREE_CHAIN (node))
18127 tree decl = TREE_PURPOSE (node);
18128 tree type_scope = TREE_VALUE (node);
18130 if (decl == type_decl && type_scope == scope)
18134 append_type_to_template_for_access_check_1 (templ, type_decl, scope);
18137 /* Set up the hash tables for template instantiations. */
18140 init_template_processing (void)
18142 decl_specializations = htab_create_ggc (37,
18143 hash_specialization,
18144 eq_specializations,
18146 type_specializations = htab_create_ggc (37,
18147 hash_specialization,
18148 eq_specializations,
18152 #include "gt-cp-pt.h"