| blob | eb9fc7f94c7cdf5b687b63d8e6841cdb4bdeffc2 |
1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992-2013 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
45 /* The type of functions taking a tree, and some additional data, and
46 returning an int. */
49 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
50 instantiations have been deferred, either because their definitions
51 were not yet available, or because we were putting off doing the work. */
55 };
70 /* Live only within one (recursive) call to tsubst_expr. We use
71 this to pass the statement expression node from the STMT_EXPR
72 to the EXPR_STMT that is its result. */
75 /* A map from local variable declarations in the body of the template
76 presently being instantiated to the corresponding instantiated
77 local variables. */
80 /* True if we've recursed into fn_type_unification too many times. */
84 {
85 tree tmpl;
86 tree args;
87 tree spec;
91 htab_t decl_specializations;
94 htab_t type_specializations;
96 /* Contains canonical template parameter types. The vector is indexed by
97 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
98 TREE_LIST, whose TREE_VALUEs contain the canonical template
99 parameters of various types and levels. */
102 #define UNIFY_ALLOW_NONE 0
103 #define UNIFY_ALLOW_MORE_CV_QUAL 1
104 #define UNIFY_ALLOW_LESS_CV_QUAL 2
105 #define UNIFY_ALLOW_DERIVED 4
106 #define UNIFY_ALLOW_INTEGER 8
107 #define UNIFY_ALLOW_OUTER_LEVEL 16
108 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
109 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
112 tbr_incomplete_type,
113 tbr_ambiguous_baseclass,
114 tbr_success
115 };
138 tree);
200 location_t);
208 /* Make the current scope suitable for access checking when we are
209 processing T. T can be FUNCTION_DECL for instantiated function
210 template, VAR_DECL for static member variable, or TYPE_DECL for
211 alias template (needed by instantiate_decl). */
213 static void
215 {
224 else
228 {
229 saved_access_scope = tree_cons
232 }
233 }
235 /* Restore the scope set up by push_access_scope. T is the node we
236 are processing. */
238 static void
240 {
242 {
245 }
249 else
251 }
253 /* Do any processing required when DECL (a member template
254 declaration) is finished. Returns the TEMPLATE_DECL corresponding
255 to DECL, unless it is a specialization, in which case the DECL
256 itself is returned. */
258 tree
260 {
267 {
268 tree type;
276 {
280 }
282 }
286 {
288 {
291 }
292 else
294 }
295 else
299 }
301 /* Create a template info node. */
303 tree
305 {
310 }
312 /* Return the template info node corresponding to T, whatever T is. */
314 tree
316 {
334 }
336 /* Returns the template nesting level of the indicated class TYPE.
338 For example, in:
339 template <class T>
340 struct A
341 {
342 template <class U>
343 struct B {};
344 };
346 A<T>::B<U> has depth two, while A<T> has depth one.
347 Both A<T>::B<int> and A<int>::B<U> have depth one, if
348 they are instantiations, not specializations.
350 This function is guaranteed to return 0 if passed NULL_TREE so
351 that, for example, `template_class_depth (current_class_type)' is
352 always safe. */
354 int
356 {
363 {
369 }
372 }
374 /* Subroutine of maybe_begin_member_template_processing.
375 Returns true if processing DECL needs us to push template parms. */
377 static bool
379 {
385 }
387 /* Subroutine of maybe_begin_member_template_processing.
388 Push the template parms in PARMS, starting from LEVELS steps into the
389 chain, and ending at the beginning, since template parms are listed
390 innermost first. */
392 static void
394 {
402 current_template_parms
408 NULL);
410 {
419 {
426 {
427 /* Make a CONST_DECL as is done in process_template_parm.
428 It is ugly that we recreate this here; the original
429 version built in process_template_parm is no longer
430 available. */
440 }
445 }
446 }
447 }
449 /* Restore the template parameter context for a member template or
450 a friend template defined in a class definition. */
452 void
454 {
455 tree parms;
459 {
464 {
467 }
470 }
472 /* Remember how many levels of template parameters we pushed so that
473 we can pop them later. */
475 }
477 /* Undo the effects of maybe_begin_member_template_processing. */
479 void
481 {
490 {
494 }
495 }
497 /* Return a new template argument vector which contains all of ARGS,
498 but has as its innermost set of arguments the EXTRA_ARGS. */
500 static tree
502 {
503 tree new_args;
521 }
523 /* Like add_to_template_args, but only the outermost ARGS are added to
524 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
525 (EXTRA_ARGS) levels are added. This function is used to combine
526 the template arguments from a partial instantiation with the
527 template arguments used to attain the full instantiation from the
528 partial instantiation. */
530 static tree
532 {
533 tree new_args;
535 /* If there are more levels of EXTRA_ARGS than there are ARGS,
536 something very fishy is going on. */
539 /* If *all* the new arguments will be the EXTRA_ARGS, just return
540 them. */
544 /* For the moment, we make ARGS look like it contains fewer levels. */
549 /* Now, we restore ARGS to its full dimensions. */
553 }
555 /* Return the N levels of innermost template arguments from the ARGS. */
557 tree
559 {
560 tree new_args;
566 /* If N is 1, just return the innermost set of template arguments. */
570 /* If we're not removing anything, just return the arguments we were
571 given. */
577 /* Make a new set of arguments, not containing the outer arguments. */
584 }
586 /* The inverse of get_innermost_template_args: Return all but the innermost
587 EXTRA_LEVELS levels of template arguments from the ARGS. */
589 static tree
591 {
592 tree new_args;
598 /* If N is 1, just return the outermost set of template arguments. */
602 /* If we're not removing anything, just return the arguments we were
603 given. */
608 /* Make a new set of arguments, not containing the inner arguments. */
615 }
617 /* We've got a template header coming up; push to a new level for storing
618 the parms. */
620 void
622 {
623 /* We use a non-tag-transparent scope here, which causes pushtag to
624 put tags in this scope, rather than in the enclosing class or
625 namespace scope. This is the right thing, since we want
626 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
627 global template class, push_template_decl handles putting the
628 TEMPLATE_DECL into top-level scope. For a nested template class,
629 e.g.:
631 template <class T> struct S1 {
632 template <class T> struct S2 {};
633 };
635 pushtag contains special code to call pushdecl_with_scope on the
636 TEMPLATE_DECL for S2. */
641 }
643 /* This routine is called when a specialization is declared. If it is
644 invalid to declare a specialization here, an error is reported and
645 false is returned, otherwise this routine will return true. */
647 static bool
649 {
652 /* [temp.expl.spec]
654 An explicit specialization shall be declared in the namespace of
655 which the template is a member, or, for member templates, in the
656 namespace of which the enclosing class or enclosing class
657 template is a member. An explicit specialization of a member
658 function, member class or static data member of a class template
659 shall be declared in the namespace of which the class template
660 is a member. */
662 {
665 }
667 /* [temp.expl.spec]
669 In an explicit specialization declaration for a member of a class
670 template or a member template that appears in namespace scope,
671 the member template and some of its enclosing class templates may
672 remain unspecialized, except that the declaration shall not
673 explicitly specialize a class member template if its enclosing
674 class templates are not explicitly specialized as well. */
676 {
679 }
682 }
684 /* We've just seen template <>. */
686 bool
688 {
692 }
694 /* Called at then end of processing a declaration preceded by
695 template<>. */
697 void
699 {
702 }
704 /* Any template <>'s that we have seen thus far are not referring to a
705 function specialization. */
707 void
709 {
712 }
714 /* We've just seen a template header. If SPECIALIZATION is nonzero,
715 it was of the form template <>. */
717 static void
719 {
721 template_header_count++;
722 }
724 /* We're beginning an explicit instantiation. */
726 void
728 {
731 }
734 void
736 {
739 }
741 /* An explicit specialization or partial specialization of TMPL is being
742 declared. Check that the namespace in which the specialization is
743 occurring is permissible. Returns false iff it is invalid to
744 specialize TMPL in the current namespace. */
746 static bool
748 {
751 /* [tmpl.expl.spec]
753 An explicit specialization shall be declared in the namespace of
754 which the template is a member, or, for member templates, in the
755 namespace of which the enclosing class or enclosing class
756 template is a member. An explicit specialization of a member
757 function, member class or static data member of a class template
758 shall be declared in the namespace of which the class template is
759 a member. */
762 {
765 }
767 /* Same or super-using namespace. */
769 else
770 {
774 }
775 }
777 /* SPEC is an explicit instantiation. Check that it is valid to
778 perform this explicit instantiation in the current namespace. */
780 static void
782 {
783 tree ns;
785 /* DR 275: An explicit instantiation shall appear in an enclosing
786 namespace of its template. */
792 }
794 /* The TYPE is being declared. If it is a template type, that means it
795 is a partial specialization. Do appropriate error-checking. */
797 tree
799 {
800 tree context;
805 /* A lambda that appears in specialization context is not itself a
806 specialization. */
811 {
815 }
820 {
825 else
828 }
830 {
831 /* This is for ordinary explicit specialization and partial
832 specialization of a template class such as:
834 template <> class C<int>;
836 or:
838 template <class T> class C<T*>;
840 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
844 {
849 {
853 }
854 }
860 /* Trying to define a specialization either without a template<> header
861 or in an inappropriate place. We've already given an error, so just
862 bail now so we don't actually define the specialization. */
864 }
870 {
871 /* This is for an explicit specialization of member class
872 template according to [temp.expl.spec/18]:
874 template <> template <class U> class C<int>::D;
876 The context `C<int>' must be an implicit instantiation.
877 Otherwise this is just a member class template declared
878 earlier like:
880 template <> class C<int> { template <class U> class D; };
881 template <> template <class U> class C<int>::D;
883 In the first case, `C<int>::D' is a specialization of `C<T>::D'
884 while in the second case, `C<int>::D' is a primary template
885 and `C<T>::D' may not exist. */
889 {
890 tree t;
895 {
898 }
900 /* Check for invalid specialization after instantiation:
902 template <> template <> class C<int>::D<int>;
903 template <> template <class U> class C<int>::D; */
907 {
910 {
911 /* We already have a full specialization of this partial
912 instantiation. Reassign it to the new member
913 specialization template. */
914 spec_entry elt;
931 }
933 /* But if we've had an implicit instantiation, that's a
934 problem ([temp.expl.spec]/6). */
937 }
939 /* Mark TYPE as a specialization. And as a result, we only
940 have one level of template argument for the innermost
941 class template. */
946 }
947 }
949 {
950 /* Someday C++0x may allow for enum template specialization. */
955 else
956 {
959 }
960 }
963 }
965 /* Returns nonzero if we can optimize the retrieval of specializations
966 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
967 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
971 {
974 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
975 parameter. */
977 /* The optimized lookup depends on the fact that the
978 template arguments for the member function template apply
979 purely to the containing class, which is not true if the
980 containing class is an explicit or partial
981 specialization. */
985 /* It is possible to have a template that is not a member
986 template and is not a member of a template class:
988 template <typename T>
989 struct S { friend A::f(); };
991 Here, the friend function is a template, but the context does
992 not have template information. The optimized lookup relies
993 on having ARGS be the template arguments for both the class
994 and the function template. */
996 }
998 /* Retrieve the specialization (in the sense of [temp.spec] - a
999 specialization is either an instantiation or an explicit
1000 specialization) of TMPL for the given template ARGS. If there is
1001 no such specialization, return NULL_TREE. The ARGS are a vector of
1002 arguments, or a vector of vectors of arguments, in the case of
1003 templates with more than one level of parameters.
1005 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1006 then we search for a partial specialization matching ARGS. This
1007 parameter is ignored if TMPL is not a class template. */
1009 static tree
1011 {
1017 /* There should be as many levels of arguments as there are
1018 levels of parameters. */
1023 {
1024 tree class_template;
1025 tree class_specialization;
1027 tree fns;
1030 /* The template arguments actually apply to the containing
1031 class. Find the class specialization with those
1032 arguments. */
1034 class_specialization
1038 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1039 for the specialization. */
1043 /* Iterate through the methods with the indicated name, looking
1044 for the one that has an instance of TMPL. */
1047 {
1050 /* using-declarations can add base methods to the method vec,
1051 and we don't want those here. */
1054 }
1056 }
1057 else
1058 {
1060 spec_entry elt;
1061 htab_t specializations;
1069 else
1077 }
1080 }
1082 /* Like retrieve_specialization, but for local declarations. */
1084 static tree
1086 {
1094 }
1096 /* Returns nonzero iff DECL is a specialization of TMPL. */
1098 int
1100 {
1101 tree t;
1104 {
1110 }
1111 else
1112 {
1121 }
1124 }
1126 /* Returns nonzero iff DECL is a specialization of friend declaration
1127 FRIEND_DECL according to [temp.friend]. */
1129 bool
1131 {
1138 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1139 of a template class, we want to check if DECL is a specialization
1140 if this. */
1144 {
1145 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1148 }
1153 /* There is nothing to do if this is not a template friend. */
1160 /* [temp.friend/6]
1161 A member of a class template may be declared to be a friend of a
1162 non-template class. In this case, the corresponding member of
1163 every specialization of the class template is a friend of the
1164 class granting friendship.
1166 For example, given a template friend declaration
1168 template <class T> friend void A<T>::f();
1170 the member function below is considered a friend
1172 template <> struct A<int> {
1173 void f();
1174 };
1176 For this type of template friend, TEMPLATE_DEPTH below will be
1177 nonzero. To determine if DECL is a friend of FRIEND, we first
1178 check if the enclosing class is a specialization of another. */
1185 {
1186 /* Next, we check the members themselves. In order to handle
1187 a few tricky cases, such as when FRIEND_DECL's are
1189 template <class T> friend void A<T>::g(T t);
1190 template <class T> template <T t> friend void A<T>::h();
1192 and DECL's are
1194 void A<int>::g(int);
1195 template <int> void A<int>::h();
1197 we need to figure out ARGS, the template arguments from
1198 the context of DECL. This is required for template substitution
1199 of `T' in the function parameter of `g' and template parameter
1200 of `h' in the above examples. Here ARGS corresponds to `int'. */
1207 {
1209 {
1212 else
1214 current_depth++;
1215 }
1217 }
1220 {
1222 tree friend_type;
1223 tree decl_type;
1224 tree friend_args_type;
1225 tree decl_args_type;
1227 /* Make sure that both DECL and FRIEND_DECL are templates or
1228 non-templates. */
1234 {
1235 /* If both are templates, check template parameter list. */
1236 tree friend_parms
1241 friend_parms))
1245 }
1246 else
1254 /* Check if return types match. */
1258 /* Check if function parameter types match, ignoring the
1259 `this' parameter. */
1268 }
1269 else
1270 {
1271 /* DECL is a TYPE_DECL */
1275 /* Make sure that both DECL and FRIEND_DECL are templates or
1276 non-templates. */
1277 is_template
1284 {
1285 tree friend_parms;
1286 /* If both are templates, check the name of the two
1287 TEMPLATE_DECL's first because is_friend didn't. */
1292 /* Now check template parameter list. */
1293 friend_parms
1296 return comp_template_parms
1298 friend_parms);
1299 }
1300 else
1303 }
1304 }
1306 }
1308 /* Register the specialization SPEC as a specialization of TMPL with
1309 the indicated ARGS. IS_FRIEND indicates whether the specialization
1310 is actually just a friend declaration. Returns SPEC, or an
1311 equivalent prior declaration, if available. */
1313 static tree
1315 hashval_t hash)
1316 {
1317 tree fn;
1319 spec_entry elt;
1325 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1326 register it; we want the corresponding TEMPLATE_DECL instead.
1327 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1328 the more obvious `uses_template_parms (spec)' to avoid problems
1329 with default function arguments. In particular, given
1330 something like this:
1332 template <class T> void f(T t1, T t = T())
1334 the default argument expression is not substituted for in an
1335 instantiation unless and until it is actually needed. */
1339 /* We don't put these specializations in the hash table, but we might
1340 want to give an error about a mismatch. */
1342 else
1343 {
1351 slot =
1355 else
1357 }
1359 /* We can sometimes try to re-register a specialization that we've
1360 already got. In particular, regenerate_decl_from_template calls
1361 duplicate_decls which will update the specialization list. But,
1362 we'll still get called again here anyhow. It's more convenient
1363 to simply allow this than to try to prevent it. */
1367 {
1369 {
1372 {
1374 fn);
1376 }
1377 else
1378 {
1379 tree clone;
1380 /* This situation should occur only if the first
1381 specialization is an implicit instantiation, the
1382 second is an explicit specialization, and the
1383 implicit instantiation has not yet been used. That
1384 situation can occur if we have implicitly
1385 instantiated a member function and then specialized
1386 it later.
1388 We can also wind up here if a friend declaration that
1389 looked like an instantiation turns out to be a
1390 specialization:
1392 template <class T> void foo(T);
1393 class S { friend void foo<>(int) };
1394 template <> void foo(int);
1396 We transform the existing DECL in place so that any
1397 pointers to it become pointers to the updated
1398 declaration.
1400 If there was a definition for the template, but not
1401 for the specialization, we want this to look as if
1402 there were no definition, and vice versa. */
1405 /* The call to duplicate_decls will have applied
1406 [temp.expl.spec]:
1408 An explicit specialization of a function template
1409 is inline only if it is explicitly declared to be,
1410 and independently of whether its function template
1411 is.
1413 to the primary function; now copy the inline bits to
1414 the various clones. */
1416 {
1421 }
1425 }
1426 }
1428 {
1430 /* Dup decl failed, but this is a new definition. Set the
1431 line number so any errors match this new
1432 definition. */
1436 }
1437 }
1441 /* A specialization must be declared in the same namespace as the
1442 template it is specializing. */
1448 {
1456 /* TMPL is a forward declaration of a template function; keep a list
1457 of all specializations in case we need to reassign them to a friend
1458 template later in tsubst_friend_function. */
1461 }
1464 }
1466 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1467 TMPL and ARGS members, ignores SPEC. */
1471 static int
1473 {
1484 }
1486 /* Returns a hash for a template TMPL and template arguments ARGS. */
1488 static hashval_t
1490 {
1493 }
1495 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1496 ignoring SPEC. */
1498 static hashval_t
1500 {
1503 }
1505 /* Recursively calculate a hash value for a template argument ARG, for use
1506 in the hash tables of template specializations. */
1508 hashval_t
1510 {
1522 /* We can get one of these when re-hashing a previous entry in the middle
1523 of substituting into a pack expansion. Just look through it. */
1532 {
1540 {
1545 }
1567 {
1570 {
1573 }
1575 }
1579 {
1582 }
1593 val = iterative_hash_template_arg
1605 val);
1607 val);
1616 /* A lambda can't appear in a template arg, but don't crash on
1617 erroneous input. */
1629 /* Now hash operands as usual. */
1634 }
1637 {
1641 val);
1644 /* Otherwise just compare the types during lookup. */
1653 {
1658 }
1659 }
1662 }
1664 /* Unregister the specialization SPEC as a specialization of TMPL.
1665 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1666 if the SPEC was listed as a specialization of TMPL.
1668 Note that SPEC has been ggc_freed, so we can't look inside it. */
1670 bool
1672 {
1674 spec_entry elt;
1682 {
1687 }
1690 }
1692 /* Like register_specialization, but for local declarations. We are
1693 registering SPEC, an instantiation of TMPL. */
1695 static void
1697 {
1702 }
1704 /* TYPE is a class type. Returns true if TYPE is an explicitly
1705 specialized class. */
1707 bool
1709 {
1713 }
1715 /* Print the list of functions at FNS, going through all the overloads
1716 for each element of the list. Alternatively, FNS can not be a
1717 TREE_LIST, in which case it will be printed together with all the
1718 overloads.
1720 MORE and *STR should respectively be FALSE and NULL when the function
1721 is called from the outside. They are used internally on recursive
1722 calls. print_candidates manages the two parameters and leaves NULL
1723 in *STR when it ends. */
1725 static void
1727 {
1733 {
1737 }
1738 else
1739 {
1742 {
1743 /* Pick the prefix string. */
1745 {
1749 }
1753 }
1756 }
1759 {
1762 }
1763 }
1765 /* Print the list of candidate FNS in an error message. FNS can also
1766 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1768 void
1770 {
1774 }
1776 /* Returns the template (one of the functions given by TEMPLATE_ID)
1777 which can be specialized to match the indicated DECL with the
1778 explicit template args given in TEMPLATE_ID. The DECL may be
1779 NULL_TREE if none is available. In that case, the functions in
1780 TEMPLATE_ID are non-members.
1782 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1783 specialization of a member template.
1785 The TEMPLATE_COUNT is the number of references to qualifying
1786 template classes that appeared in the name of the function. See
1787 check_explicit_specialization for a more accurate description.
1789 TSK indicates what kind of template declaration (if any) is being
1790 declared. TSK_TEMPLATE indicates that the declaration given by
1791 DECL, though a FUNCTION_DECL, has template parameters, and is
1792 therefore a template function.
1794 The template args (those explicitly specified and those deduced)
1795 are output in a newly created vector *TARGS_OUT.
1797 If it is impossible to determine the result, an error message is
1798 issued. The error_mark_node is returned to indicate failure. */
1800 static tree
1802 tree decl,
1806 tmpl_spec_kind tsk)
1807 {
1808 tree fns;
1809 tree targs;
1810 tree explicit_targs;
1812 /* A TREE_LIST of templates of which DECL may be a specialization.
1813 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1814 corresponding TREE_PURPOSE is the set of template arguments that,
1815 when used to instantiate the template, would produce a function
1816 with the signature of DECL. */
1826 /* We shouldn't be specializing a member template of an
1827 unspecialized class template; we already gave an error in
1828 check_specialization_scope, now avoid crashing. */
1831 {
1834 }
1842 /* Check for baselinks. */
1847 {
1850 }
1852 /* Count the number of template headers specified for this
1853 specialization. */
1861 {
1865 {
1866 tree decl_arg_types;
1867 tree fn_arg_types;
1868 tree insttype;
1870 /* In case of explicit specialization, we need to check if
1871 the number of template headers appearing in the specialization
1872 is correct. This is usually done in check_explicit_specialization,
1873 but the check done there cannot be exhaustive when specializing
1874 member functions. Consider the following code:
1876 template <> void A<int>::f(int);
1877 template <> template <> void A<int>::f(int);
1879 Assuming that A<int> is not itself an explicit specialization
1880 already, the first line specializes "f" which is a non-template
1881 member function, whilst the second line specializes "f" which
1882 is a template member function. So both lines are syntactically
1883 correct, and check_explicit_specialization does not reject
1884 them.
1886 Here, we can do better, as we are matching the specialization
1887 against the declarations. We count the number of template
1888 headers, and we check if they match TEMPLATE_COUNT + 1
1889 (TEMPLATE_COUNT is the number of qualifying template classes,
1890 plus there must be another header for the member template
1891 itself).
1893 Notice that if header_count is zero, this is not a
1894 specialization but rather a template instantiation, so there
1895 is no check we can perform here. */
1899 /* Check that the number of template arguments at the
1900 innermost level for DECL is the same as for FN. */
1908 /* DECL might be a specialization of FN. */
1912 /* For a non-static member function, we need to make sure
1913 that the const qualification is the same. Since
1914 get_bindings does not try to merge the "this" parameter,
1915 we must do the comparison explicitly. */
1921 /* Skip the "this" parameter and, for constructors of
1922 classes with virtual bases, the VTT parameter. A
1923 full specialization of a constructor will have a VTT
1924 parameter, but a template never will. */
1925 decl_arg_types
1927 fn_arg_types
1930 /* Function templates cannot be specializations; there are
1931 no partial specializations of functions. Therefore, if
1932 the type of DECL does not match FN, there is no
1933 match. */
1935 {
1939 }
1941 /* See whether this function might be a specialization of this
1942 template. Suppress access control because we might be trying
1943 to make this specialization a friend, and we have already done
1944 access control for the declaration of the specialization. */
1950 /* We cannot deduce template arguments that when used to
1951 specialize TMPL will produce DECL. */
1954 /* Make sure that the deduced arguments actually work. */
1958 fn_arg_types
1963 /* Save this template, and the arguments deduced. */
1965 }
1967 /* FN is an ordinary member function, and we need a
1968 specialization of a member template. */
1969 ;
1971 /* We can get IDENTIFIER_NODEs here in certain erroneous
1972 cases. */
1973 ;
1975 /* This is just an ordinary non-member function. Nothing can
1976 be a specialization of that. */
1977 ;
1979 /* Cannot specialize functions that are created implicitly. */
1980 ;
1981 else
1982 {
1983 tree decl_arg_types;
1985 /* This is an ordinary member function. However, since
1986 we're here, we can assume it's enclosing class is a
1987 template class. For example,
1989 template <typename T> struct S { void f(); };
1990 template <> void S<int>::f() {}
1992 Here, S<int>::f is a non-template, but S<int> is a
1993 template class. If FN has the same type as DECL, we
1994 might be in business. */
1997 /* Its enclosing class is an explicit specialization
1998 of a template class. This is not a candidate. */
2003 /* The return types differ. */
2006 /* Adjust the type of DECL in case FN is a static member. */
2013 decl_arg_types))
2014 /* They match! */
2016 }
2017 }
2020 {
2021 /* We have:
2023 [temp.expl.spec]
2025 It is possible for a specialization with a given function
2026 signature to be instantiated from more than one function
2027 template. In such cases, explicit specification of the
2028 template arguments must be used to uniquely identify the
2029 function template specialization being specialized.
2031 Note that here, there's no suggestion that we're supposed to
2032 determine which of the candidate templates is most
2033 specialized. However, we, also have:
2035 [temp.func.order]
2037 Partial ordering of overloaded function template
2038 declarations is used in the following contexts to select
2039 the function template to which a function template
2040 specialization refers:
2042 -- when an explicit specialization refers to a function
2043 template.
2045 So, we do use the partial ordering rules, at least for now.
2046 This extension can only serve to make invalid programs valid,
2047 so it's safe. And, there is strong anecdotal evidence that
2048 the committee intended the partial ordering rules to apply;
2049 the EDG front end has that behavior, and John Spicer claims
2050 that the committee simply forgot to delete the wording in
2051 [temp.expl.spec]. */
2054 {
2057 }
2058 }
2061 {
2069 }
2073 {
2079 }
2081 /* We have one, and exactly one, match. */
2083 {
2086 /* DECL is a re-declaration or partial instantiation of a template
2087 function. */
2090 /* It was a specialization of an ordinary member function in a
2091 template class. */
2093 }
2095 /* It was a specialization of a template. */
2098 {
2103 }
2104 else
2107 }
2109 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2110 but with the default argument values filled in from those in the
2111 TMPL_TYPES. */
2113 static tree
2115 tree tmpl_types)
2116 {
2117 tree new_spec_types;
2125 /* Substitute into the rest of the list. */
2126 new_spec_types =
2130 /* Add the default argument for this parameter. */
2133 new_spec_types);
2134 }
2136 /* DECL is an explicit specialization. Replicate default arguments
2137 from the template it specializes. (That way, code like:
2139 template <class T> void f(T = 3);
2140 template <> void f(double);
2141 void g () { f (); }
2143 works, as required.) An alternative approach would be to look up
2144 the correct default arguments at the call-site, but this approach
2145 is consistent with how implicit instantiations are handled. */
2147 static void
2149 {
2150 tree tmpl;
2151 tree spec_types;
2152 tree tmpl_types;
2153 tree new_spec_types;
2154 tree old_type;
2155 tree new_type;
2156 tree t;
2161 /* See if there's anything we need to do. */
2174 {
2175 /* Remove the this pointer, but remember the object's type for
2176 CV quals. */
2182 {
2183 /* DECL may contain more parameters than TMPL due to the extra
2184 in-charge parameter in constructors and destructors. */
2187 }
2189 {
2192 }
2193 }
2195 /* Compute the merged default arguments. */
2196 new_spec_types =
2199 /* Compute the new FUNCTION_TYPE. */
2201 {
2205 new_spec_types);
2208 /* Put the in-charge parameter back. */
2211 new_spec_types);
2215 new_spec_types);
2216 }
2217 else
2219 new_spec_types);
2225 }
2227 /* Return the number of template headers we expect to see for a definition
2228 or specialization of CTYPE or one of its non-template members. */
2230 int
2232 {
2236 {
2237 /* You're supposed to have one `template <...>' for every
2238 template class, but you don't need one for a full
2239 specialization. For example:
2241 template <class T> struct S{};
2242 template <> struct S<int> { void f(); };
2243 void S<int>::f () {}
2245 is correct; there shouldn't be a `template <>' for the
2246 definition of `S<int>::f'. */
2248 /* If CTYPE does not have template information of any
2249 kind, then it is not a template, nor is it nested
2250 within a template. */
2258 }
2261 }
2263 /* Do a simple sanity check on the template headers that precede the
2264 variable declaration DECL. */
2266 void
2268 {
2275 {
2281 "members of an explicitly specialized class are defined "
2283 }
2284 }
2286 /* Check to see if the function just declared, as indicated in
2287 DECLARATOR, and in DECL, is a specialization of a function
2288 template. We may also discover that the declaration is an explicit
2289 instantiation at this point.
2291 Returns DECL, or an equivalent declaration that should be used
2292 instead if all goes well. Issues an error message if something is
2293 amiss. Returns error_mark_node if the error is not easily
2294 recoverable.
2296 FLAGS is a bitmask consisting of the following flags:
2298 2: The function has a definition.
2299 4: The function is a friend.
2301 The TEMPLATE_COUNT is the number of references to qualifying
2302 template classes that appeared in the name of the function. For
2303 example, in
2305 template <class T> struct S { void f(); };
2306 void S<int>::f();
2308 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2309 classes are not counted in the TEMPLATE_COUNT, so that in
2311 template <class T> struct S {};
2312 template <> struct S<int> { void f(); }
2313 template <> void S<int>::f();
2315 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2316 invalid; there should be no template <>.)
2318 If the function is a specialization, it is marked as such via
2319 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2320 is set up correctly, and it is added to the list of specializations
2321 for that template. */
2323 tree
2325 tree decl,
2328 {
2336 tmpl_spec_kind tsk;
2339 {
2342 else
2344 }
2345 else
2349 {
2352 {
2355 }
2357 {
2359 /* This could be something like:
2361 template <class T> void f(T);
2362 class S { friend void f<>(int); } */
2364 else
2365 {
2366 /* This case handles bogus declarations like template <>
2367 template <class T> void f<int>(); */
2370 declarator);
2372 }
2373 }
2377 /* The error has already been reported in
2378 check_specialization_scope. */
2384 /* Fall through. */
2397 decl);
2400 else
2404 /* Fall through. */
2409 else
2415 {
2416 /* This case handles bogus declarations like template <>
2417 template <class T> void f<int>(); */
2422 else
2424 declarator);
2426 }
2429 /* This is a specialization of a member template, without
2430 specialization the containing class. Something like:
2432 template <class T> struct S {
2433 template <class U> void f (U);
2434 };
2435 template <> template <class U> void S<int>::f(U) {}
2437 That's a specialization -- but of the entire template. */
2443 }
2446 {
2450 {
2454 }
2455 }
2458 {
2462 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2464 {
2465 tree fns;
2470 else
2471 {
2472 /* If there is no class context, the explicit instantiation
2473 must be at namespace scope. */
2476 /* Find the namespace binding, using the declaration
2477 context. */
2481 {
2484 }
2485 else
2486 {
2492 }
2493 }
2496 }
2502 {
2504 /* A specialization in class scope. This is invalid,
2505 but the error will already have been flagged by
2506 check_specialization_scope. */
2508 else
2509 {
2510 /* It's not valid to write an explicit instantiation in
2511 class scope, e.g.:
2513 class C { template void f(); }
2515 This case is caught by the parser. However, on
2516 something like:
2518 template class C { void f(); };
2520 (which is invalid) we can get here. The error will be
2521 issued later. */
2522 ;
2523 }
2526 }
2529 IDENTIFIER_NODE))
2530 {
2531 /* Find the list of functions in ctype that have the same
2532 name as the declared function. */
2538 {
2543 {
2544 /* From [temp.expl.spec]:
2546 If such an explicit specialization for the member
2547 of a class template names an implicitly-declared
2548 special member function (clause _special_), the
2549 program is ill-formed.
2551 Similar language is found in [temp.explicit]. */
2554 }
2557 }
2560 {
2564 }
2565 else
2566 {
2568 tree ovl;
2570 /* For a type-conversion operator, we cannot do a
2571 name-based lookup. We might be looking for `operator
2572 int' which will be a specialization of `operator T'.
2573 So, we find *all* the conversion operators, and then
2574 select from them. */
2582 {
2584 /* There are no more conversion functions. */
2587 /* Glue all these conversion functions together
2588 with those we already have. */
2591 }
2592 }
2595 {
2598 }
2599 else
2601 }
2603 /* Figure out what exactly is being specialized at this point.
2604 Note that for an explicit instantiation, even one for a
2605 member function, we cannot tell apriori whether the
2606 instantiation is for a member template, or just a member
2607 function of a template class. Even if a member template is
2608 being instantiated, the member template arguments may be
2609 elided if they can be deduced from the rest of the
2610 declaration. */
2613 member_specialization,
2614 template_count,
2615 tsk);
2618 /* We couldn't figure out what this declaration was
2619 specializing. */
2621 else
2622 {
2626 {
2627 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2628 is done by do_decl_instantiation later. */
2634 {
2635 /* If TMPL is not the most general template (for
2636 example, if TMPL is a friend template that is
2637 injected into namespace scope), then there will
2638 be too many levels of TARGS. Remove some of them
2639 here. */
2641 tree new_targs;
2648 }
2651 }
2653 /* If we thought that the DECL was a member function, but it
2654 turns out to be specializing a static member function,
2655 make DECL a static member function as well. */
2660 /* If this is a specialization of a member template of a
2661 template class, we want to return the TEMPLATE_DECL, not
2662 the specialization of it. */
2664 {
2669 {
2670 tree parm;
2674 /* We want to use the argument list specified in the
2675 definition, not in the original declaration. */
2680 }
2683 }
2685 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2688 /* Inherit default function arguments from the template
2689 DECL is specializing. */
2692 /* This specialization has the same protection as the
2693 template it specializes. */
2697 /* 7.1.1-1 [dcl.stc]
2699 A storage-class-specifier shall not be specified in an
2700 explicit specialization...
2702 The parser rejects these, so unless action is taken here,
2703 explicit function specializations will always appear with
2704 global linkage.
2706 The action recommended by the C++ CWG in response to C++
2707 defect report 605 is to make the storage class and linkage
2708 of the explicit specialization match the templated function:
2710 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2711 */
2713 {
2717 /* This specialization has the same linkage and visibility as
2718 the function template it specializes. */
2721 {
2724 }
2727 {
2730 }
2731 }
2733 /* If DECL is a friend declaration, declared using an
2734 unqualified name, the namespace associated with DECL may
2735 have been set incorrectly. For example, in:
2737 template <typename T> void f(T);
2738 namespace N {
2739 struct S { friend void f<int>(int); }
2740 }
2742 we will have set the DECL_CONTEXT for the friend
2743 declaration to N, rather than to the global namespace. */
2748 /* This is not really a declaration of a specialization.
2749 It's just the name of an instantiation. But, it's not
2750 a request for an instantiation, either. */
2753 /* This is indeed a specialization. In case of constructors
2754 and destructors, we need in-charge and not-in-charge
2755 versions in V3 ABI. */
2758 /* Register this specialization so that we can find it
2759 again. */
2761 }
2762 }
2765 }
2767 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2768 parameters. These are represented in the same format used for
2769 DECL_TEMPLATE_PARMS. */
2771 int
2773 {
2774 const_tree p1;
2775 const_tree p2;
2783 {
2795 {
2799 /* If either of the template parameters are invalid, assume
2800 they match for the sake of error recovery. */
2813 }
2814 }
2817 /* One set of parameters has more parameters lists than the
2818 other. */
2822 }
2824 /* Determine whether PARM is a parameter pack. */
2826 bool
2828 {
2829 /* Determine if we have a non-type template parameter pack. */
2836 /* If this is a list of template parameters, we could get a
2837 TYPE_DECL or a TEMPLATE_DECL. */
2841 /* Otherwise it must be a type template parameter. */
2845 }
2847 /* Determine if T is a function parameter pack. */
2849 bool
2851 {
2855 }
2857 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2858 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2860 tree
2862 {
2869 }
2871 /* Return true iff the function parameter PARAM_DECL was expanded
2872 from the function parameter pack PACK. */
2874 bool
2876 {
2881 /* The parameter pack and its pack arguments have the same
2882 DECL_PARM_INDEX. */
2884 }
2886 /* Determine whether ARGS describes a variadic template args list,
2887 i.e., one that is terminated by a template argument pack. */
2889 static bool
2891 {
2893 tree last_parm;
2907 }
2909 /* Generate a new name for the parameter pack name NAME (an
2910 IDENTIFIER_NODE) that incorporates its */
2912 static tree
2914 {
2915 /* Munge the name to include the parameter index. */
2916 #define NUMBUF_LEN 128
2930 }
2932 /* Return true if T is a primary function, class or alias template
2933 instantiation. */
2935 bool
2937 {
2951 }
2953 /* Return true if PARM is a template template parameter. */
2955 bool
2957 {
2959 }
2961 /* Return true iff PARM is a DECL representing a type template
2962 parameter. */
2964 bool
2966 {
2971 }
2973 /* Return the template parameters of T if T is a
2974 primary template instantiation, NULL otherwise. */
2976 tree
2978 {
2983 parms = INNERMOST_TEMPLATE_PARMS
2987 }
2989 /* Return the template parameters of the LEVELth level from the full list
2990 of template parameters PARMS. */
2992 tree
2994 {
2995 tree p;
3006 }
3008 /* Returns the template arguments of T if T is a template instantiation,
3009 NULL otherwise. */
3011 tree
3013 {
3021 }
3023 /* Return the argument pack elements of T if T is a template argument pack,
3024 NULL otherwise. */
3026 tree
3028 {
3034 }
3036 /* Structure used to track the progress of find_parameter_packs_r. */
3037 struct find_parameter_pack_data
3038 {
3039 /* TREE_LIST that will contain all of the parameter packs found by
3040 the traversal. */
3043 /* Set of AST nodes that have been visited by the traversal. */
3045 };
3047 /* Identifies all of the argument packs that occur in a template
3048 argument and appends them to the TREE_LIST inside DATA, which is a
3049 find_parameter_pack_data structure. This is a subroutine of
3050 make_pack_expansion and uses_parameter_packs. */
3051 static tree
3053 {
3059 /* Handle type aliases/typedefs. */
3064 {
3071 }
3073 /* Identify whether this is a parameter pack or not. */
3075 {
3090 {
3091 /* We don't want to walk into the type of a PARM_DECL,
3092 because we don't want to see the type parameter pack. */
3095 }
3102 /* Not a parameter pack. */
3104 }
3107 {
3108 /* Add this parameter pack to the list. */
3110 }
3116 /* This switch statement will return immediately if we don't find a
3117 parameter pack. */
3119 {
3124 /* Check the template itself. */
3127 /* Check the template arguments. */
3143 /* Fall through. */
3185 }
3188 }
3190 /* Determines if the expression or type T uses any parameter packs. */
3191 bool
3193 {
3201 }
3203 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3204 representation a base-class initializer into a parameter pack
3205 expansion. If all goes well, the resulting node will be an
3206 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3207 respectively. */
3208 tree
3210 {
3211 tree result;
3220 {
3221 /* The only time we will see a TREE_LIST here is for a base
3222 class initializer. In this case, the TREE_PURPOSE will be a
3223 _TYPE node (representing the base class expansion we're
3224 initializing) and the TREE_VALUE will be a TREE_LIST
3225 containing the initialization arguments.
3227 The resulting expansion looks somewhat different from most
3228 expansions. Rather than returning just one _EXPANSION, we
3229 return a TREE_LIST whose TREE_PURPOSE is a
3230 TYPE_PACK_EXPANSION containing the bases that will be
3231 initialized. The TREE_VALUE will be identical to the
3232 original TREE_VALUE, which is a list of arguments that will
3233 be passed to each base. We do not introduce any new pack
3234 expansion nodes into the TREE_VALUE (although it is possible
3235 that some already exist), because the TREE_PURPOSE and
3236 TREE_VALUE all need to be expanded together with the same
3237 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3238 resulting TREE_PURPOSE will mention the parameter packs in
3239 both the bases and the arguments to the bases. */
3240 tree purpose;
3241 tree value;
3244 /* Determine which parameter packs will be used by the base
3245 class expansion. */
3252 {
3256 }
3259 {
3260 /* Collect the sets of parameter packs used in each of the
3261 initialization arguments. */
3263 {
3264 /* Determine which parameter packs will be expanded in this
3265 argument. */
3268 }
3269 }
3273 /* Create the pack expansion type for the base type. */
3278 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3279 they will rarely be compared to anything. */
3283 }
3288 /* Build the PACK_EXPANSION_* node. */
3289 result = for_types
3294 {
3295 /* Propagate type and const-expression information. */
3298 }
3299 else
3300 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3301 they will rarely be compared to anything. */
3304 /* Determine which parameter packs will be expanded. */
3310 /* Make sure we found some parameter packs. */
3312 {
3315 else
3318 }
3324 }
3326 /* Checks T for any "bare" parameter packs, which have not yet been
3327 expanded, and issues an error if any are found. This operation can
3328 only be done on full expressions or types (e.g., an expression
3329 statement, "if" condition, etc.), because we could have expressions like:
3331 foo(f(g(h(args)))...)
3333 where "args" is a parameter pack. check_for_bare_parameter_packs
3334 should not be called for the subexpressions args, h(args),
3335 g(h(args)), or f(g(h(args))), because we would produce erroneous
3336 error messages.
3338 Returns TRUE and emits an error if there were bare parameter packs,
3339 returns FALSE otherwise. */
3340 bool
3342 {
3358 {
3361 {
3370 else
3375 else
3379 }
3382 }
3385 }
3387 /* Expand any parameter packs that occur in the template arguments in
3388 ARGS. */
3389 tree
3391 {
3397 /* First, determine if we need to expand anything, and the number of
3398 slots we'll need. */
3400 {
3405 {
3409 else
3411 }
3412 else
3413 {
3415 num_result_args++;
3416 }
3417 }
3419 /* If no expansion is necessary, we're done. */
3423 /* Expand arguments. */
3426 non_default_args_count =
3429 {
3432 {
3439 }
3440 else
3441 {
3444 }
3445 }
3449 }
3451 /* Checks if DECL shadows a template parameter.
3453 [temp.local]: A template-parameter shall not be redeclared within its
3454 scope (including nested scopes).
3456 Emits an error and returns TRUE if the DECL shadows a parameter,
3457 returns FALSE otherwise. */
3459 bool
3461 {
3462 tree olddecl;
3464 /* If we're not in a template, we can't possibly shadow a template
3465 parameter. */
3469 /* Figure out what we're shadowing. */
3474 /* If there's no previous binding for this name, we're not shadowing
3475 anything, let alone a template parameter. */
3479 /* If we're not shadowing a template parameter, we're done. Note
3480 that OLDDECL might be an OVERLOAD (or perhaps even an
3481 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3482 node. */
3486 /* We check for decl != olddecl to avoid bogus errors for using a
3487 name inside a class. We check TPFI to avoid duplicate errors for
3488 inline member templates. */
3496 }
3498 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3499 ORIG_LEVEL, DECL, and TYPE. */
3501 static tree
3505 tree decl,
3506 tree type)
3507 {
3518 }
3520 /* Find the canonical type parameter for the given template type
3521 parameter. Returns the canonical type parameter, which may be TYPE
3522 if no such parameter existed. */
3524 static tree
3526 {
3527 tree list;
3541 else
3542 {
3547 }
3548 }
3550 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3551 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3552 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3553 new one is created. */
3555 static tree
3557 tsubst_flags_t complain)
3558 {
3563 {
3582 /* Template template parameters need this. */
3587 }
3590 }
3592 /* Process information from new template parameter PARM and append it
3593 to the LIST being built. This new parameter is a non-type
3594 parameter iff IS_NON_TYPE is true. This new parameter is a
3595 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3596 is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template
3597 parameter list PARM belongs to. This is used used to create a
3598 proper canonical type for the type of PARM that is to be created,
3599 iff PARM is a type. If the size is not known, this parameter shall
3600 be set to 0. */
3602 tree
3605 {
3607 tree defval;
3608 tree err_parm_list;
3615 {
3619 {
3623 else
3625 }
3628 }
3629 else
3633 {
3639 {
3643 }
3644 else
3645 {
3646 /* [temp.param]
3648 The top-level cv-qualifiers on the template-parameter are
3649 ignored when determining its type. */
3652 {
3656 }
3659 {
3660 /* This template parameter is not a parameter pack, but it
3661 should be. Complain about "bare" parameter packs. */
3664 /* Recover by calling this a parameter pack. */
3666 }
3667 }
3669 /* A template parameter is not modifiable. */
3678 processing_template_decl,
3683 }
3684 else
3685 {
3686 tree t;
3690 {
3692 /* This is for distinguishing between real templates and template
3693 template parameters */
3697 }
3698 else
3699 {
3701 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3704 }
3711 processing_template_decl,
3715 }
3721 }
3723 /* The end of a template parameter list has been reached. Process the
3724 tree list into a parameter vector, converting each parameter into a more
3725 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3726 as PARM_DECLs. */
3728 tree
3730 {
3735 current_template_parms
3740 {
3744 }
3749 }
3751 /* end_template_decl is called after a template declaration is seen. */
3753 void
3755 {
3761 /* This matches the pushlevel in begin_template_parm_list. */
3766 }
3768 /* Takes a TREE_LIST representing a template parameter and convert it
3769 into an argument suitable to be passed to the type substitution
3770 functions. Note that If the TREE_LIST contains an error_mark
3771 node, the returned argument is error_mark_node. */
3773 static tree
3775 {
3788 {
3792 {
3793 /* Turn this argument into a TYPE_ARGUMENT_PACK
3794 with a single element, which expands T. */
3796 #ifdef ENABLE_CHECKING
3797 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3799 #endif
3804 }
3805 }
3806 else
3807 {
3811 {
3812 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3813 with a single element, which expands T. */
3816 #ifdef ENABLE_CHECKING
3817 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3819 #endif
3825 }
3826 }
3828 }
3830 /* Given a set of template parameters, return them as a set of template
3831 arguments. The template parameters are represented as a TREE_VEC, in
3832 the form documented in cp-tree.h for template arguments. */
3834 static tree
3836 {
3837 tree header;
3842 /* If there is only one level of template parameters, we do not
3843 create a TREE_VEC of TREE_VECs. Instead, we return a single
3844 TREE_VEC containing the arguments. */
3849 {
3857 #ifdef ENABLE_CHECKING
3859 #endif
3863 else
3865 }
3868 /* This can happen for template parms of a template template
3869 parameter, e.g:
3871 template<template<class T, class U> class TT> struct S;
3873 Consider the level of the parms of TT; T and U both have
3874 level 2; TT has no template parm of level 1. So in this case
3875 the first element of full_template_args is NULL_TREE. If we
3876 leave it like this TMPL_ARG_DEPTH on args returns 1 instead
3877 of 2. This will make tsubst wrongly consider that T and U
3878 have level 1. Instead, let's create a dummy vector as the
3879 first element of full_template_args so that TMPL_ARG_DEPTH
3880 returns the correct depth for args. */
3883 }
3885 /* Within the declaration of a template, return the currently active
3886 template parameters as an argument TREE_VEC. */
3888 static tree
3890 {
3892 }
3894 /* Update the declared TYPE by doing any lookups which were thought to be
3895 dependent, but are not now that we know the SCOPE of the declarator. */
3897 tree
3899 {
3910 /* Don't bother building up the args in this case. */
3912 {
3913 /* tsubst in the args corresponding to the template parameters,
3914 including auto if present. Most things will be unchanged, but
3915 make_typename_type and tsubst_qualified_id will resolve
3916 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3919 tree pushed;
3921 {
3925 }
3930 }
3936 {
3939 else
3941 }
3943 }
3945 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3946 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3947 a member template. Used by push_template_decl below. */
3949 static tree
3951 {
3959 }
3961 struct template_parm_data
3962 {
3963 /* The level of the template parameters we are currently
3964 processing. */
3967 /* The index of the specialization argument we are currently
3968 processing. */
3971 /* An array whose size is the number of template parameters. The
3972 elements are nonzero if the parameter has been used in any one
3973 of the arguments processed so far. */
3976 /* An array whose size is the number of template arguments. The
3977 elements are nonzero if the argument makes use of template
3978 parameters of this level. */
3980 };
3982 /* Subroutine of push_template_decl used to see if each template
3983 parameter in a partial specialization is used in the explicit
3984 argument list. If T is of the LEVEL given in DATA (which is
3985 treated as a template_parm_data*), then DATA->PARMS is marked
3986 appropriately. */
3988 static int
3990 {
3996 {
3999 }
4000 else
4001 {
4004 }
4007 {
4010 }
4012 /* Return zero so that for_each_template_parm will continue the
4013 traversal of the tree; we want to mark *every* template parm. */
4015 }
4017 /* Process the partial specialization DECL. */
4019 static tree
4021 {
4027 tree inner_parms;
4028 tree inst;
4041 /* We check that each of the template parameters given in the
4042 partial specialization is used in the argument list to the
4043 specialization. For example:
4045 template <class T> struct S;
4046 template <class T> struct S<T*>;
4048 The second declaration is OK because `T*' uses the template
4049 parameter T, whereas
4051 template <class T> struct S<int>;
4053 is no good. Even trickier is:
4055 template <class T>
4056 struct S1
4057 {
4058 template <class U>
4059 struct S2;
4060 template <class U>
4061 struct S2<T>;
4062 };
4064 The S2<T> declaration is actually invalid; it is a
4065 full-specialization. Of course,
4067 template <class U>
4068 struct S2<T (*)(U)>;
4070 or some such would have been OK. */
4078 {
4083 NULL,
4085 }
4088 {
4089 /* One of the template parms was not used in the
4090 specialization. */
4092 {
4095 }
4098 }
4103 /* [temp.class.spec]
4105 The argument list of the specialization shall not be identical to
4106 the implicit argument list of the primary template. */
4113 /* A partial specialization that replaces multiple parameters of the
4114 primary template with a pack expansion is less specialized for those
4115 parameters. */
4117 {
4119 "primary template because it replaces multiple parameters "
4123 }
4125 /* [temp.class.spec]
4127 A partially specialized non-type argument expression shall not
4128 involve template parameters of the partial specialization except
4129 when the argument expression is a simple identifier.
4131 The type of a template parameter corresponding to a specialized
4132 non-type argument shall not be dependent on a parameter of the
4133 specialization.
4135 Also, we verify that pack expansions only occur at the
4136 end of the argument list. */
4140 {
4147 {
4148 /* Extract the arguments from the argument pack. We'll be
4149 iterating over these in the following loop. */
4152 }
4155 {
4157 /* Get the Jth argument in the parameter pack. */
4161 {
4162 /* Pack expansions must come at the end of the
4163 argument list. */
4166 {
4170 else
4173 }
4174 }
4177 /* We only care about the pattern. */
4183 /* This next line is the `argument expression is not just a
4184 simple identifier' condition and also the `specialized
4185 non-type argument' bit. */
4187 {
4191 arg);
4192 else
4193 {
4194 /* Look at the corresponding template parameter,
4195 marking which template parameters its type depends
4196 upon. */
4200 {
4201 /* We haven't yet initialized TPD2. Do so now. */
4203 /* The number of parameters here is the number in the
4204 main template, which, as checked in the assertion
4205 above, is NARGS. */
4209 }
4211 /* Mark the template parameters. But this time, we're
4212 looking for the template parameters of the main
4213 template, not in the specialization. */
4220 NULL,
4224 {
4225 /* The type depended on some template parameters.
4226 If they are fully specialized in the
4227 specialization, that's OK. */
4236 "type %qT of template argument %qE depends "
4238 "type %qT of template argument %qE depends "
4240 type,
4241 arg);
4242 }
4243 }
4244 }
4245 }
4246 }
4248 /* We should only get here once. */
4258 {
4262 {
4266 "partial specialization of %qT after instantiation "
4268 }
4269 }
4272 }
4274 /* Check that a template declaration's use of default arguments and
4275 parameter packs is not invalid. Here, PARMS are the template
4276 parameters. IS_PRIMARY is true if DECL is the thing declared by
4277 a primary template. IS_PARTIAL is true if DECL is a partial
4278 specialization.
4280 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4281 declaration (but not a definition); 1 indicates a declaration, 2
4282 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4283 emitted for extraneous default arguments.
4285 Returns TRUE if there were no errors found, FALSE otherwise. */
4287 bool
4290 {
4293 tree parm_level;
4296 /* [temp.param]
4298 A default template-argument shall not be specified in a
4299 function template declaration or a function template definition, nor
4300 in the template-parameter-list of the definition of a member of a
4301 class template. */
4304 /* You can't have a function template declaration in a local
4305 scope, nor you can you define a member of a class template in a
4306 local scope. */
4313 /* If this is either a friend defined in the scope of the class
4314 or a member function. */
4320 /* And, if it was a member function, it really was defined in
4321 the scope of the class. */
4324 /* We already checked these parameters when the template was
4325 declared, so there's no need to do it again now. This function
4326 was defined in class scope, but we're processing it's body now
4327 that the class is complete. */
4330 /* Core issue 226 (C++0x only): the following only applies to class
4331 templates. */
4334 {
4335 /* [temp.param]
4337 If a template-parameter has a default template-argument, all
4338 subsequent template-parameters shall have a default
4339 template-argument supplied. */
4341 {
4348 {
4358 {
4360 /* For better subsequent error-recovery, we indicate that
4361 there should have been a default argument. */
4364 }
4366 && !is_friend_decl
4367 /* Don't complain about an enclosing partial
4368 specialization. */
4373 {
4374 /* A primary class template can only have one
4375 parameter pack, at the end of the template
4376 parameter list. */
4381 else
4389 }
4390 }
4391 }
4392 }
4395 || is_partial
4396 || !is_primary
4398 /* For an ordinary class template, default template arguments are
4399 allowed at the innermost level, e.g.:
4400 template <class T = int>
4401 struct S {};
4402 but, in a partial specialization, they're not allowed even
4403 there, as we have in [temp.class.spec]:
4405 The template parameter list of a specialization shall not
4406 contain default template argument values.
4408 So, for a partial specialization, or for a function template
4409 (in C++98/C++03), we look at all of them. */
4410 ;
4411 else
4412 /* But, for a primary class template that is not a partial
4413 specialization we look at all template parameters except the
4414 innermost ones. */
4417 /* Figure out what error message to issue. */
4430 else
4434 /* If we're inside a class definition, there's no need to
4435 examine the parameters to the class itself. On the one
4436 hand, they will be checked when the class is defined, and,
4437 on the other, default arguments are valid in things like:
4438 template <class T = double>
4439 struct S { template <class U> void f(U); };
4440 Here the default argument for `S' has no bearing on the
4441 declaration of `f'. */
4443 else
4444 /* Check everything. */
4450 {
4457 {
4462 {
4464 {
4471 }
4473 /* Clear out the default argument so that we are not
4474 confused later. */
4476 }
4477 }
4479 /* At this point, if we're still interested in issuing messages,
4480 they must apply to classes surrounding the object declared. */
4484 }
4487 }
4489 /* Worker for push_template_decl_real, called via
4490 for_each_template_parm. DATA is really an int, indicating the
4491 level of the parameters we are interested in. If T is a template
4492 parameter of that level, return nonzero. */
4494 static int
4496 {
4502 else
4505 }
4507 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4508 parameters given by current_template_args, or reuses a
4509 previously existing one, if appropriate. Returns the DECL, or an
4510 equivalent one, if it is replaced via a call to duplicate_decls.
4512 If IS_FRIEND is true, DECL is a friend declaration. */
4514 tree
4516 {
4517 tree tmpl;
4518 tree args;
4519 tree info;
4520 tree ctx;
4524 /* True if the template is a member template, in the sense of
4525 [temp.mem]. */
4531 /* See if this is a partial specialization. */
4540 /* For a friend, we want the context of the friend function, not
4541 the type of which it is a friend. */
4545 /* In the case of a virtual function, we want the class in which
4546 it is defined. */
4548 else
4549 /* Otherwise, if we're currently defining some class, the DECL
4550 is assumed to be a member of the class. */
4559 /* See if this is a primary template. */
4561 /* A friend template that specifies a class context, i.e.
4562 template <typename T> friend void A<T>::f();
4563 is not primary. */
4565 else
4569 {
4574 {
4577 }
4579 {
4581 {
4582 /* [temp.mem]
4584 A destructor shall not be a member template. */
4587 }
4594 {
4595 /* [basic.stc.dynamic.allocation]
4597 An allocation function can be a function
4598 template. ... Template allocation functions shall
4599 have two or more parameters. */
4602 }
4603 }
4609 /* alias-declaration */
4611 else
4612 {
4615 }
4616 }
4618 /* Check to see that the rules regarding the use of default
4619 arguments are not being violated. */
4623 /* Ensure that there are no parameter packs in the type of this
4624 declaration that have not been expanded. */
4626 {
4627 /* Check each of the arguments individually to see if there are
4628 any bare parameter packs. */
4634 {
4637 {
4638 /* This is a PARM_DECL that contains unexpanded parameter
4639 packs. We have already complained about this in the
4640 check_for_bare_parameter_packs call, so just replace
4641 these types with ERROR_MARK_NODE. */
4644 }
4648 }
4650 /* Check for bare parameter packs in the return type and the
4651 exception specifiers. */
4653 /* Errors were already issued, set return type to int
4654 as the frontend doesn't expect error_mark_node as
4655 the return type. */
4659 }
4664 {
4667 }
4678 {
4683 /* If DECL is a TYPE_DECL for a class-template, then there won't
4684 be DECL_LANG_SPECIFIC. The information equivalent to
4685 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4689 {
4690 /* Since a template declaration already existed for this
4691 class-type, we must be redeclaring it here. Make sure
4692 that the redeclaration is valid. */
4694 current_template_parms);
4695 /* We don't need to create a new TEMPLATE_DECL; just use the
4696 one we already had. */
4698 }
4699 else
4700 {
4702 member_template_p);
4707 {
4708 /* A specialization of a member template of a template
4709 class. */
4713 }
4714 }
4715 }
4716 else
4717 {
4723 {
4726 }
4734 {
4735 tree new_tmpl;
4737 /* The declaration is a specialization of a member
4738 template, declared outside the class. Therefore, the
4739 innermost template arguments will be NULL, so we
4740 replace them with the arguments determined by the
4741 earlier call to check_explicit_specialization. */
4744 new_tmpl
4746 member_template_p);
4756 args,
4759 }
4761 /* Make sure the template headers we got make sense. */
4766 {
4769 }
4770 else
4772 {
4777 {
4781 else
4785 /* Avoid crash in import_export_decl. */
4788 }
4793 /* Can happen in erroneous input. */
4795 else
4799 }
4801 /* Check that the parms are used in the appropriate qualifying scopes
4802 in the declarator. */
4806 {
4812 /* Avoid crash in import_export_decl. */
4815 }
4816 }
4821 /* Push template declarations for global functions and types. Note
4822 that we do not try to push a global template friend declared in a
4823 template class; such a thing may well depend on the template
4824 parameters of the class. */
4827 {
4832 /* Hide template friend classes that haven't been declared yet. */
4834 {
4837 }
4838 }
4841 {
4847 {
4850 /* It is a conversion operator. See if the type converted to
4851 depends on innermost template operands. */
4854 depth))
4856 }
4858 /* Give template template parms a DECL_CONTEXT of the template
4859 for which they are a parameter. */
4862 {
4866 }
4867 }
4869 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4870 back to its most general template. If TMPL is a specialization,
4871 ARGS may only have the innermost set of arguments. Add the missing
4872 argument levels if necessary. */
4880 else
4881 {
4886 }
4889 }
4891 tree
4893 {
4895 }
4897 /* FN is an inheriting constructor that inherits from the constructor
4898 template INHERITED; turn FN into a constructor template with a matching
4899 template header. */
4901 tree
4903 {
4904 tree inner_parms
4907 tree parms
4918 }
4920 /* Called when a class template TYPE is redeclared with the indicated
4921 template PARMS, e.g.:
4923 template <class T> struct S;
4924 template <class T> struct S {}; */
4926 bool
4928 {
4929 tree tmpl;
4930 tree tmpl_parms;
4934 {
4937 }
4941 /* The type is nested in some template class. Nothing to worry
4942 about here; there are no new template parameters for the nested
4943 type. */
4947 {
4949 tmpl);
4951 }
4957 {
4967 }
4970 {
4971 tree tmpl_parm;
4972 tree parm;
4973 tree tmpl_default;
4974 tree parm_default;
4988 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4989 TEMPLATE_DECL. */
4999 {
5003 }
5006 {
5007 /* We have in [temp.param]:
5009 A template-parameter may not be given default arguments
5010 by two different declarations in the same scope. */
5015 }
5018 /* Update the previous template parameters (which are the ones
5019 that will really count) with the new default value. */
5022 /* Update the new parameters, too; they'll be used as the
5023 parameters for any members. */
5025 }
5028 }
5030 /* Simplify EXPR if it is a non-dependent expression. Returns the
5031 (possibly simplified) expression. */
5033 tree
5035 {
5039 /* If we're in a template, but EXPR isn't value dependent, simplify
5040 it. We're supposed to treat:
5042 template <typename T> void f(T[1 + 1]);
5043 template <typename T> void f(T[2]);
5045 as two declarations of the same function, for example. */
5050 {
5051 HOST_WIDE_INT saved_processing_template_decl;
5057 complain,
5062 }
5064 }
5066 tree
5068 {
5070 }
5072 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5073 template declaration, or a TYPE_DECL for an alias declaration. */
5075 bool
5077 {
5085 }
5087 /* Return TRUE iff is a specialization of an alias template. */
5089 bool
5091 {
5099 }
5101 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5102 must be a function or a pointer-to-function type, as specified
5103 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5104 and check that the resulting function has external linkage. */
5106 static tree
5108 {
5111 linkage_kind linkage;
5123 /* [temp.arg.nontype]/1
5125 A template-argument for a non-type, non-template template-parameter
5126 shall be one of:
5127 [...]
5128 -- the address of an object or function with external [C++11: or
5129 internal] linkage. */
5132 {
5136 else
5139 }
5143 {
5148 else
5153 }
5156 }
5158 /* Subroutine of convert_nontype_argument.
5159 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5160 Emit an error otherwise. */
5162 static bool
5164 tsubst_flags_t complain)
5165 {
5172 {
5176 }
5178 }
5180 /* Returns TRUE iff the address of OP is value-dependent.
5182 14.6.2.4 [temp.dep.temp]:
5183 A non-integral non-type template-argument is dependent if its type is
5184 dependent or it has either of the following forms
5185 qualified-id
5186 & qualified-id
5187 and contains a nested-name-specifier which specifies a class-name that
5188 names a dependent type.
5190 We generalize this to just say that the address of a member of a
5191 dependent class is value-dependent; the above doesn't cover the
5192 address of a static data member named with an unqualified-id. */
5194 static bool
5196 {
5197 /* We could use get_inner_reference here, but there's no need;
5198 this is only relevant for template non-type arguments, which
5199 can only be expressed as &id-expression. */
5201 {
5205 }
5208 }
5210 /* The next set of functions are used for providing helpful explanatory
5211 diagnostics for failed overload resolution. Their messages should be
5212 indented by two spaces for consistency with the messages in
5213 call.c */
5215 static int
5217 {
5219 }
5221 static int
5223 {
5228 }
5230 static int
5232 {
5234 }
5236 static int
5238 {
5244 }
5246 static int
5248 {
5252 }
5254 static int
5256 {
5259 " template parameter %qD is not a parameter pack, but "
5263 }
5265 static int
5267 {
5270 " template argument %qE does not match "
5274 }
5276 static int
5278 {
5282 }
5284 static int
5286 {
5292 }
5294 static int
5296 {
5298 {
5303 else
5305 " deduced conflicting values for non-type parameter "
5307 }
5309 }
5311 static int
5313 {
5316 " variable-sized array type %qT is not "
5318 arg);
5320 }
5322 static int
5324 {
5328 arg);
5330 }
5332 static int
5334 {
5341 }
5343 static int
5345 {
5347 }
5349 static int
5351 {
5353 }
5355 static int
5358 {
5363 }
5365 static int
5368 {
5371 {
5379 }
5381 }
5383 static int
5385 {
5388 " template parameters of a template template argument are "
5391 }
5393 static int
5395 {
5401 }
5403 static int
5405 {
5410 }
5412 static int
5414 {
5418 arg);
5420 }
5422 /* Attempt to convert the non-type template parameter EXPR to the
5423 indicated TYPE. If the conversion is successful, return the
5424 converted value. If the conversion is unsuccessful, return
5425 NULL_TREE if we issued an error message, or error_mark_node if we
5426 did not. We issue error messages for out-and-out bad template
5427 parameters, but not simply because the conversion failed, since we
5428 might be just trying to do argument deduction. Both TYPE and EXPR
5429 must be non-dependent.
5431 The conversion follows the special rules described in
5432 [temp.arg.nontype], and it is much more strict than an implicit
5433 conversion.
5435 This function is called twice for each template argument (see
5436 lookup_template_class for a more accurate description of this
5437 problem). This means that we need to handle expressions which
5438 are not valid in a C++ source, but can be created from the
5439 first call (for instance, casts to perform conversions). These
5440 hacks can go away after we fix the double coercion problem. */
5442 static tree
5444 {
5445 tree expr_type;
5447 /* Detect immediately string literals as invalid non-type argument.
5448 This special-case is not needed for correctness (we would easily
5449 catch this later), but only to provide better diagnostic for this
5450 common user mistake. As suggested by DR 100, we do not mention
5451 linkage issues in the diagnostic as this is not the point. */
5452 /* FIXME we're making this OK. */
5454 {
5460 }
5462 /* Add the ADDR_EXPR now for the benefit of
5463 value_dependent_expression_p. */
5466 {
5470 }
5472 /* If we are in a template, EXPR may be non-dependent, but still
5473 have a syntactic, rather than semantic, form. For example, EXPR
5474 might be a SCOPE_REF, rather than the VAR_DECL to which the
5475 SCOPE_REF refers. Preserving the qualifying scope is necessary
5476 so that access checking can be performed when the template is
5477 instantiated -- but here we need the resolved form so that we can
5478 convert the argument. */
5489 else
5492 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5493 to a non-type argument of "nullptr". */
5497 /* In C++11, integral or enumeration non-type template arguments can be
5498 arbitrary constant expressions. Pointer and pointer to
5499 member arguments can be general constant expressions that evaluate
5500 to a null value, but otherwise still need to be of a specific form. */
5502 {
5504 /* A PTRMEM_CST is already constant, and a valid template
5505 argument for a parameter of pointer to member type, we just want
5506 to leave it in that form rather than lower it to a
5511 {
5516 }
5517 }
5519 /* HACK: Due to double coercion, we can get a
5520 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5521 which is the tree that we built on the first call (see
5522 below when coercing to reference to object or to reference to
5523 function). We just strip everything and get to the arg.
5524 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5525 for examples. */
5527 {
5533 {
5534 /* ??? Maybe we could use convert_from_reference here, but we
5535 would need to relax its constraints because the NOP_EXPR
5536 could actually change the type to something more cv-qualified,
5537 and this is not folded by convert_from_reference. */
5542 && (same_type_ignoring_top_level_qualifiers_p
5545 {
5548 }
5549 }
5550 }
5552 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5553 parameter is a pointer to object, through decay and
5554 qualification conversion. Let's strip everything. */
5556 {
5560 /* Skip the ADDR_EXPR only if it is part of the decay for
5561 an array. Otherwise, it is part of the original argument
5562 in the source code. */
5566 }
5568 /* [temp.arg.nontype]/5, bullet 1
5570 For a non-type template-parameter of integral or enumeration type,
5571 integral promotions (_conv.prom_) and integral conversions
5572 (_conv.integral_) are applied. */
5574 {
5583 /* Notice that there are constant expressions like '4 % 0' which
5584 do not fold into integer constants. */
5586 {
5588 {
5599 /* else cxx_constant_value complained but gave us
5600 a real constant, so go ahead. */
5602 }
5603 else
5605 }
5606 }
5607 /* [temp.arg.nontype]/5, bullet 2
5609 For a non-type template-parameter of type pointer to object,
5610 qualification conversions (_conv.qual_) and the array-to-pointer
5611 conversion (_conv.array_) are applied. */
5613 {
5614 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5616 A template-argument for a non-type, non-template template-parameter
5617 shall be one of: [...]
5619 -- the name of a non-type template-parameter;
5620 -- the address of an object or function with external linkage, [...]
5621 expressed as "& id-expression" where the & is optional if the name
5622 refers to a function or array, or if the corresponding
5623 template-parameter is a reference.
5625 Here, we do not care about functions, as they are invalid anyway
5626 for a parameter of type pointer-to-object. */
5629 /* Non-type template parameters are OK. */
5630 ;
5635 {
5637 {
5639 "because %qD is a variable, not the address of "
5643 }
5644 /* Other values, like integer constants, might be valid
5645 non-type arguments of some other type. */
5647 }
5648 else
5649 {
5650 tree decl;
5655 {
5660 }
5662 {
5667 }
5669 {
5674 }
5675 }
5684 }
5685 /* [temp.arg.nontype]/5, bullet 3
5687 For a non-type template-parameter of type reference to object, no
5688 conversions apply. The type referred to by the reference may be more
5689 cv-qualified than the (otherwise identical) type of the
5690 template-argument. The template-parameter is bound directly to the
5691 template-argument, which must be an lvalue. */
5693 {
5695 expr_type))
5699 {
5703 }
5706 {
5710 }
5712 /* [temp.arg.nontype]/1
5714 A template-argument for a non-type, non-template template-parameter
5715 shall be one of: [...]
5717 -- the address of an object or function with external linkage. */
5720 {
5723 {
5725 "because a reference variable does not have a constant "
5728 }
5729 }
5732 {
5737 }
5740 {
5745 }
5748 }
5749 /* [temp.arg.nontype]/5, bullet 4
5751 For a non-type template-parameter of type pointer to function, only
5752 the function-to-pointer conversion (_conv.func_) is applied. If the
5753 template-argument represents a set of overloaded functions (or a
5754 pointer to such), the matching function is selected from the set
5755 (_over.over_). */
5757 {
5758 /* If the argument is a template-id, we might not have enough
5759 context information to decay the pointer. */
5761 {
5765 }
5768 /* Null pointer values are OK in C++11. */
5774 }
5775 /* [temp.arg.nontype]/5, bullet 5
5777 For a non-type template-parameter of type reference to function, no
5778 conversions apply. If the template-argument represents a set of
5779 overloaded functions, the matching function is selected from the set
5780 (_over.over_). */
5782 {
5784 {
5789 }
5796 }
5797 /* [temp.arg.nontype]/5, bullet 6
5799 For a non-type template-parameter of type pointer to member function,
5800 no conversions apply. If the template-argument represents a set of
5801 overloaded member functions, the matching member function is selected
5802 from the set (_over.over_). */
5804 {
5809 /* [temp.arg.nontype] bullet 1 says the pointer to member
5810 expression must be a pointer-to-member constant. */
5814 /* There is no way to disable standard conversions in
5815 resolve_address_of_overloaded_function (called by
5816 instantiate_type). It is possible that the call succeeded by
5817 converting &B::I to &D::I (where B is a base of D), so we need
5818 to reject this conversion here.
5820 Actually, even if there was a way to disable standard conversions,
5821 it would still be better to reject them here so that we can
5822 provide a superior diagnostic. */
5824 {
5828 /* If we are just one standard conversion off, explain. */
5833 }
5834 }
5835 /* [temp.arg.nontype]/5, bullet 7
5837 For a non-type template-parameter of type pointer to data member,
5838 qualification conversions (_conv.qual_) are applied. */
5840 {
5841 /* [temp.arg.nontype] bullet 1 says the pointer to member
5842 expression must be a pointer-to-member constant. */
5849 }
5851 {
5853 {
5857 }
5859 }
5860 /* A template non-type parameter must be one of the above. */
5861 else
5864 /* Sanity check: did we actually convert the argument to the
5865 right type? */
5869 }
5871 /* Subroutine of coerce_template_template_parms, which returns 1 if
5872 PARM_PARM and ARG_PARM match using the rule for the template
5873 parameters of template template parameters. Both PARM and ARG are
5874 template parameters; the rest of the arguments are the same as for
5875 coerce_template_template_parms.
5876 */
5877 static int
5879 tree arg,
5880 tsubst_flags_t complain,
5881 tree in_decl,
5882 tree outer_args)
5883 {
5892 {
5894 /* We encounter instantiations of templates like
5895 template <template <template <class> class> class TT>
5896 class C; */
5897 {
5904 }
5905 /* Fall through. */
5910 /* Argument is a parameter pack but parameter is not. */
5915 /* The tsubst call is used to handle cases such as
5917 template <int> class C {};
5918 template <class T, template <T> class TT> class D {};
5919 D<int, C> d;
5921 i.e. the parameter list of TT depends on earlier parameters. */
5923 && !same_type_p
5930 /* Argument is a parameter pack but parameter is not. */
5937 }
5940 }
5943 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5944 template template parameters. Both PARM_PARMS and ARG_PARMS are
5945 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5946 or PARM_DECL.
5948 Consider the example:
5949 template <class T> class A;
5950 template<template <class U> class TT> class B;
5952 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5953 the parameters to A, and OUTER_ARGS contains A. */
5955 static int
5957 tree arg_parms,
5958 tsubst_flags_t complain,
5959 tree in_decl,
5960 tree outer_args)
5961 {
5972 /* Determine whether we have a parameter pack at the end of the
5973 template template parameter's template parameter list. */
5975 {
5982 {
5996 }
5997 }
6003 /* Check all of the template parameters except the parameter pack at
6004 the end (if any). */
6006 {
6015 outer_args))
6018 }
6021 {
6022 /* Check each of the template parameters in the template
6023 argument against the template parameter pack at the end of
6024 the template template parameter. */
6031 {
6038 outer_args))
6040 }
6041 }
6044 }
6046 /* Verifies that the deduced template arguments (in TARGS) for the
6047 template template parameters (in TPARMS) represent valid bindings,
6048 by comparing the template parameter list of each template argument
6049 to the template parameter list of its corresponding template
6050 template parameter, in accordance with DR150. This
6051 routine can only be called after all template arguments have been
6052 deduced. It will return TRUE if all of the template template
6053 parameter bindings are okay, FALSE otherwise. */
6054 bool
6056 {
6060 /* We're dealing with template parms in this process. */
6066 {
6071 {
6076 {
6077 /* Look inside the argument pack. */
6080 }
6083 {
6087 /* Extract the next argument from the argument
6088 pack. */
6092 /* Look at the pattern of the pack expansion. */
6095 /* Extract the template parameters from the template
6096 argument. */
6102 /* Verify that we can coerce the template template
6103 parameters from the template argument to the template
6104 parameter. This requires an exact match. */
6106 && !coerce_template_template_parms
6108 targ_parms,
6109 tf_none,
6110 tparm,
6111 targs))
6112 {
6115 }
6116 }
6117 }
6118 }
6120 out:
6124 }
6126 /* Since type attributes aren't mangled, we need to strip them from
6127 template type arguments. */
6129 static tree
6131 {
6132 tree mv;
6139 {
6144 }
6146 }
6148 /* Convert the indicated template ARG as necessary to match the
6149 indicated template PARM. Returns the converted ARG, or
6150 error_mark_node if the conversion was unsuccessful. Error and
6151 warning messages are issued under control of COMPLAIN. This
6152 conversion is for the Ith parameter in the parameter list. ARGS is
6153 the full set of template arguments deduced so far. */
6155 static tree
6157 tree arg,
6158 tree args,
6159 tsubst_flags_t complain,
6161 tree in_decl)
6162 {
6163 tree orig_arg;
6164 tree val;
6169 {
6170 /* The template argument was the name of some
6171 member function. That's usually
6172 invalid, but static members are OK. In any
6173 case, grab the underlying fields/functions
6174 and issue an error later if required. */
6177 }
6185 /* When determining whether an argument pack expansion is a template,
6186 look at the pattern. */
6190 /* Deal with an injected-class-name used as a template template arg. */
6192 {
6195 {
6205 }
6206 }
6208 is_tmpl_type =
6224 {
6226 {
6230 }
6233 "to refer to a type member of a template parameter, "
6238 typename_type,
6239 complain);
6242 }
6244 {
6246 {
6248 {
6258 else
6260 }
6261 }
6263 }
6265 {
6267 {
6273 else
6275 }
6277 }
6280 {
6282 {
6286 /* The number of argument required is not known yet.
6287 Just accept it for now. */
6289 else
6290 {
6292 tree argparm;
6298 args))
6299 {
6302 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6303 TEMPLATE_DECL. */
6305 {
6310 }
6311 }
6312 else
6313 {
6315 {
6321 }
6324 }
6325 }
6326 }
6327 else
6329 /* We only form one instance of each template specialization.
6330 Therefore, if we use a non-canonical variant (i.e., a
6331 typedef), any future messages referring to the type will use
6332 the typedef, which is confusing if those future uses do not
6333 themselves also use the typedef. */
6336 }
6337 else
6338 {
6345 {
6348 else
6349 {
6350 /* Not sure if this is reachable, but it doesn't hurt
6351 to be robust. */
6354 }
6355 }
6357 /* We used to call digest_init here. However, digest_init
6358 will report errors, which we don't want when complain
6359 is zero. More importantly, digest_init will try too
6360 hard to convert things: for example, `0' should not be
6361 converted to pointer type at this point according to
6362 the standard. Accepting this is not merely an
6363 extension, since deciding whether or not these
6364 conversions can occur is part of determining which
6365 function template to call, or whether a given explicit
6366 argument specification is valid. */
6368 else
6377 {
6378 /* Strip typedefs from the SCOPE_REF. */
6381 complain);
6384 }
6385 }
6388 }
6390 /* Coerces the remaining template arguments in INNER_ARGS (from
6391 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6392 Returns the coerced argument pack. PARM_IDX is the position of this
6393 parameter in the template parameter list. ARGS is the original
6394 template argument list. */
6395 static tree
6398 tree args,
6399 tree inner_args,
6401 tree new_args,
6403 tree in_decl,
6404 tsubst_flags_t complain)
6405 {
6408 tree packed_args;
6409 tree argument_pack;
6419 {
6420 /* When the template parameter is a non-type template
6421 parameter pack whose type uses parameter packs, we need
6422 to look at each of the template arguments
6423 separately. Build a vector of the types for these
6424 non-type template parameters in PACKED_TYPES. */
6425 tree expansion
6433 /* Check that we have the right number of arguments. */
6437 {
6438 int needed_parms
6443 }
6445 /* If we aren't able to check the actual arguments now
6446 (because they haven't been expanded yet), we can at least
6447 verify that all of the types used for the non-type
6448 template parameter pack are, in fact, valid for non-type
6449 template parameters. */
6452 {
6455 {
6459 }
6460 }
6461 }
6463 /* Convert the remaining arguments, which will be a part of the
6464 parameter pack "parm". */
6466 {
6471 {
6472 /* When we have a vector of types (corresponding to the
6473 non-type template parameter pack that uses parameter
6474 packs in its type, as mention above), and the
6475 argument is not an expansion (which expands to a
6476 currently unknown number of arguments), clone the
6477 parm and give it the next type in PACKED_TYPES. */
6481 }
6484 {
6487 }
6488 else
6491 in_decl);
6495 }
6500 else
6501 {
6506 }
6509 #ifdef ENABLE_CHECKING
6512 #endif
6514 }
6516 /* Returns true if the template argument vector ARGS contains
6517 any pack expansions, false otherwise. */
6519 static bool
6521 {
6528 }
6530 /* Convert all template arguments to their appropriate types, and
6531 return a vector containing the innermost resulting template
6532 arguments. If any error occurs, return error_mark_node. Error and
6533 warning messages are issued under control of COMPLAIN.
6535 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6536 for arguments not specified in ARGS. Otherwise, if
6537 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6538 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6539 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6540 ARGS. */
6542 static tree
6544 tree args,
6545 tree in_decl,
6546 tsubst_flags_t complain,
6549 {
6551 tree inner_args;
6552 tree new_args;
6553 tree new_inner_args;
6557 /* When used as a boolean value, indicates whether this is a
6558 variadic template parameter list. Since it's an int, we can also
6559 subtract it from nparms to get the number of non-variadic
6560 parameters. */
6569 /* Determine if there are any parameter packs. */
6571 {
6577 }
6580 /* If there are no parameters that follow a parameter pack, we need to
6581 expand any argument packs so that we can deduce a parameter pack from
6582 some non-packed args followed by an argument pack, as in variadic85.C.
6583 If there are such parameters, we need to leave argument packs intact
6584 so the arguments are assigned properly. This can happen when dealing
6585 with a nested class inside a partial specialization of a class
6586 template, as in variadic92.C, or when deducing a template parameter pack
6587 from a sub-declarator, as in variadic114.C. */
6594 && require_all_args
6596 && (!use_default_args
6599 {
6601 {
6603 {
6607 }
6608 else
6614 }
6617 }
6619 /* We need to evaluate the template arguments, even though this
6620 template-id may be nested within a "sizeof". */
6628 {
6629 tree arg;
6630 tree parm;
6632 /* Get the Ith template parameter. */
6636 {
6639 }
6641 /* Calculate the next argument. */
6644 else
6649 {
6650 /* All remaining arguments will be placed in the
6651 template parameter pack PARM. */
6657 /* Store this argument. */
6659 lost++;
6662 /* We are done with all of the arguments. */
6666 }
6668 {
6670 {
6671 /* We don't know how many args we have yet, just
6672 use the unconverted ones for now. */
6675 }
6676 }
6678 {
6679 /* There must be a default arg in this case. */
6682 /* The position of the first default template argument,
6683 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6684 Record that. */
6687 }
6688 else
6692 {
6695 }
6697 /* This only occurs if there was an error in the template
6698 parameter list itself (which we would already have
6699 reported) that we are trying to recover from, e.g., a class
6700 template with a parameter list such as
6701 template<typename..., typename>. */
6703 else
6709 lost++;
6711 }
6718 #ifdef ENABLE_CHECKING
6722 #endif
6725 }
6727 /* Like coerce_template_parms. If PARMS represents all template
6728 parameters levels, this function returns a vector of vectors
6729 representing all the resulting argument levels. Note that in this
6730 case, only the innermost arguments are coerced because the
6731 outermost ones are supposed to have been coerced already.
6733 Otherwise, if PARMS represents only (the innermost) vector of
6734 parameters, this function returns a vector containing just the
6735 innermost resulting arguments. */
6737 static tree
6739 tree args,
6740 tree in_decl,
6741 tsubst_flags_t complain,
6744 {
6747 tree coerced_args;
6750 {
6752 tree level;
6758 {
6759 tree l;
6763 require_all_args,
6764 use_default_args);
6765 else
6772 }
6773 }
6774 else
6777 require_all_args,
6778 use_default_args);
6780 }
6782 /* Returns 1 if template args OT and NT are equivalent. */
6784 static int
6786 {
6793 /* For member templates */
6802 {
6819 }
6821 {
6822 /* We get here probably because we are in the middle of substituting
6823 into the pattern of a pack expansion. In that case the
6824 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
6825 interested in. So we want to use the initial pack argument for
6826 the comparison. */
6831 }
6836 else
6838 }
6840 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
6841 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
6842 NEWARG_PTR with the offending arguments if they are non-NULL. */
6844 static int
6847 {
6860 {
6865 {
6871 }
6872 }
6874 }
6876 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
6877 of template arguments. Returns 0 otherwise. */
6879 int
6881 {
6883 }
6885 static void
6887 {
6897 /* We are called both from instantiate_decl, where we've already had a
6898 tinst_level pushed, and instantiate_template, where we haven't.
6899 Compensate. */
6910 else
6919 }
6922 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6923 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6924 documentation for TEMPLATE_ID_EXPR. */
6926 tree
6928 {
6929 tree type;
6937 {
6940 }
6943 {
6945 unknown_type_node,
6947 arglist);
6949 }
6956 }
6958 /* Within the scope of a template class S<T>, the name S gets bound
6959 (in build_self_reference) to a TYPE_DECL for the class, not a
6960 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6961 or one of its enclosing classes, and that type is a template,
6962 return the associated TEMPLATE_DECL. Otherwise, the original
6963 DECL is returned.
6965 Also handle the case when DECL is a TREE_LIST of ambiguous
6966 injected-class-names from different bases. */
6968 tree
6970 {
6974 /* DR 176: A lookup that finds an injected-class-name (10.2
6975 [class.member.lookup]) can result in an ambiguity in certain cases
6976 (for example, if it is found in more than one base class). If all of
6977 the injected-class-names that are found refer to specializations of
6978 the same class template, and if the name is followed by a
6979 template-argument-list, the reference refers to the class template
6980 itself and not a specialization thereof, and is not ambiguous. */
6982 {
6985 {
6991 }
6994 else
6996 }
7002 }
7004 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
7005 parameters, find the desired type.
7007 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7009 IN_DECL, if non-NULL, is the template declaration we are trying to
7010 instantiate.
7012 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7013 the class we are looking up.
7015 Issue error and warning messages under control of COMPLAIN.
7017 If the template class is really a local class in a template
7018 function, then the FUNCTION_CONTEXT is the function in which it is
7019 being instantiated.
7021 ??? Note that this function is currently called *twice* for each
7022 template-id: the first time from the parser, while creating the
7023 incomplete type (finish_template_type), and the second type during the
7024 real instantiation (instantiate_template_class). This is surely something
7025 that we want to avoid. It also causes some problems with argument
7026 coercion (see convert_nontype_argument for more information on this). */
7028 static tree
7031 {
7033 tree t;
7036 spec_entry elt;
7037 hashval_t hash;
7040 {
7044 else
7045 {
7052 }
7055 }
7057 {
7060 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7061 an implicit typename for the second A. Deal with it. */
7066 {
7069 }
7070 }
7073 {
7076 }
7080 {
7084 }
7086 /* Issue an error message if we didn't find a template. */
7088 {
7092 }
7095 /* Make sure it's a user visible template, if it was named by
7096 the user. */
7099 {
7101 {
7105 }
7107 }
7112 {
7113 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7114 template arguments */
7116 tree parm;
7117 tree arglist2;
7118 tree outer;
7122 /* Consider an example where a template template parameter declared as
7124 template <class T, class U = std::allocator<T> > class TT
7126 The template parameter level of T and U are one level larger than
7127 of TT. To proper process the default argument of U, say when an
7128 instantiation `TT<int>' is seen, we need to build the full
7129 arguments containing {int} as the innermost level. Outer levels,
7130 available when not appearing as default template argument, can be
7131 obtained from the arguments of the enclosing template.
7133 Suppose that TT is later substituted with std::vector. The above
7134 instantiation is `TT<int, std::allocator<T> >' with TT at
7135 level 1, and T at level 2, while the template arguments at level 1
7136 becomes {std::vector} and the inner level 2 is {int}. */
7142 /* This is an argument of the current template, so we haven't set
7143 DECL_CONTEXT yet. */
7150 complain,
7160 }
7161 else
7162 {
7164 tree gen_tmpl;
7165 tree type_decl;
7173 /* An error occured while building the template TEMPL, and a
7174 diagnostic has most certainly been emitted for that
7175 already. Let's propagate that error. */
7184 {
7185 /* We've been given an incomplete set of template arguments.
7186 For example, given:
7188 template <class T> struct S1 {
7189 template <class U> struct S2 {};
7190 template <class U> struct S2<U*> {};
7191 };
7193 we will be called with an ARGLIST of `U*', but the
7194 TEMPLATE will be `template <class T> template
7195 <class U> struct S1<T>::S2'. We must fill in the missing
7196 arguments. */
7197 arglist
7199 arglist);
7201 }
7203 /* Now we should have enough arguments. */
7206 /* From here on, we're only interested in the most general
7207 template. */
7209 /* Calculate the BOUND_ARGS. These will be the args that are
7210 actually tsubst'd into the definition to create the
7211 instantiation. */
7213 {
7214 /* We have multiple levels of arguments to coerce, at once. */
7224 {
7225 tree a;
7229 complain,
7232 else
7233 /* Outer levels should have already been coerced. */
7236 /* Don't process further if one of the levels fails. */
7238 {
7239 /* Restore the ARGLIST to its full size. */
7242 }
7246 /* We temporarily reduce the length of the ARGLIST so
7247 that coerce_template_parms will see only the arguments
7248 corresponding to the template parameters it is
7249 examining. */
7251 }
7253 /* Restore the ARGLIST to its full size. */
7257 }
7258 else
7259 arglist
7262 gen_tmpl,
7263 complain,
7268 /* We were unable to bind the arguments. */
7271 /* In the scope of a template class, explicit references to the
7272 template class refer to the type of the template, not any
7273 instantiation of it. For example, in:
7275 template <class T> class C { void f(C<T>); }
7277 the `C<T>' is just the same as `C'. Outside of the
7278 class, however, such a reference is an instantiation. */
7282 /* comp_template_args is expensive, check it last. */
7284 arglist))
7287 /* If we already have this specialization, return it. */
7299 /* If the deduced arguments are invalid, then the binding
7300 failed. */
7304 complain))
7311 {
7316 }
7326 /* Create the type. */
7328 {
7330 {
7336 }
7337 else
7338 {
7339 /* We don't want to call start_enum for this type, since
7340 the values for the enumeration constants may involve
7341 template parameters. And, no one should be interested
7342 in the enumeration constants for such a type. */
7345 }
7349 }
7351 {
7352 /* The user referred to a specialization of an alias
7353 template represented by GEN_TMPL.
7355 [temp.alias]/2 says:
7357 When a template-id refers to the specialization of an
7358 alias template, it is equivalent to the associated
7359 type obtained by substitution of its
7360 template-arguments for the template-parameters in the
7361 type-id of the alias template. */
7364 /* Note that the call above (by indirectly calling
7365 register_specialization in tsubst_decl) registers the
7366 TYPE_DECL representing the specialization of the alias
7367 template. So next time someone substitutes ARGLIST for
7368 the template parms into the alias template (GEN_TMPL),
7369 she'll get that TYPE_DECL back. */
7373 }
7375 {
7382 /* A local class. Make sure the decl gets registered properly. */
7387 /* This instantiation is another name for the primary
7388 template type. Set the TYPE_CANONICAL field
7389 appropriately. */
7392 /* Some of the template arguments require structural
7393 equality testing, so this template class requires
7394 structural equality testing. */
7396 }
7397 else
7400 /* If we called start_enum or pushtag above, this information
7401 will already be set up. */
7403 {
7410 }
7411 else
7415 {
7421 {
7424 }
7425 }
7427 /* Let's consider the explicit specialization of a member
7428 of a class template specialization that is implicitely instantiated,
7429 e.g.:
7430 template<class T>
7431 struct S
7432 {
7433 template<class U> struct M {}; //#0
7434 };
7436 template<>
7437 template<>
7438 struct S<int>::M<char> //#1
7439 {
7440 int i;
7441 };
7442 [temp.expl.spec]/4 says this is valid.
7444 In this case, when we write:
7445 S<int>::M<char> m;
7447 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7448 the one of #0.
7450 When we encounter #1, we want to store the partial instantiation
7451 of M (template<class T> S<int>::M<T>) in it's CLASSTYPE_TI_TEMPLATE.
7453 For all cases other than this "explicit specialization of member of a
7454 class template", we just want to store the most general template into
7455 the CLASSTYPE_TI_TEMPLATE of M.
7457 This case of "explicit specialization of member of a class template"
7458 only happens when:
7459 1/ the enclosing class is an instantiation of, and therefore not
7460 the same as, the context of the most general template, and
7461 2/ we aren't looking at the partial instantiation itself, i.e.
7462 the innermost arguments are not the same as the innermost parms of
7463 the most general template.
7465 So it's only when 1/ and 2/ happens that we want to use the partial
7466 instantiation of the member template in lieu of its most general
7467 template. */
7471 /* the enclosing class must be an instantiation... */
7474 {
7475 tree partial_inst_args;
7478 partial_inst_args =
7484 use_partial_inst_tmpl =
7485 /*...and we must not be looking at the partial instantiation
7486 itself. */
7488 partial_inst_args);
7489 }
7492 /* This case is easy; there are no member templates involved. */
7494 else
7495 {
7496 /* This is a full instantiation of a member template. Find
7497 the partial instantiation of which this is an instance. */
7499 /* Temporarily reduce by one the number of levels in the ARGLIST
7500 so as to avoid comparing the last set of arguments. */
7504 /* FOUND is either a proper class type, or an alias
7505 template specialization. In the later case, it's a
7506 TYPE_DECL, resulting from the substituting of arguments
7507 for parameters in the TYPE_DECL of the alias template
7508 done earlier. So be careful while getting the template
7509 of FOUND. */
7513 }
7524 /* Note this use of the partial instantiation so we can check it
7525 later in maybe_process_partial_specialization. */
7531 /* Now that the type has been registered on the instantiations
7532 list, we set up the enumerators. Because the enumeration
7533 constants may involve the enumeration type itself, we make
7534 sure to register the type first, and then create the
7535 constants. That way, doing tsubst_expr for the enumeration
7536 constants won't result in recursive calls here; we'll find
7537 the instantiation and exit above. */
7541 /* If the type makes use of template parameters, the
7542 code that generates debugging information will crash. */
7545 /* Possibly limit visibility based on template args. */
7550 }
7551 }
7553 /* Wrapper for lookup_template_class_1. */
7555 tree
7558 {
7559 tree ret;
7565 }
7566 \f
7567 struct pair_fn_data
7568 {
7569 tree_fn_t fn;
7571 /* True when we should also visit template parameters that occur in
7572 non-deduced contexts. */
7575 };
7577 /* Called from for_each_template_parm via walk_tree. */
7579 static tree
7581 {
7594 {
7598 /* Fall through. */
7621 /* Since we're not going to walk subtrees, we have to do this
7622 explicitly here. */
7626 /* Fall through. */
7629 /* Check the return type. */
7634 /* Check the parameter types. Since default arguments are not
7635 instantiated until they are needed, the TYPE_ARG_TYPES may
7636 contain expressions that involve template parameters. But,
7637 no-one should be looking at them yet. And, once they're
7638 instantiated, they don't contain template parameters, so
7639 there's no point in looking at them then, either. */
7640 {
7641 tree parm;
7648 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7649 want walk_tree walking into them itself. */
7651 }
7669 /* Fall through. */
7685 /* Record template parameters such as `T' inside `TT<T>'. */
7689 /* Fall through. */
7701 /* A template template parameter is encountered. */
7707 /* Already substituted template template parameter */
7730 /* If there's no type, then this thing must be some expression
7731 involving template parameters. */
7753 }
7755 /* We didn't find any template parameters we liked. */
7757 }
7759 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
7760 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
7761 call FN with the parameter and the DATA.
7762 If FN returns nonzero, the iteration is terminated, and
7763 for_each_template_parm returns 1. Otherwise, the iteration
7764 continues. If FN never returns a nonzero value, the value
7765 returned by for_each_template_parm is 0. If FN is NULL, it is
7766 considered to be the function which always returns 1.
7768 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
7769 parameters that occur in non-deduced contexts. When false, only
7770 visits those template parameters that can be deduced. */
7772 static int
7776 {
7780 /* Set up. */
7785 /* Walk the tree. (Conceptually, we would like to walk without
7786 duplicates, but for_each_template_parm_r recursively calls
7787 for_each_template_parm, so we would need to reorganize a fair
7788 bit to use walk_tree_without_duplicates, so we keep our own
7789 visited list.) */
7792 else
7795 for_each_template_parm_r,
7799 /* Clean up. */
7801 {
7804 }
7807 }
7809 /* Returns true if T depends on any template parameter. */
7811 int
7813 {
7840 else
7841 {
7844 }
7849 }
7851 /* Returns true iff current_function_decl is an incompletely instantiated
7852 template. Useful instead of processing_template_decl because the latter
7853 is set to 0 during fold_non_dependent_expr. */
7855 bool
7857 {
7866 }
7868 /* Returns true if T depends on any template parameter with level LEVEL. */
7870 int
7872 {
7875 }
7877 /* Returns TRUE iff INST is an instantiation we don't need to do in an
7878 ill-formed translation unit, i.e. a variable or function that isn't
7879 usable in a constant expression. */
7883 {
7887 }
7889 /* Returns TRUE iff we should refuse to instantiate DECL because it's
7890 neglectable and instantiated from within an erroneous instantiation. */
7892 static bool
7894 {
7905 }
7913 /* We're starting to instantiate D; record the template instantiation context
7914 for diagnostics and to restore it later. */
7916 int
7918 {
7922 {
7928 else
7936 }
7938 /* If the current instantiation caused problems, don't let it instantiate
7939 anything else. Do allow deduction substitution and decls usable in
7940 constant expressions. */
7957 }
7959 /* We're done instantiating this template; return to the instantiation
7960 context. */
7962 void
7964 {
7965 /* Restore the filename and line number stashed away when we started
7966 this instantiation. */
7970 }
7972 /* We're instantiating a deferred template; restore the template
7973 instantiation context in which the instantiation was requested, which
7974 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
7976 static tree
7978 {
7990 }
7992 /* Returns the TINST_LEVEL which gives the original instantiation
7993 context. */
7997 {
8003 }
8005 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8006 vector of template arguments, as for tsubst.
8008 Returns an appropriate tsubst'd friend declaration. */
8010 static tree
8012 {
8013 tree new_friend;
8018 /* This was a friend declared with an explicit template
8019 argument list, e.g.:
8021 friend void f<>(T);
8023 to indicate that f was a template instantiation, not a new
8024 function declaration. Now, we have to figure out what
8025 instantiation of what template. */
8026 {
8028 tree new_args;
8029 tree tmpl;
8032 /* Friend functions are looked up in the containing namespace scope.
8033 We must enter that scope, to avoid finding member functions of the
8034 current class with same name. */
8049 tsk_none);
8051 }
8055 /* The NEW_FRIEND will look like an instantiation, to the
8056 compiler, but is not an instantiation from the point of view of
8057 the language. For example, we might have had:
8059 template <class T> struct S {
8060 template <class U> friend void f(T, U);
8061 };
8063 Then, in S<int>, template <class U> void f(int, U) is not an
8064 instantiation of anything. */
8070 {
8074 }
8076 /* The mangled name for the NEW_FRIEND is incorrect. The function
8077 is not a template instantiation and should not be mangled like
8078 one. Therefore, we forget the mangling here; we'll recompute it
8079 later if we need it. */
8081 {
8084 }
8087 {
8088 tree old_decl;
8089 tree new_friend_template_info;
8090 tree new_friend_result_template_info;
8091 tree ns;
8094 /* We must save some information from NEW_FRIEND before calling
8095 duplicate decls since that function will free NEW_FRIEND if
8096 possible. */
8098 new_friend_is_defn =
8103 {
8104 /* This declaration is a `primary' template. */
8107 new_friend_result_template_info
8109 }
8110 else
8113 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8117 /* Inside pushdecl_namespace_level, we will push into the
8118 current namespace. However, the friend function should go
8119 into the namespace of the template. */
8129 {
8130 /* This new friend declaration matched an existing
8131 declaration. For example, given:
8133 template <class T> void f(T);
8134 template <class U> class C {
8135 template <class T> friend void f(T) {}
8136 };
8138 the friend declaration actually provides the definition
8139 of `f', once C has been instantiated for some type. So,
8140 old_decl will be the out-of-class template declaration,
8141 while new_friend is the in-class definition.
8143 But, if `f' was called before this point, the
8144 instantiation of `f' will have DECL_TI_ARGS corresponding
8145 to `T' but not to `U', references to which might appear
8146 in the definition of `f'. Previously, the most general
8147 template for an instantiation of `f' was the out-of-class
8148 version; now it is the in-class version. Therefore, we
8149 run through all specialization of `f', adding to their
8150 DECL_TI_ARGS appropriately. In particular, they need a
8151 new set of outer arguments, corresponding to the
8152 arguments for this class instantiation.
8154 The same situation can arise with something like this:
8156 friend void f(int);
8157 template <class T> class C {
8158 friend void f(T) {}
8159 };
8161 when `C<int>' is instantiated. Now, `f(int)' is defined
8162 in the class. */
8165 /* On the other hand, if the in-class declaration does
8166 *not* provide a definition, then we don't want to alter
8167 existing definitions. We can just leave everything
8168 alone. */
8169 ;
8170 else
8171 {
8175 /* Overwrite whatever template info was there before, if
8176 any, with the new template information pertaining to
8177 the declaration. */
8181 {
8182 /* We should have called reregister_specialization in
8183 duplicate_decls. */
8188 /* Instantiate it if the global has already been used. */
8192 }
8193 else
8194 {
8195 tree t;
8197 /* Indicate that the old function template is a partial
8198 instantiation. */
8206 /* Reassign any specializations already in the hash table
8207 to the new more general template, and add the
8208 additional template args. */
8212 {
8214 spec_entry elt;
8226 register_specialization
8229 }
8231 }
8232 }
8234 /* The information from NEW_FRIEND has been merged into OLD_DECL
8235 by duplicate_decls. */
8237 }
8238 }
8239 else
8240 {
8244 /* In the code
8245 template <class T> class C {
8246 template <class U> friend void C1<U>::f (); // case 1
8247 friend void C2<T>::f (); // case 2
8248 };
8249 we only need to make sure CONTEXT is a complete type for
8250 case 2. To distinguish between the two cases, we note that
8251 CONTEXT of case 1 remains dependent type after tsubst while
8252 this isn't true for case 2. */
8262 {
8263 /* Check to see that the declaration is really present, and,
8264 possibly obtain an improved declaration. */
8270 }
8271 }
8274 }
8276 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8277 template arguments, as for tsubst.
8279 Returns an appropriate tsubst'd friend type or error_mark_node on
8280 failure. */
8282 static tree
8284 {
8285 tree friend_type;
8286 tree tmpl;
8287 tree context;
8290 {
8293 }
8298 {
8301 else
8303 }
8305 /* Look for a class template declaration. We look for hidden names
8306 because two friend declarations of the same template are the
8307 same. For example, in:
8309 struct A {
8310 template <typename> friend class F;
8311 };
8312 template <typename> struct B {
8313 template <typename> friend class F;
8314 };
8316 both F templates are the same. */
8320 /* But, if we don't find one, it might be because we're in a
8321 situation like this:
8323 template <class T>
8324 struct S {
8325 template <class U>
8326 friend struct S;
8327 };
8329 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8330 for `S<int>', not the TEMPLATE_DECL. */
8332 {
8335 }
8338 {
8339 /* The friend template has already been declared. Just
8340 check to see that the declarations match, and install any new
8341 default parameters. We must tsubst the default parameters,
8342 of course. We only need the innermost template parameters
8343 because that is all that redeclare_class_template will look
8344 at. */
8347 {
8348 tree parms;
8349 location_t saved_input_location;
8358 }
8361 }
8362 else
8363 {
8364 /* The friend template has not already been declared. In this
8365 case, the instantiation of the template class will cause the
8366 injection of this template into the global scope. */
8371 /* The new TMPL is not an instantiation of anything, so we
8372 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8373 the new type because that is supposed to be the corresponding
8374 template decl, i.e., TMPL. */
8381 /* Inject this template into the global scope. */
8383 }
8386 {
8389 else
8391 }
8394 }
8396 /* Returns zero if TYPE cannot be completed later due to circularity.
8397 Otherwise returns one. */
8399 static int
8401 {
8411 else
8413 }
8415 /* Apply any attributes which had to be deferred until instantiation
8416 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8417 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8419 static void
8422 {
8424 tree t;
8429 {
8433 }
8436 {
8440 }
8441 else
8445 {
8450 {
8453 {
8456 /* If the first attribute argument is an identifier, don't
8457 pass it through tsubst. Attributes like mode, format,
8458 cleanup and several target specific attributes expect it
8459 unmodified. */
8465 {
8466 tree chain
8468 in_decl,
8473 chain);
8474 }
8475 else
8481 }
8482 else
8484 }
8487 }
8488 }
8490 /* Perform (or defer) access check for typedefs that were referenced
8491 from within the template TMPL code.
8492 This is a subroutine of instantiate_decl and instantiate_class_template.
8493 TMPL is the template to consider and TARGS is the list of arguments of
8494 that template. */
8496 static void
8498 {
8499 location_t saved_location;
8510 {
8522 /* Make access check error messages point to the location
8523 of the use of the typedef. */
8527 tf_warning_or_error);
8528 }
8530 }
8532 static tree
8534 {
8536 tree typedecl;
8537 tree pbinfo;
8538 tree base_list;
8540 tree fn_context;
8549 /* Figure out which template is being instantiated. */
8553 /* Determine what specialization of the original template to
8554 instantiate. */
8557 {
8560 }
8562 {
8563 /* This TYPE is actually an instantiation of a partial
8564 specialization. We replace the innermost set of ARGS with
8565 the arguments appropriate for substitution. For example,
8566 given:
8568 template <class T> struct S {};
8569 template <class T> struct S<T*> {};
8571 and supposing that we are instantiating S<int*>, ARGS will
8572 presently be {int*} -- but we need {int}. */
8575 }
8576 else
8577 {
8580 }
8582 /* If the template we're instantiating is incomplete, then clearly
8583 there's nothing we can do. */
8587 /* If we've recursively instantiated too many templates, stop. */
8591 /* Now we're really doing the instantiation. Mark the type as in
8592 the process of being defined. */
8595 /* We may be in the middle of deferred access check. Disable
8596 it now. */
8602 /* Use #pragma pack from the template context. */
8608 /* Set the input location to the most specialized template definition.
8609 This is needed if tsubsting causes an error. */
8621 {
8624 /* Adjust visibility for template arguments. */
8626 }
8631 /* We should never instantiate a nested class before its enclosing
8632 class; we need to look up the nested class by name before we can
8633 instantiate it, and that lookup should instantiate the enclosing
8634 class. */
8640 {
8641 tree pbase_binfo;
8642 tree pushed_scope;
8645 /* We must enter the scope containing the type, as that is where
8646 the accessibility of types named in dependent bases are
8647 looked up from. */
8650 /* Substitute into each of the bases to determine the actual
8651 basetypes. */
8653 {
8654 tree base;
8660 {
8661 expanded_bases =
8668 }
8671 {
8673 /* Extract the already-expanded base class. */
8675 else
8676 /* Substitute to figure out the base class. */
8678 NULL_TREE);
8686 }
8687 }
8689 /* The list is now in reverse order; correct that. */
8694 }
8695 /* Now call xref_basetypes to set up all the base-class
8696 information. */
8704 /* Now that our base classes are set up, enter the scope of the
8705 class, so that name lookups into base classes, etc. will work
8706 correctly. This is precisely analogous to what we do in
8707 begin_class_definition when defining an ordinary non-template
8708 class, except we also need to push the enclosing classes. */
8711 /* Now members are processed in the order of declaration. */
8714 {
8718 {
8720 {
8721 /* Build new CLASSTYPE_NESTED_UTDS. */
8723 tree newtag;
8729 /* If the member is a class template, then -- even after
8730 substitution -- there may be dependent types in the
8731 template argument list for the class. We increment
8732 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
8733 that function will assume that no types are dependent
8734 when outside of a template. */
8744 {
8748 /* Unfortunately, lookup_template_class sets
8749 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
8750 instantiation (i.e., for the type of a member
8751 template class nested within a template class.)
8752 This behavior is required for
8753 maybe_process_partial_specialization to work
8754 correctly, but is not accurate in this case;
8755 the TAG is not an instantiation of anything.
8756 (The corresponding TEMPLATE_DECL is an
8757 instantiation, but the TYPE is not.) */
8760 /* Now, we call pushtag to put this NEWTAG into the scope of
8761 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
8762 pushtag calling push_template_decl. We don't have to do
8763 this for enums because it will already have been done in
8764 tsubst_enum. */
8768 }
8769 }
8772 {
8773 /* Build new TYPE_METHODS. */
8774 tree r;
8783 /* Instantiate members marked with attribute used. */
8786 }
8787 else
8788 {
8789 /* Build new TYPE_FIELDS. */
8791 {
8792 tree condition;
8795 condition =
8805 }
8807 {
8808 tree r;
8810 /* The file and line for this declaration, to
8811 assist in error message reporting. Since we
8812 called push_tinst_level above, we don't need to
8813 restore these. */
8822 {
8823 /* In [temp.inst]:
8825 [t]he initialization (and any associated
8826 side-effects) of a static data member does
8827 not occur unless the static data member is
8828 itself used in a way that requires the
8829 definition of the static data member to
8830 exist.
8832 Therefore, we do not substitute into the
8833 initialized for the static data member here. */
8834 finish_static_data_member_decl
8840 /* Instantiate members marked with attribute used. */
8843 }
8845 {
8846 /* Determine whether R has a valid type and can be
8847 completed later. If R is invalid, then it is
8848 replaced by error_mark_node so that it will not be
8849 added to TYPE_FIELDS. */
8855 {
8858 }
8859 }
8861 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
8862 such a thing will already have been added to the field
8863 list by tsubst_enum in finish_member_declaration in the
8864 CLASSTYPE_NESTED_UTDS case above. */
8868 {
8871 }
8872 }
8873 }
8874 }
8875 else
8876 {
8879 {
8880 /* Build new CLASSTYPE_FRIEND_CLASSES. */
8886 {
8887 /* template <class T> friend class C; */
8890 }
8892 {
8893 /* template <class T> friend class C::D; */
8899 }
8902 {
8903 /* This could be either
8905 friend class T::C;
8907 when dependent_type_p is false or
8909 template <class U> friend class T::C;
8911 otherwise. */
8914 /* Bump processing_template_decl for correct
8915 dependent_type_p calculation. */
8920 }
8923 {
8924 /* friend class C;
8926 where C hasn't been declared yet. Let's lookup name
8927 from namespace scope directly, bypassing any name that
8928 come from dependent base class. */
8931 /* The call to xref_tag_from_type does injection for friend
8932 classes. */
8934 friend_type =
8938 }
8940 /* friend class C<T>; */
8943 /* Otherwise it's
8945 friend class C;
8947 where C is already declared or
8949 friend class C<int>;
8951 We don't have to do anything in these cases. */
8954 /* Trick make_friend_class into realizing that the friend
8955 we're adding is a template, not an ordinary class. It's
8956 important that we use make_friend_class since it will
8957 perform some error-checking and output cross-reference
8958 information. */
8966 }
8967 else
8968 {
8969 /* Build new DECL_FRIENDLIST. */
8970 tree r;
8972 /* The file and line for this declaration, to
8973 assist in error message reporting. Since we
8974 called push_tinst_level above, we don't need to
8975 restore these. */
8979 {
8982 }
8987 {
8990 }
8991 }
8992 }
8993 }
8996 {
8999 {
9002 }
9003 else
9005 }
9007 /* Set the file and line number information to whatever is given for
9008 the class itself. This puts error messages involving generated
9009 implicit functions at a predictable point, and the same point
9010 that would be used for non-template classes. */
9017 /* We don't instantiate default arguments for member functions. 14.7.1:
9019 The implicit instantiation of a class template specialization causes
9020 the implicit instantiation of the declarations, but not of the
9021 definitions or default arguments, of the class member functions,
9022 member classes, static data members and member templates.... */
9024 /* Some typedefs referenced from within the template code need to be access
9025 checked at template instantiation time, i.e now. These types were
9026 added to the template at parsing time. Let's get those and perform
9027 the access checks then. */
9037 /* The vtable for a template class can be emitted in any translation
9038 unit in which the class is instantiated. When there is no key
9039 method, however, finish_struct_1 will already have added TYPE to
9040 the keyed_classes list. */
9045 }
9047 /* Wrapper for instantiate_class_template_1. */
9049 tree
9051 {
9052 tree ret;
9057 }
9059 static tree
9061 {
9062 tree r;
9068 else
9069 {
9076 /* Preserve the raw-reference nature of T. */
9080 }
9082 }
9084 /* Given a function parameter pack TMPL_PARM and some function parameters
9085 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9086 and set *SPEC_P to point at the next point in the list. */
9088 static tree
9090 {
9091 /* Collect all of the extra "packed" parameters into an
9092 argument pack. */
9093 tree parmvec;
9094 tree parmtypevec;
9105 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9110 {
9113 }
9115 /* Build the argument packs. */
9122 }
9124 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9125 NONTYPE_ARGUMENT_PACK. */
9127 static tree
9129 {
9131 }
9133 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9134 pack expansion. */
9136 static bool
9138 {
9143 }
9146 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9148 static tree
9150 {
9157 }
9159 /* This is a subroutine of tsubst_pack_expansion.
9161 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9162 mechanism to store the (non complete list of) arguments of the
9163 substitution and return a non substituted pack expansion, in order
9164 to wait for when we have enough arguments to really perform the
9165 substitution. */
9167 static bool
9171 {
9177 {
9180 parm_pack;
9182 {
9187 else
9189 }
9191 /* If one pack has an expansion and another pack has a normal
9192 argument or if one pack has an empty argument another one
9193 hasn't then tsubst_pack_expansion cannot perform the
9194 substitution and need to fall back on the
9195 PACK_EXPANSION_EXTRA mechanism. */
9199 }
9201 }
9203 /* [temp.variadic]/6 says that:
9205 The instantiation of a pack expansion [...]
9206 produces a list E1,E2, ..., En, where N is the number of elements
9207 in the pack expansion parameters.
9209 This subroutine of tsubst_pack_expansion produces one of these Ei.
9211 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9212 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9213 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9214 INDEX is the index 'i' of the element Ei to produce. ARGS,
9215 COMPLAIN, and IN_DECL are the same parameters as for the
9216 tsubst_pack_expansion function.
9218 The function returns the resulting Ei upon successful completion,
9219 or error_mark_node.
9221 Note that this function possibly modifies the ARGS parameter, so
9222 it's the responsibility of the caller to restore it. */
9224 static tree
9226 tree parm_packs,
9228 tree args /* This parm gets
9230 tsubst_flags_t complain,
9231 tree in_decl)
9232 {
9233 tree t;
9236 /* For each parameter pack, change the substitution of the parameter
9237 pack to the ith argument in its argument pack, then expand the
9238 pattern. */
9240 {
9245 ith_elem_is_expansion |=
9248 /* Select the Ith argument from the pack. */
9250 {
9252 {
9256 }
9257 else
9259 }
9260 else
9261 {
9266 {
9268 /* Update the corresponding argument. */
9270 }
9271 else
9272 /* Re-use the ARGUMENT_PACK_SELECT. */
9274 }
9276 }
9278 /* Substitute into the PATTERN with the (possibly altered)
9279 arguments. */
9283 else
9286 /* If the Ith argument pack element is a pack expansion, then
9287 the Ith element resulting from the substituting is going to
9288 be a pack expansion as well. */
9293 }
9295 /* Substitute ARGS into T, which is an pack expansion
9296 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9297 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9298 (if only a partial substitution could be performed) or
9299 ERROR_MARK_NODE if there was an error. */
9300 tree
9302 tree in_decl)
9303 {
9304 tree pattern;
9308 tree result;
9316 /* Add in any args remembered from an earlier partial instantiation. */
9321 /* Determine the argument packs that will instantiate the parameter
9322 packs used in the expansion expression. While we're at it,
9323 compute the number of arguments to be expanded and make sure it
9324 is consistent. */
9327 {
9334 {
9338 else
9341 }
9343 {
9346 else
9347 {
9348 /* We can't rely on local_specializations for a parameter
9349 name used later in a function declaration (such as in a
9350 late-specified return type). Even if it exists, it might
9351 have the wrong value for a recursive call. Just make a
9352 dummy decl, since it's only used for its type. */
9355 /* Partial instantiation of the parm_pack, we can't build
9356 up an argument pack yet. */
9358 else
9361 }
9362 }
9363 else
9364 {
9370 }
9377 /* This can only happen if we forget to expand an argument
9378 pack somewhere else. Just return an error, silently. */
9379 {
9383 }
9386 {
9390 /* Don't bother trying to do a partial substitution with
9391 incomplete packs; we'll try again after deduction. */
9398 {
9404 pattern);
9405 else
9408 pattern);
9410 }
9412 /* Keep track of the parameter packs and their corresponding
9413 argument packs. */
9416 }
9417 else
9418 {
9419 /* We can't substitute for this parameter pack. We use a flag as
9420 well as the missing_level counter because function parameter
9421 packs don't have a level. */
9423 }
9424 }
9426 /* We cannot expand this expansion expression, because we don't have
9427 all of the argument packs we need. */
9429 {
9430 /* We got some full packs, but we can't substitute them in until we
9431 have values for all the packs. So remember these until then. */
9436 }
9438 {
9439 /* There were no real arguments, we're just replacing a parameter
9440 pack with another version of itself. Substitute into the
9441 pattern and return a PACK_EXPANSION_*. The caller will need to
9442 deal with that. */
9446 else
9450 }
9455 {
9456 /* We're in a late-specified return type, so create our own local
9457 specializations map; the current map is either NULL or (in the
9458 case of recursive unification) might have bindings that we don't
9459 want to use or alter. */
9462 }
9464 /* For each argument in each argument pack, substitute into the
9465 pattern. */
9468 {
9470 i,
9472 in_decl);
9475 {
9478 }
9479 }
9481 /* Update ARGS to restore the substitution from parameter packs to
9482 their argument packs. */
9484 {
9489 else
9490 {
9498 /* Update the corresponding argument. */
9502 else
9504 }
9505 }
9508 {
9511 }
9514 }
9516 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9517 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9518 parameter packs; all parms generated from a function parameter pack will
9519 have the same DECL_PARM_INDEX. */
9521 tree
9523 {
9525 tree patparm;
9528 {
9534 }
9535 else
9536 {
9541 }
9544 }
9546 /* Substitute ARGS into the vector or list of template arguments T. */
9548 static tree
9550 {
9562 {
9564 tree new_arg;
9569 {
9570 /* Substitute into an expansion expression. */
9574 /* Add to the expanded length adjustment the number of
9575 expanded arguments. We subtract one from this
9576 measurement, because the argument pack expression
9577 itself is already counted as 1 in
9578 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9579 the argument pack is empty. */
9581 }
9583 {
9584 /* Substitute into each of the arguments. */
9590 new_arg,
9604 }
9605 }
9606 else
9615 }
9620 /* Make space for the expanded arguments coming from template
9621 argument packs. */
9623 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
9624 arguments for a member template.
9625 In that case each TREE_VEC in ORIG_T represents a level of template
9626 arguments, and ORIG_T won't carry any non defaulted argument count.
9627 It will rather be the nested TREE_VECs that will carry one.
9628 In other words, ORIG_T carries a non defaulted argument count only
9629 if it doesn't contain any nested TREE_VEC. */
9631 {
9635 }
9637 {
9641 {
9644 /* Now expand the template argument pack "in place". */
9647 }
9648 else
9649 {
9651 out++;
9652 }
9653 }
9656 }
9658 /* Return the result of substituting ARGS into the template parameters
9659 given by PARMS. If there are m levels of ARGS and m + n levels of
9660 PARMS, then the result will contain n levels of PARMS. For
9661 example, if PARMS is `template <class T> template <class U>
9662 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
9663 result will be `template <int*, double, class V>'. */
9665 static tree
9667 {
9671 /* When substituting into a template, we must set
9672 PROCESSING_TEMPLATE_DECL as the template parameters may be
9673 dependent if they are based on one-another, and the dependency
9674 predicates are short-circuit outside of templates. */
9681 {
9682 tree new_vec =
9687 {
9688 tree tuple;
9700 }
9706 }
9711 }
9713 /* Return the result of substituting ARGS into one template parameter
9714 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
9715 parameter and which TREE_PURPOSE is the default argument of the
9716 template parameter. */
9718 static tree
9720 {
9741 }
9743 /* Substitute the ARGS into the indicated aggregate (or enumeration)
9744 type T. If T is not an aggregate or enumeration type, it is
9745 handled as if by tsubst. IN_DECL is as for tsubst. If
9746 ENTERING_SCOPE is nonzero, T is the context for a template which
9747 we are presently tsubst'ing. Return the substituted value. */
9749 static tree
9751 tree args,
9752 tsubst_flags_t complain,
9753 tree in_decl,
9755 {
9760 {
9765 /* Else fall through. */
9769 {
9770 tree argvec;
9771 tree context;
9772 tree r;
9776 /* In "sizeof(X<I>)" we need to evaluate "I". */
9782 /* First, determine the context for the type we are looking
9783 up. */
9786 {
9789 /* If context is a nested class inside a class template,
9790 it may still need to be instantiated (c++/33959). */
9792 }
9794 /* Then, figure out what arguments are appropriate for the
9795 type we are trying to find. For example, given:
9797 template <class T> struct S;
9798 template <class T, class U> void f(T, U) { S<U> su; }
9800 and supposing that we are instantiating f<int, double>,
9801 then our ARGS will be {int, double}, but, when looking up
9802 S we only want {double}. */
9807 else
9808 {
9812 }
9818 }
9819 else
9820 /* This is not a template type, so there's nothing to do. */
9825 }
9826 }
9828 /* Substitute into the default argument ARG (a default argument for
9829 FN), which has the indicated TYPE. */
9831 tree
9833 {
9838 /* This can happen in invalid code. */
9842 /* This default argument came from a template. Instantiate the
9843 default argument here, not in tsubst. In the case of
9844 something like:
9846 template <class T>
9847 struct S {
9848 static T t();
9849 void f(T = t());
9850 };
9852 we must be careful to do name lookup in the scope of S<T>,
9853 rather than in the current class. */
9855 /* The "this" pointer is not valid in a default argument. */
9857 {
9862 }
9865 /* The default argument expression may cause implicitly defined
9866 member functions to be synthesized, which will result in garbage
9867 collection. We must treat this situation as if we were within
9868 the body of function so as to avoid collecting live data on the
9869 stack. */
9877 /* Restore the "this" pointer. */
9879 {
9882 }
9888 /* Make sure the default argument is reasonable. */
9894 }
9896 /* Substitute into all the default arguments for FN. */
9898 static void
9900 {
9901 tree arg;
9902 tree tmpl_args;
9906 /* If this function is not yet instantiated, we certainly don't need
9907 its default arguments. */
9910 /* Don't do this again for clones. */
9915 arg;
9921 }
9923 /* Substitute the ARGS into the T, which is a _DECL. Return the
9924 result of the substitution. Issue error and warning messages under
9925 control of COMPLAIN. */
9927 static tree
9929 {
9930 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
9931 location_t saved_loc;
9936 /* Set the filename and linenumber to improve error-reporting. */
9941 {
9943 {
9944 /* We can get here when processing a member function template,
9945 member class template, or template template parameter. */
9947 tree spec;
9948 tree tmpl_args;
9949 tree full_args;
9952 {
9953 /* Template template parameter is treated here. */
9957 /* If we get a real template back, return it. This can happen in
9958 the context of most_specialized_class. */
9970 complain);
9973 }
9975 /* We might already have an instance of this template.
9976 The ARGS are for the surrounding class type, so the
9977 full args contain the tsubst'd args for the context,
9978 plus the innermost args from the template decl. */
9982 /* Because this is a template, the arguments will still be
9983 dependent, even after substitution. If
9984 PROCESSING_TEMPLATE_DECL is not set, the dependency
9985 predicates will short-circuit. */
9993 /* If this is a default template template argument,
9994 tsubst might not have changed anything. */
10001 {
10004 }
10006 /* Make a new template decl. It will be similar to the
10007 original, but will record the current template arguments.
10008 We also create a new function declaration, which is just
10009 like the old one, but points to this new template, rather
10010 than the old one. */
10019 {
10020 tree new_type;
10032 }
10033 else
10034 {
10035 tree new_decl;
10047 }
10053 /* The template parameters for this new template are all the
10054 template parameters for the old template, except the
10055 outermost level of parameters. */
10058 complain);
10064 /* Record this non-type partial instantiation. */
10068 }
10072 {
10073 tree ctx;
10076 tree gen_tmpl;
10077 tree type;
10082 /* Nobody should be tsubst'ing into non-template functions. */
10086 {
10087 tree spec;
10090 /* If T is not dependent, just return it. We have to
10091 increment PROCESSING_TEMPLATE_DECL because
10092 value_dependent_expression_p assumes that nothing is
10093 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10100 /* Calculate the most general template of which R is a
10101 specialization, and the complete set of arguments used to
10102 specialize R. */
10105 (DECL_TEMPLATE_RESULT
10111 /* Check to see if we already have this specialization. */
10116 {
10119 }
10121 /* We can see more levels of arguments than parameters if
10122 there was a specialization of a member template, like
10123 this:
10125 template <class T> struct S { template <class U> void f(); }
10126 template <> template <class U> void S<int>::f(U);
10128 Here, we'll be substituting into the specialization,
10129 because that's where we can find the code we actually
10130 want to generate, but we'll have enough arguments for
10131 the most general template.
10133 We also deal with the peculiar case:
10135 template <class T> struct S {
10136 template <class U> friend void f();
10137 };
10138 template <class U> void f() {}
10139 template S<int>;
10140 template void f<double>();
10142 Here, the ARGS for the instantiation of will be {int,
10143 double}. But, we only need as many ARGS as there are
10144 levels of template parameters in CODE_PATTERN. We are
10145 careful not to get fooled into reducing the ARGS in
10146 situations like:
10148 template <class T> struct S { template <class U> void f(U); }
10149 template <class T> template <> void S<T>::f(int) {}
10151 which we can spot because the pattern will be a
10152 specialization in this case. */
10154 parms_depth =
10159 }
10160 else
10161 {
10162 /* This special case arises when we have something like this:
10164 template <class T> struct S {
10165 friend void f<int>(int, double);
10166 };
10168 Here, the DECL_TI_TEMPLATE for the friend declaration
10169 will be an IDENTIFIER_NODE. We are being called from
10170 tsubst_friend_function, and we want only to create a
10171 new decl (R) with appropriate types so that we can call
10172 determine_specialization. */
10174 }
10177 {
10180 else
10184 }
10185 else
10186 {
10189 }
10194 /* If we hit excessive deduction depth, the type is bogus even if
10195 it isn't error_mark_node, so don't build a decl. */
10199 /* We do NOT check for matching decls pushed separately at this
10200 point, as they may not represent instantiations of this
10201 template, and in any case are considered separate under the
10202 discrete model. */
10206 /* Clear out the mangled name and RTL for the instantiation. */
10209 /* Leave DECL_INITIAL set on deleted instantiations. */
10215 /* Type-conversion operator. Reconstruct the name, in
10216 case it's the name of one of the template's parameters. */
10226 /* If this is an instantiation of a function with internal
10227 linkage, we already know what object file linkage will be
10228 assigned to the instantiation. */
10237 /* We'll re-clone as appropriate in instantiate_template. */
10240 /* If we aren't complaining now, return on error before we register
10241 the specialization so that we'll complain eventually. */
10247 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10248 this in the special friend case mentioned above where
10249 GEN_TMPL is NULL. */
10251 {
10257 /* We're not supposed to instantiate default arguments
10258 until they are called, for a template. But, for a
10259 declaration like:
10261 template <class T> void f ()
10262 { extern void g(int i = T()); }
10264 we should do the substitution when the template is
10265 instantiated. We handle the member function case in
10266 instantiate_class_template since the default arguments
10267 might refer to other members of the class. */
10272 }
10273 else
10276 /* Copy the list of befriending classes. */
10280 {
10284 in_decl);
10285 }
10288 {
10294 /* If this is an instantiation of a member template, clone it.
10295 If it isn't, that'll be handled by
10296 clone_constructors_and_destructors. */
10299 }
10310 /* Possibly limit visibility based on template args. */
10313 {
10317 }
10325 }
10329 {
10337 {
10338 /* If there is a local specialization that isn't a
10339 parameter pack, it means that we're doing a "simple"
10340 substitution from inside tsubst_pack_expansion. Just
10341 return the local specialization (which will be a single
10342 parm). */
10349 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10350 the parameters in this function parameter pack. */
10354 {
10357 /* Zero-length parameter packs are boring. Just substitute
10358 into the chain. */
10362 }
10363 else
10364 {
10365 /* All we did was update the type. Make a note of that. */
10368 }
10369 }
10371 /* Loop through all of the parameter's we'll build. When T is
10372 a function parameter pack, LEN is the number of expanded
10373 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10376 {
10383 /* We're on the Ith parameter of the function parameter
10384 pack. */
10385 {
10386 /* An argument of a function parameter pack is not a parameter
10387 pack. */
10390 /* Get the Ith type. */
10393 /* Rename the parameter to include the index. */
10396 }
10398 /* We're dealing with a normal parameter. */
10406 {
10409 else
10412 }
10422 /* Keep track of the first new parameter we
10423 generate. That's what will be returned to the
10424 caller. */
10428 /* Build a proper chain of parameters when substituting
10429 into a function parameter pack. */
10432 }
10434 /* If cp_unevaluated_operand is set, we're just looking for a
10435 single dummy parameter, so don't keep going. */
10440 /* FIRST_R contains the start of the chain we've built. */
10442 }
10446 {
10447 tree type;
10457 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10458 non-bit-fields DECL_INITIAL is a non-static data member
10459 initializer, which gets deferred instantiation. */
10465 {
10466 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10467 NSDMI in perform_member_init. Still set DECL_INITIAL
10468 so that we know there is one. */
10473 }
10474 /* We don't have to set DECL_CONTEXT here; it is set by
10475 finish_member_declaration. */
10482 }
10486 /* We reach here only for member using decls. We also need to check
10487 uses_template_parms because DECL_DEPENDENT_P is not set for a
10488 using-declaration that designates a member of the current
10489 instantiation (c++/53549). */
10492 {
10499 else
10500 {
10503 }
10504 }
10505 else
10506 {
10509 }
10514 {
10517 tree spec;
10519 tree ctx;
10525 {
10526 /* If this is the canonical decl, we don't have to
10527 mess with instantiations, and often we can't (for
10528 typename, template type parms and such). Note that
10529 TYPE_NAME is not correct for the above test if
10530 we've copied the type for a typedef. */
10536 }
10538 /* Check to see if we already have the specialization we
10539 need. */
10542 {
10543 /* T is a static data member or namespace-scope entity.
10544 We have to substitute into namespace-scope variables
10545 (even though such entities are never templates) because
10546 of cases like:
10548 template <class T> void f() { extern T t; }
10550 where the entity referenced is not known until
10551 instantiation time. */
10555 {
10557 complain,
10559 /* If CTX is unchanged, then T is in fact the
10560 specialization we want. That situation occurs when
10561 referencing a static data member within in its own
10562 class. We can use pointer equality, rather than
10563 same_type_p, because DECL_CONTEXT is always
10564 canonical... */
10567 /* ... unless T is a member template; in which
10568 case our caller can be willing to create a
10569 specialization of that template represented
10570 by T. */
10574 }
10577 {
10585 }
10586 }
10587 else
10588 {
10589 /* A local variable. */
10591 /* Subsequent calls to pushdecl will fill this in. */
10594 }
10595 /* If we already have the specialization we need, there is
10596 nothing more to do. */
10598 {
10601 }
10604 {
10605 /* Just use name lookup to find a member alias for an anonymous
10606 union, but then add it to the hash table. */
10611 }
10613 /* Create a new node for the specialization we need. */
10616 {
10619 else
10626 }
10628 {
10629 /* Even if the original location is out of scope, the
10630 newly substituted one is not. */
10637 {
10638 /* It may seem that this case cannot occur, since:
10640 typedef void f();
10641 void g() { f x; }
10643 declares a function, not a variable. However:
10645 typedef void f();
10646 template <typename T> void g() { T t; }
10647 template void g<f>();
10649 is an attempt to declare a variable with function
10650 type. */
10652 /* R is not yet sufficiently initialized, so we
10653 just use its name. */
10656 }
10658 /* Wait until cp_finish_decl to set this again, to handle
10659 circular dependency (template/instantiate6.C). */
10664 {
10669 {
10672 }
10674 }
10675 }
10681 /* Clear out the mangled name and RTL for the instantiation. */
10685 /* The initializer must not be expanded until it is required;
10686 see [temp.inst]. */
10692 {
10693 /* Possibly limit visibility based on template args. */
10696 {
10700 }
10702 }
10705 {
10706 /* A static data member declaration is always marked
10707 external when it is declared in-class, even if an
10708 initializer is present. We mimic the non-template
10709 processing here. */
10715 }
10717 {
10718 /* We're substituting this var in a decltype outside of its
10719 scope, such as for a lambda return type. Don't add it to
10720 local_specializations, do perform auto deduction. */
10723 {
10724 tree init
10730 }
10731 }
10732 else
10741 /* Preserve a typedef that names a type. */
10743 {
10746 }
10749 }
10754 }
10755 #undef RETURN
10757 out:
10758 /* Restore the file and line information. */
10762 }
10764 /* Substitute into the ARG_TYPES of a function type.
10765 If END is a TREE_CHAIN, leave it and any following types
10766 un-substituted. */
10768 static tree
10770 tree args,
10771 tree end,
10772 tsubst_flags_t complain,
10773 tree in_decl)
10774 {
10775 tree remaining_arg_types;
10779 tree default_arg;
10790 {
10791 /* For a pack expansion, perform substitution on the
10792 entire expression. Later on, we'll handle the arguments
10793 one-by-one. */
10798 /* So that we'll spin through the parameters, one by one. */
10800 else
10801 {
10802 /* We only partially substituted into the parameter
10803 pack. Our type is TYPE_PACK_EXPANSION. */
10806 }
10807 }
10820 {
10822 {
10826 }
10828 }
10830 /* Do array-to-pointer, function-to-pointer conversion, and ignore
10831 top-level qualifiers as required. */
10834 /* We do not substitute into default arguments here. The standard
10835 mandates that they be instantiated only when needed, which is
10836 done in build_over_call. */
10840 {
10841 /* We've instantiated a template before its default arguments
10842 have been parsed. This can happen for a nested template
10843 class, and is not an error unless we require the default
10844 argument in a call of this function. */
10845 remaining_arg_types =
10848 }
10849 else
10850 remaining_arg_types =
10852 }
10855 }
10857 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
10858 *not* handle the exception-specification for FNTYPE, because the
10859 initial substitution of explicitly provided template parameters
10860 during argument deduction forbids substitution into the
10861 exception-specification:
10863 [temp.deduct]
10865 All references in the function type of the function template to the
10866 corresponding template parameters are replaced by the specified tem-
10867 plate argument values. If a substitution in a template parameter or
10868 in the function type of the function template results in an invalid
10869 type, type deduction fails. [Note: The equivalent substitution in
10870 exception specifications is done only when the function is instanti-
10871 ated, at which point a program is ill-formed if the substitution
10872 results in an invalid type.] */
10874 static tree
10876 tree args,
10877 tsubst_flags_t complain,
10878 tree in_decl)
10879 {
10880 tree return_type;
10881 tree arg_types;
10882 tree fntype;
10884 /* The TYPE_CONTEXT is not used for function/method types. */
10887 /* Substitute the return type. */
10891 /* The standard does not presently indicate that creation of a
10892 function type with an invalid return type is a deduction failure.
10893 However, that is clearly analogous to creating an array of "void"
10894 or a reference to a reference. This is core issue #486. */
10897 {
10899 {
10902 else
10904 }
10906 }
10908 /* Substitute the argument types. */
10914 /* Construct a new type node and return it. */
10916 {
10919 }
10920 else
10921 {
10924 {
10925 /* [temp.deduct]
10927 Type deduction may fail for any of the following
10928 reasons:
10930 -- Attempting to create "pointer to member of T" when T
10931 is not a class type. */
10934 r);
10936 }
10940 }
10944 }
10946 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
10947 ARGS into that specification, and return the substituted
10948 specification. If there is no specification, return NULL_TREE. */
10950 static tree
10952 tree args,
10953 tsubst_flags_t complain,
10954 tree in_decl,
10956 {
10957 tree specs;
10958 tree new_specs;
10963 {
10964 /* A noexcept-specifier. */
10969 {
10970 /* Defer instantiation of noexcept-specifiers to avoid
10971 excessive instantiations (c++/49107). */
10974 {
10975 /* We already partially instantiated this member template,
10976 so combine the new args with the old. */
10981 }
10982 else
10983 {
10986 }
10987 }
10988 else
10989 new_specs = tsubst_copy_and_build
10993 }
10995 {
10998 else
11000 {
11001 tree spec;
11006 {
11007 /* Expand the pack expansion type. */
11010 in_decl);
11016 else
11017 {
11018 /* We're substituting into a member template, so
11019 we got a TYPE_PACK_EXPANSION back. Add that
11020 expansion and move on. */
11024 expanded_specs,
11025 complain);
11028 }
11029 }
11032 {
11035 else
11040 complain);
11041 }
11044 }
11045 }
11047 }
11049 /* Take the tree structure T and replace template parameters used
11050 therein with the argument vector ARGS. IN_DECL is an associated
11051 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11052 Issue error and warning messages under control of COMPLAIN. Note
11053 that we must be relatively non-tolerant of extensions here, in
11054 order to preserve conformance; if we allow substitutions that
11055 should not be allowed, we may allow argument deductions that should
11056 not succeed, and therefore report ambiguous overload situations
11057 where there are none. In theory, we could allow the substitution,
11058 but indicate that it should have failed, and allow our caller to
11059 make sure that the right thing happens, but we don't try to do this
11060 yet.
11062 This function is used for dealing with types, decls and the like;
11063 for expressions, use tsubst_expr or tsubst_copy. */
11065 tree
11067 {
11090 else
11095 /* Reuse typedefs. We need to do this to handle dependent attributes,
11096 such as attribute aligned. */
11099 {
11103 {
11104 /* DECL represents an alias template and we want to
11105 instantiate it. */
11109 }
11113 {
11117 }
11122 else
11123 /* The typedef is from a non-template context. */
11127 {
11129 r = cp_build_qualified_type_real
11133 }
11134 else
11135 {
11136 /* We don't have an instantiation yet, so drop the typedef. */
11141 }
11142 }
11155 {
11181 {
11187 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11188 needed. */
11194 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11195 with TREE_SIDE_EFFECTS that indicates this is not an integral
11196 constant expression. */
11199 {
11202 }
11205 }
11211 {
11224 {
11228 {
11229 /* See through ARGUMENT_PACK_SELECT arguments. */
11231 /* If the selected argument is an expansion E, that most
11232 likely means we were called from
11233 gen_elem_of_pack_expansion_instantiation during the
11234 substituting of pack an argument pack (which Ith
11235 element is a pack expansion, where I is
11236 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11237 In this case, the Ith element resulting from this
11238 substituting is going to be a pack expansion, which
11239 pattern is the pattern of E. Let's return the
11240 pattern of E, and
11241 gen_elem_of_pack_expansion_instantiation will
11242 build the resulting pack expansion from it. */
11245 }
11246 }
11251 {
11253 /* If ARG is an argument pack, we don't actually want to
11254 perform a substitution here, because substitutions
11255 for argument packs are only done
11256 element-by-element. We can get to this point when
11257 substituting the type of a non-type template
11258 parameter pack, when that type actually contains
11259 template parameter packs from an outer template, e.g.,
11261 template<typename... Types> struct A {
11262 template<Types... Values> struct B { };
11263 }; */
11267 {
11273 return cp_build_qualified_type_real
11275 }
11277 {
11278 /* We are processing a type constructed from a
11279 template template parameter. */
11290 /* Consider this code:
11292 template <template <class> class Template>
11293 struct Internal {
11294 template <class Arg> using Bind = Template<Arg>;
11295 };
11297 template <template <class> class Template, class Arg>
11298 using Instantiate = Template<Arg>; //#0
11300 template <template <class> class Template,
11301 class Argument>
11302 using Bind =
11303 Instantiate<Internal<Template>::template Bind,
11304 Argument>; //#1
11306 When #1 is parsed, the
11307 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11308 parameter `Template' in #0 matches the
11309 UNBOUND_CLASS_TEMPLATE representing the argument
11310 `Internal<Template>::template Bind'; We then want
11311 to assemble the type `Bind<Argument>' that can't
11312 be fully created right now, because
11313 `Internal<Template>' not being complete, the Bind
11314 template cannot be looked up in that context. So
11315 we need to "store" `Bind<Argument>' for later
11316 when the context of Bind becomes complete. Let's
11317 store that in a TYPENAME_TYPE. */
11321 argvec),
11322 typename_type,
11323 complain);
11325 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11326 are resolving nested-types in the signature of a
11327 member function templates. Otherwise ARG is a
11328 TEMPLATE_DECL and is the real template to be
11329 instantiated. */
11337 complain);
11338 return cp_build_qualified_type_real
11340 }
11341 else
11342 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11344 }
11347 /* This can happen during the attempted tsubst'ing in
11348 unify. This means that we don't yet have any information
11349 about the template parameter in question. */
11352 /* Early in template argument deduction substitution, we don't
11353 want to reduce the level of 'auto', or it will be confused
11354 with a normal template parm in subsequent deduction. */
11358 /* If we get here, we must have been looking at a parm for a
11359 more deeply nested template. Make a new version of this
11360 template parameter, but with a lower level. */
11362 {
11367 {
11369 r = cp_build_qualified_type_real
11373 }
11374 else
11375 {
11386 /* We have reduced the level of the template
11387 template parameter, but not the levels of its
11388 template parameters, so canonical_type_parameter
11389 will not be able to find the canonical template
11390 template parameter for this level. Thus, we
11391 require structural equality checking to compare
11392 TEMPLATE_TEMPLATE_PARMs. */
11396 else
11400 {
11408 }
11409 }
11418 }
11421 }
11424 {
11432 {
11436 }
11439 {
11443 }
11446 {
11450 }
11456 }
11459 /* We should never be tsubsting a binfo. */
11463 /* A vector of template arguments. */
11469 {
11473 /* [temp.deduct]
11475 Type deduction may fail for any of the following
11476 reasons:
11478 -- Attempting to create a pointer to reference type.
11479 -- Attempting to create a reference to a reference type or
11480 a reference to void.
11482 Core issue 106 says that creating a reference to a reference
11483 during instantiation is no longer a cause for failure. We
11484 only enforce this check in strict C++98 mode. */
11488 {
11491 /* We keep track of the last time we issued this error
11492 message to avoid spewing a ton of messages during a
11493 single bad template instantiation. */
11496 {
11501 else
11504 }
11507 }
11509 {
11513 }
11515 /* In C++0x, during template argument substitution, when there is an
11516 attempt to create a reference to a reference type, reference
11517 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
11519 "If a template-argument for a template-parameter T names a type
11520 that is a reference to a type A, an attempt to create the type
11521 'lvalue reference to cv T' creates the type 'lvalue reference to
11522 A,' while an attempt to create the type type rvalue reference to
11523 cv T' creates the type T"
11524 */
11525 r = cp_build_reference_type
11528 else
11533 /* Will this ever be needed for TYPE_..._TO values? */
11537 }
11539 {
11542 {
11543 /* [temp.deduct]
11545 Type deduction may fail for any of the following
11546 reasons:
11548 -- Attempting to create "pointer to member of T" when T
11549 is not a class type. */
11553 }
11555 {
11559 }
11561 {
11565 }
11568 {
11569 /* The type of the implicit object parameter gets its
11570 cv-qualifiers from the FUNCTION_TYPE. */
11571 tree memptr;
11575 complain);
11576 }
11577 else
11580 complain);
11581 }
11584 {
11585 tree fntype;
11586 tree specs;
11591 /* Substitute the exception specification. */
11599 }
11601 {
11606 /* As an optimization, we avoid regenerating the array type if
11607 it will obviously be the same as T. */
11611 /* These checks should match the ones in grokdeclarator.
11613 [temp.deduct]
11615 The deduction may fail for any of the following reasons:
11617 -- Attempting to create an array with an element type that
11618 is void, a function type, or a reference type, or [DR337]
11619 an abstract class type. */
11623 {
11627 }
11629 {
11632 type);
11634 }
11639 {
11642 }
11645 }
11648 {
11658 {
11662 }
11664 {
11665 /* Normally, make_typename_type does not require that the CTX
11666 have complete type in order to allow things like:
11668 template <class T> struct S { typename S<T>::X Y; };
11670 But, such constructs have already been resolved by this
11671 point, so here CTX really should have complete type, unless
11672 it's a partial instantiation. */
11675 {
11679 }
11680 }
11687 {
11690 }
11693 {
11695 {
11699 else
11701 }
11703 {
11707 else
11709 }
11710 }
11712 return cp_build_qualified_type_real
11714 }
11717 {
11729 }
11732 {
11733 tree type;
11749 complain);
11750 }
11753 {
11754 tree type;
11770 else
11771 type = finish_decltype_type
11776 complain);
11777 }
11780 {
11784 }
11788 {
11790 tree packed_out =
11792 args,
11793 complain,
11794 in_decl);
11797 /* For template nontype argument packs, also substitute into
11798 the type. */
11803 }
11818 /* We should use one of the expression tsubsts for these codes. */
11824 }
11825 }
11827 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
11828 type of the expression on the left-hand side of the "." or "->"
11829 operator. */
11831 static tree
11834 {
11835 tree name;
11836 tree qualifying_scope;
11837 tree fns;
11838 tree optype;
11843 /* A baselink indicates a function from a base class. Both the
11844 BASELINK_ACCESS_BINFO and the base class referenced may
11845 indicate bases of the template class, rather than the
11846 instantiated class. In addition, lookups that were not
11847 ambiguous before may be ambiguous now. Therefore, we perform
11848 the lookup again. */
11855 {
11862 }
11870 /* If lookup found a single function, mark it as used at this
11871 point. (If it lookup found multiple functions the one selected
11872 later by overload resolution will be marked as used at that
11873 point.) */
11879 /* Add back the template arguments, if present. */
11884 template_args);
11885 /* Update the conversion operator type. */
11893 qualifying_scope,
11894 object_type);
11896 }
11898 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
11899 true if the qualified-id will be a postfix-expression in-and-of
11900 itself; false if more of the postfix-expression follows the
11901 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
11902 of "&". */
11904 static tree
11908 {
11909 tree expr;
11910 tree scope;
11911 tree name;
11913 tree template_args;
11918 /* Figure out what name to look up. */
11921 {
11929 }
11930 else
11931 {
11934 }
11936 /* Substitute into the qualifying scope. When there are no ARGS, we
11937 are just trying to simplify a non-dependent expression. In that
11938 case the qualifying scope may be dependent, and, in any case,
11939 substituting will not help. */
11942 {
11945 }
11946 else
11950 {
11955 }
11958 {
11960 {
11961 /* A BIT_NOT_EXPR is used to represent a destructor. */
11963 {
11967 }
11968 else
11971 }
11972 else
11976 {
11978 {
11982 }
11984 }
11985 }
11988 {
11990 scope);
11991 /* Remember that there was a reference to this entity. */
11993 }
11996 {
12002 }
12011 {
12012 expr = (adjust_result_of_qualified_name_lookup
12014 expr = (finish_qualified_id_expr
12018 }
12020 /* Expressions do not generally have reference type. */
12022 /* However, if we're about to form a pointer-to-member, we just
12023 want the referenced member referenced. */
12028 }
12030 /* Like tsubst, but deals with expressions. This function just replaces
12031 template parms; to finish processing the resultant expression, use
12032 tsubst_copy_and_build or tsubst_expr. */
12034 static tree
12036 {
12038 tree r;
12046 {
12051 {
12052 /* We get here for a use of 'this' in an NSDMI. */
12058 /* This can happen for a parameter name used later in a function
12059 declaration (such as in a late-specified return type). Just
12060 make a dummy decl, since it's only used for its type. */
12063 /* Give it the template pattern as its context; its true context
12064 hasn't been instantiated yet and this is good enough for
12065 mangling. */
12067 }
12075 {
12076 tree enum_type;
12077 tree v;
12081 /* There is no need to substitute into namespace-scope
12082 enumerators. */
12085 /* If ARGS is NULL, then T is known to be non-dependent. */
12089 /* Unfortunately, we cannot just call lookup_name here.
12090 Consider:
12092 template <int I> int f() {
12093 enum E { a = I };
12094 struct S { void g() { E e = a; } };
12095 };
12097 When we instantiate f<7>::S::g(), say, lookup_name is not
12098 clever enough to find f<7>::a. */
12099 enum_type
12109 /* We didn't find the name. That should never happen; if
12110 name-lookup found it during preliminary parsing, we
12111 should find it again here during instantiation. */
12113 }
12118 {
12119 tree ctx;
12124 {
12127 {
12131 }
12133 }
12134 }
12150 /* An OVERLOAD will always be a non-dependent overload set; an
12151 overload set from function scope will just be represented with an
12152 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12167 {
12168 /* Template template argument like the following example need
12169 special treatment:
12171 template <template <class> class TT> struct C {};
12172 template <class T> struct D {
12173 template <class U> struct E {};
12174 C<E> c; // #1
12175 };
12176 D<int> d; // #2
12178 We are processing the template argument `E' in #1 for
12179 the template instantiation #2. Originally, `E' is a
12180 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12181 have to substitute this with one having context `D<int>'. */
12185 }
12186 else
12187 /* Ordinary template template argument. */
12198 return build1
12204 {
12214 /* We only want to compute the number of arguments. */
12228 {
12235 else
12238 }
12239 else
12241 }
12243 {
12251 }
12252 /* Fall through */
12267 return build1
12272 {
12273 tree object;
12274 tree name;
12279 {
12283 }
12286 {
12296 }
12301 in_decl);
12302 else
12305 }
12343 return build_nt
12356 return build_nt
12363 {
12371 }
12376 {
12377 r = build_nt
12383 }
12386 {
12387 r = build_nt
12393 }
12396 {
12397 r = build_nt
12403 }
12406 {
12407 /* Substituted template arguments */
12416 }
12419 {
12439 }
12464 {
12467 }
12468 else
12472 /* This is handled by tsubst_copy_and_build. */
12478 in_decl),
12482 /* We shouldn't have built any of these during initial template
12483 generation. Instead, they should be built during instantiation
12484 in response to the saved STMT_IS_FULL_EXPR_P setting. */
12488 r = build2
12508 {
12509 /* Instantiate any typedefs in the type. */
12514 }
12517 /* These can sometimes show up in a partial instantiation, but never
12518 involve template parms. */
12523 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
12526 }
12527 }
12529 /* Like tsubst_copy, but specifically for OpenMP clauses. */
12531 static tree
12533 tree in_decl)
12534 {
12538 {
12544 {
12547 {
12553 }
12554 /* FALLTHRU */
12578 }
12579 }
12582 }
12584 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
12586 static tree
12588 tree in_decl)
12589 {
12590 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
12610 {
12613 else
12614 {
12618 }
12619 }
12624 #undef RECUR
12625 }
12627 /* Substitute one OMP_FOR iterator. */
12629 static void
12634 {
12635 #define RECUR(NODE) \
12636 tsubst_expr ((NODE), args, complain, in_decl, \
12637 integral_constant_expression_p)
12645 /* Do this before substituting into decl to handle 'auto'. */
12650 {
12654 }
12659 {
12666 complain);
12667 else
12674 }
12677 {
12678 tree c;
12680 {
12691 }
12693 {
12698 {
12701 }
12702 }
12703 }
12709 else
12713 {
12724 {
12731 }
12732 else
12738 {
12744 }
12748 {
12755 }
12756 else
12762 }
12768 #undef RECUR
12769 }
12771 /* Like tsubst_copy for expressions, etc. but also does semantic
12772 processing. */
12774 static tree
12777 {
12778 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12779 #define RECUR(NODE) \
12780 tsubst_expr ((NODE), args, complain, in_decl, \
12781 integral_constant_expression_p)
12784 tree r;
12785 location_t loc;
12797 {
12799 {
12800 tree_stmt_iterator i;
12804 }
12819 else
12828 {
12830 tree init;
12836 {
12839 tree decl;
12847 else
12849 }
12850 else
12851 {
12855 {
12856 /* By marking the declaration as instantiated, we avoid
12857 trying to instantiate it. Since instantiate_decl can't
12858 handle local variables, and since we've already done
12859 all that needs to be done, that's the right thing to
12860 do. */
12865 /* Anonymous aggregates are a special case. */
12868 {
12871 {
12875 }
12877 }
12880 else
12881 {
12886 {
12887 /* For __PRETTY_FUNCTION__ we have to adjust the
12888 initializer. */
12892 }
12893 else
12894 {
12898 {
12899 /* If we had an initializer but it
12900 instantiated to nothing,
12901 value-initialize the object. This will
12902 only occur when the initializer was a
12903 pack expansion where the parameter packs
12904 used in that expansion were of length
12905 zero. */
12907 complain);
12910 }
12911 else
12913 }
12916 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
12919 }
12920 }
12921 }
12924 }
12939 {
12949 }
12976 {
12980 }
12988 else
12996 else
13023 {
13025 tree label;
13030 }
13036 /* Computed goto's must be tsubst'd into. On the other hand,
13037 non-computed gotos must not be; the identifier in question
13038 will have no binding. */
13040 else
13046 tmp = finish_asm_stmt
13053 {
13058 }
13063 {
13068 }
13069 else
13070 {
13075 else
13082 else
13088 else
13090 }
13094 {
13098 {
13100 /* Prevent instantiate_decl from trying to instantiate
13101 this variable. We've already done all that needs to be
13102 done. */
13105 }
13110 }
13116 {
13117 /* Local classes are not independent templates; they are
13118 instantiated along with their containing function. And this
13119 way we don't have to deal with pushing out of one local class
13120 to instantiate a member of another local class. */
13121 tree fn;
13122 /* Closures are handled by the LAMBDA_EXPR. */
13128 }
13132 {
13133 tree condition;
13136 condition =
13138 args,
13147 }
13168 {
13185 integral_constant_expression_p);
13199 }
13231 {
13236 {
13239 }
13244 }
13245 else
13246 {
13253 {
13256 }
13259 {
13264 {
13267 }
13271 }
13272 else
13273 {
13277 }
13279 }
13283 {
13289 {
13293 {
13298 }
13302 }
13303 else
13304 {
13309 }
13310 }
13328 /* If the first operand was a statement, we're done with it. */
13332 complain));
13339 integral_constant_expression_p));
13340 }
13343 out:
13346 #undef RECUR
13347 #undef RETURN
13348 }
13350 /* T is a postfix-expression that is not being used in a function
13351 call. Return the substituted version of T. */
13353 static tree
13355 tsubst_flags_t complain,
13356 tree in_decl)
13357 {
13361 else
13367 }
13369 /* Like tsubst but deals with expressions and performs semantic
13370 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
13372 tree
13374 tree args,
13375 tsubst_flags_t complain,
13376 tree in_decl,
13379 {
13380 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
13381 #define RECUR(NODE) \
13382 tsubst_copy_and_build (NODE, args, complain, in_decl, \
13384 integral_constant_expression_p)
13387 location_t loc;
13397 {
13400 /* Fall through. */
13402 {
13403 tree decl;
13404 cp_id_kind idk;
13409 {
13412 }
13414 /* Look up the name. */
13417 /* By convention, expressions use ERROR_MARK_NODE to indicate
13418 failure, not NULL_TREE. */
13424 integral_constant_expression_p,
13432 input_location);
13436 {
13440 }
13442 }
13445 {
13446 tree object;
13454 {
13457 }
13458 else
13465 else
13467 }
13470 {
13474 {
13475 /* A type conversion to reference type will be enclosed in
13476 such an indirect ref, but the substitution of the cast
13477 will have also added such an indirect ref. */
13480 }
13481 else
13484 }
13492 {
13499 flags));
13500 }
13513 {
13514 tree type;
13520 {
13525 }
13531 {
13549 }
13553 }
13585 else
13587 in_decl);
13621 {
13622 tree r;
13626 r = build_x_binary_op
13630 ? ERROR_MARK
13634 ? ERROR_MARK
13637 complain);
13644 }
13658 /* Fall through */
13661 {
13662 tree r;
13668 {
13669 /* When there are no ARGS, we are trying to evaluate a
13670 non-dependent expression from the parser. Trying to do
13671 the substitutions may not work. */
13674 }
13675 else
13676 {
13681 else
13684 /*integral_constant_expression_p=*/
13688 }
13692 else
13696 {
13698 {
13700 {
13704 }
13705 else
13709 }
13711 }
13713 }
13716 {
13726 }
13740 {
13741 tree r = build_x_modify_expr
13746 complain);
13747 /* TREE_NO_WARNING must be set if either the expression was
13748 parenthesized or it uses an operator such as >>= rather
13749 than plain assignment. In the former case, it was already
13750 set and must be copied. In the latter case,
13751 build_x_modify_expr sets it and it must not be reset
13752 here. */
13756 }
13761 /* Remember that there was a reference to this entity. */
13767 {
13772 tree ret;
13776 else
13777 {
13781 }
13783 /* If there was an initializer in the original tree, but it
13784 instantiated to an empty list, then we should pass a
13785 non-NULL empty vector to tell build_new that it was an
13786 empty initializer() rather than no initializer. This can
13787 only happen when the initializer is a pack expansion whose
13788 parameter packs are of length zero. */
13791 else
13792 {
13796 else
13797 {
13800 }
13801 }
13808 complain);
13816 }
13824 complain));
13830 complain));
13833 {
13834 tree function;
13839 tree ret;
13842 /* When we parsed the expression, we determined whether or
13843 not Koenig lookup should be performed. */
13846 {
13851 }
13853 {
13854 /* Do nothing; calling tsubst_copy_and_build on an identifier
13855 would incorrectly perform unqualified lookup again.
13857 Note that we can also have an IDENTIFIER_NODE if the earlier
13858 unqualified lookup found a member function; in that case
13859 koenig_p will be false and we do want to do the lookup
13860 again to find the instantiated member function.
13862 FIXME but doing that causes c++/15272, so we need to stop
13863 using IDENTIFIER_NODE in that situation. */
13865 }
13866 else
13867 {
13869 {
13875 }
13876 else
13881 /* Avoid error about taking the address of a constructor. */
13885 in_decl,
13887 integral_constant_expression_p);
13891 }
13896 {
13901 else
13902 {
13903 /* Expand the pack expansion and push each entry onto
13904 CALL_ARGS. */
13907 {
13912 {
13917 }
13918 }
13919 else
13920 {
13921 /* A partial substitution. Add one entry. */
13923 }
13924 }
13925 }
13927 /* We do not perform argument-dependent lookup if normal
13928 lookup finds a non-function, in accordance with the
13929 expected resolution of DR 218. */
13932 /* If lookup found a member function, the Koenig lookup is
13933 not appropriate, even if an unqualified-name was used
13934 to denote the function. */
13937 /* Only do this when substitution turns a dependent call
13938 into a non-dependent call. */
13942 tf_none);
13946 {
13948 {
13949 /* For backwards compatibility and good diagnostics, try
13950 the unqualified lookup again if we aren't in SFINAE
13951 context. */
13952 tree unq = (tsubst_copy_and_build
13954 integral_constant_expression_p));
13959 {
13968 "%qD was not declared in this scope, "
13969 "and no declarations were found by "
13970 "argument-dependent lookup at the point "
13975 {
13977 "declarations in dependent base %qT are "
13983 else
13987 }
13988 else
13992 }
13993 }
13995 {
14000 }
14001 }
14003 /* Remember that there was a reference to this entity. */
14009 complain);
14011 {
14026 complain);
14027 else
14028 ret = (build_new_method_call
14033 complain));
14034 }
14035 else
14038 koenig_p,
14039 complain);
14044 }
14047 {
14052 {
14054 {
14059 }
14060 else
14061 {
14066 }
14067 }
14068 else
14069 {
14072 }
14076 }
14085 {
14093 {
14094 /* We have pack expansions, so expand those and
14095 create a new list out of it. */
14098 tree chain;
14101 /* Expand the argument expressions. */
14109 /* Build the rest of the list. */
14114 /* Determine the number of arguments. */
14116 {
14119 }
14122 else
14123 {
14124 /* Since we only performed a partial substitution into
14125 the argument pack, we only RETURN (a single list
14126 node. */
14133 }
14135 /* Convert the argument vectors into a TREE_LIST */
14138 {
14139 /* Grab the Ith values. */
14140 i--;
14143 value
14147 /* Build the list (backwards). */
14149 }
14152 }
14168 }
14171 {
14172 tree object;
14173 tree object_type;
14174 tree member;
14178 /* Remember that there was a reference to this entity. */
14188 else
14196 {
14198 {
14203 {
14206 }
14208 {
14212 }
14213 }
14214 }
14217 {
14218 /* Lookup the template functions now that we know what the
14219 scope is. */
14227 {
14230 args);
14231 member = (adjust_result_of_qualified_name_lookup
14233 object_type));
14234 }
14235 else
14236 {
14238 input_location);
14240 }
14241 }
14245 {
14247 {
14251 else
14254 }
14256 }
14262 complain));
14263 }
14270 {
14278 tree r;
14283 /* digest_init will do the wrong thing if we let it. */
14287 /* We do not want to process the index of aggregate
14288 initializers as they are identifier nodes which will be
14289 looked up by digest_init. */
14295 {
14300 {
14301 /* Substitute into the pack expansion. */
14303 in_decl);
14307 ;
14309 /* Just move the argument into place. */
14311 else
14312 {
14313 /* Update the length of the final CONSTRUCTOR
14314 arguments vector, and note that we will need to
14315 copy.*/
14318 }
14319 }
14320 else
14322 }
14325 {
14330 {
14332 {
14337 }
14338 else
14340 }
14341 }
14351 }
14354 {
14357 {
14360 }
14361 else
14362 {
14365 }
14366 }
14371 /* Fall through */
14374 {
14378 /* If the original type was a reference, we'll be wrapped in
14379 the appropriate INDIRECT_REF. */
14382 }
14393 {
14402 }
14405 {
14411 integral_constant_expression_p);
14415 /* If the resulting list of expression statement is empty,
14416 fold it further into void_zero_node. */
14421 }
14424 {
14438 /* For a function scope, we want to use tsubst so that we don't
14439 complain about referring to an auto function before its return
14440 type has been deduced. Otherwise, we want to use tsubst_copy so
14441 that we look up the existing field/parameter/variable rather
14442 than build a new one. */
14447 {
14448 /* Look up the parameter we want directly, as tsubst_copy
14449 doesn't do what we need. */
14455 /* FIXME Work around the parm not having DECL_CONTEXT set. */
14458 }
14459 else
14468 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
14470 /* Now that we know visibility, instantiate the type so we have a
14471 declaration of the op() for later calls to lambda_function. */
14474 /* The capture list refers to closure members, so this needs to
14475 wait until after we finish instantiating the type. Also keep
14476 any captures that may have been added during instantiation. */
14483 }
14486 /* We can get here for a constant initializer of non-dependent type.
14487 FIXME stop folding in cp_parser_initializer_clause. */
14488 {
14490 complain);
14492 }
14496 integral_constant_expression_p));
14499 /* Handle Objective-C++ constructs, if appropriate. */
14500 {
14501 tree subst
14506 }
14508 }
14510 #undef RECUR
14511 #undef RETURN
14512 out:
14515 }
14517 /* Verify that the instantiated ARGS are valid. For type arguments,
14518 make sure that the type's linkage is ok. For non-type arguments,
14519 make sure they are constants if they are integral or enumerations.
14520 Emit an error under control of COMPLAIN, and return TRUE on error. */
14522 static bool
14524 {
14528 {
14538 }
14540 {
14541 /* [basic.link]: A name with no linkage (notably, the name
14542 of a class or enumeration declared in a local scope)
14543 shall not be used to declare an entity with linkage.
14544 This implies that names with no linkage cannot be used as
14545 template arguments
14547 DR 757 relaxes this restriction for C++0x. */
14552 {
14553 /* DR 488 makes use of a type with no linkage cause
14554 type deduction to fail. */
14556 {
14559 else
14562 }
14564 }
14565 /* In order to avoid all sorts of complications, we do not
14566 allow variably-modified types as template arguments. */
14568 {
14572 }
14573 }
14574 /* Class template and alias template arguments should be OK. */
14576 ;
14577 /* A non-type argument of integral or enumerated type must be a
14578 constant. */
14582 {
14586 }
14588 }
14590 static bool
14592 {
14597 {
14600 }
14604 }
14606 /* We're out of SFINAE context now, so generate diagnostics for the access
14607 errors we saw earlier when instantiating D from TMPL and ARGS. */
14609 static void
14611 {
14623 }
14625 /* Instantiate the indicated variable, function, or alias template TMPL with
14626 the template arguments in TARG_PTR. */
14628 static tree
14630 {
14632 tree fndecl;
14633 tree gen_tmpl;
14634 tree spec;
14642 /* If this function is a clone, handle it specially. */
14644 {
14645 tree spec;
14646 tree clone;
14648 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
14649 DECL_CLONED_FUNCTION. */
14655 /* Look for the clone. */
14659 /* We should always have found the clone by now. */
14662 }
14664 /* Check to see if we already have this specialization. */
14667 /* The TMPL is a partial instantiation. To get a full set of
14668 arguments we must add the arguments used to perform the
14669 partial instantiation. */
14671 targ_ptr);
14673 /* It would be nice to avoid hashing here and then again in tsubst_decl,
14674 but it doesn't seem to be on the hot path. */
14683 {
14685 {
14689 }
14691 }
14694 complain))
14697 /* We are building a FUNCTION_DECL, during which the access of its
14698 parameters and return types have to be checked. However this
14699 FUNCTION_DECL which is the desired context for access checking
14700 is not built yet. We solve this chicken-and-egg problem by
14701 deferring all checks until we have the FUNCTION_DECL. */
14704 /* Instantiation of the function happens in the context of the function
14705 template, not the context of the overload resolution we're doing. */
14707 /* If there are dependent arguments, e.g. because we're doing partial
14708 ordering, make sure processing_template_decl stays set. */
14712 {
14716 }
14717 /* Substitute template parameters to obtain the specialization. */
14725 {
14728 }
14730 /* The DECL_TI_TEMPLATE should always be the immediate parent
14731 template, not the most general template. */
14734 /* Now we know the specialization, compute access previously
14735 deferred. */
14742 /* If we've just instantiated the main entry point for a function,
14743 instantiate all the alternate entry points as well. We do this
14744 by cloning the instantiation of the main entry point, not by
14745 instantiating the template clones. */
14750 {
14752 {
14753 /* Remember to reinstantiate when we're out of SFINAE so the user
14754 can see the errors. */
14756 }
14758 }
14760 }
14762 /* Wrapper for instantiate_template_1. */
14764 tree
14766 {
14767 tree ret;
14772 }
14774 /* Instantiate the alias template TMPL with ARGS. Also push a template
14775 instantiation level, which instantiate_template doesn't do because
14776 functions and variables have sufficient context established by the
14777 callers. */
14779 static tree
14781 {
14788 {
14791 }
14793 args =
14801 /* We can't free this if a pending_template entry or last_error_tinst_level
14802 is pointing at it. */
14808 }
14810 /* PARM is a template parameter pack for FN. Returns true iff
14811 PARM is used in a deducible way in the argument list of FN. */
14813 static bool
14815 {
14818 {
14820 tree packs;
14826 {
14827 /* The template parameter pack is used in a function parameter
14828 pack. If this is the end of the parameter list, the
14829 template parameter pack is deducible. */
14832 else
14833 /* Otherwise, not. Well, it could be deduced from
14834 a non-pack parameter, but doing so would end up with
14835 a deduction mismatch, so don't bother. */
14837 }
14838 }
14839 /* The template parameter pack isn't used in any function parameter
14840 packs, but it might be used deeper, e.g. tuple<Args...>. */
14842 }
14844 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
14845 NARGS elements of the arguments that are being used when calling
14846 it. TARGS is a vector into which the deduced template arguments
14847 are placed.
14849 Return zero for success, 2 for an incomplete match that doesn't resolve
14850 all the types, and 1 for complete failure. An error message will be
14851 printed only for an incomplete match.
14853 If FN is a conversion operator, or we are trying to produce a specific
14854 specialization, RETURN_TYPE is the return type desired.
14856 The EXPLICIT_TARGS are explicit template arguments provided via a
14857 template-id.
14859 The parameter STRICT is one of:
14861 DEDUCE_CALL:
14862 We are deducing arguments for a function call, as in
14863 [temp.deduct.call].
14865 DEDUCE_CONV:
14866 We are deducing arguments for a conversion function, as in
14867 [temp.deduct.conv].
14869 DEDUCE_EXACT:
14870 We are deducing arguments when doing an explicit instantiation
14871 as in [temp.explicit], when determining an explicit specialization
14872 as in [temp.expl.spec], or when taking the address of a function
14873 template, as in [temp.deduct.funcaddr]. */
14875 tree
14877 tree explicit_targs,
14878 tree targs,
14881 tree return_type,
14882 unification_kind_t strict,
14885 {
14886 tree parms;
14887 tree fntype;
14895 tree tinst;
14898 /* In C++0x, it's possible to have a function template whose type depends
14899 on itself recursively. This is most obvious with decltype, but can also
14900 occur with enumeration scope (c++/48969). So we need to catch infinite
14901 recursion and reject the substitution at deduction time; this function
14902 will return error_mark_node for any repeated substitution.
14904 This also catches excessive recursion such as when f<N> depends on
14905 f<N-1> across all integers, and returns error_mark_node for all the
14906 substitutions back up to the initial one.
14908 This is, of course, not reentrant. */
14919 {
14920 /* [temp.deduct]
14922 The specified template arguments must match the template
14923 parameters in kind (i.e., type, nontype, template), and there
14924 must not be more arguments than there are parameters;
14925 otherwise type deduction fails.
14927 Nontype arguments must match the types of the corresponding
14928 nontype template parameters, or must be convertible to the
14929 types of the corresponding nontype parameters as specified in
14930 _temp.arg.nontype_, otherwise type deduction fails.
14932 All references in the function type of the function template
14933 to the corresponding template parameters are replaced by the
14934 specified template argument values. If a substitution in a
14935 template parameter or in the function type of the function
14936 template results in an invalid type, type deduction fails. */
14941 /* Adjust any explicit template arguments before entering the
14942 substitution context. */
14943 explicit_targs
14945 complain,
14951 /* Substitute the explicit args into the function type. This is
14952 necessary so that, for instance, explicitly declared function
14953 arguments can match null pointed constants. If we were given
14954 an incomplete set of explicit args, we must not do semantic
14955 processing during substitution as we could create partial
14956 instantiations. */
14958 {
14963 /* Dig out the actual parm. */
14966 {
14969 }
14971 {
14974 }
14977 /* No explicit argument for this template parameter. */
14981 {
14982 /* Mark the argument pack as "incomplete". We could
14983 still deduce more arguments during unification.
14984 We remove this mark in type_unification_real. */
14986 {
14990 }
14992 /* We have some incomplete argument packs. */
14994 }
14995 }
14999 {
15002 }
15014 /* Throw away these access checks; we'll see them again in
15015 instantiate_template and they might have the wrong
15016 access path at this point. */
15020 /* Place the explicitly specified arguments in TARGS. */
15023 }
15025 /* Never do unification on the 'this' parameter. */
15029 {
15038 }
15040 /* We allow incomplete unification without an error message here
15041 because the standard doesn't seem to explicitly prohibit it. Our
15042 callers must be ready to deal with unification failures in any
15043 event. */
15051 /* Now that we have bindings for all of the template arguments,
15052 ensure that the arguments deduced for the template template
15053 parameters have compatible template parameter lists. We cannot
15054 check this property before we have deduced all template
15055 arguments, because the template parameter types of a template
15056 template parameter might depend on prior template parameters
15057 deduced after the template template parameter. The following
15058 ill-formed example illustrates this issue:
15060 template<typename T, template<T> class C> void f(C<5>, T);
15062 template<int N> struct X {};
15064 void g() {
15065 f(X<5>(), 5l); // error: template argument deduction fails
15066 }
15068 The template parameter list of 'C' depends on the template type
15069 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
15070 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
15071 time that we deduce 'C'. */
15074 {
15077 }
15079 /* All is well so far. Now, check:
15081 [temp.deduct]
15083 When all template arguments have been deduced, all uses of
15084 template parameters in nondeduced contexts are replaced with
15085 the corresponding deduced argument values. If the
15086 substitution results in an invalid type, as described above,
15087 type deduction fails. */
15090 {
15093 }
15100 /* Now perform any access checks encountered during deduction, such as
15101 for default template arguments. */
15108 /* If we're looking for an exact match, check that what we got
15109 is indeed an exact match. It might not be if some template
15110 parameters are used in non-deduced contexts. */
15112 {
15116 tree sarg
15122 {
15126 }
15127 }
15131 fail:
15135 {
15137 /* Reset once we're all the way out. */
15139 }
15141 /* We can't free this if a pending_template entry or last_error_tinst_level
15142 is pointing at it. */
15148 }
15150 /* Adjust types before performing type deduction, as described in
15151 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
15152 sections are symmetric. PARM is the type of a function parameter
15153 or the return type of the conversion function. ARG is the type of
15154 the argument passed to the call, or the type of the value
15155 initialized with the result of the conversion function.
15156 ARG_EXPR is the original argument expression, which may be null. */
15158 static int
15162 tree arg_expr)
15163 {
15167 {
15172 {
15173 /* Swap PARM and ARG throughout the remainder of this
15174 function; the handling is precisely symmetric since PARM
15175 will initialize ARG rather than vice versa. */
15180 }
15183 /* Core issue #873: Do the DR606 thing (see below) for these cases,
15184 too, but here handle it by stripping the reference from PARM
15185 rather than by adding it to ARG. */
15193 /* Nothing else to do in this case. */
15198 }
15201 {
15202 /* [temp.deduct.call]
15204 If P is not a reference type:
15206 --If A is an array type, the pointer type produced by the
15207 array-to-pointer standard conversion (_conv.array_) is
15208 used in place of A for type deduction; otherwise,
15210 --If A is a function type, the pointer type produced by
15211 the function-to-pointer standard conversion
15212 (_conv.func_) is used in place of A for type deduction;
15213 otherwise,
15215 --If A is a cv-qualified type, the top level
15216 cv-qualifiers of A's type are ignored for type
15217 deduction. */
15222 else
15224 }
15226 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
15227 of the form T&&, where T is a template parameter, and the argument
15228 is an lvalue, T is deduced as A& */
15234 /* try_one_overload doesn't provide an arg_expr, but
15235 functions are always lvalues. */
15239 /* [temp.deduct.call]
15241 If P is a cv-qualified type, the top level cv-qualifiers
15242 of P's type are ignored for type deduction. If P is a
15243 reference type, the type referred to by P is used for
15244 type deduction. */
15247 {
15250 }
15252 /* DR 322. For conversion deduction, remove a reference type on parm
15253 too (which has been swapped into ARG). */
15258 }
15260 /* Subroutine of unify_one_argument. PARM is a function parameter of a
15261 template which does contain any deducible template parameters; check if
15262 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
15263 unify_one_argument. */
15265 static int
15268 {
15269 tree type;
15273 else
15280 {
15284 }
15286 {
15291 }
15295 else
15297 }
15299 /* Subroutine of type_unification_real and unify_pack_expansion to
15300 handle unification of a single P/A pair. Parameters are as
15301 for those functions. */
15303 static int
15307 {
15314 /* We can't deduce anything from this, but we might get all the
15315 template args from other function args. */
15318 /* FIXME uses_deducible_template_parms */
15321 explain_p);
15324 {
15326 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
15327 | UNIFY_ALLOW_MORE_CV_QUAL
15341 }
15343 /* We only do these transformations if this is the top-level
15344 parameter_type_list in a call or declaration matching; in other
15345 situations (nested function declarators, template argument lists) we
15346 won't be comparing a type to an expression, and we don't do any type
15347 adjustments. */
15349 {
15351 {
15354 {
15355 /* [temp.deduct.type] A template-argument can be
15356 deduced from a pointer to function or pointer
15357 to member function argument if the set of
15358 overloaded functions does not contain function
15359 templates and at most one of a set of
15360 overloaded functions provides a unique
15361 match. */
15368 }
15374 }
15376 arg_strict |=
15378 }
15379 else
15383 /* For deduction from an init-list we need the actual list. */
15387 }
15389 /* Most parms like fn_type_unification.
15391 If SUBR is 1, we're being called recursively (to unify the
15392 arguments of a function or method parameter of a function
15393 template). */
15395 static int
15397 tree targs,
15398 tree xparms,
15402 unification_kind_t strict,
15405 {
15410 tree parms;
15419 /* Reset the number of non-defaulted template arguments contained
15420 in TARGS. */
15423 again:
15431 {
15436 /* For a function parameter pack that occurs at the end of the
15437 parameter-declaration-list, the type A of each remaining
15438 argument of the call is compared with the type P of the
15439 declarator-id of the function parameter pack. */
15445 /* For a function parameter pack that does not occur at the
15446 end of the parameter-declaration-list, the type of the
15447 parameter pack is a non-deduced context. */
15456 }
15461 {
15462 /* Unify the remaining arguments with the pack expansion type. */
15463 tree argvec;
15466 /* Allocate a TREE_VEC and copy in all of the arguments */
15471 /* Copy the parameter into parmvec. */
15477 /* Advance to the end of the list of parameters. */
15479 }
15481 /* Fail if we've reached the end of the parm list, and more args
15482 are present, and the parm list isn't variadic. */
15485 /* Fail if parms are left and they don't have default values. */
15488 {
15492 {
15493 count++;
15495 }
15497 }
15500 {
15501 tsubst_flags_t complain = (explain_p
15502 ? tf_warning_or_error
15506 {
15510 /* Clear the "incomplete" flags on all argument packs now so that
15511 substituting them into later default arguments works. */
15513 {
15516 }
15522 /* If this is an undeduced nontype parameter that depends on
15523 a type parameter, try another pass; its type may have been
15524 deduced from a later argument than the one from which
15525 this parameter can be deduced. */
15531 /* Core issue #226 (C++0x) [temp.deduct]:
15533 If a template argument has not been deduced, its
15534 default template argument, if any, is used.
15536 When we are in C++98 mode, TREE_PURPOSE will either
15537 be NULL_TREE or ERROR_MARK_NODE, so we do not need
15538 to explicitly check cxx_dialect here. */
15540 {
15552 else
15553 {
15555 /* The position of the first default template argument,
15556 is also the number of non-defaulted arguments in TARGS.
15557 Record that. */
15561 }
15562 }
15564 /* If the type parameter is a parameter pack, then it will
15565 be deduced to an empty parameter pack. */
15567 {
15568 tree arg;
15571 {
15575 }
15576 else
15583 }
15586 }
15587 }
15588 #ifdef ENABLE_CHECKING
15591 #endif
15594 }
15596 /* Subroutine of type_unification_real. Args are like the variables
15597 at the call site. ARG is an overloaded function (or template-id);
15598 we try deducing template args from each of the overloads, and if
15599 only one succeeds, we go with that. Modifies TARGS and returns
15600 true on success. */
15602 static bool
15604 tree targs,
15605 tree parm,
15606 tree arg,
15607 unification_kind_t strict,
15610 {
15617 {
15620 }
15621 else
15625 /* Handle `&x' where `x' is some static or non-static member
15626 function name. */
15632 /* Strip baselink information. */
15637 {
15638 /* If we got some explicit template args, we need to plug them into
15639 the affected templates before we try to unify, in case the
15640 explicit args will completely resolve the templates in question. */
15647 {
15660 {
15665 {
15668 }
15669 }
15672 }
15673 /* If no templates (or more than one) are fully resolved by the
15674 explicit arguments, this template-id is a non-deduced context; it
15675 could still be OK if we deduce all template arguments for the
15676 enclosing call through other arguments. */
15679 }
15682 /* If ARG is, for example, "(0, &f)" then its type will be unknown
15683 -- but the deduction does not succeed because the expression is
15684 not just the function on its own. */
15686 else
15692 {
15695 }
15697 /* [temp.deduct.type] A template-argument can be deduced from a pointer
15698 to function or pointer to member function argument if the set of
15699 overloaded functions does not contain function templates and at most
15700 one of a set of overloaded functions provides a unique match.
15702 So if we found multiple possibilities, we return success but don't
15703 deduce anything. */
15706 {
15711 }
15716 }
15718 /* Core DR 115: In contexts where deduction is done and fails, or in
15719 contexts where deduction is not done, if a template argument list is
15720 specified and it, along with any default template arguments, identifies
15721 a single function template specialization, then the template-id is an
15722 lvalue for the function template specialization. */
15724 tree
15726 {
15739 {
15742 }
15744 {
15747 }
15749 {
15752 }
15755 {
15759 /* If we got some explicit template args, we need to plug them into
15760 the affected templates before we try to unify, in case the
15761 explicit args will completely resolve the templates in question. */
15769 {
15782 {
15785 {
15788 }
15790 {
15793 }
15794 }
15795 }
15797 {
15805 {
15806 tree base
15809 }
15813 }
15815 /* There were no good options and at least one bad one, so let the
15816 user know what the problem is. */
15818 }
15820 }
15822 /* Subroutine of resolve_overloaded_unification; does deduction for a single
15823 overload. Fills TARGS with any deduced arguments, or error_mark_node if
15824 different overloads deduce different arguments for a given parm.
15825 ADDR_P is true if the expression for which deduction is being
15826 performed was of the form "& fn" rather than simply "fn".
15828 Returns 1 on success. */
15830 static int
15832 tree orig_targs,
15833 tree targs,
15834 tree parm,
15835 tree arg,
15836 unification_kind_t strict,
15840 {
15842 tree tempargs;
15848 /* [temp.deduct.type] A template-argument can be deduced from a pointer
15849 to function or pointer to member function argument if the set of
15850 overloaded functions does not contain function templates and at most
15851 one of a set of overloaded functions provides a unique match.
15853 So if this is a template, just return success. */
15865 /* We don't copy orig_targs for this because if we have already deduced
15866 some template args from previous args, unify would complain when we
15867 try to deduce a template parameter for the same argument, even though
15868 there isn't really a conflict. */
15875 /* First make sure we didn't deduce anything that conflicts with
15876 explicitly specified args. */
15878 {
15885 /* Since we're unifying against ourselves, we will fill in
15886 template args used in the function parm list with our own
15887 template parms. Discard them. */
15891 }
15894 {
15899 }
15902 }
15904 /* PARM is a template class (perhaps with unbound template
15905 parameters). ARG is a fully instantiated type. If ARG can be
15906 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
15907 TARGS are as for unify. */
15909 static tree
15912 {
15913 tree copy_of_targs;
15920 /* We need to make a new template argument vector for the call to
15921 unify. If we used TARGS, we'd clutter it up with the result of
15922 the attempted unification, even if this class didn't work out.
15923 We also don't want to commit ourselves to all the unifications
15924 we've already done, since unification is supposed to be done on
15925 an argument-by-argument basis. In other words, consider the
15926 following pathological case:
15928 template <int I, int J, int K>
15929 struct S {};
15931 template <int I, int J>
15932 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
15934 template <int I, int J, int K>
15935 void f(S<I, J, K>, S<I, I, I>);
15937 void g() {
15938 S<0, 0, 0> s0;
15939 S<0, 1, 2> s2;
15941 f(s0, s2);
15942 }
15944 Now, by the time we consider the unification involving `s2', we
15945 already know that we must have `f<0, 0, 0>'. But, even though
15946 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
15947 because there are two ways to unify base classes of S<0, 1, 2>
15948 with S<I, I, I>. If we kept the already deduced knowledge, we
15949 would reject the possibility I=1. */
15952 /* If unification failed, we're done. */
15958 }
15960 /* Given a template type PARM and a class type ARG, find the unique
15961 base type in ARG that is an instance of PARM. We do not examine
15962 ARG itself; only its base-classes. If there is not exactly one
15963 appropriate base class, return NULL_TREE. PARM may be the type of
15964 a partial specialization, as well as a plain template type. Used
15965 by unify. */
15967 static enum template_base_result
15970 {
15972 tree binfo;
15978 {
15979 /* The type could not be completed. */
15982 }
15984 /* Walk in inheritance graph order. The search order is not
15985 important, and this avoids multiple walks of virtual bases. */
15987 {
15992 {
15993 /* If there is more than one satisfactory baseclass, then:
15995 [temp.deduct.call]
15997 If they yield more than one possible deduced A, the type
15998 deduction fails.
16000 applies. */
16002 {
16005 }
16008 }
16009 }
16013 }
16015 /* Returns the level of DECL, which declares a template parameter. */
16017 static int
16019 {
16021 {
16031 }
16033 }
16035 /* Decide whether ARG can be unified with PARM, considering only the
16036 cv-qualifiers of each type, given STRICT as documented for unify.
16037 Returns nonzero iff the unification is OK on that basis. */
16039 static int
16041 {
16047 {
16048 /* Although a CVR qualifier is ignored when being applied to a
16049 substituted template parameter ([8.3.2]/1 for example), that
16050 does not allow us to unify "const T" with "int&" because both
16051 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
16052 It is ok when we're allowing additional CV qualifiers
16053 at the outer level [14.8.2.1]/3,1st bullet. */
16063 }
16074 }
16076 /* Determines the LEVEL and INDEX for the template parameter PARM. */
16077 void
16079 {
16083 {
16086 }
16087 else
16088 {
16091 }
16092 }
16094 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
16095 do { \
16096 if (unify (TP, TA, P, A, S, EP)) \
16097 return 1; \
16098 } while (0);
16100 /* Unifies the remaining arguments in PACKED_ARGS with the pack
16101 expansion at the end of PACKED_PARMS. Returns 0 if the type
16102 deduction succeeds, 1 otherwise. STRICT is the same as in
16103 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
16104 call argument list. We'll need to adjust the arguments to make them
16105 types. SUBR tells us if this is from a recursive call to
16106 type_unification_real, or for comparing two template argument
16107 lists. */
16109 static int
16113 {
16114 tree parm
16121 /* Determine the parameter packs we will be deducing from the
16122 pattern, and record their current deductions. */
16125 {
16129 /* Determine the index and level of this parameter pack. */
16132 /* Keep track of the parameter packs and their corresponding
16133 argument packs. */
16136 }
16138 /* Loop through all of the arguments that have not yet been
16139 unified and unify each with the pattern. */
16141 {
16142 tree parm;
16146 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
16147 or the element of its argument pack at the current index if
16148 this argument was explicitly specified. */
16150 {
16159 {
16162 }
16164 }
16166 /* If we had explicit template arguments, substitute them into the
16167 pattern before deduction. */
16169 {
16170 /* Some arguments might still be unspecified or dependent. */
16178 NULL_TREE);
16183 }
16184 else
16187 /* Unify the pattern with the current argument. */
16192 /* For each parameter pack, collect the deduced value. */
16194 {
16200 }
16201 }
16203 /* Verify that the results of unification with the parameter packs
16204 produce results consistent with what we've seen before, and make
16205 the deduced argument packs available. */
16207 {
16214 /* By default keep the original deduced argument pack.
16215 If necessary, more specific code is going to update the
16216 resulting deduced argument later down in this function. */
16220 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
16221 actually deduce anything. */
16229 {
16230 /* If we had fewer function args than explicit template args,
16231 just use the explicits. */
16236 }
16239 {
16240 tree result;
16241 /* Build the deduced *_ARGUMENT_PACK. */
16243 {
16248 }
16249 else
16254 /* Note the deduced argument packs for this parameter
16255 pack. */
16257 }
16261 {
16262 /* We only had the explicitly-provided arguments before, but
16263 now we have a complete set of arguments. */
16269 }
16270 else
16271 {
16277 /* Inconsistent unification of this parameter pack. */
16279 bad_old_arg,
16280 bad_new_arg);
16281 }
16282 }
16285 }
16287 /* Deduce the value of template parameters. TPARMS is the (innermost)
16288 set of template parameters to a template. TARGS is the bindings
16289 for those template parameters, as determined thus far; TARGS may
16290 include template arguments for outer levels of template parameters
16291 as well. PARM is a parameter to a template function, or a
16292 subcomponent of that parameter; ARG is the corresponding argument.
16293 This function attempts to match PARM with ARG in a manner
16294 consistent with the existing assignments in TARGS. If more values
16295 are deduced, then TARGS is updated.
16297 Returns 0 if the type deduction succeeds, 1 otherwise. The
16298 parameter STRICT is a bitwise or of the following flags:
16300 UNIFY_ALLOW_NONE:
16301 Require an exact match between PARM and ARG.
16302 UNIFY_ALLOW_MORE_CV_QUAL:
16303 Allow the deduced ARG to be more cv-qualified (by qualification
16304 conversion) than ARG.
16305 UNIFY_ALLOW_LESS_CV_QUAL:
16306 Allow the deduced ARG to be less cv-qualified than ARG.
16307 UNIFY_ALLOW_DERIVED:
16308 Allow the deduced ARG to be a template base class of ARG,
16309 or a pointer to a template base class of the type pointed to by
16310 ARG.
16311 UNIFY_ALLOW_INTEGER:
16312 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
16313 case for more information.
16314 UNIFY_ALLOW_OUTER_LEVEL:
16315 This is the outermost level of a deduction. Used to determine validity
16316 of qualification conversions. A valid qualification conversion must
16317 have const qualified pointers leading up to the inner type which
16318 requires additional CV quals, except at the outer level, where const
16319 is not required [conv.qual]. It would be normal to set this flag in
16320 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
16321 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
16322 This is the outermost level of a deduction, and PARM can be more CV
16323 qualified at this point.
16324 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
16325 This is the outermost level of a deduction, and PARM can be less CV
16326 qualified at this point. */
16328 static int
16331 {
16333 tree targ;
16334 tree tparm;
16337 /* I don't think this will do the right thing with respect to types.
16338 But the only case I've seen it in so far has been array bounds, where
16339 signedness is the only information lost, and I think that will be
16340 okay. */
16348 /* We can't deduce anything from this, but we might get all the
16349 template args from other function args. */
16352 /* If PARM uses template parameters, then we can't bail out here,
16353 even if ARG == PARM, since we won't record unifications for the
16354 template parameters. We might need them if we're trying to
16355 figure out which of two things is more specialized. */
16359 /* Handle init lists early, so the rest of the function can assume
16360 we're dealing with a type. */
16362 {
16367 /* Replace T with std::initializer_list<T> for deduction. */
16373 /* We can only deduce from an initializer list argument if the
16374 parameter is std::initializer_list; otherwise this is a
16375 non-deduced context. */
16381 {
16388 {
16390 /* It should only be possible to get here for a call. */
16392 elt_strict |= maybe_adjust_types_for_deduction
16395 }
16398 explain_p);
16399 }
16401 /* If the std::initializer_list<T> deduction worked, replace the
16402 deduced A with std::initializer_list<A>. */
16404 {
16409 }
16411 }
16413 /* Immediately reject some pairs that won't unify because of
16414 cv-qualification mismatches. */
16417 /* It is the elements of the array which hold the cv quals of an array
16418 type, and the elements might be template type parms. We'll check
16419 when we recurse. */
16421 /* We check the cv-qualifiers when unifying with template type
16422 parameters below. We want to allow ARG `const T' to unify with
16423 PARM `T' for example, when computing which of two templates
16424 is more specialized, for example. */
16438 {
16442 /* In a type which contains a nested-name-specifier, template
16443 argument values cannot be deduced for template parameters used
16444 within the nested-name-specifier. */
16456 /* The PARM is not one we're trying to unify. Just check
16457 to see if it matches ARG. */
16458 {
16463 else
16465 }
16472 /* Check for mixed types and values. */
16480 {
16481 /* ARG must be constructed from a template class or a template
16482 template parameter. */
16487 {
16491 tree parm_parms
16492 = DECL_INNERMOST_TEMPLATE_PARMS
16497 /* The resolution to DR150 makes clear that default
16498 arguments for an N-argument may not be used to bind T
16499 to a template template parameter with fewer than N
16500 parameters. It is not safe to permit the binding of
16501 default arguments as an extension, as that may change
16502 the meaning of a conforming program. Consider:
16504 struct Dense { static const unsigned int dim = 1; };
16506 template <template <typename> class View,
16507 typename Block>
16508 void operator+(float, View<Block> const&);
16510 template <typename Block,
16511 unsigned int Dim = Block::dim>
16512 struct Lvalue_proxy { operator float() const; };
16514 void
16515 test_1d (void) {
16516 Lvalue_proxy<Dense> p;
16517 float b;
16518 b + p;
16519 }
16521 Here, if Lvalue_proxy is permitted to bind to View, then
16522 the global operator+ will be used; if they are not, the
16523 Lvalue_proxy will be converted to float. */
16525 full_argvec,
16527 (explain_p
16528 ? tf_warning_or_error
16535 /* Deduce arguments T, i from TT<T> or TT<i>.
16536 We check each element of PARMVEC and ARGVEC individually
16537 rather than the whole TREE_VEC since they can have
16538 different number of elements. */
16545 /* Check if the parameters end in a pack, making them
16546 variadic. */
16552 /* If the template argument list of P contains a pack
16553 expansion that is not the last template argument, the
16554 entire template argument list is a non-deduced
16555 context. */
16564 {
16569 }
16574 DEDUCE_EXACT,
16577 }
16580 /* Fall through to deduce template name. */
16581 }
16585 {
16586 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
16588 /* Simple cases: Value already set, does match or doesn't. */
16593 }
16594 else
16595 {
16596 /* If PARM is `const T' and ARG is only `int', we don't have
16597 a match unless we are allowing additional qualification.
16598 If ARG is `const int' and PARM is just `T' that's OK;
16599 that binds `const int' to `T'. */
16604 /* Consider the case where ARG is `const volatile int' and
16605 PARM is `const T'. Then, T should be `volatile int'. */
16606 arg = cp_build_qualified_type_real
16611 /* Simple cases: Value already set, does match or doesn't. */
16617 /* Make sure that ARG is not a variable-sized array. (Note
16618 that were talking about variable-sized arrays (like
16619 `int[n]'), rather than arrays of unknown size (like
16620 `int[]').) We'll get very confused by such a type since
16621 the bound of the array is not constant, and therefore
16622 not mangleable. Besides, such types are not allowed in
16623 ISO C++, so we can do as we please here. We do allow
16624 them for 'auto' deduction, since that isn't ABI-exposed. */
16628 /* Strip typedefs as in convert_template_argument. */
16630 }
16632 /* If ARG is a parameter pack or an expansion, we cannot unify
16633 against it unless PARM is also a parameter pack. */
16638 /* If the argument deduction results is a METHOD_TYPE,
16639 then there is a problem.
16640 METHOD_TYPE doesn't map to any real C++ type the result of
16641 the deduction can not be of that type. */
16655 {
16656 /* The PARM is not one we're trying to unify. Just check
16657 to see if it matches ARG. */
16663 }
16669 {
16674 }
16676 /* [temp.deduct.type] If, in the declaration of a function template
16677 with a non-type template-parameter, the non-type
16678 template-parameter is used in an expression in the function
16679 parameter-list and, if the corresponding template-argument is
16680 deduced, the template-argument type shall match the type of the
16681 template-parameter exactly, except that a template-argument
16682 deduced from an array bound may be of any integral type.
16683 The non-type parameter might use already deduced type parameters. */
16686 /* Template-parameter dependent expression. Just accept it for now.
16687 It will later be processed in convert_template_argument. */
16688 ;
16694 /* Convert the ARG to the type of PARM; the deduced non-type
16695 template argument must exactly match the types of the
16696 corresponding parameter. */
16699 /* We haven't deduced the type of this parameter yet. Try again
16700 later. */
16702 else
16705 /* If ARG is a parameter pack or an expansion, we cannot unify
16706 against it unless PARM is also a parameter pack. */
16716 {
16717 /* A pointer-to-member constant can be unified only with
16718 another constant. */
16722 /* Just unify the class member. It would be useless (and possibly
16723 wrong, depending on the strict flags) to unify also
16724 PTRMEM_CST_CLASS, because we want to be sure that both parm and
16725 arg refer to the same variable, even if through different
16726 classes. For instance:
16728 struct A { int x; };
16729 struct B : A { };
16731 Unification of &A::x and &B::x must succeed. */
16734 }
16737 {
16741 /* [temp.deduct.call]
16743 A can be another pointer or pointer to member type that can
16744 be converted to the deduced A via a qualification
16745 conversion (_conv.qual_).
16747 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
16748 This will allow for additional cv-qualification of the
16749 pointed-to types if appropriate. */
16752 /* The derived-to-base conversion only persists through one
16753 level of pointers. */
16758 }
16775 {
16776 tree parm_max;
16777 tree arg_max;
16781 /* Our representation of array types uses "N - 1" as the
16782 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
16783 not an integer constant. We cannot unify arbitrarily
16784 complex expressions, so we eliminate the MINUS_EXPRs
16785 here. */
16789 {
16792 }
16796 {
16797 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
16798 trying to unify the type of a variable with the type
16799 of a template parameter. For example:
16801 template <unsigned int N>
16802 void f (char (&) [N]);
16803 int g();
16804 void h(int i) {
16805 char a[g(i)];
16806 f(a);
16807 }
16809 Here, the type of the ARG will be "int [g(i)]", and
16810 may be a SAVE_EXPR, etc. */
16814 }
16816 /* If only one of the bounds used a MINUS_EXPR, compensate
16817 by adding one to the other bound. */
16820 integer_type_node,
16821 parm_max,
16822 integer_one_node);
16825 integer_type_node,
16826 arg_max,
16827 integer_one_node);
16831 }
16845 /* We have already checked cv-qualification at the top of the
16846 function. */
16850 /* As far as unification is concerned, this wins. Later checks
16851 will invalidate it if necessary. */
16854 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
16855 /* Type INTEGER_CST can come from ordinary constant template args. */
16867 {
16877 /* Check for pack expansions in the parameters. */
16879 {
16881 {
16883 /* We can unify against something with a trailing
16884 parameter pack. */
16886 else
16887 /* [temp.deduct.type]/9: If the template argument list of
16888 P contains a pack expansion that is not the last
16889 template argument, the entire template argument list
16890 is a non-deduced context. */
16892 }
16893 }
16895 /* If we don't have enough arguments to satisfy the parameters
16896 (not counting the pack expression at the end), or we have
16897 too many arguments for a parameter list that doesn't end in
16898 a pack expression, we can't unify. */
16904 /* Unify all of the parameters that precede the (optional)
16905 pack expression. */
16907 {
16912 }
16915 DEDUCE_EXACT,
16918 }
16926 {
16934 }
16937 {
16941 {
16942 /* First, we try to unify the PARM and ARG directly. */
16947 {
16948 /* Fallback to the special case allowed in
16949 [temp.deduct.call]:
16951 If P is a class, and P has the form
16952 template-id, then A can be a derived class of
16953 the deduced A. Likewise, if P is a pointer to
16954 a class of the form template-id, A can be a
16955 pointer to a derived class pointed to by the
16956 deduced A. */
16963 }
16964 }
16968 /* Perhaps PARM is something like S<U> and ARG is S<int>.
16969 Then, we should unify `int' and `U'. */
16971 else
16972 /* There's no chance of unification succeeding. */
16977 }
16984 {
16987 tree a;
16993 /* CV qualifications for methods can never be deduced, they must
16994 match exactly. We need to check them explicitly here,
16995 because type_unification_real treats them as any other
16996 cv-qualified parameter. */
16998 && (!check_cv_quals_for_unify
17018 }
17021 /* Unify a pointer to member with a pointer to member function, which
17022 deduces the type of the member as a function type. */
17024 {
17025 tree method_type;
17026 tree fntype;
17028 /* Check top-level cv qualifiers */
17036 /* Determine the type of the function we are unifying against. */
17038 fntype =
17042 /* Extract the cv-qualifiers of the member function from the
17043 implicit object parameter and place them on the function
17044 type to be restored later. */
17047 }
17066 /* Matched cases are handled by the ARG == PARM test above. */
17070 /* A non-type template parameter that is a variable should be a
17071 an integral constant, in which case, it whould have been
17072 folded into its (constant) value. So we should not be getting
17073 a variable here. */
17084 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
17085 or UNDERLYING_TYPE nodes. */
17089 /* Unification fails if we hit an error node. */
17093 /* An unresolved overload is a nondeduced context. */
17098 /* We must be looking at an expression. This can happen with
17099 something like:
17101 template <int I>
17102 void foo(S<I>, S<I + 2>);
17104 This is a "nondeduced context":
17106 [deduct.type]
17108 The nondeduced contexts are:
17110 --A type that is a template-id in which one or more of
17111 the template-arguments is an expression that references
17112 a template-parameter.
17114 In these cases, we assume deduction succeeded, but don't
17115 actually infer any unifications. */
17120 else
17122 }
17123 }
17124 #undef RECUR_AND_CHECK_FAILURE
17125 \f
17126 /* Note that DECL can be defined in this translation unit, if
17127 required. */
17129 static void
17131 {
17132 tree clone;
17136 }
17138 /* Called if RESULT is explicitly instantiated, or is a member of an
17139 explicitly instantiated class. */
17141 void
17143 {
17146 /* If this entity has already been written out, it's too late to
17147 make any modifications. */
17152 /* The TREE_PUBLIC flag for function declarations will have been
17153 set correctly by tsubst. */
17156 /* This might have been set by an earlier implicit instantiation. */
17161 else
17162 {
17164 /* Always make artificials weak. */
17167 /* For WIN32 we also want to put explicit instantiations in
17168 linkonce sections. */
17171 }
17173 /* If EXTERN_P, then this function will not be emitted -- unless
17174 followed by an explicit instantiation, at which point its linkage
17175 will be adjusted. If !EXTERN_P, then this function will be
17176 emitted here. In neither circumstance do we want
17177 import_export_decl to adjust the linkage. */
17179 }
17181 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
17182 important template arguments. If any are missing, we check whether
17183 they're important by using error_mark_node for substituting into any
17184 args that were used for partial ordering (the ones between ARGS and END)
17185 and seeing if it bubbles up. */
17187 static bool
17189 {
17194 {
17197 }
17199 {
17203 }
17205 }
17207 /* Given two function templates PAT1 and PAT2, return:
17209 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
17210 -1 if PAT2 is more specialized than PAT1.
17211 0 if neither is more specialized.
17213 LEN indicates the number of parameters we should consider
17214 (defaulted parameters should not be considered).
17216 The 1998 std underspecified function template partial ordering, and
17217 DR214 addresses the issue. We take pairs of arguments, one from
17218 each of the templates, and deduce them against each other. One of
17219 the templates will be more specialized if all the *other*
17220 template's arguments deduce against its arguments and at least one
17221 of its arguments *does* *not* deduce against the other template's
17222 corresponding argument. Deduction is done as for class templates.
17223 The arguments used in deduction have reference and top level cv
17224 qualifiers removed. Iff both arguments were originally reference
17225 types *and* deduction succeeds in both directions, the template
17226 with the more cv-qualified argument wins for that pairing (if
17227 neither is more cv-qualified, they both are equal). Unlike regular
17228 deduction, after all the arguments have been deduced in this way,
17229 we do *not* verify the deduced template argument values can be
17230 substituted into non-deduced contexts.
17232 The logic can be a bit confusing here, because we look at deduce1 and
17233 targs1 to see if pat2 is at least as specialized, and vice versa; if we
17234 can find template arguments for pat1 to make arg1 look like arg2, that
17235 means that arg2 is at least as specialized as arg1. */
17237 int
17239 {
17252 /* Remove the this parameter from non-static member functions. If
17253 one is a non-static member function and the other is not a static
17254 member function, remove the first parameter from that function
17255 also. This situation occurs for operator functions where we
17256 locate both a member function (with this pointer) and non-member
17257 operator (with explicit first operand). */
17259 {
17264 }
17266 {
17269 {
17270 len--;
17272 }
17273 }
17275 /* If only one is a conversion operator, they are unordered. */
17279 /* Consider the return type for a conversion function */
17281 {
17284 len++;
17285 }
17287 processing_template_decl++;
17293 /* Stop when an ellipsis is seen. */
17295 {
17304 {
17305 /* When both arguments are pack expansions, we need only
17306 unify the patterns themselves. */
17310 /* This is the last comparison we need to do. */
17312 }
17315 {
17318 }
17321 {
17324 }
17330 {
17336 /* Setup the parameter vector, which contains only ARG1. */
17339 /* Setup the argument vector, which contains the remaining
17340 arguments. */
17349 /* We cannot deduce in the other direction, because ARG1 is
17350 a pack expansion but ARG2 is not. */
17352 }
17354 {
17360 /* Setup the parameter vector, which contains only ARG1. */
17363 /* Setup the argument vector, which contains the remaining
17364 arguments. */
17373 /* We cannot deduce in the other direction, because ARG2 is
17374 a pack expansion but ARG1 is not.*/
17376 }
17378 else
17379 {
17380 /* The normal case, where neither argument is a pack
17381 expansion. */
17388 }
17390 /* If we couldn't deduce arguments for tparms1 to make arg1 match
17391 arg2, then arg2 is not as specialized as arg1. */
17397 /* "If, for a given type, deduction succeeds in both directions
17398 (i.e., the types are identical after the transformations above)
17399 and if the type from the argument template is more cv-qualified
17400 than the type from the parameter template (as described above)
17401 that type is considered to be more specialized than the other. If
17402 neither type is more cv-qualified than the other then neither type
17403 is more specialized than the other." */
17407 {
17412 }
17415 /* We've failed to deduce something in either direction.
17416 These must be unordered. */
17421 /* We have already processed all of the arguments in our
17422 handing of the pack expansion type. */
17427 }
17429 /* "In most cases, all template parameters must have values in order for
17430 deduction to succeed, but for partial ordering purposes a template
17431 parameter may remain without a value provided it is not used in the
17432 types being used for partial ordering."
17434 Thus, if we are missing any of the targs1 we need to substitute into
17435 origs1, then pat2 is not as specialized as pat1. This can happen when
17436 there is a nondeduced context. */
17442 processing_template_decl--;
17444 /* All things being equal, if the next argument is a pack expansion
17445 for one function but not for the other, prefer the
17446 non-variadic function. FIXME this is bogus; see c++/41958. */
17450 {
17453 }
17459 else
17461 }
17463 /* Determine which of two partial specializations of MAIN_TMPL is more
17464 specialized.
17466 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
17467 to the first partial specialization. The TREE_VALUE is the
17468 innermost set of template parameters for the partial
17469 specialization. PAT2 is similar, but for the second template.
17471 Return 1 if the first partial specialization is more specialized;
17472 -1 if the second is more specialized; 0 if neither is more
17473 specialized.
17475 See [temp.class.order] for information about determining which of
17476 two templates is more specialized. */
17478 static int
17480 {
17481 tree targs;
17489 /* Just like what happens for functions, if we are ordering between
17490 different class template specializations, we may encounter dependent
17491 types in the arguments, and we need our dependency check functions
17492 to behave correctly. */
17498 {
17501 }
17507 {
17510 }
17513 /* In the case of a tie where at least one of the class templates
17514 has a parameter pack at the end, the template with the most
17515 non-packed parameters wins. */
17517 && any_deductions
17520 {
17526 /* We don't count the pack expansion at the end. */
17536 }
17539 }
17541 /* Return the template arguments that will produce the function signature
17542 DECL from the function template FN, with the explicit template
17543 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
17544 also match. Return NULL_TREE if no satisfactory arguments could be
17545 found. */
17547 static tree
17549 {
17553 tree decl_arg_types;
17556 tree arg;
17560 /* Never do unification on the 'this' parameter. */
17580 }
17582 /* Return the innermost template arguments that, when applied to a partial
17583 specialization of MAIN_TMPL whose innermost template parameters are
17584 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
17585 ARGS.
17587 For example, suppose we have:
17589 template <class T, class U> struct S {};
17590 template <class T> struct S<T*, int> {};
17592 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
17593 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
17594 int}. The resulting vector will be {double}, indicating that `T'
17595 is bound to `double'. */
17597 static tree
17599 {
17601 tree deduced_args;
17602 tree innermost_deduced_args;
17606 {
17610 innermost_deduced_args);
17611 }
17612 else
17625 /* Verify that nondeduced template arguments agree with the type
17626 obtained from argument deduction.
17628 For example:
17630 struct A { typedef int X; };
17631 template <class T, class U> struct C {};
17632 template <class T> struct C<T, typename T::X> {};
17634 Then with the instantiation `C<A, int>', we can deduce that
17635 `T' is `A' but unify () does not check whether `typename T::X'
17636 is `int'. */
17642 /* We only need to check the innermost arguments; the other
17643 arguments will always agree. */
17648 /* Now that we have bindings for all of the template arguments,
17649 ensure that the arguments deduced for the template template
17650 parameters have compatible template parameter lists. See the use
17651 of template_template_parm_bindings_ok_p in fn_type_unification
17652 for more information. */
17657 }
17659 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
17660 Return the TREE_LIST node with the most specialized template, if
17661 any. If there is no most specialized template, the error_mark_node
17662 is returned.
17664 Note that this function does not look at, or modify, the
17665 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
17666 returned is one of the elements of INSTANTIATIONS, callers may
17667 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
17668 and retrieve it from the value returned. */
17670 tree
17672 {
17679 {
17685 fate--;
17690 fate++;
17695 {
17696 /* Equally specialized, move to next function. If there
17697 is no next function, nothing's most specialized. */
17702 }
17703 }
17706 /* Now verify that champ is better than everything earlier in the
17707 instantiation list. */
17715 {
17718 }
17720 processing_template_decl--;
17726 }
17728 /* If DECL is a specialization of some template, return the most
17729 general such template. Otherwise, returns NULL_TREE.
17731 For example, given:
17733 template <class T> struct S { template <class U> void f(U); };
17735 if TMPL is `template <class U> void S<int>::f(U)' this will return
17736 the full template. This function will not trace past partial
17737 specializations, however. For example, given in addition:
17739 template <class T> struct S<T*> { template <class U> void f(U); };
17741 if TMPL is `template <class U> void S<int*>::f(U)' this will return
17742 `template <class T> template <class U> S<T*>::f(U)'. */
17744 tree
17746 {
17747 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
17748 an immediate specialization. */
17750 {
17754 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
17755 template friend. */
17760 }
17762 /* Look for more and more general templates. */
17764 {
17765 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
17766 (See cp-tree.h for details.) */
17774 /* Stop if we run into an explicitly specialized class template. */
17781 }
17784 }
17786 /* Return the most specialized of the class template partial
17787 specializations of TMPL which can produce TYPE, a specialization of
17788 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
17789 a _TYPE node corresponding to the partial specialization, while the
17790 TREE_PURPOSE is the set of template arguments that must be
17791 substituted into the TREE_TYPE in order to generate TYPE.
17793 If the choice of partial specialization is ambiguous, a diagnostic
17794 is issued, and the error_mark_node is returned. If there are no
17795 partial specializations of TMPL matching TYPE, then NULL_TREE is
17796 returned. */
17798 static tree
17800 {
17802 tree t;
17803 tree champ;
17806 tree args;
17812 /* For determining which partial specialization to use, only the
17813 innermost args are interesting. */
17815 {
17818 }
17821 {
17822 tree partial_spec_args;
17823 tree spec_args;
17831 {
17834 /* Discard the outer levels of args, and then substitute in the
17835 template args from the enclosing class. */
17837 partial_spec_args = tsubst_template_args
17840 /* PARMS already refers to just the innermost parms, but the
17841 template parms in partial_spec_args had their levels lowered
17842 by tsubst, so we need to do the same for the parm list. We
17843 can't just tsubst the TREE_VEC itself, as tsubst wants to
17844 treat a TREE_VEC as an argument vector. */
17850 }
17852 partial_spec_args =
17855 partial_spec_args),
17866 partial_spec_args,
17867 args);
17869 {
17874 }
17875 }
17885 {
17888 ;
17889 else
17890 {
17892 {
17895 {
17898 }
17899 }
17901 }
17902 }
17906 {
17909 {
17912 }
17913 }
17916 {
17924 {
17927 }
17930 }
17933 }
17935 /* Explicitly instantiate DECL. */
17937 void
17939 {
17944 /* An error occurred, for which grokdeclarator has already issued
17945 an appropriate message. */
17948 {
17951 }
17953 {
17954 /* There is an asymmetry here in the way VAR_DECLs and
17955 FUNCTION_DECLs are handled by grokdeclarator. In the case of
17956 the latter, the DECL we get back will be marked as a
17957 template instantiation, and the appropriate
17958 DECL_TEMPLATE_INFO will be set up. This does not happen for
17959 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
17960 should handle VAR_DECLs as it currently handles
17961 FUNCTION_DECLs. */
17963 {
17966 }
17969 {
17972 }
17974 {
17979 }
17980 }
17982 {
17985 }
17986 else
17989 /* Check for various error cases. Note that if the explicit
17990 instantiation is valid the RESULT will currently be marked as an
17991 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
17992 until we get here. */
17995 {
17996 /* DR 259 [temp.spec].
17998 Both an explicit instantiation and a declaration of an explicit
17999 specialization shall not appear in a program unless the explicit
18000 instantiation follows a declaration of the explicit specialization.
18002 For a given set of template parameters, if an explicit
18003 instantiation of a template appears after a declaration of an
18004 explicit specialization for that template, the explicit
18005 instantiation has no effect. */
18007 }
18009 {
18010 /* [temp.spec]
18012 No program shall explicitly instantiate any template more
18013 than once.
18015 We check DECL_NOT_REALLY_EXTERN so as not to complain when
18016 the first instantiation was `extern' and the second is not,
18017 and EXTERN_P for the opposite case. */
18020 /* If an "extern" explicit instantiation follows an ordinary
18021 explicit instantiation, the template is instantiated. */
18024 }
18026 {
18029 }
18031 {
18034 }
18037 ;
18039 {
18042 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
18045 }
18046 else
18054 }
18056 static void
18058 {
18064 {
18067 }
18068 }
18070 /* Called from do_type_instantiation through binding_table_foreach to
18071 do recursive instantiation for the type bound in ENTRY. */
18072 static void
18074 {
18080 }
18082 /* Called from do_type_instantiation to instantiate a member
18083 (a member function or a static member variable) of an
18084 explicitly instantiated class template. */
18085 static void
18087 {
18092 }
18094 /* Perform an explicit instantiation of template class T. STORAGE, if
18095 non-null, is the RID for extern, inline or static. COMPLAIN is
18096 nonzero if this is called from the parser, zero if called recursively,
18097 since the standard is unclear (as detailed below). */
18099 void
18101 {
18111 {
18112 tree tmpl =
18116 else
18119 }
18124 {
18127 t);
18129 }
18132 {
18134 {
18136 {
18139 "ISO C++ 1998 forbids the use of %<extern%> on "
18141 }
18142 else
18144 "ISO C++ forbids the use of %qE"
18146 }
18154 else
18155 {
18157 storage);
18159 }
18160 }
18163 {
18164 /* DR 259 [temp.spec].
18166 Both an explicit instantiation and a declaration of an explicit
18167 specialization shall not appear in a program unless the explicit
18168 instantiation follows a declaration of the explicit specialization.
18170 For a given set of template parameters, if an explicit
18171 instantiation of a template appears after a declaration of an
18172 explicit specialization for that template, the explicit
18173 instantiation has no effect. */
18175 }
18177 {
18178 /* [temp.spec]
18180 No program shall explicitly instantiate any template more
18181 than once.
18183 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
18184 instantiation was `extern'. If EXTERN_P then the second is.
18185 These cases are OK. */
18192 /* If we've already instantiated the template, just return now. */
18195 }
18203 {
18204 tree tmp;
18206 /* In contrast to implicit instantiation, where only the
18207 declarations, and not the definitions, of members are
18208 instantiated, we have here:
18210 [temp.explicit]
18212 The explicit instantiation of a class template specialization
18213 implies the instantiation of all of its members not
18214 previously explicitly specialized in the translation unit
18215 containing the explicit instantiation.
18217 Of course, we can't instantiate member template classes, since
18218 we don't have any arguments for them. Note that the standard
18219 is unclear on whether the instantiation of the members are
18220 *explicit* instantiations or not. However, the most natural
18221 interpretation is that it should be an explicit instantiation. */
18236 }
18237 }
18239 /* Given a function DECL, which is a specialization of TMPL, modify
18240 DECL to be a re-instantiation of TMPL with the same template
18241 arguments. TMPL should be the template into which tsubst'ing
18242 should occur for DECL, not the most general template.
18244 One reason for doing this is a scenario like this:
18246 template <class T>
18247 void f(const T&, int i);
18249 void g() { f(3, 7); }
18251 template <class T>
18252 void f(const T& t, const int i) { }
18254 Note that when the template is first instantiated, with
18255 instantiate_template, the resulting DECL will have no name for the
18256 first parameter, and the wrong type for the second. So, when we go
18257 to instantiate the DECL, we regenerate it. */
18259 static void
18261 {
18262 /* The arguments used to instantiate DECL, from the most general
18263 template. */
18264 tree args;
18265 tree code_pattern;
18270 /* Make sure that we can see identifiers, and compute access
18271 correctly. */
18275 {
18276 tree decl_parm;
18277 tree pattern_parm;
18278 tree specs;
18292 specs);
18294 /* Merge parameter declarations. */
18297 pattern_parm
18301 {
18302 tree parm_type;
18303 tree attributes;
18308 NULL_TREE);
18314 {
18317 }
18320 }
18321 /* Merge any parameters that match with the function parameter
18322 pack. */
18324 {
18326 tree expanded_types;
18327 /* Expand the TYPE_PACK_EXPANSION that provides the types for
18328 the parameters in this function parameter pack. */
18333 {
18334 tree parm_type;
18335 tree attributes;
18338 /* Rename the parameter to include the index. */
18347 {
18350 }
18352 }
18353 }
18354 /* Merge additional specifiers from the CODE_PATTERN. */
18358 }
18360 {
18368 }
18369 else
18373 }
18375 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
18376 substituted to get DECL. */
18378 tree
18380 {
18383 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
18384 for the instantiation. This is not always the most general
18385 template. Consider, for example:
18387 template <class T>
18388 struct S { template <class U> void f();
18389 template <> void f<int>(); };
18391 and an instantiation of S<double>::f<int>. We want TD to be the
18392 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
18394 more general template. */
18396 /* We must also deal with friend templates. Given:
18398 template <class T> struct S {
18399 template <class U> friend void f() {};
18400 };
18402 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
18403 so far as the language is concerned, but that's still
18404 where we get the pattern for the instantiation from. On
18405 other hand, if the definition comes outside the class, say:
18407 template <class T> struct S {
18408 template <class U> friend void f();
18409 };
18410 template <class U> friend void f() {}
18412 we don't need to look any further. That's what the check for
18413 DECL_INITIAL is for. */
18417 {
18418 /* The present template, TD, should not be a definition. If it
18419 were a definition, we should be using it! Note that we
18420 cannot restructure the loop to just keep going until we find
18421 a template with a definition, since that might go too far if
18422 a specialization was declared, but not defined. */
18426 /* Fetch the more general template. */
18428 }
18431 }
18433 /* Returns true if we need to instantiate this template instance even if we
18434 know we aren't going to emit it.. */
18436 bool
18438 {
18439 /* We always instantiate inline functions so that we can inline them. An
18440 explicit instantiation declaration prohibits implicit instantiation of
18441 non-inline functions. With high levels of optimization, we would
18442 normally inline non-inline functions -- but we're not allowed to do
18443 that for "extern template" functions. Therefore, we check
18444 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
18448 /* And we need to instantiate static data members so that
18449 their initializers are available in integral constant
18450 expressions. */
18453 }
18455 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
18456 instantiate it now, modifying TREE_TYPE (fn). */
18458 void
18460 {
18474 {
18476 {
18491 }
18492 else
18494 }
18495 else
18496 {
18497 /* This is an implicitly declared function, so NOEX is a list of
18498 other functions to evaluate and merge. */
18499 tree elt;
18502 {
18504 tree subspec;
18508 }
18509 }
18514 {
18517 else
18519 }
18520 }
18522 /* Produce the definition of D, a _DECL generated from a template. If
18523 DEFER_OK is nonzero, then we don't have to actually do the
18524 instantiation now; we just have to do it sometime. Normally it is
18525 an error if this is an explicit instantiation but D is undefined.
18526 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
18527 explicitly instantiated class template. */
18529 tree
18532 {
18534 tree gen_args;
18535 tree args;
18536 tree td;
18537 tree code_pattern;
18538 tree spec;
18539 tree gen_tmpl;
18543 tree fn_context;
18546 /* This function should only be used to instantiate templates for
18547 functions and static member variables. */
18551 /* Variables are never deferred; if instantiation is required, they
18552 are instantiated right away. That allows for better code in the
18553 case that an expression refers to the value of the variable --
18554 if the variable has a constant value the referring expression can
18555 take advantage of that fact. */
18560 /* Don't instantiate cloned functions. Instead, instantiate the
18561 functions they cloned. */
18569 /* D has already been instantiated or explicitly specialized, so
18570 there's nothing for us to do here.
18572 It might seem reasonable to check whether or not D is an explicit
18573 instantiation, and, if so, stop here. But when an explicit
18574 instantiation is deferred until the end of the compilation,
18575 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
18576 the instantiation. */
18579 /* Check to see whether we know that this template will be
18580 instantiated in some other file, as with "extern template"
18581 extension. */
18584 /* In general, we do not instantiate such templates. */
18592 /* We should already have the extra args. */
18595 /* And what's in the hash table should match D. */
18599 /* This needs to happen before any tsubsting. */
18605 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
18606 for the instantiation. */
18610 /* We should never be trying to instantiate a member of a class
18611 template or partial specialization. */
18616 /* In the case of a friend template whose definition is provided
18617 outside the class, we may have too many arguments. Drop the
18618 ones we don't need. The same is true for specializations. */
18619 args = get_innermost_template_args
18621 else
18627 else
18630 /* We may be in the middle of deferred access check. Disable it now. */
18633 /* Unless an explicit instantiation directive has already determined
18634 the linkage of D, remember that a definition is available for
18635 this entity. */
18645 /* If D is a member of an explicitly instantiated class template,
18646 and no definition is available, treat it like an implicit
18647 instantiation. */
18650 {
18651 /* Leave linkage flags alone on instantiations with anonymous
18652 visibility. */
18654 {
18657 }
18659 }
18664 /* Defer all other templates, unless we have been explicitly
18665 forbidden from doing so. */
18667 template. */
18668 ! pattern_defined
18669 /* If it's OK to postpone instantiation, do so. */
18670 || defer_ok
18671 /* If this is a static data member that will be defined
18672 elsewhere, we don't want to instantiate the entire data
18673 member, but we do want to instantiate the initializer so that
18674 we can substitute that elsewhere. */
18676 {
18677 /* The definition of the static data member is now required so
18678 we must substitute the initializer. */
18682 {
18683 tree ns;
18684 tree init;
18691 args,
18694 /* Make sure the initializer is still constant, in case of
18695 circular dependency (template/instantiate6.C). */
18696 const_init
18700 LOOKUP_ONLYCONVERTING);
18703 }
18705 /* We restore the source position here because it's used by
18706 add_pending_template. */
18712 /* [temp.explicit]
18714 The definition of a non-exported function template, a
18715 non-exported member function template, or a non-exported
18716 member function or static data member of a class template
18717 shall be present in every translation unit in which it is
18718 explicitly instantiated. */
18722 /* If we're in unevaluated context, we just wanted to get the
18723 constant value; this isn't an odr use, so don't queue
18724 a full instantiation. */
18727 /* ??? Historically, we have instantiated inline functions, even
18728 when marked as "extern template". */
18732 }
18733 /* Tell the repository that D is available in this translation unit
18734 -- and see if it is supposed to be instantiated here. */
18736 {
18737 /* In a PCH file, despite the fact that the repository hasn't
18738 requested instantiation in the PCH it is still possible that
18739 an instantiation will be required in a file that includes the
18740 PCH. */
18743 /* Instantiate inline functions so that the inliner can do its
18744 job, even though we'll not be emitting a copy of this
18745 function. */
18748 }
18757 /* Mark D as instantiated so that recursive calls to
18758 instantiate_decl do not try to instantiate it again. */
18761 /* Regenerate the declaration in case the template has been modified
18762 by a subsequent redeclaration. */
18765 /* We already set the file and line above. Reset them now in case
18766 they changed as a result of calling regenerate_decl_from_template. */
18770 {
18771 tree init;
18774 /* Clear out DECL_RTL; whatever was there before may not be right
18775 since we've reset the type of the declaration. */
18779 /* The initializer is placed in DECL_INITIAL by
18780 regenerate_decl_from_template so we don't need to
18781 push/pop_access_scope again here. Pull it out so that
18782 cp_finish_decl can process it. */
18787 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
18788 initializer. That function will defer actual emission until
18789 we have a chance to determine linkage. */
18792 /* Enter the scope of D so that access-checking works correctly. */
18797 }
18801 {
18803 tree subst_decl;
18804 tree tmpl_parm;
18805 tree spec_parm;
18807 /* Save away the current list, in case we are instantiating one
18808 template from within the body of another. */
18811 /* Set up the list of local specializations. */
18814 /* Set up context. */
18817 /* Some typedefs referenced from within the template code need to be
18818 access checked at template instantiation time, i.e now. These
18819 types were added to the template at parsing time. Let's get those
18820 and perform the access checks then. */
18822 gen_args);
18824 /* Create substitution entries for the parameters. */
18829 {
18833 }
18835 {
18837 {
18840 }
18841 else
18842 {
18843 /* Register the (value) argument pack as a specialization of
18844 TMPL_PARM, then move on. */
18847 }
18848 }
18851 /* Substitute into the body of the function. */
18856 /* Set the current input_location to the end of the function
18857 so that finish_function knows where we are. */
18860 /* We don't need the local specializations any more. */
18864 /* Finish the function. */
18867 }
18869 /* We're not deferring instantiation any more. */
18877 out:
18885 }
18887 /* Run through the list of templates that we wish we could
18888 instantiate, and instantiate any we can. RETRIES is the
18889 number of times we retry pending template instantiation. */
18891 void
18893 {
18897 /* Instantiating templates may trigger vtable generation. This in turn
18898 may require further template instantiations. We place a limit here
18899 to avoid infinite loop. */
18901 {
18905 " instantiating %q+D, possibly from virtual table generation"
18909 /* Pretend that we defined it. */
18912 }
18914 do
18915 {
18920 {
18925 {
18926 tree fn;
18929 {
18933 fn;
18941 }
18944 }
18945 else
18946 {
18949 {
18950 instantiation
18956 }
18960 }
18963 /* If INSTANTIATION has been instantiated, then we don't
18964 need to consider it again in the future. */
18966 else
18967 {
18970 }
18973 }
18975 }
18979 }
18981 /* Substitute ARGVEC into T, which is a list of initializers for
18982 either base class or a non-static data member. The TREE_PURPOSEs
18983 are DECLs, and the TREE_VALUEs are the initializer values. Used by
18984 instantiate_decl. */
18986 static tree
18988 {
18992 {
18993 tree decl;
18994 tree init;
19000 {
19001 tree expr;
19002 tree arg;
19004 /* Expand the base class expansion type into separate base
19005 classes. */
19007 tf_warning_or_error,
19008 NULL_TREE);
19012 /* We'll be building separate TREE_LISTs of arguments for
19013 each base. */
19019 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
19020 expand each argument in the TREE_VALUE of t. */
19027 /* VOID_TYPE_NODE is used to indicate
19028 value-initialization. */
19029 {
19032 }
19033 else
19034 {
19035 /* Substitute parameter packs into each argument in the
19036 TREE_LIST. */
19039 {
19040 tree expanded_exprs;
19042 /* Expand the argument. */
19044 expanded_exprs
19046 tf_warning_or_error,
19047 NULL_TREE);
19051 /* Prepend each of the expanded expressions to the
19052 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
19054 {
19059 }
19060 }
19063 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
19064 since we built them backwards. */
19066 {
19069 }
19070 }
19071 }
19074 {
19076 {
19080 }
19081 else
19082 {
19083 tree tmp;
19098 /* If we had an initializer but it instantiated to nothing,
19099 value-initialize the object. This will only occur when
19100 the initializer was a pack expansion where the parameter
19101 packs used in that expansion were of length zero. */
19104 }
19107 {
19111 }
19112 }
19113 }
19115 }
19117 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
19119 static void
19121 {
19126 else
19128 }
19130 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
19131 is the instantiation (which should have been created with
19132 start_enum) and ARGS are the template arguments to use. */
19134 static void
19136 {
19137 tree e;
19143 {
19144 tree value;
19145 tree decl;
19148 /* Note that in a template enum, the TREE_VALUE is the
19149 CONST_DECL, not the corresponding INTEGER_CST. */
19154 /* Give this enumeration constant the correct access. */
19157 /* Actually build the enumerator itself. */
19158 build_enumerator
19160 }
19170 }
19172 /* DECL is a FUNCTION_DECL that is a template specialization. Return
19173 its type -- but without substituting the innermost set of template
19174 arguments. So, innermost set of template parameters will appear in
19175 the type. */
19177 tree
19179 {
19180 tree fn_type;
19181 tree tmpl;
19182 tree targs;
19183 tree tparms;
19191 /* There should be as many levels of arguments as there are levels
19192 of parameters. */
19198 /* No substitution is necessary. */
19199 ;
19200 else
19201 {
19203 tree partial_args;
19205 /* Replace the innermost level of the TARGS with NULL_TREEs to
19206 let tsubst know not to substitute for those parameters. */
19215 /* Make sure that we can see identifiers, and compute access
19216 correctly. */
19220 /* Now, do the (partial) substitution to figure out the
19221 appropriate function type. */
19225 /* Substitute into the template parameters to obtain the real
19226 innermost set of parameters. This step is important if the
19227 innermost set of template parameters contains value
19228 parameters whose types depend on outer template parameters. */
19233 }
19236 }
19238 /* Return truthvalue if we're processing a template different from
19239 the last one involved in diagnostics. */
19240 int
19242 {
19244 }
19246 /* Remember current template involved in diagnostics. */
19247 void
19249 {
19251 }
19255 {
19257 }
19259 /* [temp.param] Check that template non-type parm TYPE is of an allowable
19260 type. Return zero for ok, nonzero for disallowed. Issue error and
19261 warning messages under control of COMPLAIN. */
19263 static int
19265 {
19282 {
19285 else
19287 type);
19288 }
19290 }
19292 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
19293 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
19295 static bool
19297 {
19298 tree scope;
19300 /* [temp.dep.type]
19302 A type is dependent if it is:
19304 -- a template parameter. Template template parameters are types
19305 for us (since TYPE_P holds true for them) so we handle
19306 them here. */
19310 /* -- a qualified-id with a nested-name-specifier which contains a
19311 class-name that names a dependent type or whose unqualified-id
19312 names a dependent type. */
19315 /* -- a cv-qualified type where the cv-unqualified type is
19316 dependent. */
19318 /* -- a compound type constructed from any dependent type. */
19328 {
19329 tree arg_type;
19334 arg_type;
19339 }
19340 /* -- an array type constructed from any dependent type or whose
19341 size is specified by a constant expression that is
19342 value-dependent.
19344 We checked for type- and value-dependence of the bounds in
19345 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
19347 {
19352 }
19354 /* -- a template-id in which either the template name is a template
19355 parameter ... */
19358 /* ... or any of the template arguments is a dependent type or
19359 an expression that is type-dependent or value-dependent. */
19361 && (any_dependent_template_arguments_p
19365 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
19366 dependent; if the argument of the `typeof' expression is not
19367 type-dependent, then it should already been have resolved. */
19373 /* A template argument pack is dependent if any of its packed
19374 arguments are. */
19376 {
19382 }
19384 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
19385 be template parameters. */
19389 /* The standard does not specifically mention types that are local
19390 to template functions or local classes, but they should be
19391 considered dependent too. For example:
19393 template <int I> void f() {
19394 enum E { a = I };
19395 S<sizeof (E)> s;
19396 }
19398 The size of `E' cannot be known until the value of `I' has been
19399 determined. Therefore, `E' must be considered dependent. */
19403 /* Don't use type_dependent_expression_p here, as it can lead
19404 to infinite recursion trying to determine whether a lambda
19405 nested in a lambda is dependent (c++/47687). */
19409 && (any_dependent_template_arguments_p
19413 /* Other types are non-dependent. */
19415 }
19417 /* Returns TRUE if TYPE is dependent, in the sense of
19418 [temp.dep.type]. Note that a NULL type is considered dependent. */
19420 bool
19422 {
19423 /* If there are no template parameters in scope, then there can't be
19424 any dependent types. */
19426 {
19427 /* If we are not processing a template, then nobody should be
19428 providing us with a dependent type. */
19432 }
19434 /* If the type is NULL, we have not computed a type for the entity
19435 in question; in that case, the type is dependent. */
19439 /* Erroneous types can be considered non-dependent. */
19443 /* If we have not already computed the appropriate value for TYPE,
19444 do so now. */
19446 {
19449 }
19452 }
19454 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
19455 lookup. In other words, a dependent type that is not the current
19456 instantiation. */
19458 bool
19460 {
19463 }
19465 /* T is a SCOPE_REF; return whether we need to consider it
19466 instantiation-dependent so that we can check access at instantiation
19467 time even though we know which member it resolves to. */
19469 static bool
19471 {
19477 else
19479 }
19481 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
19482 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
19483 expression. */
19485 /* Note that this predicate is not appropriate for general expressions;
19486 only constant expressions (that satisfy potential_constant_expression)
19487 can be tested for value dependence. */
19489 bool
19491 {
19495 /* A name declared with a dependent type. */
19500 {
19502 /* A name that has not been looked up -- must be dependent. */
19506 /* A non-type template parm. */
19510 /* A non-type template parm. */
19516 /* A constant with literal type and is initialized
19517 with an expression that is value-dependent.
19519 Note that a non-dependent parenthesized initializer will have
19520 already been replaced with its constant value, so if we see
19521 a TREE_LIST it must be dependent. */
19534 /* These expressions are value-dependent if the type to which
19535 the cast occurs is dependent or the expression being casted
19536 is value-dependent. */
19537 {
19543 /* A functional cast has a list of operands. */
19546 {
19547 /* If there are no operands, it must be an expression such
19548 as "int()". This should not happen for aggregate types
19549 because it would form non-constant expressions. */
19554 }
19560 }
19565 /* FALLTHRU */
19568 /* A `sizeof' expression is value-dependent if the operand is
19569 type-dependent or is a pack expansion. */
19578 /* An 'encode' expression is value-dependent if the operand is
19579 type-dependent. */
19588 /* All instantiation-dependent expressions should also be considered
19589 value-dependent. */
19597 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
19598 is value-dependent. */
19599 {
19608 }
19611 {
19615 }
19626 {
19630 }
19633 {
19640 {
19642 /* In a call to a constexpr member function, look through the
19643 implicit ADDR_EXPR on the object argument so that it doesn't
19644 cause the call to be considered value-dependent. We also
19645 look through it in potential_constant_expression. */
19652 }
19654 }
19657 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
19658 type-dependent. */
19662 {
19664 tree val;
19669 }
19672 /* Treat a GNU statement expression as dependent to avoid crashing
19673 under fold_non_dependent_expr; it can't be constant. */
19677 /* A constant expression is value-dependent if any subexpression is
19678 value-dependent. */
19680 {
19687 {
19691 {
19694 /* In some cases, some of the operands may be missing.l
19695 (For example, in the case of PREDECREMENT_EXPR, the
19696 amount to increment by may be missing.) That doesn't
19697 make the expression dependent. */
19700 }
19701 }
19705 }
19707 }
19709 /* The expression is not value-dependent. */
19711 }
19713 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
19714 [temp.dep.expr]. Note that an expression with no type is
19715 considered dependent. Other parts of the compiler arrange for an
19716 expression with type-dependent subexpressions to have no type, so
19717 this function doesn't have to be fully recursive. */
19719 bool
19721 {
19728 /* An unresolved name is always dependent. */
19733 /* Some expression forms are never type-dependent. */
19746 /* The types of these expressions depends only on the type to which
19747 the cast occurs. */
19756 /* The types of these expressions depends only on the type created
19757 by the expression. */
19760 {
19761 /* For NEW_EXPR tree nodes created inside a template, either
19762 the object type itself or a TREE_LIST may appear as the
19763 operand 1. */
19766 /* This is an array type. We need to check array dimensions
19767 as well. */
19769 || value_dependent_expression_p
19771 else
19773 }
19776 {
19780 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
19781 contains an identifier associated by name lookup with one or more
19782 declarations declared with a dependent type, or...a
19783 nested-name-specifier or qualified-id that names a member of an
19784 unknown specialization. */
19787 }
19792 && (any_dependent_template_arguments_p
19804 {
19805 tree elt;
19809 {
19812 }
19814 }
19816 /* A static data member of the current instantiation with incomplete
19817 array type is type-dependent, as the definition and specializations
19818 can have different bounds. */
19826 {
19831 {
19837 }
19838 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
19846 {
19851 }
19856 {
19860 }
19862 }
19867 }
19869 /* walk_tree callback function for instantiation_dependent_expression_p,
19870 below. Returns non-zero if a dependent subexpression is found. */
19872 static tree
19875 {
19877 {
19878 /* We don't have to worry about decltype currently because decltype
19879 of an instantiation-dependent expr is a dependent type. This
19880 might change depending on the resolution of DR 1172. */
19883 }
19886 {
19887 /* Don't treat an argument list as dependent just because it has no
19888 TREE_TYPE. */
19896 /* Handle expressions with type operands. */
19901 {
19906 {
19909 else
19910 {
19913 }
19914 }
19916 }
19927 /* In a template, finish_class_member_access_expr creates a
19928 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
19929 type-dependent, so that we can check access control at
19930 instantiation time (PR 42277). See also Core issue 1273. */
19937 else
19940 /* Treat statement-expressions as dependent. */
19946 }
19950 else
19952 }
19954 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
19955 sense defined by the ABI:
19957 "An expression is instantiation-dependent if it is type-dependent
19958 or value-dependent, or it has a subexpression that is type-dependent
19959 or value-dependent." */
19961 bool
19963 {
19964 tree result;
19975 }
19977 /* Like type_dependent_expression_p, but it also works while not processing
19978 a template definition, i.e. during substitution or mangling. */
19980 bool
19982 {
19988 }
19990 /* Returns TRUE if ARGS contains a type-dependent expression. */
19992 bool
19994 {
19996 tree arg;
19999 {
20002 }
20004 }
20006 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
20007 expressions) contains any type-dependent expressions. */
20009 bool
20011 {
20017 }
20019 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
20020 expressions) contains any value-dependent expressions. */
20022 bool
20024 {
20030 }
20032 /* Returns TRUE if the ARG (a template argument) is dependent. */
20034 bool
20036 {
20040 /* Assume a template argument that was wrongly written by the user
20041 is dependent. This is consistent with what
20042 any_dependent_template_arguments_p [that calls this function]
20043 does. */
20054 {
20058 {
20061 }
20064 }
20067 else
20070 }
20072 /* Returns true if ARGS (a collection of template arguments) contains
20073 any types that require structural equality testing. */
20075 bool
20077 {
20087 {
20090 {
20096 {
20097 /* Look inside the argument pack. */
20100 }
20103 {
20117 }
20118 }
20119 }
20122 }
20124 /* Returns true if ARGS (a collection of template arguments) contains
20125 any dependent arguments. */
20127 bool
20129 {
20139 {
20144 }
20147 }
20149 /* Returns TRUE if the template TMPL is dependent. */
20151 bool
20153 {
20155 {
20157 {
20161 }
20163 }
20165 /* Template template parameters are dependent. */
20169 /* So are names that have not been looked up. */
20173 /* So are member templates of dependent classes. */
20177 }
20179 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
20181 bool
20183 {
20186 }
20188 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
20189 is dependent. */
20191 bool
20193 {
20200 {
20221 {
20225 }
20229 {
20233 {
20238 }
20239 }
20240 }
20243 }
20245 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
20246 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
20247 no such TYPE can be found. Note that this function peers inside
20248 uninstantiated templates and therefore should be used only in
20249 extremely limited situations. ONLY_CURRENT_P restricts this
20250 peering to the currently open classes hierarchy (which is required
20251 when comparing types). */
20253 tree
20255 {
20256 tree scope;
20257 tree name;
20258 tree decl;
20260 tree pushed_scope;
20261 tree result;
20266 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
20267 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
20268 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
20269 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
20270 identifier of the TYPENAME_TYPE anymore.
20271 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
20272 TYPENAME_TYPE instead, we avoid messing up with a possible
20273 typedef variant case. */
20276 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
20277 it first before we can figure out what NAME refers to. */
20279 {
20281 /* Given a class template A with a dependent base with nested type C,
20282 typedef typename A::C::C C will land us here, as trying to resolve
20283 the initial A::C leads to the local C typedef, which leads back to
20284 A::C::C. So we break the recursion now. */
20286 else
20288 }
20289 /* If we don't know what SCOPE refers to, then we cannot resolve the
20290 TYPENAME_TYPE. */
20293 /* If the SCOPE is a template type parameter, we have no way of
20294 resolving the name. */
20297 /* If the SCOPE is not the current instantiation, there's no reason
20298 to look inside it. */
20301 /* If this is a typedef, we don't want to look inside (c++/11987). */
20304 /* If SCOPE isn't the template itself, it will not have a valid
20305 TYPE_FIELDS list. */
20307 /* scope is either the template itself or a compatible instantiation
20308 like X<T>, so look up the name in the original template. */
20310 else
20311 /* scope is a partial instantiation, so we can't do the lookup or we
20312 will lose the template arguments. */
20314 /* Enter the SCOPE so that name lookup will be resolved as if we
20315 were in the class definition. In particular, SCOPE will no
20316 longer be considered a dependent type. */
20318 /* Look up the declaration. */
20320 tf_warning_or_error);
20324 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
20325 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
20330 {
20334 }
20337 {
20338 tree tmpl;
20339 tree args;
20340 /* Obtain the template and the arguments. */
20343 /* Instantiate the template. */
20349 }
20351 /* Leave the SCOPE. */
20355 /* If we failed to resolve it, return the original typename. */
20359 /* If lookup found a typename type, resolve that too. */
20361 {
20362 /* Ill-formed programs can cause infinite recursion here, so we
20363 must catch that. */
20367 }
20369 /* Qualify the resulting type. */
20375 }
20377 /* EXPR is an expression which is not type-dependent. Return a proxy
20378 for EXPR that can be used to compute the types of larger
20379 expressions containing EXPR. */
20381 tree
20383 {
20384 tree inner_expr;
20386 #ifdef ENABLE_CHECKING
20387 /* Try to get a constant value for all non-dependent expressions in
20388 order to expose bugs in *_dependent_expression_p and constexpr. */
20392 #endif
20394 /* Preserve OVERLOADs; the functions must be available to resolve
20395 types. */
20406 /* There is no need to return a proxy for a variable. */
20409 /* Preserve string constants; conversions from string constants to
20410 "char *" are allowed, even though normally a "const char *"
20411 cannot be used to initialize a "char *". */
20414 /* Preserve arithmetic constants, as an optimization -- there is no
20415 reason to create a new node. */
20418 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
20419 There is at least one place where we want to know that a
20420 particular expression is a throw-expression: when checking a ?:
20421 expression, there are special rules if the second or third
20422 argument is a throw-expression. */
20426 /* Don't wrap an initializer list, we need to be able to look inside. */
20430 /* Don't wrap a dummy object, we need to be able to test for it. */
20449 /* If the type is unknown, it can't really be non-dependent */
20452 /* Otherwise, build a NON_DEPENDENT_EXPR. */
20454 }
20456 /* ARGS is a vector of expressions as arguments to a function call.
20457 Replace the arguments with equivalent non-dependent expressions.
20458 This modifies ARGS in place. */
20460 void
20462 {
20464 tree arg;
20467 {
20471 }
20472 }
20474 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
20475 with a level one deeper than the actual template parms. */
20477 tree
20479 {
20492 }
20494 /* Given type ARG, return std::initializer_list<ARG>. */
20496 static tree
20498 {
20499 tree std_init_list = namespace_binding
20501 tree argvec;
20503 {
20507 }
20512 }
20514 /* Replace auto in TYPE with std::initializer_list<auto>. */
20516 static tree
20518 {
20525 }
20527 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
20528 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
20530 tree
20532 {
20541 /* Defining a subset of type-dependent expressions that we can deduce
20542 from ahead of time isn't worth the trouble. */
20545 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
20546 with either a new invented type template parameter U or, if the
20547 initializer is a braced-init-list (8.5.4), with
20548 std::initializer_list<U>. */
20564 {
20566 /* Try again at instantiation time. */
20569 /* If type is error_mark_node a diagnostic must have been
20570 emitted by now. Also, having a mention to '<type error>'
20571 in the diagnostic is not really useful to the user. */
20572 {
20576 else
20578 }
20580 }
20582 /* If the list of declarators contains more than one declarator, the type
20583 of each declared variable is determined as described above. If the
20584 type deduced for the template parameter U is not the same in each
20585 deduction, the program is ill-formed. */
20588 {
20594 else
20598 }
20604 }
20606 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
20607 result. */
20609 tree
20611 {
20612 tree argvec;
20619 /* For a late-specified return type in a template type-parameter, we
20620 need to add a dummy argument level for its parmlist. */
20621 argvec = add_to_template_args
20626 }
20628 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
20630 bool
20632 {
20636 else
20638 }
20640 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
20641 appear as a type-specifier for the declaration in question, we don't
20642 have to look through the whole type. */
20644 tree
20646 {
20663 }
20665 /* For a given template T, return the vector of typedefs referenced
20666 in T for which access check is needed at T instantiation time.
20667 T is either a FUNCTION_DECL or a RECORD_TYPE.
20668 Those typedefs were added to T by the function
20669 append_type_to_template_for_access_check. */
20673 {
20674 tree ti;
20685 {
20690 }
20693 }
20695 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
20696 tied to T. That list of typedefs will be access checked at
20697 T instantiation time.
20698 T is either a FUNCTION_DECL or a RECORD_TYPE.
20699 TYPE_DECL is a TYPE_DECL node representing a typedef.
20700 SCOPE is the scope through which TYPE_DECL is accessed.
20701 LOCATION is the location of the usage point of TYPE_DECL.
20703 This function is a subroutine of
20704 append_type_to_template_for_access_check. */
20706 static void
20708 tree type_decl,
20709 tree scope,
20710 location_t location)
20711 {
20712 qualified_typedef_usage_t typedef_usage;
20713 tree ti;
20720 && type_decl
20734 }
20736 /* Append TYPE_DECL to the template TEMPL.
20737 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
20738 At TEMPL instanciation time, TYPE_DECL will be checked to see
20739 if it can be accessed through SCOPE.
20740 LOCATION is the location of the usage point of TYPE_DECL.
20742 e.g. consider the following code snippet:
20744 class C
20745 {
20746 typedef int myint;
20747 };
20749 template<class U> struct S
20750 {
20751 C::myint mi; // <-- usage point of the typedef C::myint
20752 };
20754 S<char> s;
20756 At S<char> instantiation time, we need to check the access of C::myint
20757 In other words, we need to check the access of the myint typedef through
20758 the C scope. For that purpose, this function will add the myint typedef
20759 and the scope C through which its being accessed to a list of typedefs
20760 tied to the template S. That list will be walked at template instantiation
20761 time and access check performed on each typedefs it contains.
20762 Note that this particular code snippet should yield an error because
20763 myint is private to C. */
20765 void
20767 tree type_decl,
20768 tree scope,
20769 location_t location)
20770 {
20776 /* Make sure we don't append the type to the template twice. */
20783 }
20785 /* Set up the hash tables for template instantiations. */
20787 void
20789 {
20791 hash_specialization,
20792 eq_specializations,
20793 ggc_free);
20795 hash_specialization,
20796 eq_specializations,
20797 ggc_free);
20798 }
20800 /* Print stats about the template hash tables for -fstats. */
20802 void
20804 {
20813 }