| blob | 50d12b08348c4b4dbcdfd8274b4224051aae9664 |
1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
6 Rewritten by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
48 /* The type of functions taking a tree, and some additional data, and
49 returning an int. */
52 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
53 instantiations have been deferred, either because their definitions
54 were not yet available, or because we were putting off doing the work. */
58 };
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
80 local variables. */
83 /* True if we've recursed into fn_type_unification too many times. */
87 {
88 tree tmpl;
89 tree args;
90 tree spec;
94 htab_t decl_specializations;
97 htab_t type_specializations;
99 /* Contains canonical template parameter types. The vector is indexed by
100 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
101 TREE_LIST, whose TREE_VALUEs contain the canonical template
102 parameters of various types and levels. */
105 #define UNIFY_ALLOW_NONE 0
106 #define UNIFY_ALLOW_MORE_CV_QUAL 1
107 #define UNIFY_ALLOW_LESS_CV_QUAL 2
108 #define UNIFY_ALLOW_DERIVED 4
109 #define UNIFY_ALLOW_INTEGER 8
110 #define UNIFY_ALLOW_OUTER_LEVEL 16
111 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
112 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
115 tbr_incomplete_type,
116 tbr_ambiguous_baseclass,
117 tbr_success
118 };
139 tree);
201 location_t);
210 /* Make the current scope suitable for access checking when we are
211 processing T. T can be FUNCTION_DECL for instantiated function
212 template, VAR_DECL for static member variable, or TYPE_DECL for
213 alias template (needed by instantiate_decl). */
215 static void
217 {
226 else
230 {
231 saved_access_scope = tree_cons
234 }
235 }
237 /* Restore the scope set up by push_access_scope. T is the node we
238 are processing. */
240 static void
242 {
244 {
247 }
251 else
253 }
255 /* Do any processing required when DECL (a member template
256 declaration) is finished. Returns the TEMPLATE_DECL corresponding
257 to DECL, unless it is a specialization, in which case the DECL
258 itself is returned. */
260 tree
262 {
269 {
270 tree type;
278 {
282 }
284 }
288 {
290 {
293 }
294 else
296 }
297 else
301 }
303 /* Create a template info node. */
305 tree
307 {
312 }
314 /* Return the template info node corresponding to T, whatever T is. */
316 tree
318 {
336 }
338 /* Returns the template nesting level of the indicated class TYPE.
340 For example, in:
341 template <class T>
342 struct A
343 {
344 template <class U>
345 struct B {};
346 };
348 A<T>::B<U> has depth two, while A<T> has depth one.
349 Both A<T>::B<int> and A<int>::B<U> have depth one, if
350 they are instantiations, not specializations.
352 This function is guaranteed to return 0 if passed NULL_TREE so
353 that, for example, `template_class_depth (current_class_type)' is
354 always safe. */
356 int
358 {
365 {
371 }
374 }
376 /* Subroutine of maybe_begin_member_template_processing.
377 Returns true if processing DECL needs us to push template parms. */
379 static bool
381 {
387 }
389 /* Subroutine of maybe_begin_member_template_processing.
390 Push the template parms in PARMS, starting from LEVELS steps into the
391 chain, and ending at the beginning, since template parms are listed
392 innermost first. */
394 static void
396 {
404 current_template_parms
410 NULL);
412 {
421 {
428 {
429 /* Make a CONST_DECL as is done in process_template_parm.
430 It is ugly that we recreate this here; the original
431 version built in process_template_parm is no longer
432 available. */
442 }
447 }
448 }
449 }
451 /* Restore the template parameter context for a member template or
452 a friend template defined in a class definition. */
454 void
456 {
457 tree parms;
461 {
466 {
469 }
472 }
474 /* Remember how many levels of template parameters we pushed so that
475 we can pop them later. */
477 }
479 /* Undo the effects of maybe_begin_member_template_processing. */
481 void
483 {
492 {
496 }
497 }
499 /* Return a new template argument vector which contains all of ARGS,
500 but has as its innermost set of arguments the EXTRA_ARGS. */
502 static tree
504 {
505 tree new_args;
523 }
525 /* Like add_to_template_args, but only the outermost ARGS are added to
526 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
527 (EXTRA_ARGS) levels are added. This function is used to combine
528 the template arguments from a partial instantiation with the
529 template arguments used to attain the full instantiation from the
530 partial instantiation. */
532 static tree
534 {
535 tree new_args;
537 /* If there are more levels of EXTRA_ARGS than there are ARGS,
538 something very fishy is going on. */
541 /* If *all* the new arguments will be the EXTRA_ARGS, just return
542 them. */
546 /* For the moment, we make ARGS look like it contains fewer levels. */
551 /* Now, we restore ARGS to its full dimensions. */
555 }
557 /* Return the N levels of innermost template arguments from the ARGS. */
559 tree
561 {
562 tree new_args;
568 /* If N is 1, just return the innermost set of template arguments. */
572 /* If we're not removing anything, just return the arguments we were
573 given. */
579 /* Make a new set of arguments, not containing the outer arguments. */
586 }
588 /* The inverse of get_innermost_template_args: Return all but the innermost
589 EXTRA_LEVELS levels of template arguments from the ARGS. */
591 static tree
593 {
594 tree new_args;
600 /* If N is 1, just return the outermost set of template arguments. */
604 /* If we're not removing anything, just return the arguments we were
605 given. */
610 /* Make a new set of arguments, not containing the inner arguments. */
617 }
619 /* We've got a template header coming up; push to a new level for storing
620 the parms. */
622 void
624 {
625 /* We use a non-tag-transparent scope here, which causes pushtag to
626 put tags in this scope, rather than in the enclosing class or
627 namespace scope. This is the right thing, since we want
628 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
629 global template class, push_template_decl handles putting the
630 TEMPLATE_DECL into top-level scope. For a nested template class,
631 e.g.:
633 template <class T> struct S1 {
634 template <class T> struct S2 {};
635 };
637 pushtag contains special code to call pushdecl_with_scope on the
638 TEMPLATE_DECL for S2. */
643 }
645 /* This routine is called when a specialization is declared. If it is
646 invalid to declare a specialization here, an error is reported and
647 false is returned, otherwise this routine will return true. */
649 static bool
651 {
654 /* [temp.expl.spec]
656 An explicit specialization shall be declared in the namespace of
657 which the template is a member, or, for member templates, in the
658 namespace of which the enclosing class or enclosing class
659 template is a member. An explicit specialization of a member
660 function, member class or static data member of a class template
661 shall be declared in the namespace of which the class template
662 is a member. */
664 {
667 }
669 /* [temp.expl.spec]
671 In an explicit specialization declaration for a member of a class
672 template or a member template that appears in namespace scope,
673 the member template and some of its enclosing class templates may
674 remain unspecialized, except that the declaration shall not
675 explicitly specialize a class member template if its enclosing
676 class templates are not explicitly specialized as well. */
678 {
681 }
684 }
686 /* We've just seen template <>. */
688 bool
690 {
694 }
696 /* Called at then end of processing a declaration preceded by
697 template<>. */
699 void
701 {
704 }
706 /* Any template <>'s that we have seen thus far are not referring to a
707 function specialization. */
709 void
711 {
714 }
716 /* We've just seen a template header. If SPECIALIZATION is nonzero,
717 it was of the form template <>. */
719 static void
721 {
723 template_header_count++;
724 }
726 /* We're beginning an explicit instantiation. */
728 void
730 {
733 }
736 void
738 {
741 }
743 /* An explicit specialization or partial specialization of TMPL is being
744 declared. Check that the namespace in which the specialization is
745 occurring is permissible. Returns false iff it is invalid to
746 specialize TMPL in the current namespace. */
748 static bool
750 {
753 /* [tmpl.expl.spec]
755 An explicit specialization shall be declared in the namespace of
756 which the template is a member, or, for member templates, in the
757 namespace of which the enclosing class or enclosing class
758 template is a member. An explicit specialization of a member
759 function, member class or static data member of a class template
760 shall be declared in the namespace of which the class template is
761 a member. */
764 {
767 }
769 /* Same or super-using namespace. */
771 else
772 {
776 }
777 }
779 /* SPEC is an explicit instantiation. Check that it is valid to
780 perform this explicit instantiation in the current namespace. */
782 static void
784 {
785 tree ns;
787 /* DR 275: An explicit instantiation shall appear in an enclosing
788 namespace of its template. */
794 }
796 /* The TYPE is being declared. If it is a template type, that means it
797 is a partial specialization. Do appropriate error-checking. */
799 tree
801 {
802 tree context;
808 {
812 }
817 /* Consider non-class instantiations of alias templates as
818 well. */
823 {
824 /* This is for ordinary explicit specialization and partial
825 specialization of a template class such as:
827 template <> class C<int>;
829 or:
831 template <class T> class C<T*>;
833 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
838 {
842 {
846 }
847 }
853 {
857 }
858 }
864 {
865 /* This is for an explicit specialization of member class
866 template according to [temp.expl.spec/18]:
868 template <> template <class U> class C<int>::D;
870 The context `C<int>' must be an implicit instantiation.
871 Otherwise this is just a member class template declared
872 earlier like:
874 template <> class C<int> { template <class U> class D; };
875 template <> template <class U> class C<int>::D;
877 In the first case, `C<int>::D' is a specialization of `C<T>::D'
878 while in the second case, `C<int>::D' is a primary template
879 and `C<T>::D' may not exist. */
883 {
884 tree t;
889 {
892 }
894 /* Check for invalid specialization after instantiation:
896 template <> template <> class C<int>::D<int>;
897 template <> template <class U> class C<int>::D; */
901 {
904 {
905 /* We already have a full specialization of this partial
906 instantiation. Reassign it to the new member
907 specialization template. */
908 spec_entry elt;
925 }
927 /* But if we've had an implicit instantiation, that's a
928 problem ([temp.expl.spec]/6). */
931 }
933 /* Mark TYPE as a specialization. And as a result, we only
934 have one level of template argument for the innermost
935 class template. */
939 }
940 }
942 {
943 /* Someday C++0x may allow for enum template specialization. */
948 else
949 {
952 }
953 }
956 }
958 /* Returns nonzero if we can optimize the retrieval of specializations
959 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
960 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
964 {
967 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
968 parameter. */
970 /* The optimized lookup depends on the fact that the
971 template arguments for the member function template apply
972 purely to the containing class, which is not true if the
973 containing class is an explicit or partial
974 specialization. */
978 /* It is possible to have a template that is not a member
979 template and is not a member of a template class:
981 template <typename T>
982 struct S { friend A::f(); };
984 Here, the friend function is a template, but the context does
985 not have template information. The optimized lookup relies
986 on having ARGS be the template arguments for both the class
987 and the function template. */
989 }
991 /* Retrieve the specialization (in the sense of [temp.spec] - a
992 specialization is either an instantiation or an explicit
993 specialization) of TMPL for the given template ARGS. If there is
994 no such specialization, return NULL_TREE. The ARGS are a vector of
995 arguments, or a vector of vectors of arguments, in the case of
996 templates with more than one level of parameters.
998 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
999 then we search for a partial specialization matching ARGS. This
1000 parameter is ignored if TMPL is not a class template. */
1002 static tree
1004 {
1010 /* There should be as many levels of arguments as there are
1011 levels of parameters. */
1016 {
1017 tree class_template;
1018 tree class_specialization;
1020 tree fns;
1023 /* The template arguments actually apply to the containing
1024 class. Find the class specialization with those
1025 arguments. */
1027 class_specialization
1031 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1032 for the specialization. */
1036 /* Iterate through the methods with the indicated name, looking
1037 for the one that has an instance of TMPL. */
1040 {
1043 /* using-declarations can add base methods to the method vec,
1044 and we don't want those here. */
1047 }
1049 }
1050 else
1051 {
1053 spec_entry elt;
1054 htab_t specializations;
1062 else
1070 }
1073 }
1075 /* Like retrieve_specialization, but for local declarations. */
1077 static tree
1079 {
1087 }
1089 /* Returns nonzero iff DECL is a specialization of TMPL. */
1091 int
1093 {
1094 tree t;
1097 {
1103 }
1104 else
1105 {
1114 }
1117 }
1119 /* Returns nonzero iff DECL is a specialization of friend declaration
1120 FRIEND_DECL according to [temp.friend]. */
1122 bool
1124 {
1131 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1132 of a template class, we want to check if DECL is a specialization
1133 if this. */
1137 {
1138 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1141 }
1146 /* There is nothing to do if this is not a template friend. */
1153 /* [temp.friend/6]
1154 A member of a class template may be declared to be a friend of a
1155 non-template class. In this case, the corresponding member of
1156 every specialization of the class template is a friend of the
1157 class granting friendship.
1159 For example, given a template friend declaration
1161 template <class T> friend void A<T>::f();
1163 the member function below is considered a friend
1165 template <> struct A<int> {
1166 void f();
1167 };
1169 For this type of template friend, TEMPLATE_DEPTH below will be
1170 nonzero. To determine if DECL is a friend of FRIEND, we first
1171 check if the enclosing class is a specialization of another. */
1178 {
1179 /* Next, we check the members themselves. In order to handle
1180 a few tricky cases, such as when FRIEND_DECL's are
1182 template <class T> friend void A<T>::g(T t);
1183 template <class T> template <T t> friend void A<T>::h();
1185 and DECL's are
1187 void A<int>::g(int);
1188 template <int> void A<int>::h();
1190 we need to figure out ARGS, the template arguments from
1191 the context of DECL. This is required for template substitution
1192 of `T' in the function parameter of `g' and template parameter
1193 of `h' in the above examples. Here ARGS corresponds to `int'. */
1200 {
1202 {
1205 else
1207 current_depth++;
1208 }
1210 }
1213 {
1215 tree friend_type;
1216 tree decl_type;
1217 tree friend_args_type;
1218 tree decl_args_type;
1220 /* Make sure that both DECL and FRIEND_DECL are templates or
1221 non-templates. */
1227 {
1228 /* If both are templates, check template parameter list. */
1229 tree friend_parms
1234 friend_parms))
1238 }
1239 else
1247 /* Check if return types match. */
1251 /* Check if function parameter types match, ignoring the
1252 `this' parameter. */
1261 }
1262 else
1263 {
1264 /* DECL is a TYPE_DECL */
1268 /* Make sure that both DECL and FRIEND_DECL are templates or
1269 non-templates. */
1270 is_template
1277 {
1278 tree friend_parms;
1279 /* If both are templates, check the name of the two
1280 TEMPLATE_DECL's first because is_friend didn't. */
1285 /* Now check template parameter list. */
1286 friend_parms
1289 return comp_template_parms
1291 friend_parms);
1292 }
1293 else
1296 }
1297 }
1299 }
1301 /* Register the specialization SPEC as a specialization of TMPL with
1302 the indicated ARGS. IS_FRIEND indicates whether the specialization
1303 is actually just a friend declaration. Returns SPEC, or an
1304 equivalent prior declaration, if available. */
1306 static tree
1308 hashval_t hash)
1309 {
1310 tree fn;
1312 spec_entry elt;
1318 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1319 register it; we want the corresponding TEMPLATE_DECL instead.
1320 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1321 the more obvious `uses_template_parms (spec)' to avoid problems
1322 with default function arguments. In particular, given
1323 something like this:
1325 template <class T> void f(T t1, T t = T())
1327 the default argument expression is not substituted for in an
1328 instantiation unless and until it is actually needed. */
1332 /* We don't put these specializations in the hash table, but we might
1333 want to give an error about a mismatch. */
1335 else
1336 {
1344 slot =
1348 else
1350 }
1352 /* We can sometimes try to re-register a specialization that we've
1353 already got. In particular, regenerate_decl_from_template calls
1354 duplicate_decls which will update the specialization list. But,
1355 we'll still get called again here anyhow. It's more convenient
1356 to simply allow this than to try to prevent it. */
1360 {
1362 {
1365 {
1367 fn);
1369 }
1370 else
1371 {
1372 tree clone;
1373 /* This situation should occur only if the first
1374 specialization is an implicit instantiation, the
1375 second is an explicit specialization, and the
1376 implicit instantiation has not yet been used. That
1377 situation can occur if we have implicitly
1378 instantiated a member function and then specialized
1379 it later.
1381 We can also wind up here if a friend declaration that
1382 looked like an instantiation turns out to be a
1383 specialization:
1385 template <class T> void foo(T);
1386 class S { friend void foo<>(int) };
1387 template <> void foo(int);
1389 We transform the existing DECL in place so that any
1390 pointers to it become pointers to the updated
1391 declaration.
1393 If there was a definition for the template, but not
1394 for the specialization, we want this to look as if
1395 there were no definition, and vice versa. */
1398 /* The call to duplicate_decls will have applied
1399 [temp.expl.spec]:
1401 An explicit specialization of a function template
1402 is inline only if it is explicitly declared to be,
1403 and independently of whether its function template
1404 is.
1406 to the primary function; now copy the inline bits to
1407 the various clones. */
1409 {
1414 }
1418 }
1419 }
1421 {
1423 /* Dup decl failed, but this is a new definition. Set the
1424 line number so any errors match this new
1425 definition. */
1429 }
1430 }
1434 /* A specialization must be declared in the same namespace as the
1435 template it is specializing. */
1441 {
1449 /* TMPL is a forward declaration of a template function; keep a list
1450 of all specializations in case we need to reassign them to a friend
1451 template later in tsubst_friend_function. */
1454 }
1457 }
1459 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1460 TMPL and ARGS members, ignores SPEC. */
1462 static int
1464 {
1470 }
1472 /* Returns a hash for a template TMPL and template arguments ARGS. */
1474 static hashval_t
1476 {
1479 }
1481 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1482 ignoring SPEC. */
1484 static hashval_t
1486 {
1489 }
1491 /* Recursively calculate a hash value for a template argument ARG, for use
1492 in the hash tables of template specializations. */
1494 hashval_t
1496 {
1508 /* We can get one of these when re-hashing a previous entry in the middle
1509 of substituting into a pack expansion. Just look through it. */
1518 {
1526 {
1531 }
1553 {
1556 {
1559 }
1561 }
1565 {
1568 }
1579 val = iterative_hash_template_arg
1591 val);
1593 val);
1602 /* A lambda can't appear in a template arg, but don't crash on
1603 erroneous input. */
1615 /* Now hash operands as usual. */
1620 }
1623 {
1627 val);
1630 /* Otherwise just compare the types during lookup. */
1639 {
1644 }
1645 }
1648 }
1650 /* Unregister the specialization SPEC as a specialization of TMPL.
1651 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1652 if the SPEC was listed as a specialization of TMPL.
1654 Note that SPEC has been ggc_freed, so we can't look inside it. */
1656 bool
1658 {
1660 spec_entry elt;
1668 {
1673 }
1676 }
1678 /* Like register_specialization, but for local declarations. We are
1679 registering SPEC, an instantiation of TMPL. */
1681 static void
1683 {
1688 }
1690 /* TYPE is a class type. Returns true if TYPE is an explicitly
1691 specialized class. */
1693 bool
1695 {
1699 }
1701 /* Print the list of functions at FNS, going through all the overloads
1702 for each element of the list. Alternatively, FNS can not be a
1703 TREE_LIST, in which case it will be printed together with all the
1704 overloads.
1706 MORE and *STR should respectively be FALSE and NULL when the function
1707 is called from the outside. They are used internally on recursive
1708 calls. print_candidates manages the two parameters and leaves NULL
1709 in *STR when it ends. */
1711 static void
1713 {
1719 {
1723 }
1724 else
1725 {
1728 {
1729 /* Pick the prefix string. */
1731 {
1735 }
1739 }
1742 }
1745 {
1748 }
1749 }
1751 /* Print the list of candidate FNS in an error message. FNS can also
1752 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1754 void
1756 {
1760 }
1762 /* Returns the template (one of the functions given by TEMPLATE_ID)
1763 which can be specialized to match the indicated DECL with the
1764 explicit template args given in TEMPLATE_ID. The DECL may be
1765 NULL_TREE if none is available. In that case, the functions in
1766 TEMPLATE_ID are non-members.
1768 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1769 specialization of a member template.
1771 The TEMPLATE_COUNT is the number of references to qualifying
1772 template classes that appeared in the name of the function. See
1773 check_explicit_specialization for a more accurate description.
1775 TSK indicates what kind of template declaration (if any) is being
1776 declared. TSK_TEMPLATE indicates that the declaration given by
1777 DECL, though a FUNCTION_DECL, has template parameters, and is
1778 therefore a template function.
1780 The template args (those explicitly specified and those deduced)
1781 are output in a newly created vector *TARGS_OUT.
1783 If it is impossible to determine the result, an error message is
1784 issued. The error_mark_node is returned to indicate failure. */
1786 static tree
1788 tree decl,
1792 tmpl_spec_kind tsk)
1793 {
1794 tree fns;
1795 tree targs;
1796 tree explicit_targs;
1798 /* A TREE_LIST of templates of which DECL may be a specialization.
1799 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1800 corresponding TREE_PURPOSE is the set of template arguments that,
1801 when used to instantiate the template, would produce a function
1802 with the signature of DECL. */
1812 /* We shouldn't be specializing a member template of an
1813 unspecialized class template; we already gave an error in
1814 check_specialization_scope, now avoid crashing. */
1817 {
1820 }
1828 /* Check for baselinks. */
1833 {
1836 }
1838 /* Count the number of template headers specified for this
1839 specialization. */
1847 {
1851 {
1852 tree decl_arg_types;
1853 tree fn_arg_types;
1854 tree insttype;
1856 /* In case of explicit specialization, we need to check if
1857 the number of template headers appearing in the specialization
1858 is correct. This is usually done in check_explicit_specialization,
1859 but the check done there cannot be exhaustive when specializing
1860 member functions. Consider the following code:
1862 template <> void A<int>::f(int);
1863 template <> template <> void A<int>::f(int);
1865 Assuming that A<int> is not itself an explicit specialization
1866 already, the first line specializes "f" which is a non-template
1867 member function, whilst the second line specializes "f" which
1868 is a template member function. So both lines are syntactically
1869 correct, and check_explicit_specialization does not reject
1870 them.
1872 Here, we can do better, as we are matching the specialization
1873 against the declarations. We count the number of template
1874 headers, and we check if they match TEMPLATE_COUNT + 1
1875 (TEMPLATE_COUNT is the number of qualifying template classes,
1876 plus there must be another header for the member template
1877 itself).
1879 Notice that if header_count is zero, this is not a
1880 specialization but rather a template instantiation, so there
1881 is no check we can perform here. */
1885 /* Check that the number of template arguments at the
1886 innermost level for DECL is the same as for FN. */
1894 /* DECL might be a specialization of FN. */
1898 /* For a non-static member function, we need to make sure
1899 that the const qualification is the same. Since
1900 get_bindings does not try to merge the "this" parameter,
1901 we must do the comparison explicitly. */
1907 /* Skip the "this" parameter and, for constructors of
1908 classes with virtual bases, the VTT parameter. A
1909 full specialization of a constructor will have a VTT
1910 parameter, but a template never will. */
1911 decl_arg_types
1913 fn_arg_types
1916 /* Function templates cannot be specializations; there are
1917 no partial specializations of functions. Therefore, if
1918 the type of DECL does not match FN, there is no
1919 match. */
1921 {
1925 }
1927 /* See whether this function might be a specialization of this
1928 template. Suppress access control because we might be trying
1929 to make this specialization a friend, and we have already done
1930 access control for the declaration of the specialization. */
1936 /* We cannot deduce template arguments that when used to
1937 specialize TMPL will produce DECL. */
1940 /* Make sure that the deduced arguments actually work. */
1944 fn_arg_types
1949 /* Save this template, and the arguments deduced. */
1951 }
1953 /* FN is an ordinary member function, and we need a
1954 specialization of a member template. */
1955 ;
1957 /* We can get IDENTIFIER_NODEs here in certain erroneous
1958 cases. */
1959 ;
1961 /* This is just an ordinary non-member function. Nothing can
1962 be a specialization of that. */
1963 ;
1965 /* Cannot specialize functions that are created implicitly. */
1966 ;
1967 else
1968 {
1969 tree decl_arg_types;
1971 /* This is an ordinary member function. However, since
1972 we're here, we can assume it's enclosing class is a
1973 template class. For example,
1975 template <typename T> struct S { void f(); };
1976 template <> void S<int>::f() {}
1978 Here, S<int>::f is a non-template, but S<int> is a
1979 template class. If FN has the same type as DECL, we
1980 might be in business. */
1983 /* Its enclosing class is an explicit specialization
1984 of a template class. This is not a candidate. */
1989 /* The return types differ. */
1992 /* Adjust the type of DECL in case FN is a static member. */
1999 decl_arg_types))
2000 /* They match! */
2002 }
2003 }
2006 {
2007 /* We have:
2009 [temp.expl.spec]
2011 It is possible for a specialization with a given function
2012 signature to be instantiated from more than one function
2013 template. In such cases, explicit specification of the
2014 template arguments must be used to uniquely identify the
2015 function template specialization being specialized.
2017 Note that here, there's no suggestion that we're supposed to
2018 determine which of the candidate templates is most
2019 specialized. However, we, also have:
2021 [temp.func.order]
2023 Partial ordering of overloaded function template
2024 declarations is used in the following contexts to select
2025 the function template to which a function template
2026 specialization refers:
2028 -- when an explicit specialization refers to a function
2029 template.
2031 So, we do use the partial ordering rules, at least for now.
2032 This extension can only serve to make invalid programs valid,
2033 so it's safe. And, there is strong anecdotal evidence that
2034 the committee intended the partial ordering rules to apply;
2035 the EDG front end has that behavior, and John Spicer claims
2036 that the committee simply forgot to delete the wording in
2037 [temp.expl.spec]. */
2040 {
2043 }
2044 }
2047 {
2055 }
2059 {
2065 }
2067 /* We have one, and exactly one, match. */
2069 {
2072 /* DECL is a re-declaration or partial instantiation of a template
2073 function. */
2076 /* It was a specialization of an ordinary member function in a
2077 template class. */
2079 }
2081 /* It was a specialization of a template. */
2084 {
2089 }
2090 else
2093 }
2095 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2096 but with the default argument values filled in from those in the
2097 TMPL_TYPES. */
2099 static tree
2101 tree tmpl_types)
2102 {
2103 tree new_spec_types;
2111 /* Substitute into the rest of the list. */
2112 new_spec_types =
2116 /* Add the default argument for this parameter. */
2119 new_spec_types);
2120 }
2122 /* DECL is an explicit specialization. Replicate default arguments
2123 from the template it specializes. (That way, code like:
2125 template <class T> void f(T = 3);
2126 template <> void f(double);
2127 void g () { f (); }
2129 works, as required.) An alternative approach would be to look up
2130 the correct default arguments at the call-site, but this approach
2131 is consistent with how implicit instantiations are handled. */
2133 static void
2135 {
2136 tree tmpl;
2137 tree spec_types;
2138 tree tmpl_types;
2139 tree new_spec_types;
2140 tree old_type;
2141 tree new_type;
2142 tree t;
2147 /* See if there's anything we need to do. */
2160 {
2161 /* Remove the this pointer, but remember the object's type for
2162 CV quals. */
2168 {
2169 /* DECL may contain more parameters than TMPL due to the extra
2170 in-charge parameter in constructors and destructors. */
2173 }
2175 {
2178 }
2179 }
2181 /* Compute the merged default arguments. */
2182 new_spec_types =
2185 /* Compute the new FUNCTION_TYPE. */
2187 {
2191 new_spec_types);
2194 /* Put the in-charge parameter back. */
2197 new_spec_types);
2201 new_spec_types);
2202 }
2203 else
2205 new_spec_types);
2211 }
2213 /* Return the number of template headers we expect to see for a definition
2214 or specialization of CTYPE or one of its non-template members. */
2216 int
2218 {
2222 {
2223 /* You're supposed to have one `template <...>' for every
2224 template class, but you don't need one for a full
2225 specialization. For example:
2227 template <class T> struct S{};
2228 template <> struct S<int> { void f(); };
2229 void S<int>::f () {}
2231 is correct; there shouldn't be a `template <>' for the
2232 definition of `S<int>::f'. */
2234 /* If CTYPE does not have template information of any
2235 kind, then it is not a template, nor is it nested
2236 within a template. */
2244 }
2247 }
2249 /* Do a simple sanity check on the template headers that precede the
2250 variable declaration DECL. */
2252 void
2254 {
2261 {
2267 "members of an explicitly specialized class are defined "
2269 }
2270 }
2272 /* Check to see if the function just declared, as indicated in
2273 DECLARATOR, and in DECL, is a specialization of a function
2274 template. We may also discover that the declaration is an explicit
2275 instantiation at this point.
2277 Returns DECL, or an equivalent declaration that should be used
2278 instead if all goes well. Issues an error message if something is
2279 amiss. Returns error_mark_node if the error is not easily
2280 recoverable.
2282 FLAGS is a bitmask consisting of the following flags:
2284 2: The function has a definition.
2285 4: The function is a friend.
2287 The TEMPLATE_COUNT is the number of references to qualifying
2288 template classes that appeared in the name of the function. For
2289 example, in
2291 template <class T> struct S { void f(); };
2292 void S<int>::f();
2294 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2295 classes are not counted in the TEMPLATE_COUNT, so that in
2297 template <class T> struct S {};
2298 template <> struct S<int> { void f(); }
2299 template <> void S<int>::f();
2301 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2302 invalid; there should be no template <>.)
2304 If the function is a specialization, it is marked as such via
2305 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2306 is set up correctly, and it is added to the list of specializations
2307 for that template. */
2309 tree
2311 tree decl,
2314 {
2322 tmpl_spec_kind tsk;
2325 {
2328 else
2330 }
2331 else
2335 {
2338 {
2341 }
2343 {
2345 /* This could be something like:
2347 template <class T> void f(T);
2348 class S { friend void f<>(int); } */
2350 else
2351 {
2352 /* This case handles bogus declarations like template <>
2353 template <class T> void f<int>(); */
2356 declarator);
2358 }
2359 }
2363 /* The error has already been reported in
2364 check_specialization_scope. */
2370 /* Fall through. */
2383 decl);
2386 else
2390 /* Fall through. */
2395 else
2401 {
2402 /* This case handles bogus declarations like template <>
2403 template <class T> void f<int>(); */
2408 else
2410 declarator);
2412 }
2415 /* This is a specialization of a member template, without
2416 specialization the containing class. Something like:
2418 template <class T> struct S {
2419 template <class U> void f (U);
2420 };
2421 template <> template <class U> void S<int>::f(U) {}
2423 That's a specialization -- but of the entire template. */
2429 }
2432 {
2436 {
2440 }
2441 }
2444 {
2448 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2450 {
2451 tree fns;
2456 else
2457 {
2458 /* If there is no class context, the explicit instantiation
2459 must be at namespace scope. */
2462 /* Find the namespace binding, using the declaration
2463 context. */
2467 {
2470 }
2471 else
2472 {
2478 }
2479 }
2482 }
2488 {
2490 /* A specialization in class scope. This is invalid,
2491 but the error will already have been flagged by
2492 check_specialization_scope. */
2494 else
2495 {
2496 /* It's not valid to write an explicit instantiation in
2497 class scope, e.g.:
2499 class C { template void f(); }
2501 This case is caught by the parser. However, on
2502 something like:
2504 template class C { void f(); };
2506 (which is invalid) we can get here. The error will be
2507 issued later. */
2508 ;
2509 }
2512 }
2515 IDENTIFIER_NODE))
2516 {
2517 /* Find the list of functions in ctype that have the same
2518 name as the declared function. */
2524 {
2529 {
2530 /* From [temp.expl.spec]:
2532 If such an explicit specialization for the member
2533 of a class template names an implicitly-declared
2534 special member function (clause _special_), the
2535 program is ill-formed.
2537 Similar language is found in [temp.explicit]. */
2540 }
2543 }
2546 {
2550 }
2551 else
2552 {
2554 tree ovl;
2556 /* For a type-conversion operator, we cannot do a
2557 name-based lookup. We might be looking for `operator
2558 int' which will be a specialization of `operator T'.
2559 So, we find *all* the conversion operators, and then
2560 select from them. */
2568 {
2570 /* There are no more conversion functions. */
2573 /* Glue all these conversion functions together
2574 with those we already have. */
2577 }
2578 }
2581 {
2584 }
2585 else
2587 }
2589 /* Figure out what exactly is being specialized at this point.
2590 Note that for an explicit instantiation, even one for a
2591 member function, we cannot tell apriori whether the
2592 instantiation is for a member template, or just a member
2593 function of a template class. Even if a member template is
2594 being instantiated, the member template arguments may be
2595 elided if they can be deduced from the rest of the
2596 declaration. */
2599 member_specialization,
2600 template_count,
2601 tsk);
2604 /* We couldn't figure out what this declaration was
2605 specializing. */
2607 else
2608 {
2612 {
2613 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2614 is done by do_decl_instantiation later. */
2620 {
2621 /* If TMPL is not the most general template (for
2622 example, if TMPL is a friend template that is
2623 injected into namespace scope), then there will
2624 be too many levels of TARGS. Remove some of them
2625 here. */
2627 tree new_targs;
2634 }
2637 }
2639 /* If we thought that the DECL was a member function, but it
2640 turns out to be specializing a static member function,
2641 make DECL a static member function as well. */
2646 /* If this is a specialization of a member template of a
2647 template class, we want to return the TEMPLATE_DECL, not
2648 the specialization of it. */
2650 {
2655 {
2656 tree parm;
2660 /* We want to use the argument list specified in the
2661 definition, not in the original declaration. */
2666 }
2669 }
2671 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2674 /* Inherit default function arguments from the template
2675 DECL is specializing. */
2678 /* This specialization has the same protection as the
2679 template it specializes. */
2683 /* 7.1.1-1 [dcl.stc]
2685 A storage-class-specifier shall not be specified in an
2686 explicit specialization...
2688 The parser rejects these, so unless action is taken here,
2689 explicit function specializations will always appear with
2690 global linkage.
2692 The action recommended by the C++ CWG in response to C++
2693 defect report 605 is to make the storage class and linkage
2694 of the explicit specialization match the templated function:
2696 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2697 */
2699 {
2703 /* This specialization has the same linkage and visibility as
2704 the function template it specializes. */
2707 {
2710 }
2713 {
2716 }
2717 }
2719 /* If DECL is a friend declaration, declared using an
2720 unqualified name, the namespace associated with DECL may
2721 have been set incorrectly. For example, in:
2723 template <typename T> void f(T);
2724 namespace N {
2725 struct S { friend void f<int>(int); }
2726 }
2728 we will have set the DECL_CONTEXT for the friend
2729 declaration to N, rather than to the global namespace. */
2734 /* This is not really a declaration of a specialization.
2735 It's just the name of an instantiation. But, it's not
2736 a request for an instantiation, either. */
2739 /* This is indeed a specialization. In case of constructors
2740 and destructors, we need in-charge and not-in-charge
2741 versions in V3 ABI. */
2744 /* Register this specialization so that we can find it
2745 again. */
2747 }
2748 }
2751 }
2753 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2754 parameters. These are represented in the same format used for
2755 DECL_TEMPLATE_PARMS. */
2757 int
2759 {
2760 const_tree p1;
2761 const_tree p2;
2769 {
2781 {
2785 /* If either of the template parameters are invalid, assume
2786 they match for the sake of error recovery. */
2799 }
2800 }
2803 /* One set of parameters has more parameters lists than the
2804 other. */
2808 }
2810 /* Determine whether PARM is a parameter pack. */
2812 bool
2814 {
2815 /* Determine if we have a non-type template parameter pack. */
2822 /* If this is a list of template parameters, we could get a
2823 TYPE_DECL or a TEMPLATE_DECL. */
2827 /* Otherwise it must be a type template parameter. */
2831 }
2833 /* Determine if T is a function parameter pack. */
2835 bool
2837 {
2841 }
2843 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2844 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2846 tree
2848 {
2855 }
2857 /* Return true iff the function parameter PARAM_DECL was expanded
2858 from the function parameter pack PACK. */
2860 bool
2862 {
2867 /* The parameter pack and its pack arguments have the same
2868 DECL_PARM_INDEX. */
2870 }
2872 /* Determine whether ARGS describes a variadic template args list,
2873 i.e., one that is terminated by a template argument pack. */
2875 static bool
2877 {
2879 tree last_parm;
2893 }
2895 /* Generate a new name for the parameter pack name NAME (an
2896 IDENTIFIER_NODE) that incorporates its */
2898 static tree
2900 {
2901 /* Munge the name to include the parameter index. */
2902 #define NUMBUF_LEN 128
2914 }
2916 /* Return true if T is a primary function, class or alias template
2917 instantiation. */
2919 bool
2921 {
2935 }
2937 /* Return true if PARM is a template template parameter. */
2939 bool
2941 {
2943 }
2945 /* Return true iff PARM is a DECL representing a type template
2946 parameter. */
2948 bool
2950 {
2955 }
2957 /* Return the template parameters of T if T is a
2958 primary template instantiation, NULL otherwise. */
2960 tree
2962 {
2967 parms = INNERMOST_TEMPLATE_PARMS
2971 }
2973 /* Return the template parameters of the LEVELth level from the full list
2974 of template parameters PARMS. */
2976 tree
2978 {
2979 tree p;
2990 }
2992 /* Returns the template arguments of T if T is a template instantiation,
2993 NULL otherwise. */
2995 tree
2997 {
3005 }
3007 /* Return the argument pack elements of T if T is a template argument pack,
3008 NULL otherwise. */
3010 tree
3012 {
3018 }
3020 /* Structure used to track the progress of find_parameter_packs_r. */
3021 struct find_parameter_pack_data
3022 {
3023 /* TREE_LIST that will contain all of the parameter packs found by
3024 the traversal. */
3027 /* Set of AST nodes that have been visited by the traversal. */
3029 };
3031 /* Identifies all of the argument packs that occur in a template
3032 argument and appends them to the TREE_LIST inside DATA, which is a
3033 find_parameter_pack_data structure. This is a subroutine of
3034 make_pack_expansion and uses_parameter_packs. */
3035 static tree
3037 {
3043 /* Handle type aliases/typedefs. */
3048 {
3055 }
3057 /* Identify whether this is a parameter pack or not. */
3059 {
3074 {
3075 /* We don't want to walk into the type of a PARM_DECL,
3076 because we don't want to see the type parameter pack. */
3079 }
3086 /* Not a parameter pack. */
3088 }
3091 {
3092 /* Add this parameter pack to the list. */
3094 }
3100 /* This switch statement will return immediately if we don't find a
3101 parameter pack. */
3103 {
3108 /* Check the template itself. */
3111 /* Check the template arguments. */
3127 /* Fall through. */
3169 }
3172 }
3174 /* Determines if the expression or type T uses any parameter packs. */
3175 bool
3177 {
3185 }
3187 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3188 representation a base-class initializer into a parameter pack
3189 expansion. If all goes well, the resulting node will be an
3190 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3191 respectively. */
3192 tree
3194 {
3195 tree result;
3204 {
3205 /* The only time we will see a TREE_LIST here is for a base
3206 class initializer. In this case, the TREE_PURPOSE will be a
3207 _TYPE node (representing the base class expansion we're
3208 initializing) and the TREE_VALUE will be a TREE_LIST
3209 containing the initialization arguments.
3211 The resulting expansion looks somewhat different from most
3212 expansions. Rather than returning just one _EXPANSION, we
3213 return a TREE_LIST whose TREE_PURPOSE is a
3214 TYPE_PACK_EXPANSION containing the bases that will be
3215 initialized. The TREE_VALUE will be identical to the
3216 original TREE_VALUE, which is a list of arguments that will
3217 be passed to each base. We do not introduce any new pack
3218 expansion nodes into the TREE_VALUE (although it is possible
3219 that some already exist), because the TREE_PURPOSE and
3220 TREE_VALUE all need to be expanded together with the same
3221 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3222 resulting TREE_PURPOSE will mention the parameter packs in
3223 both the bases and the arguments to the bases. */
3224 tree purpose;
3225 tree value;
3228 /* Determine which parameter packs will be used by the base
3229 class expansion. */
3236 {
3240 }
3243 {
3244 /* Collect the sets of parameter packs used in each of the
3245 initialization arguments. */
3247 {
3248 /* Determine which parameter packs will be expanded in this
3249 argument. */
3252 }
3253 }
3257 /* Create the pack expansion type for the base type. */
3262 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3263 they will rarely be compared to anything. */
3267 }
3272 /* Build the PACK_EXPANSION_* node. */
3273 result = for_types
3278 {
3279 /* Propagate type and const-expression information. */
3282 }
3283 else
3284 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3285 they will rarely be compared to anything. */
3288 /* Determine which parameter packs will be expanded. */
3294 /* Make sure we found some parameter packs. */
3296 {
3299 else
3302 }
3308 }
3310 /* Checks T for any "bare" parameter packs, which have not yet been
3311 expanded, and issues an error if any are found. This operation can
3312 only be done on full expressions or types (e.g., an expression
3313 statement, "if" condition, etc.), because we could have expressions like:
3315 foo(f(g(h(args)))...)
3317 where "args" is a parameter pack. check_for_bare_parameter_packs
3318 should not be called for the subexpressions args, h(args),
3319 g(h(args)), or f(g(h(args))), because we would produce erroneous
3320 error messages.
3322 Returns TRUE and emits an error if there were bare parameter packs,
3323 returns FALSE otherwise. */
3324 bool
3326 {
3342 {
3345 {
3354 else
3359 else
3363 }
3366 }
3369 }
3371 /* Expand any parameter packs that occur in the template arguments in
3372 ARGS. */
3373 tree
3375 {
3381 /* First, determine if we need to expand anything, and the number of
3382 slots we'll need. */
3384 {
3389 {
3393 else
3395 }
3396 else
3397 {
3399 num_result_args++;
3400 }
3401 }
3403 /* If no expansion is necessary, we're done. */
3407 /* Expand arguments. */
3410 non_default_args_count =
3413 {
3416 {
3423 }
3424 else
3425 {
3428 }
3429 }
3433 }
3435 /* Checks if DECL shadows a template parameter.
3437 [temp.local]: A template-parameter shall not be redeclared within its
3438 scope (including nested scopes).
3440 Emits an error and returns TRUE if the DECL shadows a parameter,
3441 returns FALSE otherwise. */
3443 bool
3445 {
3446 tree olddecl;
3448 /* If we're not in a template, we can't possibly shadow a template
3449 parameter. */
3453 /* Figure out what we're shadowing. */
3458 /* If there's no previous binding for this name, we're not shadowing
3459 anything, let alone a template parameter. */
3463 /* If we're not shadowing a template parameter, we're done. Note
3464 that OLDDECL might be an OVERLOAD (or perhaps even an
3465 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3466 node. */
3470 /* We check for decl != olddecl to avoid bogus errors for using a
3471 name inside a class. We check TPFI to avoid duplicate errors for
3472 inline member templates. */
3480 }
3482 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3483 ORIG_LEVEL, DECL, and TYPE. */
3485 static tree
3489 tree decl,
3490 tree type)
3491 {
3502 }
3504 /* Find the canonical type parameter for the given template type
3505 parameter. Returns the canonical type parameter, which may be TYPE
3506 if no such parameter existed. */
3508 static tree
3510 {
3511 tree list;
3525 else
3526 {
3531 }
3532 }
3534 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3535 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3536 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3537 new one is created. */
3539 static tree
3541 tsubst_flags_t complain)
3542 {
3547 {
3566 /* Template template parameters need this. */
3571 }
3574 }
3576 /* Process information from new template parameter PARM and append it
3577 to the LIST being built. This new parameter is a non-type
3578 parameter iff IS_NON_TYPE is true. This new parameter is a
3579 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3580 is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template
3581 parameter list PARM belongs to. This is used used to create a
3582 proper canonical type for the type of PARM that is to be created,
3583 iff PARM is a type. If the size is not known, this parameter shall
3584 be set to 0. */
3586 tree
3589 {
3591 tree defval;
3592 tree err_parm_list;
3599 {
3603 {
3607 else
3609 }
3612 }
3613 else
3617 {
3623 {
3627 }
3628 else
3629 {
3630 /* [temp.param]
3632 The top-level cv-qualifiers on the template-parameter are
3633 ignored when determining its type. */
3636 {
3640 }
3643 {
3644 /* This template parameter is not a parameter pack, but it
3645 should be. Complain about "bare" parameter packs. */
3648 /* Recover by calling this a parameter pack. */
3650 }
3651 }
3653 /* A template parameter is not modifiable. */
3662 processing_template_decl,
3667 }
3668 else
3669 {
3670 tree t;
3674 {
3676 /* This is for distinguishing between real templates and template
3677 template parameters */
3681 }
3682 else
3683 {
3685 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3688 }
3695 processing_template_decl,
3699 }
3705 }
3707 /* The end of a template parameter list has been reached. Process the
3708 tree list into a parameter vector, converting each parameter into a more
3709 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3710 as PARM_DECLs. */
3712 tree
3714 {
3719 current_template_parms
3724 {
3728 }
3733 }
3735 /* end_template_decl is called after a template declaration is seen. */
3737 void
3739 {
3745 /* This matches the pushlevel in begin_template_parm_list. */
3750 }
3752 /* Takes a TREE_LIST representing a template parameter and convert it
3753 into an argument suitable to be passed to the type substitution
3754 functions. Note that If the TREE_LIST contains an error_mark
3755 node, the returned argument is error_mark_node. */
3757 static tree
3759 {
3772 {
3776 {
3777 /* Turn this argument into a TYPE_ARGUMENT_PACK
3778 with a single element, which expands T. */
3780 #ifdef ENABLE_CHECKING
3781 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3783 #endif
3788 }
3789 }
3790 else
3791 {
3795 {
3796 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3797 with a single element, which expands T. */
3800 #ifdef ENABLE_CHECKING
3801 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3803 #endif
3809 }
3810 }
3812 }
3814 /* This function returns TRUE if PARM_PACK is a template parameter
3815 pack and if ARG_PACK is what template_parm_to_arg returned when
3816 passed PARM_PACK. */
3818 static bool
3820 {
3821 /* For clarity in the comments below let's use the representation
3822 argument_pack<elements>' to denote an argument pack and its
3823 elements.
3825 In the 'if' block below, we want to detect cases where
3826 ARG_PACK is argument_pack<PARM_PACK...>. I.e, we want to
3827 check if ARG_PACK is an argument pack which sole element is
3828 the expansion of PARM_PACK. That argument pack is typically
3829 created by template_parm_to_arg when passed a parameter
3830 pack. */
3835 {
3840 /* The argument pack that the parameter maps to is just an
3841 expansion of the parameter itself, such as one would
3842 find in the implicit typedef of a class inside the
3843 class itself. Consider this parameter "unsubstituted",
3844 so that we will maintain the outer pack expansion. */
3846 }
3848 }
3850 /* Given a set of template parameters, return them as a set of template
3851 arguments. The template parameters are represented as a TREE_VEC, in
3852 the form documented in cp-tree.h for template arguments. */
3854 static tree
3856 {
3857 tree header;
3862 /* If there is only one level of template parameters, we do not
3863 create a TREE_VEC of TREE_VECs. Instead, we return a single
3864 TREE_VEC containing the arguments. */
3869 {
3877 #ifdef ENABLE_CHECKING
3879 #endif
3883 else
3885 }
3888 /* This can happen for template parms of a template template
3889 parameter, e.g:
3891 template<template<class T, class U> class TT> struct S;
3893 Consider the level of the parms of TT; T and U both have
3894 level 2; TT has no template parm of level 1. So in this case
3895 the first element of full_template_args is NULL_TREE. If we
3896 leave it like this TMPL_ARG_DEPTH on args returns 1 instead
3897 of 2. This will make tsubst wrongly consider that T and U
3898 have level 1. Instead, let's create a dummy vector as the
3899 first element of full_template_args so that TMPL_ARG_DEPTH
3900 returns the correct depth for args. */
3903 }
3905 /* Within the declaration of a template, return the currently active
3906 template parameters as an argument TREE_VEC. */
3908 static tree
3910 {
3912 }
3914 /* Update the declared TYPE by doing any lookups which were thought to be
3915 dependent, but are not now that we know the SCOPE of the declarator. */
3917 tree
3919 {
3930 /* Don't bother building up the args in this case. */
3932 {
3933 /* tsubst in the args corresponding to the template parameters,
3934 including auto if present. Most things will be unchanged, but
3935 make_typename_type and tsubst_qualified_id will resolve
3936 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3939 tree pushed;
3941 {
3945 }
3950 }
3956 {
3959 else
3961 }
3963 }
3965 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3966 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3967 a member template. Used by push_template_decl below. */
3969 static tree
3971 {
3979 }
3981 struct template_parm_data
3982 {
3983 /* The level of the template parameters we are currently
3984 processing. */
3987 /* The index of the specialization argument we are currently
3988 processing. */
3991 /* An array whose size is the number of template parameters. The
3992 elements are nonzero if the parameter has been used in any one
3993 of the arguments processed so far. */
3996 /* An array whose size is the number of template arguments. The
3997 elements are nonzero if the argument makes use of template
3998 parameters of this level. */
4000 };
4002 /* Subroutine of push_template_decl used to see if each template
4003 parameter in a partial specialization is used in the explicit
4004 argument list. If T is of the LEVEL given in DATA (which is
4005 treated as a template_parm_data*), then DATA->PARMS is marked
4006 appropriately. */
4008 static int
4010 {
4016 {
4019 }
4020 else
4021 {
4024 }
4027 {
4030 }
4032 /* Return zero so that for_each_template_parm will continue the
4033 traversal of the tree; we want to mark *every* template parm. */
4035 }
4037 /* Process the partial specialization DECL. */
4039 static tree
4041 {
4047 tree inner_parms;
4048 tree inst;
4061 /* We check that each of the template parameters given in the
4062 partial specialization is used in the argument list to the
4063 specialization. For example:
4065 template <class T> struct S;
4066 template <class T> struct S<T*>;
4068 The second declaration is OK because `T*' uses the template
4069 parameter T, whereas
4071 template <class T> struct S<int>;
4073 is no good. Even trickier is:
4075 template <class T>
4076 struct S1
4077 {
4078 template <class U>
4079 struct S2;
4080 template <class U>
4081 struct S2<T>;
4082 };
4084 The S2<T> declaration is actually invalid; it is a
4085 full-specialization. Of course,
4087 template <class U>
4088 struct S2<T (*)(U)>;
4090 or some such would have been OK. */
4098 {
4103 NULL,
4105 }
4108 {
4109 /* One of the template parms was not used in the
4110 specialization. */
4112 {
4115 }
4118 }
4123 /* [temp.class.spec]
4125 The argument list of the specialization shall not be identical to
4126 the implicit argument list of the primary template. */
4133 /* A partial specialization that replaces multiple parameters of the
4134 primary template with a pack expansion is less specialized for those
4135 parameters. */
4137 {
4139 "primary template because it replaces multiple parameters "
4143 }
4145 /* [temp.class.spec]
4147 A partially specialized non-type argument expression shall not
4148 involve template parameters of the partial specialization except
4149 when the argument expression is a simple identifier.
4151 The type of a template parameter corresponding to a specialized
4152 non-type argument shall not be dependent on a parameter of the
4153 specialization.
4155 Also, we verify that pack expansions only occur at the
4156 end of the argument list. */
4160 {
4167 {
4168 /* Extract the arguments from the argument pack. We'll be
4169 iterating over these in the following loop. */
4172 }
4175 {
4177 /* Get the Jth argument in the parameter pack. */
4181 {
4182 /* Pack expansions must come at the end of the
4183 argument list. */
4186 {
4190 else
4193 }
4194 }
4197 /* We only care about the pattern. */
4203 /* This next line is the `argument expression is not just a
4204 simple identifier' condition and also the `specialized
4205 non-type argument' bit. */
4207 {
4211 arg);
4212 else
4213 {
4214 /* Look at the corresponding template parameter,
4215 marking which template parameters its type depends
4216 upon. */
4220 {
4221 /* We haven't yet initialized TPD2. Do so now. */
4223 /* The number of parameters here is the number in the
4224 main template, which, as checked in the assertion
4225 above, is NARGS. */
4229 }
4231 /* Mark the template parameters. But this time, we're
4232 looking for the template parameters of the main
4233 template, not in the specialization. */
4240 NULL,
4244 {
4245 /* The type depended on some template parameters.
4246 If they are fully specialized in the
4247 specialization, that's OK. */
4256 "type %qT of template argument %qE depends "
4258 "type %qT of template argument %qE depends "
4260 type,
4261 arg);
4262 }
4263 }
4264 }
4265 }
4266 }
4268 /* We should only get here once. */
4278 {
4282 {
4286 "partial specialization of %qT after instantiation "
4288 }
4289 }
4292 }
4294 /* Check that a template declaration's use of default arguments and
4295 parameter packs is not invalid. Here, PARMS are the template
4296 parameters. IS_PRIMARY is true if DECL is the thing declared by
4297 a primary template. IS_PARTIAL is true if DECL is a partial
4298 specialization.
4300 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4301 declaration (but not a definition); 1 indicates a declaration, 2
4302 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4303 emitted for extraneous default arguments.
4305 Returns TRUE if there were no errors found, FALSE otherwise. */
4307 bool
4310 {
4313 tree parm_level;
4316 /* [temp.param]
4318 A default template-argument shall not be specified in a
4319 function template declaration or a function template definition, nor
4320 in the template-parameter-list of the definition of a member of a
4321 class template. */
4324 /* You can't have a function template declaration in a local
4325 scope, nor you can you define a member of a class template in a
4326 local scope. */
4333 /* If this is either a friend defined in the scope of the class
4334 or a member function. */
4340 /* And, if it was a member function, it really was defined in
4341 the scope of the class. */
4344 /* We already checked these parameters when the template was
4345 declared, so there's no need to do it again now. This function
4346 was defined in class scope, but we're processing it's body now
4347 that the class is complete. */
4350 /* Core issue 226 (C++0x only): the following only applies to class
4351 templates. */
4354 {
4355 /* [temp.param]
4357 If a template-parameter has a default template-argument, all
4358 subsequent template-parameters shall have a default
4359 template-argument supplied. */
4361 {
4368 {
4378 {
4380 /* For better subsequent error-recovery, we indicate that
4381 there should have been a default argument. */
4384 }
4386 && !is_friend_decl
4387 /* Don't complain about an enclosing partial
4388 specialization. */
4393 {
4394 /* A primary class template can only have one
4395 parameter pack, at the end of the template
4396 parameter list. */
4401 else
4409 }
4410 }
4411 }
4412 }
4415 || is_partial
4416 || !is_primary
4418 /* For an ordinary class template, default template arguments are
4419 allowed at the innermost level, e.g.:
4420 template <class T = int>
4421 struct S {};
4422 but, in a partial specialization, they're not allowed even
4423 there, as we have in [temp.class.spec]:
4425 The template parameter list of a specialization shall not
4426 contain default template argument values.
4428 So, for a partial specialization, or for a function template
4429 (in C++98/C++03), we look at all of them. */
4430 ;
4431 else
4432 /* But, for a primary class template that is not a partial
4433 specialization we look at all template parameters except the
4434 innermost ones. */
4437 /* Figure out what error message to issue. */
4450 else
4454 /* If we're inside a class definition, there's no need to
4455 examine the parameters to the class itself. On the one
4456 hand, they will be checked when the class is defined, and,
4457 on the other, default arguments are valid in things like:
4458 template <class T = double>
4459 struct S { template <class U> void f(U); };
4460 Here the default argument for `S' has no bearing on the
4461 declaration of `f'. */
4463 else
4464 /* Check everything. */
4470 {
4477 {
4482 {
4484 {
4491 }
4493 /* Clear out the default argument so that we are not
4494 confused later. */
4496 }
4497 }
4499 /* At this point, if we're still interested in issuing messages,
4500 they must apply to classes surrounding the object declared. */
4504 }
4507 }
4509 /* Worker for push_template_decl_real, called via
4510 for_each_template_parm. DATA is really an int, indicating the
4511 level of the parameters we are interested in. If T is a template
4512 parameter of that level, return nonzero. */
4514 static int
4516 {
4522 else
4525 }
4527 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4528 parameters given by current_template_args, or reuses a
4529 previously existing one, if appropriate. Returns the DECL, or an
4530 equivalent one, if it is replaced via a call to duplicate_decls.
4532 If IS_FRIEND is true, DECL is a friend declaration. */
4534 tree
4536 {
4537 tree tmpl;
4538 tree args;
4539 tree info;
4540 tree ctx;
4544 /* True if the template is a member template, in the sense of
4545 [temp.mem]. */
4551 /* See if this is a partial specialization. */
4560 /* For a friend, we want the context of the friend function, not
4561 the type of which it is a friend. */
4565 /* In the case of a virtual function, we want the class in which
4566 it is defined. */
4568 else
4569 /* Otherwise, if we're currently defining some class, the DECL
4570 is assumed to be a member of the class. */
4579 /* See if this is a primary template. */
4581 /* A friend template that specifies a class context, i.e.
4582 template <typename T> friend void A<T>::f();
4583 is not primary. */
4585 else
4589 {
4594 {
4597 }
4599 {
4601 {
4602 /* [temp.mem]
4604 A destructor shall not be a member template. */
4607 }
4614 {
4615 /* [basic.stc.dynamic.allocation]
4617 An allocation function can be a function
4618 template. ... Template allocation functions shall
4619 have two or more parameters. */
4622 }
4623 }
4629 /* alias-declaration */
4631 else
4632 {
4635 }
4636 }
4638 /* Check to see that the rules regarding the use of default
4639 arguments are not being violated. */
4643 /* Ensure that there are no parameter packs in the type of this
4644 declaration that have not been expanded. */
4646 {
4647 /* Check each of the arguments individually to see if there are
4648 any bare parameter packs. */
4654 {
4657 {
4658 /* This is a PARM_DECL that contains unexpanded parameter
4659 packs. We have already complained about this in the
4660 check_for_bare_parameter_packs call, so just replace
4661 these types with ERROR_MARK_NODE. */
4664 }
4668 }
4670 /* Check for bare parameter packs in the return type and the
4671 exception specifiers. */
4673 /* Errors were already issued, set return type to int
4674 as the frontend doesn't expect error_mark_node as
4675 the return type. */
4679 }
4684 {
4687 }
4698 {
4703 /* If DECL is a TYPE_DECL for a class-template, then there won't
4704 be DECL_LANG_SPECIFIC. The information equivalent to
4705 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4709 {
4710 /* Since a template declaration already existed for this
4711 class-type, we must be redeclaring it here. Make sure
4712 that the redeclaration is valid. */
4714 current_template_parms);
4715 /* We don't need to create a new TEMPLATE_DECL; just use the
4716 one we already had. */
4718 }
4719 else
4720 {
4722 member_template_p);
4727 {
4728 /* A specialization of a member template of a template
4729 class. */
4733 }
4734 }
4735 }
4736 else
4737 {
4743 {
4746 }
4754 {
4755 tree new_tmpl;
4757 /* The declaration is a specialization of a member
4758 template, declared outside the class. Therefore, the
4759 innermost template arguments will be NULL, so we
4760 replace them with the arguments determined by the
4761 earlier call to check_explicit_specialization. */
4764 new_tmpl
4766 member_template_p);
4776 args,
4779 }
4781 /* Make sure the template headers we got make sense. */
4786 {
4789 }
4790 else
4792 {
4797 {
4801 else
4806 }
4811 /* Can happen in erroneous input. */
4813 else
4817 }
4819 /* Check that the parms are used in the appropriate qualifying scopes
4820 in the declarator. */
4824 {
4830 /* Avoid crash in import_export_decl. */
4833 }
4834 }
4839 /* Push template declarations for global functions and types. Note
4840 that we do not try to push a global template friend declared in a
4841 template class; such a thing may well depend on the template
4842 parameters of the class. */
4845 {
4850 /* Hide template friend classes that haven't been declared yet. */
4852 {
4855 }
4856 }
4859 {
4865 {
4868 /* It is a conversion operator. See if the type converted to
4869 depends on innermost template operands. */
4872 depth))
4874 }
4876 /* Give template template parms a DECL_CONTEXT of the template
4877 for which they are a parameter. */
4880 {
4884 }
4885 }
4887 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4888 back to its most general template. If TMPL is a specialization,
4889 ARGS may only have the innermost set of arguments. Add the missing
4890 argument levels if necessary. */
4898 else
4899 {
4904 }
4907 }
4909 tree
4911 {
4913 }
4915 /* FN is an inheriting constructor that inherits from the constructor
4916 template INHERITED; turn FN into a constructor template with a matching
4917 template header. */
4919 tree
4921 {
4922 tree inner_parms
4925 tree parms
4936 }
4938 /* Called when a class template TYPE is redeclared with the indicated
4939 template PARMS, e.g.:
4941 template <class T> struct S;
4942 template <class T> struct S {}; */
4944 bool
4946 {
4947 tree tmpl;
4948 tree tmpl_parms;
4952 {
4955 }
4959 /* The type is nested in some template class. Nothing to worry
4960 about here; there are no new template parameters for the nested
4961 type. */
4965 {
4967 tmpl);
4969 }
4975 {
4985 }
4988 {
4989 tree tmpl_parm;
4990 tree parm;
4991 tree tmpl_default;
4992 tree parm_default;
5006 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5007 TEMPLATE_DECL. */
5017 {
5021 }
5024 {
5025 /* We have in [temp.param]:
5027 A template-parameter may not be given default arguments
5028 by two different declarations in the same scope. */
5033 }
5036 /* Update the previous template parameters (which are the ones
5037 that will really count) with the new default value. */
5040 /* Update the new parameters, too; they'll be used as the
5041 parameters for any members. */
5043 }
5046 }
5048 /* Simplify EXPR if it is a non-dependent expression. Returns the
5049 (possibly simplified) expression. */
5051 tree
5053 {
5057 /* If we're in a template, but EXPR isn't value dependent, simplify
5058 it. We're supposed to treat:
5060 template <typename T> void f(T[1 + 1]);
5061 template <typename T> void f(T[2]);
5063 as two declarations of the same function, for example. */
5068 {
5069 HOST_WIDE_INT saved_processing_template_decl;
5075 complain,
5080 }
5082 }
5084 tree
5086 {
5088 }
5090 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5091 template declaration, or a TYPE_DECL for an alias declaration. */
5093 bool
5095 {
5103 }
5105 /* Return TRUE iff is a specialization of an alias template. */
5107 bool
5109 {
5117 }
5119 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5120 must be a function or a pointer-to-function type, as specified
5121 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5122 and check that the resulting function has external linkage. */
5124 static tree
5126 {
5129 linkage_kind linkage;
5141 /* [temp.arg.nontype]/1
5143 A template-argument for a non-type, non-template template-parameter
5144 shall be one of:
5145 [...]
5146 -- the address of an object or function with external [C++11: or
5147 internal] linkage. */
5150 {
5155 else
5160 }
5163 }
5165 /* Subroutine of convert_nontype_argument.
5166 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5167 Emit an error otherwise. */
5169 static bool
5171 tsubst_flags_t complain)
5172 {
5179 {
5183 }
5185 }
5187 /* Returns TRUE iff the address of OP is value-dependent.
5189 14.6.2.4 [temp.dep.temp]:
5190 A non-integral non-type template-argument is dependent if its type is
5191 dependent or it has either of the following forms
5192 qualified-id
5193 & qualified-id
5194 and contains a nested-name-specifier which specifies a class-name that
5195 names a dependent type.
5197 We generalize this to just say that the address of a member of a
5198 dependent class is value-dependent; the above doesn't cover the
5199 address of a static data member named with an unqualified-id. */
5201 static bool
5203 {
5204 /* We could use get_inner_reference here, but there's no need;
5205 this is only relevant for template non-type arguments, which
5206 can only be expressed as &id-expression. */
5208 {
5212 }
5215 }
5217 /* The next set of functions are used for providing helpful explanatory
5218 diagnostics for failed overload resolution. Their messages should be
5219 indented by two spaces for consistency with the messages in
5220 call.c */
5222 static int
5224 {
5226 }
5228 static int
5230 {
5235 }
5237 static int
5239 {
5241 }
5243 static int
5245 {
5251 }
5253 static int
5255 {
5259 }
5261 static int
5263 {
5266 " template parameter %qD is not a parameter pack, but "
5270 }
5272 static int
5274 {
5277 " template argument %qE does not match "
5281 }
5283 static int
5285 {
5289 }
5291 static int
5293 {
5299 }
5301 static int
5303 {
5305 {
5310 else
5312 " deduced conflicting values for non-type parameter "
5314 }
5316 }
5318 static int
5320 {
5323 " variable-sized array type %qT is not "
5325 arg);
5327 }
5329 static int
5331 {
5335 arg);
5337 }
5339 static int
5341 {
5348 }
5350 static int
5352 {
5354 }
5356 static int
5358 {
5360 }
5362 static int
5365 {
5370 }
5372 static int
5375 {
5378 {
5386 }
5388 }
5390 static int
5392 {
5395 " template parameters of a template template argument are "
5398 }
5400 static int
5402 {
5408 }
5410 static int
5412 {
5417 }
5419 static int
5421 {
5425 arg);
5427 }
5429 /* Attempt to convert the non-type template parameter EXPR to the
5430 indicated TYPE. If the conversion is successful, return the
5431 converted value. If the conversion is unsuccessful, return
5432 NULL_TREE if we issued an error message, or error_mark_node if we
5433 did not. We issue error messages for out-and-out bad template
5434 parameters, but not simply because the conversion failed, since we
5435 might be just trying to do argument deduction. Both TYPE and EXPR
5436 must be non-dependent.
5438 The conversion follows the special rules described in
5439 [temp.arg.nontype], and it is much more strict than an implicit
5440 conversion.
5442 This function is called twice for each template argument (see
5443 lookup_template_class for a more accurate description of this
5444 problem). This means that we need to handle expressions which
5445 are not valid in a C++ source, but can be created from the
5446 first call (for instance, casts to perform conversions). These
5447 hacks can go away after we fix the double coercion problem. */
5449 static tree
5451 {
5452 tree expr_type;
5454 /* Detect immediately string literals as invalid non-type argument.
5455 This special-case is not needed for correctness (we would easily
5456 catch this later), but only to provide better diagnostic for this
5457 common user mistake. As suggested by DR 100, we do not mention
5458 linkage issues in the diagnostic as this is not the point. */
5459 /* FIXME we're making this OK. */
5461 {
5467 }
5469 /* Add the ADDR_EXPR now for the benefit of
5470 value_dependent_expression_p. */
5473 {
5477 }
5479 /* If we are in a template, EXPR may be non-dependent, but still
5480 have a syntactic, rather than semantic, form. For example, EXPR
5481 might be a SCOPE_REF, rather than the VAR_DECL to which the
5482 SCOPE_REF refers. Preserving the qualifying scope is necessary
5483 so that access checking can be performed when the template is
5484 instantiated -- but here we need the resolved form so that we can
5485 convert the argument. */
5496 else
5499 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5500 to a non-type argument of "nullptr". */
5504 /* In C++11, integral or enumeration non-type template arguments can be
5505 arbitrary constant expressions. Pointer and pointer to
5506 member arguments can be general constant expressions that evaluate
5507 to a null value, but otherwise still need to be of a specific form. */
5509 {
5511 /* A PTRMEM_CST is already constant, and a valid template
5512 argument for a parameter of pointer to member type, we just want
5513 to leave it in that form rather than lower it to a
5518 {
5523 }
5524 }
5526 /* HACK: Due to double coercion, we can get a
5527 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5528 which is the tree that we built on the first call (see
5529 below when coercing to reference to object or to reference to
5530 function). We just strip everything and get to the arg.
5531 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5532 for examples. */
5534 {
5540 {
5541 /* ??? Maybe we could use convert_from_reference here, but we
5542 would need to relax its constraints because the NOP_EXPR
5543 could actually change the type to something more cv-qualified,
5544 and this is not folded by convert_from_reference. */
5555 }
5556 }
5558 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5559 parameter is a pointer to object, through decay and
5560 qualification conversion. Let's strip everything. */
5562 {
5566 /* Skip the ADDR_EXPR only if it is part of the decay for
5567 an array. Otherwise, it is part of the original argument
5568 in the source code. */
5572 }
5574 /* [temp.arg.nontype]/5, bullet 1
5576 For a non-type template-parameter of integral or enumeration type,
5577 integral promotions (_conv.prom_) and integral conversions
5578 (_conv.integral_) are applied. */
5580 {
5589 /* Notice that there are constant expressions like '4 % 0' which
5590 do not fold into integer constants. */
5592 {
5594 {
5605 /* else cxx_constant_value complained but gave us
5606 a real constant, so go ahead. */
5608 }
5609 else
5611 }
5612 }
5613 /* [temp.arg.nontype]/5, bullet 2
5615 For a non-type template-parameter of type pointer to object,
5616 qualification conversions (_conv.qual_) and the array-to-pointer
5617 conversion (_conv.array_) are applied. */
5619 {
5620 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5622 A template-argument for a non-type, non-template template-parameter
5623 shall be one of: [...]
5625 -- the name of a non-type template-parameter;
5626 -- the address of an object or function with external linkage, [...]
5627 expressed as "& id-expression" where the & is optional if the name
5628 refers to a function or array, or if the corresponding
5629 template-parameter is a reference.
5631 Here, we do not care about functions, as they are invalid anyway
5632 for a parameter of type pointer-to-object. */
5635 /* Non-type template parameters are OK. */
5636 ;
5641 {
5643 {
5645 "because %qD is a variable, not the address of "
5649 }
5650 /* Other values, like integer constants, might be valid
5651 non-type arguments of some other type. */
5653 }
5654 else
5655 {
5656 tree decl;
5661 {
5666 }
5668 {
5673 }
5675 {
5680 }
5681 }
5690 }
5691 /* [temp.arg.nontype]/5, bullet 3
5693 For a non-type template-parameter of type reference to object, no
5694 conversions apply. The type referred to by the reference may be more
5695 cv-qualified than the (otherwise identical) type of the
5696 template-argument. The template-parameter is bound directly to the
5697 template-argument, which must be an lvalue. */
5699 {
5701 expr_type))
5705 {
5709 }
5712 {
5716 }
5718 /* [temp.arg.nontype]/1
5720 A template-argument for a non-type, non-template template-parameter
5721 shall be one of: [...]
5723 -- the address of an object or function with external linkage. */
5726 {
5729 {
5731 "because a reference variable does not have a constant "
5734 }
5735 }
5738 {
5743 }
5746 {
5751 }
5754 }
5755 /* [temp.arg.nontype]/5, bullet 4
5757 For a non-type template-parameter of type pointer to function, only
5758 the function-to-pointer conversion (_conv.func_) is applied. If the
5759 template-argument represents a set of overloaded functions (or a
5760 pointer to such), the matching function is selected from the set
5761 (_over.over_). */
5763 {
5764 /* If the argument is a template-id, we might not have enough
5765 context information to decay the pointer. */
5767 {
5771 }
5774 /* Null pointer values are OK in C++11. */
5782 {
5786 }
5787 }
5788 /* [temp.arg.nontype]/5, bullet 5
5790 For a non-type template-parameter of type reference to function, no
5791 conversions apply. If the template-argument represents a set of
5792 overloaded functions, the matching function is selected from the set
5793 (_over.over_). */
5795 {
5797 {
5802 }
5809 }
5810 /* [temp.arg.nontype]/5, bullet 6
5812 For a non-type template-parameter of type pointer to member function,
5813 no conversions apply. If the template-argument represents a set of
5814 overloaded member functions, the matching member function is selected
5815 from the set (_over.over_). */
5817 {
5822 /* [temp.arg.nontype] bullet 1 says the pointer to member
5823 expression must be a pointer-to-member constant. */
5827 /* There is no way to disable standard conversions in
5828 resolve_address_of_overloaded_function (called by
5829 instantiate_type). It is possible that the call succeeded by
5830 converting &B::I to &D::I (where B is a base of D), so we need
5831 to reject this conversion here.
5833 Actually, even if there was a way to disable standard conversions,
5834 it would still be better to reject them here so that we can
5835 provide a superior diagnostic. */
5837 {
5841 /* If we are just one standard conversion off, explain. */
5846 }
5847 }
5848 /* [temp.arg.nontype]/5, bullet 7
5850 For a non-type template-parameter of type pointer to data member,
5851 qualification conversions (_conv.qual_) are applied. */
5853 {
5854 /* [temp.arg.nontype] bullet 1 says the pointer to member
5855 expression must be a pointer-to-member constant. */
5862 }
5864 {
5866 {
5870 }
5872 }
5873 /* A template non-type parameter must be one of the above. */
5874 else
5877 /* Sanity check: did we actually convert the argument to the
5878 right type? */
5882 }
5884 /* Subroutine of coerce_template_template_parms, which returns 1 if
5885 PARM_PARM and ARG_PARM match using the rule for the template
5886 parameters of template template parameters. Both PARM and ARG are
5887 template parameters; the rest of the arguments are the same as for
5888 coerce_template_template_parms.
5889 */
5890 static int
5892 tree arg,
5893 tsubst_flags_t complain,
5894 tree in_decl,
5895 tree outer_args)
5896 {
5905 {
5907 /* We encounter instantiations of templates like
5908 template <template <template <class> class> class TT>
5909 class C; */
5910 {
5917 }
5918 /* Fall through. */
5923 /* Argument is a parameter pack but parameter is not. */
5928 /* The tsubst call is used to handle cases such as
5930 template <int> class C {};
5931 template <class T, template <T> class TT> class D {};
5932 D<int, C> d;
5934 i.e. the parameter list of TT depends on earlier parameters. */
5936 && !same_type_p
5943 /* Argument is a parameter pack but parameter is not. */
5950 }
5953 }
5956 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5957 template template parameters. Both PARM_PARMS and ARG_PARMS are
5958 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5959 or PARM_DECL.
5961 Consider the example:
5962 template <class T> class A;
5963 template<template <class U> class TT> class B;
5965 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5966 the parameters to A, and OUTER_ARGS contains A. */
5968 static int
5970 tree arg_parms,
5971 tsubst_flags_t complain,
5972 tree in_decl,
5973 tree outer_args)
5974 {
5985 /* Determine whether we have a parameter pack at the end of the
5986 template template parameter's template parameter list. */
5988 {
5995 {
6009 }
6010 }
6016 /* Check all of the template parameters except the parameter pack at
6017 the end (if any). */
6019 {
6028 outer_args))
6031 }
6034 {
6035 /* Check each of the template parameters in the template
6036 argument against the template parameter pack at the end of
6037 the template template parameter. */
6044 {
6051 outer_args))
6053 }
6054 }
6057 }
6059 /* Verifies that the deduced template arguments (in TARGS) for the
6060 template template parameters (in TPARMS) represent valid bindings,
6061 by comparing the template parameter list of each template argument
6062 to the template parameter list of its corresponding template
6063 template parameter, in accordance with DR150. This
6064 routine can only be called after all template arguments have been
6065 deduced. It will return TRUE if all of the template template
6066 parameter bindings are okay, FALSE otherwise. */
6067 bool
6069 {
6073 /* We're dealing with template parms in this process. */
6079 {
6084 {
6089 {
6090 /* Look inside the argument pack. */
6093 }
6096 {
6100 /* Extract the next argument from the argument
6101 pack. */
6105 /* Look at the pattern of the pack expansion. */
6108 /* Extract the template parameters from the template
6109 argument. */
6115 /* Verify that we can coerce the template template
6116 parameters from the template argument to the template
6117 parameter. This requires an exact match. */
6119 && !coerce_template_template_parms
6121 targ_parms,
6122 tf_none,
6123 tparm,
6124 targs))
6125 {
6128 }
6129 }
6130 }
6131 }
6133 out:
6137 }
6139 /* Since type attributes aren't mangled, we need to strip them from
6140 template type arguments. */
6142 static tree
6144 {
6145 tree mv;
6152 {
6157 }
6159 }
6161 /* Convert the indicated template ARG as necessary to match the
6162 indicated template PARM. Returns the converted ARG, or
6163 error_mark_node if the conversion was unsuccessful. Error and
6164 warning messages are issued under control of COMPLAIN. This
6165 conversion is for the Ith parameter in the parameter list. ARGS is
6166 the full set of template arguments deduced so far. */
6168 static tree
6170 tree arg,
6171 tree args,
6172 tsubst_flags_t complain,
6174 tree in_decl)
6175 {
6176 tree orig_arg;
6177 tree val;
6182 {
6183 /* The template argument was the name of some
6184 member function. That's usually
6185 invalid, but static members are OK. In any
6186 case, grab the underlying fields/functions
6187 and issue an error later if required. */
6190 }
6198 /* When determining whether an argument pack expansion is a template,
6199 look at the pattern. */
6203 /* Deal with an injected-class-name used as a template template arg. */
6205 {
6208 {
6218 }
6219 }
6221 is_tmpl_type =
6237 {
6239 {
6243 }
6246 "to refer to a type member of a template parameter, "
6251 typename_type,
6252 complain);
6255 }
6257 {
6259 {
6261 {
6271 else
6273 }
6274 }
6276 }
6278 {
6280 {
6286 else
6288 }
6290 }
6293 {
6295 {
6299 /* The number of argument required is not known yet.
6300 Just accept it for now. */
6302 else
6303 {
6305 tree argparm;
6311 args))
6312 {
6315 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6316 TEMPLATE_DECL. */
6318 {
6323 }
6324 }
6325 else
6326 {
6328 {
6334 }
6337 }
6338 }
6339 }
6340 else
6342 /* We only form one instance of each template specialization.
6343 Therefore, if we use a non-canonical variant (i.e., a
6344 typedef), any future messages referring to the type will use
6345 the typedef, which is confusing if those future uses do not
6346 themselves also use the typedef. */
6349 }
6350 else
6351 {
6358 {
6361 else
6362 {
6363 /* Not sure if this is reachable, but it doesn't hurt
6364 to be robust. */
6367 }
6368 }
6370 /* We used to call digest_init here. However, digest_init
6371 will report errors, which we don't want when complain
6372 is zero. More importantly, digest_init will try too
6373 hard to convert things: for example, `0' should not be
6374 converted to pointer type at this point according to
6375 the standard. Accepting this is not merely an
6376 extension, since deciding whether or not these
6377 conversions can occur is part of determining which
6378 function template to call, or whether a given explicit
6379 argument specification is valid. */
6381 else
6390 {
6391 /* Strip typedefs from the SCOPE_REF. */
6394 complain);
6397 }
6398 }
6401 }
6403 /* Coerces the remaining template arguments in INNER_ARGS (from
6404 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6405 Returns the coerced argument pack. PARM_IDX is the position of this
6406 parameter in the template parameter list. ARGS is the original
6407 template argument list. */
6408 static tree
6411 tree args,
6412 tree inner_args,
6414 tree new_args,
6416 tree in_decl,
6417 tsubst_flags_t complain)
6418 {
6421 tree packed_args;
6422 tree argument_pack;
6432 {
6433 /* When the template parameter is a non-type template
6434 parameter pack whose type uses parameter packs, we need
6435 to look at each of the template arguments
6436 separately. Build a vector of the types for these
6437 non-type template parameters in PACKED_TYPES. */
6438 tree expansion
6446 /* Check that we have the right number of arguments. */
6450 {
6451 int needed_parms
6456 }
6458 /* If we aren't able to check the actual arguments now
6459 (because they haven't been expanded yet), we can at least
6460 verify that all of the types used for the non-type
6461 template parameter pack are, in fact, valid for non-type
6462 template parameters. */
6465 {
6468 {
6472 }
6473 }
6474 }
6476 /* Convert the remaining arguments, which will be a part of the
6477 parameter pack "parm". */
6479 {
6484 {
6485 /* When we have a vector of types (corresponding to the
6486 non-type template parameter pack that uses parameter
6487 packs in its type, as mention above), and the
6488 argument is not an expansion (which expands to a
6489 currently unknown number of arguments), clone the
6490 parm and give it the next type in PACKED_TYPES. */
6494 }
6497 {
6500 }
6501 else
6504 in_decl);
6508 }
6513 else
6514 {
6519 }
6522 #ifdef ENABLE_CHECKING
6525 #endif
6527 }
6529 /* Returns true if the template argument vector ARGS contains
6530 any pack expansions, false otherwise. */
6532 static bool
6534 {
6541 }
6543 /* Convert all template arguments to their appropriate types, and
6544 return a vector containing the innermost resulting template
6545 arguments. If any error occurs, return error_mark_node. Error and
6546 warning messages are issued under control of COMPLAIN.
6548 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6549 for arguments not specified in ARGS. Otherwise, if
6550 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6551 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6552 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6553 ARGS. */
6555 static tree
6557 tree args,
6558 tree in_decl,
6559 tsubst_flags_t complain,
6562 {
6564 tree inner_args;
6565 tree new_args;
6566 tree new_inner_args;
6570 /* When used as a boolean value, indicates whether this is a
6571 variadic template parameter list. Since it's an int, we can also
6572 subtract it from nparms to get the number of non-variadic
6573 parameters. */
6582 /* Determine if there are any parameter packs. */
6584 {
6590 }
6593 /* If there are no parameters that follow a parameter pack, we need to
6594 expand any argument packs so that we can deduce a parameter pack from
6595 some non-packed args followed by an argument pack, as in variadic85.C.
6596 If there are such parameters, we need to leave argument packs intact
6597 so the arguments are assigned properly. This can happen when dealing
6598 with a nested class inside a partial specialization of a class
6599 template, as in variadic92.C, or when deducing a template parameter pack
6600 from a sub-declarator, as in variadic114.C. */
6607 && require_all_args
6609 && (!use_default_args
6612 {
6614 {
6616 {
6620 }
6621 else
6627 }
6630 }
6632 /* We need to evaluate the template arguments, even though this
6633 template-id may be nested within a "sizeof". */
6641 {
6642 tree arg;
6643 tree parm;
6645 /* Get the Ith template parameter. */
6649 {
6652 }
6654 /* Calculate the next argument. */
6657 else
6662 {
6663 /* All remaining arguments will be placed in the
6664 template parameter pack PARM. */
6670 /* Store this argument. */
6672 lost++;
6675 /* We are done with all of the arguments. */
6679 }
6681 {
6683 {
6684 /* We don't know how many args we have yet, just
6685 use the unconverted ones for now. */
6688 }
6689 }
6691 {
6692 /* There must be a default arg in this case. */
6695 /* The position of the first default template argument,
6696 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6697 Record that. */
6700 }
6701 else
6705 {
6708 }
6710 /* This only occurs if there was an error in the template
6711 parameter list itself (which we would already have
6712 reported) that we are trying to recover from, e.g., a class
6713 template with a parameter list such as
6714 template<typename..., typename>. */
6716 else
6722 lost++;
6724 }
6731 #ifdef ENABLE_CHECKING
6735 #endif
6738 }
6740 /* Returns 1 if template args OT and NT are equivalent. */
6742 static int
6744 {
6751 /* For member templates */
6760 {
6777 }
6779 {
6780 /* We get here probably because we are in the middle of substituting
6781 into the pattern of a pack expansion. In that case the
6782 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
6783 interested in. So we want to use the initial pack argument for
6784 the comparison. */
6789 }
6794 else
6796 }
6798 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
6799 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
6800 NEWARG_PTR with the offending arguments if they are non-NULL. */
6802 static int
6805 {
6818 {
6823 {
6829 }
6830 }
6832 }
6834 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
6835 of template arguments. Returns 0 otherwise. */
6837 int
6839 {
6841 }
6843 static void
6845 {
6855 /* We are called both from instantiate_decl, where we've already had a
6856 tinst_level pushed, and instantiate_template, where we haven't.
6857 Compensate. */
6868 else
6877 }
6880 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6881 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6882 documentation for TEMPLATE_ID_EXPR. */
6884 tree
6886 {
6887 tree type;
6895 {
6898 }
6901 {
6903 unknown_type_node,
6905 arglist);
6907 }
6914 }
6916 /* Within the scope of a template class S<T>, the name S gets bound
6917 (in build_self_reference) to a TYPE_DECL for the class, not a
6918 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6919 or one of its enclosing classes, and that type is a template,
6920 return the associated TEMPLATE_DECL. Otherwise, the original
6921 DECL is returned.
6923 Also handle the case when DECL is a TREE_LIST of ambiguous
6924 injected-class-names from different bases. */
6926 tree
6928 {
6932 /* DR 176: A lookup that finds an injected-class-name (10.2
6933 [class.member.lookup]) can result in an ambiguity in certain cases
6934 (for example, if it is found in more than one base class). If all of
6935 the injected-class-names that are found refer to specializations of
6936 the same class template, and if the name is followed by a
6937 template-argument-list, the reference refers to the class template
6938 itself and not a specialization thereof, and is not ambiguous. */
6940 {
6943 {
6949 }
6952 else
6954 }
6960 }
6962 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
6963 parameters, find the desired type.
6965 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
6967 IN_DECL, if non-NULL, is the template declaration we are trying to
6968 instantiate.
6970 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
6971 the class we are looking up.
6973 Issue error and warning messages under control of COMPLAIN.
6975 If the template class is really a local class in a template
6976 function, then the FUNCTION_CONTEXT is the function in which it is
6977 being instantiated.
6979 ??? Note that this function is currently called *twice* for each
6980 template-id: the first time from the parser, while creating the
6981 incomplete type (finish_template_type), and the second type during the
6982 real instantiation (instantiate_template_class). This is surely something
6983 that we want to avoid. It also causes some problems with argument
6984 coercion (see convert_nontype_argument for more information on this). */
6986 static tree
6989 {
6991 tree t;
6994 spec_entry elt;
6995 hashval_t hash;
6998 {
7002 else
7003 {
7010 }
7013 }
7015 {
7018 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7019 an implicit typename for the second A. Deal with it. */
7024 {
7027 }
7028 }
7031 {
7034 }
7038 {
7042 }
7044 /* Issue an error message if we didn't find a template. */
7046 {
7050 }
7053 /* Make sure it's a user visible template, if it was named by
7054 the user. */
7057 {
7059 {
7063 }
7065 }
7070 {
7071 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7072 template arguments */
7074 tree parm;
7075 tree arglist2;
7076 tree outer;
7080 /* Consider an example where a template template parameter declared as
7082 template <class T, class U = std::allocator<T> > class TT
7084 The template parameter level of T and U are one level larger than
7085 of TT. To proper process the default argument of U, say when an
7086 instantiation `TT<int>' is seen, we need to build the full
7087 arguments containing {int} as the innermost level. Outer levels,
7088 available when not appearing as default template argument, can be
7089 obtained from the arguments of the enclosing template.
7091 Suppose that TT is later substituted with std::vector. The above
7092 instantiation is `TT<int, std::allocator<T> >' with TT at
7093 level 1, and T at level 2, while the template arguments at level 1
7094 becomes {std::vector} and the inner level 2 is {int}. */
7100 /* This is an argument of the current template, so we haven't set
7101 DECL_CONTEXT yet. */
7108 complain,
7118 }
7119 else
7120 {
7122 tree gen_tmpl;
7123 tree type_decl;
7131 /* An error occured while building the template TEMPL, and a
7132 diagnostic has most certainly been emitted for that
7133 already. Let's propagate that error. */
7142 {
7143 /* We've been given an incomplete set of template arguments.
7144 For example, given:
7146 template <class T> struct S1 {
7147 template <class U> struct S2 {};
7148 template <class U> struct S2<U*> {};
7149 };
7151 we will be called with an ARGLIST of `U*', but the
7152 TEMPLATE will be `template <class T> template
7153 <class U> struct S1<T>::S2'. We must fill in the missing
7154 arguments. */
7155 arglist
7157 arglist);
7159 }
7161 /* Now we should have enough arguments. */
7164 /* From here on, we're only interested in the most general
7165 template. */
7167 /* Calculate the BOUND_ARGS. These will be the args that are
7168 actually tsubst'd into the definition to create the
7169 instantiation. */
7171 {
7172 /* We have multiple levels of arguments to coerce, at once. */
7182 {
7183 tree a;
7187 complain,
7190 else
7191 /* Outer levels should have already been coerced. */
7194 /* Don't process further if one of the levels fails. */
7196 {
7197 /* Restore the ARGLIST to its full size. */
7200 }
7204 /* We temporarily reduce the length of the ARGLIST so
7205 that coerce_template_parms will see only the arguments
7206 corresponding to the template parameters it is
7207 examining. */
7209 }
7211 /* Restore the ARGLIST to its full size. */
7215 }
7216 else
7217 arglist
7220 gen_tmpl,
7221 complain,
7226 /* We were unable to bind the arguments. */
7229 /* In the scope of a template class, explicit references to the
7230 template class refer to the type of the template, not any
7231 instantiation of it. For example, in:
7233 template <class T> class C { void f(C<T>); }
7235 the `C<T>' is just the same as `C'. Outside of the
7236 class, however, such a reference is an instantiation. */
7240 /* comp_template_args is expensive, check it last. */
7242 arglist))
7245 /* If we already have this specialization, return it. */
7257 /* If the deduced arguments are invalid, then the binding
7258 failed. */
7262 complain))
7269 {
7274 }
7284 /* Create the type. */
7286 {
7288 {
7294 }
7295 else
7296 {
7297 /* We don't want to call start_enum for this type, since
7298 the values for the enumeration constants may involve
7299 template parameters. And, no one should be interested
7300 in the enumeration constants for such a type. */
7303 }
7307 }
7309 {
7310 /* The user referred to a specialization of an alias
7311 template represented by GEN_TMPL.
7313 [temp.alias]/2 says:
7315 When a template-id refers to the specialization of an
7316 alias template, it is equivalent to the associated
7317 type obtained by substitution of its
7318 template-arguments for the template-parameters in the
7319 type-id of the alias template. */
7322 /* Note that the call above (by indirectly calling
7323 register_specialization in tsubst_decl) registers the
7324 TYPE_DECL representing the specialization of the alias
7325 template. So next time someone substitutes ARGLIST for
7326 the template parms into the alias template (GEN_TMPL),
7327 she'll get that TYPE_DECL back. */
7331 }
7333 {
7340 /* A local class. Make sure the decl gets registered properly. */
7345 /* This instantiation is another name for the primary
7346 template type. Set the TYPE_CANONICAL field
7347 appropriately. */
7350 /* Some of the template arguments require structural
7351 equality testing, so this template class requires
7352 structural equality testing. */
7354 }
7355 else
7358 /* If we called start_enum or pushtag above, this information
7359 will already be set up. */
7361 {
7368 }
7369 else
7373 {
7379 {
7382 }
7383 }
7385 /* Let's consider the explicit specialization of a member
7386 of a class template specialization that is implicitely instantiated,
7387 e.g.:
7388 template<class T>
7389 struct S
7390 {
7391 template<class U> struct M {}; //#0
7392 };
7394 template<>
7395 template<>
7396 struct S<int>::M<char> //#1
7397 {
7398 int i;
7399 };
7400 [temp.expl.spec]/4 says this is valid.
7402 In this case, when we write:
7403 S<int>::M<char> m;
7405 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7406 the one of #0.
7408 When we encounter #1, we want to store the partial instantiation
7409 of M (template<class T> S<int>::M<T>) in it's CLASSTYPE_TI_TEMPLATE.
7411 For all cases other than this "explicit specialization of member of a
7412 class template", we just want to store the most general template into
7413 the CLASSTYPE_TI_TEMPLATE of M.
7415 This case of "explicit specialization of member of a class template"
7416 only happens when:
7417 1/ the enclosing class is an instantiation of, and therefore not
7418 the same as, the context of the most general template, and
7419 2/ we aren't looking at the partial instantiation itself, i.e.
7420 the innermost arguments are not the same as the innermost parms of
7421 the most general template.
7423 So it's only when 1/ and 2/ happens that we want to use the partial
7424 instantiation of the member template in lieu of its most general
7425 template. */
7429 /* the enclosing class must be an instantiation... */
7432 {
7433 tree partial_inst_args;
7436 partial_inst_args =
7442 use_partial_inst_tmpl =
7443 /*...and we must not be looking at the partial instantiation
7444 itself. */
7446 partial_inst_args);
7447 }
7450 /* This case is easy; there are no member templates involved. */
7452 else
7453 {
7454 /* This is a full instantiation of a member template. Find
7455 the partial instantiation of which this is an instance. */
7457 /* Temporarily reduce by one the number of levels in the ARGLIST
7458 so as to avoid comparing the last set of arguments. */
7462 /* FOUND is either a proper class type, or an alias
7463 template specialization. In the later case, it's a
7464 TYPE_DECL, resulting from the substituting of arguments
7465 for parameters in the TYPE_DECL of the alias template
7466 done earlier. So be careful while getting the template
7467 of FOUND. */
7471 }
7482 /* Note this use of the partial instantiation so we can check it
7483 later in maybe_process_partial_specialization. */
7489 /* Now that the type has been registered on the instantiations
7490 list, we set up the enumerators. Because the enumeration
7491 constants may involve the enumeration type itself, we make
7492 sure to register the type first, and then create the
7493 constants. That way, doing tsubst_expr for the enumeration
7494 constants won't result in recursive calls here; we'll find
7495 the instantiation and exit above. */
7499 /* If the type makes use of template parameters, the
7500 code that generates debugging information will crash. */
7503 /* Possibly limit visibility based on template args. */
7508 }
7509 }
7511 /* Wrapper for lookup_template_class_1. */
7513 tree
7516 {
7517 tree ret;
7523 }
7524 \f
7525 struct pair_fn_data
7526 {
7527 tree_fn_t fn;
7529 /* True when we should also visit template parameters that occur in
7530 non-deduced contexts. */
7533 };
7535 /* Called from for_each_template_parm via walk_tree. */
7537 static tree
7539 {
7552 {
7556 /* Fall through. */
7579 /* Since we're not going to walk subtrees, we have to do this
7580 explicitly here. */
7584 /* Fall through. */
7587 /* Check the return type. */
7592 /* Check the parameter types. Since default arguments are not
7593 instantiated until they are needed, the TYPE_ARG_TYPES may
7594 contain expressions that involve template parameters. But,
7595 no-one should be looking at them yet. And, once they're
7596 instantiated, they don't contain template parameters, so
7597 there's no point in looking at them then, either. */
7598 {
7599 tree parm;
7606 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7607 want walk_tree walking into them itself. */
7609 }
7627 /* Fall through. */
7643 /* Record template parameters such as `T' inside `TT<T>'. */
7647 /* Fall through. */
7659 /* A template template parameter is encountered. */
7665 /* Already substituted template template parameter */
7688 /* If there's no type, then this thing must be some expression
7689 involving template parameters. */
7711 }
7713 /* We didn't find any template parameters we liked. */
7715 }
7717 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
7718 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
7719 call FN with the parameter and the DATA.
7720 If FN returns nonzero, the iteration is terminated, and
7721 for_each_template_parm returns 1. Otherwise, the iteration
7722 continues. If FN never returns a nonzero value, the value
7723 returned by for_each_template_parm is 0. If FN is NULL, it is
7724 considered to be the function which always returns 1.
7726 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
7727 parameters that occur in non-deduced contexts. When false, only
7728 visits those template parameters that can be deduced. */
7730 static int
7734 {
7738 /* Set up. */
7743 /* Walk the tree. (Conceptually, we would like to walk without
7744 duplicates, but for_each_template_parm_r recursively calls
7745 for_each_template_parm, so we would need to reorganize a fair
7746 bit to use walk_tree_without_duplicates, so we keep our own
7747 visited list.) */
7750 else
7753 for_each_template_parm_r,
7757 /* Clean up. */
7759 {
7762 }
7765 }
7767 /* Returns true if T depends on any template parameter. */
7769 int
7771 {
7798 else
7799 {
7802 }
7807 }
7809 /* Returns true iff current_function_decl is an incompletely instantiated
7810 template. Useful instead of processing_template_decl because the latter
7811 is set to 0 during fold_non_dependent_expr. */
7813 bool
7815 {
7824 }
7826 /* Returns true if T depends on any template parameter with level LEVEL. */
7828 int
7830 {
7833 }
7835 /* Returns TRUE iff INST is an instantiation we don't need to do in an
7836 ill-formed translation unit, i.e. a variable or function that isn't
7837 usable in a constant expression. */
7841 {
7845 }
7847 /* Returns TRUE iff we should refuse to instantiate DECL because it's
7848 neglectable and instantiated from within an erroneous instantiation. */
7850 static bool
7852 {
7863 }
7871 /* We're starting to instantiate D; record the template instantiation context
7872 for diagnostics and to restore it later. */
7874 int
7876 {
7880 {
7886 else
7894 }
7896 /* If the current instantiation caused problems, don't let it instantiate
7897 anything else. Do allow deduction substitution and decls usable in
7898 constant expressions. */
7915 }
7917 /* We're done instantiating this template; return to the instantiation
7918 context. */
7920 void
7922 {
7923 /* Restore the filename and line number stashed away when we started
7924 this instantiation. */
7928 }
7930 /* We're instantiating a deferred template; restore the template
7931 instantiation context in which the instantiation was requested, which
7932 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
7934 static tree
7936 {
7948 }
7950 /* Returns the TINST_LEVEL which gives the original instantiation
7951 context. */
7955 {
7961 }
7963 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
7964 vector of template arguments, as for tsubst.
7966 Returns an appropriate tsubst'd friend declaration. */
7968 static tree
7970 {
7971 tree new_friend;
7976 /* This was a friend declared with an explicit template
7977 argument list, e.g.:
7979 friend void f<>(T);
7981 to indicate that f was a template instantiation, not a new
7982 function declaration. Now, we have to figure out what
7983 instantiation of what template. */
7984 {
7986 tree new_args;
7987 tree tmpl;
7990 /* Friend functions are looked up in the containing namespace scope.
7991 We must enter that scope, to avoid finding member functions of the
7992 current class with same name. */
8007 tsk_none);
8009 }
8013 /* The NEW_FRIEND will look like an instantiation, to the
8014 compiler, but is not an instantiation from the point of view of
8015 the language. For example, we might have had:
8017 template <class T> struct S {
8018 template <class U> friend void f(T, U);
8019 };
8021 Then, in S<int>, template <class U> void f(int, U) is not an
8022 instantiation of anything. */
8028 {
8032 }
8034 /* The mangled name for the NEW_FRIEND is incorrect. The function
8035 is not a template instantiation and should not be mangled like
8036 one. Therefore, we forget the mangling here; we'll recompute it
8037 later if we need it. */
8039 {
8042 }
8045 {
8046 tree old_decl;
8047 tree new_friend_template_info;
8048 tree new_friend_result_template_info;
8049 tree ns;
8052 /* We must save some information from NEW_FRIEND before calling
8053 duplicate decls since that function will free NEW_FRIEND if
8054 possible. */
8056 new_friend_is_defn =
8061 {
8062 /* This declaration is a `primary' template. */
8065 new_friend_result_template_info
8067 }
8068 else
8071 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8075 /* Inside pushdecl_namespace_level, we will push into the
8076 current namespace. However, the friend function should go
8077 into the namespace of the template. */
8087 {
8088 /* This new friend declaration matched an existing
8089 declaration. For example, given:
8091 template <class T> void f(T);
8092 template <class U> class C {
8093 template <class T> friend void f(T) {}
8094 };
8096 the friend declaration actually provides the definition
8097 of `f', once C has been instantiated for some type. So,
8098 old_decl will be the out-of-class template declaration,
8099 while new_friend is the in-class definition.
8101 But, if `f' was called before this point, the
8102 instantiation of `f' will have DECL_TI_ARGS corresponding
8103 to `T' but not to `U', references to which might appear
8104 in the definition of `f'. Previously, the most general
8105 template for an instantiation of `f' was the out-of-class
8106 version; now it is the in-class version. Therefore, we
8107 run through all specialization of `f', adding to their
8108 DECL_TI_ARGS appropriately. In particular, they need a
8109 new set of outer arguments, corresponding to the
8110 arguments for this class instantiation.
8112 The same situation can arise with something like this:
8114 friend void f(int);
8115 template <class T> class C {
8116 friend void f(T) {}
8117 };
8119 when `C<int>' is instantiated. Now, `f(int)' is defined
8120 in the class. */
8123 /* On the other hand, if the in-class declaration does
8124 *not* provide a definition, then we don't want to alter
8125 existing definitions. We can just leave everything
8126 alone. */
8127 ;
8128 else
8129 {
8133 /* Overwrite whatever template info was there before, if
8134 any, with the new template information pertaining to
8135 the declaration. */
8139 {
8140 /* We should have called reregister_specialization in
8141 duplicate_decls. */
8146 /* Instantiate it if the global has already been used. */
8150 }
8151 else
8152 {
8153 tree t;
8155 /* Indicate that the old function template is a partial
8156 instantiation. */
8164 /* Reassign any specializations already in the hash table
8165 to the new more general template, and add the
8166 additional template args. */
8170 {
8172 spec_entry elt;
8184 register_specialization
8187 }
8189 }
8190 }
8192 /* The information from NEW_FRIEND has been merged into OLD_DECL
8193 by duplicate_decls. */
8195 }
8196 }
8197 else
8198 {
8202 /* In the code
8203 template <class T> class C {
8204 template <class U> friend void C1<U>::f (); // case 1
8205 friend void C2<T>::f (); // case 2
8206 };
8207 we only need to make sure CONTEXT is a complete type for
8208 case 2. To distinguish between the two cases, we note that
8209 CONTEXT of case 1 remains dependent type after tsubst while
8210 this isn't true for case 2. */
8220 {
8221 /* Check to see that the declaration is really present, and,
8222 possibly obtain an improved declaration. */
8228 }
8229 }
8232 }
8234 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8235 template arguments, as for tsubst.
8237 Returns an appropriate tsubst'd friend type or error_mark_node on
8238 failure. */
8240 static tree
8242 {
8243 tree friend_type;
8244 tree tmpl;
8245 tree context;
8248 {
8251 }
8256 {
8259 else
8261 }
8263 /* Look for a class template declaration. We look for hidden names
8264 because two friend declarations of the same template are the
8265 same. For example, in:
8267 struct A {
8268 template <typename> friend class F;
8269 };
8270 template <typename> struct B {
8271 template <typename> friend class F;
8272 };
8274 both F templates are the same. */
8278 /* But, if we don't find one, it might be because we're in a
8279 situation like this:
8281 template <class T>
8282 struct S {
8283 template <class U>
8284 friend struct S;
8285 };
8287 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8288 for `S<int>', not the TEMPLATE_DECL. */
8290 {
8293 }
8296 {
8297 /* The friend template has already been declared. Just
8298 check to see that the declarations match, and install any new
8299 default parameters. We must tsubst the default parameters,
8300 of course. We only need the innermost template parameters
8301 because that is all that redeclare_class_template will look
8302 at. */
8305 {
8306 tree parms;
8307 location_t saved_input_location;
8316 }
8319 }
8320 else
8321 {
8322 /* The friend template has not already been declared. In this
8323 case, the instantiation of the template class will cause the
8324 injection of this template into the global scope. */
8329 /* The new TMPL is not an instantiation of anything, so we
8330 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8331 the new type because that is supposed to be the corresponding
8332 template decl, i.e., TMPL. */
8339 /* Inject this template into the global scope. */
8341 }
8344 {
8347 else
8349 }
8352 }
8354 /* Returns zero if TYPE cannot be completed later due to circularity.
8355 Otherwise returns one. */
8357 static int
8359 {
8369 else
8371 }
8373 /* Apply any attributes which had to be deferred until instantiation
8374 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8375 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8377 static void
8380 {
8382 tree t;
8387 {
8391 }
8394 {
8398 }
8399 else
8403 {
8408 {
8411 {
8414 /* If the first attribute argument is an identifier, don't
8415 pass it through tsubst. Attributes like mode, format,
8416 cleanup and several target specific attributes expect it
8417 unmodified. */
8423 {
8424 tree chain
8426 in_decl,
8431 chain);
8432 }
8433 else
8439 }
8440 else
8442 }
8445 }
8446 }
8448 /* Perform (or defer) access check for typedefs that were referenced
8449 from within the template TMPL code.
8450 This is a subroutine of instantiate_decl and instantiate_class_template.
8451 TMPL is the template to consider and TARGS is the list of arguments of
8452 that template. */
8454 static void
8456 {
8457 location_t saved_location;
8470 {
8482 /* Make access check error messages point to the location
8483 of the use of the typedef. */
8487 tf_warning_or_error);
8488 }
8490 }
8492 static tree
8494 {
8496 tree typedecl;
8497 tree pbinfo;
8498 tree base_list;
8500 tree fn_context;
8509 /* Figure out which template is being instantiated. */
8513 /* Determine what specialization of the original template to
8514 instantiate. */
8517 {
8520 }
8522 {
8523 /* This TYPE is actually an instantiation of a partial
8524 specialization. We replace the innermost set of ARGS with
8525 the arguments appropriate for substitution. For example,
8526 given:
8528 template <class T> struct S {};
8529 template <class T> struct S<T*> {};
8531 and supposing that we are instantiating S<int*>, ARGS will
8532 presently be {int*} -- but we need {int}. */
8535 }
8536 else
8537 {
8540 }
8542 /* If the template we're instantiating is incomplete, then clearly
8543 there's nothing we can do. */
8547 /* If we've recursively instantiated too many templates, stop. */
8551 /* Now we're really doing the instantiation. Mark the type as in
8552 the process of being defined. */
8555 /* We may be in the middle of deferred access check. Disable
8556 it now. */
8562 /* Use #pragma pack from the template context. */
8568 /* Set the input location to the most specialized template definition.
8569 This is needed if tsubsting causes an error. */
8581 {
8584 /* Adjust visibility for template arguments. */
8586 }
8591 /* We should never instantiate a nested class before its enclosing
8592 class; we need to look up the nested class by name before we can
8593 instantiate it, and that lookup should instantiate the enclosing
8594 class. */
8600 {
8601 tree pbase_binfo;
8602 tree pushed_scope;
8605 /* We must enter the scope containing the type, as that is where
8606 the accessibility of types named in dependent bases are
8607 looked up from. */
8610 /* Substitute into each of the bases to determine the actual
8611 basetypes. */
8613 {
8614 tree base;
8620 {
8621 expanded_bases =
8628 }
8631 {
8633 /* Extract the already-expanded base class. */
8635 else
8636 /* Substitute to figure out the base class. */
8638 NULL_TREE);
8646 }
8647 }
8649 /* The list is now in reverse order; correct that. */
8654 }
8655 /* Now call xref_basetypes to set up all the base-class
8656 information. */
8664 /* Now that our base classes are set up, enter the scope of the
8665 class, so that name lookups into base classes, etc. will work
8666 correctly. This is precisely analogous to what we do in
8667 begin_class_definition when defining an ordinary non-template
8668 class, except we also need to push the enclosing classes. */
8671 /* Now members are processed in the order of declaration. */
8674 {
8678 {
8680 {
8681 /* Build new CLASSTYPE_NESTED_UTDS. */
8683 tree newtag;
8689 /* If the member is a class template, then -- even after
8690 substitution -- there may be dependent types in the
8691 template argument list for the class. We increment
8692 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
8693 that function will assume that no types are dependent
8694 when outside of a template. */
8704 {
8708 /* Unfortunately, lookup_template_class sets
8709 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
8710 instantiation (i.e., for the type of a member
8711 template class nested within a template class.)
8712 This behavior is required for
8713 maybe_process_partial_specialization to work
8714 correctly, but is not accurate in this case;
8715 the TAG is not an instantiation of anything.
8716 (The corresponding TEMPLATE_DECL is an
8717 instantiation, but the TYPE is not.) */
8720 /* Now, we call pushtag to put this NEWTAG into the scope of
8721 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
8722 pushtag calling push_template_decl. We don't have to do
8723 this for enums because it will already have been done in
8724 tsubst_enum. */
8728 }
8729 }
8732 {
8733 /* Build new TYPE_METHODS. */
8734 tree r;
8743 /* Instantiate members marked with attribute used. */
8746 }
8747 else
8748 {
8749 /* Build new TYPE_FIELDS. */
8751 {
8752 tree condition;
8755 condition =
8765 }
8767 {
8768 tree r;
8770 /* The file and line for this declaration, to
8771 assist in error message reporting. Since we
8772 called push_tinst_level above, we don't need to
8773 restore these. */
8782 {
8783 /* In [temp.inst]:
8785 [t]he initialization (and any associated
8786 side-effects) of a static data member does
8787 not occur unless the static data member is
8788 itself used in a way that requires the
8789 definition of the static data member to
8790 exist.
8792 Therefore, we do not substitute into the
8793 initialized for the static data member here. */
8794 finish_static_data_member_decl
8800 /* Instantiate members marked with attribute used. */
8803 }
8805 {
8806 /* Determine whether R has a valid type and can be
8807 completed later. If R is invalid, then it is
8808 replaced by error_mark_node so that it will not be
8809 added to TYPE_FIELDS. */
8815 {
8818 }
8819 }
8821 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
8822 such a thing will already have been added to the field
8823 list by tsubst_enum in finish_member_declaration in the
8824 CLASSTYPE_NESTED_UTDS case above. */
8828 {
8831 }
8832 }
8833 }
8834 }
8835 else
8836 {
8839 {
8840 /* Build new CLASSTYPE_FRIEND_CLASSES. */
8846 {
8847 /* template <class T> friend class C; */
8850 }
8852 {
8853 /* template <class T> friend class C::D; */
8859 }
8862 {
8863 /* This could be either
8865 friend class T::C;
8867 when dependent_type_p is false or
8869 template <class U> friend class T::C;
8871 otherwise. */
8874 /* Bump processing_template_decl for correct
8875 dependent_type_p calculation. */
8880 }
8883 {
8884 /* friend class C;
8886 where C hasn't been declared yet. Let's lookup name
8887 from namespace scope directly, bypassing any name that
8888 come from dependent base class. */
8891 /* The call to xref_tag_from_type does injection for friend
8892 classes. */
8894 friend_type =
8898 }
8900 /* friend class C<T>; */
8903 /* Otherwise it's
8905 friend class C;
8907 where C is already declared or
8909 friend class C<int>;
8911 We don't have to do anything in these cases. */
8914 /* Trick make_friend_class into realizing that the friend
8915 we're adding is a template, not an ordinary class. It's
8916 important that we use make_friend_class since it will
8917 perform some error-checking and output cross-reference
8918 information. */
8926 }
8927 else
8928 {
8929 /* Build new DECL_FRIENDLIST. */
8930 tree r;
8932 /* The file and line for this declaration, to
8933 assist in error message reporting. Since we
8934 called push_tinst_level above, we don't need to
8935 restore these. */
8939 {
8942 }
8947 {
8950 }
8951 }
8952 }
8953 }
8956 {
8959 {
8968 }
8969 else
8971 }
8973 /* Set the file and line number information to whatever is given for
8974 the class itself. This puts error messages involving generated
8975 implicit functions at a predictable point, and the same point
8976 that would be used for non-template classes. */
8983 /* We don't instantiate default arguments for member functions. 14.7.1:
8985 The implicit instantiation of a class template specialization causes
8986 the implicit instantiation of the declarations, but not of the
8987 definitions or default arguments, of the class member functions,
8988 member classes, static data members and member templates.... */
8990 /* Some typedefs referenced from within the template code need to be access
8991 checked at template instantiation time, i.e now. These types were
8992 added to the template at parsing time. Let's get those and perform
8993 the access checks then. */
9003 /* The vtable for a template class can be emitted in any translation
9004 unit in which the class is instantiated. When there is no key
9005 method, however, finish_struct_1 will already have added TYPE to
9006 the keyed_classes list. */
9011 }
9013 /* Wrapper for instantiate_class_template_1. */
9015 tree
9017 {
9018 tree ret;
9023 }
9025 static tree
9027 {
9028 tree r;
9034 else
9035 {
9042 /* Preserve the raw-reference nature of T. */
9046 }
9048 }
9050 /* Given a function parameter pack TMPL_PARM and some function parameters
9051 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9052 and set *SPEC_P to point at the next point in the list. */
9054 static tree
9056 {
9057 /* Collect all of the extra "packed" parameters into an
9058 argument pack. */
9059 tree parmvec;
9060 tree parmtypevec;
9071 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9076 {
9079 }
9081 /* Build the argument packs. */
9088 }
9090 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9091 NONTYPE_ARGUMENT_PACK. */
9093 static tree
9095 {
9097 }
9099 /* Substitute ARGS into T, which is an pack expansion
9100 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9101 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9102 (if only a partial substitution could be performed) or
9103 ERROR_MARK_NODE if there was an error. */
9104 tree
9106 tree in_decl)
9107 {
9108 tree pattern;
9114 tree result;
9122 /* Add in any args remembered from an earlier partial instantiation. */
9127 /* Determine the argument packs that will instantiate the parameter
9128 packs used in the expansion expression. While we're at it,
9129 compute the number of arguments to be expanded and make sure it
9130 is consistent. */
9133 {
9140 {
9144 else
9147 }
9149 {
9152 else
9153 {
9154 /* We can't rely on local_specializations for a parameter
9155 name used later in a function declaration (such as in a
9156 late-specified return type). Even if it exists, it might
9157 have the wrong value for a recursive call. Just make a
9158 dummy decl, since it's only used for its type. */
9161 /* Partial instantiation of the parm_pack, we can't build
9162 up an argument pack yet. */
9164 else
9167 }
9168 }
9169 else
9170 {
9176 }
9183 /* This can only happen if we forget to expand an argument
9184 pack somewhere else. Just return an error, silently. */
9185 {
9189 }
9192 /* The argument pack that the parameter maps to is just an
9193 expansion of the parameter itself, such as one would find
9194 in the implicit typedef of a class inside the class itself.
9195 Consider this parameter "unsubstituted", so that we will
9196 maintain the outer pack expansion. */
9200 {
9204 /* Don't bother trying to do a partial substitution with
9205 incomplete packs; we'll try again after deduction. */
9212 {
9218 pattern);
9219 else
9222 pattern);
9224 }
9230 else
9233 /* Keep track of the parameter packs and their corresponding
9234 argument packs. */
9237 }
9238 else
9239 {
9240 /* We can't substitute for this parameter pack. We use a flag as
9241 well as the missing_level counter because function parameter
9242 packs don't have a level. */
9246 }
9247 }
9249 /* We cannot expand this expansion expression, because we don't have
9250 all of the argument packs we need. */
9252 {
9254 {
9255 /* We got some full packs, but we can't substitute them in until we
9256 have values for all the packs. So remember these until then. */
9257 tree save_args;
9261 /* The call to add_to_template_args above assumes no overlap
9262 between saved args and new args, so prune away any fake
9263 args, i.e. those that satisfied arg_from_parm_pack_p above. */
9265 {
9271 }
9272 else
9276 }
9277 else
9278 {
9279 /* There were no real arguments, we're just replacing a parameter
9280 pack with another version of itself. Substitute into the
9281 pattern and return a PACK_EXPANSION_*. The caller will need to
9282 deal with that. */
9286 else
9289 }
9291 }
9293 /* We could not find any argument packs that work. */
9298 {
9299 /* We're in a late-specified return type, so create our own local
9300 specializations map; the current map is either NULL or (in the
9301 case of recursive unification) might have bindings that we don't
9302 want to use or alter. */
9305 }
9307 /* For each argument in each argument pack, substitute into the
9308 pattern. */
9311 {
9312 /* For parameter pack, change the substitution of the parameter
9313 pack to the ith argument in its argument pack, then expand
9314 the pattern. */
9316 {
9318 tree arg;
9320 /* Select the Ith argument from the pack. */
9322 {
9324 {
9329 }
9330 else
9332 }
9333 else
9334 {
9339 {
9342 /* Update the corresponding argument. */
9344 }
9345 else
9346 /* Re-use the ARGUMENT_PACK_SELECT. */
9348 }
9350 }
9352 /* Substitute into the PATTERN with the altered arguments. */
9357 else
9361 {
9364 }
9365 }
9367 /* Update ARGS to restore the substitution from parameter packs to
9368 their argument packs. */
9370 {
9375 else
9376 {
9380 /* Update the corresponding argument. */
9384 else
9386 }
9387 }
9390 {
9393 }
9396 }
9398 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9399 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9400 parameter packs; all parms generated from a function parameter pack will
9401 have the same DECL_PARM_INDEX. */
9403 tree
9405 {
9407 tree patparm;
9410 {
9416 }
9417 else
9418 {
9423 }
9426 }
9428 /* Substitute ARGS into the vector or list of template arguments T. */
9430 static tree
9432 {
9444 {
9446 tree new_arg;
9451 {
9452 /* Substitute into an expansion expression. */
9456 /* Add to the expanded length adjustment the number of
9457 expanded arguments. We subtract one from this
9458 measurement, because the argument pack expression
9459 itself is already counted as 1 in
9460 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9461 the argument pack is empty. */
9463 }
9465 {
9466 /* Substitute into each of the arguments. */
9472 new_arg,
9486 }
9487 }
9488 else
9497 }
9502 /* Make space for the expanded arguments coming from template
9503 argument packs. */
9505 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
9506 arguments for a member template.
9507 In that case each TREE_VEC in ORIG_T represents a level of template
9508 arguments, and ORIG_T won't carry any non defaulted argument count.
9509 It will rather be the nested TREE_VECs that will carry one.
9510 In other words, ORIG_T carries a non defaulted argument count only
9511 if it doesn't contain any nested TREE_VEC. */
9513 {
9517 }
9519 {
9523 {
9526 /* Now expand the template argument pack "in place". */
9529 }
9530 else
9531 {
9533 out++;
9534 }
9535 }
9538 }
9540 /* Return the result of substituting ARGS into the template parameters
9541 given by PARMS. If there are m levels of ARGS and m + n levels of
9542 PARMS, then the result will contain n levels of PARMS. For
9543 example, if PARMS is `template <class T> template <class U>
9544 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
9545 result will be `template <int*, double, class V>'. */
9547 static tree
9549 {
9553 /* When substituting into a template, we must set
9554 PROCESSING_TEMPLATE_DECL as the template parameters may be
9555 dependent if they are based on one-another, and the dependency
9556 predicates are short-circuit outside of templates. */
9563 {
9564 tree new_vec =
9569 {
9570 tree tuple;
9582 }
9588 }
9593 }
9595 /* Return the result of substituting ARGS into one template parameter
9596 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
9597 parameter and which TREE_PURPOSE is the default argument of the
9598 template parameter. */
9600 static tree
9602 {
9623 }
9625 /* Substitute the ARGS into the indicated aggregate (or enumeration)
9626 type T. If T is not an aggregate or enumeration type, it is
9627 handled as if by tsubst. IN_DECL is as for tsubst. If
9628 ENTERING_SCOPE is nonzero, T is the context for a template which
9629 we are presently tsubst'ing. Return the substituted value. */
9631 static tree
9633 tree args,
9634 tsubst_flags_t complain,
9635 tree in_decl,
9637 {
9642 {
9647 /* Else fall through. */
9651 {
9652 tree argvec;
9653 tree context;
9654 tree r;
9658 /* In "sizeof(X<I>)" we need to evaluate "I". */
9664 /* First, determine the context for the type we are looking
9665 up. */
9668 {
9671 /* If context is a nested class inside a class template,
9672 it may still need to be instantiated (c++/33959). */
9674 }
9676 /* Then, figure out what arguments are appropriate for the
9677 type we are trying to find. For example, given:
9679 template <class T> struct S;
9680 template <class T, class U> void f(T, U) { S<U> su; }
9682 and supposing that we are instantiating f<int, double>,
9683 then our ARGS will be {int, double}, but, when looking up
9684 S we only want {double}. */
9689 else
9690 {
9694 }
9700 }
9701 else
9702 /* This is not a template type, so there's nothing to do. */
9707 }
9708 }
9710 /* Substitute into the default argument ARG (a default argument for
9711 FN), which has the indicated TYPE. */
9713 tree
9715 {
9720 /* This can happen in invalid code. */
9724 /* This default argument came from a template. Instantiate the
9725 default argument here, not in tsubst. In the case of
9726 something like:
9728 template <class T>
9729 struct S {
9730 static T t();
9731 void f(T = t());
9732 };
9734 we must be careful to do name lookup in the scope of S<T>,
9735 rather than in the current class. */
9737 /* The "this" pointer is not valid in a default argument. */
9739 {
9744 }
9747 /* The default argument expression may cause implicitly defined
9748 member functions to be synthesized, which will result in garbage
9749 collection. We must treat this situation as if we were within
9750 the body of function so as to avoid collecting live data on the
9751 stack. */
9759 /* Restore the "this" pointer. */
9761 {
9764 }
9770 /* Make sure the default argument is reasonable. */
9776 }
9778 /* Substitute into all the default arguments for FN. */
9780 static void
9782 {
9783 tree arg;
9784 tree tmpl_args;
9788 /* If this function is not yet instantiated, we certainly don't need
9789 its default arguments. */
9792 /* Don't do this again for clones. */
9797 arg;
9803 }
9805 /* Substitute the ARGS into the T, which is a _DECL. Return the
9806 result of the substitution. Issue error and warning messages under
9807 control of COMPLAIN. */
9809 static tree
9811 {
9812 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
9813 location_t saved_loc;
9818 /* Set the filename and linenumber to improve error-reporting. */
9823 {
9825 {
9826 /* We can get here when processing a member function template,
9827 member class template, or template template parameter. */
9829 tree spec;
9830 tree tmpl_args;
9831 tree full_args;
9834 {
9835 /* Template template parameter is treated here. */
9848 complain);
9851 }
9853 /* We might already have an instance of this template.
9854 The ARGS are for the surrounding class type, so the
9855 full args contain the tsubst'd args for the context,
9856 plus the innermost args from the template decl. */
9860 /* Because this is a template, the arguments will still be
9861 dependent, even after substitution. If
9862 PROCESSING_TEMPLATE_DECL is not set, the dependency
9863 predicates will short-circuit. */
9871 /* If this is a default template template argument,
9872 tsubst might not have changed anything. */
9879 {
9882 }
9884 /* Make a new template decl. It will be similar to the
9885 original, but will record the current template arguments.
9886 We also create a new function declaration, which is just
9887 like the old one, but points to this new template, rather
9888 than the old one. */
9897 {
9898 tree new_type;
9910 }
9911 else
9912 {
9913 tree new_decl;
9925 }
9931 /* The template parameters for this new template are all the
9932 template parameters for the old template, except the
9933 outermost level of parameters. */
9936 complain);
9942 /* Record this non-type partial instantiation. */
9946 }
9950 {
9951 tree ctx;
9954 tree gen_tmpl;
9955 tree type;
9960 /* Nobody should be tsubst'ing into non-template functions. */
9964 {
9965 tree spec;
9968 /* If T is not dependent, just return it. We have to
9969 increment PROCESSING_TEMPLATE_DECL because
9970 value_dependent_expression_p assumes that nothing is
9971 dependent when PROCESSING_TEMPLATE_DECL is zero. */
9978 /* Calculate the most general template of which R is a
9979 specialization, and the complete set of arguments used to
9980 specialize R. */
9983 (DECL_TEMPLATE_RESULT
9989 /* Check to see if we already have this specialization. */
9994 {
9997 }
9999 /* We can see more levels of arguments than parameters if
10000 there was a specialization of a member template, like
10001 this:
10003 template <class T> struct S { template <class U> void f(); }
10004 template <> template <class U> void S<int>::f(U);
10006 Here, we'll be substituting into the specialization,
10007 because that's where we can find the code we actually
10008 want to generate, but we'll have enough arguments for
10009 the most general template.
10011 We also deal with the peculiar case:
10013 template <class T> struct S {
10014 template <class U> friend void f();
10015 };
10016 template <class U> void f() {}
10017 template S<int>;
10018 template void f<double>();
10020 Here, the ARGS for the instantiation of will be {int,
10021 double}. But, we only need as many ARGS as there are
10022 levels of template parameters in CODE_PATTERN. We are
10023 careful not to get fooled into reducing the ARGS in
10024 situations like:
10026 template <class T> struct S { template <class U> void f(U); }
10027 template <class T> template <> void S<T>::f(int) {}
10029 which we can spot because the pattern will be a
10030 specialization in this case. */
10032 parms_depth =
10037 }
10038 else
10039 {
10040 /* This special case arises when we have something like this:
10042 template <class T> struct S {
10043 friend void f<int>(int, double);
10044 };
10046 Here, the DECL_TI_TEMPLATE for the friend declaration
10047 will be an IDENTIFIER_NODE. We are being called from
10048 tsubst_friend_function, and we want only to create a
10049 new decl (R) with appropriate types so that we can call
10050 determine_specialization. */
10052 }
10055 {
10058 else
10062 }
10063 else
10064 {
10067 }
10072 /* If we hit excessive deduction depth, the type is bogus even if
10073 it isn't error_mark_node, so don't build a decl. */
10077 /* We do NOT check for matching decls pushed separately at this
10078 point, as they may not represent instantiations of this
10079 template, and in any case are considered separate under the
10080 discrete model. */
10084 /* Clear out the mangled name and RTL for the instantiation. */
10087 /* Leave DECL_INITIAL set on deleted instantiations. */
10093 /* Type-conversion operator. Reconstruct the name, in
10094 case it's the name of one of the template's parameters. */
10104 /* If this is an instantiation of a function with internal
10105 linkage, we already know what object file linkage will be
10106 assigned to the instantiation. */
10115 /* We'll re-clone as appropriate in instantiate_template. */
10118 /* If we aren't complaining now, return on error before we register
10119 the specialization so that we'll complain eventually. */
10125 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10126 this in the special friend case mentioned above where
10127 GEN_TMPL is NULL. */
10129 {
10135 /* We're not supposed to instantiate default arguments
10136 until they are called, for a template. But, for a
10137 declaration like:
10139 template <class T> void f ()
10140 { extern void g(int i = T()); }
10142 we should do the substitution when the template is
10143 instantiated. We handle the member function case in
10144 instantiate_class_template since the default arguments
10145 might refer to other members of the class. */
10150 }
10151 else
10154 /* Copy the list of befriending classes. */
10158 {
10162 in_decl);
10163 }
10166 {
10172 /* If this is an instantiation of a member template, clone it.
10173 If it isn't, that'll be handled by
10174 clone_constructors_and_destructors. */
10177 }
10188 /* Possibly limit visibility based on template args. */
10191 {
10195 }
10203 }
10207 {
10215 {
10216 /* If there is a local specialization that isn't a
10217 parameter pack, it means that we're doing a "simple"
10218 substitution from inside tsubst_pack_expansion. Just
10219 return the local specialization (which will be a single
10220 parm). */
10227 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10228 the parameters in this function parameter pack. */
10232 {
10235 /* Zero-length parameter packs are boring. Just substitute
10236 into the chain. */
10240 }
10241 else
10242 {
10243 /* All we did was update the type. Make a note of that. */
10246 }
10247 }
10249 /* Loop through all of the parameter's we'll build. When T is
10250 a function parameter pack, LEN is the number of expanded
10251 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10254 {
10261 /* We're on the Ith parameter of the function parameter
10262 pack. */
10263 {
10264 /* An argument of a function parameter pack is not a parameter
10265 pack. */
10268 /* Get the Ith type. */
10272 /* Rename the parameter to include the index. */
10275 }
10277 /* We're dealing with a normal parameter. */
10285 {
10288 else
10291 }
10301 /* Keep track of the first new parameter we
10302 generate. That's what will be returned to the
10303 caller. */
10307 /* Build a proper chain of parameters when substituting
10308 into a function parameter pack. */
10311 }
10313 /* If cp_unevaluated_operand is set, we're just looking for a
10314 single dummy parameter, so don't keep going. */
10319 /* FIRST_R contains the start of the chain we've built. */
10321 }
10325 {
10326 tree type;
10336 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10337 non-bit-fields DECL_INITIAL is a non-static data member
10338 initializer, which gets deferred instantiation. */
10344 {
10345 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10346 NSDMI in perform_member_init. Still set DECL_INITIAL
10347 so that we know there is one. */
10352 }
10353 /* We don't have to set DECL_CONTEXT here; it is set by
10354 finish_member_declaration. */
10361 }
10365 /* We reach here only for member using decls. We also need to check
10366 uses_template_parms because DECL_DEPENDENT_P is not set for a
10367 using-declaration that designates a member of the current
10368 instantiation (c++/53549). */
10371 {
10382 else
10383 {
10386 }
10387 }
10388 else
10389 {
10392 }
10397 {
10400 tree spec;
10402 tree ctx;
10408 {
10409 /* If this is the canonical decl, we don't have to
10410 mess with instantiations, and often we can't (for
10411 typename, template type parms and such). Note that
10412 TYPE_NAME is not correct for the above test if
10413 we've copied the type for a typedef. */
10419 }
10421 /* Check to see if we already have the specialization we
10422 need. */
10425 {
10426 /* T is a static data member or namespace-scope entity.
10427 We have to substitute into namespace-scope variables
10428 (even though such entities are never templates) because
10429 of cases like:
10431 template <class T> void f() { extern T t; }
10433 where the entity referenced is not known until
10434 instantiation time. */
10438 {
10440 complain,
10442 /* If CTX is unchanged, then T is in fact the
10443 specialization we want. That situation occurs when
10444 referencing a static data member within in its own
10445 class. We can use pointer equality, rather than
10446 same_type_p, because DECL_CONTEXT is always
10447 canonical... */
10450 /* ... unless T is a member template; in which
10451 case our caller can be willing to create a
10452 specialization of that template represented
10453 by T. */
10457 }
10460 {
10468 }
10469 }
10470 else
10471 {
10472 /* A local variable. */
10474 /* Subsequent calls to pushdecl will fill this in. */
10477 }
10478 /* If we already have the specialization we need, there is
10479 nothing more to do. */
10481 {
10484 }
10487 {
10488 /* Just use name lookup to find a member alias for an anonymous
10489 union, but then add it to the hash table. */
10494 }
10496 /* Create a new node for the specialization we need. */
10499 {
10502 else
10509 }
10511 {
10512 /* Even if the original location is out of scope, the
10513 newly substituted one is not. */
10520 {
10521 /* It may seem that this case cannot occur, since:
10523 typedef void f();
10524 void g() { f x; }
10526 declares a function, not a variable. However:
10528 typedef void f();
10529 template <typename T> void g() { T t; }
10530 template void g<f>();
10532 is an attempt to declare a variable with function
10533 type. */
10535 /* R is not yet sufficiently initialized, so we
10536 just use its name. */
10539 }
10541 /* Wait until cp_finish_decl to set this again, to handle
10542 circular dependency (template/instantiate6.C). */
10547 {
10552 {
10555 }
10557 }
10558 }
10564 /* Clear out the mangled name and RTL for the instantiation. */
10568 /* The initializer must not be expanded until it is required;
10569 see [temp.inst]. */
10575 {
10576 /* Possibly limit visibility based on template args. */
10579 {
10583 }
10585 }
10588 {
10589 /* A static data member declaration is always marked
10590 external when it is declared in-class, even if an
10591 initializer is present. We mimic the non-template
10592 processing here. */
10598 }
10600 {
10601 /* We're substituting this var in a decltype outside of its
10602 scope, such as for a lambda return type. Don't add it to
10603 local_specializations, do perform auto deduction. */
10606 {
10607 tree init
10613 }
10614 }
10615 else
10624 /* Preserve a typedef that names a type. */
10626 {
10629 }
10632 }
10637 }
10638 #undef RETURN
10640 out:
10641 /* Restore the file and line information. */
10645 }
10647 /* Substitute into the ARG_TYPES of a function type.
10648 If END is a TREE_CHAIN, leave it and any following types
10649 un-substituted. */
10651 static tree
10653 tree args,
10654 tree end,
10655 tsubst_flags_t complain,
10656 tree in_decl)
10657 {
10658 tree remaining_arg_types;
10662 tree default_arg;
10673 {
10674 /* For a pack expansion, perform substitution on the
10675 entire expression. Later on, we'll handle the arguments
10676 one-by-one. */
10681 /* So that we'll spin through the parameters, one by one. */
10683 else
10684 {
10685 /* We only partially substituted into the parameter
10686 pack. Our type is TYPE_PACK_EXPANSION. */
10689 }
10690 }
10703 {
10705 {
10709 }
10711 }
10713 /* Do array-to-pointer, function-to-pointer conversion, and ignore
10714 top-level qualifiers as required. */
10717 /* We do not substitute into default arguments here. The standard
10718 mandates that they be instantiated only when needed, which is
10719 done in build_over_call. */
10723 {
10724 /* We've instantiated a template before its default arguments
10725 have been parsed. This can happen for a nested template
10726 class, and is not an error unless we require the default
10727 argument in a call of this function. */
10728 remaining_arg_types =
10731 remaining_arg_types);
10732 }
10733 else
10734 remaining_arg_types =
10736 }
10739 }
10741 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
10742 *not* handle the exception-specification for FNTYPE, because the
10743 initial substitution of explicitly provided template parameters
10744 during argument deduction forbids substitution into the
10745 exception-specification:
10747 [temp.deduct]
10749 All references in the function type of the function template to the
10750 corresponding template parameters are replaced by the specified tem-
10751 plate argument values. If a substitution in a template parameter or
10752 in the function type of the function template results in an invalid
10753 type, type deduction fails. [Note: The equivalent substitution in
10754 exception specifications is done only when the function is instanti-
10755 ated, at which point a program is ill-formed if the substitution
10756 results in an invalid type.] */
10758 static tree
10760 tree args,
10761 tsubst_flags_t complain,
10762 tree in_decl)
10763 {
10764 tree return_type;
10765 tree arg_types;
10766 tree fntype;
10768 /* The TYPE_CONTEXT is not used for function/method types. */
10771 /* Substitute the return type. */
10775 /* The standard does not presently indicate that creation of a
10776 function type with an invalid return type is a deduction failure.
10777 However, that is clearly analogous to creating an array of "void"
10778 or a reference to a reference. This is core issue #486. */
10781 {
10783 {
10786 else
10788 }
10790 }
10792 /* Substitute the argument types. */
10798 /* Construct a new type node and return it. */
10800 {
10803 }
10804 else
10805 {
10808 {
10809 /* [temp.deduct]
10811 Type deduction may fail for any of the following
10812 reasons:
10814 -- Attempting to create "pointer to member of T" when T
10815 is not a class type. */
10818 r);
10820 }
10824 }
10828 }
10830 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
10831 ARGS into that specification, and return the substituted
10832 specification. If there is no specification, return NULL_TREE. */
10834 static tree
10836 tree args,
10837 tsubst_flags_t complain,
10838 tree in_decl,
10840 {
10841 tree specs;
10842 tree new_specs;
10847 {
10848 /* A noexcept-specifier. */
10853 {
10854 /* Defer instantiation of noexcept-specifiers to avoid
10855 excessive instantiations (c++/49107). */
10858 {
10859 /* We already partially instantiated this member template,
10860 so combine the new args with the old. */
10865 }
10866 else
10867 {
10870 }
10871 }
10872 else
10873 new_specs = tsubst_copy_and_build
10877 }
10879 {
10882 else
10884 {
10885 tree spec;
10890 {
10891 /* Expand the pack expansion type. */
10894 in_decl);
10900 else
10901 {
10902 /* We're substituting into a member template, so
10903 we got a TYPE_PACK_EXPANSION back. Add that
10904 expansion and move on. */
10908 expanded_specs,
10909 complain);
10912 }
10913 }
10916 {
10919 else
10924 complain);
10925 }
10928 }
10929 }
10931 }
10933 /* Take the tree structure T and replace template parameters used
10934 therein with the argument vector ARGS. IN_DECL is an associated
10935 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
10936 Issue error and warning messages under control of COMPLAIN. Note
10937 that we must be relatively non-tolerant of extensions here, in
10938 order to preserve conformance; if we allow substitutions that
10939 should not be allowed, we may allow argument deductions that should
10940 not succeed, and therefore report ambiguous overload situations
10941 where there are none. In theory, we could allow the substitution,
10942 but indicate that it should have failed, and allow our caller to
10943 make sure that the right thing happens, but we don't try to do this
10944 yet.
10946 This function is used for dealing with types, decls and the like;
10947 for expressions, use tsubst_expr or tsubst_copy. */
10949 tree
10951 {
10974 else
10979 /* Reuse typedefs. We need to do this to handle dependent attributes,
10980 such as attribute aligned. */
10983 {
10987 {
10988 /* DECL represents an alias template and we want to
10989 instantiate it. */
10993 }
10997 {
11001 }
11006 else
11007 /* The typedef is from a non-template context. */
11011 {
11013 r = cp_build_qualified_type_real
11017 }
11018 else
11019 /* We don't have an instantiation yet, so drop the typedef. */
11021 }
11034 {
11060 {
11066 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11067 needed. */
11073 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11074 with TREE_SIDE_EFFECTS that indicates this is not an integral
11075 constant expression. */
11078 {
11081 }
11084 }
11090 {
11103 {
11107 /* See through ARGUMENT_PACK_SELECT arguments. */
11109 }
11114 {
11116 /* If ARG is an argument pack, we don't actually want to
11117 perform a substitution here, because substitutions
11118 for argument packs are only done
11119 element-by-element. We can get to this point when
11120 substituting the type of a non-type template
11121 parameter pack, when that type actually contains
11122 template parameter packs from an outer template, e.g.,
11124 template<typename... Types> struct A {
11125 template<Types... Values> struct B { };
11126 }; */
11130 {
11136 return cp_build_qualified_type_real
11138 }
11140 {
11141 /* We are processing a type constructed from a
11142 template template parameter. */
11153 /* Consider this code:
11155 template <template <class> class Template>
11156 struct Internal {
11157 template <class Arg> using Bind = Template<Arg>;
11158 };
11160 template <template <class> class Template, class Arg>
11161 using Instantiate = Template<Arg>; //#0
11163 template <template <class> class Template,
11164 class Argument>
11165 using Bind =
11166 Instantiate<Internal<Template>::template Bind,
11167 Argument>; //#1
11169 When #1 is parsed, the
11170 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11171 parameter `Template' in #0 matches the
11172 UNBOUND_CLASS_TEMPLATE representing the argument
11173 `Internal<Template>::template Bind'; We then want
11174 to assemble the type `Bind<Argument>' that can't
11175 be fully created right now, because
11176 `Internal<Template>' not being complete, the Bind
11177 template cannot be looked up in that context. So
11178 we need to "store" `Bind<Argument>' for later
11179 when the context of Bind becomes complete. Let's
11180 store that in a TYPENAME_TYPE. */
11184 argvec),
11185 typename_type,
11186 complain);
11188 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11189 are resolving nested-types in the signature of a
11190 member function templates. Otherwise ARG is a
11191 TEMPLATE_DECL and is the real template to be
11192 instantiated. */
11200 complain);
11201 return cp_build_qualified_type_real
11203 }
11204 else
11205 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11207 }
11210 /* This can happen during the attempted tsubst'ing in
11211 unify. This means that we don't yet have any information
11212 about the template parameter in question. */
11215 /* Early in template argument deduction substitution, we don't
11216 want to reduce the level of 'auto', or it will be confused
11217 with a normal template parm in subsequent deduction. */
11221 /* If we get here, we must have been looking at a parm for a
11222 more deeply nested template. Make a new version of this
11223 template parameter, but with a lower level. */
11225 {
11230 {
11232 r = cp_build_qualified_type_real
11236 }
11237 else
11238 {
11249 /* We have reduced the level of the template
11250 template parameter, but not the levels of its
11251 template parameters, so canonical_type_parameter
11252 will not be able to find the canonical template
11253 template parameter for this level. Thus, we
11254 require structural equality checking to compare
11255 TEMPLATE_TEMPLATE_PARMs. */
11259 else
11263 {
11271 }
11272 }
11281 }
11284 }
11287 {
11295 {
11299 }
11302 {
11306 }
11309 {
11313 }
11319 }
11322 /* We should never be tsubsting a binfo. */
11326 /* A vector of template arguments. */
11332 {
11336 /* [temp.deduct]
11338 Type deduction may fail for any of the following
11339 reasons:
11341 -- Attempting to create a pointer to reference type.
11342 -- Attempting to create a reference to a reference type or
11343 a reference to void.
11345 Core issue 106 says that creating a reference to a reference
11346 during instantiation is no longer a cause for failure. We
11347 only enforce this check in strict C++98 mode. */
11351 {
11354 /* We keep track of the last time we issued this error
11355 message to avoid spewing a ton of messages during a
11356 single bad template instantiation. */
11359 {
11364 else
11367 }
11370 }
11372 {
11376 }
11378 /* In C++0x, during template argument substitution, when there is an
11379 attempt to create a reference to a reference type, reference
11380 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
11382 "If a template-argument for a template-parameter T names a type
11383 that is a reference to a type A, an attempt to create the type
11384 'lvalue reference to cv T' creates the type 'lvalue reference to
11385 A,' while an attempt to create the type type rvalue reference to
11386 cv T' creates the type T"
11387 */
11388 r = cp_build_reference_type
11391 else
11396 /* Will this ever be needed for TYPE_..._TO values? */
11400 }
11402 {
11405 {
11406 /* [temp.deduct]
11408 Type deduction may fail for any of the following
11409 reasons:
11411 -- Attempting to create "pointer to member of T" when T
11412 is not a class type. */
11416 }
11418 {
11422 }
11424 {
11428 }
11431 {
11432 /* The type of the implicit object parameter gets its
11433 cv-qualifiers from the FUNCTION_TYPE. */
11434 tree memptr;
11438 complain);
11439 }
11440 else
11443 complain);
11444 }
11447 {
11448 tree fntype;
11449 tree specs;
11454 /* Substitute the exception specification. */
11462 }
11464 {
11469 /* As an optimization, we avoid regenerating the array type if
11470 it will obviously be the same as T. */
11474 /* These checks should match the ones in grokdeclarator.
11476 [temp.deduct]
11478 The deduction may fail for any of the following reasons:
11480 -- Attempting to create an array with an element type that
11481 is void, a function type, or a reference type, or [DR337]
11482 an abstract class type. */
11486 {
11490 }
11492 {
11495 type);
11497 }
11502 {
11505 }
11508 }
11511 {
11521 {
11525 }
11527 {
11528 /* Normally, make_typename_type does not require that the CTX
11529 have complete type in order to allow things like:
11531 template <class T> struct S { typename S<T>::X Y; };
11533 But, such constructs have already been resolved by this
11534 point, so here CTX really should have complete type, unless
11535 it's a partial instantiation. */
11538 {
11542 }
11543 }
11550 {
11553 }
11556 {
11558 {
11562 else
11564 }
11566 {
11570 else
11572 }
11573 }
11575 return cp_build_qualified_type_real
11577 }
11580 {
11592 }
11595 {
11596 tree type;
11612 complain);
11613 }
11616 {
11617 tree type;
11633 else
11634 type = finish_decltype_type
11639 complain);
11640 }
11643 {
11647 }
11651 {
11653 tree packed_out =
11655 args,
11656 complain,
11657 in_decl);
11660 /* For template nontype argument packs, also substitute into
11661 the type. */
11666 }
11681 /* We should use one of the expression tsubsts for these codes. */
11687 }
11688 }
11690 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
11691 type of the expression on the left-hand side of the "." or "->"
11692 operator. */
11694 static tree
11697 {
11698 tree name;
11699 tree qualifying_scope;
11700 tree fns;
11701 tree optype;
11706 /* A baselink indicates a function from a base class. Both the
11707 BASELINK_ACCESS_BINFO and the base class referenced may
11708 indicate bases of the template class, rather than the
11709 instantiated class. In addition, lookups that were not
11710 ambiguous before may be ambiguous now. Therefore, we perform
11711 the lookup again. */
11718 {
11725 }
11733 /* If lookup found a single function, mark it as used at this
11734 point. (If it lookup found multiple functions the one selected
11735 later by overload resolution will be marked as used at that
11736 point.) */
11742 /* Add back the template arguments, if present. */
11747 template_args);
11748 /* Update the conversion operator type. */
11756 qualifying_scope,
11757 object_type);
11759 }
11761 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
11762 true if the qualified-id will be a postfix-expression in-and-of
11763 itself; false if more of the postfix-expression follows the
11764 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
11765 of "&". */
11767 static tree
11771 {
11772 tree expr;
11773 tree scope;
11774 tree name;
11776 tree template_args;
11781 /* Figure out what name to look up. */
11784 {
11792 }
11793 else
11794 {
11797 }
11799 /* Substitute into the qualifying scope. When there are no ARGS, we
11800 are just trying to simplify a non-dependent expression. In that
11801 case the qualifying scope may be dependent, and, in any case,
11802 substituting will not help. */
11805 {
11808 }
11809 else
11813 {
11818 }
11821 {
11823 {
11824 /* A BIT_NOT_EXPR is used to represent a destructor. */
11826 {
11830 }
11831 else
11834 }
11835 else
11839 {
11841 {
11845 }
11847 }
11848 }
11851 {
11853 scope);
11854 /* Remember that there was a reference to this entity. */
11856 }
11859 {
11865 }
11874 {
11875 expr = (adjust_result_of_qualified_name_lookup
11877 expr = (finish_qualified_id_expr
11881 }
11883 /* Expressions do not generally have reference type. */
11885 /* However, if we're about to form a pointer-to-member, we just
11886 want the referenced member referenced. */
11891 }
11893 /* Like tsubst, but deals with expressions. This function just replaces
11894 template parms; to finish processing the resultant expression, use
11895 tsubst_copy_and_build or tsubst_expr. */
11897 static tree
11899 {
11901 tree r;
11909 {
11914 {
11915 /* We get here for a use of 'this' in an NSDMI. */
11921 /* This can happen for a parameter name used later in a function
11922 declaration (such as in a late-specified return type). Just
11923 make a dummy decl, since it's only used for its type. */
11926 /* Give it the template pattern as its context; its true context
11927 hasn't been instantiated yet and this is good enough for
11928 mangling. */
11930 }
11938 {
11939 tree enum_type;
11940 tree v;
11944 /* There is no need to substitute into namespace-scope
11945 enumerators. */
11948 /* If ARGS is NULL, then T is known to be non-dependent. */
11952 /* Unfortunately, we cannot just call lookup_name here.
11953 Consider:
11955 template <int I> int f() {
11956 enum E { a = I };
11957 struct S { void g() { E e = a; } };
11958 };
11960 When we instantiate f<7>::S::g(), say, lookup_name is not
11961 clever enough to find f<7>::a. */
11962 enum_type
11972 /* We didn't find the name. That should never happen; if
11973 name-lookup found it during preliminary parsing, we
11974 should find it again here during instantiation. */
11976 }
11981 {
11982 tree ctx;
11987 {
11990 {
11994 }
11996 }
11997 }
12013 /* An OVERLOAD will always be a non-dependent overload set; an
12014 overload set from function scope will just be represented with an
12015 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12030 {
12031 /* Template template argument like the following example need
12032 special treatment:
12034 template <template <class> class TT> struct C {};
12035 template <class T> struct D {
12036 template <class U> struct E {};
12037 C<E> c; // #1
12038 };
12039 D<int> d; // #2
12041 We are processing the template argument `E' in #1 for
12042 the template instantiation #2. Originally, `E' is a
12043 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12044 have to substitute this with one having context `D<int>'. */
12048 }
12049 else
12050 /* Ordinary template template argument. */
12061 return build1
12067 {
12077 /* We only want to compute the number of arguments. */
12091 {
12098 else
12101 }
12102 else
12104 }
12106 {
12114 }
12115 /* Fall through */
12130 return build1
12135 {
12136 tree object;
12137 tree name;
12142 {
12146 }
12149 {
12159 }
12164 in_decl);
12165 else
12168 }
12206 return build_nt
12219 return build_nt
12226 {
12234 }
12239 {
12240 r = build_nt
12246 }
12249 {
12250 r = build_nt
12256 }
12259 {
12260 r = build_nt
12266 }
12269 {
12270 /* Substituted template arguments */
12279 }
12282 {
12302 }
12327 {
12330 }
12331 else
12335 /* This is handled by tsubst_copy_and_build. */
12341 in_decl),
12345 /* We shouldn't have built any of these during initial template
12346 generation. Instead, they should be built during instantiation
12347 in response to the saved STMT_IS_FULL_EXPR_P setting. */
12351 r = build2
12371 {
12372 /* Instantiate any typedefs in the type. */
12377 }
12380 /* These can sometimes show up in a partial instantiation, but never
12381 involve template parms. */
12386 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
12389 }
12390 }
12392 /* Like tsubst_copy, but specifically for OpenMP clauses. */
12394 static tree
12396 tree in_decl)
12397 {
12401 {
12407 {
12410 {
12416 }
12417 /* FALLTHRU */
12441 }
12442 }
12445 }
12447 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
12449 static tree
12451 tree in_decl)
12452 {
12453 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
12473 {
12476 else
12477 {
12481 }
12482 }
12487 #undef RECUR
12488 }
12490 /* Substitute one OMP_FOR iterator. */
12492 static void
12497 {
12498 #define RECUR(NODE) \
12499 tsubst_expr ((NODE), args, complain, in_decl, \
12500 integral_constant_expression_p)
12508 /* Do this before substituting into decl to handle 'auto'. */
12513 {
12517 }
12522 {
12529 complain);
12530 else
12537 }
12540 {
12541 tree c;
12543 {
12554 }
12556 {
12561 {
12564 }
12565 }
12566 }
12572 else
12576 {
12587 {
12594 }
12595 else
12601 {
12607 }
12611 {
12618 }
12619 else
12625 }
12631 #undef RECUR
12632 }
12634 /* Like tsubst_copy for expressions, etc. but also does semantic
12635 processing. */
12637 static tree
12640 {
12641 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12642 #define RECUR(NODE) \
12643 tsubst_expr ((NODE), args, complain, in_decl, \
12644 integral_constant_expression_p)
12647 tree r;
12648 location_t loc;
12660 {
12662 {
12663 tree_stmt_iterator i;
12667 }
12682 else
12691 {
12693 tree init;
12699 {
12702 tree decl;
12710 else
12712 }
12713 else
12714 {
12718 {
12719 /* By marking the declaration as instantiated, we avoid
12720 trying to instantiate it. Since instantiate_decl can't
12721 handle local variables, and since we've already done
12722 all that needs to be done, that's the right thing to
12723 do. */
12728 /* Anonymous aggregates are a special case. */
12731 {
12734 }
12737 else
12738 {
12743 {
12744 /* For __PRETTY_FUNCTION__ we have to adjust the
12745 initializer. */
12749 }
12750 else
12751 {
12755 {
12756 /* If we had an initializer but it
12757 instantiated to nothing,
12758 value-initialize the object. This will
12759 only occur when the initializer was a
12760 pack expansion where the parameter packs
12761 used in that expansion were of length
12762 zero. */
12764 complain);
12767 }
12768 else
12770 }
12773 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
12776 }
12777 }
12778 }
12781 }
12796 {
12806 }
12833 {
12837 }
12845 else
12853 else
12880 {
12882 tree label;
12887 }
12893 /* Computed goto's must be tsubst'd into. On the other hand,
12894 non-computed gotos must not be; the identifier in question
12895 will have no binding. */
12897 else
12903 tmp = finish_asm_stmt
12910 {
12915 }
12920 {
12925 }
12926 else
12927 {
12932 else
12939 else
12945 else
12947 }
12951 {
12955 {
12957 /* Prevent instantiate_decl from trying to instantiate
12958 this variable. We've already done all that needs to be
12959 done. */
12962 }
12967 }
12973 {
12974 /* Local classes are not independent templates; they are
12975 instantiated along with their containing function. And this
12976 way we don't have to deal with pushing out of one local class
12977 to instantiate a member of another local class. */
12978 tree fn;
12979 /* Closures are handled by the LAMBDA_EXPR. */
12985 }
12989 {
12990 tree condition;
12993 condition =
12995 args,
13004 }
13025 {
13042 integral_constant_expression_p);
13056 }
13088 {
13093 {
13096 }
13101 }
13102 else
13103 {
13110 {
13113 }
13116 {
13121 {
13124 }
13128 }
13129 else
13130 {
13134 }
13136 }
13140 {
13146 {
13150 {
13155 }
13159 }
13160 else
13161 {
13166 }
13167 }
13185 /* If the first operand was a statement, we're done with it. */
13189 complain));
13196 integral_constant_expression_p));
13197 }
13200 out:
13203 #undef RECUR
13204 #undef RETURN
13205 }
13207 /* T is a postfix-expression that is not being used in a function
13208 call. Return the substituted version of T. */
13210 static tree
13212 tsubst_flags_t complain,
13213 tree in_decl)
13214 {
13218 else
13224 }
13226 /* Like tsubst but deals with expressions and performs semantic
13227 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
13229 tree
13231 tree args,
13232 tsubst_flags_t complain,
13233 tree in_decl,
13236 {
13237 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
13238 #define RECUR(NODE) \
13239 tsubst_copy_and_build (NODE, args, complain, in_decl, \
13241 integral_constant_expression_p)
13244 location_t loc;
13254 {
13257 /* Fall through. */
13259 {
13260 tree decl;
13261 cp_id_kind idk;
13266 {
13269 }
13271 /* Look up the name. */
13274 /* By convention, expressions use ERROR_MARK_NODE to indicate
13275 failure, not NULL_TREE. */
13281 integral_constant_expression_p,
13289 input_location);
13293 {
13297 }
13299 }
13302 {
13303 tree object;
13311 {
13314 }
13315 else
13322 else
13324 }
13327 {
13331 {
13332 /* A type conversion to reference type will be enclosed in
13333 such an indirect ref, but the substitution of the cast
13334 will have also added such an indirect ref. */
13337 }
13338 else
13341 }
13349 {
13356 flags));
13357 }
13370 {
13371 tree type;
13377 {
13382 }
13388 {
13406 }
13410 }
13442 else
13444 in_decl);
13478 {
13479 tree r;
13483 r = build_x_binary_op
13487 ? ERROR_MARK
13491 ? ERROR_MARK
13494 complain);
13501 }
13515 /* Fall through */
13518 {
13519 tree r;
13525 {
13526 /* When there are no ARGS, we are trying to evaluate a
13527 non-dependent expression from the parser. Trying to do
13528 the substitutions may not work. */
13531 }
13532 else
13533 {
13538 else
13541 /*integral_constant_expression_p=*/
13545 }
13549 else
13553 {
13555 {
13557 {
13561 }
13562 else
13566 }
13568 }
13570 }
13573 {
13583 }
13597 {
13598 tree r = build_x_modify_expr
13603 complain);
13604 /* TREE_NO_WARNING must be set if either the expression was
13605 parenthesized or it uses an operator such as >>= rather
13606 than plain assignment. In the former case, it was already
13607 set and must be copied. In the latter case,
13608 build_x_modify_expr sets it and it must not be reset
13609 here. */
13613 }
13618 /* Remember that there was a reference to this entity. */
13624 {
13629 tree ret;
13633 else
13634 {
13638 }
13640 /* If there was an initializer in the original tree, but it
13641 instantiated to an empty list, then we should pass a
13642 non-NULL empty vector to tell build_new that it was an
13643 empty initializer() rather than no initializer. This can
13644 only happen when the initializer is a pack expansion whose
13645 parameter packs are of length zero. */
13648 else
13649 {
13653 else
13654 {
13657 }
13658 }
13665 complain);
13673 }
13681 complain));
13687 complain));
13690 {
13691 tree function;
13696 tree ret;
13699 /* When we parsed the expression, we determined whether or
13700 not Koenig lookup should be performed. */
13703 {
13708 }
13710 {
13711 /* Do nothing; calling tsubst_copy_and_build on an identifier
13712 would incorrectly perform unqualified lookup again.
13714 Note that we can also have an IDENTIFIER_NODE if the earlier
13715 unqualified lookup found a member function; in that case
13716 koenig_p will be false and we do want to do the lookup
13717 again to find the instantiated member function.
13719 FIXME but doing that causes c++/15272, so we need to stop
13720 using IDENTIFIER_NODE in that situation. */
13722 }
13723 else
13724 {
13726 {
13732 }
13733 else
13737 in_decl,
13739 integral_constant_expression_p);
13743 }
13748 {
13754 else
13755 {
13756 /* Expand the pack expansion and push each entry onto
13757 CALL_ARGS. */
13760 {
13765 {
13770 }
13771 }
13772 else
13773 {
13774 /* A partial substitution. Add one entry. */
13776 }
13777 }
13778 }
13780 /* We do not perform argument-dependent lookup if normal
13781 lookup finds a non-function, in accordance with the
13782 expected resolution of DR 218. */
13785 /* If lookup found a member function, the Koenig lookup is
13786 not appropriate, even if an unqualified-name was used
13787 to denote the function. */
13790 /* Only do this when substitution turns a dependent call
13791 into a non-dependent call. */
13795 tf_none);
13799 {
13801 {
13802 /* For backwards compatibility and good diagnostics, try
13803 the unqualified lookup again if we aren't in SFINAE
13804 context. */
13805 tree unq = (tsubst_copy_and_build
13807 integral_constant_expression_p));
13812 {
13821 "%qD was not declared in this scope, "
13822 "and no declarations were found by "
13823 "argument-dependent lookup at the point "
13828 {
13830 "declarations in dependent base %qT are "
13836 else
13840 }
13841 else
13845 }
13846 }
13848 {
13853 }
13854 }
13856 /* Remember that there was a reference to this entity. */
13862 complain);
13864 {
13879 complain);
13880 else
13881 ret = (build_new_method_call
13886 complain));
13887 }
13888 else
13891 koenig_p,
13892 complain);
13897 }
13900 {
13905 {
13907 {
13912 }
13913 else
13914 {
13919 }
13920 }
13921 else
13922 {
13925 }
13929 }
13938 {
13946 {
13947 /* We have pack expansions, so expand those and
13948 create a new list out of it. */
13951 tree chain;
13954 /* Expand the argument expressions. */
13962 /* Build the rest of the list. */
13967 /* Determine the number of arguments. */
13969 {
13972 }
13975 else
13976 {
13977 /* Since we only performed a partial substitution into
13978 the argument pack, we only RETURN (a single list
13979 node. */
13986 }
13988 /* Convert the argument vectors into a TREE_LIST */
13991 {
13992 /* Grab the Ith values. */
13993 i--;
13996 value
14000 /* Build the list (backwards). */
14002 }
14005 }
14021 }
14024 {
14025 tree object;
14026 tree object_type;
14027 tree member;
14031 /* Remember that there was a reference to this entity. */
14041 else
14049 {
14051 {
14056 {
14059 }
14061 {
14065 }
14066 }
14067 }
14070 {
14071 /* Lookup the template functions now that we know what the
14072 scope is. */
14080 {
14083 args);
14084 member = (adjust_result_of_qualified_name_lookup
14086 object_type));
14087 }
14088 else
14089 {
14091 input_location);
14093 }
14094 }
14098 {
14100 {
14104 else
14107 }
14109 }
14115 complain));
14116 }
14123 {
14131 tree r;
14136 /* digest_init will do the wrong thing if we let it. */
14140 /* We do not want to process the index of aggregate
14141 initializers as they are identifier nodes which will be
14142 looked up by digest_init. */
14148 {
14153 {
14154 /* Substitute into the pack expansion. */
14156 in_decl);
14160 ;
14162 /* Just move the argument into place. */
14164 else
14165 {
14166 /* Update the length of the final CONSTRUCTOR
14167 arguments vector, and note that we will need to
14168 copy.*/
14171 }
14172 }
14173 else
14175 }
14178 {
14183 {
14185 {
14190 }
14191 else
14193 }
14194 }
14204 }
14207 {
14210 {
14213 }
14214 else
14215 {
14218 }
14219 }
14224 /* Fall through */
14227 {
14231 /* If the original type was a reference, we'll be wrapped in
14232 the appropriate INDIRECT_REF. */
14235 }
14246 {
14255 }
14258 {
14264 integral_constant_expression_p);
14268 /* If the resulting list of expression statement is empty,
14269 fold it further into void_zero_node. */
14274 }
14277 {
14291 /* For a function scope, we want to use tsubst so that we don't
14292 complain about referring to an auto function before its return
14293 type has been deduced. Otherwise, we want to use tsubst_copy so
14294 that we look up the existing field/parameter/variable rather
14295 than build a new one. */
14300 else
14309 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
14311 /* Now that we know visibility, instantiate the type so we have a
14312 declaration of the op() for later calls to lambda_function. */
14315 /* The capture list refers to closure members, so this needs to
14316 wait until after we finish instantiating the type. */
14321 }
14324 /* We can get here for a constant initializer of non-dependent type.
14325 FIXME stop folding in cp_parser_initializer_clause. */
14327 {
14329 complain);
14332 }
14336 integral_constant_expression_p));
14339 /* Handle Objective-C++ constructs, if appropriate. */
14340 {
14341 tree subst
14346 }
14348 }
14350 #undef RECUR
14351 #undef RETURN
14352 out:
14355 }
14357 /* Verify that the instantiated ARGS are valid. For type arguments,
14358 make sure that the type's linkage is ok. For non-type arguments,
14359 make sure they are constants if they are integral or enumerations.
14360 Emit an error under control of COMPLAIN, and return TRUE on error. */
14362 static bool
14364 {
14368 {
14378 }
14380 {
14381 /* [basic.link]: A name with no linkage (notably, the name
14382 of a class or enumeration declared in a local scope)
14383 shall not be used to declare an entity with linkage.
14384 This implies that names with no linkage cannot be used as
14385 template arguments
14387 DR 757 relaxes this restriction for C++0x. */
14392 {
14393 /* DR 488 makes use of a type with no linkage cause
14394 type deduction to fail. */
14396 {
14399 else
14402 }
14404 }
14405 /* In order to avoid all sorts of complications, we do not
14406 allow variably-modified types as template arguments. */
14408 {
14412 }
14413 }
14414 /* A non-type argument of integral or enumerated type must be a
14415 constant. */
14419 {
14423 }
14425 }
14427 static bool
14429 {
14434 {
14437 }
14441 }
14443 /* We're out of SFINAE context now, so generate diagnostics for the access
14444 errors we saw earlier when instantiating D from TMPL and ARGS. */
14446 static void
14448 {
14460 }
14462 /* Instantiate the indicated variable, function, or alias template TMPL with
14463 the template arguments in TARG_PTR. */
14465 static tree
14467 {
14469 tree fndecl;
14470 tree gen_tmpl;
14471 tree spec;
14479 /* If this function is a clone, handle it specially. */
14481 {
14482 tree spec;
14483 tree clone;
14485 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
14486 DECL_CLONED_FUNCTION. */
14492 /* Look for the clone. */
14496 /* We should always have found the clone by now. */
14499 }
14501 /* Check to see if we already have this specialization. */
14504 /* The TMPL is a partial instantiation. To get a full set of
14505 arguments we must add the arguments used to perform the
14506 partial instantiation. */
14508 targ_ptr);
14510 /* It would be nice to avoid hashing here and then again in tsubst_decl,
14511 but it doesn't seem to be on the hot path. */
14520 {
14522 {
14526 }
14528 }
14531 complain))
14534 /* We are building a FUNCTION_DECL, during which the access of its
14535 parameters and return types have to be checked. However this
14536 FUNCTION_DECL which is the desired context for access checking
14537 is not built yet. We solve this chicken-and-egg problem by
14538 deferring all checks until we have the FUNCTION_DECL. */
14541 /* Instantiation of the function happens in the context of the function
14542 template, not the context of the overload resolution we're doing. */
14544 /* If there are dependent arguments, e.g. because we're doing partial
14545 ordering, make sure processing_template_decl stays set. */
14549 {
14553 }
14554 /* Substitute template parameters to obtain the specialization. */
14562 {
14565 }
14567 /* The DECL_TI_TEMPLATE should always be the immediate parent
14568 template, not the most general template. */
14571 /* Now we know the specialization, compute access previously
14572 deferred. */
14579 /* If we've just instantiated the main entry point for a function,
14580 instantiate all the alternate entry points as well. We do this
14581 by cloning the instantiation of the main entry point, not by
14582 instantiating the template clones. */
14587 {
14589 {
14590 /* Remember to reinstantiate when we're out of SFINAE so the user
14591 can see the errors. */
14593 }
14595 }
14597 }
14599 /* Wrapper for instantiate_template_1. */
14601 tree
14603 {
14604 tree ret;
14609 }
14611 /* Instantiate the alias template TMPL with ARGS. Also push a template
14612 instantiation level, which instantiate_template doesn't do because
14613 functions and variables have sufficient context established by the
14614 callers. */
14616 static tree
14618 {
14625 {
14628 }
14631 /* We can't free this if a pending_template entry or last_error_tinst_level
14632 is pointing at it. */
14638 }
14640 /* PARM is a template parameter pack for FN. Returns true iff
14641 PARM is used in a deducible way in the argument list of FN. */
14643 static bool
14645 {
14648 {
14650 tree packs;
14656 {
14657 /* The template parameter pack is used in a function parameter
14658 pack. If this is the end of the parameter list, the
14659 template parameter pack is deducible. */
14662 else
14663 /* Otherwise, not. Well, it could be deduced from
14664 a non-pack parameter, but doing so would end up with
14665 a deduction mismatch, so don't bother. */
14667 }
14668 }
14669 /* The template parameter pack isn't used in any function parameter
14670 packs, but it might be used deeper, e.g. tuple<Args...>. */
14672 }
14674 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
14675 NARGS elements of the arguments that are being used when calling
14676 it. TARGS is a vector into which the deduced template arguments
14677 are placed.
14679 Return zero for success, 2 for an incomplete match that doesn't resolve
14680 all the types, and 1 for complete failure. An error message will be
14681 printed only for an incomplete match.
14683 If FN is a conversion operator, or we are trying to produce a specific
14684 specialization, RETURN_TYPE is the return type desired.
14686 The EXPLICIT_TARGS are explicit template arguments provided via a
14687 template-id.
14689 The parameter STRICT is one of:
14691 DEDUCE_CALL:
14692 We are deducing arguments for a function call, as in
14693 [temp.deduct.call].
14695 DEDUCE_CONV:
14696 We are deducing arguments for a conversion function, as in
14697 [temp.deduct.conv].
14699 DEDUCE_EXACT:
14700 We are deducing arguments when doing an explicit instantiation
14701 as in [temp.explicit], when determining an explicit specialization
14702 as in [temp.expl.spec], or when taking the address of a function
14703 template, as in [temp.deduct.funcaddr]. */
14705 tree
14707 tree explicit_targs,
14708 tree targs,
14711 tree return_type,
14712 unification_kind_t strict,
14715 {
14716 tree parms;
14717 tree fntype;
14725 tree tinst;
14728 /* Adjust any explicit template arguments before entering the
14729 substitution context. */
14731 {
14732 explicit_targs
14734 complain,
14739 }
14741 /* In C++0x, it's possible to have a function template whose type depends
14742 on itself recursively. This is most obvious with decltype, but can also
14743 occur with enumeration scope (c++/48969). So we need to catch infinite
14744 recursion and reject the substitution at deduction time; this function
14745 will return error_mark_node for any repeated substitution.
14747 This also catches excessive recursion such as when f<N> depends on
14748 f<N-1> across all integers, and returns error_mark_node for all the
14749 substitutions back up to the initial one.
14751 This is, of course, not reentrant. */
14756 {
14760 }
14768 {
14769 /* [temp.deduct]
14771 The specified template arguments must match the template
14772 parameters in kind (i.e., type, nontype, template), and there
14773 must not be more arguments than there are parameters;
14774 otherwise type deduction fails.
14776 Nontype arguments must match the types of the corresponding
14777 nontype template parameters, or must be convertible to the
14778 types of the corresponding nontype parameters as specified in
14779 _temp.arg.nontype_, otherwise type deduction fails.
14781 All references in the function type of the function template
14782 to the corresponding template parameters are replaced by the
14783 specified template argument values. If a substitution in a
14784 template parameter or in the function type of the function
14785 template results in an invalid type, type deduction fails. */
14790 /* Substitute the explicit args into the function type. This is
14791 necessary so that, for instance, explicitly declared function
14792 arguments can match null pointed constants. If we were given
14793 an incomplete set of explicit args, we must not do semantic
14794 processing during substitution as we could create partial
14795 instantiations. */
14797 {
14802 /* Dig out the actual parm. */
14805 {
14808 }
14810 {
14813 }
14816 /* No explicit argument for this template parameter. */
14820 {
14821 /* Mark the argument pack as "incomplete". We could
14822 still deduce more arguments during unification.
14823 We remove this mark in type_unification_real. */
14825 {
14829 }
14831 /* We have some incomplete argument packs. */
14833 }
14834 }
14846 /* Place the explicitly specified arguments in TARGS. */
14849 }
14851 /* Never do unification on the 'this' parameter. */
14855 {
14864 }
14866 /* We allow incomplete unification without an error message here
14867 because the standard doesn't seem to explicitly prohibit it. Our
14868 callers must be ready to deal with unification failures in any
14869 event. */
14879 /* Now that we have bindings for all of the template arguments,
14880 ensure that the arguments deduced for the template template
14881 parameters have compatible template parameter lists. We cannot
14882 check this property before we have deduced all template
14883 arguments, because the template parameter types of a template
14884 template parameter might depend on prior template parameters
14885 deduced after the template template parameter. The following
14886 ill-formed example illustrates this issue:
14888 template<typename T, template<T> class C> void f(C<5>, T);
14890 template<int N> struct X {};
14892 void g() {
14893 f(X<5>(), 5l); // error: template argument deduction fails
14894 }
14896 The template parameter list of 'C' depends on the template type
14897 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
14898 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
14899 time that we deduce 'C'. */
14902 {
14905 }
14907 /* All is well so far. Now, check:
14909 [temp.deduct]
14911 When all template arguments have been deduced, all uses of
14912 template parameters in nondeduced contexts are replaced with
14913 the corresponding deduced argument values. If the
14914 substitution results in an invalid type, as described above,
14915 type deduction fails. */
14920 /* Now perform any access checks encountered during deduction, such as
14921 for default template arguments. */
14928 /* If we're looking for an exact match, check that what we got
14929 is indeed an exact match. It might not be if some template
14930 parameters are used in non-deduced contexts. */
14932 {
14936 tree sarg
14942 {
14946 }
14947 }
14951 fail:
14955 {
14957 /* Reset once we're all the way out. */
14959 }
14962 /* We can't free this if a pending_template entry or last_error_tinst_level
14963 is pointing at it. */
14969 }
14971 /* Adjust types before performing type deduction, as described in
14972 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
14973 sections are symmetric. PARM is the type of a function parameter
14974 or the return type of the conversion function. ARG is the type of
14975 the argument passed to the call, or the type of the value
14976 initialized with the result of the conversion function.
14977 ARG_EXPR is the original argument expression, which may be null. */
14979 static int
14983 tree arg_expr)
14984 {
14988 {
14993 {
14994 /* Swap PARM and ARG throughout the remainder of this
14995 function; the handling is precisely symmetric since PARM
14996 will initialize ARG rather than vice versa. */
15001 }
15004 /* Core issue #873: Do the DR606 thing (see below) for these cases,
15005 too, but here handle it by stripping the reference from PARM
15006 rather than by adding it to ARG. */
15014 /* Nothing else to do in this case. */
15019 }
15022 {
15023 /* [temp.deduct.call]
15025 If P is not a reference type:
15027 --If A is an array type, the pointer type produced by the
15028 array-to-pointer standard conversion (_conv.array_) is
15029 used in place of A for type deduction; otherwise,
15031 --If A is a function type, the pointer type produced by
15032 the function-to-pointer standard conversion
15033 (_conv.func_) is used in place of A for type deduction;
15034 otherwise,
15036 --If A is a cv-qualified type, the top level
15037 cv-qualifiers of A's type are ignored for type
15038 deduction. */
15043 else
15045 }
15047 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
15048 of the form T&&, where T is a template parameter, and the argument
15049 is an lvalue, T is deduced as A& */
15055 /* try_one_overload doesn't provide an arg_expr, but
15056 functions are always lvalues. */
15060 /* [temp.deduct.call]
15062 If P is a cv-qualified type, the top level cv-qualifiers
15063 of P's type are ignored for type deduction. If P is a
15064 reference type, the type referred to by P is used for
15065 type deduction. */
15068 {
15071 }
15073 /* DR 322. For conversion deduction, remove a reference type on parm
15074 too (which has been swapped into ARG). */
15079 }
15081 /* Subroutine of unify_one_argument. PARM is a function parameter of a
15082 template which does contain any deducible template parameters; check if
15083 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
15084 unify_one_argument. */
15086 static int
15089 {
15090 tree type;
15094 else
15101 {
15105 }
15107 {
15112 }
15116 else
15118 }
15120 /* Subroutine of type_unification_real and unify_pack_expansion to
15121 handle unification of a single P/A pair. Parameters are as
15122 for those functions. */
15124 static int
15128 {
15135 /* We can't deduce anything from this, but we might get all the
15136 template args from other function args. */
15139 /* FIXME uses_deducible_template_parms */
15142 explain_p);
15145 {
15147 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
15148 | UNIFY_ALLOW_MORE_CV_QUAL
15162 }
15164 /* We only do these transformations if this is the top-level
15165 parameter_type_list in a call or declaration matching; in other
15166 situations (nested function declarators, template argument lists) we
15167 won't be comparing a type to an expression, and we don't do any type
15168 adjustments. */
15170 {
15172 {
15175 {
15176 /* [temp.deduct.type] A template-argument can be
15177 deduced from a pointer to function or pointer
15178 to member function argument if the set of
15179 overloaded functions does not contain function
15180 templates and at most one of a set of
15181 overloaded functions provides a unique
15182 match. */
15189 }
15195 }
15197 arg_strict |=
15199 }
15200 else
15204 /* For deduction from an init-list we need the actual list. */
15208 }
15210 /* Most parms like fn_type_unification.
15212 If SUBR is 1, we're being called recursively (to unify the
15213 arguments of a function or method parameter of a function
15214 template). */
15216 static int
15218 tree targs,
15219 tree xparms,
15223 unification_kind_t strict,
15226 {
15231 tree parms;
15240 /* Reset the number of non-defaulted template arguments contained
15241 in TARGS. */
15244 again:
15252 {
15257 /* For a function parameter pack that occurs at the end of the
15258 parameter-declaration-list, the type A of each remaining
15259 argument of the call is compared with the type P of the
15260 declarator-id of the function parameter pack. */
15266 /* For a function parameter pack that does not occur at the
15267 end of the parameter-declaration-list, the type of the
15268 parameter pack is a non-deduced context. */
15277 }
15282 {
15283 /* Unify the remaining arguments with the pack expansion type. */
15284 tree argvec;
15287 /* Allocate a TREE_VEC and copy in all of the arguments */
15292 /* Copy the parameter into parmvec. */
15298 /* Advance to the end of the list of parameters. */
15300 }
15302 /* Fail if we've reached the end of the parm list, and more args
15303 are present, and the parm list isn't variadic. */
15306 /* Fail if parms are left and they don't have default values. */
15309 {
15313 {
15314 count++;
15316 }
15318 }
15321 {
15322 tsubst_flags_t complain = (explain_p
15323 ? tf_warning_or_error
15326 /* Check to see if we need another pass before we start clearing
15327 ARGUMENT_PACK_INCOMPLETE_P. */
15329 {
15337 /* If this is an undeduced nontype parameter that depends on
15338 a type parameter, try another pass; its type may have been
15339 deduced from a later argument than the one from which
15340 this parameter can be deduced. */
15345 }
15348 {
15352 /* Clear the "incomplete" flags on all argument packs now so that
15353 substituting them into later default arguments works. */
15355 {
15358 }
15364 /* Core issue #226 (C++0x) [temp.deduct]:
15366 If a template argument has not been deduced, its
15367 default template argument, if any, is used.
15369 When we are in C++98 mode, TREE_PURPOSE will either
15370 be NULL_TREE or ERROR_MARK_NODE, so we do not need
15371 to explicitly check cxx_dialect here. */
15373 {
15385 else
15386 {
15388 /* The position of the first default template argument,
15389 is also the number of non-defaulted arguments in TARGS.
15390 Record that. */
15394 }
15395 }
15397 /* If the type parameter is a parameter pack, then it will
15398 be deduced to an empty parameter pack. */
15400 {
15401 tree arg;
15404 {
15408 }
15409 else
15416 }
15419 }
15420 }
15421 #ifdef ENABLE_CHECKING
15424 #endif
15427 }
15429 /* Subroutine of type_unification_real. Args are like the variables
15430 at the call site. ARG is an overloaded function (or template-id);
15431 we try deducing template args from each of the overloads, and if
15432 only one succeeds, we go with that. Modifies TARGS and returns
15433 true on success. */
15435 static bool
15437 tree targs,
15438 tree parm,
15439 tree arg,
15440 unification_kind_t strict,
15443 {
15450 {
15453 }
15454 else
15458 /* Handle `&x' where `x' is some static or non-static member
15459 function name. */
15465 /* Strip baselink information. */
15470 {
15471 /* If we got some explicit template args, we need to plug them into
15472 the affected templates before we try to unify, in case the
15473 explicit args will completely resolve the templates in question. */
15480 {
15493 {
15498 {
15501 }
15502 }
15505 }
15506 /* If no templates (or more than one) are fully resolved by the
15507 explicit arguments, this template-id is a non-deduced context; it
15508 could still be OK if we deduce all template arguments for the
15509 enclosing call through other arguments. */
15512 }
15515 /* If ARG is, for example, "(0, &f)" then its type will be unknown
15516 -- but the deduction does not succeed because the expression is
15517 not just the function on its own. */
15519 else
15525 {
15528 }
15530 /* [temp.deduct.type] A template-argument can be deduced from a pointer
15531 to function or pointer to member function argument if the set of
15532 overloaded functions does not contain function templates and at most
15533 one of a set of overloaded functions provides a unique match.
15535 So if we found multiple possibilities, we return success but don't
15536 deduce anything. */
15539 {
15544 }
15549 }
15551 /* Core DR 115: In contexts where deduction is done and fails, or in
15552 contexts where deduction is not done, if a template argument list is
15553 specified and it, along with any default template arguments, identifies
15554 a single function template specialization, then the template-id is an
15555 lvalue for the function template specialization. */
15557 tree
15559 {
15572 {
15575 }
15577 {
15580 }
15582 {
15585 }
15588 {
15592 /* If we got some explicit template args, we need to plug them into
15593 the affected templates before we try to unify, in case the
15594 explicit args will completely resolve the templates in question. */
15602 {
15615 {
15618 {
15621 }
15623 {
15626 }
15627 }
15628 }
15630 {
15638 {
15639 tree base
15642 }
15646 }
15648 /* There were no good options and at least one bad one, so let the
15649 user know what the problem is. */
15651 }
15653 }
15655 /* Subroutine of resolve_overloaded_unification; does deduction for a single
15656 overload. Fills TARGS with any deduced arguments, or error_mark_node if
15657 different overloads deduce different arguments for a given parm.
15658 ADDR_P is true if the expression for which deduction is being
15659 performed was of the form "& fn" rather than simply "fn".
15661 Returns 1 on success. */
15663 static int
15665 tree orig_targs,
15666 tree targs,
15667 tree parm,
15668 tree arg,
15669 unification_kind_t strict,
15673 {
15675 tree tempargs;
15681 /* [temp.deduct.type] A template-argument can be deduced from a pointer
15682 to function or pointer to member function argument if the set of
15683 overloaded functions does not contain function templates and at most
15684 one of a set of overloaded functions provides a unique match.
15686 So if this is a template, just return success. */
15698 /* We don't copy orig_targs for this because if we have already deduced
15699 some template args from previous args, unify would complain when we
15700 try to deduce a template parameter for the same argument, even though
15701 there isn't really a conflict. */
15708 /* First make sure we didn't deduce anything that conflicts with
15709 explicitly specified args. */
15711 {
15718 /* Since we're unifying against ourselves, we will fill in
15719 template args used in the function parm list with our own
15720 template parms. Discard them. */
15724 }
15727 {
15732 }
15735 }
15737 /* PARM is a template class (perhaps with unbound template
15738 parameters). ARG is a fully instantiated type. If ARG can be
15739 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
15740 TARGS are as for unify. */
15742 static tree
15745 {
15746 tree copy_of_targs;
15753 /* We need to make a new template argument vector for the call to
15754 unify. If we used TARGS, we'd clutter it up with the result of
15755 the attempted unification, even if this class didn't work out.
15756 We also don't want to commit ourselves to all the unifications
15757 we've already done, since unification is supposed to be done on
15758 an argument-by-argument basis. In other words, consider the
15759 following pathological case:
15761 template <int I, int J, int K>
15762 struct S {};
15764 template <int I, int J>
15765 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
15767 template <int I, int J, int K>
15768 void f(S<I, J, K>, S<I, I, I>);
15770 void g() {
15771 S<0, 0, 0> s0;
15772 S<0, 1, 2> s2;
15774 f(s0, s2);
15775 }
15777 Now, by the time we consider the unification involving `s2', we
15778 already know that we must have `f<0, 0, 0>'. But, even though
15779 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
15780 because there are two ways to unify base classes of S<0, 1, 2>
15781 with S<I, I, I>. If we kept the already deduced knowledge, we
15782 would reject the possibility I=1. */
15785 /* If unification failed, we're done. */
15791 }
15793 /* Given a template type PARM and a class type ARG, find the unique
15794 base type in ARG that is an instance of PARM. We do not examine
15795 ARG itself; only its base-classes. If there is not exactly one
15796 appropriate base class, return NULL_TREE. PARM may be the type of
15797 a partial specialization, as well as a plain template type. Used
15798 by unify. */
15800 static enum template_base_result
15803 {
15805 tree binfo;
15811 {
15812 /* The type could not be completed. */
15815 }
15817 /* Walk in inheritance graph order. The search order is not
15818 important, and this avoids multiple walks of virtual bases. */
15820 {
15825 {
15826 /* If there is more than one satisfactory baseclass, then:
15828 [temp.deduct.call]
15830 If they yield more than one possible deduced A, the type
15831 deduction fails.
15833 applies. */
15835 {
15838 }
15841 }
15842 }
15846 }
15848 /* Returns the level of DECL, which declares a template parameter. */
15850 static int
15852 {
15854 {
15864 }
15866 }
15868 /* Decide whether ARG can be unified with PARM, considering only the
15869 cv-qualifiers of each type, given STRICT as documented for unify.
15870 Returns nonzero iff the unification is OK on that basis. */
15872 static int
15874 {
15880 {
15881 /* Although a CVR qualifier is ignored when being applied to a
15882 substituted template parameter ([8.3.2]/1 for example), that
15883 does not allow us to unify "const T" with "int&" because both
15884 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
15885 It is ok when we're allowing additional CV qualifiers
15886 at the outer level [14.8.2.1]/3,1st bullet. */
15896 }
15907 }
15909 /* Determines the LEVEL and INDEX for the template parameter PARM. */
15910 void
15912 {
15916 {
15919 }
15920 else
15921 {
15924 }
15925 }
15927 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
15928 do { \
15929 if (unify (TP, TA, P, A, S, EP)) \
15930 return 1; \
15931 } while (0);
15933 /* Unifies the remaining arguments in PACKED_ARGS with the pack
15934 expansion at the end of PACKED_PARMS. Returns 0 if the type
15935 deduction succeeds, 1 otherwise. STRICT is the same as in
15936 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
15937 call argument list. We'll need to adjust the arguments to make them
15938 types. SUBR tells us if this is from a recursive call to
15939 type_unification_real, or for comparing two template argument
15940 lists. */
15942 static int
15946 {
15947 tree parm
15954 /* Determine the parameter packs we will be deducing from the
15955 pattern, and record their current deductions. */
15958 {
15962 /* Determine the index and level of this parameter pack. */
15965 /* Keep track of the parameter packs and their corresponding
15966 argument packs. */
15969 }
15971 /* Loop through all of the arguments that have not yet been
15972 unified and unify each with the pattern. */
15974 {
15975 tree parm;
15979 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
15980 or the element of its argument pack at the current index if
15981 this argument was explicitly specified. */
15983 {
15992 {
15995 }
15997 }
15999 /* If we had explicit template arguments, substitute them into the
16000 pattern before deduction. */
16002 {
16003 /* Some arguments might still be unspecified or dependent. */
16011 NULL_TREE);
16016 }
16017 else
16020 /* Unify the pattern with the current argument. */
16025 /* For each parameter pack, collect the deduced value. */
16027 {
16033 }
16034 }
16036 /* Verify that the results of unification with the parameter packs
16037 produce results consistent with what we've seen before, and make
16038 the deduced argument packs available. */
16040 {
16047 /* By default keep the original deduced argument pack.
16048 If necessary, more specific code is going to update the
16049 resulting deduced argument later down in this function. */
16053 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
16054 actually deduce anything. */
16062 {
16063 /* If we had fewer function args than explicit template args,
16064 just use the explicits. */
16069 }
16072 {
16073 tree result;
16074 /* Build the deduced *_ARGUMENT_PACK. */
16076 {
16081 }
16082 else
16087 /* Note the deduced argument packs for this parameter
16088 pack. */
16090 }
16094 {
16095 /* We only had the explicitly-provided arguments before, but
16096 now we have a complete set of arguments. */
16102 }
16103 else
16104 {
16110 /* Inconsistent unification of this parameter pack. */
16112 bad_old_arg,
16113 bad_new_arg);
16114 }
16115 }
16118 }
16120 /* Deduce the value of template parameters. TPARMS is the (innermost)
16121 set of template parameters to a template. TARGS is the bindings
16122 for those template parameters, as determined thus far; TARGS may
16123 include template arguments for outer levels of template parameters
16124 as well. PARM is a parameter to a template function, or a
16125 subcomponent of that parameter; ARG is the corresponding argument.
16126 This function attempts to match PARM with ARG in a manner
16127 consistent with the existing assignments in TARGS. If more values
16128 are deduced, then TARGS is updated.
16130 Returns 0 if the type deduction succeeds, 1 otherwise. The
16131 parameter STRICT is a bitwise or of the following flags:
16133 UNIFY_ALLOW_NONE:
16134 Require an exact match between PARM and ARG.
16135 UNIFY_ALLOW_MORE_CV_QUAL:
16136 Allow the deduced ARG to be more cv-qualified (by qualification
16137 conversion) than ARG.
16138 UNIFY_ALLOW_LESS_CV_QUAL:
16139 Allow the deduced ARG to be less cv-qualified than ARG.
16140 UNIFY_ALLOW_DERIVED:
16141 Allow the deduced ARG to be a template base class of ARG,
16142 or a pointer to a template base class of the type pointed to by
16143 ARG.
16144 UNIFY_ALLOW_INTEGER:
16145 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
16146 case for more information.
16147 UNIFY_ALLOW_OUTER_LEVEL:
16148 This is the outermost level of a deduction. Used to determine validity
16149 of qualification conversions. A valid qualification conversion must
16150 have const qualified pointers leading up to the inner type which
16151 requires additional CV quals, except at the outer level, where const
16152 is not required [conv.qual]. It would be normal to set this flag in
16153 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
16154 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
16155 This is the outermost level of a deduction, and PARM can be more CV
16156 qualified at this point.
16157 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
16158 This is the outermost level of a deduction, and PARM can be less CV
16159 qualified at this point. */
16161 static int
16164 {
16166 tree targ;
16167 tree tparm;
16170 /* I don't think this will do the right thing with respect to types.
16171 But the only case I've seen it in so far has been array bounds, where
16172 signedness is the only information lost, and I think that will be
16173 okay. */
16181 /* We can't deduce anything from this, but we might get all the
16182 template args from other function args. */
16185 /* If PARM uses template parameters, then we can't bail out here,
16186 even if ARG == PARM, since we won't record unifications for the
16187 template parameters. We might need them if we're trying to
16188 figure out which of two things is more specialized. */
16192 /* Handle init lists early, so the rest of the function can assume
16193 we're dealing with a type. */
16195 {
16200 /* Replace T with std::initializer_list<T> for deduction. */
16206 /* We can only deduce from an initializer list argument if the
16207 parameter is std::initializer_list; otherwise this is a
16208 non-deduced context. */
16214 {
16221 {
16223 /* It should only be possible to get here for a call. */
16225 elt_strict |= maybe_adjust_types_for_deduction
16228 }
16231 explain_p);
16232 }
16234 /* If the std::initializer_list<T> deduction worked, replace the
16235 deduced A with std::initializer_list<A>. */
16237 {
16242 }
16244 }
16246 /* Immediately reject some pairs that won't unify because of
16247 cv-qualification mismatches. */
16250 /* It is the elements of the array which hold the cv quals of an array
16251 type, and the elements might be template type parms. We'll check
16252 when we recurse. */
16254 /* We check the cv-qualifiers when unifying with template type
16255 parameters below. We want to allow ARG `const T' to unify with
16256 PARM `T' for example, when computing which of two templates
16257 is more specialized, for example. */
16271 {
16275 /* In a type which contains a nested-name-specifier, template
16276 argument values cannot be deduced for template parameters used
16277 within the nested-name-specifier. */
16289 /* The PARM is not one we're trying to unify. Just check
16290 to see if it matches ARG. */
16291 {
16296 else
16298 }
16305 /* Check for mixed types and values. */
16313 {
16314 /* ARG must be constructed from a template class or a template
16315 template parameter. */
16320 {
16324 tree parm_parms
16325 = DECL_INNERMOST_TEMPLATE_PARMS
16330 /* The resolution to DR150 makes clear that default
16331 arguments for an N-argument may not be used to bind T
16332 to a template template parameter with fewer than N
16333 parameters. It is not safe to permit the binding of
16334 default arguments as an extension, as that may change
16335 the meaning of a conforming program. Consider:
16337 struct Dense { static const unsigned int dim = 1; };
16339 template <template <typename> class View,
16340 typename Block>
16341 void operator+(float, View<Block> const&);
16343 template <typename Block,
16344 unsigned int Dim = Block::dim>
16345 struct Lvalue_proxy { operator float() const; };
16347 void
16348 test_1d (void) {
16349 Lvalue_proxy<Dense> p;
16350 float b;
16351 b + p;
16352 }
16354 Here, if Lvalue_proxy is permitted to bind to View, then
16355 the global operator+ will be used; if they are not, the
16356 Lvalue_proxy will be converted to float. */
16358 full_argvec,
16360 (explain_p
16361 ? tf_warning_or_error
16368 /* Deduce arguments T, i from TT<T> or TT<i>.
16369 We check each element of PARMVEC and ARGVEC individually
16370 rather than the whole TREE_VEC since they can have
16371 different number of elements. */
16378 /* Check if the parameters end in a pack, making them
16379 variadic. */
16389 {
16394 }
16399 DEDUCE_EXACT,
16402 }
16405 /* Fall through to deduce template name. */
16406 }
16410 {
16411 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
16413 /* Simple cases: Value already set, does match or doesn't. */
16418 }
16419 else
16420 {
16421 /* If PARM is `const T' and ARG is only `int', we don't have
16422 a match unless we are allowing additional qualification.
16423 If ARG is `const int' and PARM is just `T' that's OK;
16424 that binds `const int' to `T'. */
16429 /* Consider the case where ARG is `const volatile int' and
16430 PARM is `const T'. Then, T should be `volatile int'. */
16431 arg = cp_build_qualified_type_real
16436 /* Simple cases: Value already set, does match or doesn't. */
16442 /* Make sure that ARG is not a variable-sized array. (Note
16443 that were talking about variable-sized arrays (like
16444 `int[n]'), rather than arrays of unknown size (like
16445 `int[]').) We'll get very confused by such a type since
16446 the bound of the array is not constant, and therefore
16447 not mangleable. Besides, such types are not allowed in
16448 ISO C++, so we can do as we please here. We do allow
16449 them for 'auto' deduction, since that isn't ABI-exposed. */
16453 /* Strip typedefs as in convert_template_argument. */
16455 }
16457 /* If ARG is a parameter pack or an expansion, we cannot unify
16458 against it unless PARM is also a parameter pack. */
16463 /* If the argument deduction results is a METHOD_TYPE,
16464 then there is a problem.
16465 METHOD_TYPE doesn't map to any real C++ type the result of
16466 the deduction can not be of that type. */
16480 {
16481 /* The PARM is not one we're trying to unify. Just check
16482 to see if it matches ARG. */
16488 }
16494 {
16499 }
16501 /* [temp.deduct.type] If, in the declaration of a function template
16502 with a non-type template-parameter, the non-type
16503 template-parameter is used in an expression in the function
16504 parameter-list and, if the corresponding template-argument is
16505 deduced, the template-argument type shall match the type of the
16506 template-parameter exactly, except that a template-argument
16507 deduced from an array bound may be of any integral type.
16508 The non-type parameter might use already deduced type parameters. */
16511 /* Template-parameter dependent expression. Just accept it for now.
16512 It will later be processed in convert_template_argument. */
16513 ;
16519 /* Convert the ARG to the type of PARM; the deduced non-type
16520 template argument must exactly match the types of the
16521 corresponding parameter. */
16524 /* We haven't deduced the type of this parameter yet. Try again
16525 later. */
16527 else
16530 /* If ARG is a parameter pack or an expansion, we cannot unify
16531 against it unless PARM is also a parameter pack. */
16541 {
16542 /* A pointer-to-member constant can be unified only with
16543 another constant. */
16547 /* Just unify the class member. It would be useless (and possibly
16548 wrong, depending on the strict flags) to unify also
16549 PTRMEM_CST_CLASS, because we want to be sure that both parm and
16550 arg refer to the same variable, even if through different
16551 classes. For instance:
16553 struct A { int x; };
16554 struct B : A { };
16556 Unification of &A::x and &B::x must succeed. */
16559 }
16562 {
16566 /* [temp.deduct.call]
16568 A can be another pointer or pointer to member type that can
16569 be converted to the deduced A via a qualification
16570 conversion (_conv.qual_).
16572 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
16573 This will allow for additional cv-qualification of the
16574 pointed-to types if appropriate. */
16577 /* The derived-to-base conversion only persists through one
16578 level of pointers. */
16583 }
16598 {
16599 tree parm_max;
16600 tree arg_max;
16604 /* Our representation of array types uses "N - 1" as the
16605 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
16606 not an integer constant. We cannot unify arbitrarily
16607 complex expressions, so we eliminate the MINUS_EXPRs
16608 here. */
16612 {
16615 }
16619 {
16620 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
16621 trying to unify the type of a variable with the type
16622 of a template parameter. For example:
16624 template <unsigned int N>
16625 void f (char (&) [N]);
16626 int g();
16627 void h(int i) {
16628 char a[g(i)];
16629 f(a);
16630 }
16632 Here, the type of the ARG will be "int [g(i)]", and
16633 may be a SAVE_EXPR, etc. */
16637 }
16639 /* If only one of the bounds used a MINUS_EXPR, compensate
16640 by adding one to the other bound. */
16643 integer_type_node,
16644 parm_max,
16645 integer_one_node);
16648 integer_type_node,
16649 arg_max,
16650 integer_one_node);
16654 }
16669 /* We have already checked cv-qualification at the top of the
16670 function. */
16674 /* As far as unification is concerned, this wins. Later checks
16675 will invalidate it if necessary. */
16678 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
16679 /* Type INTEGER_CST can come from ordinary constant template args. */
16691 {
16701 /* Check for pack expansions in the parameters. */
16703 {
16705 {
16707 /* We can unify against something with a trailing
16708 parameter pack. */
16710 else
16711 /* [temp.deduct.type]/9: If the template argument list of
16712 P contains a pack expansion that is not the last
16713 template argument, the entire template argument list
16714 is a non-deduced context. */
16716 }
16717 }
16719 /* If we don't have enough arguments to satisfy the parameters
16720 (not counting the pack expression at the end), or we have
16721 too many arguments for a parameter list that doesn't end in
16722 a pack expression, we can't unify. */
16728 /* Unify all of the parameters that precede the (optional)
16729 pack expression. */
16731 {
16736 }
16739 DEDUCE_EXACT,
16742 }
16750 {
16758 }
16761 {
16765 {
16766 /* First, we try to unify the PARM and ARG directly. */
16771 {
16772 /* Fallback to the special case allowed in
16773 [temp.deduct.call]:
16775 If P is a class, and P has the form
16776 template-id, then A can be a derived class of
16777 the deduced A. Likewise, if P is a pointer to
16778 a class of the form template-id, A can be a
16779 pointer to a derived class pointed to by the
16780 deduced A. */
16787 }
16788 }
16792 /* Perhaps PARM is something like S<U> and ARG is S<int>.
16793 Then, we should unify `int' and `U'. */
16795 else
16796 /* There's no chance of unification succeeding. */
16801 }
16808 {
16811 tree a;
16817 /* CV qualifications for methods can never be deduced, they must
16818 match exactly. We need to check them explicitly here,
16819 because type_unification_real treats them as any other
16820 cv-qualified parameter. */
16822 && (!check_cv_quals_for_unify
16842 }
16845 /* Unify a pointer to member with a pointer to member function, which
16846 deduces the type of the member as a function type. */
16848 {
16849 tree method_type;
16850 tree fntype;
16852 /* Check top-level cv qualifiers */
16860 /* Determine the type of the function we are unifying against. */
16862 fntype =
16866 /* Extract the cv-qualifiers of the member function from the
16867 implicit object parameter and place them on the function
16868 type to be restored later. */
16871 }
16890 /* Matched cases are handled by the ARG == PARM test above. */
16894 /* A non-type template parameter that is a variable should be a
16895 an integral constant, in which case, it whould have been
16896 folded into its (constant) value. So we should not be getting
16897 a variable here. */
16908 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
16909 or UNDERLYING_TYPE nodes. */
16913 /* Unification fails if we hit an error node. */
16917 /* An unresolved overload is a nondeduced context. */
16922 /* We must be looking at an expression. This can happen with
16923 something like:
16925 template <int I>
16926 void foo(S<I>, S<I + 2>);
16928 This is a "nondeduced context":
16930 [deduct.type]
16932 The nondeduced contexts are:
16934 --A type that is a template-id in which one or more of
16935 the template-arguments is an expression that references
16936 a template-parameter.
16938 In these cases, we assume deduction succeeded, but don't
16939 actually infer any unifications. */
16944 else
16946 }
16947 }
16948 #undef RECUR_AND_CHECK_FAILURE
16949 \f
16950 /* Note that DECL can be defined in this translation unit, if
16951 required. */
16953 static void
16955 {
16956 tree clone;
16960 }
16962 /* Called if RESULT is explicitly instantiated, or is a member of an
16963 explicitly instantiated class. */
16965 void
16967 {
16970 /* If this entity has already been written out, it's too late to
16971 make any modifications. */
16976 /* The TREE_PUBLIC flag for function declarations will have been
16977 set correctly by tsubst. */
16980 /* This might have been set by an earlier implicit instantiation. */
16985 else
16986 {
16988 /* Always make artificials weak. */
16991 /* For WIN32 we also want to put explicit instantiations in
16992 linkonce sections. */
16995 }
16997 /* If EXTERN_P, then this function will not be emitted -- unless
16998 followed by an explicit instantiation, at which point its linkage
16999 will be adjusted. If !EXTERN_P, then this function will be
17000 emitted here. In neither circumstance do we want
17001 import_export_decl to adjust the linkage. */
17003 }
17005 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
17006 important template arguments. If any are missing, we check whether
17007 they're important by using error_mark_node for substituting into any
17008 args that were used for partial ordering (the ones between ARGS and END)
17009 and seeing if it bubbles up. */
17011 static bool
17013 {
17018 {
17021 }
17023 {
17027 }
17029 }
17031 /* Given two function templates PAT1 and PAT2, return:
17033 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
17034 -1 if PAT2 is more specialized than PAT1.
17035 0 if neither is more specialized.
17037 LEN indicates the number of parameters we should consider
17038 (defaulted parameters should not be considered).
17040 The 1998 std underspecified function template partial ordering, and
17041 DR214 addresses the issue. We take pairs of arguments, one from
17042 each of the templates, and deduce them against each other. One of
17043 the templates will be more specialized if all the *other*
17044 template's arguments deduce against its arguments and at least one
17045 of its arguments *does* *not* deduce against the other template's
17046 corresponding argument. Deduction is done as for class templates.
17047 The arguments used in deduction have reference and top level cv
17048 qualifiers removed. Iff both arguments were originally reference
17049 types *and* deduction succeeds in both directions, the template
17050 with the more cv-qualified argument wins for that pairing (if
17051 neither is more cv-qualified, they both are equal). Unlike regular
17052 deduction, after all the arguments have been deduced in this way,
17053 we do *not* verify the deduced template argument values can be
17054 substituted into non-deduced contexts.
17056 The logic can be a bit confusing here, because we look at deduce1 and
17057 targs1 to see if pat2 is at least as specialized, and vice versa; if we
17058 can find template arguments for pat1 to make arg1 look like arg2, that
17059 means that arg2 is at least as specialized as arg1. */
17061 int
17063 {
17076 /* Remove the this parameter from non-static member functions. If
17077 one is a non-static member function and the other is not a static
17078 member function, remove the first parameter from that function
17079 also. This situation occurs for operator functions where we
17080 locate both a member function (with this pointer) and non-member
17081 operator (with explicit first operand). */
17083 {
17088 }
17090 {
17093 {
17094 len--;
17096 }
17097 }
17099 /* If only one is a conversion operator, they are unordered. */
17103 /* Consider the return type for a conversion function */
17105 {
17108 len++;
17109 }
17111 processing_template_decl++;
17117 /* Stop when an ellipsis is seen. */
17119 {
17128 {
17129 /* When both arguments are pack expansions, we need only
17130 unify the patterns themselves. */
17134 /* This is the last comparison we need to do. */
17136 }
17139 {
17142 }
17145 {
17148 }
17154 {
17160 /* Setup the parameter vector, which contains only ARG1. */
17163 /* Setup the argument vector, which contains the remaining
17164 arguments. */
17173 /* We cannot deduce in the other direction, because ARG1 is
17174 a pack expansion but ARG2 is not. */
17176 }
17178 {
17184 /* Setup the parameter vector, which contains only ARG1. */
17187 /* Setup the argument vector, which contains the remaining
17188 arguments. */
17197 /* We cannot deduce in the other direction, because ARG2 is
17198 a pack expansion but ARG1 is not.*/
17200 }
17202 else
17203 {
17204 /* The normal case, where neither argument is a pack
17205 expansion. */
17212 }
17214 /* If we couldn't deduce arguments for tparms1 to make arg1 match
17215 arg2, then arg2 is not as specialized as arg1. */
17221 /* "If, for a given type, deduction succeeds in both directions
17222 (i.e., the types are identical after the transformations above)
17223 and if the type from the argument template is more cv-qualified
17224 than the type from the parameter template (as described above)
17225 that type is considered to be more specialized than the other. If
17226 neither type is more cv-qualified than the other then neither type
17227 is more specialized than the other." */
17231 {
17236 }
17239 /* We've failed to deduce something in either direction.
17240 These must be unordered. */
17245 /* We have already processed all of the arguments in our
17246 handing of the pack expansion type. */
17251 }
17253 /* "In most cases, all template parameters must have values in order for
17254 deduction to succeed, but for partial ordering purposes a template
17255 parameter may remain without a value provided it is not used in the
17256 types being used for partial ordering."
17258 Thus, if we are missing any of the targs1 we need to substitute into
17259 origs1, then pat2 is not as specialized as pat1. This can happen when
17260 there is a nondeduced context. */
17266 processing_template_decl--;
17268 /* All things being equal, if the next argument is a pack expansion
17269 for one function but not for the other, prefer the
17270 non-variadic function. FIXME this is bogus; see c++/41958. */
17274 {
17277 }
17283 else
17285 }
17287 /* Determine which of two partial specializations of MAIN_TMPL is more
17288 specialized.
17290 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
17291 to the first partial specialization. The TREE_VALUE is the
17292 innermost set of template parameters for the partial
17293 specialization. PAT2 is similar, but for the second template.
17295 Return 1 if the first partial specialization is more specialized;
17296 -1 if the second is more specialized; 0 if neither is more
17297 specialized.
17299 See [temp.class.order] for information about determining which of
17300 two templates is more specialized. */
17302 static int
17304 {
17305 tree targs;
17313 /* Just like what happens for functions, if we are ordering between
17314 different class template specializations, we may encounter dependent
17315 types in the arguments, and we need our dependency check functions
17316 to behave correctly. */
17322 {
17325 }
17331 {
17334 }
17337 /* In the case of a tie where at least one of the class templates
17338 has a parameter pack at the end, the template with the most
17339 non-packed parameters wins. */
17341 && any_deductions
17344 {
17350 /* We don't count the pack expansion at the end. */
17360 }
17363 }
17365 /* Return the template arguments that will produce the function signature
17366 DECL from the function template FN, with the explicit template
17367 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
17368 also match. Return NULL_TREE if no satisfactory arguments could be
17369 found. */
17371 static tree
17373 {
17377 tree decl_arg_types;
17380 tree arg;
17384 /* Never do unification on the 'this' parameter. */
17404 }
17406 /* Return the innermost template arguments that, when applied to a partial
17407 specialization of MAIN_TMPL whose innermost template parameters are
17408 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
17409 ARGS.
17411 For example, suppose we have:
17413 template <class T, class U> struct S {};
17414 template <class T> struct S<T*, int> {};
17416 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
17417 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
17418 int}. The resulting vector will be {double}, indicating that `T'
17419 is bound to `double'. */
17421 static tree
17423 {
17425 tree deduced_args;
17426 tree innermost_deduced_args;
17430 {
17434 innermost_deduced_args);
17435 }
17436 else
17449 /* Verify that nondeduced template arguments agree with the type
17450 obtained from argument deduction.
17452 For example:
17454 struct A { typedef int X; };
17455 template <class T, class U> struct C {};
17456 template <class T> struct C<T, typename T::X> {};
17458 Then with the instantiation `C<A, int>', we can deduce that
17459 `T' is `A' but unify () does not check whether `typename T::X'
17460 is `int'. */
17466 /* We only need to check the innermost arguments; the other
17467 arguments will always agree. */
17472 /* Now that we have bindings for all of the template arguments,
17473 ensure that the arguments deduced for the template template
17474 parameters have compatible template parameter lists. See the use
17475 of template_template_parm_bindings_ok_p in fn_type_unification
17476 for more information. */
17481 }
17483 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
17484 Return the TREE_LIST node with the most specialized template, if
17485 any. If there is no most specialized template, the error_mark_node
17486 is returned.
17488 Note that this function does not look at, or modify, the
17489 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
17490 returned is one of the elements of INSTANTIATIONS, callers may
17491 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
17492 and retrieve it from the value returned. */
17494 tree
17496 {
17503 {
17509 fate--;
17514 fate++;
17519 {
17520 /* Equally specialized, move to next function. If there
17521 is no next function, nothing's most specialized. */
17526 }
17527 }
17530 /* Now verify that champ is better than everything earlier in the
17531 instantiation list. */
17539 {
17542 }
17544 processing_template_decl--;
17550 }
17552 /* If DECL is a specialization of some template, return the most
17553 general such template. Otherwise, returns NULL_TREE.
17555 For example, given:
17557 template <class T> struct S { template <class U> void f(U); };
17559 if TMPL is `template <class U> void S<int>::f(U)' this will return
17560 the full template. This function will not trace past partial
17561 specializations, however. For example, given in addition:
17563 template <class T> struct S<T*> { template <class U> void f(U); };
17565 if TMPL is `template <class U> void S<int*>::f(U)' this will return
17566 `template <class T> template <class U> S<T*>::f(U)'. */
17568 tree
17570 {
17571 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
17572 an immediate specialization. */
17574 {
17578 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
17579 template friend. */
17584 }
17586 /* Look for more and more general templates. */
17588 {
17589 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
17590 (See cp-tree.h for details.) */
17598 /* Stop if we run into an explicitly specialized class template. */
17605 }
17608 }
17610 /* Return the most specialized of the class template partial
17611 specializations of TMPL which can produce TYPE, a specialization of
17612 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
17613 a _TYPE node corresponding to the partial specialization, while the
17614 TREE_PURPOSE is the set of template arguments that must be
17615 substituted into the TREE_TYPE in order to generate TYPE.
17617 If the choice of partial specialization is ambiguous, a diagnostic
17618 is issued, and the error_mark_node is returned. If there are no
17619 partial specializations of TMPL matching TYPE, then NULL_TREE is
17620 returned. */
17622 static tree
17624 {
17626 tree t;
17627 tree champ;
17630 tree args;
17636 /* For determining which partial specialization to use, only the
17637 innermost args are interesting. */
17639 {
17642 }
17645 {
17646 tree partial_spec_args;
17647 tree spec_args;
17655 {
17658 /* Discard the outer levels of args, and then substitute in the
17659 template args from the enclosing class. */
17661 partial_spec_args = tsubst_template_args
17664 /* PARMS already refers to just the innermost parms, but the
17665 template parms in partial_spec_args had their levels lowered
17666 by tsubst, so we need to do the same for the parm list. We
17667 can't just tsubst the TREE_VEC itself, as tsubst wants to
17668 treat a TREE_VEC as an argument vector. */
17674 }
17676 partial_spec_args =
17679 partial_spec_args),
17690 partial_spec_args,
17691 args);
17693 {
17698 }
17699 }
17709 {
17712 ;
17713 else
17714 {
17716 {
17719 {
17722 }
17723 }
17725 }
17726 }
17730 {
17733 {
17736 }
17737 }
17740 {
17748 {
17751 }
17754 }
17757 }
17759 /* Explicitly instantiate DECL. */
17761 void
17763 {
17768 /* An error occurred, for which grokdeclarator has already issued
17769 an appropriate message. */
17772 {
17775 }
17777 {
17778 /* There is an asymmetry here in the way VAR_DECLs and
17779 FUNCTION_DECLs are handled by grokdeclarator. In the case of
17780 the latter, the DECL we get back will be marked as a
17781 template instantiation, and the appropriate
17782 DECL_TEMPLATE_INFO will be set up. This does not happen for
17783 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
17784 should handle VAR_DECLs as it currently handles
17785 FUNCTION_DECLs. */
17787 {
17790 }
17793 {
17796 }
17798 {
17803 }
17804 }
17806 {
17809 }
17810 else
17813 /* Check for various error cases. Note that if the explicit
17814 instantiation is valid the RESULT will currently be marked as an
17815 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
17816 until we get here. */
17819 {
17820 /* DR 259 [temp.spec].
17822 Both an explicit instantiation and a declaration of an explicit
17823 specialization shall not appear in a program unless the explicit
17824 instantiation follows a declaration of the explicit specialization.
17826 For a given set of template parameters, if an explicit
17827 instantiation of a template appears after a declaration of an
17828 explicit specialization for that template, the explicit
17829 instantiation has no effect. */
17831 }
17833 {
17834 /* [temp.spec]
17836 No program shall explicitly instantiate any template more
17837 than once.
17839 We check DECL_NOT_REALLY_EXTERN so as not to complain when
17840 the first instantiation was `extern' and the second is not,
17841 and EXTERN_P for the opposite case. */
17844 /* If an "extern" explicit instantiation follows an ordinary
17845 explicit instantiation, the template is instantiated. */
17848 }
17850 {
17853 }
17855 {
17858 }
17861 ;
17863 {
17866 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
17869 }
17870 else
17878 }
17880 static void
17882 {
17888 {
17891 }
17892 }
17894 /* Called from do_type_instantiation through binding_table_foreach to
17895 do recursive instantiation for the type bound in ENTRY. */
17896 static void
17898 {
17904 }
17906 /* Called from do_type_instantiation to instantiate a member
17907 (a member function or a static member variable) of an
17908 explicitly instantiated class template. */
17909 static void
17911 {
17916 }
17918 /* Perform an explicit instantiation of template class T. STORAGE, if
17919 non-null, is the RID for extern, inline or static. COMPLAIN is
17920 nonzero if this is called from the parser, zero if called recursively,
17921 since the standard is unclear (as detailed below). */
17923 void
17925 {
17935 {
17936 tree tmpl =
17940 else
17943 }
17948 {
17951 t);
17953 }
17956 {
17958 {
17960 {
17963 "ISO C++ 1998 forbids the use of %<extern%> on "
17965 }
17966 else
17968 "ISO C++ forbids the use of %qE"
17970 }
17978 else
17979 {
17981 storage);
17983 }
17984 }
17987 {
17988 /* DR 259 [temp.spec].
17990 Both an explicit instantiation and a declaration of an explicit
17991 specialization shall not appear in a program unless the explicit
17992 instantiation follows a declaration of the explicit specialization.
17994 For a given set of template parameters, if an explicit
17995 instantiation of a template appears after a declaration of an
17996 explicit specialization for that template, the explicit
17997 instantiation has no effect. */
17999 }
18001 {
18002 /* [temp.spec]
18004 No program shall explicitly instantiate any template more
18005 than once.
18007 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
18008 instantiation was `extern'. If EXTERN_P then the second is.
18009 These cases are OK. */
18016 /* If we've already instantiated the template, just return now. */
18019 }
18027 {
18028 tree tmp;
18030 /* In contrast to implicit instantiation, where only the
18031 declarations, and not the definitions, of members are
18032 instantiated, we have here:
18034 [temp.explicit]
18036 The explicit instantiation of a class template specialization
18037 implies the instantiation of all of its members not
18038 previously explicitly specialized in the translation unit
18039 containing the explicit instantiation.
18041 Of course, we can't instantiate member template classes, since
18042 we don't have any arguments for them. Note that the standard
18043 is unclear on whether the instantiation of the members are
18044 *explicit* instantiations or not. However, the most natural
18045 interpretation is that it should be an explicit instantiation. */
18060 }
18061 }
18063 /* Given a function DECL, which is a specialization of TMPL, modify
18064 DECL to be a re-instantiation of TMPL with the same template
18065 arguments. TMPL should be the template into which tsubst'ing
18066 should occur for DECL, not the most general template.
18068 One reason for doing this is a scenario like this:
18070 template <class T>
18071 void f(const T&, int i);
18073 void g() { f(3, 7); }
18075 template <class T>
18076 void f(const T& t, const int i) { }
18078 Note that when the template is first instantiated, with
18079 instantiate_template, the resulting DECL will have no name for the
18080 first parameter, and the wrong type for the second. So, when we go
18081 to instantiate the DECL, we regenerate it. */
18083 static void
18085 {
18086 /* The arguments used to instantiate DECL, from the most general
18087 template. */
18088 tree args;
18089 tree code_pattern;
18094 /* Make sure that we can see identifiers, and compute access
18095 correctly. */
18099 {
18100 tree decl_parm;
18101 tree pattern_parm;
18102 tree specs;
18116 specs);
18118 /* Merge parameter declarations. */
18121 pattern_parm
18125 {
18126 tree parm_type;
18127 tree attributes;
18132 NULL_TREE);
18138 {
18141 }
18144 }
18145 /* Merge any parameters that match with the function parameter
18146 pack. */
18148 {
18150 tree expanded_types;
18151 /* Expand the TYPE_PACK_EXPANSION that provides the types for
18152 the parameters in this function parameter pack. */
18157 {
18158 tree parm_type;
18159 tree attributes;
18162 /* Rename the parameter to include the index. */
18171 {
18174 }
18176 }
18177 }
18178 /* Merge additional specifiers from the CODE_PATTERN. */
18182 }
18184 {
18192 }
18193 else
18197 }
18199 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
18200 substituted to get DECL. */
18202 tree
18204 {
18207 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
18208 for the instantiation. This is not always the most general
18209 template. Consider, for example:
18211 template <class T>
18212 struct S { template <class U> void f();
18213 template <> void f<int>(); };
18215 and an instantiation of S<double>::f<int>. We want TD to be the
18216 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
18218 more general template. */
18220 /* We must also deal with friend templates. Given:
18222 template <class T> struct S {
18223 template <class U> friend void f() {};
18224 };
18226 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
18227 so far as the language is concerned, but that's still
18228 where we get the pattern for the instantiation from. On
18229 other hand, if the definition comes outside the class, say:
18231 template <class T> struct S {
18232 template <class U> friend void f();
18233 };
18234 template <class U> friend void f() {}
18236 we don't need to look any further. That's what the check for
18237 DECL_INITIAL is for. */
18241 {
18242 /* The present template, TD, should not be a definition. If it
18243 were a definition, we should be using it! Note that we
18244 cannot restructure the loop to just keep going until we find
18245 a template with a definition, since that might go too far if
18246 a specialization was declared, but not defined. */
18250 /* Fetch the more general template. */
18252 }
18255 }
18257 /* Returns true if we need to instantiate this template instance even if we
18258 know we aren't going to emit it.. */
18260 bool
18262 {
18263 /* We always instantiate inline functions so that we can inline them. An
18264 explicit instantiation declaration prohibits implicit instantiation of
18265 non-inline functions. With high levels of optimization, we would
18266 normally inline non-inline functions -- but we're not allowed to do
18267 that for "extern template" functions. Therefore, we check
18268 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
18272 /* And we need to instantiate static data members so that
18273 their initializers are available in integral constant
18274 expressions. */
18277 }
18279 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
18280 instantiate it now, modifying TREE_TYPE (fn). */
18282 void
18284 {
18298 {
18300 {
18313 }
18314 else
18316 }
18317 else
18318 {
18319 /* This is an implicitly declared function, so NOEX is a list of
18320 other functions to evaluate and merge. */
18321 tree elt;
18324 {
18326 tree subspec;
18330 }
18331 }
18336 {
18339 else
18341 }
18342 }
18344 /* Produce the definition of D, a _DECL generated from a template. If
18345 DEFER_OK is nonzero, then we don't have to actually do the
18346 instantiation now; we just have to do it sometime. Normally it is
18347 an error if this is an explicit instantiation but D is undefined.
18348 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
18349 explicitly instantiated class template. */
18351 tree
18354 {
18356 tree gen_args;
18357 tree args;
18358 tree td;
18359 tree code_pattern;
18360 tree spec;
18361 tree gen_tmpl;
18365 tree fn_context;
18368 /* This function should only be used to instantiate templates for
18369 functions and static member variables. */
18373 /* Variables are never deferred; if instantiation is required, they
18374 are instantiated right away. That allows for better code in the
18375 case that an expression refers to the value of the variable --
18376 if the variable has a constant value the referring expression can
18377 take advantage of that fact. */
18382 /* Don't instantiate cloned functions. Instead, instantiate the
18383 functions they cloned. */
18391 /* D has already been instantiated or explicitly specialized, so
18392 there's nothing for us to do here.
18394 It might seem reasonable to check whether or not D is an explicit
18395 instantiation, and, if so, stop here. But when an explicit
18396 instantiation is deferred until the end of the compilation,
18397 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
18398 the instantiation. */
18401 /* Check to see whether we know that this template will be
18402 instantiated in some other file, as with "extern template"
18403 extension. */
18406 /* In general, we do not instantiate such templates. */
18414 /* We should already have the extra args. */
18417 /* And what's in the hash table should match D. */
18421 /* This needs to happen before any tsubsting. */
18427 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
18428 for the instantiation. */
18432 /* We should never be trying to instantiate a member of a class
18433 template or partial specialization. */
18438 /* In the case of a friend template whose definition is provided
18439 outside the class, we may have too many arguments. Drop the
18440 ones we don't need. The same is true for specializations. */
18441 args = get_innermost_template_args
18443 else
18449 else
18452 /* We may be in the middle of deferred access check. Disable it now. */
18455 /* Unless an explicit instantiation directive has already determined
18456 the linkage of D, remember that a definition is available for
18457 this entity. */
18467 /* If D is a member of an explicitly instantiated class template,
18468 and no definition is available, treat it like an implicit
18469 instantiation. */
18472 {
18473 /* Leave linkage flags alone on instantiations with anonymous
18474 visibility. */
18476 {
18479 }
18481 }
18486 /* Defer all other templates, unless we have been explicitly
18487 forbidden from doing so. */
18489 template. */
18490 ! pattern_defined
18491 /* If it's OK to postpone instantiation, do so. */
18492 || defer_ok
18493 /* If this is a static data member that will be defined
18494 elsewhere, we don't want to instantiate the entire data
18495 member, but we do want to instantiate the initializer so that
18496 we can substitute that elsewhere. */
18498 {
18499 /* The definition of the static data member is now required so
18500 we must substitute the initializer. */
18504 {
18505 tree ns;
18506 tree init;
18513 args,
18516 /* Make sure the initializer is still constant, in case of
18517 circular dependency (template/instantiate6.C). */
18518 const_init
18522 LOOKUP_ONLYCONVERTING);
18525 }
18527 /* We restore the source position here because it's used by
18528 add_pending_template. */
18534 /* [temp.explicit]
18536 The definition of a non-exported function template, a
18537 non-exported member function template, or a non-exported
18538 member function or static data member of a class template
18539 shall be present in every translation unit in which it is
18540 explicitly instantiated. */
18544 /* If we're in unevaluated context, we just wanted to get the
18545 constant value; this isn't an odr use, so don't queue
18546 a full instantiation. */
18549 /* ??? Historically, we have instantiated inline functions, even
18550 when marked as "extern template". */
18554 }
18555 /* Tell the repository that D is available in this translation unit
18556 -- and see if it is supposed to be instantiated here. */
18558 {
18559 /* In a PCH file, despite the fact that the repository hasn't
18560 requested instantiation in the PCH it is still possible that
18561 an instantiation will be required in a file that includes the
18562 PCH. */
18565 /* Instantiate inline functions so that the inliner can do its
18566 job, even though we'll not be emitting a copy of this
18567 function. */
18570 }
18579 /* Mark D as instantiated so that recursive calls to
18580 instantiate_decl do not try to instantiate it again. */
18583 /* Regenerate the declaration in case the template has been modified
18584 by a subsequent redeclaration. */
18587 /* We already set the file and line above. Reset them now in case
18588 they changed as a result of calling regenerate_decl_from_template. */
18592 {
18593 tree init;
18596 /* Clear out DECL_RTL; whatever was there before may not be right
18597 since we've reset the type of the declaration. */
18601 /* The initializer is placed in DECL_INITIAL by
18602 regenerate_decl_from_template so we don't need to
18603 push/pop_access_scope again here. Pull it out so that
18604 cp_finish_decl can process it. */
18609 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
18610 initializer. That function will defer actual emission until
18611 we have a chance to determine linkage. */
18614 /* Enter the scope of D so that access-checking works correctly. */
18619 }
18623 {
18625 tree subst_decl;
18626 tree tmpl_parm;
18627 tree spec_parm;
18629 /* Save away the current list, in case we are instantiating one
18630 template from within the body of another. */
18633 /* Set up the list of local specializations. */
18636 /* Set up context. */
18639 /* Some typedefs referenced from within the template code need to be
18640 access checked at template instantiation time, i.e now. These
18641 types were added to the template at parsing time. Let's get those
18642 and perform the access checks then. */
18644 gen_args);
18646 /* Create substitution entries for the parameters. */
18651 {
18655 }
18657 {
18659 {
18662 }
18663 else
18664 {
18665 /* Register the (value) argument pack as a specialization of
18666 TMPL_PARM, then move on. */
18669 }
18670 }
18673 /* Substitute into the body of the function. */
18678 /* Set the current input_location to the end of the function
18679 so that finish_function knows where we are. */
18682 /* We don't need the local specializations any more. */
18686 /* Finish the function. */
18689 }
18691 /* We're not deferring instantiation any more. */
18699 out:
18707 }
18709 /* Run through the list of templates that we wish we could
18710 instantiate, and instantiate any we can. RETRIES is the
18711 number of times we retry pending template instantiation. */
18713 void
18715 {
18719 /* Instantiating templates may trigger vtable generation. This in turn
18720 may require further template instantiations. We place a limit here
18721 to avoid infinite loop. */
18723 {
18727 " instantiating %q+D, possibly from virtual table generation"
18731 /* Pretend that we defined it. */
18734 }
18736 do
18737 {
18742 {
18747 {
18748 tree fn;
18751 {
18755 fn;
18763 }
18766 }
18767 else
18768 {
18771 {
18772 instantiation
18778 }
18782 }
18785 /* If INSTANTIATION has been instantiated, then we don't
18786 need to consider it again in the future. */
18788 else
18789 {
18792 }
18795 }
18797 }
18801 }
18803 /* Substitute ARGVEC into T, which is a list of initializers for
18804 either base class or a non-static data member. The TREE_PURPOSEs
18805 are DECLs, and the TREE_VALUEs are the initializer values. Used by
18806 instantiate_decl. */
18808 static tree
18810 {
18814 {
18815 tree decl;
18816 tree init;
18822 {
18823 tree expr;
18824 tree arg;
18826 /* Expand the base class expansion type into separate base
18827 classes. */
18829 tf_warning_or_error,
18830 NULL_TREE);
18834 /* We'll be building separate TREE_LISTs of arguments for
18835 each base. */
18841 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
18842 expand each argument in the TREE_VALUE of t. */
18849 /* VOID_TYPE_NODE is used to indicate
18850 value-initialization. */
18851 {
18854 }
18855 else
18856 {
18857 /* Substitute parameter packs into each argument in the
18858 TREE_LIST. */
18861 {
18862 tree expanded_exprs;
18864 /* Expand the argument. */
18866 expanded_exprs
18868 tf_warning_or_error,
18869 NULL_TREE);
18873 /* Prepend each of the expanded expressions to the
18874 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
18876 {
18881 }
18882 }
18885 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
18886 since we built them backwards. */
18888 {
18891 }
18892 }
18893 }
18896 {
18898 {
18902 }
18903 else
18904 {
18905 tree tmp;
18920 /* If we had an initializer but it instantiated to nothing,
18921 value-initialize the object. This will only occur when
18922 the initializer was a pack expansion where the parameter
18923 packs used in that expansion were of length zero. */
18926 }
18929 {
18933 }
18934 }
18935 }
18937 }
18939 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
18941 static void
18943 {
18948 else
18950 }
18952 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
18953 is the instantiation (which should have been created with
18954 start_enum) and ARGS are the template arguments to use. */
18956 static void
18958 {
18959 tree e;
18965 {
18966 tree value;
18967 tree decl;
18970 /* Note that in a template enum, the TREE_VALUE is the
18971 CONST_DECL, not the corresponding INTEGER_CST. */
18976 /* Give this enumeration constant the correct access. */
18979 /* Actually build the enumerator itself. */
18980 build_enumerator
18982 }
18992 }
18994 /* DECL is a FUNCTION_DECL that is a template specialization. Return
18995 its type -- but without substituting the innermost set of template
18996 arguments. So, innermost set of template parameters will appear in
18997 the type. */
18999 tree
19001 {
19002 tree fn_type;
19003 tree tmpl;
19004 tree targs;
19005 tree tparms;
19013 /* There should be as many levels of arguments as there are levels
19014 of parameters. */
19020 /* No substitution is necessary. */
19021 ;
19022 else
19023 {
19025 tree partial_args;
19027 /* Replace the innermost level of the TARGS with NULL_TREEs to
19028 let tsubst know not to substitute for those parameters. */
19037 /* Make sure that we can see identifiers, and compute access
19038 correctly. */
19042 /* Now, do the (partial) substitution to figure out the
19043 appropriate function type. */
19047 /* Substitute into the template parameters to obtain the real
19048 innermost set of parameters. This step is important if the
19049 innermost set of template parameters contains value
19050 parameters whose types depend on outer template parameters. */
19055 }
19058 }
19060 /* Return truthvalue if we're processing a template different from
19061 the last one involved in diagnostics. */
19062 int
19064 {
19066 }
19068 /* Remember current template involved in diagnostics. */
19069 void
19071 {
19073 }
19077 {
19079 }
19081 /* [temp.param] Check that template non-type parm TYPE is of an allowable
19082 type. Return zero for ok, nonzero for disallowed. Issue error and
19083 warning messages under control of COMPLAIN. */
19085 static int
19087 {
19104 {
19107 else
19109 type);
19110 }
19112 }
19114 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
19115 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
19117 static bool
19119 {
19120 tree scope;
19122 /* [temp.dep.type]
19124 A type is dependent if it is:
19126 -- a template parameter. Template template parameters are types
19127 for us (since TYPE_P holds true for them) so we handle
19128 them here. */
19132 /* -- a qualified-id with a nested-name-specifier which contains a
19133 class-name that names a dependent type or whose unqualified-id
19134 names a dependent type. */
19137 /* -- a cv-qualified type where the cv-unqualified type is
19138 dependent. */
19140 /* -- a compound type constructed from any dependent type. */
19150 {
19151 tree arg_type;
19156 arg_type;
19161 }
19162 /* -- an array type constructed from any dependent type or whose
19163 size is specified by a constant expression that is
19164 value-dependent.
19166 We checked for type- and value-dependence of the bounds in
19167 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
19169 {
19174 }
19176 /* -- a template-id in which either the template name is a template
19177 parameter ... */
19180 /* ... or any of the template arguments is a dependent type or
19181 an expression that is type-dependent or value-dependent. */
19183 && (any_dependent_template_arguments_p
19187 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
19188 dependent; if the argument of the `typeof' expression is not
19189 type-dependent, then it should already been have resolved. */
19195 /* A template argument pack is dependent if any of its packed
19196 arguments are. */
19198 {
19204 }
19206 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
19207 be template parameters. */
19211 /* The standard does not specifically mention types that are local
19212 to template functions or local classes, but they should be
19213 considered dependent too. For example:
19215 template <int I> void f() {
19216 enum E { a = I };
19217 S<sizeof (E)> s;
19218 }
19220 The size of `E' cannot be known until the value of `I' has been
19221 determined. Therefore, `E' must be considered dependent. */
19225 /* Don't use type_dependent_expression_p here, as it can lead
19226 to infinite recursion trying to determine whether a lambda
19227 nested in a lambda is dependent (c++/47687). */
19231 && (any_dependent_template_arguments_p
19235 /* Other types are non-dependent. */
19237 }
19239 /* Returns TRUE if TYPE is dependent, in the sense of
19240 [temp.dep.type]. Note that a NULL type is considered dependent. */
19242 bool
19244 {
19245 /* If there are no template parameters in scope, then there can't be
19246 any dependent types. */
19248 {
19249 /* If we are not processing a template, then nobody should be
19250 providing us with a dependent type. */
19254 }
19256 /* If the type is NULL, we have not computed a type for the entity
19257 in question; in that case, the type is dependent. */
19261 /* Erroneous types can be considered non-dependent. */
19265 /* If we have not already computed the appropriate value for TYPE,
19266 do so now. */
19268 {
19271 }
19274 }
19276 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
19277 lookup. In other words, a dependent type that is not the current
19278 instantiation. */
19280 bool
19282 {
19285 }
19287 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
19288 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
19289 expression. */
19291 /* Note that this predicate is not appropriate for general expressions;
19292 only constant expressions (that satisfy potential_constant_expression)
19293 can be tested for value dependence. */
19295 bool
19297 {
19301 /* A name declared with a dependent type. */
19306 {
19308 /* A name that has not been looked up -- must be dependent. */
19312 /* A non-type template parm. */
19316 /* A non-type template parm. */
19322 /* A constant with literal type and is initialized
19323 with an expression that is value-dependent.
19325 Note that a non-dependent parenthesized initializer will have
19326 already been replaced with its constant value, so if we see
19327 a TREE_LIST it must be dependent. */
19340 /* These expressions are value-dependent if the type to which
19341 the cast occurs is dependent or the expression being casted
19342 is value-dependent. */
19343 {
19349 /* A functional cast has a list of operands. */
19352 {
19353 /* If there are no operands, it must be an expression such
19354 as "int()". This should not happen for aggregate types
19355 because it would form non-constant expressions. */
19360 }
19366 }
19371 /* FALLTHRU */
19374 /* A `sizeof' expression is value-dependent if the operand is
19375 type-dependent or is a pack expansion. */
19384 /* An 'encode' expression is value-dependent if the operand is
19385 type-dependent. */
19394 /* instantiation_dependent_r treats this as dependent so that we
19395 check access at instantiation time, and all instantiation-dependent
19396 expressions should also be considered value-dependent. */
19404 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
19405 is value-dependent. */
19406 {
19415 }
19418 {
19422 }
19433 {
19437 }
19440 {
19447 {
19449 /* In a call to a constexpr member function, look through the
19450 implicit ADDR_EXPR on the object argument so that it doesn't
19451 cause the call to be considered value-dependent. We also
19452 look through it in potential_constant_expression. */
19459 }
19461 }
19464 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
19465 type-dependent. */
19469 {
19471 tree val;
19476 }
19479 /* Treat a GNU statement expression as dependent to avoid crashing
19480 under fold_non_dependent_expr; it can't be constant. */
19484 /* A constant expression is value-dependent if any subexpression is
19485 value-dependent. */
19487 {
19494 {
19498 {
19501 /* In some cases, some of the operands may be missing.l
19502 (For example, in the case of PREDECREMENT_EXPR, the
19503 amount to increment by may be missing.) That doesn't
19504 make the expression dependent. */
19507 }
19508 }
19512 }
19514 }
19516 /* The expression is not value-dependent. */
19518 }
19520 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
19521 [temp.dep.expr]. Note that an expression with no type is
19522 considered dependent. Other parts of the compiler arrange for an
19523 expression with type-dependent subexpressions to have no type, so
19524 this function doesn't have to be fully recursive. */
19526 bool
19528 {
19535 /* An unresolved name is always dependent. */
19540 /* Some expression forms are never type-dependent. */
19553 /* The types of these expressions depends only on the type to which
19554 the cast occurs. */
19563 /* The types of these expressions depends only on the type created
19564 by the expression. */
19567 {
19568 /* For NEW_EXPR tree nodes created inside a template, either
19569 the object type itself or a TREE_LIST may appear as the
19570 operand 1. */
19573 /* This is an array type. We need to check array dimensions
19574 as well. */
19576 || value_dependent_expression_p
19578 else
19580 }
19583 {
19587 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
19588 contains an identifier associated by name lookup with one or more
19589 declarations declared with a dependent type, or...a
19590 nested-name-specifier or qualified-id that names a member of an
19591 unknown specialization. */
19594 }
19599 && (any_dependent_template_arguments_p
19611 {
19612 tree elt;
19616 {
19619 }
19621 }
19623 /* A static data member of the current instantiation with incomplete
19624 array type is type-dependent, as the definition and specializations
19625 can have different bounds. */
19633 {
19638 {
19644 }
19645 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
19653 {
19658 }
19663 {
19667 }
19669 }
19674 }
19676 /* walk_tree callback function for instantiation_dependent_expression_p,
19677 below. Returns non-zero if a dependent subexpression is found. */
19679 static tree
19682 {
19684 {
19685 /* We don't have to worry about decltype currently because decltype
19686 of an instantiation-dependent expr is a dependent type. This
19687 might change depending on the resolution of DR 1172. */
19690 }
19693 {
19694 /* Don't treat an argument list as dependent just because it has no
19695 TREE_TYPE. */
19703 /* Handle expressions with type operands. */
19709 {
19714 {
19719 else
19720 {
19723 }
19724 }
19726 }
19730 /* In a template, finish_class_member_access_expr creates a
19731 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
19732 type-dependent, so that we can check access control at
19733 instantiation time (PR 42277). See also Core issue 1273. */
19738 /* Similarly, finish_qualified_id_expr builds up a SCOPE_REF in a
19739 template so that we can check access at instantiation time even
19740 though we know which member it resolves to. */
19745 }
19749 else
19751 }
19753 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
19754 sense defined by the ABI:
19756 "An expression is instantiation-dependent if it is type-dependent
19757 or value-dependent, or it has a subexpression that is type-dependent
19758 or value-dependent." */
19760 bool
19762 {
19763 tree result;
19774 }
19776 /* Like type_dependent_expression_p, but it also works while not processing
19777 a template definition, i.e. during substitution or mangling. */
19779 bool
19781 {
19787 }
19789 /* Returns TRUE if ARGS contains a type-dependent expression. */
19791 bool
19793 {
19795 tree arg;
19798 {
19801 }
19803 }
19805 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
19806 expressions) contains any type-dependent expressions. */
19808 bool
19810 {
19816 }
19818 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
19819 expressions) contains any value-dependent expressions. */
19821 bool
19823 {
19829 }
19831 /* Returns TRUE if the ARG (a template argument) is dependent. */
19833 bool
19835 {
19839 /* Assume a template argument that was wrongly written by the user
19840 is dependent. This is consistent with what
19841 any_dependent_template_arguments_p [that calls this function]
19842 does. */
19853 {
19857 {
19860 }
19863 }
19866 else
19869 }
19871 /* Returns true if ARGS (a collection of template arguments) contains
19872 any types that require structural equality testing. */
19874 bool
19876 {
19886 {
19889 {
19895 {
19896 /* Look inside the argument pack. */
19899 }
19902 {
19916 }
19917 }
19918 }
19921 }
19923 /* Returns true if ARGS (a collection of template arguments) contains
19924 any dependent arguments. */
19926 bool
19928 {
19938 {
19943 }
19946 }
19948 /* Returns TRUE if the template TMPL is dependent. */
19950 bool
19952 {
19954 {
19956 {
19960 }
19962 }
19964 /* Template template parameters are dependent. */
19968 /* So are names that have not been looked up. */
19972 /* So are member templates of dependent classes. */
19976 }
19978 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
19980 bool
19982 {
19985 }
19987 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
19988 is dependent. */
19990 bool
19992 {
19999 {
20020 {
20024 }
20028 {
20032 {
20037 }
20038 }
20039 }
20042 }
20044 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
20045 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
20046 no such TYPE can be found. Note that this function peers inside
20047 uninstantiated templates and therefore should be used only in
20048 extremely limited situations. ONLY_CURRENT_P restricts this
20049 peering to the currently open classes hierarchy (which is required
20050 when comparing types). */
20052 tree
20054 {
20055 tree scope;
20056 tree name;
20057 tree decl;
20059 tree pushed_scope;
20060 tree result;
20065 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
20066 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
20067 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
20068 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
20069 identifier of the TYPENAME_TYPE anymore.
20070 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
20071 TYPENAME_TYPE instead, we avoid messing up with a possible
20072 typedef variant case. */
20075 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
20076 it first before we can figure out what NAME refers to. */
20079 /* If we don't know what SCOPE refers to, then we cannot resolve the
20080 TYPENAME_TYPE. */
20083 /* If the SCOPE is a template type parameter, we have no way of
20084 resolving the name. */
20087 /* If the SCOPE is not the current instantiation, there's no reason
20088 to look inside it. */
20091 /* If this is a typedef, we don't want to look inside (c++/11987). */
20094 /* If SCOPE isn't the template itself, it will not have a valid
20095 TYPE_FIELDS list. */
20097 /* scope is either the template itself or a compatible instantiation
20098 like X<T>, so look up the name in the original template. */
20100 else
20101 /* scope is a partial instantiation, so we can't do the lookup or we
20102 will lose the template arguments. */
20104 /* Enter the SCOPE so that name lookup will be resolved as if we
20105 were in the class definition. In particular, SCOPE will no
20106 longer be considered a dependent type. */
20108 /* Look up the declaration. */
20110 tf_warning_or_error);
20114 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
20115 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
20120 {
20124 }
20127 {
20128 tree tmpl;
20129 tree args;
20130 /* Obtain the template and the arguments. */
20133 /* Instantiate the template. */
20139 }
20141 /* Leave the SCOPE. */
20145 /* If we failed to resolve it, return the original typename. */
20149 /* If lookup found a typename type, resolve that too. */
20151 {
20152 /* Ill-formed programs can cause infinite recursion here, so we
20153 must catch that. */
20157 }
20159 /* Qualify the resulting type. */
20165 }
20167 /* EXPR is an expression which is not type-dependent. Return a proxy
20168 for EXPR that can be used to compute the types of larger
20169 expressions containing EXPR. */
20171 tree
20173 {
20174 tree inner_expr;
20176 #ifdef ENABLE_CHECKING
20177 /* Try to get a constant value for all non-type-dependent expressions in
20178 order to expose bugs in *_dependent_expression_p and constexpr. */
20181 #endif
20183 /* Preserve OVERLOADs; the functions must be available to resolve
20184 types. */
20195 /* There is no need to return a proxy for a variable. */
20198 /* Preserve string constants; conversions from string constants to
20199 "char *" are allowed, even though normally a "const char *"
20200 cannot be used to initialize a "char *". */
20203 /* Preserve arithmetic constants, as an optimization -- there is no
20204 reason to create a new node. */
20207 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
20208 There is at least one place where we want to know that a
20209 particular expression is a throw-expression: when checking a ?:
20210 expression, there are special rules if the second or third
20211 argument is a throw-expression. */
20215 /* Don't wrap an initializer list, we need to be able to look inside. */
20219 /* Don't wrap a dummy object, we need to be able to test for it. */
20238 /* If the type is unknown, it can't really be non-dependent */
20241 /* Otherwise, build a NON_DEPENDENT_EXPR. */
20243 }
20245 /* ARGS is a vector of expressions as arguments to a function call.
20246 Replace the arguments with equivalent non-dependent expressions.
20247 This modifies ARGS in place. */
20249 void
20251 {
20253 tree arg;
20256 {
20260 }
20261 }
20263 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
20264 with a level one deeper than the actual template parms. */
20266 tree
20268 {
20281 }
20283 /* Given type ARG, return std::initializer_list<ARG>. */
20285 static tree
20287 {
20288 tree std_init_list = namespace_binding
20290 tree argvec;
20292 {
20296 }
20301 }
20303 /* Replace auto in TYPE with std::initializer_list<auto>. */
20305 static tree
20307 {
20314 }
20316 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
20317 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
20319 tree
20321 {
20330 /* Defining a subset of type-dependent expressions that we can deduce
20331 from ahead of time isn't worth the trouble. */
20334 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
20335 with either a new invented type template parameter U or, if the
20336 initializer is a braced-init-list (8.5.4), with
20337 std::initializer_list<U>. */
20353 {
20355 /* Try again at instantiation time. */
20358 /* If type is error_mark_node a diagnostic must have been
20359 emitted by now. Also, having a mention to '<type error>'
20360 in the diagnostic is not really useful to the user. */
20361 {
20365 else
20367 }
20369 }
20371 /* If the list of declarators contains more than one declarator, the type
20372 of each declared variable is determined as described above. If the
20373 type deduced for the template parameter U is not the same in each
20374 deduction, the program is ill-formed. */
20377 {
20383 else
20387 }
20393 }
20395 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
20396 result. */
20398 tree
20400 {
20401 tree argvec;
20408 /* For a late-specified return type in a template type-parameter, we
20409 need to add a dummy argument level for its parmlist. */
20410 argvec = add_to_template_args
20415 }
20417 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
20419 bool
20421 {
20425 else
20427 }
20429 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
20430 appear as a type-specifier for the declaration in question, we don't
20431 have to look through the whole type. */
20433 tree
20435 {
20452 }
20454 /* For a given template T, return the vector of typedefs referenced
20455 in T for which access check is needed at T instantiation time.
20456 T is either a FUNCTION_DECL or a RECORD_TYPE.
20457 Those typedefs were added to T by the function
20458 append_type_to_template_for_access_check. */
20462 {
20463 tree ti;
20474 {
20479 }
20482 }
20484 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
20485 tied to T. That list of typedefs will be access checked at
20486 T instantiation time.
20487 T is either a FUNCTION_DECL or a RECORD_TYPE.
20488 TYPE_DECL is a TYPE_DECL node representing a typedef.
20489 SCOPE is the scope through which TYPE_DECL is accessed.
20490 LOCATION is the location of the usage point of TYPE_DECL.
20492 This function is a subroutine of
20493 append_type_to_template_for_access_check. */
20495 static void
20497 tree type_decl,
20498 tree scope,
20499 location_t location)
20500 {
20501 qualified_typedef_usage_t typedef_usage;
20502 tree ti;
20509 && type_decl
20524 typedef_usage);
20525 }
20527 /* Append TYPE_DECL to the template TEMPL.
20528 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
20529 At TEMPL instanciation time, TYPE_DECL will be checked to see
20530 if it can be accessed through SCOPE.
20531 LOCATION is the location of the usage point of TYPE_DECL.
20533 e.g. consider the following code snippet:
20535 class C
20536 {
20537 typedef int myint;
20538 };
20540 template<class U> struct S
20541 {
20542 C::myint mi; // <-- usage point of the typedef C::myint
20543 };
20545 S<char> s;
20547 At S<char> instantiation time, we need to check the access of C::myint
20548 In other words, we need to check the access of the myint typedef through
20549 the C scope. For that purpose, this function will add the myint typedef
20550 and the scope C through which its being accessed to a list of typedefs
20551 tied to the template S. That list will be walked at template instantiation
20552 time and access check performed on each typedefs it contains.
20553 Note that this particular code snippet should yield an error because
20554 myint is private to C. */
20556 void
20558 tree type_decl,
20559 tree scope,
20560 location_t location)
20561 {
20567 /* Make sure we don't append the type to the template twice. */
20576 }
20578 /* Set up the hash tables for template instantiations. */
20580 void
20582 {
20584 hash_specialization,
20585 eq_specializations,
20586 ggc_free);
20588 hash_specialization,
20589 eq_specializations,
20590 ggc_free);
20591 }
20593 /* Print stats about the template hash tables for -fstats. */
20595 void
20597 {
20606 }