| blob | 68250c2aff2f86cf6f93bc52e604d3ae90b474b1 |
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)
13 any later version.
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". */
50 /* The type of functions taking a tree, and some additional data, and
51 returning an int. */
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. */
60 };
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. */
80 /* A map from local variable declarations in the body of the template
81 presently being instantiated to the corresponding instantiated
82 local variables. */
86 {
87 tree tmpl;
88 tree args;
89 tree spec;
93 htab_t decl_specializations;
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. */
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
133 tree);
195 /* Make the current scope suitable for access checking when we are
196 processing T. T can be FUNCTION_DECL for instantiated function
197 template, or VAR_DECL for static member variable (need by
198 instantiate_decl). */
200 static void
202 {
210 else
214 {
215 saved_access_scope = tree_cons
218 }
219 }
221 /* Restore the scope set up by push_access_scope. T is the node we
222 are processing. */
224 static void
226 {
228 {
231 }
235 else
237 }
239 /* Do any processing required when DECL (a member template
240 declaration) is finished. Returns the TEMPLATE_DECL corresponding
241 to DECL, unless it is a specialization, in which case the DECL
242 itself is returned. */
244 tree
246 {
253 {
254 tree type;
262 {
266 }
268 }
272 {
274 {
277 }
278 else
280 }
281 else
285 }
287 /* Return the template info node corresponding to T, whatever T is. */
289 tree
291 {
304 }
306 /* Returns the template nesting level of the indicated class TYPE.
308 For example, in:
309 template <class T>
310 struct A
311 {
312 template <class U>
313 struct B {};
314 };
316 A<T>::B<U> has depth two, while A<T> has depth one.
317 Both A<T>::B<int> and A<int>::B<U> have depth one, if
318 they are instantiations, not specializations.
320 This function is guaranteed to return 0 if passed NULL_TREE so
321 that, for example, `template_class_depth (current_class_type)' is
322 always safe. */
324 int
326 {
333 {
339 }
342 }
344 /* Subroutine of maybe_begin_member_template_processing.
345 Returns true if processing DECL needs us to push template parms. */
347 static bool
349 {
355 }
357 /* Subroutine of maybe_begin_member_template_processing.
358 Push the template parms in PARMS, starting from LEVELS steps into the
359 chain, and ending at the beginning, since template parms are listed
360 innermost first. */
362 static void
364 {
372 current_template_parms
378 NULL);
380 {
389 {
396 {
397 /* Make a CONST_DECL as is done in process_template_parm.
398 It is ugly that we recreate this here; the original
399 version built in process_template_parm is no longer
400 available. */
410 }
415 }
416 }
417 }
419 /* Restore the template parameter context for a member template or
420 a friend template defined in a class definition. */
422 void
424 {
425 tree parms;
429 {
434 {
437 }
440 }
442 /* Remember how many levels of template parameters we pushed so that
443 we can pop them later. */
445 }
447 /* Undo the effects of maybe_begin_member_template_processing. */
449 void
451 {
460 {
464 }
465 }
467 /* Return a new template argument vector which contains all of ARGS,
468 but has as its innermost set of arguments the EXTRA_ARGS. */
470 static tree
472 {
473 tree new_args;
488 }
490 /* Like add_to_template_args, but only the outermost ARGS are added to
491 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
492 (EXTRA_ARGS) levels are added. This function is used to combine
493 the template arguments from a partial instantiation with the
494 template arguments used to attain the full instantiation from the
495 partial instantiation. */
497 static tree
499 {
500 tree new_args;
502 /* If there are more levels of EXTRA_ARGS than there are ARGS,
503 something very fishy is going on. */
506 /* If *all* the new arguments will be the EXTRA_ARGS, just return
507 them. */
511 /* For the moment, we make ARGS look like it contains fewer levels. */
516 /* Now, we restore ARGS to its full dimensions. */
520 }
522 /* Return the N levels of innermost template arguments from the ARGS. */
524 tree
526 {
527 tree new_args;
533 /* If N is 1, just return the innermost set of template arguments. */
537 /* If we're not removing anything, just return the arguments we were
538 given. */
544 /* Make a new set of arguments, not containing the outer arguments. */
551 }
553 /* The inverse of get_innermost_template_args: Return all but the innermost
554 EXTRA_LEVELS levels of template arguments from the ARGS. */
556 static tree
558 {
559 tree new_args;
565 /* If N is 1, just return the outermost set of template arguments. */
569 /* If we're not removing anything, just return the arguments we were
570 given. */
575 /* Make a new set of arguments, not containing the inner arguments. */
582 }
584 /* We've got a template header coming up; push to a new level for storing
585 the parms. */
587 void
589 {
590 /* We use a non-tag-transparent scope here, which causes pushtag to
591 put tags in this scope, rather than in the enclosing class or
592 namespace scope. This is the right thing, since we want
593 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
594 global template class, push_template_decl handles putting the
595 TEMPLATE_DECL into top-level scope. For a nested template class,
596 e.g.:
598 template <class T> struct S1 {
599 template <class T> struct S2 {};
600 };
602 pushtag contains special code to call pushdecl_with_scope on the
603 TEMPLATE_DECL for S2. */
608 }
610 /* This routine is called when a specialization is declared. If it is
611 invalid to declare a specialization here, an error is reported and
612 false is returned, otherwise this routine will return true. */
614 static bool
616 {
619 /* [temp.expl.spec]
621 An explicit specialization shall be declared in the namespace of
622 which the template is a member, or, for member templates, in the
623 namespace of which the enclosing class or enclosing class
624 template is a member. An explicit specialization of a member
625 function, member class or static data member of a class template
626 shall be declared in the namespace of which the class template
627 is a member. */
629 {
632 }
634 /* [temp.expl.spec]
636 In an explicit specialization declaration for a member of a class
637 template or a member template that appears in namespace scope,
638 the member template and some of its enclosing class templates may
639 remain unspecialized, except that the declaration shall not
640 explicitly specialize a class member template if its enclosing
641 class templates are not explicitly specialized as well. */
643 {
646 }
649 }
651 /* We've just seen template <>. */
653 bool
655 {
659 }
661 /* Called at then end of processing a declaration preceded by
662 template<>. */
664 void
666 {
669 }
671 /* Any template <>'s that we have seen thus far are not referring to a
672 function specialization. */
674 void
676 {
679 }
681 /* We've just seen a template header. If SPECIALIZATION is nonzero,
682 it was of the form template <>. */
684 static void
686 {
688 template_header_count++;
689 }
691 /* We're beginning an explicit instantiation. */
693 void
695 {
698 }
701 void
703 {
706 }
708 /* An explicit specialization or partial specialization TMPL is being
709 declared. Check that the namespace in which the specialization is
710 occurring is permissible. Returns false iff it is invalid to
711 specialize TMPL in the current namespace. */
713 static bool
715 {
718 /* [tmpl.expl.spec]
720 An explicit specialization shall be declared in the namespace of
721 which the template is a member, or, for member templates, in the
722 namespace of which the enclosing class or enclosing class
723 template is a member. An explicit specialization of a member
724 function, member class or static data member of a class template
725 shall be declared in the namespace of which the class template is
726 a member. */
728 /* Same or super-using namespace. */
730 else
731 {
735 }
736 }
738 /* SPEC is an explicit instantiation. Check that it is valid to
739 perform this explicit instantiation in the current namespace. */
741 static void
743 {
744 tree ns;
746 /* DR 275: An explicit instantiation shall appear in an enclosing
747 namespace of its template. */
753 }
755 /* The TYPE is being declared. If it is a template type, that means it
756 is a partial specialization. Do appropriate error-checking. */
758 tree
760 {
761 tree context;
767 {
771 }
776 {
777 /* This is for ordinary explicit specialization and partial
778 specialization of a template class such as:
780 template <> class C<int>;
782 or:
784 template <class T> class C<T*>;
786 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
790 {
794 {
798 }
799 }
802 }
808 {
809 /* This is for an explicit specialization of member class
810 template according to [temp.expl.spec/18]:
812 template <> template <class U> class C<int>::D;
814 The context `C<int>' must be an implicit instantiation.
815 Otherwise this is just a member class template declared
816 earlier like:
818 template <> class C<int> { template <class U> class D; };
819 template <> template <class U> class C<int>::D;
821 In the first case, `C<int>::D' is a specialization of `C<T>::D'
822 while in the second case, `C<int>::D' is a primary template
823 and `C<T>::D' may not exist. */
827 {
828 tree t;
833 {
836 }
838 /* Check for invalid specialization after instantiation:
840 template <> template <> class C<int>::D<int>;
841 template <> template <class U> class C<int>::D; */
845 {
848 {
849 /* We already have a full specialization of this partial
850 instantiation. Reassign it to the new member
851 specialization template. */
852 spec_entry elt;
868 }
870 /* But if we've had an implicit instantiation, that's a
871 problem ([temp.expl.spec]/6). */
874 }
876 /* Mark TYPE as a specialization. And as a result, we only
877 have one level of template argument for the innermost
878 class template. */
882 }
883 }
885 {
888 }
891 }
893 /* Returns nonzero if we can optimize the retrieval of specializations
894 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
895 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
899 {
902 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
903 parameter. */
905 /* The optimized lookup depends on the fact that the
906 template arguments for the member function template apply
907 purely to the containing class, which is not true if the
908 containing class is an explicit or partial
909 specialization. */
913 /* It is possible to have a template that is not a member
914 template and is not a member of a template class:
916 template <typename T>
917 struct S { friend A::f(); };
919 Here, the friend function is a template, but the context does
920 not have template information. The optimized lookup relies
921 on having ARGS be the template arguments for both the class
922 and the function template. */
924 }
926 /* Retrieve the specialization (in the sense of [temp.spec] - a
927 specialization is either an instantiation or an explicit
928 specialization) of TMPL for the given template ARGS. If there is
929 no such specialization, return NULL_TREE. The ARGS are a vector of
930 arguments, or a vector of vectors of arguments, in the case of
931 templates with more than one level of parameters.
933 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
934 then we search for a partial specialization matching ARGS. This
935 parameter is ignored if TMPL is not a class template. */
937 static tree
939 {
945 /* There should be as many levels of arguments as there are
946 levels of parameters. */
951 {
952 tree class_template;
953 tree class_specialization;
955 tree fns;
958 /* The template arguments actually apply to the containing
959 class. Find the class specialization with those
960 arguments. */
962 class_specialization
966 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
967 for the specialization. */
971 /* Iterate through the methods with the indicated name, looking
972 for the one that has an instance of TMPL. */
975 {
978 /* using-declarations can add base methods to the method vec,
979 and we don't want those here. */
982 }
984 }
985 else
986 {
988 spec_entry elt;
989 htab_t specializations;
997 else
1005 }
1008 }
1010 /* Like retrieve_specialization, but for local declarations. */
1012 static tree
1014 {
1015 tree spec;
1023 }
1025 /* Returns nonzero iff DECL is a specialization of TMPL. */
1027 int
1029 {
1030 tree t;
1033 {
1039 }
1040 else
1041 {
1050 }
1053 }
1055 /* Returns nonzero iff DECL is a specialization of friend declaration
1056 FRIEND_DECL according to [temp.friend]. */
1058 bool
1060 {
1067 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1068 of a template class, we want to check if DECL is a specialization
1069 if this. */
1073 {
1074 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1077 }
1082 /* There is nothing to do if this is not a template friend. */
1089 /* [temp.friend/6]
1090 A member of a class template may be declared to be a friend of a
1091 non-template class. In this case, the corresponding member of
1092 every specialization of the class template is a friend of the
1093 class granting friendship.
1095 For example, given a template friend declaration
1097 template <class T> friend void A<T>::f();
1099 the member function below is considered a friend
1101 template <> struct A<int> {
1102 void f();
1103 };
1105 For this type of template friend, TEMPLATE_DEPTH below will be
1106 nonzero. To determine if DECL is a friend of FRIEND, we first
1107 check if the enclosing class is a specialization of another. */
1114 {
1115 /* Next, we check the members themselves. In order to handle
1116 a few tricky cases, such as when FRIEND_DECL's are
1118 template <class T> friend void A<T>::g(T t);
1119 template <class T> template <T t> friend void A<T>::h();
1121 and DECL's are
1123 void A<int>::g(int);
1124 template <int> void A<int>::h();
1126 we need to figure out ARGS, the template arguments from
1127 the context of DECL. This is required for template substitution
1128 of `T' in the function parameter of `g' and template parameter
1129 of `h' in the above examples. Here ARGS corresponds to `int'. */
1136 {
1138 {
1141 else
1143 current_depth++;
1144 }
1146 }
1149 {
1151 tree friend_type;
1152 tree decl_type;
1153 tree friend_args_type;
1154 tree decl_args_type;
1156 /* Make sure that both DECL and FRIEND_DECL are templates or
1157 non-templates. */
1163 {
1164 /* If both are templates, check template parameter list. */
1165 tree friend_parms
1170 friend_parms))
1174 }
1175 else
1183 /* Check if return types match. */
1187 /* Check if function parameter types match, ignoring the
1188 `this' parameter. */
1197 }
1198 else
1199 {
1200 /* DECL is a TYPE_DECL */
1204 /* Make sure that both DECL and FRIEND_DECL are templates or
1205 non-templates. */
1206 is_template
1213 {
1214 tree friend_parms;
1215 /* If both are templates, check the name of the two
1216 TEMPLATE_DECL's first because is_friend didn't. */
1221 /* Now check template parameter list. */
1222 friend_parms
1225 return comp_template_parms
1227 friend_parms);
1228 }
1229 else
1232 }
1233 }
1235 }
1237 /* Register the specialization SPEC as a specialization of TMPL with
1238 the indicated ARGS. IS_FRIEND indicates whether the specialization
1239 is actually just a friend declaration. Returns SPEC, or an
1240 equivalent prior declaration, if available. */
1242 static tree
1244 hashval_t hash)
1245 {
1246 tree fn;
1248 spec_entry elt;
1254 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1255 register it; we want the corresponding TEMPLATE_DECL instead.
1256 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1257 the more obvious `uses_template_parms (spec)' to avoid problems
1258 with default function arguments. In particular, given
1259 something like this:
1261 template <class T> void f(T t1, T t = T())
1263 the default argument expression is not substituted for in an
1264 instantiation unless and until it is actually needed. */
1268 /* We don't put these specializations in the hash table, but we might
1269 want to give an error about a mismatch. */
1271 else
1272 {
1284 else
1286 }
1288 /* We can sometimes try to re-register a specialization that we've
1289 already got. In particular, regenerate_decl_from_template calls
1290 duplicate_decls which will update the specialization list. But,
1291 we'll still get called again here anyhow. It's more convenient
1292 to simply allow this than to try to prevent it. */
1296 {
1298 {
1301 {
1303 fn);
1305 }
1306 else
1307 {
1308 tree clone;
1309 /* This situation should occur only if the first
1310 specialization is an implicit instantiation, the
1311 second is an explicit specialization, and the
1312 implicit instantiation has not yet been used. That
1313 situation can occur if we have implicitly
1314 instantiated a member function and then specialized
1315 it later.
1317 We can also wind up here if a friend declaration that
1318 looked like an instantiation turns out to be a
1319 specialization:
1321 template <class T> void foo(T);
1322 class S { friend void foo<>(int) };
1323 template <> void foo(int);
1325 We transform the existing DECL in place so that any
1326 pointers to it become pointers to the updated
1327 declaration.
1329 If there was a definition for the template, but not
1330 for the specialization, we want this to look as if
1331 there were no definition, and vice versa. */
1334 /* The call to duplicate_decls will have applied
1335 [temp.expl.spec]:
1337 An explicit specialization of a function template
1338 is inline only if it is explicitly declared to be,
1339 and independently of whether its function template
1340 is.
1342 to the primary function; now copy the inline bits to
1343 the various clones. */
1350 }
1351 }
1353 {
1355 /* Dup decl failed, but this is a new definition. Set the
1356 line number so any errors match this new
1357 definition. */
1361 }
1362 }
1366 /* A specialization must be declared in the same namespace as the
1367 template it is specializing. */
1373 {
1380 /* TMPL is a forward declaration of a template function; keep a list
1381 of all specializations in case we need to reassign them to a friend
1382 template later in tsubst_friend_function. */
1385 }
1388 }
1390 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1391 TMPL and ARGS members, ignores SPEC. */
1393 static int
1395 {
1401 }
1403 /* Returns a hash for a template TMPL and template arguments ARGS. */
1405 static hashval_t
1407 {
1410 }
1412 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1413 ignoring SPEC. */
1415 static hashval_t
1417 {
1420 }
1422 /* Recursively calculate a hash value for a template argument ARG, for use
1423 in the hash tables of template specializations. */
1425 static hashval_t
1427 {
1444 {
1452 {
1457 }
1464 /* We can get one of these when re-hashing a previous entry in the middle
1465 of substituting into a pack expansion. Just look through it... */
1467 /* ...and fall through. */
1483 {
1486 {
1489 }
1491 }
1505 val = iterative_hash_template_arg
1517 val);
1519 val);
1529 {
1533 val);
1536 /* Otherwise just compare the types during lookup. */
1545 {
1550 }
1551 }
1552 }
1555 }
1557 /* Unregister the specialization SPEC as a specialization of TMPL.
1558 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1559 if the SPEC was listed as a specialization of TMPL.
1561 Note that SPEC has been ggc_freed, so we can't look inside it. */
1563 bool
1565 {
1567 spec_entry elt;
1575 {
1580 }
1583 }
1585 /* Compare an entry in the local specializations hash table P1 (which
1586 is really a pointer to a TREE_LIST) with P2 (which is really a
1587 DECL). */
1589 static int
1591 {
1593 }
1595 /* Hash P1, an entry in the local specializations table. */
1597 static hashval_t
1599 {
1601 }
1603 /* Like register_specialization, but for local declarations. We are
1604 registering SPEC, an instantiation of TMPL. */
1606 static void
1608 {
1614 }
1616 /* TYPE is a class type. Returns true if TYPE is an explicitly
1617 specialized class. */
1619 bool
1621 {
1625 }
1627 /* Print the list of candidate FNS in an error message. */
1629 void
1631 {
1632 tree fn;
1637 {
1638 tree f;
1643 }
1644 }
1646 /* Returns the template (one of the functions given by TEMPLATE_ID)
1647 which can be specialized to match the indicated DECL with the
1648 explicit template args given in TEMPLATE_ID. The DECL may be
1649 NULL_TREE if none is available. In that case, the functions in
1650 TEMPLATE_ID are non-members.
1652 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1653 specialization of a member template.
1655 The TEMPLATE_COUNT is the number of references to qualifying
1656 template classes that appeared in the name of the function. See
1657 check_explicit_specialization for a more accurate description.
1659 TSK indicates what kind of template declaration (if any) is being
1660 declared. TSK_TEMPLATE indicates that the declaration given by
1661 DECL, though a FUNCTION_DECL, has template parameters, and is
1662 therefore a template function.
1664 The template args (those explicitly specified and those deduced)
1665 are output in a newly created vector *TARGS_OUT.
1667 If it is impossible to determine the result, an error message is
1668 issued. The error_mark_node is returned to indicate failure. */
1670 static tree
1672 tree decl,
1676 tmpl_spec_kind tsk)
1677 {
1678 tree fns;
1679 tree targs;
1680 tree explicit_targs;
1682 /* A TREE_LIST of templates of which DECL may be a specialization.
1683 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1684 corresponding TREE_PURPOSE is the set of template arguments that,
1685 when used to instantiate the template, would produce a function
1686 with the signature of DECL. */
1702 /* Check for baselinks. */
1707 {
1710 }
1712 /* Count the number of template headers specified for this
1713 specialization. */
1721 {
1725 {
1726 tree decl_arg_types;
1727 tree fn_arg_types;
1729 /* In case of explicit specialization, we need to check if
1730 the number of template headers appearing in the specialization
1731 is correct. This is usually done in check_explicit_specialization,
1732 but the check done there cannot be exhaustive when specializing
1733 member functions. Consider the following code:
1735 template <> void A<int>::f(int);
1736 template <> template <> void A<int>::f(int);
1738 Assuming that A<int> is not itself an explicit specialization
1739 already, the first line specializes "f" which is a non-template
1740 member function, whilst the second line specializes "f" which
1741 is a template member function. So both lines are syntactically
1742 correct, and check_explicit_specialization does not reject
1743 them.
1745 Here, we can do better, as we are matching the specialization
1746 against the declarations. We count the number of template
1747 headers, and we check if they match TEMPLATE_COUNT + 1
1748 (TEMPLATE_COUNT is the number of qualifying template classes,
1749 plus there must be another header for the member template
1750 itself).
1752 Notice that if header_count is zero, this is not a
1753 specialization but rather a template instantiation, so there
1754 is no check we can perform here. */
1758 /* Check that the number of template arguments at the
1759 innermost level for DECL is the same as for FN. */
1767 /* DECL might be a specialization of FN. */
1771 /* For a non-static member function, we need to make sure
1772 that the const qualification is the same. Since
1773 get_bindings does not try to merge the "this" parameter,
1774 we must do the comparison explicitly. */
1780 /* Skip the "this" parameter and, for constructors of
1781 classes with virtual bases, the VTT parameter. A
1782 full specialization of a constructor will have a VTT
1783 parameter, but a template never will. */
1784 decl_arg_types
1786 fn_arg_types
1789 /* Check that the number of function parameters matches.
1790 For example,
1791 template <class T> void f(int i = 0);
1792 template <> void f<int>();
1793 The specialization f<int> is invalid but is not caught
1794 by get_bindings below. */
1798 /* Function templates cannot be specializations; there are
1799 no partial specializations of functions. Therefore, if
1800 the type of DECL does not match FN, there is no
1801 match. */
1803 {
1807 }
1809 /* See whether this function might be a specialization of this
1810 template. */
1814 /* We cannot deduce template arguments that when used to
1815 specialize TMPL will produce DECL. */
1818 /* Save this template, and the arguments deduced. */
1820 }
1822 /* FN is an ordinary member function, and we need a
1823 specialization of a member template. */
1824 ;
1826 /* We can get IDENTIFIER_NODEs here in certain erroneous
1827 cases. */
1828 ;
1830 /* This is just an ordinary non-member function. Nothing can
1831 be a specialization of that. */
1832 ;
1834 /* Cannot specialize functions that are created implicitly. */
1835 ;
1836 else
1837 {
1838 tree decl_arg_types;
1840 /* This is an ordinary member function. However, since
1841 we're here, we can assume it's enclosing class is a
1842 template class. For example,
1844 template <typename T> struct S { void f(); };
1845 template <> void S<int>::f() {}
1847 Here, S<int>::f is a non-template, but S<int> is a
1848 template class. If FN has the same type as DECL, we
1849 might be in business. */
1852 /* Its enclosing class is an explicit specialization
1853 of a template class. This is not a candidate. */
1858 /* The return types differ. */
1861 /* Adjust the type of DECL in case FN is a static member. */
1868 decl_arg_types))
1869 /* They match! */
1871 }
1872 }
1875 {
1876 /* We have:
1878 [temp.expl.spec]
1880 It is possible for a specialization with a given function
1881 signature to be instantiated from more than one function
1882 template. In such cases, explicit specification of the
1883 template arguments must be used to uniquely identify the
1884 function template specialization being specialized.
1886 Note that here, there's no suggestion that we're supposed to
1887 determine which of the candidate templates is most
1888 specialized. However, we, also have:
1890 [temp.func.order]
1892 Partial ordering of overloaded function template
1893 declarations is used in the following contexts to select
1894 the function template to which a function template
1895 specialization refers:
1897 -- when an explicit specialization refers to a function
1898 template.
1900 So, we do use the partial ordering rules, at least for now.
1901 This extension can only serve to make invalid programs valid,
1902 so it's safe. And, there is strong anecdotal evidence that
1903 the committee intended the partial ordering rules to apply;
1904 the EDG front end has that behavior, and John Spicer claims
1905 that the committee simply forgot to delete the wording in
1906 [temp.expl.spec]. */
1909 {
1912 }
1913 }
1916 {
1920 }
1924 {
1930 }
1932 /* We have one, and exactly one, match. */
1934 {
1937 /* DECL is a re-declaration or partial instantiation of a template
1938 function. */
1941 /* It was a specialization of an ordinary member function in a
1942 template class. */
1944 }
1946 /* It was a specialization of a template. */
1949 {
1954 }
1955 else
1958 }
1960 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1961 but with the default argument values filled in from those in the
1962 TMPL_TYPES. */
1964 static tree
1966 tree tmpl_types)
1967 {
1968 tree new_spec_types;
1976 /* Substitute into the rest of the list. */
1977 new_spec_types =
1981 /* Add the default argument for this parameter. */
1984 new_spec_types);
1985 }
1987 /* DECL is an explicit specialization. Replicate default arguments
1988 from the template it specializes. (That way, code like:
1990 template <class T> void f(T = 3);
1991 template <> void f(double);
1992 void g () { f (); }
1994 works, as required.) An alternative approach would be to look up
1995 the correct default arguments at the call-site, but this approach
1996 is consistent with how implicit instantiations are handled. */
1998 static void
2000 {
2001 tree tmpl;
2002 tree spec_types;
2003 tree tmpl_types;
2004 tree new_spec_types;
2005 tree old_type;
2006 tree new_type;
2007 tree t;
2012 /* See if there's anything we need to do. */
2025 {
2026 /* Remove the this pointer, but remember the object's type for
2027 CV quals. */
2033 {
2034 /* DECL may contain more parameters than TMPL due to the extra
2035 in-charge parameter in constructors and destructors. */
2038 }
2040 {
2043 }
2044 }
2046 /* Compute the merged default arguments. */
2047 new_spec_types =
2050 /* Compute the new FUNCTION_TYPE. */
2052 {
2056 new_spec_types);
2059 /* Put the in-charge parameter back. */
2062 new_spec_types);
2066 new_spec_types);
2067 }
2068 else
2070 new_spec_types);
2076 }
2078 /* Check to see if the function just declared, as indicated in
2079 DECLARATOR, and in DECL, is a specialization of a function
2080 template. We may also discover that the declaration is an explicit
2081 instantiation at this point.
2083 Returns DECL, or an equivalent declaration that should be used
2084 instead if all goes well. Issues an error message if something is
2085 amiss. Returns error_mark_node if the error is not easily
2086 recoverable.
2088 FLAGS is a bitmask consisting of the following flags:
2090 2: The function has a definition.
2091 4: The function is a friend.
2093 The TEMPLATE_COUNT is the number of references to qualifying
2094 template classes that appeared in the name of the function. For
2095 example, in
2097 template <class T> struct S { void f(); };
2098 void S<int>::f();
2100 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2101 classes are not counted in the TEMPLATE_COUNT, so that in
2103 template <class T> struct S {};
2104 template <> struct S<int> { void f(); }
2105 template <> void S<int>::f();
2107 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2108 invalid; there should be no template <>.)
2110 If the function is a specialization, it is marked as such via
2111 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2112 is set up correctly, and it is added to the list of specializations
2113 for that template. */
2115 tree
2117 tree decl,
2120 {
2128 tmpl_spec_kind tsk;
2131 {
2134 else
2136 }
2137 else
2141 {
2144 {
2147 }
2149 {
2151 /* This could be something like:
2153 template <class T> void f(T);
2154 class S { friend void f<>(int); } */
2156 else
2157 {
2158 /* This case handles bogus declarations like template <>
2159 template <class T> void f<int>(); */
2162 declarator);
2164 }
2165 }
2169 /* The error has already been reported in
2170 check_specialization_scope. */
2176 /* Fall through. */
2189 decl);
2192 else
2196 /* Fall through. */
2201 else
2207 {
2208 /* This case handles bogus declarations like template <>
2209 template <class T> void f<int>(); */
2214 else
2216 declarator);
2218 }
2221 /* This is a specialization of a member template, without
2222 specialization the containing class. Something like:
2224 template <class T> struct S {
2225 template <class U> void f (U);
2226 };
2227 template <> template <class U> void S<int>::f(U) {}
2229 That's a specialization -- but of the entire template. */
2235 }
2238 {
2242 {
2246 }
2247 }
2250 {
2254 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2256 {
2257 tree fns;
2262 else
2263 {
2264 /* If there is no class context, the explicit instantiation
2265 must be at namespace scope. */
2268 /* Find the namespace binding, using the declaration
2269 context. */
2273 {
2276 }
2277 else
2278 {
2284 }
2285 }
2288 }
2294 {
2296 /* A specialization in class scope. This is invalid,
2297 but the error will already have been flagged by
2298 check_specialization_scope. */
2300 else
2301 {
2302 /* It's not valid to write an explicit instantiation in
2303 class scope, e.g.:
2305 class C { template void f(); }
2307 This case is caught by the parser. However, on
2308 something like:
2310 template class C { void f(); };
2312 (which is invalid) we can get here. The error will be
2313 issued later. */
2314 ;
2315 }
2318 }
2321 IDENTIFIER_NODE))
2322 {
2323 /* Find the list of functions in ctype that have the same
2324 name as the declared function. */
2330 {
2335 {
2336 /* From [temp.expl.spec]:
2338 If such an explicit specialization for the member
2339 of a class template names an implicitly-declared
2340 special member function (clause _special_), the
2341 program is ill-formed.
2343 Similar language is found in [temp.explicit]. */
2346 }
2349 }
2352 {
2356 }
2357 else
2358 {
2360 tree ovl;
2362 /* For a type-conversion operator, we cannot do a
2363 name-based lookup. We might be looking for `operator
2364 int' which will be a specialization of `operator T'.
2365 So, we find *all* the conversion operators, and then
2366 select from them. */
2374 {
2376 /* There are no more conversion functions. */
2379 /* Glue all these conversion functions together
2380 with those we already have. */
2383 }
2384 }
2387 {
2390 }
2391 else
2393 }
2395 /* Figure out what exactly is being specialized at this point.
2396 Note that for an explicit instantiation, even one for a
2397 member function, we cannot tell apriori whether the
2398 instantiation is for a member template, or just a member
2399 function of a template class. Even if a member template is
2400 being instantiated, the member template arguments may be
2401 elided if they can be deduced from the rest of the
2402 declaration. */
2405 member_specialization,
2406 template_count,
2407 tsk);
2410 /* We couldn't figure out what this declaration was
2411 specializing. */
2413 else
2414 {
2418 {
2419 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2420 is done by do_decl_instantiation later. */
2426 {
2427 /* If TMPL is not the most general template (for
2428 example, if TMPL is a friend template that is
2429 injected into namespace scope), then there will
2430 be too many levels of TARGS. Remove some of them
2431 here. */
2433 tree new_targs;
2440 }
2443 }
2445 /* If we thought that the DECL was a member function, but it
2446 turns out to be specializing a static member function,
2447 make DECL a static member function as well. */
2452 /* If this is a specialization of a member template of a
2453 template class, we want to return the TEMPLATE_DECL, not
2454 the specialization of it. */
2456 {
2461 {
2462 tree parm;
2466 /* We want to use the argument list specified in the
2467 definition, not in the original declaration. */
2472 }
2475 }
2477 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2480 /* Inherit default function arguments from the template
2481 DECL is specializing. */
2484 /* This specialization has the same protection as the
2485 template it specializes. */
2489 /* 7.1.1-1 [dcl.stc]
2491 A storage-class-specifier shall not be specified in an
2492 explicit specialization...
2494 The parser rejects these, so unless action is taken here,
2495 explicit function specializations will always appear with
2496 global linkage.
2498 The action recommended by the C++ CWG in response to C++
2499 defect report 605 is to make the storage class and linkage
2500 of the explicit specialization match the templated function:
2502 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2503 */
2505 {
2509 /* This specialization has the same linkage and visibility as
2510 the function template it specializes. */
2513 {
2516 }
2519 {
2522 }
2523 }
2525 /* If DECL is a friend declaration, declared using an
2526 unqualified name, the namespace associated with DECL may
2527 have been set incorrectly. For example, in:
2529 template <typename T> void f(T);
2530 namespace N {
2531 struct S { friend void f<int>(int); }
2532 }
2534 we will have set the DECL_CONTEXT for the friend
2535 declaration to N, rather than to the global namespace. */
2540 /* This is not really a declaration of a specialization.
2541 It's just the name of an instantiation. But, it's not
2542 a request for an instantiation, either. */
2545 /* This is indeed a specialization. In case of constructors
2546 and destructors, we need in-charge and not-in-charge
2547 versions in V3 ABI. */
2550 /* Register this specialization so that we can find it
2551 again. */
2553 }
2554 }
2557 }
2559 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2560 parameters. These are represented in the same format used for
2561 DECL_TEMPLATE_PARMS. */
2563 int
2565 {
2566 const_tree p1;
2567 const_tree p2;
2575 {
2587 {
2591 /* If either of the template parameters are invalid, assume
2592 they match for the sake of error recovery. */
2605 }
2606 }
2609 /* One set of parameters has more parameters lists than the
2610 other. */
2614 }
2616 /* Determine whether PARM is a parameter pack. */
2617 bool
2619 {
2620 /* Determine if we have a non-type template parameter pack. */
2625 /* If this is a list of template parameters, we could get a
2626 TYPE_DECL or a TEMPLATE_DECL. */
2633 }
2635 /* Determine whether ARGS describes a variadic template args list,
2636 i.e., one that is terminated by a template argument pack. */
2637 static bool
2639 {
2641 tree last_parm;
2655 }
2657 /* Generate a new name for the parameter pack name NAME (an
2658 IDENTIFIER_NODE) that incorporates its */
2659 static tree
2661 {
2662 /* Munge the name to include the parameter index. */
2670 }
2672 /* Structure used to track the progress of find_parameter_packs_r. */
2673 struct find_parameter_pack_data
2674 {
2675 /* TREE_LIST that will contain all of the parameter packs found by
2676 the traversal. */
2679 /* Set of AST nodes that have been visited by the traversal. */
2681 };
2683 /* Identifies all of the argument packs that occur in a template
2684 argument and appends them to the TREE_LIST inside DATA, which is a
2685 find_parameter_pack_data structure. This is a subroutine of
2686 make_pack_expansion and uses_parameter_packs. */
2687 static tree
2689 {
2695 /* Identify whether this is a parameter pack or not. */
2697 {
2711 {
2712 /* We don't want to walk into the type of a PARM_DECL,
2713 because we don't want to see the type parameter pack. */
2716 }
2720 /* Not a parameter pack. */
2722 }
2725 {
2726 /* Add this parameter pack to the list. */
2728 }
2734 /* This switch statement will return immediately if we don't find a
2735 parameter pack. */
2737 {
2742 /* Check the template itself. */
2745 /* Check the template arguments. */
2761 /* Fall through. */
2802 }
2805 }
2807 /* Determines if the expression or type T uses any parameter packs. */
2808 bool
2810 {
2818 }
2820 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2821 representation a base-class initializer into a parameter pack
2822 expansion. If all goes well, the resulting node will be an
2823 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2824 respectively. */
2825 tree
2827 {
2828 tree result;
2837 {
2838 /* The only time we will see a TREE_LIST here is for a base
2839 class initializer. In this case, the TREE_PURPOSE will be a
2840 _TYPE node (representing the base class expansion we're
2841 initializing) and the TREE_VALUE will be a TREE_LIST
2842 containing the initialization arguments.
2844 The resulting expansion looks somewhat different from most
2845 expansions. Rather than returning just one _EXPANSION, we
2846 return a TREE_LIST whose TREE_PURPOSE is a
2847 TYPE_PACK_EXPANSION containing the bases that will be
2848 initialized. The TREE_VALUE will be identical to the
2849 original TREE_VALUE, which is a list of arguments that will
2850 be passed to each base. We do not introduce any new pack
2851 expansion nodes into the TREE_VALUE (although it is possible
2852 that some already exist), because the TREE_PURPOSE and
2853 TREE_VALUE all need to be expanded together with the same
2854 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2855 resulting TREE_PURPOSE will mention the parameter packs in
2856 both the bases and the arguments to the bases. */
2857 tree purpose;
2858 tree value;
2861 /* Determine which parameter packs will be used by the base
2862 class expansion. */
2869 {
2873 }
2876 {
2877 /* Collect the sets of parameter packs used in each of the
2878 initialization arguments. */
2880 {
2881 /* Determine which parameter packs will be expanded in this
2882 argument. */
2885 }
2886 }
2890 /* Create the pack expansion type for the base type. */
2895 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2896 they will rarely be compared to anything. */
2900 }
2905 /* Build the PACK_EXPANSION_* node. */
2909 {
2910 /* Propagate type and const-expression information. */
2913 }
2914 else
2915 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2916 they will rarely be compared to anything. */
2919 /* Determine which parameter packs will be expanded. */
2925 /* Make sure we found some parameter packs. */
2927 {
2930 else
2933 }
2937 }
2939 /* Checks T for any "bare" parameter packs, which have not yet been
2940 expanded, and issues an error if any are found. This operation can
2941 only be done on full expressions or types (e.g., an expression
2942 statement, "if" condition, etc.), because we could have expressions like:
2944 foo(f(g(h(args)))...)
2946 where "args" is a parameter pack. check_for_bare_parameter_packs
2947 should not be called for the subexpressions args, h(args),
2948 g(h(args)), or f(g(h(args))), because we would produce erroneous
2949 error messages.
2951 Returns TRUE and emits an error if there were bare parameter packs,
2952 returns FALSE otherwise. */
2953 bool
2955 {
2971 {
2974 {
2983 else
2988 else
2992 }
2995 }
2998 }
3000 /* Expand any parameter packs that occur in the template arguments in
3001 ARGS. */
3002 tree
3004 {
3009 /* First, determine if we need to expand anything, and the number of
3010 slots we'll need. */
3012 {
3015 {
3019 else
3021 }
3022 else
3023 {
3025 num_result_args++;
3026 }
3027 }
3029 /* If no expansion is necessary, we're done. */
3033 /* Expand arguments. */
3036 {
3039 {
3044 }
3045 else
3046 {
3049 }
3050 }
3053 }
3055 /* Checks if DECL shadows a template parameter.
3057 [temp.local]: A template-parameter shall not be redeclared within its
3058 scope (including nested scopes).
3060 Emits an error and returns TRUE if the DECL shadows a parameter,
3061 returns FALSE otherwise. */
3063 bool
3065 {
3066 tree olddecl;
3068 /* If we're not in a template, we can't possibly shadow a template
3069 parameter. */
3073 /* Figure out what we're shadowing. */
3078 /* If there's no previous binding for this name, we're not shadowing
3079 anything, let alone a template parameter. */
3083 /* If we're not shadowing a template parameter, we're done. Note
3084 that OLDDECL might be an OVERLOAD (or perhaps even an
3085 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3086 node. */
3090 /* We check for decl != olddecl to avoid bogus errors for using a
3091 name inside a class. We check TPFI to avoid duplicate errors for
3092 inline member templates. */
3100 }
3102 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3103 ORIG_LEVEL, DECL, and TYPE. */
3105 static tree
3109 tree decl,
3110 tree type)
3111 {
3122 }
3124 /* Find the canonical type parameter for the given template type
3125 parameter. Returns the canonical type parameter, which may be TYPE
3126 if no such parameter existed. */
3127 static tree
3129 {
3130 tree list;
3144 else
3145 {
3150 }
3151 }
3153 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3154 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3155 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3156 new one is created. */
3158 static tree
3160 tsubst_flags_t complain)
3161 {
3165 {
3184 /* Template template parameters need this. */
3189 }
3192 }
3194 /* Process information from new template parameter PARM and append it to the
3195 LIST being built. This new parameter is a non-type parameter iff
3196 IS_NON_TYPE is true. This new parameter is a parameter
3197 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3198 PARM_LOC. */
3200 tree
3203 {
3205 tree defval;
3206 tree err_parm_list;
3213 {
3217 {
3221 else
3223 }
3226 }
3227 else
3231 {
3237 {
3241 }
3242 else
3243 {
3244 /* [temp.param]
3246 The top-level cv-qualifiers on the template-parameter are
3247 ignored when determining its type. */
3250 {
3254 }
3257 {
3258 /* This template parameter is not a parameter pack, but it
3259 should be. Complain about "bare" parameter packs. */
3262 /* Recover by calling this a parameter pack. */
3264 }
3265 }
3267 /* A template parameter is not modifiable. */
3276 processing_template_decl,
3281 }
3282 else
3283 {
3284 tree t;
3288 {
3290 /* This is for distinguishing between real templates and template
3291 template parameters */
3295 }
3296 else
3297 {
3299 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3302 }
3309 processing_template_decl,
3313 }
3319 }
3321 /* The end of a template parameter list has been reached. Process the
3322 tree list into a parameter vector, converting each parameter into a more
3323 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3324 as PARM_DECLs. */
3326 tree
3328 {
3333 current_template_parms
3338 {
3342 }
3347 }
3349 /* end_template_decl is called after a template declaration is seen. */
3351 void
3353 {
3359 /* This matches the pushlevel in begin_template_parm_list. */
3364 }
3366 /* Within the declaration of a template, return all levels of template
3367 parameters that apply. The template parameters are represented as
3368 a TREE_VEC, in the form documented in cp-tree.h for template
3369 arguments. */
3371 static tree
3373 {
3374 tree header;
3379 /* If there is only one level of template parameters, we do not
3380 create a TREE_VEC of TREE_VECs. Instead, we return a single
3381 TREE_VEC containing the arguments. */
3386 {
3392 {
3395 /* T will be a list if we are called from within a
3396 begin/end_template_parm_list pair, but a vector directly
3397 if within a begin/end_member_template_processing pair. */
3399 {
3403 {
3406 {
3410 {
3411 /* Turn this argument into a TYPE_ARGUMENT_PACK
3412 with a single element, which expands T. */
3418 }
3419 }
3420 else
3421 {
3425 {
3426 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3427 with a single element, which expands T. */
3435 }
3436 }
3438 }
3439 }
3440 }
3444 else
3446 }
3449 }
3451 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3452 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3453 a member template. Used by push_template_decl below. */
3455 static tree
3457 {
3464 }
3466 struct template_parm_data
3467 {
3468 /* The level of the template parameters we are currently
3469 processing. */
3472 /* The index of the specialization argument we are currently
3473 processing. */
3476 /* An array whose size is the number of template parameters. The
3477 elements are nonzero if the parameter has been used in any one
3478 of the arguments processed so far. */
3481 /* An array whose size is the number of template arguments. The
3482 elements are nonzero if the argument makes use of template
3483 parameters of this level. */
3485 };
3487 /* Subroutine of push_template_decl used to see if each template
3488 parameter in a partial specialization is used in the explicit
3489 argument list. If T is of the LEVEL given in DATA (which is
3490 treated as a template_parm_data*), then DATA->PARMS is marked
3491 appropriately. */
3493 static int
3495 {
3501 {
3504 }
3505 else
3506 {
3509 }
3512 {
3515 }
3517 /* Return zero so that for_each_template_parm will continue the
3518 traversal of the tree; we want to mark *every* template parm. */
3520 }
3522 /* Process the partial specialization DECL. */
3524 static tree
3526 {
3532 tree inner_parms;
3545 /* We check that each of the template parameters given in the
3546 partial specialization is used in the argument list to the
3547 specialization. For example:
3549 template <class T> struct S;
3550 template <class T> struct S<T*>;
3552 The second declaration is OK because `T*' uses the template
3553 parameter T, whereas
3555 template <class T> struct S<int>;
3557 is no good. Even trickier is:
3559 template <class T>
3560 struct S1
3561 {
3562 template <class U>
3563 struct S2;
3564 template <class U>
3565 struct S2<T>;
3566 };
3568 The S2<T> declaration is actually invalid; it is a
3569 full-specialization. Of course,
3571 template <class U>
3572 struct S2<T (*)(U)>;
3574 or some such would have been OK. */
3582 {
3587 NULL,
3589 }
3592 {
3593 /* One of the template parms was not used in the
3594 specialization. */
3596 {
3599 }
3602 }
3604 /* [temp.class.spec]
3606 The argument list of the specialization shall not be identical to
3607 the implicit argument list of the primary template. */
3614 /* [temp.class.spec]
3616 A partially specialized non-type argument expression shall not
3617 involve template parameters of the partial specialization except
3618 when the argument expression is a simple identifier.
3620 The type of a template parameter corresponding to a specialized
3621 non-type argument shall not be dependent on a parameter of the
3622 specialization.
3624 Also, we verify that pack expansions only occur at the
3625 end of the argument list. */
3629 {
3636 {
3637 /* Extract the arguments from the argument pack. We'll be
3638 iterating over these in the following loop. */
3641 }
3644 {
3646 /* Get the Jth argument in the parameter pack. */
3650 {
3651 /* Pack expansions must come at the end of the
3652 argument list. */
3655 {
3658 else
3663 }
3664 }
3667 /* We only care about the pattern. */
3673 /* This next line is the `argument expression is not just a
3674 simple identifier' condition and also the `specialized
3675 non-type argument' bit. */
3677 {
3681 arg);
3682 else
3683 {
3684 /* Look at the corresponding template parameter,
3685 marking which template parameters its type depends
3686 upon. */
3690 {
3691 /* We haven't yet initialized TPD2. Do so now. */
3692 tpd2.arg_uses_template_parms
3694 /* The number of parameters here is the number in the
3695 main template, which, as checked in the assertion
3696 above, is NARGS. */
3700 }
3702 /* Mark the template parameters. But this time, we're
3703 looking for the template parameters of the main
3704 template, not in the specialization. */
3711 NULL,
3715 {
3716 /* The type depended on some template parameters.
3717 If they are fully specialized in the
3718 specialization, that's OK. */
3723 {
3726 type,
3727 arg);
3729 }
3730 }
3731 }
3732 }
3733 }
3734 }
3736 /* We should only get here once. */
3744 }
3746 /* Check that a template declaration's use of default arguments and
3747 parameter packs is not invalid. Here, PARMS are the template
3748 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3749 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3750 specialization.
3753 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3754 declaration (but not a definition); 1 indicates a declaration, 2
3755 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3756 emitted for extraneous default arguments.
3758 Returns TRUE if there were no errors found, FALSE otherwise. */
3760 bool
3763 {
3766 tree parm_level;
3769 /* [temp.param]
3771 A default template-argument shall not be specified in a
3772 function template declaration or a function template definition, nor
3773 in the template-parameter-list of the definition of a member of a
3774 class template. */
3777 /* You can't have a function template declaration in a local
3778 scope, nor you can you define a member of a class template in a
3779 local scope. */
3786 /* If this is either a friend defined in the scope of the class
3787 or a member function. */
3793 /* And, if it was a member function, it really was defined in
3794 the scope of the class. */
3797 /* We already checked these parameters when the template was
3798 declared, so there's no need to do it again now. This function
3799 was defined in class scope, but we're processing it's body now
3800 that the class is complete. */
3803 /* Core issue 226 (C++0x only): the following only applies to class
3804 templates. */
3806 {
3807 /* [temp.param]
3809 If a template-parameter has a default template-argument, all
3810 subsequent template-parameters shall have a default
3811 template-argument supplied. */
3813 {
3820 {
3830 {
3832 /* For better subsequent error-recovery, we indicate that
3833 there should have been a default argument. */
3836 }
3838 && !is_partial
3839 && !is_friend_decl
3840 /* Don't complain about an enclosing partial
3841 specialization. */
3846 {
3847 /* A primary class template can only have one
3848 parameter pack, at the end of the template
3849 parameter list. */
3854 else
3862 }
3863 }
3864 }
3865 }
3868 || is_partial
3869 || !is_primary
3871 /* For an ordinary class template, default template arguments are
3872 allowed at the innermost level, e.g.:
3873 template <class T = int>
3874 struct S {};
3875 but, in a partial specialization, they're not allowed even
3876 there, as we have in [temp.class.spec]:
3878 The template parameter list of a specialization shall not
3879 contain default template argument values.
3881 So, for a partial specialization, or for a function template
3882 (in C++98/C++03), we look at all of them. */
3883 ;
3884 else
3885 /* But, for a primary class template that is not a partial
3886 specialization we look at all template parameters except the
3887 innermost ones. */
3890 /* Figure out what error message to issue. */
3899 else
3903 /* If we're inside a class definition, there's no need to
3904 examine the parameters to the class itself. On the one
3905 hand, they will be checked when the class is defined, and,
3906 on the other, default arguments are valid in things like:
3907 template <class T = double>
3908 struct S { template <class U> void f(U); };
3909 Here the default argument for `S' has no bearing on the
3910 declaration of `f'. */
3912 else
3913 /* Check everything. */
3919 {
3926 {
3931 {
3933 {
3940 }
3942 /* Clear out the default argument so that we are not
3943 confused later. */
3945 }
3946 }
3948 /* At this point, if we're still interested in issuing messages,
3949 they must apply to classes surrounding the object declared. */
3952 }
3955 }
3957 /* Worker for push_template_decl_real, called via
3958 for_each_template_parm. DATA is really an int, indicating the
3959 level of the parameters we are interested in. If T is a template
3960 parameter of that level, return nonzero. */
3962 static int
3964 {
3970 else
3973 }
3975 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3976 parameters given by current_template_args, or reuses a
3977 previously existing one, if appropriate. Returns the DECL, or an
3978 equivalent one, if it is replaced via a call to duplicate_decls.
3980 If IS_FRIEND is true, DECL is a friend declaration. */
3982 tree
3984 {
3985 tree tmpl;
3986 tree args;
3987 tree info;
3988 tree ctx;
3992 /* True if the template is a member template, in the sense of
3993 [temp.mem]. */
3999 /* See if this is a partial specialization. */
4008 /* For a friend, we want the context of the friend function, not
4009 the type of which it is a friend. */
4013 /* In the case of a virtual function, we want the class in which
4014 it is defined. */
4016 else
4017 /* Otherwise, if we're currently defining some class, the DECL
4018 is assumed to be a member of the class. */
4027 /* See if this is a primary template. */
4029 /* A friend template that specifies a class context, i.e.
4030 template <typename T> friend void A<T>::f();
4031 is not primary. */
4033 else
4037 {
4042 {
4045 }
4047 {
4049 {
4050 /* [temp.mem]
4052 A destructor shall not be a member template. */
4055 }
4062 {
4063 /* [basic.stc.dynamic.allocation]
4065 An allocation function can be a function
4066 template. ... Template allocation functions shall
4067 have two or more parameters. */
4070 }
4071 }
4075 else
4076 {
4079 }
4080 }
4082 /* Check to see that the rules regarding the use of default
4083 arguments are not being violated. */
4087 /* Ensure that there are no parameter packs in the type of this
4088 declaration that have not been expanded. */
4090 {
4091 /* Check each of the arguments individually to see if there are
4092 any bare parameter packs. */
4098 {
4101 {
4102 /* This is a PARM_DECL that contains unexpanded parameter
4103 packs. We have already complained about this in the
4104 check_for_bare_parameter_packs call, so just replace
4105 these types with ERROR_MARK_NODE. */
4108 }
4112 }
4114 /* Check for bare parameter packs in the return type and the
4115 exception specifiers. */
4117 /* Errors were already issued, set return type to int
4118 as the frontend doesn't expect error_mark_node as
4119 the return type. */
4123 }
4125 {
4128 }
4139 {
4144 /* If DECL is a TYPE_DECL for a class-template, then there won't
4145 be DECL_LANG_SPECIFIC. The information equivalent to
4146 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4150 {
4151 /* Since a template declaration already existed for this
4152 class-type, we must be redeclaring it here. Make sure
4153 that the redeclaration is valid. */
4155 current_template_parms);
4156 /* We don't need to create a new TEMPLATE_DECL; just use the
4157 one we already had. */
4159 }
4160 else
4161 {
4163 member_template_p);
4168 {
4169 /* A specialization of a member template of a template
4170 class. */
4174 }
4175 }
4176 }
4177 else
4178 {
4184 {
4187 }
4195 {
4196 tree new_tmpl;
4198 /* The declaration is a specialization of a member
4199 template, declared outside the class. Therefore, the
4200 innermost template arguments will be NULL, so we
4201 replace them with the arguments determined by the
4202 earlier call to check_explicit_specialization. */
4205 new_tmpl
4207 member_template_p);
4217 args,
4220 }
4222 /* Make sure the template headers we got make sense. */
4227 {
4230 }
4231 else
4233 {
4238 {
4242 else
4247 }
4251 else
4255 }
4257 /* Check that the parms are used in the appropriate qualifying scopes
4258 in the declarator. */
4262 {
4268 /* Avoid crash in import_export_decl. */
4271 }
4272 }
4277 /* Push template declarations for global functions and types. Note
4278 that we do not try to push a global template friend declared in a
4279 template class; such a thing may well depend on the template
4280 parameters of the class. */
4283 {
4288 /* Hide template friend classes that haven't been declared yet. */
4290 {
4293 }
4294 }
4297 {
4303 {
4306 /* It is a conversion operator. See if the type converted to
4307 depends on innermost template operands. */
4310 depth))
4312 }
4314 /* Give template template parms a DECL_CONTEXT of the template
4315 for which they are a parameter. */
4318 {
4322 }
4323 }
4325 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4326 back to its most general template. If TMPL is a specialization,
4327 ARGS may only have the innermost set of arguments. Add the missing
4328 argument levels if necessary. */
4340 }
4342 tree
4344 {
4346 }
4348 /* Called when a class template TYPE is redeclared with the indicated
4349 template PARMS, e.g.:
4351 template <class T> struct S;
4352 template <class T> struct S {}; */
4354 bool
4356 {
4357 tree tmpl;
4358 tree tmpl_parms;
4362 {
4365 }
4369 /* The type is nested in some template class. Nothing to worry
4370 about here; there are no new template parameters for the nested
4371 type. */
4375 {
4377 tmpl);
4379 }
4385 {
4391 }
4394 {
4395 tree tmpl_parm;
4396 tree parm;
4397 tree tmpl_default;
4398 tree parm_default;
4409 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4410 TEMPLATE_DECL. */
4421 {
4425 }
4428 {
4429 /* We have in [temp.param]:
4431 A template-parameter may not be given default arguments
4432 by two different declarations in the same scope. */
4437 }
4440 /* Update the previous template parameters (which are the ones
4441 that will really count) with the new default value. */
4444 /* Update the new parameters, too; they'll be used as the
4445 parameters for any members. */
4447 }
4450 }
4452 /* Simplify EXPR if it is a non-dependent expression. Returns the
4453 (possibly simplified) expression. */
4455 tree
4457 {
4461 /* If we're in a template, but EXPR isn't value dependent, simplify
4462 it. We're supposed to treat:
4464 template <typename T> void f(T[1 + 1]);
4465 template <typename T> void f(T[2]);
4467 as two declarations of the same function, for example. */
4471 {
4472 HOST_WIDE_INT saved_processing_template_decl;
4478 tf_error,
4483 }
4485 }
4487 /* EXPR is an expression which is used in a constant-expression context.
4488 For instance, it could be a VAR_DECL with a constant initializer.
4489 Extract the innermost constant expression.
4491 This is basically a more powerful version of
4492 integral_constant_value, which can be used also in templates where
4493 initializers can maintain a syntactic rather than semantic form
4494 (even if they are non-dependent, for access-checking purposes). */
4496 static tree
4498 {
4500 do
4501 {
4504 }
4508 }
4510 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4511 must be a function or a pointer-to-function type, as specified
4512 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4513 and check that the resulting function has external linkage. */
4515 static tree
4517 {
4531 /* [temp.arg.nontype]/1
4533 A template-argument for a non-type, non-template template-parameter
4534 shall be one of:
4535 [...]
4536 -- the address of an object or function with external linkage. */
4538 {
4543 }
4546 }
4548 /* Attempt to convert the non-type template parameter EXPR to the
4549 indicated TYPE. If the conversion is successful, return the
4550 converted value. If the conversion is unsuccessful, return
4551 NULL_TREE if we issued an error message, or error_mark_node if we
4552 did not. We issue error messages for out-and-out bad template
4553 parameters, but not simply because the conversion failed, since we
4554 might be just trying to do argument deduction. Both TYPE and EXPR
4555 must be non-dependent.
4557 The conversion follows the special rules described in
4558 [temp.arg.nontype], and it is much more strict than an implicit
4559 conversion.
4561 This function is called twice for each template argument (see
4562 lookup_template_class for a more accurate description of this
4563 problem). This means that we need to handle expressions which
4564 are not valid in a C++ source, but can be created from the
4565 first call (for instance, casts to perform conversions). These
4566 hacks can go away after we fix the double coercion problem. */
4568 static tree
4570 {
4571 tree expr_type;
4573 /* Detect immediately string literals as invalid non-type argument.
4574 This special-case is not needed for correctness (we would easily
4575 catch this later), but only to provide better diagnostic for this
4576 common user mistake. As suggested by DR 100, we do not mention
4577 linkage issues in the diagnostic as this is not the point. */
4579 {
4584 }
4586 /* If we are in a template, EXPR may be non-dependent, but still
4587 have a syntactic, rather than semantic, form. For example, EXPR
4588 might be a SCOPE_REF, rather than the VAR_DECL to which the
4589 SCOPE_REF refers. Preserving the qualifying scope is necessary
4590 so that access checking can be performed when the template is
4591 instantiated -- but here we need the resolved form so that we can
4592 convert the argument. */
4598 /* HACK: Due to double coercion, we can get a
4599 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4600 which is the tree that we built on the first call (see
4601 below when coercing to reference to object or to reference to
4602 function). We just strip everything and get to the arg.
4603 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4604 for examples. */
4606 {
4608 {
4609 /* ??? Maybe we could use convert_from_reference here, but we
4610 would need to relax its constraints because the NOP_EXPR
4611 could actually change the type to something more cv-qualified,
4612 and this is not folded by convert_from_reference. */
4623 }
4625 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4626 parameter is a pointer to object, through decay and
4627 qualification conversion. Let's strip everything. */
4629 {
4633 /* Skip the ADDR_EXPR only if it is part of the decay for
4634 an array. Otherwise, it is part of the original argument
4635 in the source code. */
4639 }
4640 }
4642 /* [temp.arg.nontype]/5, bullet 1
4644 For a non-type template-parameter of integral or enumeration type,
4645 integral promotions (_conv.prom_) and integral conversions
4646 (_conv.integral_) are applied. */
4648 {
4653 /* Notice that there are constant expressions like '4 % 0' which
4654 do not fold into integer constants. */
4656 {
4660 }
4662 /* At this point, an implicit conversion does what we want,
4663 because we already know that the expression is of integral
4664 type. */
4669 /* Conversion was allowed: fold it to a bare integer constant. */
4671 }
4672 /* [temp.arg.nontype]/5, bullet 2
4674 For a non-type template-parameter of type pointer to object,
4675 qualification conversions (_conv.qual_) and the array-to-pointer
4676 conversion (_conv.array_) are applied. */
4678 {
4679 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4681 A template-argument for a non-type, non-template template-parameter
4682 shall be one of: [...]
4684 -- the name of a non-type template-parameter;
4685 -- the address of an object or function with external linkage, [...]
4686 expressed as "& id-expression" where the & is optional if the name
4687 refers to a function or array, or if the corresponding
4688 template-parameter is a reference.
4690 Here, we do not care about functions, as they are invalid anyway
4691 for a parameter of type pointer-to-object. */
4694 /* Non-type template parameters are OK. */
4695 ;
4698 {
4700 {
4702 "because %qD is a variable, not the address of "
4706 }
4707 /* Other values, like integer constants, might be valid
4708 non-type arguments of some other type. */
4710 }
4711 else
4712 {
4713 tree decl;
4718 {
4723 }
4725 {
4730 }
4731 }
4740 }
4741 /* [temp.arg.nontype]/5, bullet 3
4743 For a non-type template-parameter of type reference to object, no
4744 conversions apply. The type referred to by the reference may be more
4745 cv-qualified than the (otherwise identical) type of the
4746 template-argument. The template-parameter is bound directly to the
4747 template-argument, which must be an lvalue. */
4749 {
4751 expr_type))
4755 {
4759 }
4762 {
4766 }
4768 /* [temp.arg.nontype]/1
4770 A template-argument for a non-type, non-template template-parameter
4771 shall be one of: [...]
4773 -- the address of an object or function with external linkage. */
4775 {
4780 }
4783 }
4784 /* [temp.arg.nontype]/5, bullet 4
4786 For a non-type template-parameter of type pointer to function, only
4787 the function-to-pointer conversion (_conv.func_) is applied. If the
4788 template-argument represents a set of overloaded functions (or a
4789 pointer to such), the matching function is selected from the set
4790 (_over.over_). */
4792 {
4793 /* If the argument is a template-id, we might not have enough
4794 context information to decay the pointer. */
4796 {
4800 }
4807 {
4811 }
4812 }
4813 /* [temp.arg.nontype]/5, bullet 5
4815 For a non-type template-parameter of type reference to function, no
4816 conversions apply. If the template-argument represents a set of
4817 overloaded functions, the matching function is selected from the set
4818 (_over.over_). */
4820 {
4822 {
4827 }
4834 }
4835 /* [temp.arg.nontype]/5, bullet 6
4837 For a non-type template-parameter of type pointer to member function,
4838 no conversions apply. If the template-argument represents a set of
4839 overloaded member functions, the matching member function is selected
4840 from the set (_over.over_). */
4842 {
4847 /* There is no way to disable standard conversions in
4848 resolve_address_of_overloaded_function (called by
4849 instantiate_type). It is possible that the call succeeded by
4850 converting &B::I to &D::I (where B is a base of D), so we need
4851 to reject this conversion here.
4853 Actually, even if there was a way to disable standard conversions,
4854 it would still be better to reject them here so that we can
4855 provide a superior diagnostic. */
4857 {
4858 /* Make sure we are just one standard conversion off. */
4865 }
4866 }
4867 /* [temp.arg.nontype]/5, bullet 7
4869 For a non-type template-parameter of type pointer to data member,
4870 qualification conversions (_conv.qual_) are applied. */
4872 {
4876 }
4877 /* A template non-type parameter must be one of the above. */
4878 else
4881 /* Sanity check: did we actually convert the argument to the
4882 right type? */
4885 }
4887 /* Subroutine of coerce_template_template_parms, which returns 1 if
4888 PARM_PARM and ARG_PARM match using the rule for the template
4889 parameters of template template parameters. Both PARM and ARG are
4890 template parameters; the rest of the arguments are the same as for
4891 coerce_template_template_parms.
4892 */
4893 static int
4895 tree arg,
4896 tsubst_flags_t complain,
4897 tree in_decl,
4898 tree outer_args)
4899 {
4908 {
4910 /* We encounter instantiations of templates like
4911 template <template <template <class> class> class TT>
4912 class C; */
4913 {
4920 }
4921 /* Fall through. */
4926 /* Argument is a parameter pack but parameter is not. */
4931 /* The tsubst call is used to handle cases such as
4933 template <int> class C {};
4934 template <class T, template <T> class TT> class D {};
4935 D<int, C> d;
4937 i.e. the parameter list of TT depends on earlier parameters. */
4939 && !same_type_p
4946 /* Argument is a parameter pack but parameter is not. */
4953 }
4956 }
4959 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4960 template template parameters. Both PARM_PARMS and ARG_PARMS are
4961 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4962 or PARM_DECL.
4964 Consider the example:
4965 template <class T> class A;
4966 template<template <class U> class TT> class B;
4968 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4969 the parameters to A, and OUTER_ARGS contains A. */
4971 static int
4973 tree arg_parms,
4974 tsubst_flags_t complain,
4975 tree in_decl,
4976 tree outer_args)
4977 {
4988 /* Determine whether we have a parameter pack at the end of the
4989 template template parameter's template parameter list. */
4991 {
4998 {
5012 }
5013 }
5019 /* Check all of the template parameters except the parameter pack at
5020 the end (if any). */
5022 {
5031 outer_args))
5034 }
5037 {
5038 /* Check each of the template parameters in the template
5039 argument against the template parameter pack at the end of
5040 the template template parameter. */
5047 {
5054 outer_args))
5056 }
5057 }
5060 }
5062 /* Verifies that the deduced template arguments (in TARGS) for the
5063 template template parameters (in TPARMS) represent valid bindings,
5064 by comparing the template parameter list of each template argument
5065 to the template parameter list of its corresponding template
5066 template parameter, in accordance with DR150. This
5067 routine can only be called after all template arguments have been
5068 deduced. It will return TRUE if all of the template template
5069 parameter bindings are okay, FALSE otherwise. */
5070 bool
5072 {
5076 /* We're dealing with template parms in this process. */
5082 {
5087 {
5092 {
5093 /* Look inside the argument pack. */
5096 }
5099 {
5103 /* Extract the next argument from the argument
5104 pack. */
5108 /* Look at the pattern of the pack expansion. */
5111 /* Extract the template parameters from the template
5112 argument. */
5118 /* Verify that we can coerce the template template
5119 parameters from the template argument to the template
5120 parameter. This requires an exact match. */
5122 && !coerce_template_template_parms
5124 targ_parms,
5125 tf_none,
5126 tparm,
5127 targs))
5128 {
5131 }
5132 }
5133 }
5134 }
5136 out:
5140 }
5142 /* Convert the indicated template ARG as necessary to match the
5143 indicated template PARM. Returns the converted ARG, or
5144 error_mark_node if the conversion was unsuccessful. Error and
5145 warning messages are issued under control of COMPLAIN. This
5146 conversion is for the Ith parameter in the parameter list. ARGS is
5147 the full set of template arguments deduced so far. */
5149 static tree
5151 tree arg,
5152 tree args,
5153 tsubst_flags_t complain,
5155 tree in_decl)
5156 {
5157 tree orig_arg;
5158 tree val;
5163 {
5164 /* The template argument was the name of some
5165 member function. That's usually
5166 invalid, but static members are OK. In any
5167 case, grab the underlying fields/functions
5168 and issue an error later if required. */
5171 }
5179 /* When determining whether an argument pack expansion is a template,
5180 look at the pattern. */
5184 is_tmpl_type =
5199 {
5205 typename_type,
5209 }
5211 {
5213 {
5215 {
5225 else
5227 }
5228 }
5230 }
5232 {
5234 {
5240 else
5242 }
5244 }
5247 {
5249 {
5251 /* The number of argument required is not known yet.
5252 Just accept it for now. */
5254 else
5255 {
5257 tree argparm;
5263 args))
5264 {
5267 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5268 TEMPLATE_DECL. */
5270 {
5275 {
5278 }
5279 }
5280 }
5281 else
5282 {
5284 {
5290 }
5293 }
5294 }
5295 }
5296 else
5298 /* We only form one instance of each template specialization.
5299 Therefore, if we use a non-canonical variant (i.e., a
5300 typedef), any future messages referring to the type will use
5301 the typedef, which is confusing if those future uses do not
5302 themselves also use the typedef. */
5305 }
5306 else
5307 {
5314 {
5317 else
5318 {
5319 /* Not sure if this is reachable, but it doesn't hurt
5320 to be robust. */
5323 }
5324 }
5326 /* We used to call digest_init here. However, digest_init
5327 will report errors, which we don't want when complain
5328 is zero. More importantly, digest_init will try too
5329 hard to convert things: for example, `0' should not be
5330 converted to pointer type at this point according to
5331 the standard. Accepting this is not merely an
5332 extension, since deciding whether or not these
5333 conversions can occur is part of determining which
5334 function template to call, or whether a given explicit
5335 argument specification is valid. */
5337 else
5344 }
5347 }
5349 /* Coerces the remaining template arguments in INNER_ARGS (from
5350 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5351 Returns the coerced argument pack. PARM_IDX is the position of this
5352 parameter in the template parameter list. ARGS is the original
5353 template argument list. */
5354 static tree
5357 tree args,
5358 tree inner_args,
5360 tree new_args,
5362 tree in_decl,
5363 tsubst_flags_t complain)
5364 {
5367 tree packed_args;
5368 tree argument_pack;
5378 {
5379 /* When the template parameter is a non-type template
5380 parameter pack whose type uses parameter packs, we need
5381 to look at each of the template arguments
5382 separately. Build a vector of the types for these
5383 non-type template parameters in PACKED_TYPES. */
5384 tree expansion
5392 /* Check that we have the right number of arguments. */
5396 {
5397 int needed_parms
5402 }
5404 /* If we aren't able to check the actual arguments now
5405 (because they haven't been expanded yet), we can at least
5406 verify that all of the types used for the non-type
5407 template parameter pack are, in fact, valid for non-type
5408 template parameters. */
5411 {
5414 {
5418 }
5419 }
5420 }
5422 /* Convert the remaining arguments, which will be a part of the
5423 parameter pack "parm". */
5425 {
5430 {
5431 /* When we have a vector of types (corresponding to the
5432 non-type template parameter pack that uses parameter
5433 packs in its type, as mention above), and the
5434 argument is not an expansion (which expands to a
5435 currently unknown number of arguments), clone the
5436 parm and give it the next type in PACKED_TYPES. */
5440 }
5445 in_decl);
5449 }
5454 else
5455 {
5460 }
5464 }
5466 /* Convert all template arguments to their appropriate types, and
5467 return a vector containing the innermost resulting template
5468 arguments. If any error occurs, return error_mark_node. Error and
5469 warning messages are issued under control of COMPLAIN.
5471 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5472 for arguments not specified in ARGS. Otherwise, if
5473 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5474 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5475 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5476 ARGS. */
5478 static tree
5480 tree args,
5481 tree in_decl,
5482 tsubst_flags_t complain,
5485 {
5487 tree inner_args;
5488 tree new_args;
5489 tree new_inner_args;
5493 /* When used as a boolean value, indicates whether this is a
5494 variadic template parameter list. Since it's an int, we can also
5495 subtract it from nparms to get the number of non-variadic
5496 parameters. */
5501 /* Determine if there are any parameter packs. */
5503 {
5507 }
5510 /* If there are 0 or 1 parameter packs, we need to expand any argument
5511 packs so that we can deduce a parameter pack from some non-packed args
5512 followed by an argument pack, as in variadic85.C. If there are more
5513 than that, we need to leave argument packs intact so the arguments are
5514 assigned to the right parameter packs. This should only happen when
5515 dealing with a nested class inside a partial specialization of a class
5516 template, as in variadic92.C. */
5523 && require_all_args
5524 && (!use_default_args
5527 {
5529 {
5532 {
5535 }
5542 }
5545 }
5547 /* We need to evaluate the template arguments, even though this
5548 template-id may be nested within a "sizeof". */
5556 {
5557 tree arg;
5558 tree parm;
5560 /* Get the Ith template parameter. */
5564 {
5567 }
5569 /* Calculate the next argument. */
5572 else
5577 {
5578 /* All remaining arguments will be placed in the
5579 template parameter pack PARM. */
5585 /* Store this argument. */
5587 lost++;
5590 /* We are done with all of the arguments. */
5594 }
5596 {
5598 {
5600 {
5601 /* FIXME this restriction was removed by N2555; see
5602 bug 35722. */
5603 /* If ARG is a pack expansion, but PARM is not a
5604 template parameter pack (if it were, we would have
5605 handled it above), we're trying to expand into a
5606 fixed-length argument list. */
5610 else
5613 }
5615 }
5616 }
5618 /* There must be a default arg in this case. */
5621 else
5625 {
5628 }
5630 /* This only occurs if there was an error in the template
5631 parameter list itself (which we would already have
5632 reported) that we are trying to recover from, e.g., a class
5633 template with a parameter list such as
5634 template<typename..., typename>. */
5636 else
5642 lost++;
5644 }
5652 }
5654 /* Returns 1 if template args OT and NT are equivalent. */
5656 static int
5658 {
5663 /* For member templates */
5670 {
5687 }
5692 else
5694 }
5696 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5697 of template arguments. Returns 0 otherwise. */
5699 int
5701 {
5708 {
5714 }
5716 }
5718 static void
5720 {
5730 /* We are called both from instantiate_decl, where we've already had a
5731 tinst_level pushed, and instantiate_template, where we haven't.
5732 Compensate. */
5743 else
5752 }
5755 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5756 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5757 documentation for TEMPLATE_ID_EXPR. */
5759 tree
5761 {
5762 tree type;
5772 {
5774 unknown_type_node,
5776 arglist);
5778 }
5785 }
5787 /* Within the scope of a template class S<T>, the name S gets bound
5788 (in build_self_reference) to a TYPE_DECL for the class, not a
5789 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5790 or one of its enclosing classes, and that type is a template,
5791 return the associated TEMPLATE_DECL. Otherwise, the original
5792 DECL is returned. */
5794 tree
5796 {
5803 }
5805 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5806 parameters, find the desired type.
5808 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5810 IN_DECL, if non-NULL, is the template declaration we are trying to
5811 instantiate.
5813 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5814 the class we are looking up.
5816 Issue error and warning messages under control of COMPLAIN.
5818 If the template class is really a local class in a template
5819 function, then the FUNCTION_CONTEXT is the function in which it is
5820 being instantiated.
5822 ??? Note that this function is currently called *twice* for each
5823 template-id: the first time from the parser, while creating the
5824 incomplete type (finish_template_type), and the second type during the
5825 real instantiation (instantiate_template_class). This is surely something
5826 that we want to avoid. It also causes some problems with argument
5827 coercion (see convert_nontype_argument for more information on this). */
5829 tree
5831 tree arglist,
5832 tree in_decl,
5833 tree context,
5835 tsubst_flags_t complain)
5836 {
5838 tree t;
5841 spec_entry elt;
5842 hashval_t hash;
5847 {
5851 else
5852 {
5859 }
5862 }
5864 {
5867 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5868 an implicit typename for the second A. Deal with it. */
5873 {
5876 }
5877 }
5880 {
5883 }
5887 {
5891 }
5893 /* Issue an error message if we didn't find a template. */
5895 {
5899 }
5902 /* Make sure it's a user visible template, if it was named by
5903 the user. */
5906 {
5908 {
5912 }
5914 }
5919 {
5920 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5921 template arguments */
5923 tree parm;
5924 tree arglist2;
5925 tree outer;
5929 /* Consider an example where a template template parameter declared as
5931 template <class T, class U = std::allocator<T> > class TT
5933 The template parameter level of T and U are one level larger than
5934 of TT. To proper process the default argument of U, say when an
5935 instantiation `TT<int>' is seen, we need to build the full
5936 arguments containing {int} as the innermost level. Outer levels,
5937 available when not appearing as default template argument, can be
5938 obtained from the arguments of the enclosing template.
5940 Suppose that TT is later substituted with std::vector. The above
5941 instantiation is `TT<int, std::allocator<T> >' with TT at
5942 level 1, and T at level 2, while the template arguments at level 1
5943 becomes {std::vector} and the inner level 2 is {int}. */
5949 /* This is an argument of the current template, so we haven't set
5950 DECL_CONTEXT yet. */
5957 complain,
5967 }
5968 else
5969 {
5971 tree gen_tmpl;
5972 tree type_decl;
5984 {
5985 /* We've been given an incomplete set of template arguments.
5986 For example, given:
5988 template <class T> struct S1 {
5989 template <class U> struct S2 {};
5990 template <class U> struct S2<U*> {};
5991 };
5993 we will be called with an ARGLIST of `U*', but the
5994 TEMPLATE will be `template <class T> template
5995 <class U> struct S1<T>::S2'. We must fill in the missing
5996 arguments. */
5997 arglist
5999 arglist);
6001 }
6003 /* Now we should have enough arguments. */
6006 /* From here on, we're only interested in the most general
6007 template. */
6009 /* Calculate the BOUND_ARGS. These will be the args that are
6010 actually tsubst'd into the definition to create the
6011 instantiation. */
6013 {
6014 /* We have multiple levels of arguments to coerce, at once. */
6024 {
6027 complain,
6031 /* Don't process further if one of the levels fails. */
6033 {
6034 /* Restore the ARGLIST to its full size. */
6037 }
6041 /* We temporarily reduce the length of the ARGLIST so
6042 that coerce_template_parms will see only the arguments
6043 corresponding to the template parameters it is
6044 examining. */
6046 }
6048 /* Restore the ARGLIST to its full size. */
6052 }
6053 else
6054 arglist
6057 gen_tmpl,
6058 complain,
6063 /* We were unable to bind the arguments. */
6066 /* In the scope of a template class, explicit references to the
6067 template class refer to the type of the template, not any
6068 instantiation of it. For example, in:
6070 template <class T> class C { void f(C<T>); }
6072 the `C<T>' is just the same as `C'. Outside of the
6073 class, however, such a reference is an instantiation. */
6077 /* comp_template_args is expensive, check it last. */
6079 arglist))
6082 /* If we already have this specialization, return it. */
6092 /* This type is a "partial instantiation" if any of the template
6093 arguments still involve template parameters. Note that we set
6094 IS_PARTIAL_INSTANTIATION for partial specializations as
6095 well. */
6098 /* If the deduced arguments are invalid, then the binding
6099 failed. */
6103 complain))
6109 {
6114 }
6121 /* Create the type. */
6123 {
6125 {
6131 }
6132 else
6133 {
6134 /* We don't want to call start_enum for this type, since
6135 the values for the enumeration constants may involve
6136 template parameters. And, no one should be interested
6137 in the enumeration constants for such a type. */
6140 }
6141 }
6142 else
6143 {
6150 /* A local class. Make sure the decl gets registered properly. */
6155 /* This instantiation is another name for the primary
6156 template type. Set the TYPE_CANONICAL field
6157 appropriately. */
6160 /* Some of the template arguments require structural
6161 equality testing, so this template class requires
6162 structural equality testing. */
6164 }
6166 /* If we called start_enum or pushtag above, this information
6167 will already be set up. */
6169 {
6177 }
6178 else
6186 {
6189 }
6191 /* Set up the template information. We have to figure out which
6192 template is the immediate parent if this is a full
6193 instantiation. */
6196 /* This case is easy; there are no member templates involved. */
6198 else
6199 {
6200 /* This is a full instantiation of a member template. Find
6201 the partial instantiation of which this is an instance. */
6203 /* Temporarily reduce by one the number of levels in the ARGLIST
6204 so as to avoid comparing the last set of arguments. */
6209 }
6219 /* Note this use of the partial instantiation so we can check it
6220 later in maybe_process_partial_specialization. */
6227 /* Now that the type has been registered on the instantiations
6228 list, we set up the enumerators. Because the enumeration
6229 constants may involve the enumeration type itself, we make
6230 sure to register the type first, and then create the
6231 constants. That way, doing tsubst_expr for the enumeration
6232 constants won't result in recursive calls here; we'll find
6233 the instantiation and exit above. */
6237 /* If the type makes use of template parameters, the
6238 code that generates debugging information will crash. */
6241 /* Possibly limit visibility based on template args. */
6246 }
6248 }
6249 \f
6250 struct pair_fn_data
6251 {
6252 tree_fn_t fn;
6254 /* True when we should also visit template parameters that occur in
6255 non-deduced contexts. */
6258 };
6260 /* Called from for_each_template_parm via walk_tree. */
6262 static tree
6264 {
6277 {
6281 /* Fall through. */
6304 /* Since we're not going to walk subtrees, we have to do this
6305 explicitly here. */
6309 /* Fall through. */
6312 /* Check the return type. */
6317 /* Check the parameter types. Since default arguments are not
6318 instantiated until they are needed, the TYPE_ARG_TYPES may
6319 contain expressions that involve template parameters. But,
6320 no-one should be looking at them yet. And, once they're
6321 instantiated, they don't contain template parameters, so
6322 there's no point in looking at them then, either. */
6323 {
6324 tree parm;
6331 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6332 want walk_tree walking into them itself. */
6334 }
6351 /* Fall through. */
6367 /* Record template parameters such as `T' inside `TT<T>'. */
6371 /* Fall through. */
6383 /* A template template parameter is encountered. */
6389 /* Already substituted template template parameter */
6412 /* If there's no type, then this thing must be some expression
6413 involving template parameters. */
6434 }
6436 /* We didn't find any template parameters we liked. */
6438 }
6440 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6441 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6442 call FN with the parameter and the DATA.
6443 If FN returns nonzero, the iteration is terminated, and
6444 for_each_template_parm returns 1. Otherwise, the iteration
6445 continues. If FN never returns a nonzero value, the value
6446 returned by for_each_template_parm is 0. If FN is NULL, it is
6447 considered to be the function which always returns 1.
6449 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6450 parameters that occur in non-deduced contexts. When false, only
6451 visits those template parameters that can be deduced. */
6453 static int
6457 {
6461 /* Set up. */
6466 /* Walk the tree. (Conceptually, we would like to walk without
6467 duplicates, but for_each_template_parm_r recursively calls
6468 for_each_template_parm, so we would need to reorganize a fair
6469 bit to use walk_tree_without_duplicates, so we keep our own
6470 visited list.) */
6473 else
6476 for_each_template_parm_r,
6480 /* Clean up. */
6482 {
6485 }
6488 }
6490 /* Returns true if T depends on any template parameter. */
6492 int
6494 {
6521 else
6522 {
6525 }
6530 }
6532 /* Returns true if T depends on any template parameter with level LEVEL. */
6534 int
6536 {
6539 }
6543 #ifdef GATHER_STATISTICS
6545 #endif
6549 /* We're starting to instantiate D; record the template instantiation context
6550 for diagnostics and to restore it later. */
6552 static int
6554 {
6558 {
6559 /* If the instantiation in question still has unbound template parms,
6560 we don't really care if we can't instantiate it, so just return.
6561 This happens with base instantiation for implicit `typename'. */
6573 }
6583 #ifdef GATHER_STATISTICS
6586 #endif
6590 }
6592 /* We're done instantiating this template; return to the instantiation
6593 context. */
6595 static void
6597 {
6598 /* Restore the filename and line number stashed away when we started
6599 this instantiation. */
6604 }
6606 /* We're instantiating a deferred template; restore the template
6607 instantiation context in which the instantiation was requested, which
6608 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6610 static tree
6612 {
6622 }
6624 /* Returns the TINST_LEVEL which gives the original instantiation
6625 context. */
6629 {
6635 }
6637 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
6639 bool
6641 {
6642 tree parms;
6659 }
6661 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6662 vector of template arguments, as for tsubst.
6664 Returns an appropriate tsubst'd friend declaration. */
6666 static tree
6668 {
6669 tree new_friend;
6674 /* This was a friend declared with an explicit template
6675 argument list, e.g.:
6677 friend void f<>(T);
6679 to indicate that f was a template instantiation, not a new
6680 function declaration. Now, we have to figure out what
6681 instantiation of what template. */
6682 {
6684 tree new_args;
6685 tree tmpl;
6688 /* Friend functions are looked up in the containing namespace scope.
6689 We must enter that scope, to avoid finding member functions of the
6690 current class with same name. */
6705 tsk_none);
6707 }
6711 /* The NEW_FRIEND will look like an instantiation, to the
6712 compiler, but is not an instantiation from the point of view of
6713 the language. For example, we might have had:
6715 template <class T> struct S {
6716 template <class U> friend void f(T, U);
6717 };
6719 Then, in S<int>, template <class U> void f(int, U) is not an
6720 instantiation of anything. */
6726 {
6730 }
6732 /* The mangled name for the NEW_FRIEND is incorrect. The function
6733 is not a template instantiation and should not be mangled like
6734 one. Therefore, we forget the mangling here; we'll recompute it
6735 later if we need it. */
6737 {
6740 }
6743 {
6744 tree old_decl;
6745 tree new_friend_template_info;
6746 tree new_friend_result_template_info;
6747 tree ns;
6750 /* We must save some information from NEW_FRIEND before calling
6751 duplicate decls since that function will free NEW_FRIEND if
6752 possible. */
6754 new_friend_is_defn =
6759 {
6760 /* This declaration is a `primary' template. */
6763 new_friend_result_template_info
6765 }
6766 else
6769 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6773 /* Inside pushdecl_namespace_level, we will push into the
6774 current namespace. However, the friend function should go
6775 into the namespace of the template. */
6785 {
6786 /* This new friend declaration matched an existing
6787 declaration. For example, given:
6789 template <class T> void f(T);
6790 template <class U> class C {
6791 template <class T> friend void f(T) {}
6792 };
6794 the friend declaration actually provides the definition
6795 of `f', once C has been instantiated for some type. So,
6796 old_decl will be the out-of-class template declaration,
6797 while new_friend is the in-class definition.
6799 But, if `f' was called before this point, the
6800 instantiation of `f' will have DECL_TI_ARGS corresponding
6801 to `T' but not to `U', references to which might appear
6802 in the definition of `f'. Previously, the most general
6803 template for an instantiation of `f' was the out-of-class
6804 version; now it is the in-class version. Therefore, we
6805 run through all specialization of `f', adding to their
6806 DECL_TI_ARGS appropriately. In particular, they need a
6807 new set of outer arguments, corresponding to the
6808 arguments for this class instantiation.
6810 The same situation can arise with something like this:
6812 friend void f(int);
6813 template <class T> class C {
6814 friend void f(T) {}
6815 };
6817 when `C<int>' is instantiated. Now, `f(int)' is defined
6818 in the class. */
6821 /* On the other hand, if the in-class declaration does
6822 *not* provide a definition, then we don't want to alter
6823 existing definitions. We can just leave everything
6824 alone. */
6825 ;
6826 else
6827 {
6831 /* Overwrite whatever template info was there before, if
6832 any, with the new template information pertaining to
6833 the declaration. */
6837 /* We should have called reregister_specialization in
6838 duplicate_decls. */
6842 else
6843 {
6844 tree t;
6846 /* Indicate that the old function template is a partial
6847 instantiation. */
6855 /* Reassign any specializations already in the hash table
6856 to the new more general template, and add the
6857 additional template args. */
6861 {
6863 spec_entry elt;
6875 register_specialization
6878 }
6880 }
6881 }
6883 /* The information from NEW_FRIEND has been merged into OLD_DECL
6884 by duplicate_decls. */
6886 }
6887 }
6888 else
6889 {
6893 /* In the code
6894 template <class T> class C {
6895 template <class U> friend void C1<U>::f (); // case 1
6896 friend void C2<T>::f (); // case 2
6897 };
6898 we only need to make sure CONTEXT is a complete type for
6899 case 2. To distinguish between the two cases, we note that
6900 CONTEXT of case 1 remains dependent type after tsubst while
6901 this isn't true for case 2. */
6911 {
6912 /* Check to see that the declaration is really present, and,
6913 possibly obtain an improved declaration. */
6919 }
6920 }
6923 }
6925 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6926 template arguments, as for tsubst.
6928 Returns an appropriate tsubst'd friend type or error_mark_node on
6929 failure. */
6931 static tree
6933 {
6934 tree friend_type;
6935 tree tmpl;
6936 tree context;
6941 {
6944 else
6946 }
6948 /* Look for a class template declaration. We look for hidden names
6949 because two friend declarations of the same template are the
6950 same. For example, in:
6952 struct A {
6953 template <typename> friend class F;
6954 };
6955 template <typename> struct B {
6956 template <typename> friend class F;
6957 };
6959 both F templates are the same. */
6964 /* But, if we don't find one, it might be because we're in a
6965 situation like this:
6967 template <class T>
6968 struct S {
6969 template <class U>
6970 friend struct S;
6971 };
6973 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6974 for `S<int>', not the TEMPLATE_DECL. */
6976 {
6979 }
6982 {
6983 /* The friend template has already been declared. Just
6984 check to see that the declarations match, and install any new
6985 default parameters. We must tsubst the default parameters,
6986 of course. We only need the innermost template parameters
6987 because that is all that redeclare_class_template will look
6988 at. */
6991 {
6992 tree parms;
6993 location_t saved_input_location;
7002 }
7005 }
7006 else
7007 {
7008 /* The friend template has not already been declared. In this
7009 case, the instantiation of the template class will cause the
7010 injection of this template into the global scope. */
7015 /* The new TMPL is not an instantiation of anything, so we
7016 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7017 the new type because that is supposed to be the corresponding
7018 template decl, i.e., TMPL. */
7025 /* Inject this template into the global scope. */
7027 }
7030 {
7033 else
7035 }
7038 }
7040 /* Returns zero if TYPE cannot be completed later due to circularity.
7041 Otherwise returns one. */
7043 static int
7045 {
7055 else
7057 }
7059 /* Apply any attributes which had to be deferred until instantiation
7060 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7061 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7063 static void
7066 {
7068 tree t;
7073 {
7077 }
7080 {
7084 }
7085 else
7089 {
7094 {
7097 {
7100 /* If the first attribute argument is an identifier, don't
7101 pass it through tsubst. Attributes like mode, format,
7102 cleanup and several target specific attributes expect it
7103 unmodified. */
7109 {
7110 tree chain
7112 in_decl,
7117 chain);
7118 }
7119 else
7125 }
7126 else
7128 }
7131 }
7132 }
7134 /* Perform (or defer) access check for typedefs that were referenced
7135 from within the template TMPL code.
7136 This is a subroutine of instantiate_template and instantiate_class_template.
7137 TMPL is the template to consider and TARGS is the list of arguments of
7138 that template. */
7140 static void
7142 {
7143 tree t;
7151 {
7165 }
7166 }
7168 tree
7170 {
7172 tree typedecl;
7173 tree pbinfo;
7174 tree base_list;
7184 /* Figure out which template is being instantiated. */
7188 /* Determine what specialization of the original template to
7189 instantiate. */
7192 {
7195 }
7197 {
7198 /* This TYPE is actually an instantiation of a partial
7199 specialization. We replace the innermost set of ARGS with
7200 the arguments appropriate for substitution. For example,
7201 given:
7203 template <class T> struct S {};
7204 template <class T> struct S<T*> {};
7206 and supposing that we are instantiating S<int*>, ARGS will
7207 presently be {int*} -- but we need {int}. */
7210 }
7211 else
7212 {
7215 }
7217 /* If the template we're instantiating is incomplete, then clearly
7218 there's nothing we can do. */
7222 /* If we've recursively instantiated too many templates, stop. */
7226 /* Now we're really doing the instantiation. Mark the type as in
7227 the process of being defined. */
7230 /* We may be in the middle of deferred access check. Disable
7231 it now. */
7238 /* Set the input location to the most specialized template definition.
7239 This is needed if tsubsting causes an error. */
7260 {
7263 }
7267 /* We should never instantiate a nested class before its enclosing
7268 class; we need to look up the nested class by name before we can
7269 instantiate it, and that lookup should instantiate the enclosing
7270 class. */
7277 {
7278 tree pbase_binfo;
7280 tree pushed_scope;
7283 /* We must enter the scope containing the type, as that is where
7284 the accessibility of types named in dependent bases are
7285 looked up from. */
7288 /* Substitute into each of the bases to determine the actual
7289 basetypes. */
7291 {
7292 tree base;
7298 {
7299 expanded_bases =
7306 }
7309 {
7311 /* Extract the already-expanded base class. */
7313 else
7314 /* Substitute to figure out the base class. */
7316 NULL_TREE);
7324 }
7325 }
7327 /* The list is now in reverse order; correct that. */
7332 }
7333 /* Now call xref_basetypes to set up all the base-class
7334 information. */
7341 /* Now that our base classes are set up, enter the scope of the
7342 class, so that name lookups into base classes, etc. will work
7343 correctly. This is precisely analogous to what we do in
7344 begin_class_definition when defining an ordinary non-template
7345 class, except we also need to push the enclosing classes. */
7348 /* Now members are processed in the order of declaration. */
7351 {
7355 {
7357 {
7358 /* Build new CLASSTYPE_NESTED_UTDS. */
7360 tree newtag;
7366 /* If the member is a class template, then -- even after
7367 substitution -- there may be dependent types in the
7368 template argument list for the class. We increment
7369 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7370 that function will assume that no types are dependent
7371 when outside of a template. */
7381 {
7385 /* Unfortunately, lookup_template_class sets
7386 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7387 instantiation (i.e., for the type of a member
7388 template class nested within a template class.)
7389 This behavior is required for
7390 maybe_process_partial_specialization to work
7391 correctly, but is not accurate in this case;
7392 the TAG is not an instantiation of anything.
7393 (The corresponding TEMPLATE_DECL is an
7394 instantiation, but the TYPE is not.) */
7397 /* Now, we call pushtag to put this NEWTAG into the scope of
7398 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7399 pushtag calling push_template_decl. We don't have to do
7400 this for enums because it will already have been done in
7401 tsubst_enum. */
7405 }
7406 }
7409 {
7410 /* Build new TYPE_METHODS. */
7411 tree r;
7420 }
7421 else
7422 {
7423 /* Build new TYPE_FIELDS. */
7425 {
7426 tree condition =
7434 }
7436 {
7437 tree r;
7439 /* The file and line for this declaration, to
7440 assist in error message reporting. Since we
7441 called push_tinst_level above, we don't need to
7442 restore these. */
7451 {
7452 /* In [temp.inst]:
7454 [t]he initialization (and any associated
7455 side-effects) of a static data member does
7456 not occur unless the static data member is
7457 itself used in a way that requires the
7458 definition of the static data member to
7459 exist.
7461 Therefore, we do not substitute into the
7462 initialized for the static data member here. */
7463 finish_static_data_member_decl
7471 }
7473 {
7474 /* Determine whether R has a valid type and can be
7475 completed later. If R is invalid, then it is
7476 replaced by error_mark_node so that it will not be
7477 added to TYPE_FIELDS. */
7483 {
7486 }
7487 }
7489 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7490 such a thing will already have been added to the field
7491 list by tsubst_enum in finish_member_declaration in the
7492 CLASSTYPE_NESTED_UTDS case above. */
7496 {
7499 }
7500 }
7501 }
7502 }
7503 else
7504 {
7506 {
7507 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7513 {
7514 /* template <class T> friend class C; */
7517 }
7519 {
7520 /* template <class T> friend class C::D; */
7526 }
7528 {
7529 /* This could be either
7531 friend class T::C;
7533 when dependent_type_p is false or
7535 template <class U> friend class T::C;
7537 otherwise. */
7540 /* Bump processing_template_decl for correct
7541 dependent_type_p calculation. */
7546 }
7549 {
7550 /* friend class C;
7552 where C hasn't been declared yet. Let's lookup name
7553 from namespace scope directly, bypassing any name that
7554 come from dependent base class. */
7557 /* The call to xref_tag_from_type does injection for friend
7558 classes. */
7560 friend_type =
7564 }
7566 /* friend class C<T>; */
7569 /* Otherwise it's
7571 friend class C;
7573 where C is already declared or
7575 friend class C<int>;
7577 We don't have to do anything in these cases. */
7580 /* Trick make_friend_class into realizing that the friend
7581 we're adding is a template, not an ordinary class. It's
7582 important that we use make_friend_class since it will
7583 perform some error-checking and output cross-reference
7584 information. */
7592 }
7593 else
7594 {
7595 /* Build new DECL_FRIENDLIST. */
7596 tree r;
7598 /* The file and line for this declaration, to
7599 assist in error message reporting. Since we
7600 called push_tinst_level above, we don't need to
7601 restore these. */
7605 {
7608 }
7613 {
7616 }
7617 }
7618 }
7619 }
7621 /* Set the file and line number information to whatever is given for
7622 the class itself. This puts error messages involving generated
7623 implicit functions at a predictable point, and the same point
7624 that would be used for non-template classes. */
7631 /* Now that the class is complete, instantiate default arguments for
7632 any member functions. We don't do this earlier because the
7633 default arguments may reference members of the class. */
7637 /* Implicitly generated member functions will not have template
7638 information; they are not instantiations, but instead are
7639 created "fresh" for each instantiation. */
7643 /* Some typedefs referenced from within the template code need to be access
7644 checked at template instantiation time, i.e now. These types were
7645 added to the template at parsing time. Let's get those and perform
7646 the access checks then. */
7654 /* The vtable for a template class can be emitted in any translation
7655 unit in which the class is instantiated. When there is no key
7656 method, however, finish_struct_1 will already have added TYPE to
7657 the keyed_classes list. */
7662 }
7664 static tree
7666 {
7667 tree r;
7673 else
7674 {
7678 }
7680 }
7682 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
7683 NONTYPE_ARGUMENT_PACK. */
7685 static tree
7687 {
7688 /* Collect all of the extra "packed" parameters into an
7689 argument pack. */
7690 tree parmvec;
7691 tree parmtypevec;
7696 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
7700 {
7703 }
7705 /* Build the argument packs. */
7711 }
7713 /* Substitute ARGS into T, which is an pack expansion
7714 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7715 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7716 (if only a partial substitution could be performed) or
7717 ERROR_MARK_NODE if there was an error. */
7718 tree
7720 tree in_decl)
7721 {
7722 tree pattern;
7725 tree result;
7732 /* Determine the argument packs that will instantiate the parameter
7733 packs used in the expansion expression. While we're at it,
7734 compute the number of arguments to be expanded and make sure it
7735 is consistent. */
7738 {
7744 {
7747 {
7748 /* This can happen for a parameter name used later in a function
7749 declaration (such as in a late-specified return type). Just
7750 make a dummy decl, since it's only used for its type. */
7754 }
7755 }
7756 else
7757 {
7764 }
7771 /* This can only happen if we forget to expand an argument
7772 pack somewhere else. Just return an error, silently. */
7773 {
7777 }
7782 {
7787 /* The argument pack that the parameter maps to is just an
7788 expansion of the parameter itself, such as one would
7789 find in the implicit typedef of a class inside the
7790 class itself. Consider this parameter "unsubstituted",
7791 so that we will maintain the outer pack expansion. */
7793 }
7796 {
7800 /* It's all-or-nothing with incomplete argument packs. */
7808 {
7811 }
7813 {
7817 pattern);
7818 else
7821 pattern);
7823 }
7825 /* Keep track of the parameter packs and their corresponding
7826 argument packs. */
7829 }
7830 else
7831 /* We can't substitute for this parameter pack. */
7834 unsubstituted_packs);
7835 }
7837 /* We cannot expand this expansion expression, because we don't have
7838 all of the argument packs we need. Substitute into the pattern
7839 and return a PACK_EXPANSION_*. The caller will need to deal with
7840 that. */
7842 {
7843 tree new_pat;
7847 else
7850 }
7852 /* We could not find any argument packs that work. */
7857 {
7858 /* We're in a late-specified return type, so we don't have a local
7859 specializations table. Create one for doing this expansion. */
7862 hash_local_specialization,
7863 eq_local_specializations,
7864 NULL);
7865 }
7867 /* For each argument in each argument pack, substitute into the
7868 pattern. */
7871 {
7872 /* For parameter pack, change the substitution of the parameter
7873 pack to the ith argument in its argument pack, then expand
7874 the pattern. */
7876 {
7880 {
7881 /* Select the Ith argument from the pack. */
7887 }
7888 else
7889 {
7895 {
7896 /* Select the Ith argument from the pack. */
7900 }
7902 /* Update the corresponding argument. */
7904 }
7905 }
7907 /* Substitute into the PATTERN with the altered arguments. */
7912 else
7916 /* When we have incomplete argument packs, the last "expanded"
7917 result is itself a pack expansion, which allows us
7918 to deduce more arguments. */
7923 {
7926 }
7927 }
7929 /* Update ARGS to restore the substitution from parameter packs to
7930 their argument packs. */
7932 {
7937 else
7938 {
7942 /* Update the corresponding argument. */
7946 else
7948 }
7949 }
7952 {
7955 }
7958 }
7960 /* Substitute ARGS into the vector or list of template arguments T. */
7962 static tree
7964 {
7971 {
7973 tree new_arg;
7978 {
7979 /* Substitute into an expansion expression. */
7983 /* Add to the expanded length adjustment the number of
7984 expanded arguments. We subtract one from this
7985 measurement, because the argument pack expression
7986 itself is already counted as 1 in
7987 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7988 the argument pack is empty. */
7990 }
7992 {
7993 /* Substitute into each of the arguments. */
7997 new_arg,
8011 }
8012 }
8013 else
8022 }
8027 /* Make space for the expanded arguments coming from template
8028 argument packs. */
8031 {
8035 {
8038 /* Now expand the template argument pack "in place". */
8041 }
8042 else
8043 {
8045 out++;
8046 }
8047 }
8050 }
8052 /* Return the result of substituting ARGS into the template parameters
8053 given by PARMS. If there are m levels of ARGS and m + n levels of
8054 PARMS, then the result will contain n levels of PARMS. For
8055 example, if PARMS is `template <class T> template <class U>
8056 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8057 result will be `template <int*, double, class V>'. */
8059 static tree
8061 {
8065 /* When substituting into a template, we must set
8066 PROCESSING_TEMPLATE_DECL as the template parameters may be
8067 dependent if they are based on one-another, and the dependency
8068 predicates are short-circuit outside of templates. */
8075 {
8076 tree new_vec =
8081 {
8082 tree tuple;
8083 tree default_value;
8084 tree parm_decl;
8106 }
8112 }
8117 }
8119 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8120 type T. If T is not an aggregate or enumeration type, it is
8121 handled as if by tsubst. IN_DECL is as for tsubst. If
8122 ENTERING_SCOPE is nonzero, T is the context for a template which
8123 we are presently tsubst'ing. Return the substituted value. */
8125 static tree
8127 tree args,
8128 tsubst_flags_t complain,
8129 tree in_decl,
8131 {
8136 {
8141 /* Else fall through. */
8145 {
8146 tree argvec;
8147 tree context;
8148 tree r;
8152 /* In "sizeof(X<I>)" we need to evaluate "I". */
8158 /* First, determine the context for the type we are looking
8159 up. */
8162 {
8165 /* If context is a nested class inside a class template,
8166 it may still need to be instantiated (c++/33959). */
8169 }
8171 /* Then, figure out what arguments are appropriate for the
8172 type we are trying to find. For example, given:
8174 template <class T> struct S;
8175 template <class T, class U> void f(T, U) { S<U> su; }
8177 and supposing that we are instantiating f<int, double>,
8178 then our ARGS will be {int, double}, but, when looking up
8179 S we only want {double}. */
8184 else
8185 {
8189 }
8195 }
8196 else
8197 /* This is not a template type, so there's nothing to do. */
8202 }
8203 }
8205 /* Substitute into the default argument ARG (a default argument for
8206 FN), which has the indicated TYPE. */
8208 tree
8210 {
8214 /* This default argument came from a template. Instantiate the
8215 default argument here, not in tsubst. In the case of
8216 something like:
8218 template <class T>
8219 struct S {
8220 static T t();
8221 void f(T = t());
8222 };
8224 we must be careful to do name lookup in the scope of S<T>,
8225 rather than in the current class. */
8227 /* The "this" pointer is not valid in a default argument. */
8229 {
8234 }
8237 /* The default argument expression may cause implicitly defined
8238 member functions to be synthesized, which will result in garbage
8239 collection. We must treat this situation as if we were within
8240 the body of function so as to avoid collecting live data on the
8241 stack. */
8249 /* Restore the "this" pointer. */
8251 {
8254 }
8258 /* Make sure the default argument is reasonable. */
8262 }
8264 /* Substitute into all the default arguments for FN. */
8266 static void
8268 {
8269 tree arg;
8270 tree tmpl_args;
8274 /* If this function is not yet instantiated, we certainly don't need
8275 its default arguments. */
8280 arg;
8286 }
8288 /* Substitute the ARGS into the T, which is a _DECL. Return the
8289 result of the substitution. Issue error and warning messages under
8290 control of COMPLAIN. */
8292 static tree
8294 {
8295 location_t saved_loc;
8300 /* Set the filename and linenumber to improve error-reporting. */
8305 {
8307 {
8308 /* We can get here when processing a member function template,
8309 member class template, or template template parameter. */
8311 tree spec;
8312 tree tmpl_args;
8313 tree full_args;
8316 {
8317 /* Template template parameter is treated here. */
8330 complain);
8333 }
8335 /* We might already have an instance of this template.
8336 The ARGS are for the surrounding class type, so the
8337 full args contain the tsubst'd args for the context,
8338 plus the innermost args from the template decl. */
8342 /* Because this is a template, the arguments will still be
8343 dependent, even after substitution. If
8344 PROCESSING_TEMPLATE_DECL is not set, the dependency
8345 predicates will short-circuit. */
8353 /* If this is a default template template argument,
8354 tsubst might not have changed anything. */
8361 {
8364 }
8366 /* Make a new template decl. It will be similar to the
8367 original, but will record the current template arguments.
8368 We also create a new function declaration, which is just
8369 like the old one, but points to this new template, rather
8370 than the old one. */
8378 {
8379 tree new_type;
8391 }
8392 else
8393 {
8394 tree new_decl;
8406 }
8412 /* The template parameters for this new template are all the
8413 template parameters for the old template, except the
8414 outermost level of parameters. */
8417 complain);
8423 /* Record this non-type partial instantiation. */
8427 }
8431 {
8432 tree ctx;
8435 tree gen_tmpl;
8436 tree type;
8441 /* Nobody should be tsubst'ing into non-template functions. */
8445 {
8446 tree spec;
8449 /* If T is not dependent, just return it. We have to
8450 increment PROCESSING_TEMPLATE_DECL because
8451 value_dependent_expression_p assumes that nothing is
8452 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8459 /* Calculate the most general template of which R is a
8460 specialization, and the complete set of arguments used to
8461 specialize R. */
8467 /* Check to see if we already have this specialization. */
8472 {
8475 }
8477 /* We can see more levels of arguments than parameters if
8478 there was a specialization of a member template, like
8479 this:
8481 template <class T> struct S { template <class U> void f(); }
8482 template <> template <class U> void S<int>::f(U);
8484 Here, we'll be substituting into the specialization,
8485 because that's where we can find the code we actually
8486 want to generate, but we'll have enough arguments for
8487 the most general template.
8489 We also deal with the peculiar case:
8491 template <class T> struct S {
8492 template <class U> friend void f();
8493 };
8494 template <class U> void f() {}
8495 template S<int>;
8496 template void f<double>();
8498 Here, the ARGS for the instantiation of will be {int,
8499 double}. But, we only need as many ARGS as there are
8500 levels of template parameters in CODE_PATTERN. We are
8501 careful not to get fooled into reducing the ARGS in
8502 situations like:
8504 template <class T> struct S { template <class U> void f(U); }
8505 template <class T> template <> void S<T>::f(int) {}
8507 which we can spot because the pattern will be a
8508 specialization in this case. */
8510 parms_depth =
8515 }
8516 else
8517 {
8518 /* This special case arises when we have something like this:
8520 template <class T> struct S {
8521 friend void f<int>(int, double);
8522 };
8524 Here, the DECL_TI_TEMPLATE for the friend declaration
8525 will be an IDENTIFIER_NODE. We are being called from
8526 tsubst_friend_function, and we want only to create a
8527 new decl (R) with appropriate types so that we can call
8528 determine_specialization. */
8530 }
8533 {
8536 else
8540 }
8541 else
8542 {
8545 }
8550 /* We do NOT check for matching decls pushed separately at this
8551 point, as they may not represent instantiations of this
8552 template, and in any case are considered separate under the
8553 discrete model. */
8557 /* Clear out the mangled name and RTL for the instantiation. */
8560 /* Leave DECL_INITIAL set on deleted instantiations. */
8566 /* Type-conversion operator. Reconstruct the name, in
8567 case it's the name of one of the template's parameters. */
8577 /* If this is an instantiation of a function with internal
8578 linkage, we already know what object file linkage will be
8579 assigned to the instantiation. */
8588 /* We'll re-clone as appropriate in instantiate_template. */
8591 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8592 this in the special friend case mentioned above where
8593 GEN_TMPL is NULL. */
8595 {
8601 /* We're not supposed to instantiate default arguments
8602 until they are called, for a template. But, for a
8603 declaration like:
8605 template <class T> void f ()
8606 { extern void g(int i = T()); }
8608 we should do the substitution when the template is
8609 instantiated. We handle the member function case in
8610 instantiate_class_template since the default arguments
8611 might refer to other members of the class. */
8616 }
8617 else
8620 /* Copy the list of befriending classes. */
8624 {
8628 in_decl);
8629 }
8632 {
8636 /* If this is an instantiation of a member template, clone it.
8637 If it isn't, that'll be handled by
8638 clone_constructors_and_destructors. */
8641 }
8651 /* Possibly limit visibility based on template args. */
8654 {
8658 }
8663 }
8667 {
8675 {
8676 /* If there is a local specialization that isn't a
8677 parameter pack, it means that we're doing a "simple"
8678 substitution from inside tsubst_pack_expansion. Just
8679 return the local specialization (which will be a single
8680 parm). */
8687 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8688 the parameters in this function parameter pack. */
8692 {
8695 /* Zero-length parameter packs are boring. Just substitute
8696 into the chain. */
8700 }
8701 else
8702 {
8703 /* All we did was update the type. Make a note of that. */
8706 }
8707 }
8709 /* Loop through all of the parameter's we'll build. When T is
8710 a function parameter pack, LEN is the number of expanded
8711 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8714 {
8721 /* We're on the Ith parameter of the function parameter
8722 pack. */
8723 {
8724 /* Get the Ith type. */
8728 /* Rename the parameter to include the index. */
8731 }
8733 /* We're dealing with a normal parameter. */
8741 {
8744 else
8747 }
8757 /* Keep track of the first new parameter we
8758 generate. That's what will be returned to the
8759 caller. */
8763 /* Build a proper chain of parameters when substituting
8764 into a function parameter pack. */
8767 }
8773 /* FIRST_R contains the start of the chain we've built. */
8775 }
8779 {
8780 tree type;
8789 /* DECL_INITIAL gives the number of bits in a bit-field. */
8794 /* We don't have to set DECL_CONTEXT here; it is set by
8795 finish_member_declaration. */
8802 }
8806 /* We reach here only for member using decls. */
8808 {
8809 r = do_class_using_decl
8814 else
8815 {
8818 }
8819 }
8820 else
8821 {
8824 }
8829 {
8832 tree spec;
8834 tree ctx;
8840 {
8841 /* If this is the canonical decl, we don't have to
8842 mess with instantiations, and often we can't (for
8843 typename, template type parms and such). Note that
8844 TYPE_NAME is not correct for the above test if
8845 we've copied the type for a typedef. */
8851 }
8853 /* Check to see if we already have the specialization we
8854 need. */
8857 {
8858 /* T is a static data member or namespace-scope entity.
8859 We have to substitute into namespace-scope variables
8860 (even though such entities are never templates) because
8861 of cases like:
8863 template <class T> void f() { extern T t; }
8865 where the entity referenced is not known until
8866 instantiation time. */
8870 {
8872 complain,
8874 /* If CTX is unchanged, then T is in fact the
8875 specialization we want. That situation occurs when
8876 referencing a static data member within in its own
8877 class. We can use pointer equality, rather than
8878 same_type_p, because DECL_CONTEXT is always
8879 canonical. */
8882 }
8885 {
8891 }
8892 }
8893 else
8894 {
8895 /* A local variable. */
8897 /* Subsequent calls to pushdecl will fill this in. */
8900 }
8901 /* If we already have the specialization we need, there is
8902 nothing more to do. */
8904 {
8907 }
8909 /* Create a new node for the specialization we need. */
8914 {
8915 /* Even if the original location is out of scope, the
8916 newly substituted one is not. */
8923 {
8924 /* It may seem that this case cannot occur, since:
8926 typedef void f();
8927 void g() { f x; }
8929 declares a function, not a variable. However:
8931 typedef void f();
8932 template <typename T> void g() { T t; }
8933 template void g<f>();
8935 is an attempt to declare a variable with function
8936 type. */
8938 /* R is not yet sufficiently initialized, so we
8939 just use its name. */
8942 }
8949 {
8954 }
8955 }
8961 /* Clear out the mangled name and RTL for the instantiation. */
8965 /* The initializer must not be expanded until it is required;
8966 see [temp.inst]. */
8972 {
8973 /* Possibly limit visibility based on template args. */
8976 {
8980 }
8982 }
8983 /* Preserve a typedef that names a type. */
8987 {
8992 }
8995 {
8996 /* A static data member declaration is always marked
8997 external when it is declared in-class, even if an
8998 initializer is present. We mimic the non-template
8999 processing here. */
9005 }
9006 else
9015 }
9020 }
9022 /* Restore the file and line information. */
9026 }
9028 /* Substitute into the ARG_TYPES of a function type. */
9030 static tree
9032 tree args,
9033 tsubst_flags_t complain,
9034 tree in_decl)
9035 {
9036 tree remaining_arg_types;
9040 tree default_arg;
9051 {
9052 /* For a pack expansion, perform substitution on the
9053 entire expression. Later on, we'll handle the arguments
9054 one-by-one. */
9059 /* So that we'll spin through the parameters, one by one. */
9061 else
9062 {
9063 /* We only partially substituted into the parameter
9064 pack. Our type is TYPE_PACK_EXPANSION. */
9067 }
9068 }
9081 {
9083 {
9087 }
9089 }
9091 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9092 top-level qualifiers as required. */
9095 /* We do not substitute into default arguments here. The standard
9096 mandates that they be instantiated only when needed, which is
9097 done in build_over_call. */
9101 {
9102 /* We've instantiated a template before its default arguments
9103 have been parsed. This can happen for a nested template
9104 class, and is not an error unless we require the default
9105 argument in a call of this function. */
9106 remaining_arg_types =
9109 remaining_arg_types);
9110 }
9111 else
9112 remaining_arg_types =
9114 }
9117 }
9119 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9120 *not* handle the exception-specification for FNTYPE, because the
9121 initial substitution of explicitly provided template parameters
9122 during argument deduction forbids substitution into the
9123 exception-specification:
9125 [temp.deduct]
9127 All references in the function type of the function template to the
9128 corresponding template parameters are replaced by the specified tem-
9129 plate argument values. If a substitution in a template parameter or
9130 in the function type of the function template results in an invalid
9131 type, type deduction fails. [Note: The equivalent substitution in
9132 exception specifications is done only when the function is instanti-
9133 ated, at which point a program is ill-formed if the substitution
9134 results in an invalid type.] */
9136 static tree
9138 tree args,
9139 tsubst_flags_t complain,
9140 tree in_decl)
9141 {
9142 tree return_type;
9143 tree arg_types;
9144 tree fntype;
9146 /* The TYPE_CONTEXT is not used for function/method types. */
9149 /* Substitute the return type. */
9153 /* The standard does not presently indicate that creation of a
9154 function type with an invalid return type is a deduction failure.
9155 However, that is clearly analogous to creating an array of "void"
9156 or a reference to a reference. This is core issue #486. */
9159 {
9161 {
9164 else
9166 }
9168 }
9170 /* Substitute the argument types. */
9176 /* Construct a new type node and return it. */
9179 else
9180 {
9183 {
9184 /* [temp.deduct]
9186 Type deduction may fail for any of the following
9187 reasons:
9189 -- Attempting to create "pointer to member of T" when T
9190 is not a class type. */
9193 r);
9195 }
9199 }
9204 }
9206 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9207 ARGS into that specification, and return the substituted
9208 specification. If there is no specification, return NULL_TREE. */
9210 static tree
9212 tree args,
9213 tsubst_flags_t complain,
9214 tree in_decl)
9215 {
9216 tree specs;
9217 tree new_specs;
9222 {
9225 else
9227 {
9228 tree spec;
9233 {
9234 /* Expand the pack expansion type. */
9237 in_decl);
9243 else
9244 {
9245 /* We're substituting into a member template, so
9246 we got a TYPE_PACK_EXPANSION back. Add that
9247 expansion and move on. */
9251 expanded_specs,
9252 complain);
9255 }
9256 }
9259 {
9262 else
9267 complain);
9268 }
9271 }
9272 }
9274 }
9276 /* Take the tree structure T and replace template parameters used
9277 therein with the argument vector ARGS. IN_DECL is an associated
9278 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9279 Issue error and warning messages under control of COMPLAIN. Note
9280 that we must be relatively non-tolerant of extensions here, in
9281 order to preserve conformance; if we allow substitutions that
9282 should not be allowed, we may allow argument deductions that should
9283 not succeed, and therefore report ambiguous overload situations
9284 where there are none. In theory, we could allow the substitution,
9285 but indicate that it should have failed, and allow our caller to
9286 make sure that the right thing happens, but we don't try to do this
9287 yet.
9289 This function is used for dealing with types, decls and the like;
9290 for expressions, use tsubst_expr or tsubst_copy. */
9292 tree
9294 {
9313 else
9318 /* Reuse typedefs. We need to do this to handle dependent attributes,
9319 such as attribute aligned. */
9323 {
9329 {
9333 }
9338 else
9339 /* The typedef is from a non-template context. */
9343 {
9345 r = cp_build_qualified_type_real
9349 }
9350 /* Else we must be instantiating the typedef, so fall through. */
9351 }
9363 {
9390 {
9396 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
9397 needed. */
9405 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
9406 with TREE_SIDE_EFFECTS that indicates this is not an integral
9407 constant expression. */
9410 {
9413 }
9419 {
9423 }
9425 /* [temp.deduct]
9427 Type deduction may fail for any of the following
9428 reasons:
9430 Attempting to create an array with a size that is
9431 zero or negative. */
9433 /* We must fail if performing argument deduction (as
9434 indicated by the state of complain), so that
9435 another substitution can be found. */
9439 {
9444 }
9447 }
9453 {
9466 {
9470 /* See through ARGUMENT_PACK_SELECT arguments. */
9472 }
9477 {
9479 /* If ARG is an argument pack, we don't actually want to
9480 perform a substitution here, because substitutions
9481 for argument packs are only done
9482 element-by-element. We can get to this point when
9483 substituting the type of a non-type template
9484 parameter pack, when that type actually contains
9485 template parameter packs from an outer template, e.g.,
9487 template<typename... Types> struct A {
9488 template<Types... Values> struct B { };
9489 }; */
9493 {
9497 /* cv-quals from the template are discarded when
9498 substituting in a function or reference type. */
9503 else
9506 return cp_build_qualified_type_real
9508 }
9510 {
9511 /* We are processing a type constructed from a
9512 template template parameter. */
9518 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9519 are resolving nested-types in the signature of a
9520 member function templates. Otherwise ARG is a
9521 TEMPLATE_DECL and is the real template to be
9522 instantiated. */
9530 complain);
9531 return cp_build_qualified_type_real
9533 }
9534 else
9535 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9537 }
9540 /* This can happen during the attempted tsubst'ing in
9541 unify. This means that we don't yet have any information
9542 about the template parameter in question. */
9545 /* If we get here, we must have been looking at a parm for a
9546 more deeply nested template. Make a new version of this
9547 template parameter, but with a lower level. */
9549 {
9554 {
9556 r = cp_build_qualified_type_real
9560 }
9561 else
9562 {
9573 /* We have reduced the level of the template
9574 template parameter, but not the levels of its
9575 template parameters, so canonical_type_parameter
9576 will not be able to find the canonical template
9577 template parameter for this level. Thus, we
9578 require structural equality checking to compare
9579 TEMPLATE_TEMPLATE_PARMs. */
9583 else
9587 {
9595 }
9596 }
9605 }
9608 }
9611 {
9619 {
9623 }
9626 {
9630 }
9633 {
9637 }
9643 }
9646 /* We should never be tsubsting a binfo. */
9650 /* A vector of template arguments. */
9656 {
9665 /* [temp.deduct]
9667 Type deduction may fail for any of the following
9668 reasons:
9670 -- Attempting to create a pointer to reference type.
9671 -- Attempting to create a reference to a reference type or
9672 a reference to void.
9674 Core issue 106 says that creating a reference to a reference
9675 during instantiation is no longer a cause for failure. We
9676 only enforce this check in strict C++98 mode. */
9680 {
9683 /* We keep track of the last time we issued this error
9684 message to avoid spewing a ton of messages during a
9685 single bad template instantiation. */
9688 {
9691 else
9694 type);
9696 }
9699 }
9701 {
9705 }
9707 /* In C++0x, during template argument substitution, when there is an
9708 attempt to create a reference to a reference type, reference
9709 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9711 "If a template-argument for a template-parameter T names a type
9712 that is a reference to a type A, an attempt to create the type
9713 'lvalue reference to cv T' creates the type 'lvalue reference to
9714 A,' while an attempt to create the type type rvalue reference to
9715 cv T' creates the type T"
9716 */
9717 r = cp_build_reference_type
9720 else
9725 /* Will this ever be needed for TYPE_..._TO values? */
9729 }
9731 {
9734 {
9735 /* [temp.deduct]
9737 Type deduction may fail for any of the following
9738 reasons:
9740 -- Attempting to create "pointer to member of T" when T
9741 is not a class type. */
9745 }
9747 {
9751 }
9753 {
9757 }
9760 {
9761 /* The type of the implicit object parameter gets its
9762 cv-qualifiers from the FUNCTION_TYPE. */
9763 tree method_type;
9766 tree memptr;
9772 complain);
9773 }
9774 else
9777 complain);
9778 }
9781 {
9782 tree fntype;
9783 tree specs;
9788 /* Substitute the exception specification. */
9790 in_decl);
9796 }
9798 {
9803 /* As an optimization, we avoid regenerating the array type if
9804 it will obviously be the same as T. */
9808 /* These checks should match the ones in grokdeclarator.
9810 [temp.deduct]
9812 The deduction may fail for any of the following reasons:
9814 -- Attempting to create an array with an element type that
9815 is void, a function type, or a reference type, or [DR337]
9816 an abstract class type. */
9820 {
9824 }
9826 {
9829 type);
9831 }
9836 {
9839 }
9842 }
9846 {
9854 }
9858 {
9864 }
9867 {
9877 {
9881 }
9883 {
9884 /* Normally, make_typename_type does not require that the CTX
9885 have complete type in order to allow things like:
9887 template <class T> struct S { typename S<T>::X Y; };
9889 But, such constructs have already been resolved by this
9890 point, so here CTX really should have complete type, unless
9891 it's a partial instantiation. */
9894 {
9898 }
9899 }
9906 {
9909 }
9912 {
9919 }
9921 return cp_build_qualified_type_real
9923 }
9926 {
9938 }
9946 {
9954 }
9957 {
9965 }
9968 {
9969 tree type;
9978 complain);
9979 }
9982 {
9983 tree type;
9995 type =
10001 complain);
10002 }
10006 {
10008 tree packed_out =
10010 args,
10011 complain,
10012 in_decl);
10015 /* For template nontype argument packs, also substitute into
10016 the type. */
10021 }
10028 }
10029 }
10031 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10032 type of the expression on the left-hand side of the "." or "->"
10033 operator. */
10035 static tree
10038 {
10039 tree name;
10040 tree qualifying_scope;
10041 tree fns;
10042 tree optype;
10046 /* A baselink indicates a function from a base class. Both the
10047 BASELINK_ACCESS_BINFO and the base class referenced may
10048 indicate bases of the template class, rather than the
10049 instantiated class. In addition, lookups that were not
10050 ambiguous before may be ambiguous now. Therefore, we perform
10051 the lookup again. */
10058 {
10065 }
10069 /* If lookup found a single function, mark it as used at this
10070 point. (If it lookup found multiple functions the one selected
10071 later by overload resolution will be marked as used at that
10072 point.) */
10078 /* Add back the template arguments, if present. */
10083 template_args);
10084 /* Update the conversion operator type. */
10091 qualifying_scope,
10092 object_type);
10093 }
10095 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10096 true if the qualified-id will be a postfix-expression in-and-of
10097 itself; false if more of the postfix-expression follows the
10098 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10099 of "&". */
10101 static tree
10105 {
10106 tree expr;
10107 tree scope;
10108 tree name;
10110 tree template_args;
10114 /* Figure out what name to look up. */
10117 {
10124 }
10125 else
10126 {
10129 }
10131 /* Substitute into the qualifying scope. When there are no ARGS, we
10132 are just trying to simplify a non-dependent expression. In that
10133 case the qualifying scope may be dependent, and, in any case,
10134 substituting will not help. */
10137 {
10140 }
10141 else
10145 {
10151 }
10154 {
10156 {
10157 /* A BIT_NOT_EXPR is used to represent a destructor. */
10159 {
10163 }
10164 else
10167 }
10168 else
10172 {
10174 {
10178 }
10180 }
10181 }
10184 {
10186 scope);
10187 /* Remember that there was a reference to this entity. */
10189 }
10192 {
10198 }
10207 {
10208 expr = (adjust_result_of_qualified_name_lookup
10210 expr = (finish_qualified_id_expr
10214 }
10216 /* Expressions do not generally have reference type. */
10218 /* However, if we're about to form a pointer-to-member, we just
10219 want the referenced member referenced. */
10224 }
10226 /* Like tsubst, but deals with expressions. This function just replaces
10227 template parms; to finish processing the resultant expression, use
10228 tsubst_expr. */
10230 static tree
10232 {
10234 tree r;
10242 {
10247 {
10248 tree c;
10249 /* This can happen for a parameter name used later in a function
10250 declaration (such as in a late-specified return type). Just
10251 make a dummy decl, since it's only used for its type. */
10253 /* We copy T because want to tsubst the PARM_DECL only,
10254 not the following PARM_DECLs that are chained to T. */
10257 /* Give it the template pattern as its context; its true context
10258 hasn't been instantiated yet and this is good enough for
10259 mangling. */
10261 }
10269 {
10270 tree enum_type;
10271 tree v;
10275 /* There is no need to substitute into namespace-scope
10276 enumerators. */
10279 /* If ARGS is NULL, then T is known to be non-dependent. */
10283 /* Unfortunately, we cannot just call lookup_name here.
10284 Consider:
10286 template <int I> int f() {
10287 enum E { a = I };
10288 struct S { void g() { E e = a; } };
10289 };
10291 When we instantiate f<7>::S::g(), say, lookup_name is not
10292 clever enough to find f<7>::a. */
10293 enum_type
10303 /* We didn't find the name. That should never happen; if
10304 name-lookup found it during preliminary parsing, we
10305 should find it again here during instantiation. */
10307 }
10312 {
10313 tree ctx;
10318 {
10321 {
10325 }
10327 }
10328 }
10351 {
10352 /* Template template argument like the following example need
10353 special treatment:
10355 template <template <class> class TT> struct C {};
10356 template <class T> struct D {
10357 template <class U> struct E {};
10358 C<E> c; // #1
10359 };
10360 D<int> d; // #2
10362 We are processing the template argument `E' in #1 for
10363 the template instantiation #2. Originally, `E' is a
10364 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10365 have to substitute this with one having context `D<int>'. */
10369 }
10370 else
10371 /* Ordinary template template argument. */
10380 return build1
10386 {
10387 /* We only want to compute the number of arguments. */
10401 {
10408 else
10411 }
10412 else
10414 }
10415 /* Fall through */
10429 return build1
10434 {
10435 tree object;
10436 tree name;
10441 {
10445 }
10448 {
10458 }
10463 in_decl);
10464 else
10467 }
10505 return build_nt
10518 return build_nt
10525 {
10533 }
10538 {
10539 r = build_nt
10545 }
10548 {
10549 r = build_nt
10555 }
10558 {
10559 r = build_nt
10565 }
10568 {
10569 /* Substituted template arguments */
10578 }
10581 {
10601 }
10626 {
10629 }
10630 else
10634 /* This is handled by tsubst_copy_and_build. */
10639 in_decl),
10643 /* We shouldn't have built any of these during initial template
10644 generation. Instead, they should be built during instantiation
10645 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10662 }
10663 }
10665 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10667 static tree
10669 tree in_decl)
10670 {
10674 {
10680 {
10683 {
10689 }
10690 /* FALLTHRU */
10712 }
10713 }
10716 }
10718 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10720 static tree
10722 tree in_decl)
10723 {
10724 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10749 #undef RECUR
10750 }
10752 /* Substitute one OMP_FOR iterator. */
10754 static void
10759 {
10760 #define RECUR(NODE) \
10761 tsubst_expr ((NODE), args, complain, in_decl, \
10762 integral_constant_expression_p)
10771 {
10778 }
10782 {
10788 complain);
10789 else
10796 }
10799 {
10800 tree c;
10802 {
10813 }
10815 {
10820 {
10823 }
10824 }
10825 }
10831 else
10835 {
10846 {
10853 }
10854 else
10860 {
10866 }
10870 {
10877 }
10878 else
10884 }
10890 #undef RECUR
10891 }
10893 /* Like tsubst_copy for expressions, etc. but also does semantic
10894 processing. */
10896 static tree
10899 {
10900 #define RECUR(NODE) \
10901 tsubst_expr ((NODE), args, complain, in_decl, \
10902 integral_constant_expression_p)
10915 {
10917 {
10918 tree_stmt_iterator i;
10922 }
10937 else
10946 {
10947 tree decl;
10948 tree init;
10954 {
10957 tree decl;
10965 else
10967 }
10968 else
10969 {
10973 {
10974 /* By marking the declaration as instantiated, we avoid
10975 trying to instantiate it. Since instantiate_decl can't
10976 handle local variables, and since we've already done
10977 all that needs to be done, that's the right thing to
10978 do. */
10983 /* Anonymous aggregates are a special case. */
10985 else
10986 {
10990 {
10991 /* For __PRETTY_FUNCTION__ we have to adjust the
10992 initializer. */
10996 }
10997 else
10998 {
11002 /* If we had an initializer but it
11003 instantiated to nothing,
11004 value-initialize the object. This will
11005 only occur when the initializer was a
11006 pack expansion where the parameter packs
11007 used in that expansion were of length
11008 zero. */
11010 else
11012 }
11015 }
11016 }
11017 }
11019 /* A DECL_EXPR can also be used as an expression, in the condition
11020 clause of an if/for/while construct. */
11022 }
11060 {
11064 }
11072 else
11080 else
11107 {
11109 tree label;
11114 }
11120 /* Computed goto's must be tsubst'd into. On the other hand,
11121 non-computed gotos must not be; the identifier in question
11122 will have no binding. */
11124 else
11130 tmp = finish_asm_stmt
11136 {
11141 }
11146 {
11151 }
11152 else
11153 {
11158 else
11165 else
11171 else
11173 }
11177 {
11181 {
11183 /* Prevent instantiate_decl from trying to instantiate
11184 this variable. We've already done all that needs to be
11185 done. */
11188 }
11193 }
11201 {
11202 tree condition =
11204 args,
11211 }
11232 {
11247 integral_constant_expression_p);
11256 {
11260 }
11261 else
11262 {
11270 }
11284 }
11315 {
11320 }
11336 integral_constant_expression_p);
11337 }
11340 #undef RECUR
11341 }
11343 /* T is a postfix-expression that is not being used in a function
11344 call. Return the substituted version of T. */
11346 static tree
11348 tsubst_flags_t complain,
11349 tree in_decl)
11350 {
11354 else
11360 }
11362 /* Like tsubst but deals with expressions and performs semantic
11363 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11365 tree
11367 tree args,
11368 tsubst_flags_t complain,
11369 tree in_decl,
11372 {
11373 #define RECUR(NODE) \
11374 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11376 integral_constant_expression_p)
11378 tree op1;
11384 {
11387 /* Fall through. */
11389 {
11390 tree decl;
11391 cp_id_kind idk;
11396 {
11399 }
11401 /* Look up the name. */
11404 /* By convention, expressions use ERROR_MARK_NODE to indicate
11405 failure, not NULL_TREE. */
11411 integral_constant_expression_p,
11419 input_location);
11425 }
11428 {
11429 tree object;
11437 {
11440 }
11441 else
11448 else
11450 }
11453 {
11457 {
11458 /* A type conversion to reference type will be enclosed in
11459 such an indirect ref, but the substitution of the cast
11460 will have also added such an indirect ref. */
11463 }
11464 else
11467 }
11470 return build_nop
11479 {
11480 tree type;
11481 tree op;
11486 {
11491 }
11496 {
11509 }
11510 }
11528 complain);
11535 else
11537 in_decl);
11574 return build_x_binary_op
11578 ? ERROR_MARK
11582 ? ERROR_MARK
11585 complain);
11598 /* Fall through */
11603 {
11604 /* When there are no ARGS, we are trying to evaluate a
11605 non-dependent expression from the parser. Trying to do
11606 the substitutions may not work. */
11609 }
11610 else
11611 {
11619 }
11623 else
11628 {
11629 tree r = build_x_modify_expr
11633 complain);
11634 /* TREE_NO_WARNING must be set if either the expression was
11635 parenthesized or it uses an operator such as >>= rather
11636 than plain assignment. In the former case, it was already
11637 set and must be copied. In the latter case,
11638 build_x_modify_expr sets it and it must not be reset
11639 here. */
11643 }
11648 /* Remember that there was a reference to this entity. */
11654 {
11659 tree ret;
11663 else
11664 {
11668 }
11670 /* If there was an initializer in the original tree, but it
11671 instantiated to an empty list, then we should pass a
11672 non-NULL empty vector to tell build_new that it was an
11673 empty initializer() rather than no initializer. This can
11674 only happen when the initializer is a pack expansion whose
11675 parameter packs are of length zero. */
11678 else
11679 {
11683 else
11684 {
11687 }
11688 }
11695 complain);
11703 }
11706 return delete_sanity
11715 complain);
11718 {
11719 tree function;
11724 tree ret;
11727 /* When we parsed the expression, we determined whether or
11728 not Koenig lookup should be performed. */
11731 {
11736 }
11737 else
11738 {
11740 {
11746 }
11747 else
11751 in_decl,
11753 integral_constant_expression_p);
11757 }
11762 {
11768 else
11769 {
11770 /* Expand the pack expansion and push each entry onto
11771 CALL_ARGS. */
11774 {
11779 {
11784 }
11785 }
11786 else
11787 {
11788 /* A partial substitution. Add one entry. */
11790 }
11791 }
11792 }
11794 /* We do not perform argument-dependent lookup if normal
11795 lookup finds a non-function, in accordance with the
11796 expected resolution of DR 218. */
11799 /* If lookup found a member function, the Koenig lookup is
11800 not appropriate, even if an unqualified-name was used
11801 to denote the function. */
11804 /* Only do this when substitution turns a dependent call
11805 into a non-dependent call. */
11811 {
11815 }
11817 /* Remember that there was a reference to this entity. */
11824 {
11829 complain);
11830 else
11831 ret = (build_new_method_call
11837 complain));
11838 }
11839 else
11842 koenig_p,
11843 complain);
11848 }
11851 return build_x_conditional_expr
11855 complain);
11858 return finish_pseudo_destructor_expr
11864 {
11872 {
11873 /* We have pack expansions, so expand those and
11874 create a new list out of it. */
11877 tree chain;
11880 /* Expand the argument expressions. */
11888 /* Build the rest of the list. */
11893 /* Determine the number of arguments. */
11895 {
11898 }
11901 else
11902 {
11903 /* Since we only performed a partial substitution into
11904 the argument pack, we only return a single list
11905 node. */
11912 }
11914 /* Convert the argument vectors into a TREE_LIST */
11917 {
11918 /* Grab the Ith values. */
11919 i--;
11922 value
11926 /* Build the list (backwards). */
11928 }
11931 }
11947 }
11950 {
11951 tree object;
11952 tree object_type;
11953 tree member;
11957 /* Remember that there was a reference to this entity. */
11967 else
11973 {
11975 {
11980 {
11983 }
11985 {
11989 }
11990 }
11991 }
11994 {
11995 tree tmpl;
11996 tree args;
11998 /* Lookup the template functions now that we know what the
11999 scope is. */
12006 {
12009 args);
12010 member = (adjust_result_of_qualified_name_lookup
12012 object_type));
12013 }
12014 else
12015 {
12017 input_location);
12019 }
12020 }
12024 {
12026 {
12030 else
12033 }
12035 }
12041 complain);
12042 }
12045 return build_throw
12049 {
12057 tree r;
12062 /* digest_init will do the wrong thing if we let it. */
12066 /* We do not want to process the index of aggregate
12067 initializers as they are identifier nodes which will be
12068 looked up by digest_init. */
12074 {
12079 {
12080 /* Substitute into the pack expansion. */
12082 in_decl);
12085 ;
12087 /* Just move the argument into place. */
12089 else
12090 {
12091 /* Update the length of the final CONSTRUCTOR
12092 arguments vector, and note that we will need to
12093 copy.*/
12096 }
12097 }
12098 else
12100 }
12103 {
12108 idx++)
12109 {
12111 {
12116 }
12117 else
12119 }
12120 }
12129 }
12132 {
12137 }
12142 /* Fall through */
12145 {
12149 /* If the original type was a reference, we'll be wrapped in
12150 the appropriate INDIRECT_REF. */
12153 }
12158 in_decl));
12164 {
12173 }
12176 {
12182 integral_constant_expression_p);
12187 }
12191 /* As in finish_id_expression, we resolve enumeration constants
12192 to their underlying values. */
12194 {
12197 }
12201 /* Handle Objective-C++ constructs, if appropriate. */
12202 {
12203 tree subst
12208 }
12210 }
12212 #undef RECUR
12213 }
12215 /* Verify that the instantiated ARGS are valid. For type arguments,
12216 make sure that the type's linkage is ok. For non-type arguments,
12217 make sure they are constants if they are integral or enumerations.
12218 Emit an error under control of COMPLAIN, and return TRUE on error. */
12220 static bool
12222 {
12224 {
12234 }
12236 {
12237 /* [basic.link]: A name with no linkage (notably, the name
12238 of a class or enumeration declared in a local scope)
12239 shall not be used to declare an entity with linkage.
12240 This implies that names with no linkage cannot be used as
12241 template arguments. */
12245 {
12246 /* DR 488 makes use of a type with no linkage cause
12247 type deduction to fail. */
12249 {
12252 else
12255 }
12257 }
12258 /* In order to avoid all sorts of complications, we do not
12259 allow variably-modified types as template arguments. */
12261 {
12265 }
12266 }
12267 /* A non-type argument of integral or enumerated type must be a
12268 constant. */
12272 {
12276 }
12278 }
12280 static bool
12282 {
12287 {
12290 }
12294 }
12296 /* Instantiate the indicated variable or function template TMPL with
12297 the template arguments in TARG_PTR. */
12299 tree
12301 {
12303 tree fndecl;
12304 tree gen_tmpl;
12305 tree spec;
12306 HOST_WIDE_INT saved_processing_template_decl;
12313 /* If this function is a clone, handle it specially. */
12315 {
12316 tree spec;
12317 tree clone;
12319 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
12320 DECL_CLONED_FUNCTION. */
12326 /* Look for the clone. */
12330 /* We should always have found the clone by now. */
12333 }
12335 /* Check to see if we already have this specialization. */
12338 /* The TMPL is a partial instantiation. To get a full set of
12339 arguments we must add the arguments used to perform the
12340 partial instantiation. */
12342 targ_ptr);
12344 /* It would be nice to avoid hashing here and then again in tsubst_decl,
12345 but it doesn't seem to be on the hot path. */
12357 complain))
12360 /* We are building a FUNCTION_DECL, during which the access of its
12361 parameters and return types have to be checked. However this
12362 FUNCTION_DECL which is the desired context for access checking
12363 is not built yet. We solve this chicken-and-egg problem by
12364 deferring all checks until we have the FUNCTION_DECL. */
12367 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
12368 (because, for example, we have encountered a non-dependent
12369 function call in the body of a template function and must now
12370 determine which of several overloaded functions will be called),
12371 within the instantiation itself we are not processing a
12372 template. */
12375 /* Substitute template parameters to obtain the specialization. */
12382 /* Now we know the specialization, compute access previously
12383 deferred. */
12386 /* Some typedefs referenced from within the template code need to be access
12387 checked at template instantiation time, i.e now. These types were
12388 added to the template at parsing time. Let's get those and perfom
12389 the acces checks then. */
12395 /* The DECL_TI_TEMPLATE should always be the immediate parent
12396 template, not the most general template. */
12399 /* If we've just instantiated the main entry point for a function,
12400 instantiate all the alternate entry points as well. We do this
12401 by cloning the instantiation of the main entry point, not by
12402 instantiating the template clones. */
12407 }
12409 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
12410 NARGS elements of the arguments that are being used when calling
12411 it. TARGS is a vector into which the deduced template arguments
12412 are placed.
12414 Return zero for success, 2 for an incomplete match that doesn't resolve
12415 all the types, and 1 for complete failure. An error message will be
12416 printed only for an incomplete match.
12418 If FN is a conversion operator, or we are trying to produce a specific
12419 specialization, RETURN_TYPE is the return type desired.
12421 The EXPLICIT_TARGS are explicit template arguments provided via a
12422 template-id.
12424 The parameter STRICT is one of:
12426 DEDUCE_CALL:
12427 We are deducing arguments for a function call, as in
12428 [temp.deduct.call].
12430 DEDUCE_CONV:
12431 We are deducing arguments for a conversion function, as in
12432 [temp.deduct.conv].
12434 DEDUCE_EXACT:
12435 We are deducing arguments when doing an explicit instantiation
12436 as in [temp.explicit], when determining an explicit specialization
12437 as in [temp.expl.spec], or when taking the address of a function
12438 template, as in [temp.deduct.funcaddr]. */
12440 int
12442 tree explicit_targs,
12443 tree targs,
12446 tree return_type,
12447 unification_kind_t strict,
12449 {
12450 tree parms;
12451 tree fntype;
12459 {
12460 /* [temp.deduct]
12462 The specified template arguments must match the template
12463 parameters in kind (i.e., type, nontype, template), and there
12464 must not be more arguments than there are parameters;
12465 otherwise type deduction fails.
12467 Nontype arguments must match the types of the corresponding
12468 nontype template parameters, or must be convertible to the
12469 types of the corresponding nontype parameters as specified in
12470 _temp.arg.nontype_, otherwise type deduction fails.
12472 All references in the function type of the function template
12473 to the corresponding template parameters are replaced by the
12474 specified template argument values. If a substitution in a
12475 template parameter or in the function type of the function
12476 template results in an invalid type, type deduction fails. */
12479 tree converted_args;
12485 converted_args
12492 /* Substitute the explicit args into the function type. This is
12493 necessary so that, for instance, explicitly declared function
12494 arguments can match null pointed constants. If we were given
12495 an incomplete set of explicit args, we must not do semantic
12496 processing during substitution as we could create partial
12497 instantiations. */
12499 {
12503 /* Dig out the actual parm. */
12506 {
12509 }
12511 {
12514 }
12517 {
12519 tree targ;
12522 /* Mark the argument pack as "incomplete". We could
12523 still deduce more arguments during unification. */
12526 {
12530 }
12532 /* We have some incomplete argument packs. */
12534 }
12535 }
12538 /* Any substitution is guaranteed to be incomplete if there
12539 are incomplete argument packs, because we can still deduce
12540 more arguments. */
12542 else
12552 /* Place the explicitly specified arguments in TARGS. */
12555 }
12557 /* Never do unification on the 'this' parameter. */
12561 {
12570 }
12572 /* We allow incomplete unification without an error message here
12573 because the standard doesn't seem to explicitly prohibit it. Our
12574 callers must be ready to deal with unification failures in any
12575 event. */
12581 {
12584 /* Clear the "incomplete" flags on all argument packs. */
12586 {
12589 {
12592 }
12593 }
12594 }
12596 /* Now that we have bindings for all of the template arguments,
12597 ensure that the arguments deduced for the template template
12598 parameters have compatible template parameter lists. We cannot
12599 check this property before we have deduced all template
12600 arguments, because the template parameter types of a template
12601 template parameter might depend on prior template parameters
12602 deduced after the template template parameter. The following
12603 ill-formed example illustrates this issue:
12605 template<typename T, template<T> class C> void f(C<5>, T);
12607 template<int N> struct X {};
12609 void g() {
12610 f(X<5>(), 5l); // error: template argument deduction fails
12611 }
12613 The template parameter list of 'C' depends on the template type
12614 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
12615 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
12616 time that we deduce 'C'. */
12618 && !template_template_parm_bindings_ok_p
12623 /* All is well so far. Now, check:
12625 [temp.deduct]
12627 When all template arguments have been deduced, all uses of
12628 template parameters in nondeduced contexts are replaced with
12629 the corresponding deduced argument values. If the
12630 substitution results in an invalid type, as described above,
12631 type deduction fails. */
12632 {
12637 /* If we're looking for an exact match, check that what we got
12638 is indeed an exact match. It might not be if some template
12639 parameters are used in non-deduced contexts. */
12641 {
12644 tree sarg
12651 }
12652 }
12655 }
12657 /* Adjust types before performing type deduction, as described in
12658 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
12659 sections are symmetric. PARM is the type of a function parameter
12660 or the return type of the conversion function. ARG is the type of
12661 the argument passed to the call, or the type of the value
12662 initialized with the result of the conversion function.
12663 ARG_EXPR is the original argument expression, which may be null. */
12665 static int
12669 tree arg_expr)
12670 {
12674 {
12679 {
12680 /* Swap PARM and ARG throughout the remainder of this
12681 function; the handling is precisely symmetric since PARM
12682 will initialize ARG rather than vice versa. */
12687 }
12690 /* There is nothing to do in this case. */
12695 }
12698 {
12699 /* [temp.deduct.call]
12701 If P is not a reference type:
12703 --If A is an array type, the pointer type produced by the
12704 array-to-pointer standard conversion (_conv.array_) is
12705 used in place of A for type deduction; otherwise,
12707 --If A is a function type, the pointer type produced by
12708 the function-to-pointer standard conversion
12709 (_conv.func_) is used in place of A for type deduction;
12710 otherwise,
12712 --If A is a cv-qualified type, the top level
12713 cv-qualifiers of A's type are ignored for type
12714 deduction. */
12719 else
12721 }
12723 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
12724 of the form T&&, where T is a template parameter, and the argument
12725 is an lvalue, T is deduced as A& */
12733 /* [temp.deduct.call]
12735 If P is a cv-qualified type, the top level cv-qualifiers
12736 of P's type are ignored for type deduction. If P is a
12737 reference type, the type referred to by P is used for
12738 type deduction. */
12741 {
12744 }
12746 /* DR 322. For conversion deduction, remove a reference type on parm
12747 too (which has been swapped into ARG). */
12752 }
12754 /* Most parms like fn_type_unification.
12756 If SUBR is 1, we're being called recursively (to unify the
12757 arguments of a function or method parameter of a function
12758 template). */
12760 static int
12762 tree targs,
12763 tree xparms,
12767 unification_kind_t strict,
12769 {
12775 tree parms;
12785 {
12801 }
12803 again:
12811 {
12824 /* We can't deduce anything from this, but we might get all the
12825 template args from other function args. */
12828 /* Conversions will be performed on a function argument that
12829 corresponds with a function parameter that contains only
12830 non-deducible template parameters and explicitly specified
12831 template parameters. */
12833 {
12834 tree type;
12838 else
12845 flags))
12849 }
12852 {
12855 {
12856 /* [temp.deduct.type]
12858 A template-argument can be deduced from a pointer to
12859 function or pointer to member function argument if
12860 the set of overloaded functions does not contain
12861 function templates and at most one of a set of
12862 overloaded functions provides a unique match. */
12868 }
12873 }
12875 {
12880 arg_expr);
12886 }
12887 }
12893 {
12894 /* Unify the remaining arguments with the pack expansion type. */
12895 tree argvec;
12898 /* Allocate a TREE_VEC and copy in all of the arguments */
12903 /* Copy the parameter into parmvec. */
12909 /* Advance to the end of the list of parameters. */
12911 }
12913 /* Fail if we've reached the end of the parm list, and more args
12914 are present, and the parm list isn't variadic. */
12917 /* Fail if parms are left and they don't have default values. */
12925 {
12926 tree tparm;
12933 /* If this is an undeduced nontype parameter that depends on
12934 a type parameter, try another pass; its type may have been
12935 deduced from a later argument than the one from which
12936 this parameter can be deduced. */
12942 /* Core issue #226 (C++0x) [temp.deduct]:
12944 If a template argument has not been deduced, its
12945 default template argument, if any, is used.
12947 When we are in C++98 mode, TREE_PURPOSE will either
12948 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12949 to explicitly check cxx_dialect here. */
12951 {
12952 tree arg = tsubst_template_arg
12957 else
12958 {
12961 }
12962 }
12964 /* If the type parameter is a parameter pack, then it will
12965 be deduced to an empty parameter pack. */
12967 {
12968 tree arg;
12971 {
12975 }
12976 else
12983 }
12986 }
12989 }
12991 /* Subroutine of type_unification_real. Args are like the variables
12992 at the call site. ARG is an overloaded function (or template-id);
12993 we try deducing template args from each of the overloads, and if
12994 only one succeeds, we go with that. Modifies TARGS and returns
12995 true on success. */
12997 static bool
12999 tree targs,
13000 tree parm,
13001 tree arg,
13002 unification_kind_t strict,
13004 {
13011 {
13014 }
13015 else
13019 /* Handle `&x' where `x' is some static or non-static member
13020 function name. */
13026 /* Strip baselink information. */
13031 {
13032 /* If we got some explicit template args, we need to plug them into
13033 the affected templates before we try to unify, in case the
13034 explicit args will completely resolve the templates in question. */
13040 {
13051 {
13056 {
13059 }
13060 }
13062 }
13063 }
13066 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13067 -- but the deduction does not succeed because the expression is
13068 not just the function on its own. */
13070 else
13076 {
13079 }
13081 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13082 to function or pointer to member function argument if the set of
13083 overloaded functions does not contain function templates and at most
13084 one of a set of overloaded functions provides a unique match.
13086 So if we found multiple possibilities, we return success but don't
13087 deduce anything. */
13090 {
13095 }
13100 }
13102 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13103 overload. Fills TARGS with any deduced arguments, or error_mark_node if
13104 different overloads deduce different arguments for a given parm.
13105 ADDR_P is true if the expression for which deduction is being
13106 performed was of the form "& fn" rather than simply "fn".
13108 Returns 1 on success. */
13110 static int
13112 tree orig_targs,
13113 tree targs,
13114 tree parm,
13115 tree arg,
13116 unification_kind_t strict,
13119 {
13121 tree tempargs;
13124 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13125 to function or pointer to member function argument if the set of
13126 overloaded functions does not contain function templates and at most
13127 one of a set of overloaded functions provides a unique match.
13129 So if this is a template, just return success. */
13141 /* We don't copy orig_targs for this because if we have already deduced
13142 some template args from previous args, unify would complain when we
13143 try to deduce a template parameter for the same argument, even though
13144 there isn't really a conflict. */
13151 /* First make sure we didn't deduce anything that conflicts with
13152 explicitly specified args. */
13154 {
13161 /* Since we're unifying against ourselves, we will fill in
13162 template args used in the function parm list with our own
13163 template parms. Discard them. */
13167 }
13170 {
13175 }
13178 }
13180 /* PARM is a template class (perhaps with unbound template
13181 parameters). ARG is a fully instantiated type. If ARG can be
13182 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
13183 TARGS are as for unify. */
13185 static tree
13187 {
13188 tree copy_of_targs;
13195 /* We need to make a new template argument vector for the call to
13196 unify. If we used TARGS, we'd clutter it up with the result of
13197 the attempted unification, even if this class didn't work out.
13198 We also don't want to commit ourselves to all the unifications
13199 we've already done, since unification is supposed to be done on
13200 an argument-by-argument basis. In other words, consider the
13201 following pathological case:
13203 template <int I, int J, int K>
13204 struct S {};
13206 template <int I, int J>
13207 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
13209 template <int I, int J, int K>
13210 void f(S<I, J, K>, S<I, I, I>);
13212 void g() {
13213 S<0, 0, 0> s0;
13214 S<0, 1, 2> s2;
13216 f(s0, s2);
13217 }
13219 Now, by the time we consider the unification involving `s2', we
13220 already know that we must have `f<0, 0, 0>'. But, even though
13221 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
13222 because there are two ways to unify base classes of S<0, 1, 2>
13223 with S<I, I, I>. If we kept the already deduced knowledge, we
13224 would reject the possibility I=1. */
13227 /* If unification failed, we're done. */
13233 }
13235 /* Given a template type PARM and a class type ARG, find the unique
13236 base type in ARG that is an instance of PARM. We do not examine
13237 ARG itself; only its base-classes. If there is not exactly one
13238 appropriate base class, return NULL_TREE. PARM may be the type of
13239 a partial specialization, as well as a plain template type. Used
13240 by unify. */
13242 static tree
13244 {
13246 tree binfo;
13252 /* The type could not be completed. */
13255 /* Walk in inheritance graph order. The search order is not
13256 important, and this avoids multiple walks of virtual bases. */
13258 {
13262 {
13263 /* If there is more than one satisfactory baseclass, then:
13265 [temp.deduct.call]
13267 If they yield more than one possible deduced A, the type
13268 deduction fails.
13270 applies. */
13275 }
13276 }
13279 }
13281 /* Returns the level of DECL, which declares a template parameter. */
13283 static int
13285 {
13287 {
13297 }
13299 }
13301 /* Decide whether ARG can be unified with PARM, considering only the
13302 cv-qualifiers of each type, given STRICT as documented for unify.
13303 Returns nonzero iff the unification is OK on that basis. */
13305 static int
13307 {
13313 {
13314 /* Although a CVR qualifier is ignored when being applied to a
13315 substituted template parameter ([8.3.2]/1 for example), that
13316 does not apply during deduction [14.8.2.4]/1, (even though
13317 that is not explicitly mentioned, [14.8.2.4]/9 indicates
13318 this). Except when we're allowing additional CV qualifiers
13319 at the outer level [14.8.2.1]/3,1st bullet. */
13329 }
13340 }
13342 /* Determines the LEVEL and INDEX for the template parameter PARM. */
13343 void
13345 {
13349 {
13352 }
13353 else
13354 {
13357 }
13358 }
13360 /* Unifies the remaining arguments in PACKED_ARGS with the pack
13361 expansion at the end of PACKED_PARMS. Returns 0 if the type
13362 deduction succeeds, 1 otherwise. STRICT is the same as in
13363 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
13364 call argument list. We'll need to adjust the arguments to make them
13365 types. SUBR tells us if this is from a recursive call to
13366 type_unification_real. */
13367 int
13371 {
13372 tree parm
13379 /* Determine the parameter packs we will be deducing from the
13380 pattern, and record their current deductions. */
13383 {
13387 /* Determine the index and level of this parameter pack. */
13390 /* Keep track of the parameter packs and their corresponding
13391 argument packs. */
13394 }
13396 /* Loop through all of the arguments that have not yet been
13397 unified and unify each with the pattern. */
13399 {
13402 /* For each parameter pack, clear out the deduced value so that
13403 we can deduce it again. */
13405 {
13410 }
13412 /* Unify the pattern with the current argument. */
13413 {
13420 {
13423 /* This mirrors what we do in type_unification_real. */
13425 {
13427 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
13428 | UNIFY_ALLOW_MORE_CV_QUAL
13442 }
13445 {
13448 {
13449 /* [temp.deduct.type] A template-argument can be
13450 deduced from a pointer to function or pointer
13451 to member function argument if the set of
13452 overloaded functions does not contain function
13453 templates and at most one of a set of
13454 overloaded functions provides a unique
13455 match. */
13460 sub_strict)
13464 }
13467 {
13472 }
13473 }
13478 arg_strict |=
13481 }
13484 {
13487 }
13488 }
13490 /* For each parameter pack, collect the deduced value. */
13492 {
13498 }
13499 }
13501 /* Verify that the results of unification with the parameter packs
13502 produce results consistent with what we've seen before, and make
13503 the deduced argument packs available. */
13505 {
13511 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
13512 actually deduce anything. */
13520 {
13521 /* Prepend the explicit arguments onto NEW_ARGS. */
13527 /* Copy the explicit arguments. */
13532 /* Copy the deduced arguments. */
13536 }
13539 {
13540 tree result;
13545 /* Build the deduced *_ARGUMENT_PACK. */
13547 {
13552 }
13553 else
13558 /* Note the deduced argument packs for this parameter
13559 pack. */
13561 }
13565 {
13566 /* We only had the explicitly-provided arguments before, but
13567 now we have a complete set of arguments. */
13572 /* Keep the original deduced argument pack. */
13578 }
13580 new_args))
13581 /* Inconsistent unification of this parameter pack. */
13583 else
13584 {
13589 /* Keep the original deduced argument pack. */
13591 }
13592 }
13595 }
13597 /* Deduce the value of template parameters. TPARMS is the (innermost)
13598 set of template parameters to a template. TARGS is the bindings
13599 for those template parameters, as determined thus far; TARGS may
13600 include template arguments for outer levels of template parameters
13601 as well. PARM is a parameter to a template function, or a
13602 subcomponent of that parameter; ARG is the corresponding argument.
13603 This function attempts to match PARM with ARG in a manner
13604 consistent with the existing assignments in TARGS. If more values
13605 are deduced, then TARGS is updated.
13607 Returns 0 if the type deduction succeeds, 1 otherwise. The
13608 parameter STRICT is a bitwise or of the following flags:
13610 UNIFY_ALLOW_NONE:
13611 Require an exact match between PARM and ARG.
13612 UNIFY_ALLOW_MORE_CV_QUAL:
13613 Allow the deduced ARG to be more cv-qualified (by qualification
13614 conversion) than ARG.
13615 UNIFY_ALLOW_LESS_CV_QUAL:
13616 Allow the deduced ARG to be less cv-qualified than ARG.
13617 UNIFY_ALLOW_DERIVED:
13618 Allow the deduced ARG to be a template base class of ARG,
13619 or a pointer to a template base class of the type pointed to by
13620 ARG.
13621 UNIFY_ALLOW_INTEGER:
13622 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
13623 case for more information.
13624 UNIFY_ALLOW_OUTER_LEVEL:
13625 This is the outermost level of a deduction. Used to determine validity
13626 of qualification conversions. A valid qualification conversion must
13627 have const qualified pointers leading up to the inner type which
13628 requires additional CV quals, except at the outer level, where const
13629 is not required [conv.qual]. It would be normal to set this flag in
13630 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
13631 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
13632 This is the outermost level of a deduction, and PARM can be more CV
13633 qualified at this point.
13634 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
13635 This is the outermost level of a deduction, and PARM can be less CV
13636 qualified at this point. */
13638 static int
13640 {
13642 tree targ;
13643 tree tparm;
13646 /* I don't think this will do the right thing with respect to types.
13647 But the only case I've seen it in so far has been array bounds, where
13648 signedness is the only information lost, and I think that will be
13649 okay. */
13657 /* We can't deduce anything from this, but we might get all the
13658 template args from other function args. */
13661 /* If PARM uses template parameters, then we can't bail out here,
13662 even if ARG == PARM, since we won't record unifications for the
13663 template parameters. We might need them if we're trying to
13664 figure out which of two things is more specialized. */
13668 /* Handle init lists early, so the rest of the function can assume
13669 we're dealing with a type. */
13671 {
13676 /* We can only deduce from an initializer list argument if the
13677 parameter is std::initializer_list; otherwise this is a
13678 non-deduced context. */
13684 {
13687 {
13689 /* It should only be possible to get here for a call. */
13691 elt_strict |= maybe_adjust_types_for_deduction
13694 }
13698 }
13700 }
13702 /* Immediately reject some pairs that won't unify because of
13703 cv-qualification mismatches. */
13706 /* It is the elements of the array which hold the cv quals of an array
13707 type, and the elements might be template type parms. We'll check
13708 when we recurse. */
13710 /* We check the cv-qualifiers when unifying with template type
13711 parameters below. We want to allow ARG `const T' to unify with
13712 PARM `T' for example, when computing which of two templates
13713 is more specialized, for example. */
13727 {
13731 /* In a type which contains a nested-name-specifier, template
13732 argument values cannot be deduced for template parameters used
13733 within the nested-name-specifier. */
13745 /* The PARM is not one we're trying to unify. Just check
13746 to see if it matches ARG. */
13753 /* Check for mixed types and values. */
13761 {
13762 /* ARG must be constructed from a template class or a template
13763 template parameter. */
13768 {
13771 tree parm_parms
13772 = DECL_INNERMOST_TEMPLATE_PARMS
13777 /* The resolution to DR150 makes clear that default
13778 arguments for an N-argument may not be used to bind T
13779 to a template template parameter with fewer than N
13780 parameters. It is not safe to permit the binding of
13781 default arguments as an extension, as that may change
13782 the meaning of a conforming program. Consider:
13784 struct Dense { static const unsigned int dim = 1; };
13786 template <template <typename> class View,
13787 typename Block>
13788 void operator+(float, View<Block> const&);
13790 template <typename Block,
13791 unsigned int Dim = Block::dim>
13792 struct Lvalue_proxy { operator float() const; };
13794 void
13795 test_1d (void) {
13796 Lvalue_proxy<Dense> p;
13797 float b;
13798 b + p;
13799 }
13801 Here, if Lvalue_proxy is permitted to bind to View, then
13802 the global operator+ will be used; if they are not, the
13803 Lvalue_proxy will be converted to float. */
13805 argvec,
13807 tf_none,
13813 /* Deduce arguments T, i from TT<T> or TT<i>.
13814 We check each element of PARMVEC and ARGVEC individually
13815 rather than the whole TREE_VEC since they can have
13816 different number of elements. */
13823 /* Check if the parameters end in a pack, making them
13824 variadic. */
13833 {
13837 UNIFY_ALLOW_NONE))
13839 }
13844 UNIFY_ALLOW_NONE,
13848 }
13851 /* Fall through to deduce template name. */
13852 }
13856 {
13857 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
13859 /* Simple cases: Value already set, does match or doesn't. */
13864 }
13865 else
13866 {
13867 /* If PARM is `const T' and ARG is only `int', we don't have
13868 a match unless we are allowing additional qualification.
13869 If ARG is `const int' and PARM is just `T' that's OK;
13870 that binds `const int' to `T'. */
13875 /* Consider the case where ARG is `const volatile int' and
13876 PARM is `const T'. Then, T should be `volatile int'. */
13877 arg = cp_build_qualified_type_real
13882 /* Simple cases: Value already set, does match or doesn't. */
13888 /* Make sure that ARG is not a variable-sized array. (Note
13889 that were talking about variable-sized arrays (like
13890 `int[n]'), rather than arrays of unknown size (like
13891 `int[]').) We'll get very confused by such a type since
13892 the bound of the array will not be computable in an
13893 instantiation. Besides, such types are not allowed in
13894 ISO C++, so we can do as we please here. */
13898 /* Strip typedefs as in convert_template_argument. */
13900 }
13902 /* If ARG is a parameter pack or an expansion, we cannot unify
13903 against it unless PARM is also a parameter pack. */
13908 /* If the argument deduction results is a METHOD_TYPE,
13909 then there is a problem.
13910 METHOD_TYPE doesn't map to any real C++ type the result of
13911 the deduction can not be of that type. */
13925 /* The PARM is not one we're trying to unify. Just check
13926 to see if it matches ARG. */
13936 /* [temp.deduct.type] If, in the declaration of a function template
13937 with a non-type template-parameter, the non-type
13938 template-parameter is used in an expression in the function
13939 parameter-list and, if the corresponding template-argument is
13940 deduced, the template-argument type shall match the type of the
13941 template-parameter exactly, except that a template-argument
13942 deduced from an array bound may be of any integral type.
13943 The non-type parameter might use already deduced type parameters. */
13946 /* Template-parameter dependent expression. Just accept it for now.
13947 It will later be processed in convert_template_argument. */
13948 ;
13954 /* Convert the ARG to the type of PARM; the deduced non-type
13955 template argument must exactly match the types of the
13956 corresponding parameter. */
13959 /* We haven't deduced the type of this parameter yet. Try again
13960 later. */
13962 else
13965 /* If ARG is a parameter pack or an expansion, we cannot unify
13966 against it unless PARM is also a parameter pack. */
13975 {
13976 /* A pointer-to-member constant can be unified only with
13977 another constant. */
13981 /* Just unify the class member. It would be useless (and possibly
13982 wrong, depending on the strict flags) to unify also
13983 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13984 arg refer to the same variable, even if through different
13985 classes. For instance:
13987 struct A { int x; };
13988 struct B : A { };
13990 Unification of &A::x and &B::x must succeed. */
13993 }
13996 {
14000 /* [temp.deduct.call]
14002 A can be another pointer or pointer to member type that can
14003 be converted to the deduced A via a qualification
14004 conversion (_conv.qual_).
14006 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14007 This will allow for additional cv-qualification of the
14008 pointed-to types if appropriate. */
14011 /* The derived-to-base conversion only persists through one
14012 level of pointers. */
14017 }
14032 {
14033 tree parm_max;
14034 tree arg_max;
14038 /* Our representation of array types uses "N - 1" as the
14039 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14040 not an integer constant. We cannot unify arbitrarily
14041 complex expressions, so we eliminate the MINUS_EXPRs
14042 here. */
14046 {
14049 }
14053 {
14054 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14055 trying to unify the type of a variable with the type
14056 of a template parameter. For example:
14058 template <unsigned int N>
14059 void f (char (&) [N]);
14060 int g();
14061 void h(int i) {
14062 char a[g(i)];
14063 f(a);
14064 }
14066 Here, the type of the ARG will be "int [g(i)]", and
14067 may be a SAVE_EXPR, etc. */
14071 }
14073 /* If only one of the bounds used a MINUS_EXPR, compensate
14074 by adding one to the other bound. */
14077 integer_type_node,
14078 parm_max,
14079 integer_one_node);
14082 integer_type_node,
14083 arg_max,
14084 integer_one_node);
14088 }
14102 /* We have already checked cv-qualification at the top of the
14103 function. */
14107 /* As far as unification is concerned, this wins. Later checks
14108 will invalidate it if necessary. */
14111 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
14112 /* Type INTEGER_CST can come from ordinary constant template args. */
14122 {
14131 UNIFY_ALLOW_NONE))
14134 }
14142 {
14149 strict);
14150 }
14153 {
14157 {
14158 /* First, we try to unify the PARM and ARG directly. */
14163 {
14164 /* Fallback to the special case allowed in
14165 [temp.deduct.call]:
14167 If P is a class, and P has the form
14168 template-id, then A can be a derived class of
14169 the deduced A. Likewise, if P is a pointer to
14170 a class of the form template-id, A can be a
14171 pointer to a derived class pointed to by the
14172 deduced A. */
14177 }
14178 }
14182 /* Perhaps PARM is something like S<U> and ARG is S<int>.
14183 Then, we should unify `int' and `U'. */
14185 else
14186 /* There's no chance of unification succeeding. */
14191 }
14198 {
14201 tree a;
14207 /* CV qualifications for methods can never be deduced, they must
14208 match exactly. We need to check them explicitly here,
14209 because type_unification_real treats them as any other
14210 cv-qualified parameter. */
14212 && (!check_cv_quals_for_unify
14232 LOOKUP_NORMAL);
14233 }
14236 /* Unify a pointer to member with a pointer to member function, which
14237 deduces the type of the member as a function type. */
14239 {
14240 tree method_type;
14241 tree fntype;
14242 cp_cv_quals cv_quals;
14244 /* Check top-level cv qualifiers */
14252 /* Determine the type of the function we are unifying against. */
14254 fntype =
14258 /* Extract the cv-qualifiers of the member function from the
14259 implicit object parameter and place them on the function
14260 type to be restored later. */
14261 cv_quals =
14265 }
14273 strict);
14284 /* Matched cases are handled by the ARG == PARM test above. */
14289 {
14297 {
14299 {
14301 /* We can unify against something with a trailing
14302 parameter pack. */
14304 else
14305 /* Since there is something following the pack
14306 expansion, we cannot unify this template argument
14307 list. */
14309 }
14310 }
14313 /* If we don't have enough arguments to satisfy the parameters
14314 (not counting the pack expression at the end), or we have
14315 too many arguments for a parameter list that doesn't end in
14316 a pack expression, we can't unify. */
14321 /* Unify all of the parameters that precede the (optional)
14322 pack expression. */
14324 {
14328 }
14336 }
14342 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
14343 nodes. */
14347 /* Unification fails if we hit an error node. */
14353 /* We must be looking at an expression. This can happen with
14354 something like:
14356 template <int I>
14357 void foo(S<I>, S<I + 2>);
14359 This is a "nondeduced context":
14361 [deduct.type]
14363 The nondeduced contexts are:
14365 --A type that is a template-id in which one or more of
14366 the template-arguments is an expression that references
14367 a template-parameter.
14369 In these cases, we assume deduction succeeded, but don't
14370 actually infer any unifications. */
14375 else
14377 }
14378 }
14379 \f
14380 /* Note that DECL can be defined in this translation unit, if
14381 required. */
14383 static void
14385 {
14386 tree clone;
14390 }
14392 /* Called if RESULT is explicitly instantiated, or is a member of an
14393 explicitly instantiated class. */
14395 void
14397 {
14400 /* If this entity has already been written out, it's too late to
14401 make any modifications. */
14406 /* The TREE_PUBLIC flag for function declarations will have been
14407 set correctly by tsubst. */
14410 /* This might have been set by an earlier implicit instantiation. */
14415 else
14416 {
14418 /* Always make artificials weak. */
14421 /* For WIN32 we also want to put explicit instantiations in
14422 linkonce sections. */
14425 }
14427 /* If EXTERN_P, then this function will not be emitted -- unless
14428 followed by an explicit instantiation, at which point its linkage
14429 will be adjusted. If !EXTERN_P, then this function will be
14430 emitted here. In neither circumstance do we want
14431 import_export_decl to adjust the linkage. */
14433 }
14435 /* Given two function templates PAT1 and PAT2, return:
14437 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
14438 -1 if PAT2 is more specialized than PAT1.
14439 0 if neither is more specialized.
14441 LEN indicates the number of parameters we should consider
14442 (defaulted parameters should not be considered).
14444 The 1998 std underspecified function template partial ordering, and
14445 DR214 addresses the issue. We take pairs of arguments, one from
14446 each of the templates, and deduce them against each other. One of
14447 the templates will be more specialized if all the *other*
14448 template's arguments deduce against its arguments and at least one
14449 of its arguments *does* *not* deduce against the other template's
14450 corresponding argument. Deduction is done as for class templates.
14451 The arguments used in deduction have reference and top level cv
14452 qualifiers removed. Iff both arguments were originally reference
14453 types *and* deduction succeeds in both directions, the template
14454 with the more cv-qualified argument wins for that pairing (if
14455 neither is more cv-qualified, they both are equal). Unlike regular
14456 deduction, after all the arguments have been deduced in this way,
14457 we do *not* verify the deduced template argument values can be
14458 substituted into non-deduced contexts, nor do we have to verify
14459 that all template arguments have been deduced. */
14461 int
14463 {
14475 /* Remove the this parameter from non-static member functions. If
14476 one is a non-static member function and the other is not a static
14477 member function, remove the first parameter from that function
14478 also. This situation occurs for operator functions where we
14479 locate both a member function (with this pointer) and non-member
14480 operator (with explicit first operand). */
14482 {
14487 }
14489 {
14492 {
14493 len--;
14495 }
14496 }
14498 /* If only one is a conversion operator, they are unordered. */
14502 /* Consider the return type for a conversion function */
14504 {
14507 len++;
14508 }
14510 processing_template_decl++;
14513 /* Stop when an ellipsis is seen. */
14515 {
14524 {
14525 /* When both arguments are pack expansions, we need only
14526 unify the patterns themselves. */
14530 /* This is the last comparison we need to do. */
14532 }
14535 {
14538 }
14541 {
14544 }
14547 {
14548 /* Only of the args is a reference, see if we should apply
14549 array/function pointer decay to it. This is not part of
14550 DR214, but is, IMHO, consistent with the deduction rules
14551 for the function call itself, and with our earlier
14552 implementation of the underspecified partial ordering
14553 rules. (nathan). */
14555 {
14557 {
14560 /* FALLTHROUGH. */
14567 }
14568 }
14569 else
14570 {
14572 {
14575 /* FALLTHROUGH. */
14582 }
14583 }
14584 }
14590 {
14596 /* Setup the parameter vector, which contains only ARG1. */
14599 /* Setup the argument vector, which contains the remaining
14600 arguments. */
14609 /* We cannot deduce in the other direction, because ARG1 is
14610 a pack expansion but ARG2 is not. */
14612 }
14614 {
14620 /* Setup the parameter vector, which contains only ARG1. */
14623 /* Setup the argument vector, which contains the remaining
14624 arguments. */
14633 /* We cannot deduce in the other direction, because ARG2 is
14634 a pack expansion but ARG1 is not.*/
14636 }
14638 else
14639 {
14640 /* The normal case, where neither argument is a pack
14641 expansion. */
14644 }
14651 /* We've failed to deduce something in either direction.
14652 These must be unordered. */
14656 {
14657 /* Deduces in both directions, see if quals can
14658 disambiguate. Pretend the worse one failed to deduce. */
14663 }
14671 /* We have already processed all of the arguments in our
14672 handing of the pack expansion type. */
14677 }
14679 processing_template_decl--;
14681 /* All things being equal, if the next argument is a pack expansion
14682 for one function but not for the other, prefer the
14683 non-variadic function. */
14687 {
14692 }
14695 }
14697 /* Determine which of two partial specializations is more specialized.
14699 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
14700 to the first partial specialization. The TREE_VALUE is the
14701 innermost set of template parameters for the partial
14702 specialization. PAT2 is similar, but for the second template.
14704 Return 1 if the first partial specialization is more specialized;
14705 -1 if the second is more specialized; 0 if neither is more
14706 specialized.
14708 See [temp.class.order] for information about determining which of
14709 two templates is more specialized. */
14711 static int
14713 {
14714 tree targs;
14722 /* Just like what happens for functions, if we are ordering between
14723 different class template specializations, we may encounter dependent
14724 types in the arguments, and we need our dependency check functions
14725 to behave correctly. */
14731 {
14734 }
14740 {
14743 }
14746 /* In the case of a tie where at least one of the class templates
14747 has a parameter pack at the end, the template with the most
14748 non-packed parameters wins. */
14750 && any_deductions
14753 {
14759 /* We don't count the pack expansion at the end. */
14769 }
14772 }
14774 /* Return the template arguments that will produce the function signature
14775 DECL from the function template FN, with the explicit template
14776 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
14777 also match. Return NULL_TREE if no satisfactory arguments could be
14778 found. */
14780 static tree
14782 {
14785 tree decl_type;
14786 tree decl_arg_types;
14789 tree arg;
14791 /* Substitute the explicit template arguments into the type of DECL.
14792 The call to fn_type_unification will handle substitution into the
14793 FN. */
14796 {
14797 tree tmpl;
14798 tree converted_args;
14802 else
14803 /* We can get here for some invalid specializations. */
14806 converted_args
14809 tf_none,
14818 }
14820 /* Never do unification on the 'this' parameter. */
14839 }
14841 /* Return the innermost template arguments that, when applied to a
14842 template specialization whose innermost template parameters are
14843 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
14844 ARGS.
14846 For example, suppose we have:
14848 template <class T, class U> struct S {};
14849 template <class T> struct S<T*, int> {};
14851 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
14852 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
14853 int}. The resulting vector will be {double}, indicating that `T'
14854 is bound to `double'. */
14856 static tree
14858 {
14860 tree deduced_args;
14861 tree innermost_deduced_args;
14865 {
14869 innermost_deduced_args);
14870 }
14871 else
14877 UNIFY_ALLOW_NONE))
14884 /* Verify that nondeduced template arguments agree with the type
14885 obtained from argument deduction.
14887 For example:
14889 struct A { typedef int X; };
14890 template <class T, class U> struct C {};
14891 template <class T> struct C<T, typename T::X> {};
14893 Then with the instantiation `C<A, int>', we can deduce that
14894 `T' is `A' but unify () does not check whether `typename T::X'
14895 is `int'. */
14898 /* We only need to check the innermost arguments; the other
14899 arguments will always agree. */
14904 /* Now that we have bindings for all of the template arguments,
14905 ensure that the arguments deduced for the template template
14906 parameters have compatible template parameter lists. See the use
14907 of template_template_parm_bindings_ok_p in fn_type_unification
14908 for more information. */
14913 }
14915 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
14916 Return the TREE_LIST node with the most specialized template, if
14917 any. If there is no most specialized template, the error_mark_node
14918 is returned.
14920 Note that this function does not look at, or modify, the
14921 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
14922 returned is one of the elements of INSTANTIATIONS, callers may
14923 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
14924 and retrieve it from the value returned. */
14926 tree
14928 {
14935 {
14941 fate--;
14946 fate++;
14951 {
14952 /* Equally specialized, move to next function. If there
14953 is no next function, nothing's most specialized. */
14958 }
14959 }
14962 /* Now verify that champ is better than everything earlier in the
14963 instantiation list. */
14971 {
14974 }
14976 processing_template_decl--;
14982 }
14984 /* If DECL is a specialization of some template, return the most
14985 general such template. Otherwise, returns NULL_TREE.
14987 For example, given:
14989 template <class T> struct S { template <class U> void f(U); };
14991 if TMPL is `template <class U> void S<int>::f(U)' this will return
14992 the full template. This function will not trace past partial
14993 specializations, however. For example, given in addition:
14995 template <class T> struct S<T*> { template <class U> void f(U); };
14997 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14998 `template <class T> template <class U> S<T*>::f(U)'. */
15000 tree
15002 {
15003 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15004 an immediate specialization. */
15006 {
15010 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15011 template friend. */
15016 }
15018 /* Look for more and more general templates. */
15020 {
15021 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15022 (See cp-tree.h for details.) */
15030 /* Stop if we run into an explicitly specialized class template. */
15037 }
15040 }
15042 /* Return the most specialized of the class template partial
15043 specializations of TMPL which can produce TYPE, a specialization of
15044 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
15045 a _TYPE node corresponding to the partial specialization, while the
15046 TREE_PURPOSE is the set of template arguments that must be
15047 substituted into the TREE_TYPE in order to generate TYPE.
15049 If the choice of partial specialization is ambiguous, a diagnostic
15050 is issued, and the error_mark_node is returned. If there are no
15051 partial specializations of TMPL matching TYPE, then NULL_TREE is
15052 returned. */
15054 static tree
15056 {
15058 tree t;
15059 tree champ;
15062 tree args;
15068 /* For determining which partial specialization to use, only the
15069 innermost args are interesting. */
15071 {
15074 }
15077 {
15078 tree partial_spec_args;
15079 tree spec_args;
15084 {
15089 /* Discard the outer levels of args, and then substitute in the
15090 template args from the enclosing class. */
15092 partial_spec_args = tsubst_template_args
15095 /* PARMS already refers to just the innermost parms, but the
15096 template parms in partial_spec_args had their levels lowered
15097 by tsubst, so we need to do the same for the parm list. We
15098 can't just tsubst the TREE_VEC itself, as tsubst wants to
15099 treat a TREE_VEC as an argument vector. */
15106 }
15108 partial_spec_args,
15109 args);
15111 {
15116 }
15117 }
15127 {
15130 ;
15131 else
15132 {
15134 {
15137 {
15140 }
15141 }
15143 }
15144 }
15148 {
15151 {
15154 }
15155 }
15158 {
15162 {
15165 }
15167 }
15170 }
15172 /* Explicitly instantiate DECL. */
15174 void
15176 {
15181 /* An error occurred, for which grokdeclarator has already issued
15182 an appropriate message. */
15185 {
15188 }
15190 {
15191 /* There is an asymmetry here in the way VAR_DECLs and
15192 FUNCTION_DECLs are handled by grokdeclarator. In the case of
15193 the latter, the DECL we get back will be marked as a
15194 template instantiation, and the appropriate
15195 DECL_TEMPLATE_INFO will be set up. This does not happen for
15196 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
15197 should handle VAR_DECLs as it currently handles
15198 FUNCTION_DECLs. */
15200 {
15203 }
15206 {
15209 }
15211 {
15216 }
15217 }
15219 {
15222 }
15223 else
15226 /* Check for various error cases. Note that if the explicit
15227 instantiation is valid the RESULT will currently be marked as an
15228 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
15229 until we get here. */
15232 {
15233 /* DR 259 [temp.spec].
15235 Both an explicit instantiation and a declaration of an explicit
15236 specialization shall not appear in a program unless the explicit
15237 instantiation follows a declaration of the explicit specialization.
15239 For a given set of template parameters, if an explicit
15240 instantiation of a template appears after a declaration of an
15241 explicit specialization for that template, the explicit
15242 instantiation has no effect. */
15244 }
15246 {
15247 /* [temp.spec]
15249 No program shall explicitly instantiate any template more
15250 than once.
15252 We check DECL_NOT_REALLY_EXTERN so as not to complain when
15253 the first instantiation was `extern' and the second is not,
15254 and EXTERN_P for the opposite case. */
15257 /* If an "extern" explicit instantiation follows an ordinary
15258 explicit instantiation, the template is instantiated. */
15261 }
15263 {
15266 }
15268 {
15271 }
15274 ;
15276 {
15279 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
15282 }
15283 else
15291 }
15293 static void
15295 {
15301 {
15304 }
15305 }
15307 /* Called from do_type_instantiation through binding_table_foreach to
15308 do recursive instantiation for the type bound in ENTRY. */
15309 static void
15311 {
15317 }
15319 /* Called from do_type_instantiation to instantiate a member
15320 (a member function or a static member variable) of an
15321 explicitly instantiated class template. */
15322 static void
15324 {
15329 }
15331 /* Perform an explicit instantiation of template class T. STORAGE, if
15332 non-null, is the RID for extern, inline or static. COMPLAIN is
15333 nonzero if this is called from the parser, zero if called recursively,
15334 since the standard is unclear (as detailed below). */
15336 void
15338 {
15348 {
15351 }
15356 {
15359 t);
15361 }
15364 {
15366 {
15368 {
15371 "ISO C++ 1998 forbids the use of %<extern%> on "
15373 }
15374 else
15376 "ISO C++ forbids the use of %qE"
15378 }
15386 else
15387 {
15389 storage);
15391 }
15392 }
15395 {
15396 /* DR 259 [temp.spec].
15398 Both an explicit instantiation and a declaration of an explicit
15399 specialization shall not appear in a program unless the explicit
15400 instantiation follows a declaration of the explicit specialization.
15402 For a given set of template parameters, if an explicit
15403 instantiation of a template appears after a declaration of an
15404 explicit specialization for that template, the explicit
15405 instantiation has no effect. */
15407 }
15409 {
15410 /* [temp.spec]
15412 No program shall explicitly instantiate any template more
15413 than once.
15415 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
15416 instantiation was `extern'. If EXTERN_P then the second is.
15417 These cases are OK. */
15424 /* If we've already instantiated the template, just return now. */
15427 }
15435 {
15436 tree tmp;
15438 /* In contrast to implicit instantiation, where only the
15439 declarations, and not the definitions, of members are
15440 instantiated, we have here:
15442 [temp.explicit]
15444 The explicit instantiation of a class template specialization
15445 implies the instantiation of all of its members not
15446 previously explicitly specialized in the translation unit
15447 containing the explicit instantiation.
15449 Of course, we can't instantiate member template classes, since
15450 we don't have any arguments for them. Note that the standard
15451 is unclear on whether the instantiation of the members are
15452 *explicit* instantiations or not. However, the most natural
15453 interpretation is that it should be an explicit instantiation. */
15468 }
15469 }
15471 /* Given a function DECL, which is a specialization of TMPL, modify
15472 DECL to be a re-instantiation of TMPL with the same template
15473 arguments. TMPL should be the template into which tsubst'ing
15474 should occur for DECL, not the most general template.
15476 One reason for doing this is a scenario like this:
15478 template <class T>
15479 void f(const T&, int i);
15481 void g() { f(3, 7); }
15483 template <class T>
15484 void f(const T& t, const int i) { }
15486 Note that when the template is first instantiated, with
15487 instantiate_template, the resulting DECL will have no name for the
15488 first parameter, and the wrong type for the second. So, when we go
15489 to instantiate the DECL, we regenerate it. */
15491 static void
15493 {
15494 /* The arguments used to instantiate DECL, from the most general
15495 template. */
15496 tree args;
15497 tree code_pattern;
15502 /* Make sure that we can see identifiers, and compute access
15503 correctly. */
15507 {
15508 tree decl_parm;
15509 tree pattern_parm;
15510 tree specs;
15523 specs);
15525 /* Merge parameter declarations. */
15528 pattern_parm
15532 {
15533 tree parm_type;
15534 tree attributes;
15539 NULL_TREE);
15545 {
15548 }
15551 }
15552 /* Merge any parameters that match with the function parameter
15553 pack. */
15555 {
15557 tree expanded_types;
15558 /* Expand the TYPE_PACK_EXPANSION that provides the types for
15559 the parameters in this function parameter pack. */
15564 {
15565 tree parm_type;
15566 tree attributes;
15569 /* Rename the parameter to include the index. */
15578 {
15581 }
15583 }
15584 }
15585 /* Merge additional specifiers from the CODE_PATTERN. */
15589 }
15595 else
15599 }
15601 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
15602 substituted to get DECL. */
15604 tree
15606 {
15609 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
15610 for the instantiation. This is not always the most general
15611 template. Consider, for example:
15613 template <class T>
15614 struct S { template <class U> void f();
15615 template <> void f<int>(); };
15617 and an instantiation of S<double>::f<int>. We want TD to be the
15618 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
15620 more general template. */
15622 /* We must also deal with friend templates. Given:
15624 template <class T> struct S {
15625 template <class U> friend void f() {};
15626 };
15628 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
15629 so far as the language is concerned, but that's still
15630 where we get the pattern for the instantiation from. On
15631 other hand, if the definition comes outside the class, say:
15633 template <class T> struct S {
15634 template <class U> friend void f();
15635 };
15636 template <class U> friend void f() {}
15638 we don't need to look any further. That's what the check for
15639 DECL_INITIAL is for. */
15643 {
15644 /* The present template, TD, should not be a definition. If it
15645 were a definition, we should be using it! Note that we
15646 cannot restructure the loop to just keep going until we find
15647 a template with a definition, since that might go too far if
15648 a specialization was declared, but not defined. */
15652 /* Fetch the more general template. */
15654 }
15657 }
15659 /* Produce the definition of D, a _DECL generated from a template. If
15660 DEFER_OK is nonzero, then we don't have to actually do the
15661 instantiation now; we just have to do it sometime. Normally it is
15662 an error if this is an explicit instantiation but D is undefined.
15663 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
15664 explicitly instantiated class template. */
15666 tree
15669 {
15671 tree gen_args;
15672 tree args;
15673 tree td;
15674 tree code_pattern;
15675 tree spec;
15676 tree gen_tmpl;
15682 /* This function should only be used to instantiate templates for
15683 functions and static member variables. */
15687 /* Variables are never deferred; if instantiation is required, they
15688 are instantiated right away. That allows for better code in the
15689 case that an expression refers to the value of the variable --
15690 if the variable has a constant value the referring expression can
15691 take advantage of that fact. */
15695 /* Don't instantiate cloned functions. Instead, instantiate the
15696 functions they cloned. */
15702 /* D has already been instantiated or explicitly specialized, so
15703 there's nothing for us to do here.
15705 It might seem reasonable to check whether or not D is an explicit
15706 instantiation, and, if so, stop here. But when an explicit
15707 instantiation is deferred until the end of the compilation,
15708 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
15709 the instantiation. */
15716 /* We should already have the extra args. */
15719 /* And what's in the hash table should match D. */
15723 /* This needs to happen before any tsubsting. */
15729 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
15730 for the instantiation. */
15734 /* We should never be trying to instantiate a member of a class
15735 template or partial specialization. */
15740 /* In the case of a friend template whose definition is provided
15741 outside the class, we may have too many arguments. Drop the
15742 ones we don't need. The same is true for specializations. */
15743 args = get_innermost_template_args
15745 else
15750 else
15753 /* We may be in the middle of deferred access check. Disable it now. */
15756 /* Unless an explicit instantiation directive has already determined
15757 the linkage of D, remember that a definition is available for
15758 this entity. */
15766 /* If D is a member of an explicitly instantiated class template,
15767 and no definition is available, treat it like an implicit
15768 instantiation. */
15771 {
15775 }
15778 {
15779 /* Recheck the substitutions to obtain any warning messages
15780 about ignoring cv qualifiers. */
15784 /* Make sure that we can see identifiers, and compute access
15785 correctly. D is already the target FUNCTION_DECL with the
15786 right context. */
15790 {
15793 d);
15794 /* Don't simply tsubst the function type, as that will give
15795 duplicate warnings about poor parameter qualifications.
15796 The function arguments are the same as the decl_arguments
15797 without the top level cv qualifiers. */
15799 }
15803 }
15805 /* Check to see whether we know that this template will be
15806 instantiated in some other file, as with "extern template"
15807 extension. */
15809 /* In general, we do not instantiate such templates... */
15811 /* ... but we instantiate inline functions so that we can inline
15812 them. An explicit instantiation declaration prohibits implicit
15813 instantiation of non-inline functions. With high levels of
15814 optimization, we would normally inline non-inline functions
15815 -- but we're not allowed to do that for "extern template" functions.
15816 Therefore, we check DECL_DECLARED_INLINE_P, rather than
15817 possibly_inlined_p. And ... */
15820 /* ... we instantiate static data members whose values are
15821 needed in integral constant expressions. */
15825 /* Defer all other templates, unless we have been explicitly
15826 forbidden from doing so. */
15828 template. */
15829 ! pattern_defined
15830 /* If it's OK to postpone instantiation, do so. */
15831 || defer_ok
15832 /* If this is a static data member that will be defined
15833 elsewhere, we don't want to instantiate the entire data
15834 member, but we do want to instantiate the initializer so that
15835 we can substitute that elsewhere. */
15837 {
15838 /* The definition of the static data member is now required so
15839 we must substitute the initializer. */
15843 {
15844 tree ns;
15845 tree init;
15851 args,
15856 LOOKUP_ONLYCONVERTING);
15859 }
15861 /* We restore the source position here because it's used by
15862 add_pending_template. */
15868 /* [temp.explicit]
15870 The definition of a non-exported function template, a
15871 non-exported member function template, or a non-exported
15872 member function or static data member of a class template
15873 shall be present in every translation unit in which it is
15874 explicitly instantiated. */
15878 /* ??? Historically, we have instantiated inline functions, even
15879 when marked as "extern template". */
15883 }
15884 /* Tell the repository that D is available in this translation unit
15885 -- and see if it is supposed to be instantiated here. */
15887 {
15888 /* In a PCH file, despite the fact that the repository hasn't
15889 requested instantiation in the PCH it is still possible that
15890 an instantiation will be required in a file that includes the
15891 PCH. */
15894 /* Instantiate inline functions so that the inliner can do its
15895 job, even though we'll not be emitting a copy of this
15896 function. */
15899 }
15905 /* Mark D as instantiated so that recursive calls to
15906 instantiate_decl do not try to instantiate it again. */
15909 /* Regenerate the declaration in case the template has been modified
15910 by a subsequent redeclaration. */
15913 /* We already set the file and line above. Reset them now in case
15914 they changed as a result of calling regenerate_decl_from_template. */
15918 {
15919 tree init;
15921 /* Clear out DECL_RTL; whatever was there before may not be right
15922 since we've reset the type of the declaration. */
15926 /* The initializer is placed in DECL_INITIAL by
15927 regenerate_decl_from_template. Pull it out so that
15928 cp_finish_decl can process it. */
15933 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
15934 initializer. That function will defer actual emission until
15935 we have a chance to determine linkage. */
15938 /* Enter the scope of D so that access-checking works correctly. */
15942 }
15944 {
15945 htab_t saved_local_specializations;
15946 tree subst_decl;
15947 tree tmpl_parm;
15948 tree spec_parm;
15950 /* Save away the current list, in case we are instantiating one
15951 template from within the body of another. */
15954 /* Set up the list of local specializations. */
15956 hash_local_specialization,
15957 eq_local_specializations,
15958 NULL);
15960 /* Set up context. */
15963 /* Create substitution entries for the parameters. */
15968 {
15972 }
15974 {
15978 }
15980 {
15981 /* Register the (value) argument pack as a specialization of
15982 TMPL_PARM, then move on. */
15987 }
15990 /* Substitute into the body of the function. */
15995 /* Set the current input_location to the end of the function
15996 so that finish_function knows where we are. */
15999 /* We don't need the local specializations any more. */
16003 /* Finish the function. */
16006 }
16008 /* We're not deferring instantiation any more. */
16014 out:
16022 }
16024 /* Run through the list of templates that we wish we could
16025 instantiate, and instantiate any we can. RETRIES is the
16026 number of times we retry pending template instantiation. */
16028 void
16030 {
16034 /* Instantiating templates may trigger vtable generation. This in turn
16035 may require further template instantiations. We place a limit here
16036 to avoid infinite loop. */
16038 {
16042 " instantiating %q+D, possibly from virtual table generation"
16046 /* Pretend that we defined it. */
16049 }
16051 do
16052 {
16057 {
16062 {
16063 tree fn;
16066 {
16070 fn;
16078 }
16081 }
16082 else
16083 {
16086 {
16087 instantiation
16093 }
16097 }
16100 /* If INSTANTIATION has been instantiated, then we don't
16101 need to consider it again in the future. */
16103 else
16104 {
16107 }
16110 }
16112 }
16116 }
16118 /* Substitute ARGVEC into T, which is a list of initializers for
16119 either base class or a non-static data member. The TREE_PURPOSEs
16120 are DECLs, and the TREE_VALUEs are the initializer values. Used by
16121 instantiate_decl. */
16123 static tree
16125 {
16129 {
16130 tree decl;
16131 tree init;
16137 {
16138 tree expr;
16139 tree arg;
16141 /* Expand the base class expansion type into separate base
16142 classes. */
16144 tf_warning_or_error,
16145 NULL_TREE);
16149 /* We'll be building separate TREE_LISTs of arguments for
16150 each base. */
16156 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
16157 expand each argument in the TREE_VALUE of t. */
16163 /* VOID_TYPE_NODE is used to indicate
16164 value-initialization. */
16165 {
16168 }
16169 else
16170 {
16171 /* Substitute parameter packs into each argument in the
16172 TREE_LIST. */
16175 {
16176 tree expanded_exprs;
16178 /* Expand the argument. */
16180 expanded_exprs
16182 tf_warning_or_error,
16183 NULL_TREE);
16187 /* Prepend each of the expanded expressions to the
16188 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
16190 {
16195 }
16196 }
16199 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
16200 since we built them backwards. */
16202 {
16205 }
16206 }
16207 }
16210 {
16212 {
16216 }
16217 else
16218 {
16230 }
16233 {
16237 }
16238 }
16239 }
16241 }
16243 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
16245 static void
16247 {
16252 else
16254 }
16256 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
16257 is the instantiation (which should have been created with
16258 start_enum) and ARGS are the template arguments to use. */
16260 static void
16262 {
16263 tree e;
16266 {
16267 tree value;
16268 tree decl;
16271 /* Note that in a template enum, the TREE_VALUE is the
16272 CONST_DECL, not the corresponding INTEGER_CST. */
16277 /* Give this enumeration constant the correct access. */
16280 /* Actually build the enumerator itself. */
16282 }
16287 }
16289 /* DECL is a FUNCTION_DECL that is a template specialization. Return
16290 its type -- but without substituting the innermost set of template
16291 arguments. So, innermost set of template parameters will appear in
16292 the type. */
16294 tree
16296 {
16297 tree fn_type;
16298 tree tmpl;
16299 tree targs;
16300 tree tparms;
16308 /* There should be as many levels of arguments as there are levels
16309 of parameters. */
16315 /* No substitution is necessary. */
16316 ;
16317 else
16318 {
16320 tree partial_args;
16322 /* Replace the innermost level of the TARGS with NULL_TREEs to
16323 let tsubst know not to substitute for those parameters. */
16332 /* Disable access control as this function is used only during
16333 name-mangling. */
16338 /* Now, do the (partial) substitution to figure out the
16339 appropriate function type. */
16343 /* Substitute into the template parameters to obtain the real
16344 innermost set of parameters. This step is important if the
16345 innermost set of template parameters contains value
16346 parameters whose types depend on outer template parameters. */
16351 }
16354 }
16356 /* Return truthvalue if we're processing a template different from
16357 the last one involved in diagnostics. */
16358 int
16360 {
16362 }
16364 /* Remember current template involved in diagnostics. */
16365 void
16367 {
16369 }
16373 {
16375 }
16377 /* [temp.param] Check that template non-type parm TYPE is of an allowable
16378 type. Return zero for ok, nonzero for disallowed. Issue error and
16379 warning messages under control of COMPLAIN. */
16381 static int
16383 {
16398 }
16400 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
16401 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
16403 static bool
16405 {
16406 tree scope;
16408 /* [temp.dep.type]
16410 A type is dependent if it is:
16412 -- a template parameter. Template template parameters are types
16413 for us (since TYPE_P holds true for them) so we handle
16414 them here. */
16418 /* -- a qualified-id with a nested-name-specifier which contains a
16419 class-name that names a dependent type or whose unqualified-id
16420 names a dependent type. */
16423 /* -- a cv-qualified type where the cv-unqualified type is
16424 dependent. */
16426 /* -- a compound type constructed from any dependent type. */
16436 {
16437 tree arg_type;
16442 arg_type;
16447 }
16448 /* -- an array type constructed from any dependent type or whose
16449 size is specified by a constant expression that is
16450 value-dependent. */
16452 {
16457 }
16460 {
16461 /* If this is the TYPE_DOMAIN of an array type, consider it
16462 dependent. We already checked for value-dependence in
16463 compute_array_index_type. */
16465 }
16467 /* -- a template-id in which either the template name is a template
16468 parameter ... */
16471 /* ... or any of the template arguments is a dependent type or
16472 an expression that is type-dependent or value-dependent. */
16474 && (any_dependent_template_arguments_p
16478 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
16479 argument of the `typeof' expression is not type-dependent, then
16480 it should already been have resolved. */
16485 /* A template argument pack is dependent if any of its packed
16486 arguments are. */
16488 {
16494 }
16496 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
16497 be template parameters. */
16501 /* The standard does not specifically mention types that are local
16502 to template functions or local classes, but they should be
16503 considered dependent too. For example:
16505 template <int I> void f() {
16506 enum E { a = I };
16507 S<sizeof (E)> s;
16508 }
16510 The size of `E' cannot be known until the value of `I' has been
16511 determined. Therefore, `E' must be considered dependent. */
16518 /* Other types are non-dependent. */
16520 }
16522 /* Returns TRUE if TYPE is dependent, in the sense of
16523 [temp.dep.type]. */
16525 bool
16527 {
16528 /* If there are no template parameters in scope, then there can't be
16529 any dependent types. */
16531 {
16532 /* If we are not processing a template, then nobody should be
16533 providing us with a dependent type. */
16537 }
16539 /* If the type is NULL, we have not computed a type for the entity
16540 in question; in that case, the type is dependent. */
16544 /* Erroneous types can be considered non-dependent. */
16548 /* If we have not already computed the appropriate value for TYPE,
16549 do so now. */
16551 {
16554 }
16557 }
16559 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
16560 lookup. In other words, a dependent type that is not the current
16561 instantiation. */
16563 bool
16565 {
16568 }
16570 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
16572 static bool
16574 {
16575 tree scope;
16576 tree name;
16586 /* [temp.dep.expr]
16588 An id-expression is type-dependent if it contains a
16589 nested-name-specifier that contains a class-name that names a
16590 dependent type. */
16591 /* The suggested resolution to Core Issue 224 implies that if the
16592 qualifying type is the current class, then we must peek
16593 inside it. */
16602 }
16604 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
16605 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
16606 expression. */
16608 bool
16610 {
16614 /* A name declared with a dependent type. */
16619 {
16621 /* A name that has not been looked up -- must be dependent. */
16625 /* A non-type template parm. */
16629 /* A non-type template parm. */
16635 /* A constant with integral or enumeration type and is initialized
16636 with an expression that is value-dependent. */
16648 /* These expressions are value-dependent if the type to which
16649 the cast occurs is dependent or the expression being casted
16650 is value-dependent. */
16651 {
16657 /* A functional cast has a list of operands. */
16660 {
16661 /* If there are no operands, it must be an expression such
16662 as "int()". This should not happen for aggregate types
16663 because it would form non-constant expressions. */
16667 }
16673 }
16677 /* A `sizeof' expression is value-dependent if the operand is
16678 type-dependent or is a pack expansion. */
16694 /* A CALL_EXPR may appear in a constant expression if it is a
16695 call to a builtin function, e.g., __builtin_constant_p. All
16696 such calls are value-dependent. */
16700 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
16701 is value-dependent. */
16702 {
16711 }
16714 {
16718 }
16725 /* A constant expression is value-dependent if any subexpression is
16726 value-dependent. */
16728 {
16738 || (value_dependent_expression_p
16743 {
16746 /* In some cases, some of the operands may be missing.
16747 (For example, in the case of PREDECREMENT_EXPR, the
16748 amount to increment by may be missing.) That doesn't
16749 make the expression dependent. */
16751 && (value_dependent_expression_p
16755 }
16759 }
16760 }
16762 /* The expression is not value-dependent. */
16764 }
16766 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
16767 [temp.dep.expr]. */
16769 bool
16771 {
16778 /* An unresolved name is always dependent. */
16783 /* Some expression forms are never type-dependent. */
16794 /* The types of these expressions depends only on the type to which
16795 the cast occurs. */
16803 /* The types of these expressions depends only on the type created
16804 by the expression. */
16807 {
16808 /* For NEW_EXPR tree nodes created inside a template, either
16809 the object type itself or a TREE_LIST may appear as the
16810 operand 1. */
16813 /* This is an array type. We need to check array dimensions
16814 as well. */
16816 || value_dependent_expression_p
16818 else
16820 }
16824 type_dependent_expression_p))
16830 && (any_dependent_template_arguments_p
16842 {
16843 tree elt;
16847 {
16850 }
16852 }
16855 {
16860 {
16866 }
16867 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
16875 {
16880 }
16885 {
16889 }
16891 }
16896 }
16898 /* Like type_dependent_expression_p, but it also works while not processing
16899 a template definition, i.e. during substitution or mangling. */
16901 bool
16903 {
16909 }
16911 /* Returns TRUE if ARGS contains a type-dependent expression. */
16913 bool
16915 {
16917 tree arg;
16920 {
16923 }
16925 }
16927 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
16928 expressions) contains any value-dependent expressions. */
16930 bool
16932 {
16938 }
16940 /* Returns TRUE if the ARG (a template argument) is dependent. */
16942 bool
16944 {
16952 {
16956 {
16959 }
16962 }
16965 else
16968 }
16970 /* Returns true if ARGS (a collection of template arguments) contains
16971 any types that require structural equality testing. */
16973 bool
16975 {
16985 {
16988 {
16994 {
16995 /* Look inside the argument pack. */
16998 }
17001 {
17015 }
17016 }
17017 }
17020 }
17022 /* Returns true if ARGS (a collection of template arguments) contains
17023 any dependent arguments. */
17025 bool
17027 {
17037 {
17042 }
17045 }
17047 /* Returns TRUE if the template TMPL is dependent. */
17049 bool
17051 {
17053 {
17055 {
17059 }
17061 }
17063 /* Template template parameters are dependent. */
17067 /* So are names that have not been looked up. */
17071 /* So are member templates of dependent classes. */
17075 }
17077 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
17079 bool
17081 {
17084 }
17086 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
17087 is dependent. */
17089 bool
17091 {
17098 {
17119 {
17123 }
17127 {
17131 {
17136 }
17137 }
17138 }
17141 }
17143 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
17144 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
17145 no such TYPE can be found. Note that this function peers inside
17146 uninstantiated templates and therefore should be used only in
17147 extremely limited situations. ONLY_CURRENT_P restricts this
17148 peering to the currently open classes hierarchy (which is required
17149 when comparing types). */
17151 tree
17153 {
17154 tree scope;
17155 tree name;
17156 tree decl;
17158 tree pushed_scope;
17159 tree result;
17164 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
17165 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
17166 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
17167 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
17168 identifier of the TYPENAME_TYPE anymore.
17169 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
17170 TYPENAME_TYPE instead, we avoid messing up with a possible
17171 typedef variant case. */
17174 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
17175 it first before we can figure out what NAME refers to. */
17178 /* If we don't know what SCOPE refers to, then we cannot resolve the
17179 TYPENAME_TYPE. */
17182 /* If the SCOPE is a template type parameter, we have no way of
17183 resolving the name. */
17186 /* If the SCOPE is not the current instantiation, there's no reason
17187 to look inside it. */
17190 /* If SCOPE isn't the template itself, it will not have a valid
17191 TYPE_FIELDS list. */
17193 /* scope is either the template itself or a compatible instantiation
17194 like X<T>, so look up the name in the original template. */
17196 else
17197 /* scope is a partial instantiation, so we can't do the lookup or we
17198 will lose the template arguments. */
17200 /* Enter the SCOPE so that name lookup will be resolved as if we
17201 were in the class definition. In particular, SCOPE will no
17202 longer be considered a dependent type. */
17204 /* Look up the declaration. */
17209 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
17210 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
17215 {
17219 }
17222 {
17223 tree tmpl;
17224 tree args;
17225 /* Obtain the template and the arguments. */
17228 /* Instantiate the template. */
17234 }
17236 /* Leave the SCOPE. */
17240 /* If we failed to resolve it, return the original typename. */
17244 /* If lookup found a typename type, resolve that too. */
17246 {
17247 /* Ill-formed programs can cause infinite recursion here, so we
17248 must catch that. */
17252 }
17254 /* Qualify the resulting type. */
17260 }
17262 /* EXPR is an expression which is not type-dependent. Return a proxy
17263 for EXPR that can be used to compute the types of larger
17264 expressions containing EXPR. */
17266 tree
17268 {
17269 tree inner_expr;
17271 /* Preserve null pointer constants so that the type of things like
17272 "p == 0" where "p" is a pointer can be determined. */
17275 /* Preserve OVERLOADs; the functions must be available to resolve
17276 types. */
17287 /* There is no need to return a proxy for a variable. */
17290 /* Preserve string constants; conversions from string constants to
17291 "char *" are allowed, even though normally a "const char *"
17292 cannot be used to initialize a "char *". */
17295 /* Preserve arithmetic constants, as an optimization -- there is no
17296 reason to create a new node. */
17299 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
17300 There is at least one place where we want to know that a
17301 particular expression is a throw-expression: when checking a ?:
17302 expression, there are special rules if the second or third
17303 argument is a throw-expression. */
17322 /* If the type is unknown, it can't really be non-dependent */
17325 /* Otherwise, build a NON_DEPENDENT_EXPR.
17327 REFERENCE_TYPEs are not stripped for expressions in templates
17328 because doing so would play havoc with mangling. Consider, for
17329 example:
17331 template <typename T> void f<T& g>() { g(); }
17333 In the body of "f", the expression for "g" will have
17334 REFERENCE_TYPE, even though the standard says that it should
17335 not. The reason is that we must preserve the syntactic form of
17336 the expression so that mangling (say) "f<g>" inside the body of
17337 "f" works out correctly. Therefore, the REFERENCE_TYPE is
17338 stripped here. */
17340 }
17342 /* ARGS is a vector of expressions as arguments to a function call.
17343 Replace the arguments with equivalent non-dependent expressions.
17344 This modifies ARGS in place. */
17346 void
17348 {
17350 tree arg;
17353 {
17357 }
17358 }
17360 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
17361 with a level one deeper than the actual template parms. */
17363 tree
17365 {
17366 tree au;
17368 /* ??? Is it worth caching this for multiple autos at the same level? */
17381 }
17383 /* Replace auto in TYPE with std::initializer_list<auto>. */
17385 static tree
17387 {
17388 tree std_init_list = namespace_binding
17390 tree argvec;
17391 tree init_auto;
17393 {
17397 }
17407 }
17409 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
17410 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
17412 tree
17414 {
17419 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
17420 with either a new invented type template parameter U or, if the
17421 initializer is a braced-init-list (8.5.4), with
17422 std::initializer_list<U>. */
17435 {
17438 }
17443 }
17445 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
17446 result. */
17448 tree
17450 {
17451 tree argvec;
17460 }
17462 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
17464 bool
17466 {
17470 else
17472 }
17474 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
17475 appear as a type-specifier for the declaration in question, we don't
17476 have to look through the whole type. */
17478 tree
17480 {
17497 }
17499 /* For a given template T, return the list of typedefs referenced
17500 in T for which access check is needed at T instantiation time.
17501 T is either a FUNCTION_DECL or a RECORD_TYPE.
17502 Those typedefs were added to T by the function
17503 append_type_to_template_for_access_check. */
17505 tree
17507 {
17518 {
17523 }
17526 }
17528 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
17529 tied to T. That list of typedefs will be access checked at
17530 T instantiation time.
17531 T is either a FUNCTION_DECL or a RECORD_TYPE.
17532 TYPE_DECL is a TYPE_DECL node representing a typedef.
17533 SCOPE is the scope through which TYPE_DECL is accessed.
17535 This function is a subroutine of
17536 append_type_to_template_for_access_check. */
17538 static void
17540 tree type_decl,
17541 tree scope)
17542 {
17543 tree ti;
17550 && type_decl
17561 }
17563 /* Append TYPE_DECL to the template TEMPL.
17564 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
17565 At TEMPL instanciation time, TYPE_DECL will be checked to see
17566 if it can be accessed through SCOPE.
17568 e.g. consider the following code snippet:
17570 class C
17571 {
17572 typedef int myint;
17573 };
17575 template<class U> struct S
17576 {
17577 C::myint mi;
17578 };
17580 S<char> s;
17582 At S<char> instantiation time, we need to check the access of C::myint
17583 In other words, we need to check the access of the myint typedef through
17584 the C scope. For that purpose, this function will add the myint typedef
17585 and the scope C through which its being accessed to a list of typedefs
17586 tied to the template S. That list will be walked at template instantiation
17587 time and access check performed on each typedefs it contains.
17588 Note that this particular code snippet should yield an error because
17589 myint is private to C. */
17591 void
17593 tree type_decl,
17594 tree scope)
17595 {
17596 tree node;
17600 /* Make sure we don't append the type to the template twice. */
17602 node;
17604 {
17610 }
17613 }
17615 /* Set up the hash tables for template instantiations. */
17617 void
17619 {
17621 hash_specialization,
17622 eq_specializations,
17623 ggc_free);
17625 hash_specialization,
17626 eq_specializations,
17627 ggc_free);
17628 }