| blob | d8147365fed2c09a7bba1b564a3f04fd96d56a0f |
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". */
51 /* The type of functions taking a tree, and some additional data, and
52 returning an int. */
55 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
56 instantiations have been deferred, either because their definitions
57 were not yet available, or because we were putting off doing the work. */
61 };
76 /* Live only within one (recursive) call to tsubst_expr. We use
77 this to pass the statement expression node from the STMT_EXPR
78 to the EXPR_STMT that is its result. */
81 /* A map from local variable declarations in the body of the template
82 presently being instantiated to the corresponding instantiated
83 local variables. */
87 {
88 tree tmpl;
89 tree args;
90 tree spec;
94 htab_t decl_specializations;
97 htab_t type_specializations;
99 /* Contains canonical template parameter types. The vector is indexed by
100 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
101 TREE_LIST, whose TREE_VALUEs contain the canonical template
102 parameters of various types and levels. */
105 #define UNIFY_ALLOW_NONE 0
106 #define UNIFY_ALLOW_MORE_CV_QUAL 1
107 #define UNIFY_ALLOW_LESS_CV_QUAL 2
108 #define UNIFY_ALLOW_DERIVED 4
109 #define UNIFY_ALLOW_INTEGER 8
110 #define UNIFY_ALLOW_OUTER_LEVEL 16
111 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
112 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
134 tree);
194 location_t);
199 /* Make the current scope suitable for access checking when we are
200 processing T. T can be FUNCTION_DECL for instantiated function
201 template, or VAR_DECL for static member variable (need by
202 instantiate_decl). */
204 static void
206 {
214 else
218 {
219 saved_access_scope = tree_cons
222 }
223 }
225 /* Restore the scope set up by push_access_scope. T is the node we
226 are processing. */
228 static void
230 {
232 {
235 }
239 else
241 }
243 /* Do any processing required when DECL (a member template
244 declaration) is finished. Returns the TEMPLATE_DECL corresponding
245 to DECL, unless it is a specialization, in which case the DECL
246 itself is returned. */
248 tree
250 {
257 {
258 tree type;
266 {
270 }
272 }
276 {
278 {
281 }
282 else
284 }
285 else
289 }
291 /* Create a template info node. */
293 tree
295 {
300 }
302 /* Return the template info node corresponding to T, whatever T is. */
304 tree
306 {
322 }
324 /* Returns the template nesting level of the indicated class TYPE.
326 For example, in:
327 template <class T>
328 struct A
329 {
330 template <class U>
331 struct B {};
332 };
334 A<T>::B<U> has depth two, while A<T> has depth one.
335 Both A<T>::B<int> and A<int>::B<U> have depth one, if
336 they are instantiations, not specializations.
338 This function is guaranteed to return 0 if passed NULL_TREE so
339 that, for example, `template_class_depth (current_class_type)' is
340 always safe. */
342 int
344 {
351 {
357 }
360 }
362 /* Subroutine of maybe_begin_member_template_processing.
363 Returns true if processing DECL needs us to push template parms. */
365 static bool
367 {
373 }
375 /* Subroutine of maybe_begin_member_template_processing.
376 Push the template parms in PARMS, starting from LEVELS steps into the
377 chain, and ending at the beginning, since template parms are listed
378 innermost first. */
380 static void
382 {
390 current_template_parms
396 NULL);
398 {
407 {
414 {
415 /* Make a CONST_DECL as is done in process_template_parm.
416 It is ugly that we recreate this here; the original
417 version built in process_template_parm is no longer
418 available. */
428 }
433 }
434 }
435 }
437 /* Restore the template parameter context for a member template or
438 a friend template defined in a class definition. */
440 void
442 {
443 tree parms;
447 {
452 {
455 }
458 }
460 /* Remember how many levels of template parameters we pushed so that
461 we can pop them later. */
463 }
465 /* Undo the effects of maybe_begin_member_template_processing. */
467 void
469 {
478 {
482 }
483 }
485 /* Return a new template argument vector which contains all of ARGS,
486 but has as its innermost set of arguments the EXTRA_ARGS. */
488 static tree
490 {
491 tree new_args;
506 }
508 /* Like add_to_template_args, but only the outermost ARGS are added to
509 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
510 (EXTRA_ARGS) levels are added. This function is used to combine
511 the template arguments from a partial instantiation with the
512 template arguments used to attain the full instantiation from the
513 partial instantiation. */
515 static tree
517 {
518 tree new_args;
520 /* If there are more levels of EXTRA_ARGS than there are ARGS,
521 something very fishy is going on. */
524 /* If *all* the new arguments will be the EXTRA_ARGS, just return
525 them. */
529 /* For the moment, we make ARGS look like it contains fewer levels. */
534 /* Now, we restore ARGS to its full dimensions. */
538 }
540 /* Return the N levels of innermost template arguments from the ARGS. */
542 tree
544 {
545 tree new_args;
551 /* If N is 1, just return the innermost set of template arguments. */
555 /* If we're not removing anything, just return the arguments we were
556 given. */
562 /* Make a new set of arguments, not containing the outer arguments. */
569 }
571 /* The inverse of get_innermost_template_args: Return all but the innermost
572 EXTRA_LEVELS levels of template arguments from the ARGS. */
574 static tree
576 {
577 tree new_args;
583 /* If N is 1, just return the outermost set of template arguments. */
587 /* If we're not removing anything, just return the arguments we were
588 given. */
593 /* Make a new set of arguments, not containing the inner arguments. */
600 }
602 /* We've got a template header coming up; push to a new level for storing
603 the parms. */
605 void
607 {
608 /* We use a non-tag-transparent scope here, which causes pushtag to
609 put tags in this scope, rather than in the enclosing class or
610 namespace scope. This is the right thing, since we want
611 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
612 global template class, push_template_decl handles putting the
613 TEMPLATE_DECL into top-level scope. For a nested template class,
614 e.g.:
616 template <class T> struct S1 {
617 template <class T> struct S2 {};
618 };
620 pushtag contains special code to call pushdecl_with_scope on the
621 TEMPLATE_DECL for S2. */
626 }
628 /* This routine is called when a specialization is declared. If it is
629 invalid to declare a specialization here, an error is reported and
630 false is returned, otherwise this routine will return true. */
632 static bool
634 {
637 /* [temp.expl.spec]
639 An explicit specialization shall be declared in the namespace of
640 which the template is a member, or, for member templates, in the
641 namespace of which the enclosing class or enclosing class
642 template is a member. An explicit specialization of a member
643 function, member class or static data member of a class template
644 shall be declared in the namespace of which the class template
645 is a member. */
647 {
650 }
652 /* [temp.expl.spec]
654 In an explicit specialization declaration for a member of a class
655 template or a member template that appears in namespace scope,
656 the member template and some of its enclosing class templates may
657 remain unspecialized, except that the declaration shall not
658 explicitly specialize a class member template if its enclosing
659 class templates are not explicitly specialized as well. */
661 {
664 }
667 }
669 /* We've just seen template <>. */
671 bool
673 {
677 }
679 /* Called at then end of processing a declaration preceded by
680 template<>. */
682 void
684 {
687 }
689 /* Any template <>'s that we have seen thus far are not referring to a
690 function specialization. */
692 void
694 {
697 }
699 /* We've just seen a template header. If SPECIALIZATION is nonzero,
700 it was of the form template <>. */
702 static void
704 {
706 template_header_count++;
707 }
709 /* We're beginning an explicit instantiation. */
711 void
713 {
716 }
719 void
721 {
724 }
726 /* An explicit specialization or partial specialization TMPL is being
727 declared. Check that the namespace in which the specialization is
728 occurring is permissible. Returns false iff it is invalid to
729 specialize TMPL in the current namespace. */
731 static bool
733 {
736 /* [tmpl.expl.spec]
738 An explicit specialization shall be declared in the namespace of
739 which the template is a member, or, for member templates, in the
740 namespace of which the enclosing class or enclosing class
741 template is a member. An explicit specialization of a member
742 function, member class or static data member of a class template
743 shall be declared in the namespace of which the class template is
744 a member. */
747 {
750 }
752 /* Same or super-using namespace. */
754 else
755 {
759 }
760 }
762 /* SPEC is an explicit instantiation. Check that it is valid to
763 perform this explicit instantiation in the current namespace. */
765 static void
767 {
768 tree ns;
770 /* DR 275: An explicit instantiation shall appear in an enclosing
771 namespace of its template. */
777 }
779 /* The TYPE is being declared. If it is a template type, that means it
780 is a partial specialization. Do appropriate error-checking. */
782 tree
784 {
785 tree context;
791 {
795 }
800 {
801 /* This is for ordinary explicit specialization and partial
802 specialization of a template class such as:
804 template <> class C<int>;
806 or:
808 template <class T> class C<T*>;
810 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
814 {
818 {
822 }
823 }
826 }
832 {
833 /* This is for an explicit specialization of member class
834 template according to [temp.expl.spec/18]:
836 template <> template <class U> class C<int>::D;
838 The context `C<int>' must be an implicit instantiation.
839 Otherwise this is just a member class template declared
840 earlier like:
842 template <> class C<int> { template <class U> class D; };
843 template <> template <class U> class C<int>::D;
845 In the first case, `C<int>::D' is a specialization of `C<T>::D'
846 while in the second case, `C<int>::D' is a primary template
847 and `C<T>::D' may not exist. */
851 {
852 tree t;
857 {
860 }
862 /* Check for invalid specialization after instantiation:
864 template <> template <> class C<int>::D<int>;
865 template <> template <class U> class C<int>::D; */
869 {
872 {
873 /* We already have a full specialization of this partial
874 instantiation. Reassign it to the new member
875 specialization template. */
876 spec_entry elt;
892 }
894 /* But if we've had an implicit instantiation, that's a
895 problem ([temp.expl.spec]/6). */
898 }
900 /* Mark TYPE as a specialization. And as a result, we only
901 have one level of template argument for the innermost
902 class template. */
906 }
907 }
909 {
912 }
915 }
917 /* Returns nonzero if we can optimize the retrieval of specializations
918 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
919 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
923 {
926 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
927 parameter. */
929 /* The optimized lookup depends on the fact that the
930 template arguments for the member function template apply
931 purely to the containing class, which is not true if the
932 containing class is an explicit or partial
933 specialization. */
937 /* It is possible to have a template that is not a member
938 template and is not a member of a template class:
940 template <typename T>
941 struct S { friend A::f(); };
943 Here, the friend function is a template, but the context does
944 not have template information. The optimized lookup relies
945 on having ARGS be the template arguments for both the class
946 and the function template. */
948 }
950 /* Retrieve the specialization (in the sense of [temp.spec] - a
951 specialization is either an instantiation or an explicit
952 specialization) of TMPL for the given template ARGS. If there is
953 no such specialization, return NULL_TREE. The ARGS are a vector of
954 arguments, or a vector of vectors of arguments, in the case of
955 templates with more than one level of parameters.
957 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
958 then we search for a partial specialization matching ARGS. This
959 parameter is ignored if TMPL is not a class template. */
961 static tree
963 {
969 /* There should be as many levels of arguments as there are
970 levels of parameters. */
975 {
976 tree class_template;
977 tree class_specialization;
979 tree fns;
982 /* The template arguments actually apply to the containing
983 class. Find the class specialization with those
984 arguments. */
986 class_specialization
990 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
991 for the specialization. */
995 /* Iterate through the methods with the indicated name, looking
996 for the one that has an instance of TMPL. */
999 {
1002 /* using-declarations can add base methods to the method vec,
1003 and we don't want those here. */
1006 }
1008 }
1009 else
1010 {
1012 spec_entry elt;
1013 htab_t specializations;
1021 else
1029 }
1032 }
1034 /* Like retrieve_specialization, but for local declarations. */
1036 static tree
1038 {
1039 tree spec;
1047 }
1049 /* Returns nonzero iff DECL is a specialization of TMPL. */
1051 int
1053 {
1054 tree t;
1057 {
1063 }
1064 else
1065 {
1074 }
1077 }
1079 /* Returns nonzero iff DECL is a specialization of friend declaration
1080 FRIEND_DECL according to [temp.friend]. */
1082 bool
1084 {
1091 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1092 of a template class, we want to check if DECL is a specialization
1093 if this. */
1097 {
1098 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1101 }
1106 /* There is nothing to do if this is not a template friend. */
1113 /* [temp.friend/6]
1114 A member of a class template may be declared to be a friend of a
1115 non-template class. In this case, the corresponding member of
1116 every specialization of the class template is a friend of the
1117 class granting friendship.
1119 For example, given a template friend declaration
1121 template <class T> friend void A<T>::f();
1123 the member function below is considered a friend
1125 template <> struct A<int> {
1126 void f();
1127 };
1129 For this type of template friend, TEMPLATE_DEPTH below will be
1130 nonzero. To determine if DECL is a friend of FRIEND, we first
1131 check if the enclosing class is a specialization of another. */
1138 {
1139 /* Next, we check the members themselves. In order to handle
1140 a few tricky cases, such as when FRIEND_DECL's are
1142 template <class T> friend void A<T>::g(T t);
1143 template <class T> template <T t> friend void A<T>::h();
1145 and DECL's are
1147 void A<int>::g(int);
1148 template <int> void A<int>::h();
1150 we need to figure out ARGS, the template arguments from
1151 the context of DECL. This is required for template substitution
1152 of `T' in the function parameter of `g' and template parameter
1153 of `h' in the above examples. Here ARGS corresponds to `int'. */
1160 {
1162 {
1165 else
1167 current_depth++;
1168 }
1170 }
1173 {
1175 tree friend_type;
1176 tree decl_type;
1177 tree friend_args_type;
1178 tree decl_args_type;
1180 /* Make sure that both DECL and FRIEND_DECL are templates or
1181 non-templates. */
1187 {
1188 /* If both are templates, check template parameter list. */
1189 tree friend_parms
1194 friend_parms))
1198 }
1199 else
1207 /* Check if return types match. */
1211 /* Check if function parameter types match, ignoring the
1212 `this' parameter. */
1221 }
1222 else
1223 {
1224 /* DECL is a TYPE_DECL */
1228 /* Make sure that both DECL and FRIEND_DECL are templates or
1229 non-templates. */
1230 is_template
1237 {
1238 tree friend_parms;
1239 /* If both are templates, check the name of the two
1240 TEMPLATE_DECL's first because is_friend didn't. */
1245 /* Now check template parameter list. */
1246 friend_parms
1249 return comp_template_parms
1251 friend_parms);
1252 }
1253 else
1256 }
1257 }
1259 }
1261 /* Register the specialization SPEC as a specialization of TMPL with
1262 the indicated ARGS. IS_FRIEND indicates whether the specialization
1263 is actually just a friend declaration. Returns SPEC, or an
1264 equivalent prior declaration, if available. */
1266 static tree
1268 hashval_t hash)
1269 {
1270 tree fn;
1272 spec_entry elt;
1278 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1279 register it; we want the corresponding TEMPLATE_DECL instead.
1280 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1281 the more obvious `uses_template_parms (spec)' to avoid problems
1282 with default function arguments. In particular, given
1283 something like this:
1285 template <class T> void f(T t1, T t = T())
1287 the default argument expression is not substituted for in an
1288 instantiation unless and until it is actually needed. */
1292 /* We don't put these specializations in the hash table, but we might
1293 want to give an error about a mismatch. */
1295 else
1296 {
1308 else
1310 }
1312 /* We can sometimes try to re-register a specialization that we've
1313 already got. In particular, regenerate_decl_from_template calls
1314 duplicate_decls which will update the specialization list. But,
1315 we'll still get called again here anyhow. It's more convenient
1316 to simply allow this than to try to prevent it. */
1320 {
1322 {
1325 {
1327 fn);
1329 }
1330 else
1331 {
1332 tree clone;
1333 /* This situation should occur only if the first
1334 specialization is an implicit instantiation, the
1335 second is an explicit specialization, and the
1336 implicit instantiation has not yet been used. That
1337 situation can occur if we have implicitly
1338 instantiated a member function and then specialized
1339 it later.
1341 We can also wind up here if a friend declaration that
1342 looked like an instantiation turns out to be a
1343 specialization:
1345 template <class T> void foo(T);
1346 class S { friend void foo<>(int) };
1347 template <> void foo(int);
1349 We transform the existing DECL in place so that any
1350 pointers to it become pointers to the updated
1351 declaration.
1353 If there was a definition for the template, but not
1354 for the specialization, we want this to look as if
1355 there were no definition, and vice versa. */
1358 /* The call to duplicate_decls will have applied
1359 [temp.expl.spec]:
1361 An explicit specialization of a function template
1362 is inline only if it is explicitly declared to be,
1363 and independently of whether its function template
1364 is.
1366 to the primary function; now copy the inline bits to
1367 the various clones. */
1369 {
1374 }
1378 }
1379 }
1381 {
1383 /* Dup decl failed, but this is a new definition. Set the
1384 line number so any errors match this new
1385 definition. */
1389 }
1390 }
1394 /* A specialization must be declared in the same namespace as the
1395 template it is specializing. */
1401 {
1408 /* TMPL is a forward declaration of a template function; keep a list
1409 of all specializations in case we need to reassign them to a friend
1410 template later in tsubst_friend_function. */
1413 }
1416 }
1418 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1419 TMPL and ARGS members, ignores SPEC. */
1421 static int
1423 {
1429 }
1431 /* Returns a hash for a template TMPL and template arguments ARGS. */
1433 static hashval_t
1435 {
1438 }
1440 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1441 ignoring SPEC. */
1443 static hashval_t
1445 {
1448 }
1450 /* Recursively calculate a hash value for a template argument ARG, for use
1451 in the hash tables of template specializations. */
1453 static hashval_t
1455 {
1467 /* We can get one of these when re-hashing a previous entry in the middle
1468 of substituting into a pack expansion. Just look through it. */
1477 {
1485 {
1490 }
1511 {
1514 {
1517 }
1519 }
1534 val = iterative_hash_template_arg
1546 val);
1548 val);
1557 /* layout_type sets structural equality for arrays of
1558 incomplete type, so we can't rely on the canonical type
1559 for hashing. */
1565 {
1569 val);
1572 /* Otherwise just compare the types during lookup. */
1581 {
1586 }
1587 }
1588 }
1591 }
1593 /* Unregister the specialization SPEC as a specialization of TMPL.
1594 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1595 if the SPEC was listed as a specialization of TMPL.
1597 Note that SPEC has been ggc_freed, so we can't look inside it. */
1599 bool
1601 {
1603 spec_entry elt;
1611 {
1616 }
1619 }
1621 /* Compare an entry in the local specializations hash table P1 (which
1622 is really a pointer to a TREE_LIST) with P2 (which is really a
1623 DECL). */
1625 static int
1627 {
1629 }
1631 /* Hash P1, an entry in the local specializations table. */
1633 static hashval_t
1635 {
1637 }
1639 /* Like register_specialization, but for local declarations. We are
1640 registering SPEC, an instantiation of TMPL. */
1642 static void
1644 {
1650 }
1652 /* TYPE is a class type. Returns true if TYPE is an explicitly
1653 specialized class. */
1655 bool
1657 {
1661 }
1663 /* Print the list of functions at FNS, going through all the overloads
1664 for each element of the list. Alternatively, FNS can not be a
1665 TREE_LIST, in which case it will be printed together with all the
1666 overloads.
1668 MORE and *STR should respectively be FALSE and NULL when the function
1669 is called from the outside. They are used internally on recursive
1670 calls. print_candidates manages the two parameters and leaves NULL
1671 in *STR when it ends. */
1673 static void
1675 {
1681 {
1686 }
1687 else
1688 {
1690 {
1691 /* Pick the prefix string. */
1693 {
1696 }
1700 }
1703 }
1706 {
1709 }
1710 }
1712 /* Print the list of candidate FNS in an error message. */
1714 void
1716 {
1720 }
1722 /* Returns the template (one of the functions given by TEMPLATE_ID)
1723 which can be specialized to match the indicated DECL with the
1724 explicit template args given in TEMPLATE_ID. The DECL may be
1725 NULL_TREE if none is available. In that case, the functions in
1726 TEMPLATE_ID are non-members.
1728 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1729 specialization of a member template.
1731 The TEMPLATE_COUNT is the number of references to qualifying
1732 template classes that appeared in the name of the function. See
1733 check_explicit_specialization for a more accurate description.
1735 TSK indicates what kind of template declaration (if any) is being
1736 declared. TSK_TEMPLATE indicates that the declaration given by
1737 DECL, though a FUNCTION_DECL, has template parameters, and is
1738 therefore a template function.
1740 The template args (those explicitly specified and those deduced)
1741 are output in a newly created vector *TARGS_OUT.
1743 If it is impossible to determine the result, an error message is
1744 issued. The error_mark_node is returned to indicate failure. */
1746 static tree
1748 tree decl,
1752 tmpl_spec_kind tsk)
1753 {
1754 tree fns;
1755 tree targs;
1756 tree explicit_targs;
1758 /* A TREE_LIST of templates of which DECL may be a specialization.
1759 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1760 corresponding TREE_PURPOSE is the set of template arguments that,
1761 when used to instantiate the template, would produce a function
1762 with the signature of DECL. */
1778 /* Check for baselinks. */
1783 {
1786 }
1788 /* Count the number of template headers specified for this
1789 specialization. */
1797 {
1801 {
1802 tree decl_arg_types;
1803 tree fn_arg_types;
1805 /* In case of explicit specialization, we need to check if
1806 the number of template headers appearing in the specialization
1807 is correct. This is usually done in check_explicit_specialization,
1808 but the check done there cannot be exhaustive when specializing
1809 member functions. Consider the following code:
1811 template <> void A<int>::f(int);
1812 template <> template <> void A<int>::f(int);
1814 Assuming that A<int> is not itself an explicit specialization
1815 already, the first line specializes "f" which is a non-template
1816 member function, whilst the second line specializes "f" which
1817 is a template member function. So both lines are syntactically
1818 correct, and check_explicit_specialization does not reject
1819 them.
1821 Here, we can do better, as we are matching the specialization
1822 against the declarations. We count the number of template
1823 headers, and we check if they match TEMPLATE_COUNT + 1
1824 (TEMPLATE_COUNT is the number of qualifying template classes,
1825 plus there must be another header for the member template
1826 itself).
1828 Notice that if header_count is zero, this is not a
1829 specialization but rather a template instantiation, so there
1830 is no check we can perform here. */
1834 /* Check that the number of template arguments at the
1835 innermost level for DECL is the same as for FN. */
1843 /* DECL might be a specialization of FN. */
1847 /* For a non-static member function, we need to make sure
1848 that the const qualification is the same. Since
1849 get_bindings does not try to merge the "this" parameter,
1850 we must do the comparison explicitly. */
1856 /* Skip the "this" parameter and, for constructors of
1857 classes with virtual bases, the VTT parameter. A
1858 full specialization of a constructor will have a VTT
1859 parameter, but a template never will. */
1860 decl_arg_types
1862 fn_arg_types
1865 /* Check that the number of function parameters matches.
1866 For example,
1867 template <class T> void f(int i = 0);
1868 template <> void f<int>();
1869 The specialization f<int> is invalid but is not caught
1870 by get_bindings below. */
1874 /* Function templates cannot be specializations; there are
1875 no partial specializations of functions. Therefore, if
1876 the type of DECL does not match FN, there is no
1877 match. */
1879 {
1883 }
1885 /* See whether this function might be a specialization of this
1886 template. */
1890 /* We cannot deduce template arguments that when used to
1891 specialize TMPL will produce DECL. */
1894 /* Save this template, and the arguments deduced. */
1896 }
1898 /* FN is an ordinary member function, and we need a
1899 specialization of a member template. */
1900 ;
1902 /* We can get IDENTIFIER_NODEs here in certain erroneous
1903 cases. */
1904 ;
1906 /* This is just an ordinary non-member function. Nothing can
1907 be a specialization of that. */
1908 ;
1910 /* Cannot specialize functions that are created implicitly. */
1911 ;
1912 else
1913 {
1914 tree decl_arg_types;
1916 /* This is an ordinary member function. However, since
1917 we're here, we can assume it's enclosing class is a
1918 template class. For example,
1920 template <typename T> struct S { void f(); };
1921 template <> void S<int>::f() {}
1923 Here, S<int>::f is a non-template, but S<int> is a
1924 template class. If FN has the same type as DECL, we
1925 might be in business. */
1928 /* Its enclosing class is an explicit specialization
1929 of a template class. This is not a candidate. */
1934 /* The return types differ. */
1937 /* Adjust the type of DECL in case FN is a static member. */
1944 decl_arg_types))
1945 /* They match! */
1947 }
1948 }
1951 {
1952 /* We have:
1954 [temp.expl.spec]
1956 It is possible for a specialization with a given function
1957 signature to be instantiated from more than one function
1958 template. In such cases, explicit specification of the
1959 template arguments must be used to uniquely identify the
1960 function template specialization being specialized.
1962 Note that here, there's no suggestion that we're supposed to
1963 determine which of the candidate templates is most
1964 specialized. However, we, also have:
1966 [temp.func.order]
1968 Partial ordering of overloaded function template
1969 declarations is used in the following contexts to select
1970 the function template to which a function template
1971 specialization refers:
1973 -- when an explicit specialization refers to a function
1974 template.
1976 So, we do use the partial ordering rules, at least for now.
1977 This extension can only serve to make invalid programs valid,
1978 so it's safe. And, there is strong anecdotal evidence that
1979 the committee intended the partial ordering rules to apply;
1980 the EDG front end has that behavior, and John Spicer claims
1981 that the committee simply forgot to delete the wording in
1982 [temp.expl.spec]. */
1985 {
1988 }
1989 }
1992 {
2000 }
2004 {
2010 }
2012 /* We have one, and exactly one, match. */
2014 {
2017 /* DECL is a re-declaration or partial instantiation of a template
2018 function. */
2021 /* It was a specialization of an ordinary member function in a
2022 template class. */
2024 }
2026 /* It was a specialization of a template. */
2029 {
2034 }
2035 else
2038 }
2040 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2041 but with the default argument values filled in from those in the
2042 TMPL_TYPES. */
2044 static tree
2046 tree tmpl_types)
2047 {
2048 tree new_spec_types;
2056 /* Substitute into the rest of the list. */
2057 new_spec_types =
2061 /* Add the default argument for this parameter. */
2064 new_spec_types);
2065 }
2067 /* DECL is an explicit specialization. Replicate default arguments
2068 from the template it specializes. (That way, code like:
2070 template <class T> void f(T = 3);
2071 template <> void f(double);
2072 void g () { f (); }
2074 works, as required.) An alternative approach would be to look up
2075 the correct default arguments at the call-site, but this approach
2076 is consistent with how implicit instantiations are handled. */
2078 static void
2080 {
2081 tree tmpl;
2082 tree spec_types;
2083 tree tmpl_types;
2084 tree new_spec_types;
2085 tree old_type;
2086 tree new_type;
2087 tree t;
2092 /* See if there's anything we need to do. */
2105 {
2106 /* Remove the this pointer, but remember the object's type for
2107 CV quals. */
2113 {
2114 /* DECL may contain more parameters than TMPL due to the extra
2115 in-charge parameter in constructors and destructors. */
2118 }
2120 {
2123 }
2124 }
2126 /* Compute the merged default arguments. */
2127 new_spec_types =
2130 /* Compute the new FUNCTION_TYPE. */
2132 {
2136 new_spec_types);
2139 /* Put the in-charge parameter back. */
2142 new_spec_types);
2146 new_spec_types);
2147 }
2148 else
2150 new_spec_types);
2156 }
2158 /* Check to see if the function just declared, as indicated in
2159 DECLARATOR, and in DECL, is a specialization of a function
2160 template. We may also discover that the declaration is an explicit
2161 instantiation at this point.
2163 Returns DECL, or an equivalent declaration that should be used
2164 instead if all goes well. Issues an error message if something is
2165 amiss. Returns error_mark_node if the error is not easily
2166 recoverable.
2168 FLAGS is a bitmask consisting of the following flags:
2170 2: The function has a definition.
2171 4: The function is a friend.
2173 The TEMPLATE_COUNT is the number of references to qualifying
2174 template classes that appeared in the name of the function. For
2175 example, in
2177 template <class T> struct S { void f(); };
2178 void S<int>::f();
2180 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2181 classes are not counted in the TEMPLATE_COUNT, so that in
2183 template <class T> struct S {};
2184 template <> struct S<int> { void f(); }
2185 template <> void S<int>::f();
2187 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2188 invalid; there should be no template <>.)
2190 If the function is a specialization, it is marked as such via
2191 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2192 is set up correctly, and it is added to the list of specializations
2193 for that template. */
2195 tree
2197 tree decl,
2200 {
2208 tmpl_spec_kind tsk;
2211 {
2214 else
2216 }
2217 else
2221 {
2224 {
2227 }
2229 {
2231 /* This could be something like:
2233 template <class T> void f(T);
2234 class S { friend void f<>(int); } */
2236 else
2237 {
2238 /* This case handles bogus declarations like template <>
2239 template <class T> void f<int>(); */
2242 declarator);
2244 }
2245 }
2249 /* The error has already been reported in
2250 check_specialization_scope. */
2256 /* Fall through. */
2269 decl);
2272 else
2276 /* Fall through. */
2281 else
2287 {
2288 /* This case handles bogus declarations like template <>
2289 template <class T> void f<int>(); */
2294 else
2296 declarator);
2298 }
2301 /* This is a specialization of a member template, without
2302 specialization the containing class. Something like:
2304 template <class T> struct S {
2305 template <class U> void f (U);
2306 };
2307 template <> template <class U> void S<int>::f(U) {}
2309 That's a specialization -- but of the entire template. */
2315 }
2318 {
2322 {
2326 }
2327 }
2330 {
2334 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2336 {
2337 tree fns;
2342 else
2343 {
2344 /* If there is no class context, the explicit instantiation
2345 must be at namespace scope. */
2348 /* Find the namespace binding, using the declaration
2349 context. */
2353 {
2356 }
2357 else
2358 {
2364 }
2365 }
2368 }
2374 {
2376 /* A specialization in class scope. This is invalid,
2377 but the error will already have been flagged by
2378 check_specialization_scope. */
2380 else
2381 {
2382 /* It's not valid to write an explicit instantiation in
2383 class scope, e.g.:
2385 class C { template void f(); }
2387 This case is caught by the parser. However, on
2388 something like:
2390 template class C { void f(); };
2392 (which is invalid) we can get here. The error will be
2393 issued later. */
2394 ;
2395 }
2398 }
2401 IDENTIFIER_NODE))
2402 {
2403 /* Find the list of functions in ctype that have the same
2404 name as the declared function. */
2410 {
2415 {
2416 /* From [temp.expl.spec]:
2418 If such an explicit specialization for the member
2419 of a class template names an implicitly-declared
2420 special member function (clause _special_), the
2421 program is ill-formed.
2423 Similar language is found in [temp.explicit]. */
2426 }
2429 }
2432 {
2436 }
2437 else
2438 {
2440 tree ovl;
2442 /* For a type-conversion operator, we cannot do a
2443 name-based lookup. We might be looking for `operator
2444 int' which will be a specialization of `operator T'.
2445 So, we find *all* the conversion operators, and then
2446 select from them. */
2454 {
2456 /* There are no more conversion functions. */
2459 /* Glue all these conversion functions together
2460 with those we already have. */
2463 }
2464 }
2467 {
2470 }
2471 else
2473 }
2475 /* Figure out what exactly is being specialized at this point.
2476 Note that for an explicit instantiation, even one for a
2477 member function, we cannot tell apriori whether the
2478 instantiation is for a member template, or just a member
2479 function of a template class. Even if a member template is
2480 being instantiated, the member template arguments may be
2481 elided if they can be deduced from the rest of the
2482 declaration. */
2485 member_specialization,
2486 template_count,
2487 tsk);
2490 /* We couldn't figure out what this declaration was
2491 specializing. */
2493 else
2494 {
2498 {
2499 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2500 is done by do_decl_instantiation later. */
2506 {
2507 /* If TMPL is not the most general template (for
2508 example, if TMPL is a friend template that is
2509 injected into namespace scope), then there will
2510 be too many levels of TARGS. Remove some of them
2511 here. */
2513 tree new_targs;
2520 }
2523 }
2525 /* If we thought that the DECL was a member function, but it
2526 turns out to be specializing a static member function,
2527 make DECL a static member function as well. */
2532 /* If this is a specialization of a member template of a
2533 template class, we want to return the TEMPLATE_DECL, not
2534 the specialization of it. */
2536 {
2541 {
2542 tree parm;
2546 /* We want to use the argument list specified in the
2547 definition, not in the original declaration. */
2552 }
2555 }
2557 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2560 /* Inherit default function arguments from the template
2561 DECL is specializing. */
2564 /* This specialization has the same protection as the
2565 template it specializes. */
2569 /* 7.1.1-1 [dcl.stc]
2571 A storage-class-specifier shall not be specified in an
2572 explicit specialization...
2574 The parser rejects these, so unless action is taken here,
2575 explicit function specializations will always appear with
2576 global linkage.
2578 The action recommended by the C++ CWG in response to C++
2579 defect report 605 is to make the storage class and linkage
2580 of the explicit specialization match the templated function:
2582 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2583 */
2585 {
2589 /* This specialization has the same linkage and visibility as
2590 the function template it specializes. */
2593 {
2596 }
2599 {
2602 }
2603 }
2605 /* If DECL is a friend declaration, declared using an
2606 unqualified name, the namespace associated with DECL may
2607 have been set incorrectly. For example, in:
2609 template <typename T> void f(T);
2610 namespace N {
2611 struct S { friend void f<int>(int); }
2612 }
2614 we will have set the DECL_CONTEXT for the friend
2615 declaration to N, rather than to the global namespace. */
2620 /* This is not really a declaration of a specialization.
2621 It's just the name of an instantiation. But, it's not
2622 a request for an instantiation, either. */
2625 /* This is indeed a specialization. In case of constructors
2626 and destructors, we need in-charge and not-in-charge
2627 versions in V3 ABI. */
2630 /* Register this specialization so that we can find it
2631 again. */
2633 }
2634 }
2637 }
2639 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2640 parameters. These are represented in the same format used for
2641 DECL_TEMPLATE_PARMS. */
2643 int
2645 {
2646 const_tree p1;
2647 const_tree p2;
2655 {
2667 {
2671 /* If either of the template parameters are invalid, assume
2672 they match for the sake of error recovery. */
2685 }
2686 }
2689 /* One set of parameters has more parameters lists than the
2690 other. */
2694 }
2696 /* Determine whether PARM is a parameter pack. */
2698 bool
2700 {
2701 /* Determine if we have a non-type template parameter pack. */
2706 /* If this is a list of template parameters, we could get a
2707 TYPE_DECL or a TEMPLATE_DECL. */
2714 }
2716 /* Determine if T is a function parameter pack. */
2718 bool
2720 {
2724 }
2726 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2727 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2729 tree
2731 {
2738 }
2740 /* Return true iff the function parameter PARAM_DECL was expanded
2741 from the function parameter pack PACK. */
2743 bool
2745 {
2750 /* The parameter pack and its pack arguments have the same
2751 DECL_PARM_INDEX. */
2753 }
2755 /* Determine whether ARGS describes a variadic template args list,
2756 i.e., one that is terminated by a template argument pack. */
2758 static bool
2760 {
2762 tree last_parm;
2776 }
2778 /* Generate a new name for the parameter pack name NAME (an
2779 IDENTIFIER_NODE) that incorporates its */
2781 static tree
2783 {
2784 /* Munge the name to include the parameter index. */
2785 #define NUMBUF_LEN 128
2797 }
2799 /* Return true if T is a primary function
2800 or class template instantiation. */
2802 bool
2804 {
2816 }
2818 /* Return true if PARM is a template template parameter. */
2820 bool
2822 {
2824 }
2826 /* Return the template parameters of T if T is a
2827 primary template instantiation, NULL otherwise. */
2829 tree
2831 {
2836 parms = INNERMOST_TEMPLATE_PARMS
2840 }
2842 /* Returns the template arguments of T if T is a template instantiation,
2843 NULL otherwise. */
2845 tree
2847 {
2855 }
2857 /* Return the argument pack elements of T if T is a template argument pack,
2858 NULL otherwise. */
2860 tree
2862 {
2868 }
2870 /* Structure used to track the progress of find_parameter_packs_r. */
2871 struct find_parameter_pack_data
2872 {
2873 /* TREE_LIST that will contain all of the parameter packs found by
2874 the traversal. */
2877 /* Set of AST nodes that have been visited by the traversal. */
2879 };
2881 /* Identifies all of the argument packs that occur in a template
2882 argument and appends them to the TREE_LIST inside DATA, which is a
2883 find_parameter_pack_data structure. This is a subroutine of
2884 make_pack_expansion and uses_parameter_packs. */
2885 static tree
2887 {
2893 /* Identify whether this is a parameter pack or not. */
2895 {
2909 {
2910 /* We don't want to walk into the type of a PARM_DECL,
2911 because we don't want to see the type parameter pack. */
2914 }
2918 /* Not a parameter pack. */
2920 }
2923 {
2924 /* Add this parameter pack to the list. */
2926 }
2932 /* This switch statement will return immediately if we don't find a
2933 parameter pack. */
2935 {
2940 /* Check the template itself. */
2943 /* Check the template arguments. */
2959 /* Fall through. */
3000 }
3003 }
3005 /* Determines if the expression or type T uses any parameter packs. */
3006 bool
3008 {
3016 }
3018 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3019 representation a base-class initializer into a parameter pack
3020 expansion. If all goes well, the resulting node will be an
3021 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3022 respectively. */
3023 tree
3025 {
3026 tree result;
3035 {
3036 /* The only time we will see a TREE_LIST here is for a base
3037 class initializer. In this case, the TREE_PURPOSE will be a
3038 _TYPE node (representing the base class expansion we're
3039 initializing) and the TREE_VALUE will be a TREE_LIST
3040 containing the initialization arguments.
3042 The resulting expansion looks somewhat different from most
3043 expansions. Rather than returning just one _EXPANSION, we
3044 return a TREE_LIST whose TREE_PURPOSE is a
3045 TYPE_PACK_EXPANSION containing the bases that will be
3046 initialized. The TREE_VALUE will be identical to the
3047 original TREE_VALUE, which is a list of arguments that will
3048 be passed to each base. We do not introduce any new pack
3049 expansion nodes into the TREE_VALUE (although it is possible
3050 that some already exist), because the TREE_PURPOSE and
3051 TREE_VALUE all need to be expanded together with the same
3052 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3053 resulting TREE_PURPOSE will mention the parameter packs in
3054 both the bases and the arguments to the bases. */
3055 tree purpose;
3056 tree value;
3059 /* Determine which parameter packs will be used by the base
3060 class expansion. */
3067 {
3071 }
3074 {
3075 /* Collect the sets of parameter packs used in each of the
3076 initialization arguments. */
3078 {
3079 /* Determine which parameter packs will be expanded in this
3080 argument. */
3083 }
3084 }
3088 /* Create the pack expansion type for the base type. */
3093 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3094 they will rarely be compared to anything. */
3098 }
3103 /* Build the PACK_EXPANSION_* node. */
3104 result = for_types
3109 {
3110 /* Propagate type and const-expression information. */
3113 }
3114 else
3115 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3116 they will rarely be compared to anything. */
3119 /* Determine which parameter packs will be expanded. */
3125 /* Make sure we found some parameter packs. */
3127 {
3130 else
3133 }
3137 }
3139 /* Checks T for any "bare" parameter packs, which have not yet been
3140 expanded, and issues an error if any are found. This operation can
3141 only be done on full expressions or types (e.g., an expression
3142 statement, "if" condition, etc.), because we could have expressions like:
3144 foo(f(g(h(args)))...)
3146 where "args" is a parameter pack. check_for_bare_parameter_packs
3147 should not be called for the subexpressions args, h(args),
3148 g(h(args)), or f(g(h(args))), because we would produce erroneous
3149 error messages.
3151 Returns TRUE and emits an error if there were bare parameter packs,
3152 returns FALSE otherwise. */
3153 bool
3155 {
3171 {
3174 {
3183 else
3188 else
3192 }
3195 }
3198 }
3200 /* Expand any parameter packs that occur in the template arguments in
3201 ARGS. */
3202 tree
3204 {
3209 /* First, determine if we need to expand anything, and the number of
3210 slots we'll need. */
3212 {
3217 {
3221 else
3223 }
3224 else
3225 {
3227 num_result_args++;
3228 }
3229 }
3231 /* If no expansion is necessary, we're done. */
3235 /* Expand arguments. */
3238 {
3241 {
3246 }
3247 else
3248 {
3251 }
3252 }
3255 }
3257 /* Checks if DECL shadows a template parameter.
3259 [temp.local]: A template-parameter shall not be redeclared within its
3260 scope (including nested scopes).
3262 Emits an error and returns TRUE if the DECL shadows a parameter,
3263 returns FALSE otherwise. */
3265 bool
3267 {
3268 tree olddecl;
3270 /* If we're not in a template, we can't possibly shadow a template
3271 parameter. */
3275 /* Figure out what we're shadowing. */
3280 /* If there's no previous binding for this name, we're not shadowing
3281 anything, let alone a template parameter. */
3285 /* If we're not shadowing a template parameter, we're done. Note
3286 that OLDDECL might be an OVERLOAD (or perhaps even an
3287 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3288 node. */
3292 /* We check for decl != olddecl to avoid bogus errors for using a
3293 name inside a class. We check TPFI to avoid duplicate errors for
3294 inline member templates. */
3302 }
3304 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3305 ORIG_LEVEL, DECL, and TYPE. */
3307 static tree
3311 tree decl,
3312 tree type)
3313 {
3324 }
3326 /* Find the canonical type parameter for the given template type
3327 parameter. Returns the canonical type parameter, which may be TYPE
3328 if no such parameter existed. */
3329 static tree
3331 {
3332 tree list;
3346 else
3347 {
3352 }
3353 }
3355 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3356 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3357 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3358 new one is created. */
3360 static tree
3362 tsubst_flags_t complain)
3363 {
3368 {
3387 /* Template template parameters need this. */
3392 }
3395 }
3397 /* Process information from new template parameter PARM and append it to the
3398 LIST being built. This new parameter is a non-type parameter iff
3399 IS_NON_TYPE is true. This new parameter is a parameter
3400 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3401 PARM_LOC. */
3403 tree
3406 {
3408 tree defval;
3409 tree err_parm_list;
3416 {
3420 {
3424 else
3426 }
3429 }
3430 else
3434 {
3440 {
3444 }
3445 else
3446 {
3447 /* [temp.param]
3449 The top-level cv-qualifiers on the template-parameter are
3450 ignored when determining its type. */
3453 {
3457 }
3460 {
3461 /* This template parameter is not a parameter pack, but it
3462 should be. Complain about "bare" parameter packs. */
3465 /* Recover by calling this a parameter pack. */
3467 }
3468 }
3470 /* A template parameter is not modifiable. */
3479 processing_template_decl,
3484 }
3485 else
3486 {
3487 tree t;
3491 {
3493 /* This is for distinguishing between real templates and template
3494 template parameters */
3498 }
3499 else
3500 {
3502 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3505 }
3512 processing_template_decl,
3516 }
3522 }
3524 /* The end of a template parameter list has been reached. Process the
3525 tree list into a parameter vector, converting each parameter into a more
3526 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3527 as PARM_DECLs. */
3529 tree
3531 {
3536 current_template_parms
3541 {
3545 }
3550 }
3552 /* end_template_decl is called after a template declaration is seen. */
3554 void
3556 {
3562 /* This matches the pushlevel in begin_template_parm_list. */
3567 }
3569 /* Within the declaration of a template, return all levels of template
3570 parameters that apply. The template parameters are represented as
3571 a TREE_VEC, in the form documented in cp-tree.h for template
3572 arguments. */
3574 static tree
3576 {
3577 tree header;
3582 /* If there is only one level of template parameters, we do not
3583 create a TREE_VEC of TREE_VECs. Instead, we return a single
3584 TREE_VEC containing the arguments. */
3589 {
3595 {
3598 /* T will be a list if we are called from within a
3599 begin/end_template_parm_list pair, but a vector directly
3600 if within a begin/end_member_template_processing pair. */
3602 {
3606 {
3609 {
3613 {
3614 /* Turn this argument into a TYPE_ARGUMENT_PACK
3615 with a single element, which expands T. */
3621 }
3622 }
3623 else
3624 {
3628 {
3629 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3630 with a single element, which expands T. */
3638 }
3639 }
3641 }
3642 }
3643 }
3647 else
3649 }
3652 }
3654 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3655 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3656 a member template. Used by push_template_decl below. */
3658 static tree
3660 {
3667 }
3669 struct template_parm_data
3670 {
3671 /* The level of the template parameters we are currently
3672 processing. */
3675 /* The index of the specialization argument we are currently
3676 processing. */
3679 /* An array whose size is the number of template parameters. The
3680 elements are nonzero if the parameter has been used in any one
3681 of the arguments processed so far. */
3684 /* An array whose size is the number of template arguments. The
3685 elements are nonzero if the argument makes use of template
3686 parameters of this level. */
3688 };
3690 /* Subroutine of push_template_decl used to see if each template
3691 parameter in a partial specialization is used in the explicit
3692 argument list. If T is of the LEVEL given in DATA (which is
3693 treated as a template_parm_data*), then DATA->PARMS is marked
3694 appropriately. */
3696 static int
3698 {
3704 {
3707 }
3708 else
3709 {
3712 }
3715 {
3718 }
3720 /* Return zero so that for_each_template_parm will continue the
3721 traversal of the tree; we want to mark *every* template parm. */
3723 }
3725 /* Process the partial specialization DECL. */
3727 static tree
3729 {
3735 tree inner_parms;
3748 /* We check that each of the template parameters given in the
3749 partial specialization is used in the argument list to the
3750 specialization. For example:
3752 template <class T> struct S;
3753 template <class T> struct S<T*>;
3755 The second declaration is OK because `T*' uses the template
3756 parameter T, whereas
3758 template <class T> struct S<int>;
3760 is no good. Even trickier is:
3762 template <class T>
3763 struct S1
3764 {
3765 template <class U>
3766 struct S2;
3767 template <class U>
3768 struct S2<T>;
3769 };
3771 The S2<T> declaration is actually invalid; it is a
3772 full-specialization. Of course,
3774 template <class U>
3775 struct S2<T (*)(U)>;
3777 or some such would have been OK. */
3785 {
3790 NULL,
3792 }
3795 {
3796 /* One of the template parms was not used in the
3797 specialization. */
3799 {
3802 }
3805 }
3807 /* [temp.class.spec]
3809 The argument list of the specialization shall not be identical to
3810 the implicit argument list of the primary template. */
3817 /* [temp.class.spec]
3819 A partially specialized non-type argument expression shall not
3820 involve template parameters of the partial specialization except
3821 when the argument expression is a simple identifier.
3823 The type of a template parameter corresponding to a specialized
3824 non-type argument shall not be dependent on a parameter of the
3825 specialization.
3827 Also, we verify that pack expansions only occur at the
3828 end of the argument list. */
3832 {
3839 {
3840 /* Extract the arguments from the argument pack. We'll be
3841 iterating over these in the following loop. */
3844 }
3847 {
3849 /* Get the Jth argument in the parameter pack. */
3853 {
3854 /* Pack expansions must come at the end of the
3855 argument list. */
3858 {
3862 else
3865 }
3866 }
3869 /* We only care about the pattern. */
3875 /* This next line is the `argument expression is not just a
3876 simple identifier' condition and also the `specialized
3877 non-type argument' bit. */
3879 {
3883 arg);
3884 else
3885 {
3886 /* Look at the corresponding template parameter,
3887 marking which template parameters its type depends
3888 upon. */
3892 {
3893 /* We haven't yet initialized TPD2. Do so now. */
3894 tpd2.arg_uses_template_parms
3896 /* The number of parameters here is the number in the
3897 main template, which, as checked in the assertion
3898 above, is NARGS. */
3902 }
3904 /* Mark the template parameters. But this time, we're
3905 looking for the template parameters of the main
3906 template, not in the specialization. */
3913 NULL,
3917 {
3918 /* The type depended on some template parameters.
3919 If they are fully specialized in the
3920 specialization, that's OK. */
3925 {
3928 type,
3929 arg);
3931 }
3932 }
3933 }
3934 }
3935 }
3936 }
3938 /* We should only get here once. */
3946 }
3948 /* Check that a template declaration's use of default arguments and
3949 parameter packs is not invalid. Here, PARMS are the template
3950 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3951 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3952 specialization.
3955 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3956 declaration (but not a definition); 1 indicates a declaration, 2
3957 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3958 emitted for extraneous default arguments.
3960 Returns TRUE if there were no errors found, FALSE otherwise. */
3962 bool
3965 {
3968 tree parm_level;
3971 /* [temp.param]
3973 A default template-argument shall not be specified in a
3974 function template declaration or a function template definition, nor
3975 in the template-parameter-list of the definition of a member of a
3976 class template. */
3979 /* You can't have a function template declaration in a local
3980 scope, nor you can you define a member of a class template in a
3981 local scope. */
3988 /* If this is either a friend defined in the scope of the class
3989 or a member function. */
3995 /* And, if it was a member function, it really was defined in
3996 the scope of the class. */
3999 /* We already checked these parameters when the template was
4000 declared, so there's no need to do it again now. This function
4001 was defined in class scope, but we're processing it's body now
4002 that the class is complete. */
4005 /* Core issue 226 (C++0x only): the following only applies to class
4006 templates. */
4008 {
4009 /* [temp.param]
4011 If a template-parameter has a default template-argument, all
4012 subsequent template-parameters shall have a default
4013 template-argument supplied. */
4015 {
4022 {
4032 {
4034 /* For better subsequent error-recovery, we indicate that
4035 there should have been a default argument. */
4038 }
4040 && !is_partial
4041 && !is_friend_decl
4042 /* Don't complain about an enclosing partial
4043 specialization. */
4048 {
4049 /* A primary class template can only have one
4050 parameter pack, at the end of the template
4051 parameter list. */
4056 else
4064 }
4065 }
4066 }
4067 }
4070 || is_partial
4071 || !is_primary
4073 /* For an ordinary class template, default template arguments are
4074 allowed at the innermost level, e.g.:
4075 template <class T = int>
4076 struct S {};
4077 but, in a partial specialization, they're not allowed even
4078 there, as we have in [temp.class.spec]:
4080 The template parameter list of a specialization shall not
4081 contain default template argument values.
4083 So, for a partial specialization, or for a function template
4084 (in C++98/C++03), we look at all of them. */
4085 ;
4086 else
4087 /* But, for a primary class template that is not a partial
4088 specialization we look at all template parameters except the
4089 innermost ones. */
4092 /* Figure out what error message to issue. */
4102 else
4106 /* If we're inside a class definition, there's no need to
4107 examine the parameters to the class itself. On the one
4108 hand, they will be checked when the class is defined, and,
4109 on the other, default arguments are valid in things like:
4110 template <class T = double>
4111 struct S { template <class U> void f(U); };
4112 Here the default argument for `S' has no bearing on the
4113 declaration of `f'. */
4115 else
4116 /* Check everything. */
4122 {
4129 {
4134 {
4136 {
4143 }
4145 /* Clear out the default argument so that we are not
4146 confused later. */
4148 }
4149 }
4151 /* At this point, if we're still interested in issuing messages,
4152 they must apply to classes surrounding the object declared. */
4155 }
4158 }
4160 /* Worker for push_template_decl_real, called via
4161 for_each_template_parm. DATA is really an int, indicating the
4162 level of the parameters we are interested in. If T is a template
4163 parameter of that level, return nonzero. */
4165 static int
4167 {
4173 else
4176 }
4178 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4179 parameters given by current_template_args, or reuses a
4180 previously existing one, if appropriate. Returns the DECL, or an
4181 equivalent one, if it is replaced via a call to duplicate_decls.
4183 If IS_FRIEND is true, DECL is a friend declaration. */
4185 tree
4187 {
4188 tree tmpl;
4189 tree args;
4190 tree info;
4191 tree ctx;
4195 /* True if the template is a member template, in the sense of
4196 [temp.mem]. */
4202 /* See if this is a partial specialization. */
4211 /* For a friend, we want the context of the friend function, not
4212 the type of which it is a friend. */
4216 /* In the case of a virtual function, we want the class in which
4217 it is defined. */
4219 else
4220 /* Otherwise, if we're currently defining some class, the DECL
4221 is assumed to be a member of the class. */
4230 /* See if this is a primary template. */
4232 /* A friend template that specifies a class context, i.e.
4233 template <typename T> friend void A<T>::f();
4234 is not primary. */
4236 else
4240 {
4245 {
4248 }
4250 {
4252 {
4253 /* [temp.mem]
4255 A destructor shall not be a member template. */
4258 }
4265 {
4266 /* [basic.stc.dynamic.allocation]
4268 An allocation function can be a function
4269 template. ... Template allocation functions shall
4270 have two or more parameters. */
4273 }
4274 }
4278 else
4279 {
4282 }
4283 }
4285 /* Check to see that the rules regarding the use of default
4286 arguments are not being violated. */
4290 /* Ensure that there are no parameter packs in the type of this
4291 declaration that have not been expanded. */
4293 {
4294 /* Check each of the arguments individually to see if there are
4295 any bare parameter packs. */
4301 {
4304 {
4305 /* This is a PARM_DECL that contains unexpanded parameter
4306 packs. We have already complained about this in the
4307 check_for_bare_parameter_packs call, so just replace
4308 these types with ERROR_MARK_NODE. */
4311 }
4315 }
4317 /* Check for bare parameter packs in the return type and the
4318 exception specifiers. */
4320 /* Errors were already issued, set return type to int
4321 as the frontend doesn't expect error_mark_node as
4322 the return type. */
4326 }
4328 {
4331 }
4342 {
4347 /* If DECL is a TYPE_DECL for a class-template, then there won't
4348 be DECL_LANG_SPECIFIC. The information equivalent to
4349 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4353 {
4354 /* Since a template declaration already existed for this
4355 class-type, we must be redeclaring it here. Make sure
4356 that the redeclaration is valid. */
4358 current_template_parms);
4359 /* We don't need to create a new TEMPLATE_DECL; just use the
4360 one we already had. */
4362 }
4363 else
4364 {
4366 member_template_p);
4371 {
4372 /* A specialization of a member template of a template
4373 class. */
4377 }
4378 }
4379 }
4380 else
4381 {
4387 {
4390 }
4398 {
4399 tree new_tmpl;
4401 /* The declaration is a specialization of a member
4402 template, declared outside the class. Therefore, the
4403 innermost template arguments will be NULL, so we
4404 replace them with the arguments determined by the
4405 earlier call to check_explicit_specialization. */
4408 new_tmpl
4410 member_template_p);
4420 args,
4423 }
4425 /* Make sure the template headers we got make sense. */
4430 {
4433 }
4434 else
4436 {
4441 {
4445 else
4450 }
4454 else
4458 }
4460 /* Check that the parms are used in the appropriate qualifying scopes
4461 in the declarator. */
4465 {
4471 /* Avoid crash in import_export_decl. */
4474 }
4475 }
4480 /* Push template declarations for global functions and types. Note
4481 that we do not try to push a global template friend declared in a
4482 template class; such a thing may well depend on the template
4483 parameters of the class. */
4486 {
4491 /* Hide template friend classes that haven't been declared yet. */
4493 {
4496 }
4497 }
4500 {
4506 {
4509 /* It is a conversion operator. See if the type converted to
4510 depends on innermost template operands. */
4513 depth))
4515 }
4517 /* Give template template parms a DECL_CONTEXT of the template
4518 for which they are a parameter. */
4521 {
4528 }
4529 }
4531 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4532 back to its most general template. If TMPL is a specialization,
4533 ARGS may only have the innermost set of arguments. Add the missing
4534 argument levels if necessary. */
4546 }
4548 tree
4550 {
4552 }
4554 /* Called when a class template TYPE is redeclared with the indicated
4555 template PARMS, e.g.:
4557 template <class T> struct S;
4558 template <class T> struct S {}; */
4560 bool
4562 {
4563 tree tmpl;
4564 tree tmpl_parms;
4568 {
4571 }
4575 /* The type is nested in some template class. Nothing to worry
4576 about here; there are no new template parameters for the nested
4577 type. */
4581 {
4583 tmpl);
4585 }
4591 {
4597 }
4600 {
4601 tree tmpl_parm;
4602 tree parm;
4603 tree tmpl_default;
4604 tree parm_default;
4615 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4616 TEMPLATE_DECL. */
4627 {
4631 }
4634 {
4635 /* We have in [temp.param]:
4637 A template-parameter may not be given default arguments
4638 by two different declarations in the same scope. */
4643 }
4646 /* Update the previous template parameters (which are the ones
4647 that will really count) with the new default value. */
4650 /* Update the new parameters, too; they'll be used as the
4651 parameters for any members. */
4653 }
4656 }
4658 /* Simplify EXPR if it is a non-dependent expression. Returns the
4659 (possibly simplified) expression. */
4661 tree
4663 {
4667 /* If we're in a template, but EXPR isn't value dependent, simplify
4668 it. We're supposed to treat:
4670 template <typename T> void f(T[1 + 1]);
4671 template <typename T> void f(T[2]);
4673 as two declarations of the same function, for example. */
4677 {
4678 HOST_WIDE_INT saved_processing_template_decl;
4684 tf_error,
4689 }
4691 }
4693 /* EXPR is an expression which is used in a constant-expression context.
4694 For instance, it could be a VAR_DECL with a constant initializer.
4695 Extract the innermost constant expression.
4697 This is basically a more powerful version of
4698 integral_constant_value, which can be used also in templates where
4699 initializers can maintain a syntactic rather than semantic form
4700 (even if they are non-dependent, for access-checking purposes). */
4702 static tree
4704 {
4706 do
4707 {
4710 }
4714 }
4716 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4717 must be a function or a pointer-to-function type, as specified
4718 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4719 and check that the resulting function has external linkage. */
4721 static tree
4723 {
4737 /* [temp.arg.nontype]/1
4739 A template-argument for a non-type, non-template template-parameter
4740 shall be one of:
4741 [...]
4742 -- the address of an object or function with external linkage. */
4744 {
4749 }
4752 }
4754 /* Subroutine of convert_nontype_argument.
4755 Check if EXPR of type TYPE is a valid pointer-to-member constant.
4756 Emit an error otherwise. */
4758 static bool
4760 {
4768 }
4770 /* Attempt to convert the non-type template parameter EXPR to the
4771 indicated TYPE. If the conversion is successful, return the
4772 converted value. If the conversion is unsuccessful, return
4773 NULL_TREE if we issued an error message, or error_mark_node if we
4774 did not. We issue error messages for out-and-out bad template
4775 parameters, but not simply because the conversion failed, since we
4776 might be just trying to do argument deduction. Both TYPE and EXPR
4777 must be non-dependent.
4779 The conversion follows the special rules described in
4780 [temp.arg.nontype], and it is much more strict than an implicit
4781 conversion.
4783 This function is called twice for each template argument (see
4784 lookup_template_class for a more accurate description of this
4785 problem). This means that we need to handle expressions which
4786 are not valid in a C++ source, but can be created from the
4787 first call (for instance, casts to perform conversions). These
4788 hacks can go away after we fix the double coercion problem. */
4790 static tree
4792 {
4793 tree expr_type;
4795 /* Detect immediately string literals as invalid non-type argument.
4796 This special-case is not needed for correctness (we would easily
4797 catch this later), but only to provide better diagnostic for this
4798 common user mistake. As suggested by DR 100, we do not mention
4799 linkage issues in the diagnostic as this is not the point. */
4801 {
4806 }
4808 /* If we are in a template, EXPR may be non-dependent, but still
4809 have a syntactic, rather than semantic, form. For example, EXPR
4810 might be a SCOPE_REF, rather than the VAR_DECL to which the
4811 SCOPE_REF refers. Preserving the qualifying scope is necessary
4812 so that access checking can be performed when the template is
4813 instantiated -- but here we need the resolved form so that we can
4814 convert the argument. */
4820 /* HACK: Due to double coercion, we can get a
4821 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4822 which is the tree that we built on the first call (see
4823 below when coercing to reference to object or to reference to
4824 function). We just strip everything and get to the arg.
4825 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4826 for examples. */
4828 {
4830 {
4831 /* ??? Maybe we could use convert_from_reference here, but we
4832 would need to relax its constraints because the NOP_EXPR
4833 could actually change the type to something more cv-qualified,
4834 and this is not folded by convert_from_reference. */
4845 }
4847 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4848 parameter is a pointer to object, through decay and
4849 qualification conversion. Let's strip everything. */
4851 {
4855 /* Skip the ADDR_EXPR only if it is part of the decay for
4856 an array. Otherwise, it is part of the original argument
4857 in the source code. */
4861 }
4862 }
4864 /* [temp.arg.nontype]/5, bullet 1
4866 For a non-type template-parameter of integral or enumeration type,
4867 integral promotions (_conv.prom_) and integral conversions
4868 (_conv.integral_) are applied. */
4870 {
4875 /* Notice that there are constant expressions like '4 % 0' which
4876 do not fold into integer constants. */
4878 {
4882 }
4884 /* At this point, an implicit conversion does what we want,
4885 because we already know that the expression is of integral
4886 type. */
4891 /* Conversion was allowed: fold it to a bare integer constant. */
4893 }
4894 /* [temp.arg.nontype]/5, bullet 2
4896 For a non-type template-parameter of type pointer to object,
4897 qualification conversions (_conv.qual_) and the array-to-pointer
4898 conversion (_conv.array_) are applied. */
4900 {
4901 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4903 A template-argument for a non-type, non-template template-parameter
4904 shall be one of: [...]
4906 -- the name of a non-type template-parameter;
4907 -- the address of an object or function with external linkage, [...]
4908 expressed as "& id-expression" where the & is optional if the name
4909 refers to a function or array, or if the corresponding
4910 template-parameter is a reference.
4912 Here, we do not care about functions, as they are invalid anyway
4913 for a parameter of type pointer-to-object. */
4916 /* Non-type template parameters are OK. */
4917 ;
4920 {
4922 {
4924 "because %qD is a variable, not the address of "
4928 }
4929 /* Other values, like integer constants, might be valid
4930 non-type arguments of some other type. */
4932 }
4933 else
4934 {
4935 tree decl;
4940 {
4945 }
4947 {
4952 }
4953 }
4962 }
4963 /* [temp.arg.nontype]/5, bullet 3
4965 For a non-type template-parameter of type reference to object, no
4966 conversions apply. The type referred to by the reference may be more
4967 cv-qualified than the (otherwise identical) type of the
4968 template-argument. The template-parameter is bound directly to the
4969 template-argument, which must be an lvalue. */
4971 {
4973 expr_type))
4977 {
4981 }
4984 {
4988 }
4990 /* [temp.arg.nontype]/1
4992 A template-argument for a non-type, non-template template-parameter
4993 shall be one of: [...]
4995 -- the address of an object or function with external linkage. */
4998 {
5001 {
5003 "because a reference variable does not have a constant "
5006 }
5007 }
5010 {
5015 }
5018 {
5023 }
5026 }
5027 /* [temp.arg.nontype]/5, bullet 4
5029 For a non-type template-parameter of type pointer to function, only
5030 the function-to-pointer conversion (_conv.func_) is applied. If the
5031 template-argument represents a set of overloaded functions (or a
5032 pointer to such), the matching function is selected from the set
5033 (_over.over_). */
5035 {
5036 /* If the argument is a template-id, we might not have enough
5037 context information to decay the pointer. */
5039 {
5043 }
5050 {
5054 }
5055 }
5056 /* [temp.arg.nontype]/5, bullet 5
5058 For a non-type template-parameter of type reference to function, no
5059 conversions apply. If the template-argument represents a set of
5060 overloaded functions, the matching function is selected from the set
5061 (_over.over_). */
5063 {
5065 {
5070 }
5077 }
5078 /* [temp.arg.nontype]/5, bullet 6
5080 For a non-type template-parameter of type pointer to member function,
5081 no conversions apply. If the template-argument represents a set of
5082 overloaded member functions, the matching member function is selected
5083 from the set (_over.over_). */
5085 {
5090 /* [temp.arg.nontype] bullet 1 says the pointer to member
5091 expression must be a pointer-to-member constant. */
5095 /* There is no way to disable standard conversions in
5096 resolve_address_of_overloaded_function (called by
5097 instantiate_type). It is possible that the call succeeded by
5098 converting &B::I to &D::I (where B is a base of D), so we need
5099 to reject this conversion here.
5101 Actually, even if there was a way to disable standard conversions,
5102 it would still be better to reject them here so that we can
5103 provide a superior diagnostic. */
5105 {
5106 /* Make sure we are just one standard conversion off. */
5113 }
5114 }
5115 /* [temp.arg.nontype]/5, bullet 7
5117 For a non-type template-parameter of type pointer to data member,
5118 qualification conversions (_conv.qual_) are applied. */
5120 {
5121 /* [temp.arg.nontype] bullet 1 says the pointer to member
5122 expression must be a pointer-to-member constant. */
5129 }
5130 /* A template non-type parameter must be one of the above. */
5131 else
5134 /* Sanity check: did we actually convert the argument to the
5135 right type? */
5138 }
5140 /* Subroutine of coerce_template_template_parms, which returns 1 if
5141 PARM_PARM and ARG_PARM match using the rule for the template
5142 parameters of template template parameters. Both PARM and ARG are
5143 template parameters; the rest of the arguments are the same as for
5144 coerce_template_template_parms.
5145 */
5146 static int
5148 tree arg,
5149 tsubst_flags_t complain,
5150 tree in_decl,
5151 tree outer_args)
5152 {
5161 {
5163 /* We encounter instantiations of templates like
5164 template <template <template <class> class> class TT>
5165 class C; */
5166 {
5173 }
5174 /* Fall through. */
5179 /* Argument is a parameter pack but parameter is not. */
5184 /* The tsubst call is used to handle cases such as
5186 template <int> class C {};
5187 template <class T, template <T> class TT> class D {};
5188 D<int, C> d;
5190 i.e. the parameter list of TT depends on earlier parameters. */
5192 && !same_type_p
5199 /* Argument is a parameter pack but parameter is not. */
5206 }
5209 }
5212 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5213 template template parameters. Both PARM_PARMS and ARG_PARMS are
5214 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5215 or PARM_DECL.
5217 Consider the example:
5218 template <class T> class A;
5219 template<template <class U> class TT> class B;
5221 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5222 the parameters to A, and OUTER_ARGS contains A. */
5224 static int
5226 tree arg_parms,
5227 tsubst_flags_t complain,
5228 tree in_decl,
5229 tree outer_args)
5230 {
5241 /* Determine whether we have a parameter pack at the end of the
5242 template template parameter's template parameter list. */
5244 {
5251 {
5265 }
5266 }
5272 /* Check all of the template parameters except the parameter pack at
5273 the end (if any). */
5275 {
5284 outer_args))
5287 }
5290 {
5291 /* Check each of the template parameters in the template
5292 argument against the template parameter pack at the end of
5293 the template template parameter. */
5300 {
5307 outer_args))
5309 }
5310 }
5313 }
5315 /* Verifies that the deduced template arguments (in TARGS) for the
5316 template template parameters (in TPARMS) represent valid bindings,
5317 by comparing the template parameter list of each template argument
5318 to the template parameter list of its corresponding template
5319 template parameter, in accordance with DR150. This
5320 routine can only be called after all template arguments have been
5321 deduced. It will return TRUE if all of the template template
5322 parameter bindings are okay, FALSE otherwise. */
5323 bool
5325 {
5329 /* We're dealing with template parms in this process. */
5335 {
5340 {
5345 {
5346 /* Look inside the argument pack. */
5349 }
5352 {
5356 /* Extract the next argument from the argument
5357 pack. */
5361 /* Look at the pattern of the pack expansion. */
5364 /* Extract the template parameters from the template
5365 argument. */
5371 /* Verify that we can coerce the template template
5372 parameters from the template argument to the template
5373 parameter. This requires an exact match. */
5375 && !coerce_template_template_parms
5377 targ_parms,
5378 tf_none,
5379 tparm,
5380 targs))
5381 {
5384 }
5385 }
5386 }
5387 }
5389 out:
5393 }
5395 /* Convert the indicated template ARG as necessary to match the
5396 indicated template PARM. Returns the converted ARG, or
5397 error_mark_node if the conversion was unsuccessful. Error and
5398 warning messages are issued under control of COMPLAIN. This
5399 conversion is for the Ith parameter in the parameter list. ARGS is
5400 the full set of template arguments deduced so far. */
5402 static tree
5404 tree arg,
5405 tree args,
5406 tsubst_flags_t complain,
5408 tree in_decl)
5409 {
5410 tree orig_arg;
5411 tree val;
5416 {
5417 /* The template argument was the name of some
5418 member function. That's usually
5419 invalid, but static members are OK. In any
5420 case, grab the underlying fields/functions
5421 and issue an error later if required. */
5424 }
5432 /* When determining whether an argument pack expansion is a template,
5433 look at the pattern. */
5437 /* Deal with an injected-class-name used as a template template arg. */
5439 {
5442 {
5450 }
5451 }
5453 is_tmpl_type =
5468 {
5474 typename_type,
5478 }
5480 {
5482 {
5484 {
5494 else
5496 }
5497 }
5499 }
5501 {
5503 {
5509 else
5511 }
5513 }
5516 {
5518 {
5520 /* The number of argument required is not known yet.
5521 Just accept it for now. */
5523 else
5524 {
5526 tree argparm;
5532 args))
5533 {
5536 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5537 TEMPLATE_DECL. */
5539 {
5544 }
5545 }
5546 else
5547 {
5549 {
5555 }
5558 }
5559 }
5560 }
5561 else
5563 /* We only form one instance of each template specialization.
5564 Therefore, if we use a non-canonical variant (i.e., a
5565 typedef), any future messages referring to the type will use
5566 the typedef, which is confusing if those future uses do not
5567 themselves also use the typedef. */
5570 }
5571 else
5572 {
5579 {
5582 else
5583 {
5584 /* Not sure if this is reachable, but it doesn't hurt
5585 to be robust. */
5588 }
5589 }
5591 /* We used to call digest_init here. However, digest_init
5592 will report errors, which we don't want when complain
5593 is zero. More importantly, digest_init will try too
5594 hard to convert things: for example, `0' should not be
5595 converted to pointer type at this point according to
5596 the standard. Accepting this is not merely an
5597 extension, since deciding whether or not these
5598 conversions can occur is part of determining which
5599 function template to call, or whether a given explicit
5600 argument specification is valid. */
5602 else
5611 {
5612 /* Strip typedefs from the SCOPE_REF. */
5617 }
5618 }
5621 }
5623 /* Coerces the remaining template arguments in INNER_ARGS (from
5624 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5625 Returns the coerced argument pack. PARM_IDX is the position of this
5626 parameter in the template parameter list. ARGS is the original
5627 template argument list. */
5628 static tree
5631 tree args,
5632 tree inner_args,
5634 tree new_args,
5636 tree in_decl,
5637 tsubst_flags_t complain)
5638 {
5641 tree packed_args;
5642 tree argument_pack;
5652 {
5653 /* When the template parameter is a non-type template
5654 parameter pack whose type uses parameter packs, we need
5655 to look at each of the template arguments
5656 separately. Build a vector of the types for these
5657 non-type template parameters in PACKED_TYPES. */
5658 tree expansion
5666 /* Check that we have the right number of arguments. */
5670 {
5671 int needed_parms
5676 }
5678 /* If we aren't able to check the actual arguments now
5679 (because they haven't been expanded yet), we can at least
5680 verify that all of the types used for the non-type
5681 template parameter pack are, in fact, valid for non-type
5682 template parameters. */
5685 {
5688 {
5692 }
5693 }
5694 }
5696 /* Convert the remaining arguments, which will be a part of the
5697 parameter pack "parm". */
5699 {
5704 {
5705 /* When we have a vector of types (corresponding to the
5706 non-type template parameter pack that uses parameter
5707 packs in its type, as mention above), and the
5708 argument is not an expansion (which expands to a
5709 currently unknown number of arguments), clone the
5710 parm and give it the next type in PACKED_TYPES. */
5714 }
5719 in_decl);
5723 }
5728 else
5729 {
5734 }
5738 }
5740 /* Convert all template arguments to their appropriate types, and
5741 return a vector containing the innermost resulting template
5742 arguments. If any error occurs, return error_mark_node. Error and
5743 warning messages are issued under control of COMPLAIN.
5745 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5746 for arguments not specified in ARGS. Otherwise, if
5747 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5748 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5749 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5750 ARGS. */
5752 static tree
5754 tree args,
5755 tree in_decl,
5756 tsubst_flags_t complain,
5759 {
5761 tree inner_args;
5762 tree new_args;
5763 tree new_inner_args;
5767 /* When used as a boolean value, indicates whether this is a
5768 variadic template parameter list. Since it's an int, we can also
5769 subtract it from nparms to get the number of non-variadic
5770 parameters. */
5775 /* Determine if there are any parameter packs. */
5777 {
5781 }
5784 /* If there are 0 or 1 parameter packs, we need to expand any argument
5785 packs so that we can deduce a parameter pack from some non-packed args
5786 followed by an argument pack, as in variadic85.C. If there are more
5787 than that, we need to leave argument packs intact so the arguments are
5788 assigned to the right parameter packs. This should only happen when
5789 dealing with a nested class inside a partial specialization of a class
5790 template, as in variadic92.C. */
5797 && require_all_args
5798 && (!use_default_args
5801 {
5803 {
5806 {
5809 }
5816 }
5819 }
5821 /* We need to evaluate the template arguments, even though this
5822 template-id may be nested within a "sizeof". */
5830 {
5831 tree arg;
5832 tree parm;
5834 /* Get the Ith template parameter. */
5838 {
5841 }
5843 /* Calculate the next argument. */
5846 else
5851 {
5852 /* All remaining arguments will be placed in the
5853 template parameter pack PARM. */
5859 /* Store this argument. */
5861 lost++;
5864 /* We are done with all of the arguments. */
5868 }
5870 {
5872 {
5874 {
5875 /* FIXME this restriction was removed by N2555; see
5876 bug 35722. */
5877 /* If ARG is a pack expansion, but PARM is not a
5878 template parameter pack (if it were, we would have
5879 handled it above), we're trying to expand into a
5880 fixed-length argument list. */
5884 else
5887 }
5889 }
5890 }
5892 /* There must be a default arg in this case. */
5895 else
5899 {
5902 }
5904 /* This only occurs if there was an error in the template
5905 parameter list itself (which we would already have
5906 reported) that we are trying to recover from, e.g., a class
5907 template with a parameter list such as
5908 template<typename..., typename>. */
5910 else
5916 lost++;
5918 }
5926 }
5928 /* Returns 1 if template args OT and NT are equivalent. */
5930 static int
5932 {
5937 /* For member templates */
5944 {
5961 }
5963 {
5964 /* We get here probably because we are in the middle of substituting
5965 into the pattern of a pack expansion. In that case the
5966 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
5967 interested in. So we want to use the initial pack argument for
5968 the comparison. */
5973 }
5978 else
5980 }
5982 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5983 of template arguments. Returns 0 otherwise. */
5985 int
5987 {
5994 {
6000 }
6002 }
6004 static void
6006 {
6016 /* We are called both from instantiate_decl, where we've already had a
6017 tinst_level pushed, and instantiate_template, where we haven't.
6018 Compensate. */
6029 else
6038 }
6041 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6042 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6043 documentation for TEMPLATE_ID_EXPR. */
6045 tree
6047 {
6048 tree type;
6058 {
6060 unknown_type_node,
6062 arglist);
6064 }
6071 }
6073 /* Within the scope of a template class S<T>, the name S gets bound
6074 (in build_self_reference) to a TYPE_DECL for the class, not a
6075 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6076 or one of its enclosing classes, and that type is a template,
6077 return the associated TEMPLATE_DECL. Otherwise, the original
6078 DECL is returned.
6080 Also handle the case when DECL is a TREE_LIST of ambiguous
6081 injected-class-names from different bases. */
6083 tree
6085 {
6089 /* DR 176: A lookup that finds an injected-class-name (10.2
6090 [class.member.lookup]) can result in an ambiguity in certain cases
6091 (for example, if it is found in more than one base class). If all of
6092 the injected-class-names that are found refer to specializations of
6093 the same class template, and if the name is followed by a
6094 template-argument-list, the reference refers to the class template
6095 itself and not a specialization thereof, and is not ambiguous. */
6097 {
6100 {
6106 }
6109 else
6111 }
6117 }
6119 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
6120 parameters, find the desired type.
6122 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
6124 IN_DECL, if non-NULL, is the template declaration we are trying to
6125 instantiate.
6127 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
6128 the class we are looking up.
6130 Issue error and warning messages under control of COMPLAIN.
6132 If the template class is really a local class in a template
6133 function, then the FUNCTION_CONTEXT is the function in which it is
6134 being instantiated.
6136 ??? Note that this function is currently called *twice* for each
6137 template-id: the first time from the parser, while creating the
6138 incomplete type (finish_template_type), and the second type during the
6139 real instantiation (instantiate_template_class). This is surely something
6140 that we want to avoid. It also causes some problems with argument
6141 coercion (see convert_nontype_argument for more information on this). */
6143 tree
6145 tree arglist,
6146 tree in_decl,
6147 tree context,
6149 tsubst_flags_t complain)
6150 {
6152 tree t;
6155 spec_entry elt;
6156 hashval_t hash;
6161 {
6165 else
6166 {
6173 }
6176 }
6178 {
6181 /* If we are declaring a constructor, say A<T>::A<T>, we will get
6182 an implicit typename for the second A. Deal with it. */
6187 {
6190 }
6191 }
6194 {
6197 }
6201 {
6205 }
6207 /* Issue an error message if we didn't find a template. */
6209 {
6213 }
6216 /* Make sure it's a user visible template, if it was named by
6217 the user. */
6220 {
6222 {
6226 }
6228 }
6233 {
6234 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
6235 template arguments */
6237 tree parm;
6238 tree arglist2;
6239 tree outer;
6243 /* Consider an example where a template template parameter declared as
6245 template <class T, class U = std::allocator<T> > class TT
6247 The template parameter level of T and U are one level larger than
6248 of TT. To proper process the default argument of U, say when an
6249 instantiation `TT<int>' is seen, we need to build the full
6250 arguments containing {int} as the innermost level. Outer levels,
6251 available when not appearing as default template argument, can be
6252 obtained from the arguments of the enclosing template.
6254 Suppose that TT is later substituted with std::vector. The above
6255 instantiation is `TT<int, std::allocator<T> >' with TT at
6256 level 1, and T at level 2, while the template arguments at level 1
6257 becomes {std::vector} and the inner level 2 is {int}. */
6263 /* This is an argument of the current template, so we haven't set
6264 DECL_CONTEXT yet. */
6271 complain,
6281 }
6282 else
6283 {
6285 tree gen_tmpl;
6286 tree type_decl;
6298 {
6299 /* We've been given an incomplete set of template arguments.
6300 For example, given:
6302 template <class T> struct S1 {
6303 template <class U> struct S2 {};
6304 template <class U> struct S2<U*> {};
6305 };
6307 we will be called with an ARGLIST of `U*', but the
6308 TEMPLATE will be `template <class T> template
6309 <class U> struct S1<T>::S2'. We must fill in the missing
6310 arguments. */
6311 arglist
6313 arglist);
6315 }
6317 /* Now we should have enough arguments. */
6320 /* From here on, we're only interested in the most general
6321 template. */
6323 /* Calculate the BOUND_ARGS. These will be the args that are
6324 actually tsubst'd into the definition to create the
6325 instantiation. */
6327 {
6328 /* We have multiple levels of arguments to coerce, at once. */
6338 {
6341 complain,
6345 /* Don't process further if one of the levels fails. */
6347 {
6348 /* Restore the ARGLIST to its full size. */
6351 }
6355 /* We temporarily reduce the length of the ARGLIST so
6356 that coerce_template_parms will see only the arguments
6357 corresponding to the template parameters it is
6358 examining. */
6360 }
6362 /* Restore the ARGLIST to its full size. */
6366 }
6367 else
6368 arglist
6371 gen_tmpl,
6372 complain,
6377 /* We were unable to bind the arguments. */
6380 /* In the scope of a template class, explicit references to the
6381 template class refer to the type of the template, not any
6382 instantiation of it. For example, in:
6384 template <class T> class C { void f(C<T>); }
6386 the `C<T>' is just the same as `C'. Outside of the
6387 class, however, such a reference is an instantiation. */
6391 /* comp_template_args is expensive, check it last. */
6393 arglist))
6396 /* If we already have this specialization, return it. */
6406 /* This type is a "partial instantiation" if any of the template
6407 arguments still involve template parameters. Note that we set
6408 IS_PARTIAL_INSTANTIATION for partial specializations as
6409 well. */
6412 /* If the deduced arguments are invalid, then the binding
6413 failed. */
6417 complain))
6424 {
6429 }
6436 /* Create the type. */
6438 {
6440 {
6446 }
6447 else
6448 {
6449 /* We don't want to call start_enum for this type, since
6450 the values for the enumeration constants may involve
6451 template parameters. And, no one should be interested
6452 in the enumeration constants for such a type. */
6455 }
6456 }
6457 else
6458 {
6465 /* A local class. Make sure the decl gets registered properly. */
6470 /* This instantiation is another name for the primary
6471 template type. Set the TYPE_CANONICAL field
6472 appropriately. */
6475 /* Some of the template arguments require structural
6476 equality testing, so this template class requires
6477 structural equality testing. */
6479 }
6481 /* If we called start_enum or pushtag above, this information
6482 will already be set up. */
6484 {
6491 }
6492 else
6500 {
6503 }
6505 /* Set up the template information. We have to figure out which
6506 template is the immediate parent if this is a full
6507 instantiation. */
6510 /* This case is easy; there are no member templates involved. */
6512 else
6513 {
6514 /* This is a full instantiation of a member template. Find
6515 the partial instantiation of which this is an instance. */
6517 /* Temporarily reduce by one the number of levels in the ARGLIST
6518 so as to avoid comparing the last set of arguments. */
6523 }
6533 /* Note this use of the partial instantiation so we can check it
6534 later in maybe_process_partial_specialization. */
6541 /* Now that the type has been registered on the instantiations
6542 list, we set up the enumerators. Because the enumeration
6543 constants may involve the enumeration type itself, we make
6544 sure to register the type first, and then create the
6545 constants. That way, doing tsubst_expr for the enumeration
6546 constants won't result in recursive calls here; we'll find
6547 the instantiation and exit above. */
6551 /* If the type makes use of template parameters, the
6552 code that generates debugging information will crash. */
6555 /* Possibly limit visibility based on template args. */
6560 }
6562 }
6563 \f
6564 struct pair_fn_data
6565 {
6566 tree_fn_t fn;
6568 /* True when we should also visit template parameters that occur in
6569 non-deduced contexts. */
6572 };
6574 /* Called from for_each_template_parm via walk_tree. */
6576 static tree
6578 {
6591 {
6595 /* Fall through. */
6618 /* Since we're not going to walk subtrees, we have to do this
6619 explicitly here. */
6623 /* Fall through. */
6626 /* Check the return type. */
6631 /* Check the parameter types. Since default arguments are not
6632 instantiated until they are needed, the TYPE_ARG_TYPES may
6633 contain expressions that involve template parameters. But,
6634 no-one should be looking at them yet. And, once they're
6635 instantiated, they don't contain template parameters, so
6636 there's no point in looking at them then, either. */
6637 {
6638 tree parm;
6645 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6646 want walk_tree walking into them itself. */
6648 }
6665 /* Fall through. */
6681 /* Record template parameters such as `T' inside `TT<T>'. */
6685 /* Fall through. */
6697 /* A template template parameter is encountered. */
6703 /* Already substituted template template parameter */
6726 /* If there's no type, then this thing must be some expression
6727 involving template parameters. */
6748 }
6750 /* We didn't find any template parameters we liked. */
6752 }
6754 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6755 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6756 call FN with the parameter and the DATA.
6757 If FN returns nonzero, the iteration is terminated, and
6758 for_each_template_parm returns 1. Otherwise, the iteration
6759 continues. If FN never returns a nonzero value, the value
6760 returned by for_each_template_parm is 0. If FN is NULL, it is
6761 considered to be the function which always returns 1.
6763 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6764 parameters that occur in non-deduced contexts. When false, only
6765 visits those template parameters that can be deduced. */
6767 static int
6771 {
6775 /* Set up. */
6780 /* Walk the tree. (Conceptually, we would like to walk without
6781 duplicates, but for_each_template_parm_r recursively calls
6782 for_each_template_parm, so we would need to reorganize a fair
6783 bit to use walk_tree_without_duplicates, so we keep our own
6784 visited list.) */
6787 else
6790 for_each_template_parm_r,
6794 /* Clean up. */
6796 {
6799 }
6802 }
6804 /* Returns true if T depends on any template parameter. */
6806 int
6808 {
6835 else
6836 {
6839 }
6844 }
6846 /* Returns true if T depends on any template parameter with level LEVEL. */
6848 int
6850 {
6853 }
6857 #ifdef GATHER_STATISTICS
6859 #endif
6863 /* We're starting to instantiate D; record the template instantiation context
6864 for diagnostics and to restore it later. */
6866 static int
6868 {
6872 {
6873 /* If the instantiation in question still has unbound template parms,
6874 we don't really care if we can't instantiate it, so just return.
6875 This happens with base instantiation for implicit `typename'. */
6887 }
6897 #ifdef GATHER_STATISTICS
6900 #endif
6904 }
6906 /* We're done instantiating this template; return to the instantiation
6907 context. */
6909 static void
6911 {
6912 /* Restore the filename and line number stashed away when we started
6913 this instantiation. */
6918 }
6920 /* We're instantiating a deferred template; restore the template
6921 instantiation context in which the instantiation was requested, which
6922 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6924 static tree
6926 {
6936 }
6938 /* Returns the TINST_LEVEL which gives the original instantiation
6939 context. */
6943 {
6949 }
6951 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
6953 bool
6955 {
6956 tree parms;
6973 }
6975 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6976 vector of template arguments, as for tsubst.
6978 Returns an appropriate tsubst'd friend declaration. */
6980 static tree
6982 {
6983 tree new_friend;
6988 /* This was a friend declared with an explicit template
6989 argument list, e.g.:
6991 friend void f<>(T);
6993 to indicate that f was a template instantiation, not a new
6994 function declaration. Now, we have to figure out what
6995 instantiation of what template. */
6996 {
6998 tree new_args;
6999 tree tmpl;
7002 /* Friend functions are looked up in the containing namespace scope.
7003 We must enter that scope, to avoid finding member functions of the
7004 current class with same name. */
7019 tsk_none);
7021 }
7025 /* The NEW_FRIEND will look like an instantiation, to the
7026 compiler, but is not an instantiation from the point of view of
7027 the language. For example, we might have had:
7029 template <class T> struct S {
7030 template <class U> friend void f(T, U);
7031 };
7033 Then, in S<int>, template <class U> void f(int, U) is not an
7034 instantiation of anything. */
7040 {
7044 }
7046 /* The mangled name for the NEW_FRIEND is incorrect. The function
7047 is not a template instantiation and should not be mangled like
7048 one. Therefore, we forget the mangling here; we'll recompute it
7049 later if we need it. */
7051 {
7054 }
7057 {
7058 tree old_decl;
7059 tree new_friend_template_info;
7060 tree new_friend_result_template_info;
7061 tree ns;
7064 /* We must save some information from NEW_FRIEND before calling
7065 duplicate decls since that function will free NEW_FRIEND if
7066 possible. */
7068 new_friend_is_defn =
7073 {
7074 /* This declaration is a `primary' template. */
7077 new_friend_result_template_info
7079 }
7080 else
7083 /* Make the init_value nonzero so pushdecl knows this is a defn. */
7087 /* Inside pushdecl_namespace_level, we will push into the
7088 current namespace. However, the friend function should go
7089 into the namespace of the template. */
7099 {
7100 /* This new friend declaration matched an existing
7101 declaration. For example, given:
7103 template <class T> void f(T);
7104 template <class U> class C {
7105 template <class T> friend void f(T) {}
7106 };
7108 the friend declaration actually provides the definition
7109 of `f', once C has been instantiated for some type. So,
7110 old_decl will be the out-of-class template declaration,
7111 while new_friend is the in-class definition.
7113 But, if `f' was called before this point, the
7114 instantiation of `f' will have DECL_TI_ARGS corresponding
7115 to `T' but not to `U', references to which might appear
7116 in the definition of `f'. Previously, the most general
7117 template for an instantiation of `f' was the out-of-class
7118 version; now it is the in-class version. Therefore, we
7119 run through all specialization of `f', adding to their
7120 DECL_TI_ARGS appropriately. In particular, they need a
7121 new set of outer arguments, corresponding to the
7122 arguments for this class instantiation.
7124 The same situation can arise with something like this:
7126 friend void f(int);
7127 template <class T> class C {
7128 friend void f(T) {}
7129 };
7131 when `C<int>' is instantiated. Now, `f(int)' is defined
7132 in the class. */
7135 /* On the other hand, if the in-class declaration does
7136 *not* provide a definition, then we don't want to alter
7137 existing definitions. We can just leave everything
7138 alone. */
7139 ;
7140 else
7141 {
7145 /* Overwrite whatever template info was there before, if
7146 any, with the new template information pertaining to
7147 the declaration. */
7151 /* We should have called reregister_specialization in
7152 duplicate_decls. */
7156 else
7157 {
7158 tree t;
7160 /* Indicate that the old function template is a partial
7161 instantiation. */
7169 /* Reassign any specializations already in the hash table
7170 to the new more general template, and add the
7171 additional template args. */
7175 {
7177 spec_entry elt;
7189 register_specialization
7192 }
7194 }
7195 }
7197 /* The information from NEW_FRIEND has been merged into OLD_DECL
7198 by duplicate_decls. */
7200 }
7201 }
7202 else
7203 {
7207 /* In the code
7208 template <class T> class C {
7209 template <class U> friend void C1<U>::f (); // case 1
7210 friend void C2<T>::f (); // case 2
7211 };
7212 we only need to make sure CONTEXT is a complete type for
7213 case 2. To distinguish between the two cases, we note that
7214 CONTEXT of case 1 remains dependent type after tsubst while
7215 this isn't true for case 2. */
7225 {
7226 /* Check to see that the declaration is really present, and,
7227 possibly obtain an improved declaration. */
7233 }
7234 }
7237 }
7239 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
7240 template arguments, as for tsubst.
7242 Returns an appropriate tsubst'd friend type or error_mark_node on
7243 failure. */
7245 static tree
7247 {
7248 tree friend_type;
7249 tree tmpl;
7250 tree context;
7255 {
7258 else
7260 }
7262 /* Look for a class template declaration. We look for hidden names
7263 because two friend declarations of the same template are the
7264 same. For example, in:
7266 struct A {
7267 template <typename> friend class F;
7268 };
7269 template <typename> struct B {
7270 template <typename> friend class F;
7271 };
7273 both F templates are the same. */
7278 /* But, if we don't find one, it might be because we're in a
7279 situation like this:
7281 template <class T>
7282 struct S {
7283 template <class U>
7284 friend struct S;
7285 };
7287 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
7288 for `S<int>', not the TEMPLATE_DECL. */
7290 {
7293 }
7296 {
7297 /* The friend template has already been declared. Just
7298 check to see that the declarations match, and install any new
7299 default parameters. We must tsubst the default parameters,
7300 of course. We only need the innermost template parameters
7301 because that is all that redeclare_class_template will look
7302 at. */
7305 {
7306 tree parms;
7307 location_t saved_input_location;
7316 }
7319 }
7320 else
7321 {
7322 /* The friend template has not already been declared. In this
7323 case, the instantiation of the template class will cause the
7324 injection of this template into the global scope. */
7329 /* The new TMPL is not an instantiation of anything, so we
7330 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7331 the new type because that is supposed to be the corresponding
7332 template decl, i.e., TMPL. */
7339 /* Inject this template into the global scope. */
7341 }
7344 {
7347 else
7349 }
7352 }
7354 /* Returns zero if TYPE cannot be completed later due to circularity.
7355 Otherwise returns one. */
7357 static int
7359 {
7369 else
7371 }
7373 /* Apply any attributes which had to be deferred until instantiation
7374 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7375 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7377 static void
7380 {
7382 tree t;
7387 {
7391 }
7394 {
7398 }
7399 else
7403 {
7408 {
7411 {
7414 /* If the first attribute argument is an identifier, don't
7415 pass it through tsubst. Attributes like mode, format,
7416 cleanup and several target specific attributes expect it
7417 unmodified. */
7423 {
7424 tree chain
7426 in_decl,
7431 chain);
7432 }
7433 else
7439 }
7440 else
7442 }
7445 }
7446 }
7448 /* Perform (or defer) access check for typedefs that were referenced
7449 from within the template TMPL code.
7450 This is a subroutine of instantiate_template and instantiate_class_template.
7451 TMPL is the template to consider and TARGS is the list of arguments of
7452 that template. */
7454 static void
7456 {
7457 location_t saved_location;
7472 {
7484 /* Make access check error messages point to the location
7485 of the use of the typedef. */
7489 }
7491 }
7493 tree
7495 {
7497 tree typedecl;
7498 tree pbinfo;
7499 tree base_list;
7510 /* Figure out which template is being instantiated. */
7514 /* Determine what specialization of the original template to
7515 instantiate. */
7518 {
7521 }
7523 {
7524 /* This TYPE is actually an instantiation of a partial
7525 specialization. We replace the innermost set of ARGS with
7526 the arguments appropriate for substitution. For example,
7527 given:
7529 template <class T> struct S {};
7530 template <class T> struct S<T*> {};
7532 and supposing that we are instantiating S<int*>, ARGS will
7533 presently be {int*} -- but we need {int}. */
7536 }
7537 else
7538 {
7541 }
7543 /* If the template we're instantiating is incomplete, then clearly
7544 there's nothing we can do. */
7548 /* If we've recursively instantiated too many templates, stop. */
7552 /* Now we're really doing the instantiation. Mark the type as in
7553 the process of being defined. */
7556 /* We may be in the middle of deferred access check. Disable
7557 it now. */
7561 /* Use #pragma pack from the template context. */
7567 /* Set the input location to the most specialized template definition.
7568 This is needed if tsubsting causes an error. */
7589 {
7592 }
7596 /* We should never instantiate a nested class before its enclosing
7597 class; we need to look up the nested class by name before we can
7598 instantiate it, and that lookup should instantiate the enclosing
7599 class. */
7606 {
7607 tree pbase_binfo;
7609 tree pushed_scope;
7612 /* We must enter the scope containing the type, as that is where
7613 the accessibility of types named in dependent bases are
7614 looked up from. */
7617 /* Substitute into each of the bases to determine the actual
7618 basetypes. */
7620 {
7621 tree base;
7627 {
7628 expanded_bases =
7635 }
7638 {
7640 /* Extract the already-expanded base class. */
7642 else
7643 /* Substitute to figure out the base class. */
7645 NULL_TREE);
7653 }
7654 }
7656 /* The list is now in reverse order; correct that. */
7661 }
7662 /* Now call xref_basetypes to set up all the base-class
7663 information. */
7670 /* Now that our base classes are set up, enter the scope of the
7671 class, so that name lookups into base classes, etc. will work
7672 correctly. This is precisely analogous to what we do in
7673 begin_class_definition when defining an ordinary non-template
7674 class, except we also need to push the enclosing classes. */
7677 /* Now members are processed in the order of declaration. */
7680 {
7684 {
7686 {
7687 /* Build new CLASSTYPE_NESTED_UTDS. */
7689 tree newtag;
7695 /* If the member is a class template, then -- even after
7696 substitution -- there may be dependent types in the
7697 template argument list for the class. We increment
7698 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7699 that function will assume that no types are dependent
7700 when outside of a template. */
7710 {
7714 /* Unfortunately, lookup_template_class sets
7715 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7716 instantiation (i.e., for the type of a member
7717 template class nested within a template class.)
7718 This behavior is required for
7719 maybe_process_partial_specialization to work
7720 correctly, but is not accurate in this case;
7721 the TAG is not an instantiation of anything.
7722 (The corresponding TEMPLATE_DECL is an
7723 instantiation, but the TYPE is not.) */
7726 /* Now, we call pushtag to put this NEWTAG into the scope of
7727 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7728 pushtag calling push_template_decl. We don't have to do
7729 this for enums because it will already have been done in
7730 tsubst_enum. */
7734 }
7735 }
7738 {
7739 /* Build new TYPE_METHODS. */
7740 tree r;
7749 }
7750 else
7751 {
7752 /* Build new TYPE_FIELDS. */
7754 {
7755 tree condition =
7763 }
7765 {
7766 tree r;
7768 /* The file and line for this declaration, to
7769 assist in error message reporting. Since we
7770 called push_tinst_level above, we don't need to
7771 restore these. */
7780 {
7781 /* In [temp.inst]:
7783 [t]he initialization (and any associated
7784 side-effects) of a static data member does
7785 not occur unless the static data member is
7786 itself used in a way that requires the
7787 definition of the static data member to
7788 exist.
7790 Therefore, we do not substitute into the
7791 initialized for the static data member here. */
7792 finish_static_data_member_decl
7800 }
7802 {
7803 /* Determine whether R has a valid type and can be
7804 completed later. If R is invalid, then it is
7805 replaced by error_mark_node so that it will not be
7806 added to TYPE_FIELDS. */
7812 {
7815 }
7816 }
7818 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7819 such a thing will already have been added to the field
7820 list by tsubst_enum in finish_member_declaration in the
7821 CLASSTYPE_NESTED_UTDS case above. */
7825 {
7828 }
7829 }
7830 }
7831 }
7832 else
7833 {
7835 {
7836 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7842 {
7843 /* template <class T> friend class C; */
7846 }
7848 {
7849 /* template <class T> friend class C::D; */
7855 }
7857 {
7858 /* This could be either
7860 friend class T::C;
7862 when dependent_type_p is false or
7864 template <class U> friend class T::C;
7866 otherwise. */
7869 /* Bump processing_template_decl for correct
7870 dependent_type_p calculation. */
7875 }
7878 {
7879 /* friend class C;
7881 where C hasn't been declared yet. Let's lookup name
7882 from namespace scope directly, bypassing any name that
7883 come from dependent base class. */
7886 /* The call to xref_tag_from_type does injection for friend
7887 classes. */
7889 friend_type =
7893 }
7895 /* friend class C<T>; */
7898 /* Otherwise it's
7900 friend class C;
7902 where C is already declared or
7904 friend class C<int>;
7906 We don't have to do anything in these cases. */
7909 /* Trick make_friend_class into realizing that the friend
7910 we're adding is a template, not an ordinary class. It's
7911 important that we use make_friend_class since it will
7912 perform some error-checking and output cross-reference
7913 information. */
7921 }
7922 else
7923 {
7924 /* Build new DECL_FRIENDLIST. */
7925 tree r;
7927 /* The file and line for this declaration, to
7928 assist in error message reporting. Since we
7929 called push_tinst_level above, we don't need to
7930 restore these. */
7934 {
7937 }
7942 {
7945 }
7946 }
7947 }
7948 }
7950 /* Set the file and line number information to whatever is given for
7951 the class itself. This puts error messages involving generated
7952 implicit functions at a predictable point, and the same point
7953 that would be used for non-template classes. */
7960 /* Now that the class is complete, instantiate default arguments for
7961 any member functions. We don't do this earlier because the
7962 default arguments may reference members of the class. */
7966 /* Implicitly generated member functions will not have template
7967 information; they are not instantiations, but instead are
7968 created "fresh" for each instantiation. */
7972 /* Some typedefs referenced from within the template code need to be access
7973 checked at template instantiation time, i.e now. These types were
7974 added to the template at parsing time. Let's get those and perform
7975 the access checks then. */
7984 /* The vtable for a template class can be emitted in any translation
7985 unit in which the class is instantiated. When there is no key
7986 method, however, finish_struct_1 will already have added TYPE to
7987 the keyed_classes list. */
7992 }
7994 static tree
7996 {
7997 tree r;
8003 else
8004 {
8008 }
8010 }
8012 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
8013 NONTYPE_ARGUMENT_PACK. */
8015 static tree
8017 {
8018 /* Collect all of the extra "packed" parameters into an
8019 argument pack. */
8020 tree parmvec;
8021 tree parmtypevec;
8026 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
8030 {
8033 }
8035 /* Build the argument packs. */
8041 }
8043 /* Substitute ARGS into T, which is an pack expansion
8044 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
8045 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
8046 (if only a partial substitution could be performed) or
8047 ERROR_MARK_NODE if there was an error. */
8048 tree
8050 tree in_decl)
8051 {
8052 tree pattern;
8055 tree result;
8062 /* Determine the argument packs that will instantiate the parameter
8063 packs used in the expansion expression. While we're at it,
8064 compute the number of arguments to be expanded and make sure it
8065 is consistent. */
8068 {
8074 {
8077 {
8078 /* This can happen for a parameter name used later in a function
8079 declaration (such as in a late-specified return type). Just
8080 make a dummy decl, since it's only used for its type. */
8084 }
8085 }
8086 else
8087 {
8094 }
8101 /* This can only happen if we forget to expand an argument
8102 pack somewhere else. Just return an error, silently. */
8103 {
8107 }
8112 {
8117 /* The argument pack that the parameter maps to is just an
8118 expansion of the parameter itself, such as one would
8119 find in the implicit typedef of a class inside the
8120 class itself. Consider this parameter "unsubstituted",
8121 so that we will maintain the outer pack expansion. */
8123 }
8126 {
8130 /* It's all-or-nothing with incomplete argument packs. */
8140 {
8142 /* We got explicit args for some packs but not others;
8143 do nothing now and try again after deduction. */
8148 pattern);
8149 else
8152 pattern);
8154 }
8156 /* Keep track of the parameter packs and their corresponding
8157 argument packs. */
8160 }
8161 else
8162 /* We can't substitute for this parameter pack. */
8165 unsubstituted_packs);
8166 }
8168 /* We cannot expand this expansion expression, because we don't have
8169 all of the argument packs we need. Substitute into the pattern
8170 and return a PACK_EXPANSION_*. The caller will need to deal with
8171 that. */
8173 {
8174 tree new_pat;
8178 else
8181 }
8183 /* We could not find any argument packs that work. */
8188 {
8189 /* We're in a late-specified return type, so we don't have a local
8190 specializations table. Create one for doing this expansion. */
8193 hash_local_specialization,
8194 eq_local_specializations,
8195 NULL);
8196 }
8198 /* For each argument in each argument pack, substitute into the
8199 pattern. */
8202 {
8203 /* For parameter pack, change the substitution of the parameter
8204 pack to the ith argument in its argument pack, then expand
8205 the pattern. */
8207 {
8211 {
8212 /* Select the Ith argument from the pack. */
8218 }
8219 else
8220 {
8226 {
8227 /* Select the Ith argument from the pack. */
8231 }
8233 /* Update the corresponding argument. */
8235 }
8236 }
8238 /* Substitute into the PATTERN with the altered arguments. */
8243 else
8247 /* When we have incomplete argument packs, the last "expanded"
8248 result is itself a pack expansion, which allows us
8249 to deduce more arguments. */
8254 {
8257 }
8258 }
8260 /* Update ARGS to restore the substitution from parameter packs to
8261 their argument packs. */
8263 {
8268 else
8269 {
8273 /* Update the corresponding argument. */
8277 else
8279 }
8280 }
8283 {
8286 }
8289 }
8291 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
8292 TMPL. We do this using DECL_PARM_INDEX, which should work even with
8293 parameter packs; all parms generated from a function parameter pack will
8294 have the same DECL_PARM_INDEX. */
8296 tree
8298 {
8300 tree patparm;
8303 {
8309 }
8310 else
8311 {
8316 }
8319 }
8321 /* Substitute ARGS into the vector or list of template arguments T. */
8323 static tree
8325 {
8332 {
8334 tree new_arg;
8339 {
8340 /* Substitute into an expansion expression. */
8344 /* Add to the expanded length adjustment the number of
8345 expanded arguments. We subtract one from this
8346 measurement, because the argument pack expression
8347 itself is already counted as 1 in
8348 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
8349 the argument pack is empty. */
8351 }
8353 {
8354 /* Substitute into each of the arguments. */
8360 new_arg,
8374 }
8375 }
8376 else
8385 }
8390 /* Make space for the expanded arguments coming from template
8391 argument packs. */
8394 {
8398 {
8401 /* Now expand the template argument pack "in place". */
8404 }
8405 else
8406 {
8408 out++;
8409 }
8410 }
8413 }
8415 /* Return the result of substituting ARGS into the template parameters
8416 given by PARMS. If there are m levels of ARGS and m + n levels of
8417 PARMS, then the result will contain n levels of PARMS. For
8418 example, if PARMS is `template <class T> template <class U>
8419 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8420 result will be `template <int*, double, class V>'. */
8422 static tree
8424 {
8428 /* When substituting into a template, we must set
8429 PROCESSING_TEMPLATE_DECL as the template parameters may be
8430 dependent if they are based on one-another, and the dependency
8431 predicates are short-circuit outside of templates. */
8438 {
8439 tree new_vec =
8444 {
8445 tree tuple;
8446 tree default_value;
8447 tree parm_decl;
8469 }
8475 }
8480 }
8482 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8483 type T. If T is not an aggregate or enumeration type, it is
8484 handled as if by tsubst. IN_DECL is as for tsubst. If
8485 ENTERING_SCOPE is nonzero, T is the context for a template which
8486 we are presently tsubst'ing. Return the substituted value. */
8488 static tree
8490 tree args,
8491 tsubst_flags_t complain,
8492 tree in_decl,
8494 {
8499 {
8504 /* Else fall through. */
8508 {
8509 tree argvec;
8510 tree context;
8511 tree r;
8515 /* In "sizeof(X<I>)" we need to evaluate "I". */
8521 /* First, determine the context for the type we are looking
8522 up. */
8525 {
8528 /* If context is a nested class inside a class template,
8529 it may still need to be instantiated (c++/33959). */
8532 }
8534 /* Then, figure out what arguments are appropriate for the
8535 type we are trying to find. For example, given:
8537 template <class T> struct S;
8538 template <class T, class U> void f(T, U) { S<U> su; }
8540 and supposing that we are instantiating f<int, double>,
8541 then our ARGS will be {int, double}, but, when looking up
8542 S we only want {double}. */
8547 else
8548 {
8552 }
8558 }
8559 else
8560 /* This is not a template type, so there's nothing to do. */
8565 }
8566 }
8568 /* Substitute into the default argument ARG (a default argument for
8569 FN), which has the indicated TYPE. */
8571 tree
8573 {
8577 /* This default argument came from a template. Instantiate the
8578 default argument here, not in tsubst. In the case of
8579 something like:
8581 template <class T>
8582 struct S {
8583 static T t();
8584 void f(T = t());
8585 };
8587 we must be careful to do name lookup in the scope of S<T>,
8588 rather than in the current class. */
8590 /* The "this" pointer is not valid in a default argument. */
8592 {
8597 }
8600 /* The default argument expression may cause implicitly defined
8601 member functions to be synthesized, which will result in garbage
8602 collection. We must treat this situation as if we were within
8603 the body of function so as to avoid collecting live data on the
8604 stack. */
8612 /* Restore the "this" pointer. */
8614 {
8617 }
8619 /* Make sure the default argument is reasonable. */
8625 }
8627 /* Substitute into all the default arguments for FN. */
8629 static void
8631 {
8632 tree arg;
8633 tree tmpl_args;
8637 /* If this function is not yet instantiated, we certainly don't need
8638 its default arguments. */
8643 arg;
8649 }
8651 /* Substitute the ARGS into the T, which is a _DECL. Return the
8652 result of the substitution. Issue error and warning messages under
8653 control of COMPLAIN. */
8655 static tree
8657 {
8658 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
8659 location_t saved_loc;
8664 /* Set the filename and linenumber to improve error-reporting. */
8669 {
8671 {
8672 /* We can get here when processing a member function template,
8673 member class template, or template template parameter. */
8675 tree spec;
8676 tree tmpl_args;
8677 tree full_args;
8680 {
8681 /* Template template parameter is treated here. */
8694 complain);
8697 }
8699 /* We might already have an instance of this template.
8700 The ARGS are for the surrounding class type, so the
8701 full args contain the tsubst'd args for the context,
8702 plus the innermost args from the template decl. */
8706 /* Because this is a template, the arguments will still be
8707 dependent, even after substitution. If
8708 PROCESSING_TEMPLATE_DECL is not set, the dependency
8709 predicates will short-circuit. */
8717 /* If this is a default template template argument,
8718 tsubst might not have changed anything. */
8725 {
8728 }
8730 /* Make a new template decl. It will be similar to the
8731 original, but will record the current template arguments.
8732 We also create a new function declaration, which is just
8733 like the old one, but points to this new template, rather
8734 than the old one. */
8742 {
8743 tree new_type;
8755 }
8756 else
8757 {
8758 tree new_decl;
8770 }
8776 /* The template parameters for this new template are all the
8777 template parameters for the old template, except the
8778 outermost level of parameters. */
8781 complain);
8787 /* Record this non-type partial instantiation. */
8791 }
8795 {
8796 tree ctx;
8799 tree gen_tmpl;
8800 tree type;
8805 /* Nobody should be tsubst'ing into non-template functions. */
8809 {
8810 tree spec;
8813 /* If T is not dependent, just return it. We have to
8814 increment PROCESSING_TEMPLATE_DECL because
8815 value_dependent_expression_p assumes that nothing is
8816 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8823 /* Calculate the most general template of which R is a
8824 specialization, and the complete set of arguments used to
8825 specialize R. */
8831 /* Check to see if we already have this specialization. */
8836 {
8839 }
8841 /* We can see more levels of arguments than parameters if
8842 there was a specialization of a member template, like
8843 this:
8845 template <class T> struct S { template <class U> void f(); }
8846 template <> template <class U> void S<int>::f(U);
8848 Here, we'll be substituting into the specialization,
8849 because that's where we can find the code we actually
8850 want to generate, but we'll have enough arguments for
8851 the most general template.
8853 We also deal with the peculiar case:
8855 template <class T> struct S {
8856 template <class U> friend void f();
8857 };
8858 template <class U> void f() {}
8859 template S<int>;
8860 template void f<double>();
8862 Here, the ARGS for the instantiation of will be {int,
8863 double}. But, we only need as many ARGS as there are
8864 levels of template parameters in CODE_PATTERN. We are
8865 careful not to get fooled into reducing the ARGS in
8866 situations like:
8868 template <class T> struct S { template <class U> void f(U); }
8869 template <class T> template <> void S<T>::f(int) {}
8871 which we can spot because the pattern will be a
8872 specialization in this case. */
8874 parms_depth =
8879 }
8880 else
8881 {
8882 /* This special case arises when we have something like this:
8884 template <class T> struct S {
8885 friend void f<int>(int, double);
8886 };
8888 Here, the DECL_TI_TEMPLATE for the friend declaration
8889 will be an IDENTIFIER_NODE. We are being called from
8890 tsubst_friend_function, and we want only to create a
8891 new decl (R) with appropriate types so that we can call
8892 determine_specialization. */
8894 }
8897 {
8900 else
8904 }
8905 else
8906 {
8909 }
8914 /* We do NOT check for matching decls pushed separately at this
8915 point, as they may not represent instantiations of this
8916 template, and in any case are considered separate under the
8917 discrete model. */
8921 /* Clear out the mangled name and RTL for the instantiation. */
8924 /* Leave DECL_INITIAL set on deleted instantiations. */
8930 /* Type-conversion operator. Reconstruct the name, in
8931 case it's the name of one of the template's parameters. */
8941 /* If this is an instantiation of a function with internal
8942 linkage, we already know what object file linkage will be
8943 assigned to the instantiation. */
8952 /* We'll re-clone as appropriate in instantiate_template. */
8955 /* If we aren't complaining now, return on error before we register
8956 the specialization so that we'll complain eventually. */
8962 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8963 this in the special friend case mentioned above where
8964 GEN_TMPL is NULL. */
8966 {
8972 /* We're not supposed to instantiate default arguments
8973 until they are called, for a template. But, for a
8974 declaration like:
8976 template <class T> void f ()
8977 { extern void g(int i = T()); }
8979 we should do the substitution when the template is
8980 instantiated. We handle the member function case in
8981 instantiate_class_template since the default arguments
8982 might refer to other members of the class. */
8987 }
8988 else
8991 /* Copy the list of befriending classes. */
8995 {
8999 in_decl);
9000 }
9003 {
9007 /* If this is an instantiation of a member template, clone it.
9008 If it isn't, that'll be handled by
9009 clone_constructors_and_destructors. */
9012 }
9023 /* Possibly limit visibility based on template args. */
9026 {
9030 }
9038 }
9042 {
9050 {
9051 /* If there is a local specialization that isn't a
9052 parameter pack, it means that we're doing a "simple"
9053 substitution from inside tsubst_pack_expansion. Just
9054 return the local specialization (which will be a single
9055 parm). */
9062 /* Expand the TYPE_PACK_EXPANSION that provides the types for
9063 the parameters in this function parameter pack. */
9067 {
9070 /* Zero-length parameter packs are boring. Just substitute
9071 into the chain. */
9075 }
9076 else
9077 {
9078 /* All we did was update the type. Make a note of that. */
9081 }
9082 }
9084 /* Loop through all of the parameter's we'll build. When T is
9085 a function parameter pack, LEN is the number of expanded
9086 types in EXPANDED_TYPES; otherwise, LEN is 1. */
9089 {
9095 /* An argument of a function parameter pack is not a parameter
9096 pack. */
9100 /* We're on the Ith parameter of the function parameter
9101 pack. */
9102 {
9103 /* Get the Ith type. */
9107 /* Rename the parameter to include the index. */
9110 }
9112 /* We're dealing with a normal parameter. */
9120 {
9123 else
9126 }
9136 /* Keep track of the first new parameter we
9137 generate. That's what will be returned to the
9138 caller. */
9142 /* Build a proper chain of parameters when substituting
9143 into a function parameter pack. */
9146 }
9152 /* FIRST_R contains the start of the chain we've built. */
9154 }
9158 {
9159 tree type;
9168 /* DECL_INITIAL gives the number of bits in a bit-field. */
9173 /* We don't have to set DECL_CONTEXT here; it is set by
9174 finish_member_declaration. */
9181 }
9185 /* We reach here only for member using decls. */
9187 {
9188 r = do_class_using_decl
9193 else
9194 {
9197 }
9198 }
9199 else
9200 {
9203 }
9208 {
9211 tree spec;
9213 tree ctx;
9219 {
9220 /* If this is the canonical decl, we don't have to
9221 mess with instantiations, and often we can't (for
9222 typename, template type parms and such). Note that
9223 TYPE_NAME is not correct for the above test if
9224 we've copied the type for a typedef. */
9230 }
9232 /* Check to see if we already have the specialization we
9233 need. */
9236 {
9237 /* T is a static data member or namespace-scope entity.
9238 We have to substitute into namespace-scope variables
9239 (even though such entities are never templates) because
9240 of cases like:
9242 template <class T> void f() { extern T t; }
9244 where the entity referenced is not known until
9245 instantiation time. */
9249 {
9251 complain,
9253 /* If CTX is unchanged, then T is in fact the
9254 specialization we want. That situation occurs when
9255 referencing a static data member within in its own
9256 class. We can use pointer equality, rather than
9257 same_type_p, because DECL_CONTEXT is always
9258 canonical. */
9261 }
9264 {
9270 }
9271 }
9272 else
9273 {
9274 /* A local variable. */
9276 /* Subsequent calls to pushdecl will fill this in. */
9279 }
9280 /* If we already have the specialization we need, there is
9281 nothing more to do. */
9283 {
9286 }
9288 /* Create a new node for the specialization we need. */
9291 {
9294 else
9297 }
9299 {
9300 /* Even if the original location is out of scope, the
9301 newly substituted one is not. */
9308 {
9309 /* It may seem that this case cannot occur, since:
9311 typedef void f();
9312 void g() { f x; }
9314 declares a function, not a variable. However:
9316 typedef void f();
9317 template <typename T> void g() { T t; }
9318 template void g<f>();
9320 is an attempt to declare a variable with function
9321 type. */
9323 /* R is not yet sufficiently initialized, so we
9324 just use its name. */
9327 }
9334 {
9339 }
9340 }
9346 /* Clear out the mangled name and RTL for the instantiation. */
9350 /* The initializer must not be expanded until it is required;
9351 see [temp.inst]. */
9357 {
9358 /* Possibly limit visibility based on template args. */
9361 {
9365 }
9367 }
9370 {
9371 /* A static data member declaration is always marked
9372 external when it is declared in-class, even if an
9373 initializer is present. We mimic the non-template
9374 processing here. */
9380 }
9382 {
9383 /* We're substituting this var in a decltype outside of its
9384 scope, such as for a lambda return type. Don't add it to
9385 local_specializations, do perform auto deduction. */
9387 tree init
9392 {
9395 }
9396 }
9397 else
9406 /* Preserve a typedef that names a type. */
9408 {
9411 }
9414 }
9419 }
9420 #undef RETURN
9422 out:
9423 /* Restore the file and line information. */
9427 }
9429 /* Substitute into the ARG_TYPES of a function type. */
9431 static tree
9433 tree args,
9434 tsubst_flags_t complain,
9435 tree in_decl)
9436 {
9437 tree remaining_arg_types;
9441 tree default_arg;
9452 {
9453 /* For a pack expansion, perform substitution on the
9454 entire expression. Later on, we'll handle the arguments
9455 one-by-one. */
9460 /* So that we'll spin through the parameters, one by one. */
9462 else
9463 {
9464 /* We only partially substituted into the parameter
9465 pack. Our type is TYPE_PACK_EXPANSION. */
9468 }
9469 }
9482 {
9484 {
9488 }
9490 }
9492 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9493 top-level qualifiers as required. */
9496 /* We do not substitute into default arguments here. The standard
9497 mandates that they be instantiated only when needed, which is
9498 done in build_over_call. */
9502 {
9503 /* We've instantiated a template before its default arguments
9504 have been parsed. This can happen for a nested template
9505 class, and is not an error unless we require the default
9506 argument in a call of this function. */
9507 remaining_arg_types =
9510 remaining_arg_types);
9511 }
9512 else
9513 remaining_arg_types =
9515 }
9518 }
9520 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9521 *not* handle the exception-specification for FNTYPE, because the
9522 initial substitution of explicitly provided template parameters
9523 during argument deduction forbids substitution into the
9524 exception-specification:
9526 [temp.deduct]
9528 All references in the function type of the function template to the
9529 corresponding template parameters are replaced by the specified tem-
9530 plate argument values. If a substitution in a template parameter or
9531 in the function type of the function template results in an invalid
9532 type, type deduction fails. [Note: The equivalent substitution in
9533 exception specifications is done only when the function is instanti-
9534 ated, at which point a program is ill-formed if the substitution
9535 results in an invalid type.] */
9537 static tree
9539 tree args,
9540 tsubst_flags_t complain,
9541 tree in_decl)
9542 {
9543 tree return_type;
9544 tree arg_types;
9545 tree fntype;
9547 /* The TYPE_CONTEXT is not used for function/method types. */
9550 /* Substitute the return type. */
9554 /* The standard does not presently indicate that creation of a
9555 function type with an invalid return type is a deduction failure.
9556 However, that is clearly analogous to creating an array of "void"
9557 or a reference to a reference. This is core issue #486. */
9560 {
9562 {
9565 else
9567 }
9569 }
9571 /* Substitute the argument types. */
9577 /* Construct a new type node and return it. */
9580 else
9581 {
9584 {
9585 /* [temp.deduct]
9587 Type deduction may fail for any of the following
9588 reasons:
9590 -- Attempting to create "pointer to member of T" when T
9591 is not a class type. */
9594 r);
9596 }
9600 }
9605 }
9607 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9608 ARGS into that specification, and return the substituted
9609 specification. If there is no specification, return NULL_TREE. */
9611 static tree
9613 tree args,
9614 tsubst_flags_t complain,
9615 tree in_decl)
9616 {
9617 tree specs;
9618 tree new_specs;
9623 {
9626 else
9628 {
9629 tree spec;
9634 {
9635 /* Expand the pack expansion type. */
9638 in_decl);
9644 else
9645 {
9646 /* We're substituting into a member template, so
9647 we got a TYPE_PACK_EXPANSION back. Add that
9648 expansion and move on. */
9652 expanded_specs,
9653 complain);
9656 }
9657 }
9660 {
9663 else
9668 complain);
9669 }
9672 }
9673 }
9675 }
9677 /* Take the tree structure T and replace template parameters used
9678 therein with the argument vector ARGS. IN_DECL is an associated
9679 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9680 Issue error and warning messages under control of COMPLAIN. Note
9681 that we must be relatively non-tolerant of extensions here, in
9682 order to preserve conformance; if we allow substitutions that
9683 should not be allowed, we may allow argument deductions that should
9684 not succeed, and therefore report ambiguous overload situations
9685 where there are none. In theory, we could allow the substitution,
9686 but indicate that it should have failed, and allow our caller to
9687 make sure that the right thing happens, but we don't try to do this
9688 yet.
9690 This function is used for dealing with types, decls and the like;
9691 for expressions, use tsubst_expr or tsubst_copy. */
9693 tree
9695 {
9714 else
9719 /* Reuse typedefs. We need to do this to handle dependent attributes,
9720 such as attribute aligned. */
9724 {
9730 {
9734 }
9739 else
9740 /* The typedef is from a non-template context. */
9744 {
9746 r = cp_build_qualified_type_real
9750 }
9751 /* Else we must be instantiating the typedef, so fall through. */
9752 }
9764 {
9791 {
9797 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
9798 needed. */
9806 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
9807 with TREE_SIDE_EFFECTS that indicates this is not an integral
9808 constant expression. */
9811 {
9814 }
9820 {
9824 }
9826 /* [temp.deduct]
9828 Type deduction may fail for any of the following
9829 reasons:
9831 Attempting to create an array with a size that is
9832 zero or negative. */
9834 /* We must fail if performing argument deduction (as
9835 indicated by the state of complain), so that
9836 another substitution can be found. */
9840 {
9845 }
9848 }
9854 {
9867 {
9871 /* See through ARGUMENT_PACK_SELECT arguments. */
9873 }
9878 {
9880 /* If ARG is an argument pack, we don't actually want to
9881 perform a substitution here, because substitutions
9882 for argument packs are only done
9883 element-by-element. We can get to this point when
9884 substituting the type of a non-type template
9885 parameter pack, when that type actually contains
9886 template parameter packs from an outer template, e.g.,
9888 template<typename... Types> struct A {
9889 template<Types... Values> struct B { };
9890 }; */
9894 {
9898 /* cv-quals from the template are discarded when
9899 substituting in a function or reference type. */
9904 else
9907 return cp_build_qualified_type_real
9909 }
9911 {
9912 /* We are processing a type constructed from a
9913 template template parameter. */
9919 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9920 are resolving nested-types in the signature of a
9921 member function templates. Otherwise ARG is a
9922 TEMPLATE_DECL and is the real template to be
9923 instantiated. */
9931 complain);
9932 return cp_build_qualified_type_real
9934 }
9935 else
9936 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9938 }
9941 /* This can happen during the attempted tsubst'ing in
9942 unify. This means that we don't yet have any information
9943 about the template parameter in question. */
9946 /* If we get here, we must have been looking at a parm for a
9947 more deeply nested template. Make a new version of this
9948 template parameter, but with a lower level. */
9950 {
9955 {
9957 r = cp_build_qualified_type_real
9961 }
9962 else
9963 {
9974 /* We have reduced the level of the template
9975 template parameter, but not the levels of its
9976 template parameters, so canonical_type_parameter
9977 will not be able to find the canonical template
9978 template parameter for this level. Thus, we
9979 require structural equality checking to compare
9980 TEMPLATE_TEMPLATE_PARMs. */
9984 else
9988 {
9996 }
9997 }
10006 }
10009 }
10012 {
10020 {
10024 }
10027 {
10031 }
10034 {
10038 }
10044 }
10047 /* We should never be tsubsting a binfo. */
10051 /* A vector of template arguments. */
10057 {
10066 /* [temp.deduct]
10068 Type deduction may fail for any of the following
10069 reasons:
10071 -- Attempting to create a pointer to reference type.
10072 -- Attempting to create a reference to a reference type or
10073 a reference to void.
10075 Core issue 106 says that creating a reference to a reference
10076 during instantiation is no longer a cause for failure. We
10077 only enforce this check in strict C++98 mode. */
10081 {
10084 /* We keep track of the last time we issued this error
10085 message to avoid spewing a ton of messages during a
10086 single bad template instantiation. */
10089 {
10094 else
10097 }
10100 }
10102 {
10106 }
10108 /* In C++0x, during template argument substitution, when there is an
10109 attempt to create a reference to a reference type, reference
10110 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
10112 "If a template-argument for a template-parameter T names a type
10113 that is a reference to a type A, an attempt to create the type
10114 'lvalue reference to cv T' creates the type 'lvalue reference to
10115 A,' while an attempt to create the type type rvalue reference to
10116 cv T' creates the type T"
10117 */
10118 r = cp_build_reference_type
10121 else
10126 /* Will this ever be needed for TYPE_..._TO values? */
10130 }
10132 {
10135 {
10136 /* [temp.deduct]
10138 Type deduction may fail for any of the following
10139 reasons:
10141 -- Attempting to create "pointer to member of T" when T
10142 is not a class type. */
10146 }
10148 {
10152 }
10154 {
10158 }
10161 {
10162 /* The type of the implicit object parameter gets its
10163 cv-qualifiers from the FUNCTION_TYPE. */
10164 tree memptr;
10168 complain);
10169 }
10170 else
10173 complain);
10174 }
10177 {
10178 tree fntype;
10179 tree specs;
10184 /* Substitute the exception specification. */
10186 in_decl);
10192 }
10194 {
10199 /* As an optimization, we avoid regenerating the array type if
10200 it will obviously be the same as T. */
10204 /* These checks should match the ones in grokdeclarator.
10206 [temp.deduct]
10208 The deduction may fail for any of the following reasons:
10210 -- Attempting to create an array with an element type that
10211 is void, a function type, or a reference type, or [DR337]
10212 an abstract class type. */
10216 {
10220 }
10222 {
10225 type);
10227 }
10232 {
10235 }
10238 }
10242 {
10251 }
10255 {
10261 }
10264 {
10274 {
10278 }
10280 {
10281 /* Normally, make_typename_type does not require that the CTX
10282 have complete type in order to allow things like:
10284 template <class T> struct S { typename S<T>::X Y; };
10286 But, such constructs have already been resolved by this
10287 point, so here CTX really should have complete type, unless
10288 it's a partial instantiation. */
10292 {
10296 }
10297 }
10304 {
10307 }
10310 {
10317 }
10319 return cp_build_qualified_type_real
10321 }
10324 {
10336 }
10344 {
10352 }
10355 {
10363 }
10366 {
10367 tree type;
10383 complain);
10384 }
10387 {
10388 tree type;
10404 else
10405 type = finish_decltype_type
10410 complain);
10411 }
10415 {
10419 tree packed_out =
10421 args,
10422 complain,
10423 in_decl);
10426 /* For template nontype argument packs, also substitute into
10427 the type. */
10432 }
10439 }
10440 }
10442 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10443 type of the expression on the left-hand side of the "." or "->"
10444 operator. */
10446 static tree
10449 {
10450 tree name;
10451 tree qualifying_scope;
10452 tree fns;
10453 tree optype;
10457 /* A baselink indicates a function from a base class. Both the
10458 BASELINK_ACCESS_BINFO and the base class referenced may
10459 indicate bases of the template class, rather than the
10460 instantiated class. In addition, lookups that were not
10461 ambiguous before may be ambiguous now. Therefore, we perform
10462 the lookup again. */
10469 {
10476 }
10482 /* If lookup found a single function, mark it as used at this
10483 point. (If it lookup found multiple functions the one selected
10484 later by overload resolution will be marked as used at that
10485 point.) */
10491 /* Add back the template arguments, if present. */
10496 template_args);
10497 /* Update the conversion operator type. */
10503 qualifying_scope,
10504 object_type);
10505 }
10507 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10508 true if the qualified-id will be a postfix-expression in-and-of
10509 itself; false if more of the postfix-expression follows the
10510 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10511 of "&". */
10513 static tree
10517 {
10518 tree expr;
10519 tree scope;
10520 tree name;
10522 tree template_args;
10526 /* Figure out what name to look up. */
10529 {
10536 }
10537 else
10538 {
10541 }
10543 /* Substitute into the qualifying scope. When there are no ARGS, we
10544 are just trying to simplify a non-dependent expression. In that
10545 case the qualifying scope may be dependent, and, in any case,
10546 substituting will not help. */
10549 {
10552 }
10553 else
10557 {
10563 }
10566 {
10568 {
10569 /* A BIT_NOT_EXPR is used to represent a destructor. */
10571 {
10575 }
10576 else
10579 }
10580 else
10584 {
10586 {
10590 }
10592 }
10593 }
10596 {
10598 scope);
10599 /* Remember that there was a reference to this entity. */
10601 }
10604 {
10610 }
10619 {
10620 expr = (adjust_result_of_qualified_name_lookup
10622 expr = (finish_qualified_id_expr
10626 }
10628 /* Expressions do not generally have reference type. */
10630 /* However, if we're about to form a pointer-to-member, we just
10631 want the referenced member referenced. */
10636 }
10638 /* Like tsubst, but deals with expressions. This function just replaces
10639 template parms; to finish processing the resultant expression, use
10640 tsubst_expr. */
10642 static tree
10644 {
10646 tree r;
10654 {
10659 {
10660 tree c;
10661 /* This can happen for a parameter name used later in a function
10662 declaration (such as in a late-specified return type). Just
10663 make a dummy decl, since it's only used for its type. */
10665 /* We copy T because want to tsubst the PARM_DECL only,
10666 not the following PARM_DECLs that are chained to T. */
10669 /* Give it the template pattern as its context; its true context
10670 hasn't been instantiated yet and this is good enough for
10671 mangling. */
10673 }
10681 {
10682 tree enum_type;
10683 tree v;
10687 /* There is no need to substitute into namespace-scope
10688 enumerators. */
10691 /* If ARGS is NULL, then T is known to be non-dependent. */
10695 /* Unfortunately, we cannot just call lookup_name here.
10696 Consider:
10698 template <int I> int f() {
10699 enum E { a = I };
10700 struct S { void g() { E e = a; } };
10701 };
10703 When we instantiate f<7>::S::g(), say, lookup_name is not
10704 clever enough to find f<7>::a. */
10705 enum_type
10715 /* We didn't find the name. That should never happen; if
10716 name-lookup found it during preliminary parsing, we
10717 should find it again here during instantiation. */
10719 }
10724 {
10725 tree ctx;
10730 {
10733 {
10737 }
10739 }
10740 }
10763 {
10764 /* Template template argument like the following example need
10765 special treatment:
10767 template <template <class> class TT> struct C {};
10768 template <class T> struct D {
10769 template <class U> struct E {};
10770 C<E> c; // #1
10771 };
10772 D<int> d; // #2
10774 We are processing the template argument `E' in #1 for
10775 the template instantiation #2. Originally, `E' is a
10776 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10777 have to substitute this with one having context `D<int>'. */
10781 }
10782 else
10783 /* Ordinary template template argument. */
10792 return build1
10798 {
10799 /* We only want to compute the number of arguments. */
10813 {
10820 else
10823 }
10824 else
10826 }
10827 /* Fall through */
10841 return build1
10846 {
10847 tree object;
10848 tree name;
10853 {
10857 }
10860 {
10870 }
10875 in_decl);
10876 else
10879 }
10917 return build_nt
10930 return build_nt
10937 {
10945 }
10950 {
10951 r = build_nt
10957 }
10960 {
10961 r = build_nt
10967 }
10970 {
10971 r = build_nt
10977 }
10980 {
10981 /* Substituted template arguments */
10990 }
10993 {
11013 }
11038 {
11041 }
11042 else
11046 /* This is handled by tsubst_copy_and_build. */
11051 in_decl),
11055 /* We shouldn't have built any of these during initial template
11056 generation. Instead, they should be built during instantiation
11057 in response to the saved STMT_IS_FULL_EXPR_P setting. */
11074 }
11075 }
11077 /* Like tsubst_copy, but specifically for OpenMP clauses. */
11079 static tree
11081 tree in_decl)
11082 {
11086 {
11092 {
11095 {
11101 }
11102 /* FALLTHRU */
11124 }
11125 }
11128 }
11130 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
11132 static tree
11134 tree in_decl)
11135 {
11136 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
11161 #undef RECUR
11162 }
11164 /* Substitute one OMP_FOR iterator. */
11166 static void
11171 {
11172 #define RECUR(NODE) \
11173 tsubst_expr ((NODE), args, complain, in_decl, \
11174 integral_constant_expression_p)
11183 {
11190 }
11194 {
11200 complain);
11201 else
11208 }
11211 {
11212 tree c;
11214 {
11225 }
11227 {
11232 {
11235 }
11236 }
11237 }
11243 else
11247 {
11258 {
11265 }
11266 else
11272 {
11278 }
11282 {
11289 }
11290 else
11296 }
11302 #undef RECUR
11303 }
11305 /* Like tsubst_copy for expressions, etc. but also does semantic
11306 processing. */
11308 static tree
11311 {
11312 #define RECUR(NODE) \
11313 tsubst_expr ((NODE), args, complain, in_decl, \
11314 integral_constant_expression_p)
11327 {
11329 {
11330 tree_stmt_iterator i;
11334 }
11349 else
11358 {
11359 tree decl;
11360 tree init;
11366 {
11369 tree decl;
11377 else
11379 }
11380 else
11381 {
11385 {
11386 /* By marking the declaration as instantiated, we avoid
11387 trying to instantiate it. Since instantiate_decl can't
11388 handle local variables, and since we've already done
11389 all that needs to be done, that's the right thing to
11390 do. */
11395 /* Anonymous aggregates are a special case. */
11397 else
11398 {
11402 {
11403 /* For __PRETTY_FUNCTION__ we have to adjust the
11404 initializer. */
11408 }
11409 else
11410 {
11414 /* If we had an initializer but it
11415 instantiated to nothing,
11416 value-initialize the object. This will
11417 only occur when the initializer was a
11418 pack expansion where the parameter packs
11419 used in that expansion were of length
11420 zero. */
11422 else
11424 }
11427 }
11428 }
11429 }
11431 /* A DECL_EXPR can also be used as an expression, in the condition
11432 clause of an if/for/while construct. */
11434 }
11472 {
11476 }
11484 else
11492 else
11519 {
11521 tree label;
11526 }
11532 /* Computed goto's must be tsubst'd into. On the other hand,
11533 non-computed gotos must not be; the identifier in question
11534 will have no binding. */
11536 else
11542 tmp = finish_asm_stmt
11549 {
11554 }
11559 {
11564 }
11565 else
11566 {
11571 else
11578 else
11584 else
11586 }
11590 {
11594 {
11596 /* Prevent instantiate_decl from trying to instantiate
11597 this variable. We've already done all that needs to be
11598 done. */
11601 }
11606 }
11614 {
11615 tree condition =
11617 args,
11624 }
11645 {
11660 integral_constant_expression_p);
11669 {
11673 }
11674 else
11675 {
11683 }
11697 }
11728 {
11733 }
11749 integral_constant_expression_p);
11750 }
11753 #undef RECUR
11754 }
11756 /* T is a postfix-expression that is not being used in a function
11757 call. Return the substituted version of T. */
11759 static tree
11761 tsubst_flags_t complain,
11762 tree in_decl)
11763 {
11767 else
11773 }
11775 /* Like tsubst but deals with expressions and performs semantic
11776 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11778 tree
11780 tree args,
11781 tsubst_flags_t complain,
11782 tree in_decl,
11785 {
11786 #define RECUR(NODE) \
11787 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11789 integral_constant_expression_p)
11791 tree op1;
11797 {
11800 /* Fall through. */
11802 {
11803 tree decl;
11804 cp_id_kind idk;
11809 {
11812 }
11814 /* Look up the name. */
11817 /* By convention, expressions use ERROR_MARK_NODE to indicate
11818 failure, not NULL_TREE. */
11824 integral_constant_expression_p,
11832 input_location);
11838 }
11841 {
11842 tree object;
11850 {
11853 }
11854 else
11861 else
11863 }
11866 {
11870 {
11871 /* A type conversion to reference type will be enclosed in
11872 such an indirect ref, but the substitution of the cast
11873 will have also added such an indirect ref. */
11876 }
11877 else
11880 }
11883 return build_nop
11892 {
11893 tree type;
11894 tree op;
11899 {
11904 }
11909 {
11922 }
11923 }
11941 complain);
11948 else
11950 in_decl);
11987 return build_x_binary_op
11991 ? ERROR_MARK
11995 ? ERROR_MARK
11998 complain);
12011 /* Fall through */
12016 {
12017 /* When there are no ARGS, we are trying to evaluate a
12018 non-dependent expression from the parser. Trying to do
12019 the substitutions may not work. */
12022 }
12023 else
12024 {
12032 }
12036 else
12041 {
12042 tree r = build_x_modify_expr
12046 complain);
12047 /* TREE_NO_WARNING must be set if either the expression was
12048 parenthesized or it uses an operator such as >>= rather
12049 than plain assignment. In the former case, it was already
12050 set and must be copied. In the latter case,
12051 build_x_modify_expr sets it and it must not be reset
12052 here. */
12056 }
12061 /* Remember that there was a reference to this entity. */
12067 {
12072 tree ret;
12076 else
12077 {
12081 }
12083 /* If there was an initializer in the original tree, but it
12084 instantiated to an empty list, then we should pass a
12085 non-NULL empty vector to tell build_new that it was an
12086 empty initializer() rather than no initializer. This can
12087 only happen when the initializer is a pack expansion whose
12088 parameter packs are of length zero. */
12091 else
12092 {
12096 else
12097 {
12100 }
12101 }
12108 complain);
12116 }
12119 return delete_sanity
12128 complain);
12131 {
12132 tree function;
12137 tree ret;
12140 /* When we parsed the expression, we determined whether or
12141 not Koenig lookup should be performed. */
12144 {
12149 }
12150 else
12151 {
12153 {
12159 }
12160 else
12164 in_decl,
12166 integral_constant_expression_p);
12170 }
12175 {
12181 else
12182 {
12183 /* Expand the pack expansion and push each entry onto
12184 CALL_ARGS. */
12187 {
12192 {
12197 }
12198 }
12199 else
12200 {
12201 /* A partial substitution. Add one entry. */
12203 }
12204 }
12205 }
12207 /* We do not perform argument-dependent lookup if normal
12208 lookup finds a non-function, in accordance with the
12209 expected resolution of DR 218. */
12212 /* If lookup found a member function, the Koenig lookup is
12213 not appropriate, even if an unqualified-name was used
12214 to denote the function. */
12217 /* Only do this when substitution turns a dependent call
12218 into a non-dependent call. */
12224 {
12228 }
12230 /* Remember that there was a reference to this entity. */
12237 {
12242 complain);
12243 else
12244 ret = (build_new_method_call
12250 complain));
12251 }
12252 else
12255 koenig_p,
12256 complain);
12261 }
12264 return build_x_conditional_expr
12268 complain);
12271 return finish_pseudo_destructor_expr
12277 {
12285 {
12286 /* We have pack expansions, so expand those and
12287 create a new list out of it. */
12290 tree chain;
12293 /* Expand the argument expressions. */
12301 /* Build the rest of the list. */
12306 /* Determine the number of arguments. */
12308 {
12311 }
12314 else
12315 {
12316 /* Since we only performed a partial substitution into
12317 the argument pack, we only return a single list
12318 node. */
12325 }
12327 /* Convert the argument vectors into a TREE_LIST */
12330 {
12331 /* Grab the Ith values. */
12332 i--;
12335 value
12339 /* Build the list (backwards). */
12341 }
12344 }
12360 }
12363 {
12364 tree object;
12365 tree object_type;
12366 tree member;
12370 /* Remember that there was a reference to this entity. */
12380 else
12386 {
12388 {
12393 {
12396 }
12398 {
12402 }
12403 }
12404 }
12407 {
12408 tree tmpl;
12409 tree args;
12411 /* Lookup the template functions now that we know what the
12412 scope is. */
12419 {
12422 args);
12423 member = (adjust_result_of_qualified_name_lookup
12425 object_type));
12426 }
12427 else
12428 {
12430 input_location);
12432 }
12433 }
12437 {
12439 {
12443 else
12446 }
12448 }
12454 complain);
12455 }
12458 return build_throw
12462 {
12470 tree r;
12475 /* digest_init will do the wrong thing if we let it. */
12479 /* We do not want to process the index of aggregate
12480 initializers as they are identifier nodes which will be
12481 looked up by digest_init. */
12487 {
12492 {
12493 /* Substitute into the pack expansion. */
12495 in_decl);
12498 ;
12500 /* Just move the argument into place. */
12502 else
12503 {
12504 /* Update the length of the final CONSTRUCTOR
12505 arguments vector, and note that we will need to
12506 copy.*/
12509 }
12510 }
12511 else
12513 }
12516 {
12521 idx++)
12522 {
12524 {
12529 }
12530 else
12532 }
12533 }
12542 }
12545 {
12550 }
12555 /* Fall through */
12558 {
12562 /* If the original type was a reference, we'll be wrapped in
12563 the appropriate INDIRECT_REF. */
12566 }
12571 in_decl));
12577 {
12586 }
12589 {
12595 integral_constant_expression_p);
12599 /* If the resulting list of expression statement is empty,
12600 fold it further into void_zero_node. */
12605 }
12609 /* As in finish_id_expression, we resolve enumeration constants
12610 to their underlying values. */
12612 {
12615 }
12619 {
12638 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
12640 /* Now that we know visibility, instantiate the type so we have a
12641 declaration of the op() for later calls to lambda_function. */
12649 }
12652 /* Handle Objective-C++ constructs, if appropriate. */
12653 {
12654 tree subst
12659 }
12661 }
12663 #undef RECUR
12664 }
12666 /* Verify that the instantiated ARGS are valid. For type arguments,
12667 make sure that the type's linkage is ok. For non-type arguments,
12668 make sure they are constants if they are integral or enumerations.
12669 Emit an error under control of COMPLAIN, and return TRUE on error. */
12671 static bool
12673 {
12675 {
12685 }
12687 {
12688 /* [basic.link]: A name with no linkage (notably, the name
12689 of a class or enumeration declared in a local scope)
12690 shall not be used to declare an entity with linkage.
12691 This implies that names with no linkage cannot be used as
12692 template arguments
12694 DR 757 relaxes this restriction for C++0x. */
12699 {
12700 /* DR 488 makes use of a type with no linkage cause
12701 type deduction to fail. */
12703 {
12706 else
12709 }
12711 }
12712 /* In order to avoid all sorts of complications, we do not
12713 allow variably-modified types as template arguments. */
12715 {
12719 }
12720 }
12721 /* A non-type argument of integral or enumerated type must be a
12722 constant. */
12726 {
12730 }
12732 }
12734 static bool
12736 {
12741 {
12744 }
12748 }
12750 /* Instantiate the indicated variable or function template TMPL with
12751 the template arguments in TARG_PTR. */
12753 tree
12755 {
12757 tree fndecl;
12758 tree gen_tmpl;
12759 tree spec;
12760 HOST_WIDE_INT saved_processing_template_decl;
12767 /* If this function is a clone, handle it specially. */
12769 {
12770 tree spec;
12771 tree clone;
12773 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
12774 DECL_CLONED_FUNCTION. */
12780 /* Look for the clone. */
12784 /* We should always have found the clone by now. */
12787 }
12789 /* Check to see if we already have this specialization. */
12792 /* The TMPL is a partial instantiation. To get a full set of
12793 arguments we must add the arguments used to perform the
12794 partial instantiation. */
12796 targ_ptr);
12798 /* It would be nice to avoid hashing here and then again in tsubst_decl,
12799 but it doesn't seem to be on the hot path. */
12811 complain))
12814 /* We are building a FUNCTION_DECL, during which the access of its
12815 parameters and return types have to be checked. However this
12816 FUNCTION_DECL which is the desired context for access checking
12817 is not built yet. We solve this chicken-and-egg problem by
12818 deferring all checks until we have the FUNCTION_DECL. */
12821 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
12822 (because, for example, we have encountered a non-dependent
12823 function call in the body of a template function and must now
12824 determine which of several overloaded functions will be called),
12825 within the instantiation itself we are not processing a
12826 template. */
12829 /* Substitute template parameters to obtain the specialization. */
12836 /* Now we know the specialization, compute access previously
12837 deferred. */
12840 /* Some typedefs referenced from within the template code need to be access
12841 checked at template instantiation time, i.e now. These types were
12842 added to the template at parsing time. Let's get those and perfom
12843 the acces checks then. */
12849 /* The DECL_TI_TEMPLATE should always be the immediate parent
12850 template, not the most general template. */
12853 /* If we've just instantiated the main entry point for a function,
12854 instantiate all the alternate entry points as well. We do this
12855 by cloning the instantiation of the main entry point, not by
12856 instantiating the template clones. */
12861 }
12863 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
12864 NARGS elements of the arguments that are being used when calling
12865 it. TARGS is a vector into which the deduced template arguments
12866 are placed.
12868 Return zero for success, 2 for an incomplete match that doesn't resolve
12869 all the types, and 1 for complete failure. An error message will be
12870 printed only for an incomplete match.
12872 If FN is a conversion operator, or we are trying to produce a specific
12873 specialization, RETURN_TYPE is the return type desired.
12875 The EXPLICIT_TARGS are explicit template arguments provided via a
12876 template-id.
12878 The parameter STRICT is one of:
12880 DEDUCE_CALL:
12881 We are deducing arguments for a function call, as in
12882 [temp.deduct.call].
12884 DEDUCE_CONV:
12885 We are deducing arguments for a conversion function, as in
12886 [temp.deduct.conv].
12888 DEDUCE_EXACT:
12889 We are deducing arguments when doing an explicit instantiation
12890 as in [temp.explicit], when determining an explicit specialization
12891 as in [temp.expl.spec], or when taking the address of a function
12892 template, as in [temp.deduct.funcaddr]. */
12894 int
12896 tree explicit_targs,
12897 tree targs,
12900 tree return_type,
12901 unification_kind_t strict,
12903 {
12904 tree parms;
12905 tree fntype;
12913 {
12914 /* [temp.deduct]
12916 The specified template arguments must match the template
12917 parameters in kind (i.e., type, nontype, template), and there
12918 must not be more arguments than there are parameters;
12919 otherwise type deduction fails.
12921 Nontype arguments must match the types of the corresponding
12922 nontype template parameters, or must be convertible to the
12923 types of the corresponding nontype parameters as specified in
12924 _temp.arg.nontype_, otherwise type deduction fails.
12926 All references in the function type of the function template
12927 to the corresponding template parameters are replaced by the
12928 specified template argument values. If a substitution in a
12929 template parameter or in the function type of the function
12930 template results in an invalid type, type deduction fails. */
12933 tree converted_args;
12939 converted_args
12946 /* Substitute the explicit args into the function type. This is
12947 necessary so that, for instance, explicitly declared function
12948 arguments can match null pointed constants. If we were given
12949 an incomplete set of explicit args, we must not do semantic
12950 processing during substitution as we could create partial
12951 instantiations. */
12953 {
12957 /* Dig out the actual parm. */
12960 {
12963 }
12965 {
12968 }
12971 {
12973 tree targ;
12976 /* Mark the argument pack as "incomplete". We could
12977 still deduce more arguments during unification. */
12980 {
12984 }
12986 /* We have some incomplete argument packs. */
12988 }
12989 }
12992 /* Any substitution is guaranteed to be incomplete if there
12993 are incomplete argument packs, because we can still deduce
12994 more arguments. */
12996 else
13006 /* Place the explicitly specified arguments in TARGS. */
13009 }
13011 /* Never do unification on the 'this' parameter. */
13015 {
13024 }
13026 /* We allow incomplete unification without an error message here
13027 because the standard doesn't seem to explicitly prohibit it. Our
13028 callers must be ready to deal with unification failures in any
13029 event. */
13035 {
13038 /* Clear the "incomplete" flags on all argument packs. */
13040 {
13043 {
13046 }
13047 }
13048 }
13050 /* Now that we have bindings for all of the template arguments,
13051 ensure that the arguments deduced for the template template
13052 parameters have compatible template parameter lists. We cannot
13053 check this property before we have deduced all template
13054 arguments, because the template parameter types of a template
13055 template parameter might depend on prior template parameters
13056 deduced after the template template parameter. The following
13057 ill-formed example illustrates this issue:
13059 template<typename T, template<T> class C> void f(C<5>, T);
13061 template<int N> struct X {};
13063 void g() {
13064 f(X<5>(), 5l); // error: template argument deduction fails
13065 }
13067 The template parameter list of 'C' depends on the template type
13068 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
13069 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
13070 time that we deduce 'C'. */
13072 && !template_template_parm_bindings_ok_p
13077 /* All is well so far. Now, check:
13079 [temp.deduct]
13081 When all template arguments have been deduced, all uses of
13082 template parameters in nondeduced contexts are replaced with
13083 the corresponding deduced argument values. If the
13084 substitution results in an invalid type, as described above,
13085 type deduction fails. */
13086 {
13091 /* If we're looking for an exact match, check that what we got
13092 is indeed an exact match. It might not be if some template
13093 parameters are used in non-deduced contexts. */
13095 {
13098 tree sarg
13105 }
13106 }
13109 }
13111 /* Adjust types before performing type deduction, as described in
13112 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
13113 sections are symmetric. PARM is the type of a function parameter
13114 or the return type of the conversion function. ARG is the type of
13115 the argument passed to the call, or the type of the value
13116 initialized with the result of the conversion function.
13117 ARG_EXPR is the original argument expression, which may be null. */
13119 static int
13123 tree arg_expr)
13124 {
13128 {
13133 {
13134 /* Swap PARM and ARG throughout the remainder of this
13135 function; the handling is precisely symmetric since PARM
13136 will initialize ARG rather than vice versa. */
13141 }
13144 /* Core issue #873: Do the DR606 thing (see below) for these cases,
13145 too, but here handle it by stripping the reference from PARM
13146 rather than by adding it to ARG. */
13154 /* Nothing else to do in this case. */
13159 }
13162 {
13163 /* [temp.deduct.call]
13165 If P is not a reference type:
13167 --If A is an array type, the pointer type produced by the
13168 array-to-pointer standard conversion (_conv.array_) is
13169 used in place of A for type deduction; otherwise,
13171 --If A is a function type, the pointer type produced by
13172 the function-to-pointer standard conversion
13173 (_conv.func_) is used in place of A for type deduction;
13174 otherwise,
13176 --If A is a cv-qualified type, the top level
13177 cv-qualifiers of A's type are ignored for type
13178 deduction. */
13183 else
13185 }
13187 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
13188 of the form T&&, where T is a template parameter, and the argument
13189 is an lvalue, T is deduced as A& */
13197 /* [temp.deduct.call]
13199 If P is a cv-qualified type, the top level cv-qualifiers
13200 of P's type are ignored for type deduction. If P is a
13201 reference type, the type referred to by P is used for
13202 type deduction. */
13205 {
13208 }
13210 /* DR 322. For conversion deduction, remove a reference type on parm
13211 too (which has been swapped into ARG). */
13216 }
13218 /* Most parms like fn_type_unification.
13220 If SUBR is 1, we're being called recursively (to unify the
13221 arguments of a function or method parameter of a function
13222 template). */
13224 static int
13226 tree targs,
13227 tree xparms,
13231 unification_kind_t strict,
13233 {
13239 tree parms;
13249 {
13265 }
13267 again:
13275 {
13288 /* We can't deduce anything from this, but we might get all the
13289 template args from other function args. */
13292 /* Conversions will be performed on a function argument that
13293 corresponds with a function parameter that contains only
13294 non-deducible template parameters and explicitly specified
13295 template parameters. */
13297 {
13298 tree type;
13302 else
13309 flags))
13313 }
13316 {
13319 {
13320 /* [temp.deduct.type]
13322 A template-argument can be deduced from a pointer to
13323 function or pointer to member function argument if
13324 the set of overloaded functions does not contain
13325 function templates and at most one of a set of
13326 overloaded functions provides a unique match. */
13332 }
13337 }
13339 {
13344 arg_expr);
13350 }
13351 }
13357 {
13358 /* Unify the remaining arguments with the pack expansion type. */
13359 tree argvec;
13362 /* Allocate a TREE_VEC and copy in all of the arguments */
13367 /* Copy the parameter into parmvec. */
13373 /* Advance to the end of the list of parameters. */
13375 }
13377 /* Fail if we've reached the end of the parm list, and more args
13378 are present, and the parm list isn't variadic. */
13381 /* Fail if parms are left and they don't have default values. */
13389 {
13390 tree tparm;
13397 /* If this is an undeduced nontype parameter that depends on
13398 a type parameter, try another pass; its type may have been
13399 deduced from a later argument than the one from which
13400 this parameter can be deduced. */
13406 /* Core issue #226 (C++0x) [temp.deduct]:
13408 If a template argument has not been deduced, its
13409 default template argument, if any, is used.
13411 When we are in C++98 mode, TREE_PURPOSE will either
13412 be NULL_TREE or ERROR_MARK_NODE, so we do not need
13413 to explicitly check cxx_dialect here. */
13415 {
13423 else
13424 {
13427 }
13428 }
13430 /* If the type parameter is a parameter pack, then it will
13431 be deduced to an empty parameter pack. */
13433 {
13434 tree arg;
13437 {
13441 }
13442 else
13449 }
13452 }
13455 }
13457 /* Subroutine of type_unification_real. Args are like the variables
13458 at the call site. ARG is an overloaded function (or template-id);
13459 we try deducing template args from each of the overloads, and if
13460 only one succeeds, we go with that. Modifies TARGS and returns
13461 true on success. */
13463 static bool
13465 tree targs,
13466 tree parm,
13467 tree arg,
13468 unification_kind_t strict,
13470 {
13477 {
13480 }
13481 else
13485 /* Handle `&x' where `x' is some static or non-static member
13486 function name. */
13492 /* Strip baselink information. */
13497 {
13498 /* If we got some explicit template args, we need to plug them into
13499 the affected templates before we try to unify, in case the
13500 explicit args will completely resolve the templates in question. */
13506 {
13517 {
13522 {
13525 }
13526 }
13528 }
13529 }
13532 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13533 -- but the deduction does not succeed because the expression is
13534 not just the function on its own. */
13536 else
13542 {
13545 }
13547 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13548 to function or pointer to member function argument if the set of
13549 overloaded functions does not contain function templates and at most
13550 one of a set of overloaded functions provides a unique match.
13552 So if we found multiple possibilities, we return success but don't
13553 deduce anything. */
13556 {
13561 }
13566 }
13568 /* Core DR 115: In contexts where deduction is done and fails, or in
13569 contexts where deduction is not done, if a template argument list is
13570 specified and it, along with any default template arguments, identifies
13571 a single function template specialization, then the template-id is an
13572 lvalue for the function template specialization. */
13574 tree
13576 {
13589 {
13592 }
13594 {
13597 }
13599 {
13602 }
13605 {
13609 /* If we got some explicit template args, we need to plug them into
13610 the affected templates before we try to unify, in case the
13611 explicit args will completely resolve the templates in question. */
13619 {
13630 {
13633 {
13636 }
13638 {
13641 }
13642 }
13644 }
13646 {
13658 }
13660 /* There were no good options and at least one bad one, so let the
13661 user know what the problem is. */
13663 }
13665 }
13667 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13668 overload. Fills TARGS with any deduced arguments, or error_mark_node if
13669 different overloads deduce different arguments for a given parm.
13670 ADDR_P is true if the expression for which deduction is being
13671 performed was of the form "& fn" rather than simply "fn".
13673 Returns 1 on success. */
13675 static int
13677 tree orig_targs,
13678 tree targs,
13679 tree parm,
13680 tree arg,
13681 unification_kind_t strict,
13684 {
13686 tree tempargs;
13689 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13690 to function or pointer to member function argument if the set of
13691 overloaded functions does not contain function templates and at most
13692 one of a set of overloaded functions provides a unique match.
13694 So if this is a template, just return success. */
13706 /* We don't copy orig_targs for this because if we have already deduced
13707 some template args from previous args, unify would complain when we
13708 try to deduce a template parameter for the same argument, even though
13709 there isn't really a conflict. */
13716 /* First make sure we didn't deduce anything that conflicts with
13717 explicitly specified args. */
13719 {
13726 /* Since we're unifying against ourselves, we will fill in
13727 template args used in the function parm list with our own
13728 template parms. Discard them. */
13732 }
13735 {
13740 }
13743 }
13745 /* PARM is a template class (perhaps with unbound template
13746 parameters). ARG is a fully instantiated type. If ARG can be
13747 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
13748 TARGS are as for unify. */
13750 static tree
13752 {
13753 tree copy_of_targs;
13760 /* We need to make a new template argument vector for the call to
13761 unify. If we used TARGS, we'd clutter it up with the result of
13762 the attempted unification, even if this class didn't work out.
13763 We also don't want to commit ourselves to all the unifications
13764 we've already done, since unification is supposed to be done on
13765 an argument-by-argument basis. In other words, consider the
13766 following pathological case:
13768 template <int I, int J, int K>
13769 struct S {};
13771 template <int I, int J>
13772 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
13774 template <int I, int J, int K>
13775 void f(S<I, J, K>, S<I, I, I>);
13777 void g() {
13778 S<0, 0, 0> s0;
13779 S<0, 1, 2> s2;
13781 f(s0, s2);
13782 }
13784 Now, by the time we consider the unification involving `s2', we
13785 already know that we must have `f<0, 0, 0>'. But, even though
13786 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
13787 because there are two ways to unify base classes of S<0, 1, 2>
13788 with S<I, I, I>. If we kept the already deduced knowledge, we
13789 would reject the possibility I=1. */
13792 /* If unification failed, we're done. */
13798 }
13800 /* Given a template type PARM and a class type ARG, find the unique
13801 base type in ARG that is an instance of PARM. We do not examine
13802 ARG itself; only its base-classes. If there is not exactly one
13803 appropriate base class, return NULL_TREE. PARM may be the type of
13804 a partial specialization, as well as a plain template type. Used
13805 by unify. */
13807 static tree
13809 {
13811 tree binfo;
13817 /* The type could not be completed. */
13820 /* Walk in inheritance graph order. The search order is not
13821 important, and this avoids multiple walks of virtual bases. */
13823 {
13827 {
13828 /* If there is more than one satisfactory baseclass, then:
13830 [temp.deduct.call]
13832 If they yield more than one possible deduced A, the type
13833 deduction fails.
13835 applies. */
13840 }
13841 }
13844 }
13846 /* Returns the level of DECL, which declares a template parameter. */
13848 static int
13850 {
13852 {
13862 }
13864 }
13866 /* Decide whether ARG can be unified with PARM, considering only the
13867 cv-qualifiers of each type, given STRICT as documented for unify.
13868 Returns nonzero iff the unification is OK on that basis. */
13870 static int
13872 {
13878 {
13879 /* Although a CVR qualifier is ignored when being applied to a
13880 substituted template parameter ([8.3.2]/1 for example), that
13881 does not apply during deduction [14.8.2.4]/1, (even though
13882 that is not explicitly mentioned, [14.8.2.4]/9 indicates
13883 this). Except when we're allowing additional CV qualifiers
13884 at the outer level [14.8.2.1]/3,1st bullet. */
13894 }
13905 }
13907 /* Determines the LEVEL and INDEX for the template parameter PARM. */
13908 void
13910 {
13914 {
13917 }
13918 else
13919 {
13922 }
13923 }
13925 /* Unifies the remaining arguments in PACKED_ARGS with the pack
13926 expansion at the end of PACKED_PARMS. Returns 0 if the type
13927 deduction succeeds, 1 otherwise. STRICT is the same as in
13928 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
13929 call argument list. We'll need to adjust the arguments to make them
13930 types. SUBR tells us if this is from a recursive call to
13931 type_unification_real. */
13932 int
13936 {
13937 tree parm
13944 /* Determine the parameter packs we will be deducing from the
13945 pattern, and record their current deductions. */
13948 {
13952 /* Determine the index and level of this parameter pack. */
13955 /* Keep track of the parameter packs and their corresponding
13956 argument packs. */
13959 }
13961 /* Loop through all of the arguments that have not yet been
13962 unified and unify each with the pattern. */
13964 {
13967 /* For each parameter pack, clear out the deduced value so that
13968 we can deduce it again. */
13970 {
13975 }
13977 /* Unify the pattern with the current argument. */
13978 {
13985 {
13988 /* This mirrors what we do in type_unification_real. */
13990 {
13992 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
13993 | UNIFY_ALLOW_MORE_CV_QUAL
14007 }
14010 {
14013 {
14014 /* [temp.deduct.type] A template-argument can be
14015 deduced from a pointer to function or pointer
14016 to member function argument if the set of
14017 overloaded functions does not contain function
14018 templates and at most one of a set of
14019 overloaded functions provides a unique
14020 match. */
14025 sub_strict)
14029 }
14032 {
14037 }
14038 }
14043 arg_strict |=
14046 }
14049 {
14050 /* For deduction from an init-list we need the actual list. */
14055 }
14056 }
14058 /* For each parameter pack, collect the deduced value. */
14060 {
14066 }
14067 }
14069 /* Verify that the results of unification with the parameter packs
14070 produce results consistent with what we've seen before, and make
14071 the deduced argument packs available. */
14073 {
14079 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
14080 actually deduce anything. */
14088 {
14089 /* Prepend the explicit arguments onto NEW_ARGS. */
14095 /* Copy the explicit arguments. */
14100 /* Copy the deduced arguments. */
14104 }
14107 {
14108 tree result;
14113 /* Build the deduced *_ARGUMENT_PACK. */
14115 {
14120 }
14121 else
14126 /* Note the deduced argument packs for this parameter
14127 pack. */
14129 }
14133 {
14134 /* We only had the explicitly-provided arguments before, but
14135 now we have a complete set of arguments. */
14140 /* Keep the original deduced argument pack. */
14146 }
14148 new_args))
14149 /* Inconsistent unification of this parameter pack. */
14151 else
14152 {
14157 /* Keep the original deduced argument pack. */
14159 }
14160 }
14163 }
14165 /* Deduce the value of template parameters. TPARMS is the (innermost)
14166 set of template parameters to a template. TARGS is the bindings
14167 for those template parameters, as determined thus far; TARGS may
14168 include template arguments for outer levels of template parameters
14169 as well. PARM is a parameter to a template function, or a
14170 subcomponent of that parameter; ARG is the corresponding argument.
14171 This function attempts to match PARM with ARG in a manner
14172 consistent with the existing assignments in TARGS. If more values
14173 are deduced, then TARGS is updated.
14175 Returns 0 if the type deduction succeeds, 1 otherwise. The
14176 parameter STRICT is a bitwise or of the following flags:
14178 UNIFY_ALLOW_NONE:
14179 Require an exact match between PARM and ARG.
14180 UNIFY_ALLOW_MORE_CV_QUAL:
14181 Allow the deduced ARG to be more cv-qualified (by qualification
14182 conversion) than ARG.
14183 UNIFY_ALLOW_LESS_CV_QUAL:
14184 Allow the deduced ARG to be less cv-qualified than ARG.
14185 UNIFY_ALLOW_DERIVED:
14186 Allow the deduced ARG to be a template base class of ARG,
14187 or a pointer to a template base class of the type pointed to by
14188 ARG.
14189 UNIFY_ALLOW_INTEGER:
14190 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
14191 case for more information.
14192 UNIFY_ALLOW_OUTER_LEVEL:
14193 This is the outermost level of a deduction. Used to determine validity
14194 of qualification conversions. A valid qualification conversion must
14195 have const qualified pointers leading up to the inner type which
14196 requires additional CV quals, except at the outer level, where const
14197 is not required [conv.qual]. It would be normal to set this flag in
14198 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
14199 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
14200 This is the outermost level of a deduction, and PARM can be more CV
14201 qualified at this point.
14202 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
14203 This is the outermost level of a deduction, and PARM can be less CV
14204 qualified at this point. */
14206 static int
14208 {
14210 tree targ;
14211 tree tparm;
14214 /* I don't think this will do the right thing with respect to types.
14215 But the only case I've seen it in so far has been array bounds, where
14216 signedness is the only information lost, and I think that will be
14217 okay. */
14225 /* We can't deduce anything from this, but we might get all the
14226 template args from other function args. */
14229 /* If PARM uses template parameters, then we can't bail out here,
14230 even if ARG == PARM, since we won't record unifications for the
14231 template parameters. We might need them if we're trying to
14232 figure out which of two things is more specialized. */
14236 /* Handle init lists early, so the rest of the function can assume
14237 we're dealing with a type. */
14239 {
14244 /* Replace T with std::initializer_list<T> for deduction. */
14250 /* We can only deduce from an initializer list argument if the
14251 parameter is std::initializer_list; otherwise this is a
14252 non-deduced context. */
14258 {
14261 {
14263 /* It should only be possible to get here for a call. */
14265 elt_strict |= maybe_adjust_types_for_deduction
14268 }
14272 }
14274 /* If the std::initializer_list<T> deduction worked, replace the
14275 deduced A with std::initializer_list<A>. */
14277 {
14282 }
14284 }
14286 /* Immediately reject some pairs that won't unify because of
14287 cv-qualification mismatches. */
14290 /* It is the elements of the array which hold the cv quals of an array
14291 type, and the elements might be template type parms. We'll check
14292 when we recurse. */
14294 /* We check the cv-qualifiers when unifying with template type
14295 parameters below. We want to allow ARG `const T' to unify with
14296 PARM `T' for example, when computing which of two templates
14297 is more specialized, for example. */
14311 {
14315 /* In a type which contains a nested-name-specifier, template
14316 argument values cannot be deduced for template parameters used
14317 within the nested-name-specifier. */
14329 /* The PARM is not one we're trying to unify. Just check
14330 to see if it matches ARG. */
14337 /* Check for mixed types and values. */
14345 {
14346 /* ARG must be constructed from a template class or a template
14347 template parameter. */
14352 {
14355 tree parm_parms
14356 = DECL_INNERMOST_TEMPLATE_PARMS
14361 /* The resolution to DR150 makes clear that default
14362 arguments for an N-argument may not be used to bind T
14363 to a template template parameter with fewer than N
14364 parameters. It is not safe to permit the binding of
14365 default arguments as an extension, as that may change
14366 the meaning of a conforming program. Consider:
14368 struct Dense { static const unsigned int dim = 1; };
14370 template <template <typename> class View,
14371 typename Block>
14372 void operator+(float, View<Block> const&);
14374 template <typename Block,
14375 unsigned int Dim = Block::dim>
14376 struct Lvalue_proxy { operator float() const; };
14378 void
14379 test_1d (void) {
14380 Lvalue_proxy<Dense> p;
14381 float b;
14382 b + p;
14383 }
14385 Here, if Lvalue_proxy is permitted to bind to View, then
14386 the global operator+ will be used; if they are not, the
14387 Lvalue_proxy will be converted to float. */
14389 argvec,
14391 tf_none,
14397 /* Deduce arguments T, i from TT<T> or TT<i>.
14398 We check each element of PARMVEC and ARGVEC individually
14399 rather than the whole TREE_VEC since they can have
14400 different number of elements. */
14407 /* Check if the parameters end in a pack, making them
14408 variadic. */
14417 {
14421 UNIFY_ALLOW_NONE))
14423 }
14428 UNIFY_ALLOW_NONE,
14432 }
14435 /* Fall through to deduce template name. */
14436 }
14440 {
14441 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
14443 /* Simple cases: Value already set, does match or doesn't. */
14448 }
14449 else
14450 {
14451 /* If PARM is `const T' and ARG is only `int', we don't have
14452 a match unless we are allowing additional qualification.
14453 If ARG is `const int' and PARM is just `T' that's OK;
14454 that binds `const int' to `T'. */
14459 /* Consider the case where ARG is `const volatile int' and
14460 PARM is `const T'. Then, T should be `volatile int'. */
14461 arg = cp_build_qualified_type_real
14466 /* Simple cases: Value already set, does match or doesn't. */
14472 /* Make sure that ARG is not a variable-sized array. (Note
14473 that were talking about variable-sized arrays (like
14474 `int[n]'), rather than arrays of unknown size (like
14475 `int[]').) We'll get very confused by such a type since
14476 the bound of the array will not be computable in an
14477 instantiation. Besides, such types are not allowed in
14478 ISO C++, so we can do as we please here. */
14482 /* Strip typedefs as in convert_template_argument. */
14484 }
14486 /* If ARG is a parameter pack or an expansion, we cannot unify
14487 against it unless PARM is also a parameter pack. */
14492 /* If the argument deduction results is a METHOD_TYPE,
14493 then there is a problem.
14494 METHOD_TYPE doesn't map to any real C++ type the result of
14495 the deduction can not be of that type. */
14509 /* The PARM is not one we're trying to unify. Just check
14510 to see if it matches ARG. */
14520 /* [temp.deduct.type] If, in the declaration of a function template
14521 with a non-type template-parameter, the non-type
14522 template-parameter is used in an expression in the function
14523 parameter-list and, if the corresponding template-argument is
14524 deduced, the template-argument type shall match the type of the
14525 template-parameter exactly, except that a template-argument
14526 deduced from an array bound may be of any integral type.
14527 The non-type parameter might use already deduced type parameters. */
14530 /* Template-parameter dependent expression. Just accept it for now.
14531 It will later be processed in convert_template_argument. */
14532 ;
14538 /* Convert the ARG to the type of PARM; the deduced non-type
14539 template argument must exactly match the types of the
14540 corresponding parameter. */
14543 /* We haven't deduced the type of this parameter yet. Try again
14544 later. */
14546 else
14549 /* If ARG is a parameter pack or an expansion, we cannot unify
14550 against it unless PARM is also a parameter pack. */
14559 {
14560 /* A pointer-to-member constant can be unified only with
14561 another constant. */
14565 /* Just unify the class member. It would be useless (and possibly
14566 wrong, depending on the strict flags) to unify also
14567 PTRMEM_CST_CLASS, because we want to be sure that both parm and
14568 arg refer to the same variable, even if through different
14569 classes. For instance:
14571 struct A { int x; };
14572 struct B : A { };
14574 Unification of &A::x and &B::x must succeed. */
14577 }
14580 {
14584 /* [temp.deduct.call]
14586 A can be another pointer or pointer to member type that can
14587 be converted to the deduced A via a qualification
14588 conversion (_conv.qual_).
14590 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14591 This will allow for additional cv-qualification of the
14592 pointed-to types if appropriate. */
14595 /* The derived-to-base conversion only persists through one
14596 level of pointers. */
14601 }
14616 {
14617 tree parm_max;
14618 tree arg_max;
14622 /* Our representation of array types uses "N - 1" as the
14623 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14624 not an integer constant. We cannot unify arbitrarily
14625 complex expressions, so we eliminate the MINUS_EXPRs
14626 here. */
14630 {
14633 }
14637 {
14638 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14639 trying to unify the type of a variable with the type
14640 of a template parameter. For example:
14642 template <unsigned int N>
14643 void f (char (&) [N]);
14644 int g();
14645 void h(int i) {
14646 char a[g(i)];
14647 f(a);
14648 }
14650 Here, the type of the ARG will be "int [g(i)]", and
14651 may be a SAVE_EXPR, etc. */
14655 }
14657 /* If only one of the bounds used a MINUS_EXPR, compensate
14658 by adding one to the other bound. */
14661 integer_type_node,
14662 parm_max,
14663 integer_one_node);
14666 integer_type_node,
14667 arg_max,
14668 integer_one_node);
14672 }
14686 /* We have already checked cv-qualification at the top of the
14687 function. */
14691 /* As far as unification is concerned, this wins. Later checks
14692 will invalidate it if necessary. */
14695 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
14696 /* Type INTEGER_CST can come from ordinary constant template args. */
14706 {
14715 UNIFY_ALLOW_NONE))
14718 }
14726 {
14733 strict);
14734 }
14737 {
14741 {
14742 /* First, we try to unify the PARM and ARG directly. */
14747 {
14748 /* Fallback to the special case allowed in
14749 [temp.deduct.call]:
14751 If P is a class, and P has the form
14752 template-id, then A can be a derived class of
14753 the deduced A. Likewise, if P is a pointer to
14754 a class of the form template-id, A can be a
14755 pointer to a derived class pointed to by the
14756 deduced A. */
14761 }
14762 }
14766 /* Perhaps PARM is something like S<U> and ARG is S<int>.
14767 Then, we should unify `int' and `U'. */
14769 else
14770 /* There's no chance of unification succeeding. */
14775 }
14782 {
14785 tree a;
14791 /* CV qualifications for methods can never be deduced, they must
14792 match exactly. We need to check them explicitly here,
14793 because type_unification_real treats them as any other
14794 cv-qualified parameter. */
14796 && (!check_cv_quals_for_unify
14816 LOOKUP_NORMAL);
14817 }
14820 /* Unify a pointer to member with a pointer to member function, which
14821 deduces the type of the member as a function type. */
14823 {
14824 tree method_type;
14825 tree fntype;
14826 cp_cv_quals cv_quals;
14828 /* Check top-level cv qualifiers */
14836 /* Determine the type of the function we are unifying against. */
14838 fntype =
14842 /* Extract the cv-qualifiers of the member function from the
14843 implicit object parameter and place them on the function
14844 type to be restored later. */
14845 cv_quals =
14849 }
14857 strict);
14868 /* Matched cases are handled by the ARG == PARM test above. */
14873 {
14881 {
14883 {
14885 /* We can unify against something with a trailing
14886 parameter pack. */
14888 else
14889 /* Since there is something following the pack
14890 expansion, we cannot unify this template argument
14891 list. */
14893 }
14894 }
14897 /* If we don't have enough arguments to satisfy the parameters
14898 (not counting the pack expression at the end), or we have
14899 too many arguments for a parameter list that doesn't end in
14900 a pack expression, we can't unify. */
14905 /* Unify all of the parameters that precede the (optional)
14906 pack expression. */
14908 {
14912 }
14920 }
14926 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
14927 nodes. */
14931 /* Unification fails if we hit an error node. */
14937 /* We must be looking at an expression. This can happen with
14938 something like:
14940 template <int I>
14941 void foo(S<I>, S<I + 2>);
14943 This is a "nondeduced context":
14945 [deduct.type]
14947 The nondeduced contexts are:
14949 --A type that is a template-id in which one or more of
14950 the template-arguments is an expression that references
14951 a template-parameter.
14953 In these cases, we assume deduction succeeded, but don't
14954 actually infer any unifications. */
14959 else
14961 }
14962 }
14963 \f
14964 /* Note that DECL can be defined in this translation unit, if
14965 required. */
14967 static void
14969 {
14970 tree clone;
14974 }
14976 /* Called if RESULT is explicitly instantiated, or is a member of an
14977 explicitly instantiated class. */
14979 void
14981 {
14984 /* If this entity has already been written out, it's too late to
14985 make any modifications. */
14990 /* The TREE_PUBLIC flag for function declarations will have been
14991 set correctly by tsubst. */
14994 /* This might have been set by an earlier implicit instantiation. */
14999 else
15000 {
15002 /* Always make artificials weak. */
15005 /* For WIN32 we also want to put explicit instantiations in
15006 linkonce sections. */
15009 }
15011 /* If EXTERN_P, then this function will not be emitted -- unless
15012 followed by an explicit instantiation, at which point its linkage
15013 will be adjusted. If !EXTERN_P, then this function will be
15014 emitted here. In neither circumstance do we want
15015 import_export_decl to adjust the linkage. */
15017 }
15019 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
15020 important template arguments. If any are missing, we check whether
15021 they're important by using error_mark_node for substituting into any
15022 args that were used for partial ordering (the ones between ARGS and END)
15023 and seeing if it bubbles up. */
15025 static bool
15027 {
15032 {
15035 }
15037 {
15039 {
15043 }
15044 }
15046 }
15048 /* Given two function templates PAT1 and PAT2, return:
15050 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
15051 -1 if PAT2 is more specialized than PAT1.
15052 0 if neither is more specialized.
15054 LEN indicates the number of parameters we should consider
15055 (defaulted parameters should not be considered).
15057 The 1998 std underspecified function template partial ordering, and
15058 DR214 addresses the issue. We take pairs of arguments, one from
15059 each of the templates, and deduce them against each other. One of
15060 the templates will be more specialized if all the *other*
15061 template's arguments deduce against its arguments and at least one
15062 of its arguments *does* *not* deduce against the other template's
15063 corresponding argument. Deduction is done as for class templates.
15064 The arguments used in deduction have reference and top level cv
15065 qualifiers removed. Iff both arguments were originally reference
15066 types *and* deduction succeeds in both directions, the template
15067 with the more cv-qualified argument wins for that pairing (if
15068 neither is more cv-qualified, they both are equal). Unlike regular
15069 deduction, after all the arguments have been deduced in this way,
15070 we do *not* verify the deduced template argument values can be
15071 substituted into non-deduced contexts.
15073 The logic can be a bit confusing here, because we look at deduce1 and
15074 targs1 to see if pat2 is at least as specialized, and vice versa; if we
15075 can find template arguments for pat1 to make arg1 look like arg2, that
15076 means that arg2 is at least as specialized as arg1. */
15078 int
15080 {
15093 /* Remove the this parameter from non-static member functions. If
15094 one is a non-static member function and the other is not a static
15095 member function, remove the first parameter from that function
15096 also. This situation occurs for operator functions where we
15097 locate both a member function (with this pointer) and non-member
15098 operator (with explicit first operand). */
15100 {
15105 }
15107 {
15110 {
15111 len--;
15113 }
15114 }
15116 /* If only one is a conversion operator, they are unordered. */
15120 /* Consider the return type for a conversion function */
15122 {
15125 len++;
15126 }
15128 processing_template_decl++;
15134 /* Stop when an ellipsis is seen. */
15136 {
15145 {
15146 /* When both arguments are pack expansions, we need only
15147 unify the patterns themselves. */
15151 /* This is the last comparison we need to do. */
15153 }
15156 {
15159 }
15162 {
15165 }
15168 {
15169 /* Only of the args is a reference, see if we should apply
15170 array/function pointer decay to it. This is not part of
15171 DR214, but is, IMHO, consistent with the deduction rules
15172 for the function call itself, and with our earlier
15173 implementation of the underspecified partial ordering
15174 rules. (nathan). */
15176 {
15178 {
15181 /* FALLTHROUGH. */
15188 }
15189 }
15190 else
15191 {
15193 {
15196 /* FALLTHROUGH. */
15203 }
15204 }
15205 }
15211 {
15217 /* Setup the parameter vector, which contains only ARG1. */
15220 /* Setup the argument vector, which contains the remaining
15221 arguments. */
15230 /* We cannot deduce in the other direction, because ARG1 is
15231 a pack expansion but ARG2 is not. */
15233 }
15235 {
15241 /* Setup the parameter vector, which contains only ARG1. */
15244 /* Setup the argument vector, which contains the remaining
15245 arguments. */
15254 /* We cannot deduce in the other direction, because ARG2 is
15255 a pack expansion but ARG1 is not.*/
15257 }
15259 else
15260 {
15261 /* The normal case, where neither argument is a pack
15262 expansion. */
15265 }
15267 /* If we couldn't deduce arguments for tparms1 to make arg1 match
15268 arg2, then arg2 is not as specialized as arg1. */
15274 /* "If, for a given type, deduction succeeds in both directions
15275 (i.e., the types are identical after the transformations above)
15276 and if the type from the argument template is more cv-qualified
15277 than the type from the parameter template (as described above)
15278 that type is considered to be more specialized than the other. If
15279 neither type is more cv-qualified than the other then neither type
15280 is more specialized than the other."
15282 We check same_type_p explicitly because deduction can also succeed
15283 in both directions when there is a nondeduced context. */
15287 {
15292 }
15295 /* We've failed to deduce something in either direction.
15296 These must be unordered. */
15301 /* We have already processed all of the arguments in our
15302 handing of the pack expansion type. */
15307 }
15309 /* "In most cases, all template parameters must have values in order for
15310 deduction to succeed, but for partial ordering purposes a template
15311 parameter may remain without a value provided it is not used in the
15312 types being used for partial ordering."
15314 Thus, if we are missing any of the targs1 we need to substitute into
15315 origs1, then pat2 is not as specialized as pat1. This can happen when
15316 there is a nondeduced context. */
15322 processing_template_decl--;
15324 /* All things being equal, if the next argument is a pack expansion
15325 for one function but not for the other, prefer the
15326 non-variadic function. FIXME this is bogus; see c++/41958. */
15330 {
15333 }
15339 else
15341 }
15343 /* Determine which of two partial specializations is more specialized.
15345 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
15346 to the first partial specialization. The TREE_VALUE is the
15347 innermost set of template parameters for the partial
15348 specialization. PAT2 is similar, but for the second template.
15350 Return 1 if the first partial specialization is more specialized;
15351 -1 if the second is more specialized; 0 if neither is more
15352 specialized.
15354 See [temp.class.order] for information about determining which of
15355 two templates is more specialized. */
15357 static int
15359 {
15360 tree targs;
15368 /* Just like what happens for functions, if we are ordering between
15369 different class template specializations, we may encounter dependent
15370 types in the arguments, and we need our dependency check functions
15371 to behave correctly. */
15377 {
15380 }
15386 {
15389 }
15392 /* In the case of a tie where at least one of the class templates
15393 has a parameter pack at the end, the template with the most
15394 non-packed parameters wins. */
15396 && any_deductions
15399 {
15405 /* We don't count the pack expansion at the end. */
15415 }
15418 }
15420 /* Return the template arguments that will produce the function signature
15421 DECL from the function template FN, with the explicit template
15422 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
15423 also match. Return NULL_TREE if no satisfactory arguments could be
15424 found. */
15426 static tree
15428 {
15431 tree decl_type;
15432 tree decl_arg_types;
15435 tree arg;
15437 /* Substitute the explicit template arguments into the type of DECL.
15438 The call to fn_type_unification will handle substitution into the
15439 FN. */
15442 {
15443 tree tmpl;
15444 tree converted_args;
15448 else
15449 /* We can get here for some invalid specializations. */
15452 converted_args
15455 tf_none,
15464 }
15466 /* Never do unification on the 'this' parameter. */
15485 }
15487 /* Return the innermost template arguments that, when applied to a
15488 template specialization whose innermost template parameters are
15489 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
15490 ARGS.
15492 For example, suppose we have:
15494 template <class T, class U> struct S {};
15495 template <class T> struct S<T*, int> {};
15497 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
15498 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
15499 int}. The resulting vector will be {double}, indicating that `T'
15500 is bound to `double'. */
15502 static tree
15504 {
15506 tree deduced_args;
15507 tree innermost_deduced_args;
15511 {
15515 innermost_deduced_args);
15516 }
15517 else
15523 UNIFY_ALLOW_NONE))
15530 /* Verify that nondeduced template arguments agree with the type
15531 obtained from argument deduction.
15533 For example:
15535 struct A { typedef int X; };
15536 template <class T, class U> struct C {};
15537 template <class T> struct C<T, typename T::X> {};
15539 Then with the instantiation `C<A, int>', we can deduce that
15540 `T' is `A' but unify () does not check whether `typename T::X'
15541 is `int'. */
15544 /* We only need to check the innermost arguments; the other
15545 arguments will always agree. */
15550 /* Now that we have bindings for all of the template arguments,
15551 ensure that the arguments deduced for the template template
15552 parameters have compatible template parameter lists. See the use
15553 of template_template_parm_bindings_ok_p in fn_type_unification
15554 for more information. */
15559 }
15561 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
15562 Return the TREE_LIST node with the most specialized template, if
15563 any. If there is no most specialized template, the error_mark_node
15564 is returned.
15566 Note that this function does not look at, or modify, the
15567 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
15568 returned is one of the elements of INSTANTIATIONS, callers may
15569 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
15570 and retrieve it from the value returned. */
15572 tree
15574 {
15581 {
15587 fate--;
15592 fate++;
15597 {
15598 /* Equally specialized, move to next function. If there
15599 is no next function, nothing's most specialized. */
15604 }
15605 }
15608 /* Now verify that champ is better than everything earlier in the
15609 instantiation list. */
15617 {
15620 }
15622 processing_template_decl--;
15628 }
15630 /* If DECL is a specialization of some template, return the most
15631 general such template. Otherwise, returns NULL_TREE.
15633 For example, given:
15635 template <class T> struct S { template <class U> void f(U); };
15637 if TMPL is `template <class U> void S<int>::f(U)' this will return
15638 the full template. This function will not trace past partial
15639 specializations, however. For example, given in addition:
15641 template <class T> struct S<T*> { template <class U> void f(U); };
15643 if TMPL is `template <class U> void S<int*>::f(U)' this will return
15644 `template <class T> template <class U> S<T*>::f(U)'. */
15646 tree
15648 {
15649 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15650 an immediate specialization. */
15652 {
15656 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15657 template friend. */
15662 }
15664 /* Look for more and more general templates. */
15666 {
15667 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15668 (See cp-tree.h for details.) */
15676 /* Stop if we run into an explicitly specialized class template. */
15683 }
15686 }
15688 /* Return the most specialized of the class template partial
15689 specializations of TMPL which can produce TYPE, a specialization of
15690 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
15691 a _TYPE node corresponding to the partial specialization, while the
15692 TREE_PURPOSE is the set of template arguments that must be
15693 substituted into the TREE_TYPE in order to generate TYPE.
15695 If the choice of partial specialization is ambiguous, a diagnostic
15696 is issued, and the error_mark_node is returned. If there are no
15697 partial specializations of TMPL matching TYPE, then NULL_TREE is
15698 returned. */
15700 static tree
15702 {
15704 tree t;
15705 tree champ;
15708 tree args;
15714 /* For determining which partial specialization to use, only the
15715 innermost args are interesting. */
15717 {
15720 }
15723 {
15724 tree partial_spec_args;
15725 tree spec_args;
15730 {
15735 /* Discard the outer levels of args, and then substitute in the
15736 template args from the enclosing class. */
15738 partial_spec_args = tsubst_template_args
15741 /* PARMS already refers to just the innermost parms, but the
15742 template parms in partial_spec_args had their levels lowered
15743 by tsubst, so we need to do the same for the parm list. We
15744 can't just tsubst the TREE_VEC itself, as tsubst wants to
15745 treat a TREE_VEC as an argument vector. */
15752 }
15754 partial_spec_args,
15755 args);
15757 {
15762 }
15763 }
15773 {
15776 ;
15777 else
15778 {
15780 {
15783 {
15786 }
15787 }
15789 }
15790 }
15794 {
15797 {
15800 }
15801 }
15804 {
15810 {
15813 }
15816 }
15819 }
15821 /* Explicitly instantiate DECL. */
15823 void
15825 {
15830 /* An error occurred, for which grokdeclarator has already issued
15831 an appropriate message. */
15834 {
15837 }
15839 {
15840 /* There is an asymmetry here in the way VAR_DECLs and
15841 FUNCTION_DECLs are handled by grokdeclarator. In the case of
15842 the latter, the DECL we get back will be marked as a
15843 template instantiation, and the appropriate
15844 DECL_TEMPLATE_INFO will be set up. This does not happen for
15845 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
15846 should handle VAR_DECLs as it currently handles
15847 FUNCTION_DECLs. */
15849 {
15852 }
15855 {
15858 }
15860 {
15865 }
15866 }
15868 {
15871 }
15872 else
15875 /* Check for various error cases. Note that if the explicit
15876 instantiation is valid the RESULT will currently be marked as an
15877 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
15878 until we get here. */
15881 {
15882 /* DR 259 [temp.spec].
15884 Both an explicit instantiation and a declaration of an explicit
15885 specialization shall not appear in a program unless the explicit
15886 instantiation follows a declaration of the explicit specialization.
15888 For a given set of template parameters, if an explicit
15889 instantiation of a template appears after a declaration of an
15890 explicit specialization for that template, the explicit
15891 instantiation has no effect. */
15893 }
15895 {
15896 /* [temp.spec]
15898 No program shall explicitly instantiate any template more
15899 than once.
15901 We check DECL_NOT_REALLY_EXTERN so as not to complain when
15902 the first instantiation was `extern' and the second is not,
15903 and EXTERN_P for the opposite case. */
15906 /* If an "extern" explicit instantiation follows an ordinary
15907 explicit instantiation, the template is instantiated. */
15910 }
15912 {
15915 }
15917 {
15920 }
15923 ;
15925 {
15928 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
15931 }
15932 else
15940 }
15942 static void
15944 {
15950 {
15953 }
15954 }
15956 /* Called from do_type_instantiation through binding_table_foreach to
15957 do recursive instantiation for the type bound in ENTRY. */
15958 static void
15960 {
15966 }
15968 /* Called from do_type_instantiation to instantiate a member
15969 (a member function or a static member variable) of an
15970 explicitly instantiated class template. */
15971 static void
15973 {
15978 }
15980 /* Perform an explicit instantiation of template class T. STORAGE, if
15981 non-null, is the RID for extern, inline or static. COMPLAIN is
15982 nonzero if this is called from the parser, zero if called recursively,
15983 since the standard is unclear (as detailed below). */
15985 void
15987 {
15997 {
16000 }
16005 {
16008 t);
16010 }
16013 {
16015 {
16017 {
16020 "ISO C++ 1998 forbids the use of %<extern%> on "
16022 }
16023 else
16025 "ISO C++ forbids the use of %qE"
16027 }
16035 else
16036 {
16038 storage);
16040 }
16041 }
16044 {
16045 /* DR 259 [temp.spec].
16047 Both an explicit instantiation and a declaration of an explicit
16048 specialization shall not appear in a program unless the explicit
16049 instantiation follows a declaration of the explicit specialization.
16051 For a given set of template parameters, if an explicit
16052 instantiation of a template appears after a declaration of an
16053 explicit specialization for that template, the explicit
16054 instantiation has no effect. */
16056 }
16058 {
16059 /* [temp.spec]
16061 No program shall explicitly instantiate any template more
16062 than once.
16064 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
16065 instantiation was `extern'. If EXTERN_P then the second is.
16066 These cases are OK. */
16073 /* If we've already instantiated the template, just return now. */
16076 }
16084 {
16085 tree tmp;
16087 /* In contrast to implicit instantiation, where only the
16088 declarations, and not the definitions, of members are
16089 instantiated, we have here:
16091 [temp.explicit]
16093 The explicit instantiation of a class template specialization
16094 implies the instantiation of all of its members not
16095 previously explicitly specialized in the translation unit
16096 containing the explicit instantiation.
16098 Of course, we can't instantiate member template classes, since
16099 we don't have any arguments for them. Note that the standard
16100 is unclear on whether the instantiation of the members are
16101 *explicit* instantiations or not. However, the most natural
16102 interpretation is that it should be an explicit instantiation. */
16117 }
16118 }
16120 /* Given a function DECL, which is a specialization of TMPL, modify
16121 DECL to be a re-instantiation of TMPL with the same template
16122 arguments. TMPL should be the template into which tsubst'ing
16123 should occur for DECL, not the most general template.
16125 One reason for doing this is a scenario like this:
16127 template <class T>
16128 void f(const T&, int i);
16130 void g() { f(3, 7); }
16132 template <class T>
16133 void f(const T& t, const int i) { }
16135 Note that when the template is first instantiated, with
16136 instantiate_template, the resulting DECL will have no name for the
16137 first parameter, and the wrong type for the second. So, when we go
16138 to instantiate the DECL, we regenerate it. */
16140 static void
16142 {
16143 /* The arguments used to instantiate DECL, from the most general
16144 template. */
16145 tree args;
16146 tree code_pattern;
16151 /* Make sure that we can see identifiers, and compute access
16152 correctly. */
16156 {
16157 tree decl_parm;
16158 tree pattern_parm;
16159 tree specs;
16172 specs);
16174 /* Merge parameter declarations. */
16177 pattern_parm
16181 {
16182 tree parm_type;
16183 tree attributes;
16188 NULL_TREE);
16194 {
16197 }
16200 }
16201 /* Merge any parameters that match with the function parameter
16202 pack. */
16204 {
16206 tree expanded_types;
16207 /* Expand the TYPE_PACK_EXPANSION that provides the types for
16208 the parameters in this function parameter pack. */
16213 {
16214 tree parm_type;
16215 tree attributes;
16218 /* Rename the parameter to include the index. */
16227 {
16230 }
16232 }
16233 }
16234 /* Merge additional specifiers from the CODE_PATTERN. */
16238 }
16244 else
16248 }
16250 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
16251 substituted to get DECL. */
16253 tree
16255 {
16258 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
16259 for the instantiation. This is not always the most general
16260 template. Consider, for example:
16262 template <class T>
16263 struct S { template <class U> void f();
16264 template <> void f<int>(); };
16266 and an instantiation of S<double>::f<int>. We want TD to be the
16267 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
16269 more general template. */
16271 /* We must also deal with friend templates. Given:
16273 template <class T> struct S {
16274 template <class U> friend void f() {};
16275 };
16277 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
16278 so far as the language is concerned, but that's still
16279 where we get the pattern for the instantiation from. On
16280 other hand, if the definition comes outside the class, say:
16282 template <class T> struct S {
16283 template <class U> friend void f();
16284 };
16285 template <class U> friend void f() {}
16287 we don't need to look any further. That's what the check for
16288 DECL_INITIAL is for. */
16292 {
16293 /* The present template, TD, should not be a definition. If it
16294 were a definition, we should be using it! Note that we
16295 cannot restructure the loop to just keep going until we find
16296 a template with a definition, since that might go too far if
16297 a specialization was declared, but not defined. */
16301 /* Fetch the more general template. */
16303 }
16306 }
16308 /* Returns true if we need to instantiate this template instance even if we
16309 know we aren't going to emit it.. */
16311 bool
16313 {
16314 /* We always instantiate inline functions so that we can inline them. An
16315 explicit instantiation declaration prohibits implicit instantiation of
16316 non-inline functions. With high levels of optimization, we would
16317 normally inline non-inline functions -- but we're not allowed to do
16318 that for "extern template" functions. Therefore, we check
16319 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
16322 /* And we need to instantiate static data members so that
16323 their initializers are available in integral constant
16324 expressions. */
16327 }
16329 /* Produce the definition of D, a _DECL generated from a template. If
16330 DEFER_OK is nonzero, then we don't have to actually do the
16331 instantiation now; we just have to do it sometime. Normally it is
16332 an error if this is an explicit instantiation but D is undefined.
16333 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
16334 explicitly instantiated class template. */
16336 tree
16339 {
16341 tree gen_args;
16342 tree args;
16343 tree td;
16344 tree code_pattern;
16345 tree spec;
16346 tree gen_tmpl;
16352 /* This function should only be used to instantiate templates for
16353 functions and static member variables. */
16357 /* Variables are never deferred; if instantiation is required, they
16358 are instantiated right away. That allows for better code in the
16359 case that an expression refers to the value of the variable --
16360 if the variable has a constant value the referring expression can
16361 take advantage of that fact. */
16365 /* Don't instantiate cloned functions. Instead, instantiate the
16366 functions they cloned. */
16372 /* D has already been instantiated or explicitly specialized, so
16373 there's nothing for us to do here.
16375 It might seem reasonable to check whether or not D is an explicit
16376 instantiation, and, if so, stop here. But when an explicit
16377 instantiation is deferred until the end of the compilation,
16378 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
16379 the instantiation. */
16382 /* Check to see whether we know that this template will be
16383 instantiated in some other file, as with "extern template"
16384 extension. */
16387 /* In general, we do not instantiate such templates. */
16395 /* We should already have the extra args. */
16398 /* And what's in the hash table should match D. */
16402 /* This needs to happen before any tsubsting. */
16408 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
16409 for the instantiation. */
16413 /* We should never be trying to instantiate a member of a class
16414 template or partial specialization. */
16419 /* In the case of a friend template whose definition is provided
16420 outside the class, we may have too many arguments. Drop the
16421 ones we don't need. The same is true for specializations. */
16422 args = get_innermost_template_args
16424 else
16429 else
16432 /* We may be in the middle of deferred access check. Disable it now. */
16435 /* Unless an explicit instantiation directive has already determined
16436 the linkage of D, remember that a definition is available for
16437 this entity. */
16445 /* If D is a member of an explicitly instantiated class template,
16446 and no definition is available, treat it like an implicit
16447 instantiation. */
16450 {
16454 }
16456 /* Recheck the substitutions to obtain any warning messages
16457 about ignoring cv qualifiers. Don't do this for artificial decls,
16458 as it breaks the context-sensitive substitution for lambda op(). */
16460 {
16464 /* Make sure that we can see identifiers, and compute access
16465 correctly. D is already the target FUNCTION_DECL with the
16466 right context. */
16470 {
16473 d);
16474 /* Don't simply tsubst the function type, as that will give
16475 duplicate warnings about poor parameter qualifications.
16476 The function arguments are the same as the decl_arguments
16477 without the top level cv qualifiers. */
16479 }
16483 }
16485 /* Defer all other templates, unless we have been explicitly
16486 forbidden from doing so. */
16488 template. */
16489 ! pattern_defined
16490 /* If it's OK to postpone instantiation, do so. */
16491 || defer_ok
16492 /* If this is a static data member that will be defined
16493 elsewhere, we don't want to instantiate the entire data
16494 member, but we do want to instantiate the initializer so that
16495 we can substitute that elsewhere. */
16497 {
16498 /* The definition of the static data member is now required so
16499 we must substitute the initializer. */
16503 {
16504 tree ns;
16505 tree init;
16511 args,
16516 LOOKUP_ONLYCONVERTING);
16519 }
16521 /* We restore the source position here because it's used by
16522 add_pending_template. */
16528 /* [temp.explicit]
16530 The definition of a non-exported function template, a
16531 non-exported member function template, or a non-exported
16532 member function or static data member of a class template
16533 shall be present in every translation unit in which it is
16534 explicitly instantiated. */
16538 /* ??? Historically, we have instantiated inline functions, even
16539 when marked as "extern template". */
16543 }
16544 /* Tell the repository that D is available in this translation unit
16545 -- and see if it is supposed to be instantiated here. */
16547 {
16548 /* In a PCH file, despite the fact that the repository hasn't
16549 requested instantiation in the PCH it is still possible that
16550 an instantiation will be required in a file that includes the
16551 PCH. */
16554 /* Instantiate inline functions so that the inliner can do its
16555 job, even though we'll not be emitting a copy of this
16556 function. */
16559 }
16565 /* Mark D as instantiated so that recursive calls to
16566 instantiate_decl do not try to instantiate it again. */
16569 /* Regenerate the declaration in case the template has been modified
16570 by a subsequent redeclaration. */
16573 /* We already set the file and line above. Reset them now in case
16574 they changed as a result of calling regenerate_decl_from_template. */
16578 {
16579 tree init;
16581 /* Clear out DECL_RTL; whatever was there before may not be right
16582 since we've reset the type of the declaration. */
16586 /* The initializer is placed in DECL_INITIAL by
16587 regenerate_decl_from_template. Pull it out so that
16588 cp_finish_decl can process it. */
16593 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
16594 initializer. That function will defer actual emission until
16595 we have a chance to determine linkage. */
16598 /* Enter the scope of D so that access-checking works correctly. */
16602 }
16604 {
16605 htab_t saved_local_specializations;
16606 tree subst_decl;
16607 tree tmpl_parm;
16608 tree spec_parm;
16610 /* Save away the current list, in case we are instantiating one
16611 template from within the body of another. */
16614 /* Set up the list of local specializations. */
16616 hash_local_specialization,
16617 eq_local_specializations,
16618 NULL);
16620 /* Set up context. */
16623 /* Create substitution entries for the parameters. */
16628 {
16632 }
16634 {
16638 }
16640 {
16641 /* Register the (value) argument pack as a specialization of
16642 TMPL_PARM, then move on. */
16647 }
16650 /* Substitute into the body of the function. */
16655 /* Set the current input_location to the end of the function
16656 so that finish_function knows where we are. */
16659 /* We don't need the local specializations any more. */
16663 /* Finish the function. */
16666 }
16668 /* We're not deferring instantiation any more. */
16674 out:
16682 }
16684 /* Run through the list of templates that we wish we could
16685 instantiate, and instantiate any we can. RETRIES is the
16686 number of times we retry pending template instantiation. */
16688 void
16690 {
16694 /* Instantiating templates may trigger vtable generation. This in turn
16695 may require further template instantiations. We place a limit here
16696 to avoid infinite loop. */
16698 {
16702 " instantiating %q+D, possibly from virtual table generation"
16706 /* Pretend that we defined it. */
16709 }
16711 do
16712 {
16717 {
16722 {
16723 tree fn;
16726 {
16730 fn;
16738 }
16741 }
16742 else
16743 {
16746 {
16747 instantiation
16753 }
16757 }
16760 /* If INSTANTIATION has been instantiated, then we don't
16761 need to consider it again in the future. */
16763 else
16764 {
16767 }
16770 }
16772 }
16776 }
16778 /* Substitute ARGVEC into T, which is a list of initializers for
16779 either base class or a non-static data member. The TREE_PURPOSEs
16780 are DECLs, and the TREE_VALUEs are the initializer values. Used by
16781 instantiate_decl. */
16783 static tree
16785 {
16789 {
16790 tree decl;
16791 tree init;
16797 {
16798 tree expr;
16799 tree arg;
16801 /* Expand the base class expansion type into separate base
16802 classes. */
16804 tf_warning_or_error,
16805 NULL_TREE);
16809 /* We'll be building separate TREE_LISTs of arguments for
16810 each base. */
16816 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
16817 expand each argument in the TREE_VALUE of t. */
16823 /* VOID_TYPE_NODE is used to indicate
16824 value-initialization. */
16825 {
16828 }
16829 else
16830 {
16831 /* Substitute parameter packs into each argument in the
16832 TREE_LIST. */
16835 {
16836 tree expanded_exprs;
16838 /* Expand the argument. */
16840 expanded_exprs
16842 tf_warning_or_error,
16843 NULL_TREE);
16847 /* Prepend each of the expanded expressions to the
16848 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
16850 {
16855 }
16856 }
16859 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
16860 since we built them backwards. */
16862 {
16865 }
16866 }
16867 }
16870 {
16872 {
16876 }
16877 else
16878 {
16890 }
16893 {
16897 }
16898 }
16899 }
16901 }
16903 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
16905 static void
16907 {
16912 else
16914 }
16916 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
16917 is the instantiation (which should have been created with
16918 start_enum) and ARGS are the template arguments to use. */
16920 static void
16922 {
16923 tree e;
16926 {
16927 tree value;
16928 tree decl;
16931 /* Note that in a template enum, the TREE_VALUE is the
16932 CONST_DECL, not the corresponding INTEGER_CST. */
16937 /* Give this enumeration constant the correct access. */
16940 /* Actually build the enumerator itself. */
16942 }
16947 }
16949 /* DECL is a FUNCTION_DECL that is a template specialization. Return
16950 its type -- but without substituting the innermost set of template
16951 arguments. So, innermost set of template parameters will appear in
16952 the type. */
16954 tree
16956 {
16957 tree fn_type;
16958 tree tmpl;
16959 tree targs;
16960 tree tparms;
16968 /* There should be as many levels of arguments as there are levels
16969 of parameters. */
16975 /* No substitution is necessary. */
16976 ;
16977 else
16978 {
16980 tree partial_args;
16982 /* Replace the innermost level of the TARGS with NULL_TREEs to
16983 let tsubst know not to substitute for those parameters. */
16992 /* Disable access control as this function is used only during
16993 name-mangling. */
16998 /* Now, do the (partial) substitution to figure out the
16999 appropriate function type. */
17003 /* Substitute into the template parameters to obtain the real
17004 innermost set of parameters. This step is important if the
17005 innermost set of template parameters contains value
17006 parameters whose types depend on outer template parameters. */
17011 }
17014 }
17016 /* Return truthvalue if we're processing a template different from
17017 the last one involved in diagnostics. */
17018 int
17020 {
17022 }
17024 /* Remember current template involved in diagnostics. */
17025 void
17027 {
17029 }
17033 {
17035 }
17037 /* [temp.param] Check that template non-type parm TYPE is of an allowable
17038 type. Return zero for ok, nonzero for disallowed. Issue error and
17039 warning messages under control of COMPLAIN. */
17041 static int
17043 {
17058 }
17060 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
17061 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
17063 static bool
17065 {
17066 tree scope;
17068 /* [temp.dep.type]
17070 A type is dependent if it is:
17072 -- a template parameter. Template template parameters are types
17073 for us (since TYPE_P holds true for them) so we handle
17074 them here. */
17078 /* -- a qualified-id with a nested-name-specifier which contains a
17079 class-name that names a dependent type or whose unqualified-id
17080 names a dependent type. */
17083 /* -- a cv-qualified type where the cv-unqualified type is
17084 dependent. */
17086 /* -- a compound type constructed from any dependent type. */
17096 {
17097 tree arg_type;
17102 arg_type;
17107 }
17108 /* -- an array type constructed from any dependent type or whose
17109 size is specified by a constant expression that is
17110 value-dependent. */
17112 {
17117 }
17120 {
17121 /* If this is the TYPE_DOMAIN of an array type, consider it
17122 dependent. We already checked for value-dependence in
17123 compute_array_index_type. */
17125 }
17127 /* -- a template-id in which either the template name is a template
17128 parameter ... */
17131 /* ... or any of the template arguments is a dependent type or
17132 an expression that is type-dependent or value-dependent. */
17134 && (any_dependent_template_arguments_p
17138 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
17139 argument of the `typeof' expression is not type-dependent, then
17140 it should already been have resolved. */
17145 /* A template argument pack is dependent if any of its packed
17146 arguments are. */
17148 {
17154 }
17156 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
17157 be template parameters. */
17161 /* The standard does not specifically mention types that are local
17162 to template functions or local classes, but they should be
17163 considered dependent too. For example:
17165 template <int I> void f() {
17166 enum E { a = I };
17167 S<sizeof (E)> s;
17168 }
17170 The size of `E' cannot be known until the value of `I' has been
17171 determined. Therefore, `E' must be considered dependent. */
17178 /* Other types are non-dependent. */
17180 }
17182 /* Returns TRUE if TYPE is dependent, in the sense of
17183 [temp.dep.type]. */
17185 bool
17187 {
17188 /* If there are no template parameters in scope, then there can't be
17189 any dependent types. */
17191 {
17192 /* If we are not processing a template, then nobody should be
17193 providing us with a dependent type. */
17197 }
17199 /* If the type is NULL, we have not computed a type for the entity
17200 in question; in that case, the type is dependent. */
17204 /* Erroneous types can be considered non-dependent. */
17208 /* If we have not already computed the appropriate value for TYPE,
17209 do so now. */
17211 {
17214 }
17217 }
17219 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
17220 lookup. In other words, a dependent type that is not the current
17221 instantiation. */
17223 bool
17225 {
17228 }
17230 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
17232 static bool
17234 {
17235 tree scope;
17236 tree name;
17246 /* [temp.dep.expr]
17248 An id-expression is type-dependent if it contains a
17249 nested-name-specifier that contains a class-name that names a
17250 dependent type. */
17251 /* The suggested resolution to Core Issue 224 implies that if the
17252 qualifying type is the current class, then we must peek
17253 inside it. */
17262 }
17264 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
17265 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
17266 expression. */
17268 bool
17270 {
17274 /* A name declared with a dependent type. */
17279 {
17281 /* A name that has not been looked up -- must be dependent. */
17285 /* A non-type template parm. */
17289 /* A non-type template parm. */
17295 /* A constant with integral or enumeration type and is initialized
17296 with an expression that is value-dependent. */
17308 /* These expressions are value-dependent if the type to which
17309 the cast occurs is dependent or the expression being casted
17310 is value-dependent. */
17311 {
17317 /* A functional cast has a list of operands. */
17320 {
17321 /* If there are no operands, it must be an expression such
17322 as "int()". This should not happen for aggregate types
17323 because it would form non-constant expressions. */
17327 }
17333 }
17337 /* A `sizeof' expression is value-dependent if the operand is
17338 type-dependent or is a pack expansion. */
17354 /* A CALL_EXPR may appear in a constant expression if it is a
17355 call to a builtin function, e.g., __builtin_constant_p. All
17356 such calls are value-dependent. */
17360 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
17361 is value-dependent. */
17362 {
17371 }
17374 {
17378 }
17385 /* A constant expression is value-dependent if any subexpression is
17386 value-dependent. */
17388 {
17398 || (value_dependent_expression_p
17403 {
17406 /* In some cases, some of the operands may be missing.
17407 (For example, in the case of PREDECREMENT_EXPR, the
17408 amount to increment by may be missing.) That doesn't
17409 make the expression dependent. */
17411 && (value_dependent_expression_p
17415 }
17419 }
17420 }
17422 /* The expression is not value-dependent. */
17424 }
17426 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
17427 [temp.dep.expr]. */
17429 bool
17431 {
17438 /* An unresolved name is always dependent. */
17443 /* Some expression forms are never type-dependent. */
17454 /* The types of these expressions depends only on the type to which
17455 the cast occurs. */
17463 /* The types of these expressions depends only on the type created
17464 by the expression. */
17467 {
17468 /* For NEW_EXPR tree nodes created inside a template, either
17469 the object type itself or a TREE_LIST may appear as the
17470 operand 1. */
17473 /* This is an array type. We need to check array dimensions
17474 as well. */
17476 || value_dependent_expression_p
17478 else
17480 }
17484 type_dependent_expression_p))
17490 && (any_dependent_template_arguments_p
17502 {
17503 tree elt;
17507 {
17510 }
17512 }
17515 {
17520 {
17526 }
17527 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
17535 {
17540 }
17545 {
17549 }
17551 }
17556 }
17558 /* Like type_dependent_expression_p, but it also works while not processing
17559 a template definition, i.e. during substitution or mangling. */
17561 bool
17563 {
17569 }
17571 /* Returns TRUE if ARGS contains a type-dependent expression. */
17573 bool
17575 {
17577 tree arg;
17580 {
17583 }
17585 }
17587 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
17588 expressions) contains any value-dependent expressions. */
17590 bool
17592 {
17598 }
17600 /* Returns TRUE if the ARG (a template argument) is dependent. */
17602 bool
17604 {
17612 {
17616 {
17619 }
17622 }
17625 else
17628 }
17630 /* Returns true if ARGS (a collection of template arguments) contains
17631 any types that require structural equality testing. */
17633 bool
17635 {
17645 {
17648 {
17654 {
17655 /* Look inside the argument pack. */
17658 }
17661 {
17675 }
17676 }
17677 }
17680 }
17682 /* Returns true if ARGS (a collection of template arguments) contains
17683 any dependent arguments. */
17685 bool
17687 {
17697 {
17702 }
17705 }
17707 /* Returns TRUE if the template TMPL is dependent. */
17709 bool
17711 {
17713 {
17715 {
17719 }
17721 }
17723 /* Template template parameters are dependent. */
17727 /* So are names that have not been looked up. */
17731 /* So are member templates of dependent classes. */
17735 }
17737 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
17739 bool
17741 {
17744 }
17746 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
17747 is dependent. */
17749 bool
17751 {
17758 {
17779 {
17783 }
17787 {
17791 {
17796 }
17797 }
17798 }
17801 }
17803 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
17804 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
17805 no such TYPE can be found. Note that this function peers inside
17806 uninstantiated templates and therefore should be used only in
17807 extremely limited situations. ONLY_CURRENT_P restricts this
17808 peering to the currently open classes hierarchy (which is required
17809 when comparing types). */
17811 tree
17813 {
17814 tree scope;
17815 tree name;
17816 tree decl;
17818 tree pushed_scope;
17819 tree result;
17824 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
17825 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
17826 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
17827 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
17828 identifier of the TYPENAME_TYPE anymore.
17829 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
17830 TYPENAME_TYPE instead, we avoid messing up with a possible
17831 typedef variant case. */
17834 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
17835 it first before we can figure out what NAME refers to. */
17838 /* If we don't know what SCOPE refers to, then we cannot resolve the
17839 TYPENAME_TYPE. */
17842 /* If the SCOPE is a template type parameter, we have no way of
17843 resolving the name. */
17846 /* If the SCOPE is not the current instantiation, there's no reason
17847 to look inside it. */
17850 /* If this is a typedef, we don't want to look inside (c++/11987). */
17853 /* If SCOPE isn't the template itself, it will not have a valid
17854 TYPE_FIELDS list. */
17856 /* scope is either the template itself or a compatible instantiation
17857 like X<T>, so look up the name in the original template. */
17859 else
17860 /* scope is a partial instantiation, so we can't do the lookup or we
17861 will lose the template arguments. */
17863 /* Enter the SCOPE so that name lookup will be resolved as if we
17864 were in the class definition. In particular, SCOPE will no
17865 longer be considered a dependent type. */
17867 /* Look up the declaration. */
17872 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
17873 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
17878 {
17882 }
17885 {
17886 tree tmpl;
17887 tree args;
17888 /* Obtain the template and the arguments. */
17891 /* Instantiate the template. */
17897 }
17899 /* Leave the SCOPE. */
17903 /* If we failed to resolve it, return the original typename. */
17907 /* If lookup found a typename type, resolve that too. */
17909 {
17910 /* Ill-formed programs can cause infinite recursion here, so we
17911 must catch that. */
17915 }
17917 /* Qualify the resulting type. */
17923 }
17925 /* EXPR is an expression which is not type-dependent. Return a proxy
17926 for EXPR that can be used to compute the types of larger
17927 expressions containing EXPR. */
17929 tree
17931 {
17932 tree inner_expr;
17934 /* Preserve null pointer constants so that the type of things like
17935 "p == 0" where "p" is a pointer can be determined. */
17938 /* Preserve OVERLOADs; the functions must be available to resolve
17939 types. */
17950 /* There is no need to return a proxy for a variable. */
17953 /* Preserve string constants; conversions from string constants to
17954 "char *" are allowed, even though normally a "const char *"
17955 cannot be used to initialize a "char *". */
17958 /* Preserve arithmetic constants, as an optimization -- there is no
17959 reason to create a new node. */
17962 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
17963 There is at least one place where we want to know that a
17964 particular expression is a throw-expression: when checking a ?:
17965 expression, there are special rules if the second or third
17966 argument is a throw-expression. */
17985 /* If the type is unknown, it can't really be non-dependent */
17988 /* Otherwise, build a NON_DEPENDENT_EXPR.
17990 REFERENCE_TYPEs are not stripped for expressions in templates
17991 because doing so would play havoc with mangling. Consider, for
17992 example:
17994 template <typename T> void f<T& g>() { g(); }
17996 In the body of "f", the expression for "g" will have
17997 REFERENCE_TYPE, even though the standard says that it should
17998 not. The reason is that we must preserve the syntactic form of
17999 the expression so that mangling (say) "f<g>" inside the body of
18000 "f" works out correctly. Therefore, the REFERENCE_TYPE is
18001 stripped here. */
18003 }
18005 /* ARGS is a vector of expressions as arguments to a function call.
18006 Replace the arguments with equivalent non-dependent expressions.
18007 This modifies ARGS in place. */
18009 void
18011 {
18013 tree arg;
18016 {
18020 }
18021 }
18023 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
18024 with a level one deeper than the actual template parms. */
18026 tree
18028 {
18041 }
18043 /* Given type ARG, return std::initializer_list<ARG>. */
18045 static tree
18047 {
18048 tree std_init_list = namespace_binding
18050 tree argvec;
18052 {
18056 }
18061 }
18063 /* Replace auto in TYPE with std::initializer_list<auto>. */
18065 static tree
18067 {
18074 }
18076 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
18077 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
18079 tree
18081 {
18086 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
18087 with either a new invented type template parameter U or, if the
18088 initializer is a braced-init-list (8.5.4), with
18089 std::initializer_list<U>. */
18102 {
18105 }
18107 /* If the list of declarators contains more than one declarator, the type
18108 of each declared variable is determined as described above. If the
18109 type deduced for the template parameter U is not the same in each
18110 deduction, the program is ill-formed. */
18113 {
18117 }
18123 }
18125 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
18126 result. */
18128 tree
18130 {
18131 tree argvec;
18140 }
18142 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
18144 bool
18146 {
18150 else
18152 }
18154 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
18155 appear as a type-specifier for the declaration in question, we don't
18156 have to look through the whole type. */
18158 tree
18160 {
18177 }
18179 /* For a given template T, return the vector of typedefs referenced
18180 in T for which access check is needed at T instantiation time.
18181 T is either a FUNCTION_DECL or a RECORD_TYPE.
18182 Those typedefs were added to T by the function
18183 append_type_to_template_for_access_check. */
18187 {
18188 tree ti;
18199 {
18204 }
18207 }
18209 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
18210 tied to T. That list of typedefs will be access checked at
18211 T instantiation time.
18212 T is either a FUNCTION_DECL or a RECORD_TYPE.
18213 TYPE_DECL is a TYPE_DECL node representing a typedef.
18214 SCOPE is the scope through which TYPE_DECL is accessed.
18215 LOCATION is the location of the usage point of TYPE_DECL.
18217 This function is a subroutine of
18218 append_type_to_template_for_access_check. */
18220 static void
18222 tree type_decl,
18223 tree scope,
18224 location_t location)
18225 {
18226 qualified_typedef_usage_t typedef_usage;
18227 tree ti;
18234 && type_decl
18250 }
18252 /* Append TYPE_DECL to the template TEMPL.
18253 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
18254 At TEMPL instanciation time, TYPE_DECL will be checked to see
18255 if it can be accessed through SCOPE.
18256 LOCATION is the location of the usage point of TYPE_DECL.
18258 e.g. consider the following code snippet:
18260 class C
18261 {
18262 typedef int myint;
18263 };
18265 template<class U> struct S
18266 {
18267 C::myint mi; // <-- usage point of the typedef C::myint
18268 };
18270 S<char> s;
18272 At S<char> instantiation time, we need to check the access of C::myint
18273 In other words, we need to check the access of the myint typedef through
18274 the C scope. For that purpose, this function will add the myint typedef
18275 and the scope C through which its being accessed to a list of typedefs
18276 tied to the template S. That list will be walked at template instantiation
18277 time and access check performed on each typedefs it contains.
18278 Note that this particular code snippet should yield an error because
18279 myint is private to C. */
18281 void
18283 tree type_decl,
18284 tree scope,
18285 location_t location)
18286 {
18292 /* Make sure we don't append the type to the template twice. */
18303 }
18305 /* Set up the hash tables for template instantiations. */
18307 void
18309 {
18311 hash_specialization,
18312 eq_specializations,
18313 ggc_free);
18315 hash_specialization,
18316 eq_specializations,
18317 ggc_free);
18318 }