| blob | c791d031ae19d1168cfd86e0601d1757c20e693d |
1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2014 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
51 /* The type of functions taking a tree, and some additional data, and
52 returning an int. */
55 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
56 instantiations have been deferred, either because their definitions
57 were not yet available, or because we were putting off doing the work. */
61 };
76 /* Live only within one (recursive) call to tsubst_expr. We use
77 this to pass the statement expression node from the STMT_EXPR
78 to the EXPR_STMT that is its result. */
81 /* True if we've recursed into fn_type_unification too many times. */
85 {
86 tree tmpl;
87 tree args;
88 tree spec;
92 htab_t decl_specializations;
95 htab_t type_specializations;
97 /* Contains canonical template parameter types. The vector is indexed by
98 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
99 TREE_LIST, whose TREE_VALUEs contain the canonical template
100 parameters of various types and levels. */
103 #define UNIFY_ALLOW_NONE 0
104 #define UNIFY_ALLOW_MORE_CV_QUAL 1
105 #define UNIFY_ALLOW_LESS_CV_QUAL 2
106 #define UNIFY_ALLOW_DERIVED 4
107 #define UNIFY_ALLOW_INTEGER 8
108 #define UNIFY_ALLOW_OUTER_LEVEL 16
109 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
110 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
113 tbr_incomplete_type,
114 tbr_ambiguous_baseclass,
115 tbr_success
116 };
139 tree);
202 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 {
225 else
229 {
230 saved_access_scope = tree_cons
233 }
234 }
236 /* Restore the scope set up by push_access_scope. T is the node we
237 are processing. */
239 static void
241 {
243 {
246 }
250 else
252 }
254 /* Do any processing required when DECL (a member template
255 declaration) is finished. Returns the TEMPLATE_DECL corresponding
256 to DECL, unless it is a specialization, in which case the DECL
257 itself is returned. */
259 tree
261 {
268 {
269 tree type;
277 {
281 }
283 }
287 {
289 {
292 }
293 else
295 }
296 else
300 }
302 /* Create a template info node. */
304 tree
306 {
311 }
313 /* Return the template info node corresponding to T, whatever T is. */
315 tree
317 {
335 }
337 /* Returns the template nesting level of the indicated class TYPE.
339 For example, in:
340 template <class T>
341 struct A
342 {
343 template <class U>
344 struct B {};
345 };
347 A<T>::B<U> has depth two, while A<T> has depth one.
348 Both A<T>::B<int> and A<int>::B<U> have depth one, if
349 they are instantiations, not specializations.
351 This function is guaranteed to return 0 if passed NULL_TREE so
352 that, for example, `template_class_depth (current_class_type)' is
353 always safe. */
355 int
357 {
364 {
370 }
373 }
375 /* Subroutine of maybe_begin_member_template_processing.
376 Returns true if processing DECL needs us to push template parms. */
378 static bool
380 {
386 }
388 /* Subroutine of maybe_begin_member_template_processing.
389 Push the template parms in PARMS, starting from LEVELS steps into the
390 chain, and ending at the beginning, since template parms are listed
391 innermost first. */
393 static void
395 {
403 current_template_parms
409 NULL);
411 {
420 {
427 {
428 /* Make a CONST_DECL as is done in process_template_parm.
429 It is ugly that we recreate this here; the original
430 version built in process_template_parm is no longer
431 available. */
441 }
446 }
447 }
448 }
450 /* Restore the template parameter context for a member template, a
451 friend template defined in a class definition, or a non-template
452 member of template class. */
454 void
456 {
457 tree parms;
467 {
472 {
475 }
478 }
480 /* Remember how many levels of template parameters we pushed so that
481 we can pop them later. */
483 }
485 /* Undo the effects of maybe_begin_member_template_processing. */
487 void
489 {
498 {
502 }
503 }
505 /* Return a new template argument vector which contains all of ARGS,
506 but has as its innermost set of arguments the EXTRA_ARGS. */
508 static tree
510 {
511 tree new_args;
529 }
531 /* Like add_to_template_args, but only the outermost ARGS are added to
532 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
533 (EXTRA_ARGS) levels are added. This function is used to combine
534 the template arguments from a partial instantiation with the
535 template arguments used to attain the full instantiation from the
536 partial instantiation. */
538 static tree
540 {
541 tree new_args;
543 /* If there are more levels of EXTRA_ARGS than there are ARGS,
544 something very fishy is going on. */
547 /* If *all* the new arguments will be the EXTRA_ARGS, just return
548 them. */
552 /* For the moment, we make ARGS look like it contains fewer levels. */
557 /* Now, we restore ARGS to its full dimensions. */
561 }
563 /* Return the N levels of innermost template arguments from the ARGS. */
565 tree
567 {
568 tree new_args;
574 /* If N is 1, just return the innermost set of template arguments. */
578 /* If we're not removing anything, just return the arguments we were
579 given. */
585 /* Make a new set of arguments, not containing the outer arguments. */
592 }
594 /* The inverse of get_innermost_template_args: Return all but the innermost
595 EXTRA_LEVELS levels of template arguments from the ARGS. */
597 static tree
599 {
600 tree new_args;
606 /* If N is 1, just return the outermost set of template arguments. */
610 /* If we're not removing anything, just return the arguments we were
611 given. */
616 /* Make a new set of arguments, not containing the inner arguments. */
623 }
625 /* We've got a template header coming up; push to a new level for storing
626 the parms. */
628 void
630 {
631 /* We use a non-tag-transparent scope here, which causes pushtag to
632 put tags in this scope, rather than in the enclosing class or
633 namespace scope. This is the right thing, since we want
634 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
635 global template class, push_template_decl handles putting the
636 TEMPLATE_DECL into top-level scope. For a nested template class,
637 e.g.:
639 template <class T> struct S1 {
640 template <class T> struct S2 {};
641 };
643 pushtag contains special code to call pushdecl_with_scope on the
644 TEMPLATE_DECL for S2. */
649 }
651 /* This routine is called when a specialization is declared. If it is
652 invalid to declare a specialization here, an error is reported and
653 false is returned, otherwise this routine will return true. */
655 static bool
657 {
660 /* [temp.expl.spec]
662 An explicit specialization shall be declared in the namespace of
663 which the template is a member, or, for member templates, in the
664 namespace of which the enclosing class or enclosing class
665 template is a member. An explicit specialization of a member
666 function, member class or static data member of a class template
667 shall be declared in the namespace of which the class template
668 is a member. */
670 {
673 }
675 /* [temp.expl.spec]
677 In an explicit specialization declaration for a member of a class
678 template or a member template that appears in namespace scope,
679 the member template and some of its enclosing class templates may
680 remain unspecialized, except that the declaration shall not
681 explicitly specialize a class member template if its enclosing
682 class templates are not explicitly specialized as well. */
684 {
687 }
690 }
692 /* We've just seen template <>. */
694 bool
696 {
700 }
702 /* Called at then end of processing a declaration preceded by
703 template<>. */
705 void
707 {
710 }
712 /* Any template <>'s that we have seen thus far are not referring to a
713 function specialization. */
715 void
717 {
720 }
722 /* We've just seen a template header. If SPECIALIZATION is nonzero,
723 it was of the form template <>. */
725 static void
727 {
729 template_header_count++;
730 }
732 /* We're beginning an explicit instantiation. */
734 void
736 {
739 }
742 void
744 {
747 }
749 /* An explicit specialization or partial specialization of TMPL is being
750 declared. Check that the namespace in which the specialization is
751 occurring is permissible. Returns false iff it is invalid to
752 specialize TMPL in the current namespace. */
754 static bool
756 {
759 /* [tmpl.expl.spec]
761 An explicit specialization shall be declared in the namespace of
762 which the template is a member, or, for member templates, in the
763 namespace of which the enclosing class or enclosing class
764 template is a member. An explicit specialization of a member
765 function, member class or static data member of a class template
766 shall be declared in the namespace of which the class template is
767 a member. */
770 {
773 }
775 /* Same or super-using namespace. */
777 else
778 {
782 }
783 }
785 /* SPEC is an explicit instantiation. Check that it is valid to
786 perform this explicit instantiation in the current namespace. */
788 static void
790 {
791 tree ns;
793 /* DR 275: An explicit instantiation shall appear in an enclosing
794 namespace of its template. */
800 }
802 /* The TYPE is being declared. If it is a template type, that means it
803 is a partial specialization. Do appropriate error-checking. */
805 tree
807 {
808 tree context;
813 /* A lambda that appears in specialization context is not itself a
814 specialization. */
819 {
823 }
828 {
833 else
836 }
838 {
839 /* This is for ordinary explicit specialization and partial
840 specialization of a template class such as:
842 template <> class C<int>;
844 or:
846 template <class T> class C<T*>;
848 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
852 {
859 {
863 }
864 }
870 /* Trying to define a specialization either without a template<> header
871 or in an inappropriate place. We've already given an error, so just
872 bail now so we don't actually define the specialization. */
874 }
880 {
881 /* This is for an explicit specialization of member class
882 template according to [temp.expl.spec/18]:
884 template <> template <class U> class C<int>::D;
886 The context `C<int>' must be an implicit instantiation.
887 Otherwise this is just a member class template declared
888 earlier like:
890 template <> class C<int> { template <class U> class D; };
891 template <> template <class U> class C<int>::D;
893 In the first case, `C<int>::D' is a specialization of `C<T>::D'
894 while in the second case, `C<int>::D' is a primary template
895 and `C<T>::D' may not exist. */
899 {
900 tree t;
905 {
908 }
910 /* Check for invalid specialization after instantiation:
912 template <> template <> class C<int>::D<int>;
913 template <> template <class U> class C<int>::D; */
917 {
921 {
922 /* We already have a full specialization of this partial
923 instantiation, or a full specialization has been
924 looked up but not instantiated. Reassign it to the
925 new member specialization template. */
926 spec_entry elt;
943 }
944 else
945 /* But if we've had an implicit instantiation, that's a
946 problem ([temp.expl.spec]/6). */
949 }
951 /* Mark TYPE as a specialization. And as a result, we only
952 have one level of template argument for the innermost
953 class template. */
958 }
959 }
961 {
962 /* Someday C++0x may allow for enum template specialization. */
967 else
968 {
971 }
972 }
975 }
977 /* Returns nonzero if we can optimize the retrieval of specializations
978 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
979 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
983 {
986 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
987 parameter. */
989 /* The optimized lookup depends on the fact that the
990 template arguments for the member function template apply
991 purely to the containing class, which is not true if the
992 containing class is an explicit or partial
993 specialization. */
997 /* It is possible to have a template that is not a member
998 template and is not a member of a template class:
1000 template <typename T>
1001 struct S { friend A::f(); };
1003 Here, the friend function is a template, but the context does
1004 not have template information. The optimized lookup relies
1005 on having ARGS be the template arguments for both the class
1006 and the function template. */
1008 }
1010 /* Retrieve the specialization (in the sense of [temp.spec] - a
1011 specialization is either an instantiation or an explicit
1012 specialization) of TMPL for the given template ARGS. If there is
1013 no such specialization, return NULL_TREE. The ARGS are a vector of
1014 arguments, or a vector of vectors of arguments, in the case of
1015 templates with more than one level of parameters.
1017 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1018 then we search for a partial specialization matching ARGS. This
1019 parameter is ignored if TMPL is not a class template.
1021 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1022 result is a NONTYPE_ARGUMENT_PACK. */
1024 static tree
1026 {
1036 /* There should be as many levels of arguments as there are
1037 levels of parameters. */
1044 {
1045 tree class_template;
1046 tree class_specialization;
1048 tree fns;
1051 /* The template arguments actually apply to the containing
1052 class. Find the class specialization with those
1053 arguments. */
1055 class_specialization
1059 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1060 for the specialization. */
1064 /* Iterate through the methods with the indicated name, looking
1065 for the one that has an instance of TMPL. */
1068 {
1071 /* using-declarations can add base methods to the method vec,
1072 and we don't want those here. */
1075 }
1077 }
1078 else
1079 {
1081 spec_entry elt;
1082 htab_t specializations;
1090 else
1098 }
1101 }
1103 /* Like retrieve_specialization, but for local declarations. */
1105 static tree
1107 {
1115 }
1117 /* Returns nonzero iff DECL is a specialization of TMPL. */
1119 int
1121 {
1122 tree t;
1125 {
1131 }
1132 else
1133 {
1142 }
1145 }
1147 /* Returns nonzero iff DECL is a specialization of friend declaration
1148 FRIEND_DECL according to [temp.friend]. */
1150 bool
1152 {
1159 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1160 of a template class, we want to check if DECL is a specialization
1161 if this. */
1165 {
1166 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1169 }
1174 /* There is nothing to do if this is not a template friend. */
1181 /* [temp.friend/6]
1182 A member of a class template may be declared to be a friend of a
1183 non-template class. In this case, the corresponding member of
1184 every specialization of the class template is a friend of the
1185 class granting friendship.
1187 For example, given a template friend declaration
1189 template <class T> friend void A<T>::f();
1191 the member function below is considered a friend
1193 template <> struct A<int> {
1194 void f();
1195 };
1197 For this type of template friend, TEMPLATE_DEPTH below will be
1198 nonzero. To determine if DECL is a friend of FRIEND, we first
1199 check if the enclosing class is a specialization of another. */
1206 {
1207 /* Next, we check the members themselves. In order to handle
1208 a few tricky cases, such as when FRIEND_DECL's are
1210 template <class T> friend void A<T>::g(T t);
1211 template <class T> template <T t> friend void A<T>::h();
1213 and DECL's are
1215 void A<int>::g(int);
1216 template <int> void A<int>::h();
1218 we need to figure out ARGS, the template arguments from
1219 the context of DECL. This is required for template substitution
1220 of `T' in the function parameter of `g' and template parameter
1221 of `h' in the above examples. Here ARGS corresponds to `int'. */
1228 {
1230 {
1233 else
1235 current_depth++;
1236 }
1238 }
1241 {
1243 tree friend_type;
1244 tree decl_type;
1245 tree friend_args_type;
1246 tree decl_args_type;
1248 /* Make sure that both DECL and FRIEND_DECL are templates or
1249 non-templates. */
1255 {
1256 /* If both are templates, check template parameter list. */
1257 tree friend_parms
1262 friend_parms))
1266 }
1267 else
1275 /* Check if return types match. */
1279 /* Check if function parameter types match, ignoring the
1280 `this' parameter. */
1289 }
1290 else
1291 {
1292 /* DECL is a TYPE_DECL */
1296 /* Make sure that both DECL and FRIEND_DECL are templates or
1297 non-templates. */
1298 is_template
1305 {
1306 tree friend_parms;
1307 /* If both are templates, check the name of the two
1308 TEMPLATE_DECL's first because is_friend didn't. */
1313 /* Now check template parameter list. */
1314 friend_parms
1317 return comp_template_parms
1319 friend_parms);
1320 }
1321 else
1324 }
1325 }
1327 }
1329 /* Register the specialization SPEC as a specialization of TMPL with
1330 the indicated ARGS. IS_FRIEND indicates whether the specialization
1331 is actually just a friend declaration. Returns SPEC, or an
1332 equivalent prior declaration, if available.
1334 We also store instantiations of field packs in the hash table, even
1335 though they are not themselves templates, to make lookup easier. */
1337 static tree
1339 hashval_t hash)
1340 {
1341 tree fn;
1343 spec_entry elt;
1351 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1352 register it; we want the corresponding TEMPLATE_DECL instead.
1353 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1354 the more obvious `uses_template_parms (spec)' to avoid problems
1355 with default function arguments. In particular, given
1356 something like this:
1358 template <class T> void f(T t1, T t = T())
1360 the default argument expression is not substituted for in an
1361 instantiation unless and until it is actually needed. */
1365 /* We don't put these specializations in the hash table, but we might
1366 want to give an error about a mismatch. */
1368 else
1369 {
1377 slot =
1381 else
1383 }
1385 /* We can sometimes try to re-register a specialization that we've
1386 already got. In particular, regenerate_decl_from_template calls
1387 duplicate_decls which will update the specialization list. But,
1388 we'll still get called again here anyhow. It's more convenient
1389 to simply allow this than to try to prevent it. */
1393 {
1395 {
1398 {
1400 fn);
1402 }
1403 else
1404 {
1405 tree clone;
1406 /* This situation should occur only if the first
1407 specialization is an implicit instantiation, the
1408 second is an explicit specialization, and the
1409 implicit instantiation has not yet been used. That
1410 situation can occur if we have implicitly
1411 instantiated a member function and then specialized
1412 it later.
1414 We can also wind up here if a friend declaration that
1415 looked like an instantiation turns out to be a
1416 specialization:
1418 template <class T> void foo(T);
1419 class S { friend void foo<>(int) };
1420 template <> void foo(int);
1422 We transform the existing DECL in place so that any
1423 pointers to it become pointers to the updated
1424 declaration.
1426 If there was a definition for the template, but not
1427 for the specialization, we want this to look as if
1428 there were no definition, and vice versa. */
1431 /* The call to duplicate_decls will have applied
1432 [temp.expl.spec]:
1434 An explicit specialization of a function template
1435 is inline only if it is explicitly declared to be,
1436 and independently of whether its function template
1437 is.
1439 to the primary function; now copy the inline bits to
1440 the various clones. */
1442 {
1449 }
1453 }
1454 }
1456 {
1458 /* Dup decl failed, but this is a new definition. Set the
1459 line number so any errors match this new
1460 definition. */
1464 }
1465 }
1469 /* A specialization must be declared in the same namespace as the
1470 template it is specializing. */
1476 {
1484 /* TMPL is a forward declaration of a template function; keep a list
1485 of all specializations in case we need to reassign them to a friend
1486 template later in tsubst_friend_function. */
1489 }
1492 }
1494 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1495 TMPL and ARGS members, ignores SPEC. */
1499 static int
1501 {
1512 }
1514 /* Returns a hash for a template TMPL and template arguments ARGS. */
1516 static hashval_t
1518 {
1521 }
1523 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1524 ignoring SPEC. */
1526 static hashval_t
1528 {
1531 }
1533 /* Recursively calculate a hash value for a template argument ARG, for use
1534 in the hash tables of template specializations. */
1536 hashval_t
1538 {
1550 /* We can get one of these when re-hashing a previous entry in the middle
1551 of substituting into a pack expansion. Just look through it. */
1560 {
1568 {
1573 }
1595 {
1598 {
1601 }
1603 }
1607 {
1610 }
1621 val = iterative_hash_template_arg
1633 val);
1635 val);
1644 /* A lambda can't appear in a template arg, but don't crash on
1645 erroneous input. */
1657 /* Now hash operands as usual. */
1662 }
1665 {
1669 val);
1672 /* Otherwise just compare the types during lookup. */
1681 {
1686 }
1687 }
1690 }
1692 /* Unregister the specialization SPEC as a specialization of TMPL.
1693 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1694 if the SPEC was listed as a specialization of TMPL.
1696 Note that SPEC has been ggc_freed, so we can't look inside it. */
1698 bool
1700 {
1702 spec_entry elt;
1710 {
1715 }
1718 }
1720 /* Like register_specialization, but for local declarations. We are
1721 registering SPEC, an instantiation of TMPL. */
1723 static void
1725 {
1730 }
1732 /* TYPE is a class type. Returns true if TYPE is an explicitly
1733 specialized class. */
1735 bool
1737 {
1741 }
1743 /* Print the list of functions at FNS, going through all the overloads
1744 for each element of the list. Alternatively, FNS can not be a
1745 TREE_LIST, in which case it will be printed together with all the
1746 overloads.
1748 MORE and *STR should respectively be FALSE and NULL when the function
1749 is called from the outside. They are used internally on recursive
1750 calls. print_candidates manages the two parameters and leaves NULL
1751 in *STR when it ends. */
1753 static void
1755 {
1761 {
1765 }
1766 else
1767 {
1770 {
1771 /* Pick the prefix string. */
1773 {
1777 }
1781 }
1784 }
1787 {
1790 }
1791 }
1793 /* Print the list of candidate FNS in an error message. FNS can also
1794 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1796 void
1798 {
1802 }
1804 /* Returns the template (one of the functions given by TEMPLATE_ID)
1805 which can be specialized to match the indicated DECL with the
1806 explicit template args given in TEMPLATE_ID. The DECL may be
1807 NULL_TREE if none is available. In that case, the functions in
1808 TEMPLATE_ID are non-members.
1810 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1811 specialization of a member template.
1813 The TEMPLATE_COUNT is the number of references to qualifying
1814 template classes that appeared in the name of the function. See
1815 check_explicit_specialization for a more accurate description.
1817 TSK indicates what kind of template declaration (if any) is being
1818 declared. TSK_TEMPLATE indicates that the declaration given by
1819 DECL, though a FUNCTION_DECL, has template parameters, and is
1820 therefore a template function.
1822 The template args (those explicitly specified and those deduced)
1823 are output in a newly created vector *TARGS_OUT.
1825 If it is impossible to determine the result, an error message is
1826 issued. The error_mark_node is returned to indicate failure. */
1828 static tree
1830 tree decl,
1834 tmpl_spec_kind tsk)
1835 {
1836 tree fns;
1837 tree targs;
1838 tree explicit_targs;
1840 /* A TREE_LIST of templates of which DECL may be a specialization.
1841 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1842 corresponding TREE_PURPOSE is the set of template arguments that,
1843 when used to instantiate the template, would produce a function
1844 with the signature of DECL. */
1854 /* We shouldn't be specializing a member template of an
1855 unspecialized class template; we already gave an error in
1856 check_specialization_scope, now avoid crashing. */
1859 {
1862 }
1870 /* Check for baselinks. */
1875 {
1878 }
1880 /* Count the number of template headers specified for this
1881 specialization. */
1889 {
1893 {
1894 tree decl_arg_types;
1895 tree fn_arg_types;
1896 tree insttype;
1898 /* In case of explicit specialization, we need to check if
1899 the number of template headers appearing in the specialization
1900 is correct. This is usually done in check_explicit_specialization,
1901 but the check done there cannot be exhaustive when specializing
1902 member functions. Consider the following code:
1904 template <> void A<int>::f(int);
1905 template <> template <> void A<int>::f(int);
1907 Assuming that A<int> is not itself an explicit specialization
1908 already, the first line specializes "f" which is a non-template
1909 member function, whilst the second line specializes "f" which
1910 is a template member function. So both lines are syntactically
1911 correct, and check_explicit_specialization does not reject
1912 them.
1914 Here, we can do better, as we are matching the specialization
1915 against the declarations. We count the number of template
1916 headers, and we check if they match TEMPLATE_COUNT + 1
1917 (TEMPLATE_COUNT is the number of qualifying template classes,
1918 plus there must be another header for the member template
1919 itself).
1921 Notice that if header_count is zero, this is not a
1922 specialization but rather a template instantiation, so there
1923 is no check we can perform here. */
1927 /* Check that the number of template arguments at the
1928 innermost level for DECL is the same as for FN. */
1936 /* DECL might be a specialization of FN. */
1940 /* For a non-static member function, we need to make sure
1941 that the const qualification is the same. Since
1942 get_bindings does not try to merge the "this" parameter,
1943 we must do the comparison explicitly. */
1949 /* Skip the "this" parameter and, for constructors of
1950 classes with virtual bases, the VTT parameter. A
1951 full specialization of a constructor will have a VTT
1952 parameter, but a template never will. */
1953 decl_arg_types
1955 fn_arg_types
1958 /* Function templates cannot be specializations; there are
1959 no partial specializations of functions. Therefore, if
1960 the type of DECL does not match FN, there is no
1961 match. */
1963 {
1967 }
1969 /* See whether this function might be a specialization of this
1970 template. Suppress access control because we might be trying
1971 to make this specialization a friend, and we have already done
1972 access control for the declaration of the specialization. */
1978 /* We cannot deduce template arguments that when used to
1979 specialize TMPL will produce DECL. */
1982 /* Make sure that the deduced arguments actually work. */
1986 fn_arg_types
1991 /* Save this template, and the arguments deduced. */
1993 }
1995 /* FN is an ordinary member function, and we need a
1996 specialization of a member template. */
1997 ;
1999 /* We can get IDENTIFIER_NODEs here in certain erroneous
2000 cases. */
2001 ;
2003 /* This is just an ordinary non-member function. Nothing can
2004 be a specialization of that. */
2005 ;
2007 /* Cannot specialize functions that are created implicitly. */
2008 ;
2009 else
2010 {
2011 tree decl_arg_types;
2013 /* This is an ordinary member function. However, since
2014 we're here, we can assume its enclosing class is a
2015 template class. For example,
2017 template <typename T> struct S { void f(); };
2018 template <> void S<int>::f() {}
2020 Here, S<int>::f is a non-template, but S<int> is a
2021 template class. If FN has the same type as DECL, we
2022 might be in business. */
2025 /* Its enclosing class is an explicit specialization
2026 of a template class. This is not a candidate. */
2031 /* The return types differ. */
2034 /* Adjust the type of DECL in case FN is a static member. */
2041 decl_arg_types))
2042 /* They match! */
2044 }
2045 }
2048 {
2049 /* We have:
2051 [temp.expl.spec]
2053 It is possible for a specialization with a given function
2054 signature to be instantiated from more than one function
2055 template. In such cases, explicit specification of the
2056 template arguments must be used to uniquely identify the
2057 function template specialization being specialized.
2059 Note that here, there's no suggestion that we're supposed to
2060 determine which of the candidate templates is most
2061 specialized. However, we, also have:
2063 [temp.func.order]
2065 Partial ordering of overloaded function template
2066 declarations is used in the following contexts to select
2067 the function template to which a function template
2068 specialization refers:
2070 -- when an explicit specialization refers to a function
2071 template.
2073 So, we do use the partial ordering rules, at least for now.
2074 This extension can only serve to make invalid programs valid,
2075 so it's safe. And, there is strong anecdotal evidence that
2076 the committee intended the partial ordering rules to apply;
2077 the EDG front end has that behavior, and John Spicer claims
2078 that the committee simply forgot to delete the wording in
2079 [temp.expl.spec]. */
2082 {
2085 }
2086 }
2089 {
2097 }
2101 {
2107 }
2109 /* We have one, and exactly one, match. */
2111 {
2114 /* DECL is a re-declaration or partial instantiation of a template
2115 function. */
2118 /* It was a specialization of an ordinary member function in a
2119 template class. */
2121 }
2123 /* It was a specialization of a template. */
2126 {
2131 }
2132 else
2135 }
2137 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2138 but with the default argument values filled in from those in the
2139 TMPL_TYPES. */
2141 static tree
2143 tree tmpl_types)
2144 {
2145 tree new_spec_types;
2153 /* Substitute into the rest of the list. */
2154 new_spec_types =
2158 /* Add the default argument for this parameter. */
2161 new_spec_types);
2162 }
2164 /* DECL is an explicit specialization. Replicate default arguments
2165 from the template it specializes. (That way, code like:
2167 template <class T> void f(T = 3);
2168 template <> void f(double);
2169 void g () { f (); }
2171 works, as required.) An alternative approach would be to look up
2172 the correct default arguments at the call-site, but this approach
2173 is consistent with how implicit instantiations are handled. */
2175 static void
2177 {
2178 tree tmpl;
2179 tree spec_types;
2180 tree tmpl_types;
2181 tree new_spec_types;
2182 tree old_type;
2183 tree new_type;
2184 tree t;
2189 /* See if there's anything we need to do. */
2202 {
2203 /* Remove the this pointer, but remember the object's type for
2204 CV quals. */
2210 {
2211 /* DECL may contain more parameters than TMPL due to the extra
2212 in-charge parameter in constructors and destructors. */
2215 }
2217 {
2220 }
2221 }
2223 /* Compute the merged default arguments. */
2224 new_spec_types =
2227 /* Compute the new FUNCTION_TYPE. */
2229 {
2233 new_spec_types);
2236 /* Put the in-charge parameter back. */
2239 new_spec_types);
2243 new_spec_types);
2244 }
2245 else
2247 new_spec_types);
2253 }
2255 /* Return the number of template headers we expect to see for a definition
2256 or specialization of CTYPE or one of its non-template members. */
2258 int
2260 {
2264 {
2265 /* You're supposed to have one `template <...>' for every
2266 template class, but you don't need one for a full
2267 specialization. For example:
2269 template <class T> struct S{};
2270 template <> struct S<int> { void f(); };
2271 void S<int>::f () {}
2273 is correct; there shouldn't be a `template <>' for the
2274 definition of `S<int>::f'. */
2276 /* If CTYPE does not have template information of any
2277 kind, then it is not a template, nor is it nested
2278 within a template. */
2286 }
2289 }
2291 /* Do a simple sanity check on the template headers that precede the
2292 variable declaration DECL. */
2294 void
2296 {
2303 {
2309 "members of an explicitly specialized class are defined "
2311 }
2312 }
2314 /* Check to see if the function just declared, as indicated in
2315 DECLARATOR, and in DECL, is a specialization of a function
2316 template. We may also discover that the declaration is an explicit
2317 instantiation at this point.
2319 Returns DECL, or an equivalent declaration that should be used
2320 instead if all goes well. Issues an error message if something is
2321 amiss. Returns error_mark_node if the error is not easily
2322 recoverable.
2324 FLAGS is a bitmask consisting of the following flags:
2326 2: The function has a definition.
2327 4: The function is a friend.
2329 The TEMPLATE_COUNT is the number of references to qualifying
2330 template classes that appeared in the name of the function. For
2331 example, in
2333 template <class T> struct S { void f(); };
2334 void S<int>::f();
2336 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2337 classes are not counted in the TEMPLATE_COUNT, so that in
2339 template <class T> struct S {};
2340 template <> struct S<int> { void f(); }
2341 template <> void S<int>::f();
2343 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2344 invalid; there should be no template <>.)
2346 If the function is a specialization, it is marked as such via
2347 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2348 is set up correctly, and it is added to the list of specializations
2349 for that template. */
2351 tree
2353 tree decl,
2356 {
2364 tmpl_spec_kind tsk;
2367 {
2370 else
2372 }
2373 else
2377 {
2380 {
2383 }
2385 {
2387 /* This could be something like:
2389 template <class T> void f(T);
2390 class S { friend void f<>(int); } */
2392 else
2393 {
2394 /* This case handles bogus declarations like template <>
2395 template <class T> void f<int>(); */
2398 declarator);
2400 }
2401 }
2405 /* The error has already been reported in
2406 check_specialization_scope. */
2412 /* Fall through. */
2425 decl);
2428 else
2432 /* Fall through. */
2437 else
2443 {
2444 /* This case handles bogus declarations like template <>
2445 template <class T> void f<int>(); */
2450 else
2452 declarator);
2454 }
2457 /* This is a specialization of a member template, without
2458 specialization the containing class. Something like:
2460 template <class T> struct S {
2461 template <class U> void f (U);
2462 };
2463 template <> template <class U> void S<int>::f(U) {}
2465 That's a specialization -- but of the entire template. */
2471 }
2474 {
2478 {
2482 }
2483 }
2486 {
2490 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2492 {
2493 tree fns;
2498 else
2499 {
2500 /* If there is no class context, the explicit instantiation
2501 must be at namespace scope. */
2504 /* Find the namespace binding, using the declaration
2505 context. */
2509 {
2512 }
2513 else
2514 {
2520 }
2521 }
2524 }
2530 {
2532 /* A specialization in class scope. This is invalid,
2533 but the error will already have been flagged by
2534 check_specialization_scope. */
2536 else
2537 {
2538 /* It's not valid to write an explicit instantiation in
2539 class scope, e.g.:
2541 class C { template void f(); }
2543 This case is caught by the parser. However, on
2544 something like:
2546 template class C { void f(); };
2548 (which is invalid) we can get here. The error will be
2549 issued later. */
2550 ;
2551 }
2554 }
2557 {
2558 /* Find the list of functions in ctype that have the same
2559 name as the declared function. */
2565 {
2570 {
2571 /* From [temp.expl.spec]:
2573 If such an explicit specialization for the member
2574 of a class template names an implicitly-declared
2575 special member function (clause _special_), the
2576 program is ill-formed.
2578 Similar language is found in [temp.explicit]. */
2581 }
2584 }
2587 {
2591 }
2592 else
2593 {
2595 tree ovl;
2597 /* For a type-conversion operator, we cannot do a
2598 name-based lookup. We might be looking for `operator
2599 int' which will be a specialization of `operator T'.
2600 So, we find *all* the conversion operators, and then
2601 select from them. */
2609 {
2611 /* There are no more conversion functions. */
2614 /* Glue all these conversion functions together
2615 with those we already have. */
2618 }
2619 }
2622 {
2625 }
2626 else
2628 }
2630 /* Figure out what exactly is being specialized at this point.
2631 Note that for an explicit instantiation, even one for a
2632 member function, we cannot tell apriori whether the
2633 instantiation is for a member template, or just a member
2634 function of a template class. Even if a member template is
2635 being instantiated, the member template arguments may be
2636 elided if they can be deduced from the rest of the
2637 declaration. */
2640 member_specialization,
2641 template_count,
2642 tsk);
2645 /* We couldn't figure out what this declaration was
2646 specializing. */
2648 else
2649 {
2653 {
2654 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2655 is done by do_decl_instantiation later. */
2661 {
2662 /* If TMPL is not the most general template (for
2663 example, if TMPL is a friend template that is
2664 injected into namespace scope), then there will
2665 be too many levels of TARGS. Remove some of them
2666 here. */
2668 tree new_targs;
2675 }
2678 }
2680 /* If we thought that the DECL was a member function, but it
2681 turns out to be specializing a static member function,
2682 make DECL a static member function as well. */
2687 /* If this is a specialization of a member template of a
2688 template class, we want to return the TEMPLATE_DECL, not
2689 the specialization of it. */
2691 {
2696 {
2697 tree parm;
2701 /* We want to use the argument list specified in the
2702 definition, not in the original declaration. */
2707 }
2710 }
2712 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2715 /* Inherit default function arguments from the template
2716 DECL is specializing. */
2719 /* This specialization has the same protection as the
2720 template it specializes. */
2724 /* 7.1.1-1 [dcl.stc]
2726 A storage-class-specifier shall not be specified in an
2727 explicit specialization...
2729 The parser rejects these, so unless action is taken here,
2730 explicit function specializations will always appear with
2731 global linkage.
2733 The action recommended by the C++ CWG in response to C++
2734 defect report 605 is to make the storage class and linkage
2735 of the explicit specialization match the templated function:
2737 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2738 */
2740 {
2744 /* This specialization has the same linkage and visibility as
2745 the function template it specializes. */
2748 {
2751 }
2754 {
2757 }
2758 }
2760 /* If DECL is a friend declaration, declared using an
2761 unqualified name, the namespace associated with DECL may
2762 have been set incorrectly. For example, in:
2764 template <typename T> void f(T);
2765 namespace N {
2766 struct S { friend void f<int>(int); }
2767 }
2769 we will have set the DECL_CONTEXT for the friend
2770 declaration to N, rather than to the global namespace. */
2775 /* This is not really a declaration of a specialization.
2776 It's just the name of an instantiation. But, it's not
2777 a request for an instantiation, either. */
2780 /* Register this specialization so that we can find it
2781 again. */
2784 /* A 'structor should already have clones. */
2789 }
2790 }
2793 }
2795 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2796 parameters. These are represented in the same format used for
2797 DECL_TEMPLATE_PARMS. */
2799 int
2801 {
2802 const_tree p1;
2803 const_tree p2;
2811 {
2823 {
2827 /* If either of the template parameters are invalid, assume
2828 they match for the sake of error recovery. */
2841 }
2842 }
2845 /* One set of parameters has more parameters lists than the
2846 other. */
2850 }
2852 /* Determine whether PARM is a parameter pack. */
2854 bool
2856 {
2857 /* Determine if we have a non-type template parameter pack. */
2864 /* If this is a list of template parameters, we could get a
2865 TYPE_DECL or a TEMPLATE_DECL. */
2869 /* Otherwise it must be a type template parameter. */
2873 }
2875 /* Determine if T is a function parameter pack. */
2877 bool
2879 {
2883 }
2885 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2886 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2888 tree
2890 {
2897 }
2899 /* Return true iff the function parameter PARAM_DECL was expanded
2900 from the function parameter pack PACK. */
2902 bool
2904 {
2909 /* The parameter pack and its pack arguments have the same
2910 DECL_PARM_INDEX. */
2912 }
2914 /* Determine whether ARGS describes a variadic template args list,
2915 i.e., one that is terminated by a template argument pack. */
2917 static bool
2919 {
2921 tree last_parm;
2935 }
2937 /* Generate a new name for the parameter pack name NAME (an
2938 IDENTIFIER_NODE) that incorporates its */
2940 static tree
2942 {
2943 /* Munge the name to include the parameter index. */
2944 #define NUMBUF_LEN 128
2958 }
2960 /* Return true if T is a primary function, class or alias template
2961 instantiation. */
2963 bool
2965 {
2979 }
2981 /* Return true if PARM is a template template parameter. */
2983 bool
2985 {
2987 }
2989 /* Return true iff PARM is a DECL representing a type template
2990 parameter. */
2992 bool
2994 {
2999 }
3001 /* Return the template parameters of T if T is a
3002 primary template instantiation, NULL otherwise. */
3004 tree
3006 {
3011 parms = INNERMOST_TEMPLATE_PARMS
3015 }
3017 /* Return the template parameters of the LEVELth level from the full list
3018 of template parameters PARMS. */
3020 tree
3022 {
3023 tree p;
3034 }
3036 /* Returns the template arguments of T if T is a template instantiation,
3037 NULL otherwise. */
3039 tree
3041 {
3049 }
3051 /* Return the argument pack elements of T if T is a template argument pack,
3052 NULL otherwise. */
3054 tree
3056 {
3062 }
3064 /* Structure used to track the progress of find_parameter_packs_r. */
3065 struct find_parameter_pack_data
3066 {
3067 /* TREE_LIST that will contain all of the parameter packs found by
3068 the traversal. */
3071 /* Set of AST nodes that have been visited by the traversal. */
3073 };
3075 /* Identifies all of the argument packs that occur in a template
3076 argument and appends them to the TREE_LIST inside DATA, which is a
3077 find_parameter_pack_data structure. This is a subroutine of
3078 make_pack_expansion and uses_parameter_packs. */
3079 static tree
3081 {
3087 /* Handle type aliases/typedefs. */
3089 {
3096 }
3098 /* Identify whether this is a parameter pack or not. */
3100 {
3116 {
3117 /* We don't want to walk into the type of a PARM_DECL,
3118 because we don't want to see the type parameter pack. */
3121 }
3124 /* Look through a lambda capture proxy to the field pack. */
3127 {
3133 }
3140 /* Not a parameter pack. */
3142 }
3145 {
3146 /* Add this parameter pack to the list. */
3148 }
3154 /* This switch statement will return immediately if we don't find a
3155 parameter pack. */
3157 {
3162 /* Check the template itself. */
3165 /* Check the template arguments. */
3181 /* Fall through. */
3223 }
3226 }
3228 /* Determines if the expression or type T uses any parameter packs. */
3229 bool
3231 {
3239 }
3241 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3242 representation a base-class initializer into a parameter pack
3243 expansion. If all goes well, the resulting node will be an
3244 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3245 respectively. */
3246 tree
3248 {
3249 tree result;
3258 {
3259 /* The only time we will see a TREE_LIST here is for a base
3260 class initializer. In this case, the TREE_PURPOSE will be a
3261 _TYPE node (representing the base class expansion we're
3262 initializing) and the TREE_VALUE will be a TREE_LIST
3263 containing the initialization arguments.
3265 The resulting expansion looks somewhat different from most
3266 expansions. Rather than returning just one _EXPANSION, we
3267 return a TREE_LIST whose TREE_PURPOSE is a
3268 TYPE_PACK_EXPANSION containing the bases that will be
3269 initialized. The TREE_VALUE will be identical to the
3270 original TREE_VALUE, which is a list of arguments that will
3271 be passed to each base. We do not introduce any new pack
3272 expansion nodes into the TREE_VALUE (although it is possible
3273 that some already exist), because the TREE_PURPOSE and
3274 TREE_VALUE all need to be expanded together with the same
3275 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3276 resulting TREE_PURPOSE will mention the parameter packs in
3277 both the bases and the arguments to the bases. */
3278 tree purpose;
3279 tree value;
3282 /* Determine which parameter packs will be used by the base
3283 class expansion. */
3290 {
3294 }
3297 {
3298 /* Collect the sets of parameter packs used in each of the
3299 initialization arguments. */
3301 {
3302 /* Determine which parameter packs will be expanded in this
3303 argument. */
3306 }
3307 }
3311 /* Create the pack expansion type for the base type. */
3316 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3317 they will rarely be compared to anything. */
3321 }
3326 /* Build the PACK_EXPANSION_* node. */
3327 result = for_types
3332 {
3333 /* Propagate type and const-expression information. */
3336 }
3337 else
3338 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3339 they will rarely be compared to anything. */
3342 /* Determine which parameter packs will be expanded. */
3348 /* Make sure we found some parameter packs. */
3350 {
3353 else
3356 }
3362 }
3364 /* Checks T for any "bare" parameter packs, which have not yet been
3365 expanded, and issues an error if any are found. This operation can
3366 only be done on full expressions or types (e.g., an expression
3367 statement, "if" condition, etc.), because we could have expressions like:
3369 foo(f(g(h(args)))...)
3371 where "args" is a parameter pack. check_for_bare_parameter_packs
3372 should not be called for the subexpressions args, h(args),
3373 g(h(args)), or f(g(h(args))), because we would produce erroneous
3374 error messages.
3376 Returns TRUE and emits an error if there were bare parameter packs,
3377 returns FALSE otherwise. */
3378 bool
3380 {
3396 {
3399 {
3408 else
3413 else
3417 }
3420 }
3423 }
3425 /* Expand any parameter packs that occur in the template arguments in
3426 ARGS. */
3427 tree
3429 {
3435 /* First, determine if we need to expand anything, and the number of
3436 slots we'll need. */
3438 {
3443 {
3447 else
3449 }
3450 else
3451 {
3453 num_result_args++;
3454 }
3455 }
3457 /* If no expansion is necessary, we're done. */
3461 /* Expand arguments. */
3464 non_default_args_count =
3467 {
3470 {
3477 }
3478 else
3479 {
3482 }
3483 }
3487 }
3489 /* Checks if DECL shadows a template parameter.
3491 [temp.local]: A template-parameter shall not be redeclared within its
3492 scope (including nested scopes).
3494 Emits an error and returns TRUE if the DECL shadows a parameter,
3495 returns FALSE otherwise. */
3497 bool
3499 {
3500 tree olddecl;
3502 /* If we're not in a template, we can't possibly shadow a template
3503 parameter. */
3507 /* Figure out what we're shadowing. */
3512 /* If there's no previous binding for this name, we're not shadowing
3513 anything, let alone a template parameter. */
3517 /* If we're not shadowing a template parameter, we're done. Note
3518 that OLDDECL might be an OVERLOAD (or perhaps even an
3519 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3520 node. */
3524 /* We check for decl != olddecl to avoid bogus errors for using a
3525 name inside a class. We check TPFI to avoid duplicate errors for
3526 inline member templates. */
3532 /* Don't complain about the injected class name, as we've already
3533 complained about the class itself. */
3540 }
3542 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3543 ORIG_LEVEL, DECL, and TYPE. */
3545 static tree
3549 tree decl,
3550 tree type)
3551 {
3562 }
3564 /* Find the canonical type parameter for the given template type
3565 parameter. Returns the canonical type parameter, which may be TYPE
3566 if no such parameter existed. */
3568 static tree
3570 {
3571 tree list;
3585 else
3586 {
3591 }
3592 }
3594 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3595 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3596 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3597 new one is created. */
3599 static tree
3601 tsubst_flags_t complain)
3602 {
3607 {
3626 /* Template template parameters need this. */
3631 }
3634 }
3636 /* Process information from new template parameter PARM and append it
3637 to the LIST being built. This new parameter is a non-type
3638 parameter iff IS_NON_TYPE is true. This new parameter is a
3639 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3640 is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template
3641 parameter list PARM belongs to. This is used used to create a
3642 proper canonical type for the type of PARM that is to be created,
3643 iff PARM is a type. If the size is not known, this parameter shall
3644 be set to 0. */
3646 tree
3649 {
3651 tree defval;
3652 tree err_parm_list;
3659 {
3663 {
3667 else
3669 }
3672 }
3673 else
3677 {
3683 {
3687 }
3688 else
3689 {
3690 /* [temp.param]
3692 The top-level cv-qualifiers on the template-parameter are
3693 ignored when determining its type. */
3696 {
3700 }
3703 /* If we're in a nested template parameter list, the template
3704 template parameter could be a parameter pack. */
3706 {
3707 /* This template parameter is not a parameter pack, but it
3708 should be. Complain about "bare" parameter packs. */
3711 /* Recover by calling this a parameter pack. */
3713 }
3714 }
3716 /* A template parameter is not modifiable. */
3725 processing_template_decl,
3730 }
3731 else
3732 {
3733 tree t;
3737 {
3739 /* This is for distinguishing between real templates and template
3740 template parameters */
3744 }
3745 else
3746 {
3748 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3751 }
3758 processing_template_decl,
3762 }
3768 }
3770 /* The end of a template parameter list has been reached. Process the
3771 tree list into a parameter vector, converting each parameter into a more
3772 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3773 as PARM_DECLs. */
3775 tree
3777 {
3782 current_template_parms
3787 {
3791 }
3796 }
3798 /* end_template_decl is called after a template declaration is seen. */
3800 void
3802 {
3808 /* This matches the pushlevel in begin_template_parm_list. */
3813 }
3815 /* Takes a TREE_LIST representing a template parameter and convert it
3816 into an argument suitable to be passed to the type substitution
3817 functions. Note that If the TREE_LIST contains an error_mark
3818 node, the returned argument is error_mark_node. */
3820 static tree
3822 {
3835 {
3839 {
3840 /* Turn this argument into a TYPE_ARGUMENT_PACK
3841 with a single element, which expands T. */
3843 #ifdef ENABLE_CHECKING
3844 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3846 #endif
3851 }
3852 }
3853 else
3854 {
3858 {
3859 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3860 with a single element, which expands T. */
3863 #ifdef ENABLE_CHECKING
3864 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3866 #endif
3873 }
3874 else
3876 }
3878 }
3880 /* Given a set of template parameters, return them as a set of template
3881 arguments. The template parameters are represented as a TREE_VEC, in
3882 the form documented in cp-tree.h for template arguments. */
3884 static tree
3886 {
3887 tree header;
3892 /* If there is only one level of template parameters, we do not
3893 create a TREE_VEC of TREE_VECs. Instead, we return a single
3894 TREE_VEC containing the arguments. */
3899 {
3907 #ifdef ENABLE_CHECKING
3909 #endif
3913 else
3915 }
3918 /* This can happen for template parms of a template template
3919 parameter, e.g:
3921 template<template<class T, class U> class TT> struct S;
3923 Consider the level of the parms of TT; T and U both have
3924 level 2; TT has no template parm of level 1. So in this case
3925 the first element of full_template_args is NULL_TREE. If we
3926 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3927 of 2. This will make tsubst wrongly consider that T and U
3928 have level 1. Instead, let's create a dummy vector as the
3929 first element of full_template_args so that TMPL_ARGS_DEPTH
3930 returns the correct depth for args. */
3933 }
3935 /* Within the declaration of a template, return the currently active
3936 template parameters as an argument TREE_VEC. */
3938 static tree
3940 {
3942 }
3944 /* Update the declared TYPE by doing any lookups which were thought to be
3945 dependent, but are not now that we know the SCOPE of the declarator. */
3947 tree
3949 {
3960 /* Don't bother building up the args in this case. */
3962 {
3963 /* tsubst in the args corresponding to the template parameters,
3964 including auto if present. Most things will be unchanged, but
3965 make_typename_type and tsubst_qualified_id will resolve
3966 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3969 tree pushed;
3971 {
3975 }
3980 }
3986 {
3989 else
3991 }
3993 }
3995 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3996 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3997 a member template. Used by push_template_decl below. */
3999 static tree
4001 {
4009 }
4011 struct template_parm_data
4012 {
4013 /* The level of the template parameters we are currently
4014 processing. */
4017 /* The index of the specialization argument we are currently
4018 processing. */
4021 /* An array whose size is the number of template parameters. The
4022 elements are nonzero if the parameter has been used in any one
4023 of the arguments processed so far. */
4026 /* An array whose size is the number of template arguments. The
4027 elements are nonzero if the argument makes use of template
4028 parameters of this level. */
4030 };
4032 /* Subroutine of push_template_decl used to see if each template
4033 parameter in a partial specialization is used in the explicit
4034 argument list. If T is of the LEVEL given in DATA (which is
4035 treated as a template_parm_data*), then DATA->PARMS is marked
4036 appropriately. */
4038 static int
4040 {
4046 {
4049 }
4050 else
4051 {
4054 }
4057 {
4060 }
4062 /* Return zero so that for_each_template_parm will continue the
4063 traversal of the tree; we want to mark *every* template parm. */
4065 }
4067 /* Process the partial specialization DECL. */
4069 static tree
4071 {
4077 tree inner_parms;
4078 tree inst;
4091 /* We check that each of the template parameters given in the
4092 partial specialization is used in the argument list to the
4093 specialization. For example:
4095 template <class T> struct S;
4096 template <class T> struct S<T*>;
4098 The second declaration is OK because `T*' uses the template
4099 parameter T, whereas
4101 template <class T> struct S<int>;
4103 is no good. Even trickier is:
4105 template <class T>
4106 struct S1
4107 {
4108 template <class U>
4109 struct S2;
4110 template <class U>
4111 struct S2<T>;
4112 };
4114 The S2<T> declaration is actually invalid; it is a
4115 full-specialization. Of course,
4117 template <class U>
4118 struct S2<T (*)(U)>;
4120 or some such would have been OK. */
4128 {
4133 NULL,
4135 }
4138 {
4139 /* One of the template parms was not used in the
4140 specialization. */
4142 {
4145 }
4148 }
4153 /* [temp.class.spec]
4155 The argument list of the specialization shall not be identical to
4156 the implicit argument list of the primary template. */
4163 /* A partial specialization that replaces multiple parameters of the
4164 primary template with a pack expansion is less specialized for those
4165 parameters. */
4167 {
4169 "primary template because it replaces multiple parameters "
4173 }
4175 /* [temp.class.spec]
4177 A partially specialized non-type argument expression shall not
4178 involve template parameters of the partial specialization except
4179 when the argument expression is a simple identifier.
4181 The type of a template parameter corresponding to a specialized
4182 non-type argument shall not be dependent on a parameter of the
4183 specialization.
4185 Also, we verify that pack expansions only occur at the
4186 end of the argument list. */
4190 {
4197 {
4198 /* Extract the arguments from the argument pack. We'll be
4199 iterating over these in the following loop. */
4202 }
4205 {
4207 /* Get the Jth argument in the parameter pack. */
4211 {
4212 /* Pack expansions must come at the end of the
4213 argument list. */
4216 {
4220 else
4223 }
4224 }
4227 /* We only care about the pattern. */
4233 /* This next two lines are the `argument expression is not just a
4234 simple identifier' condition and also the `specialized
4235 non-type argument' bit. */
4239 {
4243 arg);
4244 else
4245 {
4246 /* Look at the corresponding template parameter,
4247 marking which template parameters its type depends
4248 upon. */
4252 {
4253 /* We haven't yet initialized TPD2. Do so now. */
4255 /* The number of parameters here is the number in the
4256 main template, which, as checked in the assertion
4257 above, is NARGS. */
4261 }
4263 /* Mark the template parameters. But this time, we're
4264 looking for the template parameters of the main
4265 template, not in the specialization. */
4272 NULL,
4276 {
4277 /* The type depended on some template parameters.
4278 If they are fully specialized in the
4279 specialization, that's OK. */
4288 "type %qT of template argument %qE depends "
4290 "type %qT of template argument %qE depends "
4292 type,
4293 arg);
4294 }
4295 }
4296 }
4297 }
4298 }
4300 /* We should only get here once. */
4318 {
4322 {
4326 "partial specialization of %qT after instantiation "
4328 }
4329 }
4332 }
4334 /* PARM is a template parameter of some form; return the corresponding
4335 TEMPLATE_PARM_INDEX. */
4337 static tree
4339 {
4351 }
4353 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4354 parameter packs used by the template parameter PARM. */
4356 static void
4358 {
4359 /* A type parm can't refer to another parm. */
4363 {
4367 }
4374 }
4376 /* PARM is a template parameter pack. Return any parameter packs used in
4377 its type or the type of any of its template parameters. If there are
4378 any such packs, it will be instantiated into a fixed template parameter
4379 list by partial instantiation rather than be fully deduced. */
4381 tree
4383 {
4384 /* This can only be true in a member template. */
4387 /* This can only be true for a parameter pack. */
4390 /* A type parm can't refer to another parm. */
4403 }
4405 /* Check that a template declaration's use of default arguments and
4406 parameter packs is not invalid. Here, PARMS are the template
4407 parameters. IS_PRIMARY is true if DECL is the thing declared by
4408 a primary template. IS_PARTIAL is true if DECL is a partial
4409 specialization.
4411 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4412 declaration (but not a definition); 1 indicates a declaration, 2
4413 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4414 emitted for extraneous default arguments.
4416 Returns TRUE if there were no errors found, FALSE otherwise. */
4418 bool
4421 {
4424 tree parm_level;
4427 /* [temp.param]
4429 A default template-argument shall not be specified in a
4430 function template declaration or a function template definition, nor
4431 in the template-parameter-list of the definition of a member of a
4432 class template. */
4435 /* You can't have a function template declaration in a local
4436 scope, nor you can you define a member of a class template in a
4437 local scope. */
4443 /* A lambda doesn't have an explicit declaration; don't complain
4444 about the parms of the enclosing class. */
4451 /* If this is either a friend defined in the scope of the class
4452 or a member function. */
4458 /* And, if it was a member function, it really was defined in
4459 the scope of the class. */
4462 /* We already checked these parameters when the template was
4463 declared, so there's no need to do it again now. This function
4464 was defined in class scope, but we're processing its body now
4465 that the class is complete. */
4468 /* Core issue 226 (C++0x only): the following only applies to class
4469 templates. */
4472 {
4473 /* [temp.param]
4475 If a template-parameter has a default template-argument, all
4476 subsequent template-parameters shall have a default
4477 template-argument supplied. */
4479 {
4486 {
4496 {
4498 /* For better subsequent error-recovery, we indicate that
4499 there should have been a default argument. */
4502 }
4504 && !is_friend_decl
4505 /* Don't complain about an enclosing partial
4506 specialization. */
4511 /* A fixed parameter pack will be partially
4512 instantiated into a fixed length list. */
4514 {
4515 /* A primary class template can only have one
4516 parameter pack, at the end of the template
4517 parameter list. */
4522 else
4530 }
4531 }
4532 }
4533 }
4536 || is_partial
4537 || !is_primary
4539 /* For an ordinary class template, default template arguments are
4540 allowed at the innermost level, e.g.:
4541 template <class T = int>
4542 struct S {};
4543 but, in a partial specialization, they're not allowed even
4544 there, as we have in [temp.class.spec]:
4546 The template parameter list of a specialization shall not
4547 contain default template argument values.
4549 So, for a partial specialization, or for a function template
4550 (in C++98/C++03), we look at all of them. */
4551 ;
4552 else
4553 /* But, for a primary class template that is not a partial
4554 specialization we look at all template parameters except the
4555 innermost ones. */
4558 /* Figure out what error message to issue. */
4571 else
4575 /* If we're inside a class definition, there's no need to
4576 examine the parameters to the class itself. On the one
4577 hand, they will be checked when the class is defined, and,
4578 on the other, default arguments are valid in things like:
4579 template <class T = double>
4580 struct S { template <class U> void f(U); };
4581 Here the default argument for `S' has no bearing on the
4582 declaration of `f'. */
4584 else
4585 /* Check everything. */
4591 {
4598 {
4603 {
4605 {
4612 }
4614 /* Clear out the default argument so that we are not
4615 confused later. */
4617 }
4618 }
4620 /* At this point, if we're still interested in issuing messages,
4621 they must apply to classes surrounding the object declared. */
4625 }
4628 }
4630 /* Worker for push_template_decl_real, called via
4631 for_each_template_parm. DATA is really an int, indicating the
4632 level of the parameters we are interested in. If T is a template
4633 parameter of that level, return nonzero. */
4635 static int
4637 {
4643 else
4646 }
4648 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4649 parameters given by current_template_args, or reuses a
4650 previously existing one, if appropriate. Returns the DECL, or an
4651 equivalent one, if it is replaced via a call to duplicate_decls.
4653 If IS_FRIEND is true, DECL is a friend declaration. */
4655 tree
4657 {
4658 tree tmpl;
4659 tree args;
4660 tree info;
4661 tree ctx;
4665 /* True if the template is a member template, in the sense of
4666 [temp.mem]. */
4672 /* See if this is a partial specialization. */
4681 /* For a friend, we want the context of the friend function, not
4682 the type of which it is a friend. */
4686 /* In the case of a virtual function, we want the class in which
4687 it is defined. */
4689 else
4690 /* Otherwise, if we're currently defining some class, the DECL
4691 is assumed to be a member of the class. */
4700 /* See if this is a primary template. */
4703 /* A friend template that specifies a class context, i.e.
4704 template <typename T> friend void A<T>::f();
4705 is not primary. */
4707 else
4711 {
4716 {
4719 }
4721 {
4723 {
4724 /* [temp.mem]
4726 A destructor shall not be a member template. */
4729 }
4736 {
4737 /* [basic.stc.dynamic.allocation]
4739 An allocation function can be a function
4740 template. ... Template allocation functions shall
4741 have two or more parameters. */
4744 }
4745 }
4751 /* alias-declaration */
4753 else
4754 {
4757 }
4758 }
4760 /* Check to see that the rules regarding the use of default
4761 arguments are not being violated. */
4765 /* Ensure that there are no parameter packs in the type of this
4766 declaration that have not been expanded. */
4768 {
4769 /* Check each of the arguments individually to see if there are
4770 any bare parameter packs. */
4776 {
4779 {
4780 /* This is a PARM_DECL that contains unexpanded parameter
4781 packs. We have already complained about this in the
4782 check_for_bare_parameter_packs call, so just replace
4783 these types with ERROR_MARK_NODE. */
4786 }
4790 }
4792 /* Check for bare parameter packs in the return type and the
4793 exception specifiers. */
4795 /* Errors were already issued, set return type to int
4796 as the frontend doesn't expect error_mark_node as
4797 the return type. */
4801 }
4806 {
4809 }
4822 {
4827 /* If DECL is a TYPE_DECL for a class-template, then there won't
4828 be DECL_LANG_SPECIFIC. The information equivalent to
4829 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4833 {
4834 /* Since a template declaration already existed for this
4835 class-type, we must be redeclaring it here. Make sure
4836 that the redeclaration is valid. */
4838 current_template_parms);
4839 /* We don't need to create a new TEMPLATE_DECL; just use the
4840 one we already had. */
4842 }
4843 else
4844 {
4846 member_template_p);
4851 {
4852 /* A specialization of a member template of a template
4853 class. */
4857 }
4858 }
4859 }
4860 else
4861 {
4867 {
4870 }
4878 {
4879 tree new_tmpl;
4881 /* The declaration is a specialization of a member
4882 template, declared outside the class. Therefore, the
4883 innermost template arguments will be NULL, so we
4884 replace them with the arguments determined by the
4885 earlier call to check_explicit_specialization. */
4888 new_tmpl
4890 member_template_p);
4900 args,
4903 }
4905 /* Make sure the template headers we got make sense. */
4910 {
4915 }
4916 else
4918 {
4923 {
4927 else
4931 /* Avoid crash in import_export_decl. */
4934 }
4939 /* Can happen in erroneous input. */
4941 else
4943 }
4945 /* Check that the parms are used in the appropriate qualifying scopes
4946 in the declarator. */
4950 {
4956 /* Avoid crash in import_export_decl. */
4959 }
4960 }
4965 /* Push template declarations for global functions and types. Note
4966 that we do not try to push a global template friend declared in a
4967 template class; such a thing may well depend on the template
4968 parameters of the class. */
4971 {
4976 /* Hide template friend classes that haven't been declared yet. */
4978 {
4981 }
4982 }
4985 {
4991 {
4994 /* It is a conversion operator. See if the type converted to
4995 depends on innermost template operands. */
4998 depth))
5000 }
5002 /* Give template template parms a DECL_CONTEXT of the template
5003 for which they are a parameter. */
5006 {
5010 }
5011 }
5013 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5014 back to its most general template. If TMPL is a specialization,
5015 ARGS may only have the innermost set of arguments. Add the missing
5016 argument levels if necessary. */
5024 else
5025 {
5030 }
5033 }
5035 tree
5037 {
5039 }
5041 /* FN is an inheriting constructor that inherits from the constructor
5042 template INHERITED; turn FN into a constructor template with a matching
5043 template header. */
5045 tree
5047 {
5048 tree inner_parms
5051 tree parms
5062 }
5064 /* Called when a class template TYPE is redeclared with the indicated
5065 template PARMS, e.g.:
5067 template <class T> struct S;
5068 template <class T> struct S {}; */
5070 bool
5072 {
5073 tree tmpl;
5074 tree tmpl_parms;
5078 {
5081 }
5085 /* The type is nested in some template class. Nothing to worry
5086 about here; there are no new template parameters for the nested
5087 type. */
5091 {
5093 tmpl);
5095 }
5101 {
5111 }
5114 {
5115 tree tmpl_parm;
5116 tree parm;
5117 tree tmpl_default;
5118 tree parm_default;
5132 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5133 TEMPLATE_DECL. */
5143 {
5147 }
5150 {
5151 /* We have in [temp.param]:
5153 A template-parameter may not be given default arguments
5154 by two different declarations in the same scope. */
5159 }
5162 /* Update the previous template parameters (which are the ones
5163 that will really count) with the new default value. */
5166 /* Update the new parameters, too; they'll be used as the
5167 parameters for any members. */
5169 }
5172 }
5174 /* Simplify EXPR if it is a non-dependent expression. Returns the
5175 (possibly simplified) expression. */
5177 tree
5179 {
5183 /* If we're in a template, but EXPR isn't value dependent, simplify
5184 it. We're supposed to treat:
5186 template <typename T> void f(T[1 + 1]);
5187 template <typename T> void f(T[2]);
5189 as two declarations of the same function, for example. */
5193 {
5194 HOST_WIDE_INT saved_processing_template_decl;
5200 complain,
5205 }
5207 }
5209 tree
5211 {
5213 }
5215 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5216 template declaration, or a TYPE_DECL for an alias declaration. */
5218 bool
5220 {
5228 }
5230 /* Return TRUE iff is a specialization of an alias template. */
5232 bool
5234 {
5242 }
5244 /* Return the number of innermost template parameters in TMPL. */
5246 static int
5248 {
5251 }
5253 /* Return either TMPL or another template that it is equivalent to under DR
5254 1286: An alias that just changes the name of a template is equivalent to
5255 the other template. */
5257 static tree
5259 {
5262 {
5265 {
5270 {
5271 tree alias_args = INNERMOST_TEMPLATE_ARGS
5275 /* The alias type is equivalent to the pattern of the
5276 underlying template, so strip the alias. */
5279 }
5280 }
5282 }
5284 }
5286 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5287 must be a function or a pointer-to-function type, as specified
5288 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5289 and check that the resulting function has external linkage. */
5291 static tree
5293 {
5296 linkage_kind linkage;
5308 /* [temp.arg.nontype]/1
5310 A template-argument for a non-type, non-template template-parameter
5311 shall be one of:
5312 [...]
5313 -- the address of an object or function with external [C++11: or
5314 internal] linkage. */
5317 {
5321 else
5324 }
5328 {
5333 else
5338 }
5341 }
5343 /* Subroutine of convert_nontype_argument.
5344 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5345 Emit an error otherwise. */
5347 static bool
5349 tsubst_flags_t complain)
5350 {
5357 {
5361 }
5363 }
5365 /* Returns TRUE iff the address of OP is value-dependent.
5367 14.6.2.4 [temp.dep.temp]:
5368 A non-integral non-type template-argument is dependent if its type is
5369 dependent or it has either of the following forms
5370 qualified-id
5371 & qualified-id
5372 and contains a nested-name-specifier which specifies a class-name that
5373 names a dependent type.
5375 We generalize this to just say that the address of a member of a
5376 dependent class is value-dependent; the above doesn't cover the
5377 address of a static data member named with an unqualified-id. */
5379 static bool
5381 {
5382 /* We could use get_inner_reference here, but there's no need;
5383 this is only relevant for template non-type arguments, which
5384 can only be expressed as &id-expression. */
5386 {
5390 }
5393 }
5395 /* The next set of functions are used for providing helpful explanatory
5396 diagnostics for failed overload resolution. Their messages should be
5397 indented by two spaces for consistency with the messages in
5398 call.c */
5400 static int
5402 {
5404 }
5406 static int
5408 {
5413 }
5415 static int
5417 {
5419 }
5421 static int
5423 {
5429 }
5431 static int
5433 {
5437 }
5439 static int
5441 {
5444 " template parameter %qD is not a parameter pack, but "
5448 }
5450 static int
5452 {
5455 " template argument %qE does not match "
5459 }
5461 static int
5463 {
5467 }
5469 static int
5471 {
5477 }
5479 static int
5481 {
5483 {
5488 else
5490 " deduced conflicting values for non-type parameter "
5492 }
5494 }
5496 static int
5498 {
5501 " variable-sized array type %qT is not "
5503 arg);
5505 }
5507 static int
5509 {
5513 arg);
5515 }
5517 static int
5519 {
5526 }
5528 static int
5530 {
5532 }
5534 static int
5536 {
5538 }
5540 static int
5543 {
5549 }
5551 static int
5554 {
5557 {
5565 }
5567 }
5569 static int
5571 {
5574 " template parameters of a template template argument are "
5577 }
5579 static int
5581 {
5587 }
5589 static int
5591 {
5596 }
5598 static int
5600 {
5604 arg);
5606 }
5608 /* Attempt to convert the non-type template parameter EXPR to the
5609 indicated TYPE. If the conversion is successful, return the
5610 converted value. If the conversion is unsuccessful, return
5611 NULL_TREE if we issued an error message, or error_mark_node if we
5612 did not. We issue error messages for out-and-out bad template
5613 parameters, but not simply because the conversion failed, since we
5614 might be just trying to do argument deduction. Both TYPE and EXPR
5615 must be non-dependent.
5617 The conversion follows the special rules described in
5618 [temp.arg.nontype], and it is much more strict than an implicit
5619 conversion.
5621 This function is called twice for each template argument (see
5622 lookup_template_class for a more accurate description of this
5623 problem). This means that we need to handle expressions which
5624 are not valid in a C++ source, but can be created from the
5625 first call (for instance, casts to perform conversions). These
5626 hacks can go away after we fix the double coercion problem. */
5628 static tree
5630 {
5631 tree expr_type;
5633 /* Detect immediately string literals as invalid non-type argument.
5634 This special-case is not needed for correctness (we would easily
5635 catch this later), but only to provide better diagnostic for this
5636 common user mistake. As suggested by DR 100, we do not mention
5637 linkage issues in the diagnostic as this is not the point. */
5638 /* FIXME we're making this OK. */
5640 {
5646 }
5648 /* Add the ADDR_EXPR now for the benefit of
5649 value_dependent_expression_p. */
5652 {
5656 }
5658 /* If we are in a template, EXPR may be non-dependent, but still
5659 have a syntactic, rather than semantic, form. For example, EXPR
5660 might be a SCOPE_REF, rather than the VAR_DECL to which the
5661 SCOPE_REF refers. Preserving the qualifying scope is necessary
5662 so that access checking can be performed when the template is
5663 instantiated -- but here we need the resolved form so that we can
5664 convert the argument. */
5675 else
5678 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5679 to a non-type argument of "nullptr". */
5683 /* In C++11, integral or enumeration non-type template arguments can be
5684 arbitrary constant expressions. Pointer and pointer to
5685 member arguments can be general constant expressions that evaluate
5686 to a null value, but otherwise still need to be of a specific form. */
5688 {
5690 /* A PTRMEM_CST is already constant, and a valid template
5691 argument for a parameter of pointer to member type, we just want
5692 to leave it in that form rather than lower it to a
5697 {
5702 }
5703 }
5705 /* HACK: Due to double coercion, we can get a
5706 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5707 which is the tree that we built on the first call (see
5708 below when coercing to reference to object or to reference to
5709 function). We just strip everything and get to the arg.
5710 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5711 for examples. */
5713 {
5719 {
5720 /* ??? Maybe we could use convert_from_reference here, but we
5721 would need to relax its constraints because the NOP_EXPR
5722 could actually change the type to something more cv-qualified,
5723 and this is not folded by convert_from_reference. */
5728 && (same_type_ignoring_top_level_qualifiers_p
5731 {
5734 }
5735 }
5736 }
5738 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5739 parameter is a pointer to object, through decay and
5740 qualification conversion. Let's strip everything. */
5742 {
5747 {
5748 /* Skip the ADDR_EXPR only if it is part of the decay for
5749 an array. Otherwise, it is part of the original argument
5750 in the source code. */
5755 }
5756 }
5758 /* [temp.arg.nontype]/5, bullet 1
5760 For a non-type template-parameter of integral or enumeration type,
5761 integral promotions (_conv.prom_) and integral conversions
5762 (_conv.integral_) are applied. */
5764 {
5773 /* Notice that there are constant expressions like '4 % 0' which
5774 do not fold into integer constants. */
5776 {
5778 {
5789 /* else cxx_constant_value complained but gave us
5790 a real constant, so go ahead. */
5792 }
5793 else
5795 }
5797 /* Avoid typedef problems. */
5800 }
5801 /* [temp.arg.nontype]/5, bullet 2
5803 For a non-type template-parameter of type pointer to object,
5804 qualification conversions (_conv.qual_) and the array-to-pointer
5805 conversion (_conv.array_) are applied. */
5807 {
5808 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5810 A template-argument for a non-type, non-template template-parameter
5811 shall be one of: [...]
5813 -- the name of a non-type template-parameter;
5814 -- the address of an object or function with external linkage, [...]
5815 expressed as "& id-expression" where the & is optional if the name
5816 refers to a function or array, or if the corresponding
5817 template-parameter is a reference.
5819 Here, we do not care about functions, as they are invalid anyway
5820 for a parameter of type pointer-to-object. */
5823 /* Non-type template parameters are OK. */
5824 ;
5829 {
5831 {
5833 "because %qD is a variable, not the address of "
5837 }
5839 {
5844 }
5845 /* Other values, like integer constants, might be valid
5846 non-type arguments of some other type. */
5848 }
5849 else
5850 {
5851 tree decl;
5856 {
5861 }
5863 {
5868 }
5870 {
5875 }
5876 }
5885 }
5886 /* [temp.arg.nontype]/5, bullet 3
5888 For a non-type template-parameter of type reference to object, no
5889 conversions apply. The type referred to by the reference may be more
5890 cv-qualified than the (otherwise identical) type of the
5891 template-argument. The template-parameter is bound directly to the
5892 template-argument, which must be an lvalue. */
5894 {
5896 expr_type))
5900 {
5904 }
5907 {
5911 }
5913 /* [temp.arg.nontype]/1
5915 A template-argument for a non-type, non-template template-parameter
5916 shall be one of: [...]
5918 -- the address of an object or function with external linkage. */
5921 {
5924 {
5926 "because a reference variable does not have a constant "
5929 }
5930 }
5933 {
5938 }
5941 {
5946 }
5949 }
5950 /* [temp.arg.nontype]/5, bullet 4
5952 For a non-type template-parameter of type pointer to function, only
5953 the function-to-pointer conversion (_conv.func_) is applied. If the
5954 template-argument represents a set of overloaded functions (or a
5955 pointer to such), the matching function is selected from the set
5956 (_over.over_). */
5958 {
5959 /* If the argument is a template-id, we might not have enough
5960 context information to decay the pointer. */
5962 {
5966 }
5969 /* Null pointer values are OK in C++11. */
5975 }
5976 /* [temp.arg.nontype]/5, bullet 5
5978 For a non-type template-parameter of type reference to function, no
5979 conversions apply. If the template-argument represents a set of
5980 overloaded functions, the matching function is selected from the set
5981 (_over.over_). */
5983 {
5985 {
5990 }
5997 }
5998 /* [temp.arg.nontype]/5, bullet 6
6000 For a non-type template-parameter of type pointer to member function,
6001 no conversions apply. If the template-argument represents a set of
6002 overloaded member functions, the matching member function is selected
6003 from the set (_over.over_). */
6005 {
6010 /* [temp.arg.nontype] bullet 1 says the pointer to member
6011 expression must be a pointer-to-member constant. */
6015 /* There is no way to disable standard conversions in
6016 resolve_address_of_overloaded_function (called by
6017 instantiate_type). It is possible that the call succeeded by
6018 converting &B::I to &D::I (where B is a base of D), so we need
6019 to reject this conversion here.
6021 Actually, even if there was a way to disable standard conversions,
6022 it would still be better to reject them here so that we can
6023 provide a superior diagnostic. */
6025 {
6029 /* If we are just one standard conversion off, explain. */
6034 }
6035 }
6036 /* [temp.arg.nontype]/5, bullet 7
6038 For a non-type template-parameter of type pointer to data member,
6039 qualification conversions (_conv.qual_) are applied. */
6041 {
6042 /* [temp.arg.nontype] bullet 1 says the pointer to member
6043 expression must be a pointer-to-member constant. */
6050 }
6052 {
6054 {
6058 }
6060 }
6061 /* A template non-type parameter must be one of the above. */
6062 else
6065 /* Sanity check: did we actually convert the argument to the
6066 right type? */
6070 }
6072 /* Subroutine of coerce_template_template_parms, which returns 1 if
6073 PARM_PARM and ARG_PARM match using the rule for the template
6074 parameters of template template parameters. Both PARM and ARG are
6075 template parameters; the rest of the arguments are the same as for
6076 coerce_template_template_parms.
6077 */
6078 static int
6080 tree arg,
6081 tsubst_flags_t complain,
6082 tree in_decl,
6083 tree outer_args)
6084 {
6093 {
6095 /* We encounter instantiations of templates like
6096 template <template <template <class> class> class TT>
6097 class C; */
6098 {
6105 }
6106 /* Fall through. */
6111 /* Argument is a parameter pack but parameter is not. */
6116 /* The tsubst call is used to handle cases such as
6118 template <int> class C {};
6119 template <class T, template <T> class TT> class D {};
6120 D<int, C> d;
6122 i.e. the parameter list of TT depends on earlier parameters. */
6124 && !same_type_p
6131 /* Argument is a parameter pack but parameter is not. */
6138 }
6141 }
6144 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6145 template template parameters. Both PARM_PARMS and ARG_PARMS are
6146 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6147 or PARM_DECL.
6149 Consider the example:
6150 template <class T> class A;
6151 template<template <class U> class TT> class B;
6153 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6154 the parameters to A, and OUTER_ARGS contains A. */
6156 static int
6158 tree arg_parms,
6159 tsubst_flags_t complain,
6160 tree in_decl,
6161 tree outer_args)
6162 {
6173 /* Determine whether we have a parameter pack at the end of the
6174 template template parameter's template parameter list. */
6176 {
6183 {
6197 }
6198 }
6204 /* Check all of the template parameters except the parameter pack at
6205 the end (if any). */
6207 {
6216 outer_args))
6219 }
6222 {
6223 /* Check each of the template parameters in the template
6224 argument against the template parameter pack at the end of
6225 the template template parameter. */
6232 {
6239 outer_args))
6241 }
6242 }
6245 }
6247 /* Verifies that the deduced template arguments (in TARGS) for the
6248 template template parameters (in TPARMS) represent valid bindings,
6249 by comparing the template parameter list of each template argument
6250 to the template parameter list of its corresponding template
6251 template parameter, in accordance with DR150. This
6252 routine can only be called after all template arguments have been
6253 deduced. It will return TRUE if all of the template template
6254 parameter bindings are okay, FALSE otherwise. */
6255 bool
6257 {
6261 /* We're dealing with template parms in this process. */
6267 {
6272 {
6277 {
6278 /* Look inside the argument pack. */
6281 }
6284 {
6288 /* Extract the next argument from the argument
6289 pack. */
6293 /* Look at the pattern of the pack expansion. */
6296 /* Extract the template parameters from the template
6297 argument. */
6303 /* Verify that we can coerce the template template
6304 parameters from the template argument to the template
6305 parameter. This requires an exact match. */
6307 && !coerce_template_template_parms
6309 targ_parms,
6310 tf_none,
6311 tparm,
6312 targs))
6313 {
6316 }
6317 }
6318 }
6319 }
6321 out:
6325 }
6327 /* Since type attributes aren't mangled, we need to strip them from
6328 template type arguments. */
6330 static tree
6332 {
6333 tree mv;
6340 {
6345 }
6347 }
6349 /* Convert the indicated template ARG as necessary to match the
6350 indicated template PARM. Returns the converted ARG, or
6351 error_mark_node if the conversion was unsuccessful. Error and
6352 warning messages are issued under control of COMPLAIN. This
6353 conversion is for the Ith parameter in the parameter list. ARGS is
6354 the full set of template arguments deduced so far. */
6356 static tree
6358 tree arg,
6359 tree args,
6360 tsubst_flags_t complain,
6362 tree in_decl)
6363 {
6364 tree orig_arg;
6365 tree val;
6370 {
6371 /* The template argument was the name of some
6372 member function. That's usually
6373 invalid, but static members are OK. In any
6374 case, grab the underlying fields/functions
6375 and issue an error later if required. */
6378 }
6386 /* When determining whether an argument pack expansion is a template,
6387 look at the pattern. */
6391 /* Deal with an injected-class-name used as a template template arg. */
6393 {
6396 {
6406 }
6407 }
6409 is_tmpl_type =
6425 {
6427 {
6431 }
6434 "to refer to a type member of a template parameter, "
6439 typename_type,
6440 complain);
6443 }
6445 {
6447 {
6449 {
6459 else
6461 }
6462 }
6464 }
6466 {
6468 {
6474 else
6476 }
6478 }
6481 {
6483 {
6487 /* The number of argument required is not known yet.
6488 Just accept it for now. */
6490 else
6491 {
6493 tree argparm;
6495 /* Strip alias templates that are equivalent to another
6496 template. */
6502 args))
6503 {
6506 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6507 TEMPLATE_DECL. */
6509 {
6514 }
6515 }
6516 else
6517 {
6519 {
6525 }
6528 }
6529 }
6530 }
6531 else
6533 /* We only form one instance of each template specialization.
6534 Therefore, if we use a non-canonical variant (i.e., a
6535 typedef), any future messages referring to the type will use
6536 the typedef, which is confusing if those future uses do not
6537 themselves also use the typedef. */
6540 }
6541 else
6542 {
6549 {
6552 else
6553 {
6554 /* Not sure if this is reachable, but it doesn't hurt
6555 to be robust. */
6558 }
6559 }
6562 /* We used to call digest_init here. However, digest_init
6563 will report errors, which we don't want when complain
6564 is zero. More importantly, digest_init will try too
6565 hard to convert things: for example, `0' should not be
6566 converted to pointer type at this point according to
6567 the standard. Accepting this is not merely an
6568 extension, since deciding whether or not these
6569 conversions can occur is part of determining which
6570 function template to call, or whether a given explicit
6571 argument specification is valid. */
6573 else
6582 {
6583 /* Strip typedefs from the SCOPE_REF. */
6586 complain);
6589 }
6590 }
6593 }
6595 /* Coerces the remaining template arguments in INNER_ARGS (from
6596 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6597 Returns the coerced argument pack. PARM_IDX is the position of this
6598 parameter in the template parameter list. ARGS is the original
6599 template argument list. */
6600 static tree
6603 tree args,
6604 tree inner_args,
6606 tree new_args,
6608 tree in_decl,
6609 tsubst_flags_t complain)
6610 {
6613 tree packed_args;
6614 tree argument_pack;
6621 {
6622 /* When the template parameter is a non-type template parameter pack
6623 or template template parameter pack whose type or template
6624 parameters use parameter packs, we know exactly how many arguments
6625 we are looking for. Build a vector of the instantiated decls for
6626 these template parameters in PACKED_PARMS. */
6627 /* We can't use make_pack_expansion here because it would interpret a
6628 _DECL as a use rather than a declaration. */
6642 /* If we're doing a partial instantiation of a member template,
6643 verify that all of the types used for the non-type
6644 template parameter pack are, in fact, valid for non-type
6645 template parameters. */
6648 {
6651 {
6655 }
6656 }
6659 }
6660 else
6663 /* Convert the remaining arguments, which will be a part of the
6664 parameter pack "parm". */
6666 {
6672 {
6673 /* Once we've packed as many args as we have types, stop. */
6677 /* We don't know how many args we have yet, just
6678 use the unconverted ones for now. */
6680 else
6682 }
6685 {
6688 }
6689 else
6692 in_decl);
6696 }
6700 {
6704 }
6709 else
6710 {
6715 }
6718 #ifdef ENABLE_CHECKING
6721 #endif
6723 }
6725 /* Returns the number of pack expansions in the template argument vector
6726 ARGS. */
6728 static int
6730 {
6735 {
6739 }
6741 }
6743 /* Convert all template arguments to their appropriate types, and
6744 return a vector containing the innermost resulting template
6745 arguments. If any error occurs, return error_mark_node. Error and
6746 warning messages are issued under control of COMPLAIN.
6748 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6749 for arguments not specified in ARGS. Otherwise, if
6750 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6751 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6752 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6753 ARGS. */
6755 static tree
6757 tree args,
6758 tree in_decl,
6759 tsubst_flags_t complain,
6762 {
6764 tree orig_inner_args;
6765 tree inner_args;
6766 tree new_args;
6767 tree new_inner_args;
6771 /* When used as a boolean value, indicates whether this is a
6772 variadic template parameter list. Since it's an int, we can also
6773 subtract it from nparms to get the number of non-variadic
6774 parameters. */
6784 /* Determine if there are any parameter packs. */
6786 {
6792 }
6795 /* If there are no parameters that follow a parameter pack, we need to
6796 expand any argument packs so that we can deduce a parameter pack from
6797 some non-packed args followed by an argument pack, as in variadic85.C.
6798 If there are such parameters, we need to leave argument packs intact
6799 so the arguments are assigned properly. This can happen when dealing
6800 with a nested class inside a partial specialization of a class
6801 template, as in variadic92.C, or when deducing a template parameter pack
6802 from a sub-declarator, as in variadic114.C. */
6806 /* Count any pack expansion args. */
6812 && require_all_args
6813 && !variadic_args_p
6814 && (!use_default_args
6817 {
6819 {
6821 {
6825 }
6826 else
6832 }
6835 }
6836 /* We can't pass a pack expansion to a non-pack parameter of an alias
6837 template (DR 1430). */
6839 && variadic_args_p
6841 {
6843 {
6845 {
6851 {
6856 }
6857 }
6859 found:;
6860 }
6862 }
6864 /* We need to evaluate the template arguments, even though this
6865 template-id may be nested within a "sizeof". */
6874 {
6875 tree arg;
6876 tree parm;
6878 /* Get the Ith template parameter. */
6882 {
6885 }
6887 /* Calculate the next argument. */
6890 else
6895 {
6896 /* Some arguments will be placed in the
6897 template parameter pack PARM. */
6904 {
6905 /* We don't know how many args we have yet, just use the
6906 unconverted (and still packed) ones for now. */
6910 }
6914 /* Store this argument. */
6916 {
6917 lost++;
6918 /* We are done with all of the arguments. */
6920 }
6921 else
6922 {
6925 }
6928 }
6930 {
6932 {
6933 /* We don't know how many args we have yet, just
6934 use the unconverted ones for now. */
6938 }
6939 }
6941 {
6942 /* There must be a default arg in this case. */
6945 /* The position of the first default template argument,
6946 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6947 Record that. */
6951 }
6952 else
6956 {
6959 }
6961 /* This only occurs if there was an error in the template
6962 parameter list itself (which we would already have
6963 reported) that we are trying to recover from, e.g., a class
6964 template with a parameter list such as
6965 template<typename..., typename>. */
6967 else
6973 lost++;
6975 }
6980 {
6982 {
6987 }
6989 }
6994 #ifdef ENABLE_CHECKING
6998 #endif
7001 }
7003 /* Like coerce_template_parms. If PARMS represents all template
7004 parameters levels, this function returns a vector of vectors
7005 representing all the resulting argument levels. Note that in this
7006 case, only the innermost arguments are coerced because the
7007 outermost ones are supposed to have been coerced already.
7009 Otherwise, if PARMS represents only (the innermost) vector of
7010 parameters, this function returns a vector containing just the
7011 innermost resulting arguments. */
7013 static tree
7015 tree args,
7016 tree in_decl,
7017 tsubst_flags_t complain,
7020 {
7023 tree coerced_args;
7026 {
7028 tree level;
7034 {
7035 tree l;
7039 require_all_args,
7040 use_default_args);
7041 else
7048 }
7049 }
7050 else
7053 require_all_args,
7054 use_default_args);
7056 }
7058 /* Returns 1 if template args OT and NT are equivalent. */
7060 static int
7062 {
7069 /* For member templates */
7078 {
7095 }
7097 {
7098 /* We get here probably because we are in the middle of substituting
7099 into the pattern of a pack expansion. In that case the
7100 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7101 interested in. So we want to use the initial pack argument for
7102 the comparison. */
7107 }
7112 else
7114 }
7116 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7117 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7118 NEWARG_PTR with the offending arguments if they are non-NULL. */
7120 static int
7123 {
7136 {
7141 {
7147 }
7148 }
7150 }
7152 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7153 of template arguments. Returns 0 otherwise. */
7155 int
7157 {
7159 }
7161 static void
7163 {
7173 /* We are called both from instantiate_decl, where we've already had a
7174 tinst_level pushed, and instantiate_template, where we haven't.
7175 Compensate. */
7186 else
7195 }
7198 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7199 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7200 documentation for TEMPLATE_ID_EXPR. */
7202 tree
7204 {
7205 tree type;
7213 {
7216 }
7219 {
7221 unknown_type_node,
7223 arglist);
7225 }
7232 }
7234 /* Within the scope of a template class S<T>, the name S gets bound
7235 (in build_self_reference) to a TYPE_DECL for the class, not a
7236 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7237 or one of its enclosing classes, and that type is a template,
7238 return the associated TEMPLATE_DECL. Otherwise, the original
7239 DECL is returned.
7241 Also handle the case when DECL is a TREE_LIST of ambiguous
7242 injected-class-names from different bases. */
7244 tree
7246 {
7250 /* DR 176: A lookup that finds an injected-class-name (10.2
7251 [class.member.lookup]) can result in an ambiguity in certain cases
7252 (for example, if it is found in more than one base class). If all of
7253 the injected-class-names that are found refer to specializations of
7254 the same class template, and if the name is followed by a
7255 template-argument-list, the reference refers to the class template
7256 itself and not a specialization thereof, and is not ambiguous. */
7258 {
7261 {
7267 }
7270 else
7272 }
7278 }
7280 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7281 parameters, find the desired type.
7283 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7285 IN_DECL, if non-NULL, is the template declaration we are trying to
7286 instantiate.
7288 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7289 the class we are looking up.
7291 Issue error and warning messages under control of COMPLAIN.
7293 If the template class is really a local class in a template
7294 function, then the FUNCTION_CONTEXT is the function in which it is
7295 being instantiated.
7297 ??? Note that this function is currently called *twice* for each
7298 template-id: the first time from the parser, while creating the
7299 incomplete type (finish_template_type), and the second type during the
7300 real instantiation (instantiate_template_class). This is surely something
7301 that we want to avoid. It also causes some problems with argument
7302 coercion (see convert_nontype_argument for more information on this). */
7304 static tree
7307 {
7309 tree t;
7312 spec_entry elt;
7313 hashval_t hash;
7316 {
7320 else
7321 {
7328 }
7331 }
7333 {
7336 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7337 an implicit typename for the second A. Deal with it. */
7342 {
7345 }
7346 }
7349 {
7352 }
7356 {
7360 }
7362 {
7365 }
7367 /* Issue an error message if we didn't find a template. */
7369 {
7373 }
7376 /* Make sure it's a user visible template, if it was named by
7377 the user. */
7380 {
7382 {
7386 }
7388 }
7392 /* An alias that just changes the name of a template is equivalent to the
7393 other template, so if any of the arguments are pack expansions, strip
7394 the alias to avoid problems with a pack expansion passed to a non-pack
7395 alias template parameter (DR 1430). */
7400 {
7401 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7402 template arguments */
7404 tree parm;
7405 tree arglist2;
7406 tree outer;
7410 /* Consider an example where a template template parameter declared as
7412 template <class T, class U = std::allocator<T> > class TT
7414 The template parameter level of T and U are one level larger than
7415 of TT. To proper process the default argument of U, say when an
7416 instantiation `TT<int>' is seen, we need to build the full
7417 arguments containing {int} as the innermost level. Outer levels,
7418 available when not appearing as default template argument, can be
7419 obtained from the arguments of the enclosing template.
7421 Suppose that TT is later substituted with std::vector. The above
7422 instantiation is `TT<int, std::allocator<T> >' with TT at
7423 level 1, and T at level 2, while the template arguments at level 1
7424 becomes {std::vector} and the inner level 2 is {int}. */
7430 /* This is an argument of the current template, so we haven't set
7431 DECL_CONTEXT yet. */
7438 complain,
7448 }
7449 else
7450 {
7452 tree gen_tmpl;
7453 tree type_decl;
7461 /* An error occurred while building the template TEMPL, and a
7462 diagnostic has most certainly been emitted for that
7463 already. Let's propagate that error. */
7472 {
7473 /* We've been given an incomplete set of template arguments.
7474 For example, given:
7476 template <class T> struct S1 {
7477 template <class U> struct S2 {};
7478 template <class U> struct S2<U*> {};
7479 };
7481 we will be called with an ARGLIST of `U*', but the
7482 TEMPLATE will be `template <class T> template
7483 <class U> struct S1<T>::S2'. We must fill in the missing
7484 arguments. */
7485 arglist
7487 arglist);
7489 }
7491 /* Now we should have enough arguments. */
7494 /* From here on, we're only interested in the most general
7495 template. */
7497 /* Calculate the BOUND_ARGS. These will be the args that are
7498 actually tsubst'd into the definition to create the
7499 instantiation. */
7501 {
7502 /* We have multiple levels of arguments to coerce, at once. */
7512 {
7513 tree a;
7517 complain,
7520 else
7521 /* Outer levels should have already been coerced. */
7524 /* Don't process further if one of the levels fails. */
7526 {
7527 /* Restore the ARGLIST to its full size. */
7530 }
7534 /* We temporarily reduce the length of the ARGLIST so
7535 that coerce_template_parms will see only the arguments
7536 corresponding to the template parameters it is
7537 examining. */
7539 }
7541 /* Restore the ARGLIST to its full size. */
7545 }
7546 else
7547 arglist
7550 gen_tmpl,
7551 complain,
7556 /* We were unable to bind the arguments. */
7559 /* In the scope of a template class, explicit references to the
7560 template class refer to the type of the template, not any
7561 instantiation of it. For example, in:
7563 template <class T> class C { void f(C<T>); }
7565 the `C<T>' is just the same as `C'. Outside of the
7566 class, however, such a reference is an instantiation. */
7570 /* comp_template_args is expensive, check it last. */
7572 arglist))
7575 /* If we already have this specialization, return it. */
7587 /* If the deduced arguments are invalid, then the binding
7588 failed. */
7592 complain))
7599 {
7604 }
7614 /* Create the type. */
7616 {
7617 /* The user referred to a specialization of an alias
7618 template represented by GEN_TMPL.
7620 [temp.alias]/2 says:
7622 When a template-id refers to the specialization of an
7623 alias template, it is equivalent to the associated
7624 type obtained by substitution of its
7625 template-arguments for the template-parameters in the
7626 type-id of the alias template. */
7629 /* Note that the call above (by indirectly calling
7630 register_specialization in tsubst_decl) registers the
7631 TYPE_DECL representing the specialization of the alias
7632 template. So next time someone substitutes ARGLIST for
7633 the template parms into the alias template (GEN_TMPL),
7634 she'll get that TYPE_DECL back. */
7638 }
7640 {
7642 {
7651 }
7652 else
7653 {
7654 /* We don't want to call start_enum for this type, since
7655 the values for the enumeration constants may involve
7656 template parameters. And, no one should be interested
7657 in the enumeration constants for such a type. */
7660 }
7664 }
7666 {
7673 /* A local class. Make sure the decl gets registered properly. */
7678 /* This instantiation is another name for the primary
7679 template type. Set the TYPE_CANONICAL field
7680 appropriately. */
7683 /* Some of the template arguments require structural
7684 equality testing, so this template class requires
7685 structural equality testing. */
7687 }
7688 else
7691 /* If we called start_enum or pushtag above, this information
7692 will already be set up. */
7694 {
7701 }
7702 else
7706 {
7712 {
7715 }
7716 }
7718 /* Let's consider the explicit specialization of a member
7719 of a class template specialization that is implicitly instantiated,
7720 e.g.:
7721 template<class T>
7722 struct S
7723 {
7724 template<class U> struct M {}; //#0
7725 };
7727 template<>
7728 template<>
7729 struct S<int>::M<char> //#1
7730 {
7731 int i;
7732 };
7733 [temp.expl.spec]/4 says this is valid.
7735 In this case, when we write:
7736 S<int>::M<char> m;
7738 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7739 the one of #0.
7741 When we encounter #1, we want to store the partial instantiation
7742 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7744 For all cases other than this "explicit specialization of member of a
7745 class template", we just want to store the most general template into
7746 the CLASSTYPE_TI_TEMPLATE of M.
7748 This case of "explicit specialization of member of a class template"
7749 only happens when:
7750 1/ the enclosing class is an instantiation of, and therefore not
7751 the same as, the context of the most general template, and
7752 2/ we aren't looking at the partial instantiation itself, i.e.
7753 the innermost arguments are not the same as the innermost parms of
7754 the most general template.
7756 So it's only when 1/ and 2/ happens that we want to use the partial
7757 instantiation of the member template in lieu of its most general
7758 template. */
7762 /* the enclosing class must be an instantiation... */
7765 {
7766 tree partial_inst_args;
7769 partial_inst_args =
7775 use_partial_inst_tmpl =
7776 /*...and we must not be looking at the partial instantiation
7777 itself. */
7779 partial_inst_args);
7780 }
7783 /* This case is easy; there are no member templates involved. */
7785 else
7786 {
7787 /* This is a full instantiation of a member template. Find
7788 the partial instantiation of which this is an instance. */
7790 /* Temporarily reduce by one the number of levels in the ARGLIST
7791 so as to avoid comparing the last set of arguments. */
7795 /* FOUND is either a proper class type, or an alias
7796 template specialization. In the later case, it's a
7797 TYPE_DECL, resulting from the substituting of arguments
7798 for parameters in the TYPE_DECL of the alias template
7799 done earlier. So be careful while getting the template
7800 of FOUND. */
7804 }
7815 /* Note this use of the partial instantiation so we can check it
7816 later in maybe_process_partial_specialization. */
7823 /* Now that the type has been registered on the instantiations
7824 list, we set up the enumerators. Because the enumeration
7825 constants may involve the enumeration type itself, we make
7826 sure to register the type first, and then create the
7827 constants. That way, doing tsubst_expr for the enumeration
7828 constants won't result in recursive calls here; we'll find
7829 the instantiation and exit above. */
7833 /* If the type makes use of template parameters, the
7834 code that generates debugging information will crash. */
7837 /* Possibly limit visibility based on template args. */
7842 }
7843 }
7845 /* Wrapper for lookup_template_class_1. */
7847 tree
7850 {
7851 tree ret;
7857 }
7858 \f
7859 struct pair_fn_data
7860 {
7861 tree_fn_t fn;
7863 /* True when we should also visit template parameters that occur in
7864 non-deduced contexts. */
7867 };
7869 /* Called from for_each_template_parm via walk_tree. */
7871 static tree
7873 {
7886 {
7890 /* Fall through. */
7913 /* Since we're not going to walk subtrees, we have to do this
7914 explicitly here. */
7918 /* Fall through. */
7921 /* Check the return type. */
7926 /* Check the parameter types. Since default arguments are not
7927 instantiated until they are needed, the TYPE_ARG_TYPES may
7928 contain expressions that involve template parameters. But,
7929 no-one should be looking at them yet. And, once they're
7930 instantiated, they don't contain template parameters, so
7931 there's no point in looking at them then, either. */
7932 {
7933 tree parm;
7940 /* Since we've already handled the TYPE_ARG_TYPES, we don't
7941 want walk_tree walking into them itself. */
7943 }
7961 /* Fall through. */
7977 /* Record template parameters such as `T' inside `TT<T>'. */
7981 /* Fall through. */
7993 /* A template template parameter is encountered. */
7999 /* Already substituted template template parameter */
8022 /* If there's no type, then this thing must be some expression
8023 involving template parameters. */
8045 }
8047 /* We didn't find any template parameters we liked. */
8049 }
8051 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8052 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8053 call FN with the parameter and the DATA.
8054 If FN returns nonzero, the iteration is terminated, and
8055 for_each_template_parm returns 1. Otherwise, the iteration
8056 continues. If FN never returns a nonzero value, the value
8057 returned by for_each_template_parm is 0. If FN is NULL, it is
8058 considered to be the function which always returns 1.
8060 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8061 parameters that occur in non-deduced contexts. When false, only
8062 visits those template parameters that can be deduced. */
8064 static int
8068 {
8072 /* Set up. */
8077 /* Walk the tree. (Conceptually, we would like to walk without
8078 duplicates, but for_each_template_parm_r recursively calls
8079 for_each_template_parm, so we would need to reorganize a fair
8080 bit to use walk_tree_without_duplicates, so we keep our own
8081 visited list.) */
8084 else
8087 for_each_template_parm_r,
8091 /* Clean up. */
8093 {
8096 }
8099 }
8101 /* Returns true if T depends on any template parameter. */
8103 int
8105 {
8132 else
8133 {
8136 }
8141 }
8143 /* Returns true iff current_function_decl is an incompletely instantiated
8144 template. Useful instead of processing_template_decl because the latter
8145 is set to 0 during fold_non_dependent_expr. */
8147 bool
8149 {
8158 }
8160 /* Returns true if T depends on any template parameter with level LEVEL. */
8162 int
8164 {
8167 }
8169 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8170 ill-formed translation unit, i.e. a variable or function that isn't
8171 usable in a constant expression. */
8175 {
8179 }
8181 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8182 neglectable and instantiated from within an erroneous instantiation. */
8184 static bool
8186 {
8197 }
8205 /* We're starting to instantiate D; record the template instantiation context
8206 for diagnostics and to restore it later. */
8208 int
8210 {
8214 {
8220 else
8228 }
8230 /* If the current instantiation caused problems, don't let it instantiate
8231 anything else. Do allow deduction substitution and decls usable in
8232 constant expressions. */
8249 }
8251 /* We're done instantiating this template; return to the instantiation
8252 context. */
8254 void
8256 {
8257 /* Restore the filename and line number stashed away when we started
8258 this instantiation. */
8262 }
8264 /* We're instantiating a deferred template; restore the template
8265 instantiation context in which the instantiation was requested, which
8266 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8268 static tree
8270 {
8282 }
8284 /* Returns the TINST_LEVEL which gives the original instantiation
8285 context. */
8289 {
8295 }
8297 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8298 vector of template arguments, as for tsubst.
8300 Returns an appropriate tsubst'd friend declaration. */
8302 static tree
8304 {
8305 tree new_friend;
8310 /* This was a friend declared with an explicit template
8311 argument list, e.g.:
8313 friend void f<>(T);
8315 to indicate that f was a template instantiation, not a new
8316 function declaration. Now, we have to figure out what
8317 instantiation of what template. */
8318 {
8320 tree new_args;
8321 tree tmpl;
8324 /* Friend functions are looked up in the containing namespace scope.
8325 We must enter that scope, to avoid finding member functions of the
8326 current class with same name. */
8341 tsk_none);
8343 }
8347 /* The NEW_FRIEND will look like an instantiation, to the
8348 compiler, but is not an instantiation from the point of view of
8349 the language. For example, we might have had:
8351 template <class T> struct S {
8352 template <class U> friend void f(T, U);
8353 };
8355 Then, in S<int>, template <class U> void f(int, U) is not an
8356 instantiation of anything. */
8362 {
8366 }
8368 /* The mangled name for the NEW_FRIEND is incorrect. The function
8369 is not a template instantiation and should not be mangled like
8370 one. Therefore, we forget the mangling here; we'll recompute it
8371 later if we need it. */
8373 {
8376 }
8379 {
8380 tree old_decl;
8381 tree new_friend_template_info;
8382 tree new_friend_result_template_info;
8383 tree ns;
8386 /* We must save some information from NEW_FRIEND before calling
8387 duplicate decls since that function will free NEW_FRIEND if
8388 possible. */
8390 new_friend_is_defn =
8395 {
8396 /* This declaration is a `primary' template. */
8399 new_friend_result_template_info
8401 }
8402 else
8405 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8409 /* Inside pushdecl_namespace_level, we will push into the
8410 current namespace. However, the friend function should go
8411 into the namespace of the template. */
8421 {
8422 /* This new friend declaration matched an existing
8423 declaration. For example, given:
8425 template <class T> void f(T);
8426 template <class U> class C {
8427 template <class T> friend void f(T) {}
8428 };
8430 the friend declaration actually provides the definition
8431 of `f', once C has been instantiated for some type. So,
8432 old_decl will be the out-of-class template declaration,
8433 while new_friend is the in-class definition.
8435 But, if `f' was called before this point, the
8436 instantiation of `f' will have DECL_TI_ARGS corresponding
8437 to `T' but not to `U', references to which might appear
8438 in the definition of `f'. Previously, the most general
8439 template for an instantiation of `f' was the out-of-class
8440 version; now it is the in-class version. Therefore, we
8441 run through all specialization of `f', adding to their
8442 DECL_TI_ARGS appropriately. In particular, they need a
8443 new set of outer arguments, corresponding to the
8444 arguments for this class instantiation.
8446 The same situation can arise with something like this:
8448 friend void f(int);
8449 template <class T> class C {
8450 friend void f(T) {}
8451 };
8453 when `C<int>' is instantiated. Now, `f(int)' is defined
8454 in the class. */
8457 /* On the other hand, if the in-class declaration does
8458 *not* provide a definition, then we don't want to alter
8459 existing definitions. We can just leave everything
8460 alone. */
8461 ;
8462 else
8463 {
8467 /* Overwrite whatever template info was there before, if
8468 any, with the new template information pertaining to
8469 the declaration. */
8473 {
8474 /* We should have called reregister_specialization in
8475 duplicate_decls. */
8480 /* Instantiate it if the global has already been used. */
8484 }
8485 else
8486 {
8487 tree t;
8489 /* Indicate that the old function template is a partial
8490 instantiation. */
8498 /* Reassign any specializations already in the hash table
8499 to the new more general template, and add the
8500 additional template args. */
8504 {
8506 spec_entry elt;
8518 register_specialization
8521 }
8523 }
8524 }
8526 /* The information from NEW_FRIEND has been merged into OLD_DECL
8527 by duplicate_decls. */
8529 }
8530 }
8531 else
8532 {
8536 /* In the code
8537 template <class T> class C {
8538 template <class U> friend void C1<U>::f (); // case 1
8539 friend void C2<T>::f (); // case 2
8540 };
8541 we only need to make sure CONTEXT is a complete type for
8542 case 2. To distinguish between the two cases, we note that
8543 CONTEXT of case 1 remains dependent type after tsubst while
8544 this isn't true for case 2. */
8554 {
8556 /* do_friend adds the TEMPLATE_DECL for any member friend
8557 template even if it isn't a member template, i.e.
8558 template <class T> friend A<T>::f();
8559 Look through it in that case. */
8563 /* Check to see that the declaration is really present, and,
8564 possibly obtain an improved declaration. */
8569 }
8570 }
8573 }
8575 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8576 template arguments, as for tsubst.
8578 Returns an appropriate tsubst'd friend type or error_mark_node on
8579 failure. */
8581 static tree
8583 {
8584 tree friend_type;
8585 tree tmpl;
8586 tree context;
8589 {
8592 }
8597 {
8600 else
8602 }
8604 /* Look for a class template declaration. We look for hidden names
8605 because two friend declarations of the same template are the
8606 same. For example, in:
8608 struct A {
8609 template <typename> friend class F;
8610 };
8611 template <typename> struct B {
8612 template <typename> friend class F;
8613 };
8615 both F templates are the same. */
8619 /* But, if we don't find one, it might be because we're in a
8620 situation like this:
8622 template <class T>
8623 struct S {
8624 template <class U>
8625 friend struct S;
8626 };
8628 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8629 for `S<int>', not the TEMPLATE_DECL. */
8631 {
8634 }
8637 {
8638 /* The friend template has already been declared. Just
8639 check to see that the declarations match, and install any new
8640 default parameters. We must tsubst the default parameters,
8641 of course. We only need the innermost template parameters
8642 because that is all that redeclare_class_template will look
8643 at. */
8646 {
8647 tree parms;
8648 location_t saved_input_location;
8657 }
8660 }
8661 else
8662 {
8663 /* The friend template has not already been declared. In this
8664 case, the instantiation of the template class will cause the
8665 injection of this template into the global scope. */
8670 /* The new TMPL is not an instantiation of anything, so we
8671 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8672 the new type because that is supposed to be the corresponding
8673 template decl, i.e., TMPL. */
8680 /* Inject this template into the global scope. */
8682 }
8685 {
8688 else
8690 }
8693 }
8695 /* Returns zero if TYPE cannot be completed later due to circularity.
8696 Otherwise returns one. */
8698 static int
8700 {
8710 else
8712 }
8716 /* Apply any attributes which had to be deferred until instantiation
8717 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8718 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8720 static void
8723 {
8725 tree t;
8730 {
8734 }
8737 {
8741 }
8742 else
8746 {
8751 {
8754 {
8761 {
8768 clauses
8772 else
8774 }
8775 /* If the first attribute argument is an identifier, don't
8776 pass it through tsubst. Attributes like mode, format,
8777 cleanup and several target specific attributes expect it
8778 unmodified. */
8781 {
8782 tree chain
8784 in_decl,
8789 chain);
8790 }
8791 else
8797 }
8798 else
8800 }
8803 }
8804 }
8806 /* Perform (or defer) access check for typedefs that were referenced
8807 from within the template TMPL code.
8808 This is a subroutine of instantiate_decl and instantiate_class_template.
8809 TMPL is the template to consider and TARGS is the list of arguments of
8810 that template. */
8812 static void
8814 {
8815 location_t saved_location;
8826 {
8838 /* Make access check error messages point to the location
8839 of the use of the typedef. */
8843 tf_warning_or_error);
8844 }
8846 }
8848 static tree
8850 {
8852 tree typedecl;
8853 tree pbinfo;
8854 tree base_list;
8856 tree fn_context;
8865 /* Figure out which template is being instantiated. */
8869 /* Determine what specialization of the original template to
8870 instantiate. */
8873 {
8876 }
8878 {
8879 /* This TYPE is actually an instantiation of a partial
8880 specialization. We replace the innermost set of ARGS with
8881 the arguments appropriate for substitution. For example,
8882 given:
8884 template <class T> struct S {};
8885 template <class T> struct S<T*> {};
8887 and supposing that we are instantiating S<int*>, ARGS will
8888 presently be {int*} -- but we need {int}. */
8891 }
8892 else
8893 {
8896 }
8898 /* If the template we're instantiating is incomplete, then clearly
8899 there's nothing we can do. */
8903 /* If we've recursively instantiated too many templates, stop. */
8907 /* Now we're really doing the instantiation. Mark the type as in
8908 the process of being defined. */
8911 /* We may be in the middle of deferred access check. Disable
8912 it now. */
8918 /* Use #pragma pack from the template context. */
8924 /* Set the input location to the most specialized template definition.
8925 This is needed if tsubsting causes an error. */
8937 {
8940 /* Adjust visibility for template arguments. */
8942 }
8948 /* We should never instantiate a nested class before its enclosing
8949 class; we need to look up the nested class by name before we can
8950 instantiate it, and that lookup should instantiate the enclosing
8951 class. */
8957 {
8958 tree pbase_binfo;
8959 tree pushed_scope;
8962 /* We must enter the scope containing the type, as that is where
8963 the accessibility of types named in dependent bases are
8964 looked up from. */
8967 /* Substitute into each of the bases to determine the actual
8968 basetypes. */
8970 {
8971 tree base;
8977 {
8978 expanded_bases =
8985 }
8988 {
8990 /* Extract the already-expanded base class. */
8992 else
8993 /* Substitute to figure out the base class. */
8995 NULL_TREE);
9003 }
9004 }
9006 /* The list is now in reverse order; correct that. */
9011 }
9012 /* Now call xref_basetypes to set up all the base-class
9013 information. */
9021 /* Now that our base classes are set up, enter the scope of the
9022 class, so that name lookups into base classes, etc. will work
9023 correctly. This is precisely analogous to what we do in
9024 begin_class_definition when defining an ordinary non-template
9025 class, except we also need to push the enclosing classes. */
9028 /* Now members are processed in the order of declaration. */
9031 {
9035 {
9037 {
9038 /* Build new CLASSTYPE_NESTED_UTDS. */
9040 tree newtag;
9046 /* If the member is a class template, then -- even after
9047 substitution -- there may be dependent types in the
9048 template argument list for the class. We increment
9049 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9050 that function will assume that no types are dependent
9051 when outside of a template. */
9061 {
9065 /* Unfortunately, lookup_template_class sets
9066 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9067 instantiation (i.e., for the type of a member
9068 template class nested within a template class.)
9069 This behavior is required for
9070 maybe_process_partial_specialization to work
9071 correctly, but is not accurate in this case;
9072 the TAG is not an instantiation of anything.
9073 (The corresponding TEMPLATE_DECL is an
9074 instantiation, but the TYPE is not.) */
9077 /* Now, we call pushtag to put this NEWTAG into the scope of
9078 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9079 pushtag calling push_template_decl. We don't have to do
9080 this for enums because it will already have been done in
9081 tsubst_enum. */
9085 }
9086 }
9088 {
9089 /* Build new TYPE_METHODS. */
9090 tree r;
9099 /* Instantiate members marked with attribute used. */
9105 }
9106 else
9107 {
9108 /* Build new TYPE_FIELDS. */
9110 {
9111 tree condition;
9114 condition =
9124 }
9126 {
9127 tree r;
9131 /* The file and line for this declaration, to
9132 assist in error message reporting. Since we
9133 called push_tinst_level above, we don't need to
9134 restore these. */
9144 {
9145 /* A capture pack became multiple fields. */
9148 }
9151 {
9155 {
9156 /* In [temp.inst]:
9158 [t]he initialization (and any associated
9159 side-effects) of a static data member does
9160 not occur unless the static data member is
9161 itself used in a way that requires the
9162 definition of the static data member to
9163 exist.
9165 Therefore, we do not substitute into the
9166 initialized for the static data member here. */
9167 finish_static_data_member_decl
9173 /* Instantiate members marked with attribute used. */
9176 }
9178 {
9179 /* Determine whether R has a valid type and can be
9180 completed later. If R is invalid, then its type
9181 is replaced by error_mark_node. */
9187 {
9190 }
9191 }
9193 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9194 such a thing will already have been added to the field
9195 list by tsubst_enum in finish_member_declaration in the
9196 CLASSTYPE_NESTED_UTDS case above. */
9200 {
9203 }
9204 }
9205 }
9206 }
9207 }
9208 else
9209 {
9212 {
9213 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9219 {
9220 /* template <class T> friend class C; */
9223 }
9225 {
9226 /* template <class T> friend class C::D; */
9232 }
9235 {
9236 /* This could be either
9238 friend class T::C;
9240 when dependent_type_p is false or
9242 template <class U> friend class T::C;
9244 otherwise. */
9247 /* Bump processing_template_decl for correct
9248 dependent_type_p calculation. */
9253 }
9256 {
9257 /* friend class C;
9259 where C hasn't been declared yet. Let's lookup name
9260 from namespace scope directly, bypassing any name that
9261 come from dependent base class. */
9264 /* The call to xref_tag_from_type does injection for friend
9265 classes. */
9267 friend_type =
9271 }
9273 /* friend class C<T>; */
9276 /* Otherwise it's
9278 friend class C;
9280 where C is already declared or
9282 friend class C<int>;
9284 We don't have to do anything in these cases. */
9287 /* Trick make_friend_class into realizing that the friend
9288 we're adding is a template, not an ordinary class. It's
9289 important that we use make_friend_class since it will
9290 perform some error-checking and output cross-reference
9291 information. */
9299 }
9300 else
9301 {
9302 /* Build new DECL_FRIENDLIST. */
9303 tree r;
9305 /* The file and line for this declaration, to
9306 assist in error message reporting. Since we
9307 called push_tinst_level above, we don't need to
9308 restore these. */
9312 {
9315 }
9320 {
9323 }
9324 }
9325 }
9326 }
9329 {
9332 {
9337 /* We need to instantiate the capture list from the template
9338 after we've instantiated the closure members, but before we
9339 consider adding the conversion op. Also keep any captures
9340 that may have been added during instantiation of the op(). */
9342 tree tmpl_cap
9351 }
9352 else
9354 }
9356 /* Set the file and line number information to whatever is given for
9357 the class itself. This puts error messages involving generated
9358 implicit functions at a predictable point, and the same point
9359 that would be used for non-template classes. */
9366 /* We don't instantiate default arguments for member functions. 14.7.1:
9368 The implicit instantiation of a class template specialization causes
9369 the implicit instantiation of the declarations, but not of the
9370 definitions or default arguments, of the class member functions,
9371 member classes, static data members and member templates.... */
9373 /* Some typedefs referenced from within the template code need to be access
9374 checked at template instantiation time, i.e now. These types were
9375 added to the template at parsing time. Let's get those and perform
9376 the access checks then. */
9386 /* The vtable for a template class can be emitted in any translation
9387 unit in which the class is instantiated. When there is no key
9388 method, however, finish_struct_1 will already have added TYPE to
9389 the keyed_classes list. */
9394 }
9396 /* Wrapper for instantiate_class_template_1. */
9398 tree
9400 {
9401 tree ret;
9406 }
9408 static tree
9410 {
9411 tree r;
9417 else
9418 {
9425 }
9427 }
9429 /* Given a function parameter pack TMPL_PARM and some function parameters
9430 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9431 and set *SPEC_P to point at the next point in the list. */
9433 static tree
9435 {
9436 /* Collect all of the extra "packed" parameters into an
9437 argument pack. */
9438 tree parmvec;
9439 tree parmtypevec;
9450 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9455 {
9458 }
9460 /* Build the argument packs. */
9467 }
9469 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9470 NONTYPE_ARGUMENT_PACK. */
9472 static tree
9474 {
9476 }
9478 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9479 pack expansion. */
9481 static bool
9483 {
9488 }
9491 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9493 static tree
9495 {
9502 }
9504 /* This is a subroutine of tsubst_pack_expansion.
9506 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9507 mechanism to store the (non complete list of) arguments of the
9508 substitution and return a non substituted pack expansion, in order
9509 to wait for when we have enough arguments to really perform the
9510 substitution. */
9512 static bool
9516 {
9517 /* If one pack has an expansion and another pack has a normal
9518 argument or if one pack has an empty argument and an another
9519 one hasn't then tsubst_pack_expansion cannot perform the
9520 substitution and need to fall back on the
9521 PACK_EXPANSION_EXTRA mechanism. */
9529 {
9532 parm_pack;
9534 {
9539 else
9541 }
9545 }
9547 }
9549 /* [temp.variadic]/6 says that:
9551 The instantiation of a pack expansion [...]
9552 produces a list E1,E2, ..., En, where N is the number of elements
9553 in the pack expansion parameters.
9555 This subroutine of tsubst_pack_expansion produces one of these Ei.
9557 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9558 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9559 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9560 INDEX is the index 'i' of the element Ei to produce. ARGS,
9561 COMPLAIN, and IN_DECL are the same parameters as for the
9562 tsubst_pack_expansion function.
9564 The function returns the resulting Ei upon successful completion,
9565 or error_mark_node.
9567 Note that this function possibly modifies the ARGS parameter, so
9568 it's the responsibility of the caller to restore it. */
9570 static tree
9572 tree parm_packs,
9574 tree args /* This parm gets
9576 tsubst_flags_t complain,
9577 tree in_decl)
9578 {
9579 tree t;
9582 /* For each parameter pack, change the substitution of the parameter
9583 pack to the ith argument in its argument pack, then expand the
9584 pattern. */
9586 {
9591 ith_elem_is_expansion |=
9594 /* Select the Ith argument from the pack. */
9597 {
9599 {
9603 }
9604 else
9606 }
9607 else
9608 {
9613 {
9615 /* Update the corresponding argument. */
9617 }
9618 else
9619 /* Re-use the ARGUMENT_PACK_SELECT. */
9621 }
9623 }
9625 /* Substitute into the PATTERN with the (possibly altered)
9626 arguments. */
9628 /* Expanding a fixed parameter pack from
9629 coerce_template_parameter_pack. */
9634 else
9637 /* If the Ith argument pack element is a pack expansion, then
9638 the Ith element resulting from the substituting is going to
9639 be a pack expansion as well. */
9644 }
9646 /* Substitute ARGS into T, which is an pack expansion
9647 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9648 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9649 (if only a partial substitution could be performed) or
9650 ERROR_MARK_NODE if there was an error. */
9651 tree
9653 tree in_decl)
9654 {
9655 tree pattern;
9659 tree result;
9667 /* Add in any args remembered from an earlier partial instantiation. */
9672 /* Determine the argument packs that will instantiate the parameter
9673 packs used in the expansion expression. While we're at it,
9674 compute the number of arguments to be expanded and make sure it
9675 is consistent. */
9678 {
9685 {
9689 else
9692 }
9694 {
9697 else
9698 {
9699 /* We can't rely on local_specializations for a parameter
9700 name used later in a function declaration (such as in a
9701 late-specified return type). Even if it exists, it might
9702 have the wrong value for a recursive call. Just make a
9703 dummy decl, since it's only used for its type. */
9706 /* Partial instantiation of the parm_pack, we can't build
9707 up an argument pack yet. */
9709 else
9712 }
9713 }
9716 else
9717 {
9723 }
9730 /* This can only happen if we forget to expand an argument
9731 pack somewhere else. Just return an error, silently. */
9732 {
9736 }
9739 {
9743 /* Don't bother trying to do a partial substitution with
9744 incomplete packs; we'll try again after deduction. */
9751 {
9757 pattern);
9758 else
9761 pattern);
9763 }
9765 /* Keep track of the parameter packs and their corresponding
9766 argument packs. */
9769 }
9770 else
9771 {
9772 /* We can't substitute for this parameter pack. We use a flag as
9773 well as the missing_level counter because function parameter
9774 packs don't have a level. */
9776 }
9777 }
9779 /* We cannot expand this expansion expression, because we don't have
9780 all of the argument packs we need. */
9782 {
9783 /* We got some full packs, but we can't substitute them in until we
9784 have values for all the packs. So remember these until then. */
9789 }
9791 {
9792 /* There were no real arguments, we're just replacing a parameter
9793 pack with another version of itself. Substitute into the
9794 pattern and return a PACK_EXPANSION_*. The caller will need to
9795 deal with that. */
9799 else
9803 }
9808 {
9809 /* We're in a late-specified return type, so create our own local
9810 specializations map; the current map is either NULL or (in the
9811 case of recursive unification) might have bindings that we don't
9812 want to use or alter. */
9815 }
9817 /* For each argument in each argument pack, substitute into the
9818 pattern. */
9821 {
9823 i,
9825 in_decl);
9828 {
9831 }
9832 }
9834 /* Update ARGS to restore the substitution from parameter packs to
9835 their argument packs. */
9837 {
9843 else
9844 {
9852 /* Update the corresponding argument. */
9856 else
9858 }
9859 }
9862 {
9865 }
9868 }
9870 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
9871 TMPL. We do this using DECL_PARM_INDEX, which should work even with
9872 parameter packs; all parms generated from a function parameter pack will
9873 have the same DECL_PARM_INDEX. */
9875 tree
9877 {
9879 tree patparm;
9882 {
9888 }
9889 else
9890 {
9895 }
9898 }
9900 /* Substitute ARGS into the vector or list of template arguments T. */
9902 static tree
9904 {
9916 {
9918 tree new_arg;
9923 {
9924 /* Substitute into an expansion expression. */
9928 /* Add to the expanded length adjustment the number of
9929 expanded arguments. We subtract one from this
9930 measurement, because the argument pack expression
9931 itself is already counted as 1 in
9932 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
9933 the argument pack is empty. */
9935 }
9937 {
9938 /* Substitute into each of the arguments. */
9944 new_arg,
9958 }
9959 }
9960 else
9969 }
9974 /* Make space for the expanded arguments coming from template
9975 argument packs. */
9977 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
9978 arguments for a member template.
9979 In that case each TREE_VEC in ORIG_T represents a level of template
9980 arguments, and ORIG_T won't carry any non defaulted argument count.
9981 It will rather be the nested TREE_VECs that will carry one.
9982 In other words, ORIG_T carries a non defaulted argument count only
9983 if it doesn't contain any nested TREE_VEC. */
9985 {
9989 }
9991 {
9995 {
9998 /* Now expand the template argument pack "in place". */
10001 }
10002 else
10003 {
10005 out++;
10006 }
10007 }
10010 }
10012 /* Return the result of substituting ARGS into the template parameters
10013 given by PARMS. If there are m levels of ARGS and m + n levels of
10014 PARMS, then the result will contain n levels of PARMS. For
10015 example, if PARMS is `template <class T> template <class U>
10016 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10017 result will be `template <int*, double, class V>'. */
10019 static tree
10021 {
10025 /* When substituting into a template, we must set
10026 PROCESSING_TEMPLATE_DECL as the template parameters may be
10027 dependent if they are based on one-another, and the dependency
10028 predicates are short-circuit outside of templates. */
10035 {
10036 tree new_vec =
10041 {
10042 tree tuple;
10054 }
10060 }
10065 }
10067 /* Return the result of substituting ARGS into one template parameter
10068 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10069 parameter and which TREE_PURPOSE is the default argument of the
10070 template parameter. */
10072 static tree
10074 {
10095 }
10097 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10098 type T. If T is not an aggregate or enumeration type, it is
10099 handled as if by tsubst. IN_DECL is as for tsubst. If
10100 ENTERING_SCOPE is nonzero, T is the context for a template which
10101 we are presently tsubst'ing. Return the substituted value. */
10103 static tree
10105 tree args,
10106 tsubst_flags_t complain,
10107 tree in_decl,
10109 {
10114 {
10119 /* Else fall through. */
10123 {
10124 tree argvec;
10125 tree context;
10126 tree r;
10130 /* In "sizeof(X<I>)" we need to evaluate "I". */
10136 /* First, determine the context for the type we are looking
10137 up. */
10140 {
10143 /* If context is a nested class inside a class template,
10144 it may still need to be instantiated (c++/33959). */
10146 }
10148 /* Then, figure out what arguments are appropriate for the
10149 type we are trying to find. For example, given:
10151 template <class T> struct S;
10152 template <class T, class U> void f(T, U) { S<U> su; }
10154 and supposing that we are instantiating f<int, double>,
10155 then our ARGS will be {int, double}, but, when looking up
10156 S we only want {double}. */
10161 else
10162 {
10166 }
10172 }
10173 else
10174 /* This is not a template type, so there's nothing to do. */
10179 }
10180 }
10182 /* Substitute into the default argument ARG (a default argument for
10183 FN), which has the indicated TYPE. */
10185 tree
10187 {
10192 /* This can happen in invalid code. */
10196 /* This default argument came from a template. Instantiate the
10197 default argument here, not in tsubst. In the case of
10198 something like:
10200 template <class T>
10201 struct S {
10202 static T t();
10203 void f(T = t());
10204 };
10206 we must be careful to do name lookup in the scope of S<T>,
10207 rather than in the current class. */
10209 /* The "this" pointer is not valid in a default argument. */
10211 {
10216 }
10219 /* The default argument expression may cause implicitly defined
10220 member functions to be synthesized, which will result in garbage
10221 collection. We must treat this situation as if we were within
10222 the body of function so as to avoid collecting live data on the
10223 stack. */
10231 /* Restore the "this" pointer. */
10233 {
10236 }
10243 /* Make sure the default argument is reasonable. */
10249 }
10251 /* Substitute into all the default arguments for FN. */
10253 static void
10255 {
10256 tree arg;
10257 tree tmpl_args;
10261 /* If this function is not yet instantiated, we certainly don't need
10262 its default arguments. */
10265 /* Don't do this again for clones. */
10270 arg;
10276 complain);
10277 }
10279 /* Substitute the ARGS into the T, which is a _DECL. Return the
10280 result of the substitution. Issue error and warning messages under
10281 control of COMPLAIN. */
10283 static tree
10285 {
10286 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10287 location_t saved_loc;
10292 /* Set the filename and linenumber to improve error-reporting. */
10297 {
10299 {
10300 /* We can get here when processing a member function template,
10301 member class template, or template template parameter. */
10303 tree spec;
10304 tree tmpl_args;
10305 tree full_args;
10308 {
10309 /* Template template parameter is treated here. */
10313 /* If we get a real template back, return it. This can happen in
10314 the context of most_specialized_class. */
10326 complain);
10329 }
10331 /* We might already have an instance of this template.
10332 The ARGS are for the surrounding class type, so the
10333 full args contain the tsubst'd args for the context,
10334 plus the innermost args from the template decl. */
10338 /* Because this is a template, the arguments will still be
10339 dependent, even after substitution. If
10340 PROCESSING_TEMPLATE_DECL is not set, the dependency
10341 predicates will short-circuit. */
10349 /* If this is a default template template argument,
10350 tsubst might not have changed anything. */
10357 {
10360 }
10362 /* Make a new template decl. It will be similar to the
10363 original, but will record the current template arguments.
10364 We also create a new function declaration, which is just
10365 like the old one, but points to this new template, rather
10366 than the old one. */
10375 {
10376 tree new_type;
10384 /* For a partial specialization, we need to keep pointing to
10385 the primary template. */
10391 }
10392 else
10393 {
10394 tree new_decl;
10406 }
10412 /* The template parameters for this new template are all the
10413 template parameters for the old template, except the
10414 outermost level of parameters. */
10417 complain);
10423 /* Record this non-type partial instantiation. */
10427 }
10431 {
10432 tree ctx;
10435 tree gen_tmpl;
10436 tree type;
10441 /* Nobody should be tsubst'ing into non-template functions. */
10445 {
10446 tree spec;
10449 /* If T is not dependent, just return it. We have to
10450 increment PROCESSING_TEMPLATE_DECL because
10451 value_dependent_expression_p assumes that nothing is
10452 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10459 /* Calculate the most general template of which R is a
10460 specialization, and the complete set of arguments used to
10461 specialize R. */
10464 (DECL_TEMPLATE_RESULT
10470 /* Check to see if we already have this specialization. */
10475 {
10478 }
10480 /* We can see more levels of arguments than parameters if
10481 there was a specialization of a member template, like
10482 this:
10484 template <class T> struct S { template <class U> void f(); }
10485 template <> template <class U> void S<int>::f(U);
10487 Here, we'll be substituting into the specialization,
10488 because that's where we can find the code we actually
10489 want to generate, but we'll have enough arguments for
10490 the most general template.
10492 We also deal with the peculiar case:
10494 template <class T> struct S {
10495 template <class U> friend void f();
10496 };
10497 template <class U> void f() {}
10498 template S<int>;
10499 template void f<double>();
10501 Here, the ARGS for the instantiation of will be {int,
10502 double}. But, we only need as many ARGS as there are
10503 levels of template parameters in CODE_PATTERN. We are
10504 careful not to get fooled into reducing the ARGS in
10505 situations like:
10507 template <class T> struct S { template <class U> void f(U); }
10508 template <class T> template <> void S<T>::f(int) {}
10510 which we can spot because the pattern will be a
10511 specialization in this case. */
10513 parms_depth =
10518 }
10519 else
10520 {
10521 /* This special case arises when we have something like this:
10523 template <class T> struct S {
10524 friend void f<int>(int, double);
10525 };
10527 Here, the DECL_TI_TEMPLATE for the friend declaration
10528 will be an IDENTIFIER_NODE. We are being called from
10529 tsubst_friend_function, and we want only to create a
10530 new decl (R) with appropriate types so that we can call
10531 determine_specialization. */
10533 }
10536 {
10539 else
10543 }
10544 else
10545 {
10548 }
10553 /* If we hit excessive deduction depth, the type is bogus even if
10554 it isn't error_mark_node, so don't build a decl. */
10558 /* We do NOT check for matching decls pushed separately at this
10559 point, as they may not represent instantiations of this
10560 template, and in any case are considered separate under the
10561 discrete model. */
10565 /* Clear out the mangled name and RTL for the instantiation. */
10568 /* Leave DECL_INITIAL set on deleted instantiations. */
10573 /* OpenMP UDRs have the only argument a reference to the declared
10574 type. We want to diagnose if the declared type is a reference,
10575 which is invalid, but as references to references are usually
10576 quietly merged, diagnose it here. */
10578 {
10579 tree argtype
10584 "reference type %qT in "
10588 argtype);
10589 }
10592 /* Type-conversion operator. Reconstruct the name, in
10593 case it's the name of one of the template's parameters. */
10603 /* If this is an instantiation of a function with internal
10604 linkage, we already know what object file linkage will be
10605 assigned to the instantiation. */
10614 /* We'll re-clone as appropriate in instantiate_template. */
10617 /* If we aren't complaining now, return on error before we register
10618 the specialization so that we'll complain eventually. */
10624 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10625 this in the special friend case mentioned above where
10626 GEN_TMPL is NULL. */
10628 {
10633 tree new_r
10636 /* We instantiated this while substituting into
10637 the type earlier (template/friend54.C). */
10640 /* We're not supposed to instantiate default arguments
10641 until they are called, for a template. But, for a
10642 declaration like:
10644 template <class T> void f ()
10645 { extern void g(int i = T()); }
10647 we should do the substitution when the template is
10648 instantiated. We handle the member function case in
10649 instantiate_class_template since the default arguments
10650 might refer to other members of the class. */
10655 }
10656 else
10659 /* Copy the list of befriending classes. */
10663 {
10667 in_decl);
10668 }
10671 {
10677 /* If this is an instantiation of a member template, clone it.
10678 If it isn't, that'll be handled by
10679 clone_constructors_and_destructors. */
10682 }
10693 /* Possibly limit visibility based on template args. */
10696 {
10700 }
10708 }
10712 {
10720 {
10721 /* If there is a local specialization that isn't a
10722 parameter pack, it means that we're doing a "simple"
10723 substitution from inside tsubst_pack_expansion. Just
10724 return the local specialization (which will be a single
10725 parm). */
10732 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10733 the parameters in this function parameter pack. */
10737 {
10740 /* Zero-length parameter packs are boring. Just substitute
10741 into the chain. */
10745 }
10746 else
10747 {
10748 /* All we did was update the type. Make a note of that. */
10751 }
10752 }
10754 /* Loop through all of the parameters we'll build. When T is
10755 a function parameter pack, LEN is the number of expanded
10756 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10759 {
10766 /* We're on the Ith parameter of the function parameter
10767 pack. */
10768 {
10769 /* Get the Ith type. */
10772 /* Rename the parameter to include the index. */
10775 }
10777 /* We're dealing with a normal parameter. */
10785 {
10788 else
10791 }
10801 /* Keep track of the first new parameter we
10802 generate. That's what will be returned to the
10803 caller. */
10807 /* Build a proper chain of parameters when substituting
10808 into a function parameter pack. */
10811 }
10813 /* If cp_unevaluated_operand is set, we're just looking for a
10814 single dummy parameter, so don't keep going. */
10819 /* FIRST_R contains the start of the chain we've built. */
10821 }
10825 {
10832 {
10833 /* This field is a lambda capture pack. Return a TREE_VEC of
10834 the expanded fields to instantiate_class_template_1 and
10835 store them in the specializations hash table as a
10836 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10840 {
10843 }
10844 else
10845 {
10846 /* All we did was update the type. Make a note of that. */
10849 }
10850 }
10853 {
10856 {
10860 }
10870 /* For bit-fields, DECL_INITIAL gives the number of bits. For
10871 non-bit-fields DECL_INITIAL is a non-static data member
10872 initializer, which gets deferred instantiation. */
10878 {
10879 /* Set up DECL_TEMPLATE_INFO so that we can get at the
10880 NSDMI in perform_member_init. Still set DECL_INITIAL
10881 so that we know there is one. */
10886 }
10887 /* We don't have to set DECL_CONTEXT here; it is set by
10888 finish_member_declaration. */
10896 }
10899 {
10907 }
10908 }
10912 /* We reach here only for member using decls. We also need to check
10913 uses_template_parms because DECL_DEPENDENT_P is not set for a
10914 using-declaration that designates a member of the current
10915 instantiation (c++/53549). */
10918 {
10925 else
10926 {
10929 }
10930 }
10931 else
10932 {
10935 }
10940 {
10943 tree spec;
10945 tree ctx;
10954 {
10955 /* If this is the canonical decl, we don't have to
10956 mess with instantiations, and often we can't (for
10957 typename, template type parms and such). Note that
10958 TYPE_NAME is not correct for the above test if
10959 we've copied the type for a typedef. */
10965 }
10967 /* Check to see if we already have the specialization we
10968 need. */
10971 {
10972 /* T is a static data member or namespace-scope entity.
10973 We have to substitute into namespace-scope variables
10974 (even though such entities are never templates) because
10975 of cases like:
10977 template <class T> void f() { extern T t; }
10979 where the entity referenced is not known until
10980 instantiation time. */
10984 {
10986 complain,
10988 /* If CTX is unchanged, then T is in fact the
10989 specialization we want. That situation occurs when
10990 referencing a static data member within in its own
10991 class. We can use pointer equality, rather than
10992 same_type_p, because DECL_CONTEXT is always
10993 canonical... */
10996 /* ... unless T is a member template; in which
10997 case our caller can be willing to create a
10998 specialization of that template represented
10999 by T. */
11003 }
11006 {
11014 }
11015 }
11016 else
11017 {
11018 /* A local variable. */
11020 /* Subsequent calls to pushdecl will fill this in. */
11023 }
11024 /* If we already have the specialization we need, there is
11025 nothing more to do. */
11027 {
11030 }
11032 /* Create a new node for the specialization we need. */
11035 {
11038 else
11045 }
11047 {
11048 /* Even if the original location is out of scope, the
11049 newly substituted one is not. */
11056 {
11057 /* It may seem that this case cannot occur, since:
11059 typedef void f();
11060 void g() { f x; }
11062 declares a function, not a variable. However:
11064 typedef void f();
11065 template <typename T> void g() { T t; }
11066 template void g<f>();
11068 is an attempt to declare a variable with function
11069 type. */
11071 /* R is not yet sufficiently initialized, so we
11072 just use its name. */
11075 }
11077 /* Wait until cp_finish_decl to set this again, to handle
11078 circular dependency (template/instantiate6.C). */
11083 {
11088 {
11091 }
11093 }
11094 }
11100 /* Clear out the mangled name and RTL for the instantiation. */
11104 /* The initializer must not be expanded until it is required;
11105 see [temp.inst]. */
11111 {
11112 /* Possibly limit visibility based on template args. */
11115 {
11119 }
11121 }
11124 {
11125 /* A static data member declaration is always marked
11126 external when it is declared in-class, even if an
11127 initializer is present. We mimic the non-template
11128 processing here. */
11134 }
11144 /* Preserve a typedef that names a type. */
11146 {
11149 }
11152 }
11157 }
11158 #undef RETURN
11160 out:
11161 /* Restore the file and line information. */
11165 }
11167 /* Substitute into the ARG_TYPES of a function type.
11168 If END is a TREE_CHAIN, leave it and any following types
11169 un-substituted. */
11171 static tree
11173 tree args,
11174 tree end,
11175 tsubst_flags_t complain,
11176 tree in_decl)
11177 {
11178 tree remaining_arg_types;
11182 tree default_arg;
11193 {
11194 /* For a pack expansion, perform substitution on the
11195 entire expression. Later on, we'll handle the arguments
11196 one-by-one. */
11201 /* So that we'll spin through the parameters, one by one. */
11203 else
11204 {
11205 /* We only partially substituted into the parameter
11206 pack. Our type is TYPE_PACK_EXPANSION. */
11209 }
11210 }
11223 {
11225 {
11229 }
11231 }
11232 /* DR 657. */
11236 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11237 top-level qualifiers as required. */
11240 /* We do not substitute into default arguments here. The standard
11241 mandates that they be instantiated only when needed, which is
11242 done in build_over_call. */
11246 {
11247 /* We've instantiated a template before its default arguments
11248 have been parsed. This can happen for a nested template
11249 class, and is not an error unless we require the default
11250 argument in a call of this function. */
11251 remaining_arg_types =
11254 }
11255 else
11256 remaining_arg_types =
11258 }
11261 }
11263 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11264 *not* handle the exception-specification for FNTYPE, because the
11265 initial substitution of explicitly provided template parameters
11266 during argument deduction forbids substitution into the
11267 exception-specification:
11269 [temp.deduct]
11271 All references in the function type of the function template to the
11272 corresponding template parameters are replaced by the specified tem-
11273 plate argument values. If a substitution in a template parameter or
11274 in the function type of the function template results in an invalid
11275 type, type deduction fails. [Note: The equivalent substitution in
11276 exception specifications is done only when the function is instanti-
11277 ated, at which point a program is ill-formed if the substitution
11278 results in an invalid type.] */
11280 static tree
11282 tree args,
11283 tsubst_flags_t complain,
11284 tree in_decl)
11285 {
11286 tree return_type;
11287 tree arg_types;
11288 tree fntype;
11290 /* The TYPE_CONTEXT is not used for function/method types. */
11293 /* Substitute the return type. */
11297 /* DR 486 clarifies that creation of a function type with an
11298 invalid return type is a deduction failure. */
11301 {
11303 {
11306 else
11308 }
11310 }
11311 /* And DR 657. */
11315 /* Substitute the argument types. */
11321 /* Construct a new type node and return it. */
11323 {
11328 }
11329 else
11330 {
11332 /* Don't pick up extra function qualifiers from the basetype. */
11335 {
11336 /* [temp.deduct]
11338 Type deduction may fail for any of the following
11339 reasons:
11341 -- Attempting to create "pointer to member of T" when T
11342 is not a class type. */
11345 r);
11347 }
11352 }
11356 }
11358 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11359 ARGS into that specification, and return the substituted
11360 specification. If there is no specification, return NULL_TREE. */
11362 static tree
11364 tree args,
11365 tsubst_flags_t complain,
11366 tree in_decl,
11368 {
11369 tree specs;
11370 tree new_specs;
11375 {
11376 /* A noexcept-specifier. */
11381 {
11382 /* Defer instantiation of noexcept-specifiers to avoid
11383 excessive instantiations (c++/49107). */
11386 {
11387 /* We already partially instantiated this member template,
11388 so combine the new args with the old. */
11393 }
11394 else
11395 {
11398 }
11399 }
11400 else
11401 new_specs = tsubst_copy_and_build
11405 }
11407 {
11410 else
11412 {
11413 tree spec;
11418 {
11419 /* Expand the pack expansion type. */
11422 in_decl);
11428 else
11429 {
11430 /* We're substituting into a member template, so
11431 we got a TYPE_PACK_EXPANSION back. Add that
11432 expansion and move on. */
11436 expanded_specs,
11437 complain);
11440 }
11441 }
11444 {
11447 else
11452 complain);
11453 }
11456 }
11457 }
11459 }
11461 /* Take the tree structure T and replace template parameters used
11462 therein with the argument vector ARGS. IN_DECL is an associated
11463 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11464 Issue error and warning messages under control of COMPLAIN. Note
11465 that we must be relatively non-tolerant of extensions here, in
11466 order to preserve conformance; if we allow substitutions that
11467 should not be allowed, we may allow argument deductions that should
11468 not succeed, and therefore report ambiguous overload situations
11469 where there are none. In theory, we could allow the substitution,
11470 but indicate that it should have failed, and allow our caller to
11471 make sure that the right thing happens, but we don't try to do this
11472 yet.
11474 This function is used for dealing with types, decls and the like;
11475 for expressions, use tsubst_expr or tsubst_copy. */
11477 tree
11479 {
11502 else
11507 /* Reuse typedefs. We need to do this to handle dependent attributes,
11508 such as attribute aligned. */
11511 {
11515 {
11516 /* DECL represents an alias template and we want to
11517 instantiate it. */
11521 }
11525 {
11529 }
11534 else
11535 /* The typedef is from a non-template context. */
11539 {
11541 r = cp_build_qualified_type_real
11545 }
11546 else
11547 {
11548 /* We don't have an instantiation yet, so drop the typedef. */
11553 }
11554 }
11567 {
11593 {
11599 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11600 needed. */
11606 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11607 with TREE_SIDE_EFFECTS that indicates this is not an integral
11608 constant expression. */
11611 {
11614 }
11617 }
11623 {
11636 {
11640 {
11641 /* See through ARGUMENT_PACK_SELECT arguments. */
11643 /* If the selected argument is an expansion E, that most
11644 likely means we were called from
11645 gen_elem_of_pack_expansion_instantiation during the
11646 substituting of pack an argument pack (which Ith
11647 element is a pack expansion, where I is
11648 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11649 In this case, the Ith element resulting from this
11650 substituting is going to be a pack expansion, which
11651 pattern is the pattern of E. Let's return the
11652 pattern of E, and
11653 gen_elem_of_pack_expansion_instantiation will
11654 build the resulting pack expansion from it. */
11657 }
11658 }
11663 {
11665 /* If ARG is an argument pack, we don't actually want to
11666 perform a substitution here, because substitutions
11667 for argument packs are only done
11668 element-by-element. We can get to this point when
11669 substituting the type of a non-type template
11670 parameter pack, when that type actually contains
11671 template parameter packs from an outer template, e.g.,
11673 template<typename... Types> struct A {
11674 template<Types... Values> struct B { };
11675 }; */
11679 {
11685 return cp_build_qualified_type_real
11687 }
11689 {
11690 /* We are processing a type constructed from a
11691 template template parameter. */
11702 /* Consider this code:
11704 template <template <class> class Template>
11705 struct Internal {
11706 template <class Arg> using Bind = Template<Arg>;
11707 };
11709 template <template <class> class Template, class Arg>
11710 using Instantiate = Template<Arg>; //#0
11712 template <template <class> class Template,
11713 class Argument>
11714 using Bind =
11715 Instantiate<Internal<Template>::template Bind,
11716 Argument>; //#1
11718 When #1 is parsed, the
11719 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11720 parameter `Template' in #0 matches the
11721 UNBOUND_CLASS_TEMPLATE representing the argument
11722 `Internal<Template>::template Bind'; We then want
11723 to assemble the type `Bind<Argument>' that can't
11724 be fully created right now, because
11725 `Internal<Template>' not being complete, the Bind
11726 template cannot be looked up in that context. So
11727 we need to "store" `Bind<Argument>' for later
11728 when the context of Bind becomes complete. Let's
11729 store that in a TYPENAME_TYPE. */
11733 argvec),
11734 typename_type,
11735 complain);
11737 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11738 are resolving nested-types in the signature of a
11739 member function templates. Otherwise ARG is a
11740 TEMPLATE_DECL and is the real template to be
11741 instantiated. */
11749 complain);
11750 return cp_build_qualified_type_real
11752 }
11753 else
11754 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11756 }
11759 /* This can happen during the attempted tsubst'ing in
11760 unify. This means that we don't yet have any information
11761 about the template parameter in question. */
11764 /* Early in template argument deduction substitution, we don't
11765 want to reduce the level of 'auto', or it will be confused
11766 with a normal template parm in subsequent deduction. */
11770 /* If we get here, we must have been looking at a parm for a
11771 more deeply nested template. Make a new version of this
11772 template parameter, but with a lower level. */
11774 {
11779 {
11781 r = cp_build_qualified_type_real
11785 }
11786 else
11787 {
11798 /* We have reduced the level of the template
11799 template parameter, but not the levels of its
11800 template parameters, so canonical_type_parameter
11801 will not be able to find the canonical template
11802 template parameter for this level. Thus, we
11803 require structural equality checking to compare
11804 TEMPLATE_TEMPLATE_PARMs. */
11808 else
11812 {
11820 }
11821 }
11830 }
11833 }
11836 {
11844 {
11848 }
11851 {
11855 }
11858 {
11862 }
11868 }
11871 /* We should never be tsubsting a binfo. */
11875 /* A vector of template arguments. */
11881 {
11885 /* [temp.deduct]
11887 Type deduction may fail for any of the following
11888 reasons:
11890 -- Attempting to create a pointer to reference type.
11891 -- Attempting to create a reference to a reference type or
11892 a reference to void.
11894 Core issue 106 says that creating a reference to a reference
11895 during instantiation is no longer a cause for failure. We
11896 only enforce this check in strict C++98 mode. */
11900 {
11903 /* We keep track of the last time we issued this error
11904 message to avoid spewing a ton of messages during a
11905 single bad template instantiation. */
11908 {
11913 else
11916 }
11919 }
11923 {
11925 {
11928 type);
11929 else
11931 type);
11932 }
11934 }
11936 {
11940 }
11942 /* In C++0x, during template argument substitution, when there is an
11943 attempt to create a reference to a reference type, reference
11944 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
11946 "If a template-argument for a template-parameter T names a type
11947 that is a reference to a type A, an attempt to create the type
11948 'lvalue reference to cv T' creates the type 'lvalue reference to
11949 A,' while an attempt to create the type type rvalue reference to
11950 cv T' creates the type T"
11951 */
11952 r = cp_build_reference_type
11955 else
11963 {
11965 pedwarn
11967 code == REFERENCE_TYPE
11970 else
11972 }
11975 /* Will this ever be needed for TYPE_..._TO values? */
11979 }
11981 {
11984 {
11985 /* [temp.deduct]
11987 Type deduction may fail for any of the following
11988 reasons:
11990 -- Attempting to create "pointer to member of T" when T
11991 is not a class type. */
11995 }
11997 {
12001 }
12003 {
12007 }
12010 {
12011 /* The type of the implicit object parameter gets its
12012 cv-qualifiers from the FUNCTION_TYPE. */
12013 tree memptr;
12014 tree method_type
12019 complain);
12020 }
12021 else
12024 complain);
12025 }
12028 {
12029 tree fntype;
12030 tree specs;
12035 /* Substitute the exception specification. */
12043 }
12045 {
12050 /* As an optimization, we avoid regenerating the array type if
12051 it will obviously be the same as T. */
12055 /* These checks should match the ones in grokdeclarator.
12057 [temp.deduct]
12059 The deduction may fail for any of the following reasons:
12061 -- Attempting to create an array with an element type that
12062 is void, a function type, or a reference type, or [DR337]
12063 an abstract class type. */
12067 {
12071 }
12079 {
12082 }
12085 }
12088 {
12098 {
12102 }
12104 {
12105 /* Normally, make_typename_type does not require that the CTX
12106 have complete type in order to allow things like:
12108 template <class T> struct S { typename S<T>::X Y; };
12110 But, such constructs have already been resolved by this
12111 point, so here CTX really should have complete type, unless
12112 it's a partial instantiation. */
12115 {
12119 }
12120 }
12127 {
12130 }
12133 {
12135 {
12139 else
12141 }
12143 {
12147 else
12149 }
12150 }
12152 return cp_build_qualified_type_real
12154 }
12157 {
12169 }
12172 {
12173 tree type;
12189 complain);
12190 }
12193 {
12194 tree type;
12212 else
12213 {
12217 /* In a template ~id could be either a complement expression
12218 or an unqualified-id naming a destructor; if instantiating
12219 it produces an expression, it's not an id-expression or
12220 member access. */
12223 }
12227 complain);
12228 }
12231 {
12235 }
12239 {
12241 tree packed_out =
12243 args,
12244 complain,
12245 in_decl);
12248 /* For template nontype argument packs, also substitute into
12249 the type. */
12254 }
12269 /* We should use one of the expression tsubsts for these codes. */
12275 }
12276 }
12278 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12279 type of the expression on the left-hand side of the "." or "->"
12280 operator. */
12282 static tree
12285 {
12286 tree name;
12287 tree qualifying_scope;
12288 tree fns;
12289 tree optype;
12294 /* A baselink indicates a function from a base class. Both the
12295 BASELINK_ACCESS_BINFO and the base class referenced may
12296 indicate bases of the template class, rather than the
12297 instantiated class. In addition, lookups that were not
12298 ambiguous before may be ambiguous now. Therefore, we perform
12299 the lookup again. */
12306 {
12313 }
12321 /* If lookup found a single function, mark it as used at this
12322 point. (If it lookup found multiple functions the one selected
12323 later by overload resolution will be marked as used at that
12324 point.) */
12330 /* Add back the template arguments, if present. */
12335 template_args);
12336 /* Update the conversion operator type. */
12344 qualifying_scope,
12345 object_type);
12347 }
12349 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12350 true if the qualified-id will be a postfix-expression in-and-of
12351 itself; false if more of the postfix-expression follows the
12352 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12353 of "&". */
12355 static tree
12359 {
12360 tree expr;
12361 tree scope;
12362 tree name;
12364 tree template_args;
12369 /* Figure out what name to look up. */
12372 {
12380 }
12381 else
12382 {
12385 }
12387 /* Substitute into the qualifying scope. When there are no ARGS, we
12388 are just trying to simplify a non-dependent expression. In that
12389 case the qualifying scope may be dependent, and, in any case,
12390 substituting will not help. */
12393 {
12396 }
12397 else
12401 {
12406 }
12409 {
12411 {
12412 /* A BIT_NOT_EXPR is used to represent a destructor. */
12414 {
12418 }
12419 else
12422 }
12423 else
12427 {
12429 {
12433 }
12435 }
12436 }
12439 {
12441 scope);
12442 /* Remember that there was a reference to this entity. */
12444 }
12447 {
12453 }
12462 {
12463 expr = (adjust_result_of_qualified_name_lookup
12465 expr = (finish_qualified_id_expr
12469 }
12471 /* Expressions do not generally have reference type. */
12473 /* However, if we're about to form a pointer-to-member, we just
12474 want the referenced member referenced. */
12479 }
12481 /* Like tsubst, but deals with expressions. This function just replaces
12482 template parms; to finish processing the resultant expression, use
12483 tsubst_copy_and_build or tsubst_expr. */
12485 static tree
12487 {
12489 tree r;
12497 {
12502 {
12503 /* We get here for a use of 'this' in an NSDMI. */
12509 /* This can happen for a parameter name used later in a function
12510 declaration (such as in a late-specified return type). Just
12511 make a dummy decl, since it's only used for its type. */
12514 /* Give it the template pattern as its context; its true context
12515 hasn't been instantiated yet and this is good enough for
12516 mangling. */
12518 }
12526 {
12527 tree enum_type;
12528 tree v;
12532 /* There is no need to substitute into namespace-scope
12533 enumerators. */
12536 /* If ARGS is NULL, then T is known to be non-dependent. */
12540 /* Unfortunately, we cannot just call lookup_name here.
12541 Consider:
12543 template <int I> int f() {
12544 enum E { a = I };
12545 struct S { void g() { E e = a; } };
12546 };
12548 When we instantiate f<7>::S::g(), say, lookup_name is not
12549 clever enough to find f<7>::a. */
12550 enum_type
12560 /* We didn't find the name. That should never happen; if
12561 name-lookup found it during preliminary parsing, we
12562 should find it again here during instantiation. */
12564 }
12569 {
12570 /* Check for a local specialization set up by
12571 tsubst_pack_expansion. */
12573 {
12577 }
12579 /* When retrieving a capture pack from a generic lambda, remove the
12580 lambda call op's own template argument list from ARGS. Only the
12581 template arguments active for the closure type should be used to
12582 retrieve the pack specialization. */
12588 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12589 tsubst_decl put in the hash table. */
12591 }
12594 {
12595 tree ctx;
12600 {
12603 {
12607 }
12609 }
12610 }
12619 {
12622 {
12624 {
12625 /* Just use name lookup to find a member alias for an
12626 anonymous union, but then add it to the hash table. */
12630 }
12631 else
12632 {
12633 /* This can happen for a variable used in a late-specified
12634 return type of a local lambda. Just make a dummy decl
12635 since it's only used for its type. */
12640 }
12641 }
12642 }
12643 else
12652 /* An OVERLOAD will always be a non-dependent overload set; an
12653 overload set from function scope will just be represented with an
12654 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12670 {
12671 /* Template template argument like the following example need
12672 special treatment:
12674 template <template <class> class TT> struct C {};
12675 template <class T> struct D {
12676 template <class U> struct E {};
12677 C<E> c; // #1
12678 };
12679 D<int> d; // #2
12681 We are processing the template argument `E' in #1 for
12682 the template instantiation #2. Originally, `E' is a
12683 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12684 have to substitute this with one having context `D<int>'. */
12688 }
12689 else
12690 /* Ordinary template template argument. */
12701 return build1
12707 {
12717 /* We only want to compute the number of arguments. */
12731 {
12738 else
12741 }
12742 else
12744 }
12746 {
12754 }
12755 /* Fall through */
12771 return build1
12776 {
12777 tree object;
12778 tree name;
12783 {
12787 }
12790 {
12800 }
12805 in_decl);
12806 else
12809 }
12847 return build_nt
12860 return build_nt
12867 {
12875 }
12881 {
12882 r = build_nt
12888 }
12891 {
12892 r = build_nt
12898 }
12901 {
12902 r = build_nt
12908 }
12911 {
12912 /* Substituted template arguments */
12921 }
12924 {
12944 }
12969 /* Fall through. */
12972 {
12975 }
12976 else
12980 /* This is handled by tsubst_copy_and_build. */
12986 in_decl),
12990 /* We shouldn't have built any of these during initial template
12991 generation. Instead, they should be built during instantiation
12992 in response to the saved STMT_IS_FULL_EXPR_P setting. */
12996 r = build2
13016 {
13017 /* Instantiate any typedefs in the type. */
13022 }
13025 /* These can sometimes show up in a partial instantiation, but never
13026 involve template parms. */
13031 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13034 }
13035 }
13037 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13039 static tree
13042 {
13046 {
13052 {
13055 {
13061 }
13062 /* FALLTHRU */
13090 {
13093 {
13100 }
13101 else
13103 }
13133 }
13134 }
13140 }
13142 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13144 static tree
13146 tree in_decl)
13147 {
13148 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13168 {
13171 else
13172 {
13176 }
13177 }
13182 #undef RECUR
13183 }
13185 /* Substitute one OMP_FOR iterator. */
13187 static void
13192 {
13193 #define RECUR(NODE) \
13194 tsubst_expr ((NODE), args, complain, in_decl, \
13195 integral_constant_expression_p)
13204 {
13205 /* We need to jump through some hoops to handle declarations in the
13206 for-init-statement, since we might need to handle auto deduction,
13207 but we need to keep control of initialization. */
13211 }
13212 else
13224 {
13226 {
13227 /* Declare the variable, but don't let that initialize it. */
13232 }
13240 complain);
13241 else
13248 }
13251 {
13252 /* Declare and initialize the variable. */
13255 }
13257 {
13258 tree c;
13260 {
13271 }
13273 {
13278 {
13281 }
13282 }
13283 }
13289 else
13293 {
13304 {
13311 }
13312 else
13318 {
13324 }
13328 {
13335 }
13336 else
13342 }
13348 #undef RECUR
13349 }
13351 /* Like tsubst_copy for expressions, etc. but also does semantic
13352 processing. */
13354 static tree
13357 {
13358 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13359 #define RECUR(NODE) \
13360 tsubst_expr ((NODE), args, complain, in_decl, \
13361 integral_constant_expression_p)
13364 tree r;
13365 location_t loc;
13377 {
13379 {
13380 tree_stmt_iterator i;
13384 }
13399 else
13408 {
13410 tree init;
13416 {
13419 tree decl;
13427 else
13429 }
13431 {
13432 /* Don't build up decls for a variadic capture proxy, we'll
13433 instantiate the elements directly as needed. */
13435 }
13436 else
13437 {
13441 {
13442 /* By marking the declaration as instantiated, we avoid
13443 trying to instantiate it. Since instantiate_decl can't
13444 handle local variables, and since we've already done
13445 all that needs to be done, that's the right thing to
13446 do. */
13451 /* Anonymous aggregates are a special case. */
13454 {
13457 {
13461 }
13463 }
13469 {
13474 }
13475 else
13476 {
13481 {
13482 /* For __PRETTY_FUNCTION__ we have to adjust the
13483 initializer. */
13487 }
13488 else
13489 {
13493 {
13494 /* If we had an initializer but it
13495 instantiated to nothing,
13496 value-initialize the object. This will
13497 only occur when the initializer was a
13498 pack expansion where the parameter packs
13499 used in that expansion were of length
13500 zero. */
13502 complain);
13505 }
13506 else
13508 }
13511 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13514 }
13515 }
13516 }
13519 }
13534 {
13544 }
13571 {
13575 }
13583 else
13591 else
13618 {
13620 tree label;
13625 }
13631 /* Computed goto's must be tsubst'd into. On the other hand,
13632 non-computed gotos must not be; the identifier in question
13633 will have no binding. */
13635 else
13641 tmp = finish_asm_stmt
13648 {
13653 }
13658 {
13663 }
13664 else
13665 {
13670 else
13677 else
13683 else
13685 }
13689 {
13693 {
13695 /* Prevent instantiate_decl from trying to instantiate
13696 this variable. We've already done all that needs to be
13697 done. */
13700 }
13705 }
13711 {
13712 /* Local classes are not independent templates; they are
13713 instantiated along with their containing function. And this
13714 way we don't have to deal with pushing out of one local class
13715 to instantiate a member of another local class. */
13716 tree fn;
13717 /* Closures are handled by the LAMBDA_EXPR. */
13723 }
13727 {
13728 tree condition;
13731 condition =
13733 args,
13742 }
13766 {
13775 {
13780 }
13792 integral_constant_expression_p);
13801 else
13802 {
13810 }
13813 }
13858 {
13863 {
13866 }
13872 }
13873 else
13874 {
13881 {
13884 }
13887 {
13892 {
13895 }
13901 }
13902 else
13903 {
13907 }
13910 }
13914 {
13920 {
13924 {
13929 }
13933 }
13934 else
13935 {
13940 }
13941 }
13966 /* If the first operand was a statement, we're done with it. */
13970 complain));
13982 integral_constant_expression_p));
13983 }
13986 out:
13989 #undef RECUR
13990 #undef RETURN
13991 }
13993 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
13994 function. For description of the body see comment above
13995 cp_parser_omp_declare_reduction_exprs. */
13997 static void
13999 {
14005 tree_stmt_iterator tsi;
14016 {
14035 }
14037 {
14057 }
14058 }
14060 /* T is a postfix-expression that is not being used in a function
14061 call. Return the substituted version of T. */
14063 static tree
14065 tsubst_flags_t complain,
14066 tree in_decl)
14067 {
14071 else
14077 }
14079 /* Sentinel to disable certain warnings during template substitution. */
14087 };
14089 /* Like tsubst but deals with expressions and performs semantic
14090 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14092 tree
14094 tree args,
14095 tsubst_flags_t complain,
14096 tree in_decl,
14099 {
14100 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14101 #define RECUR(NODE) \
14102 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14104 integral_constant_expression_p)
14107 location_t loc;
14116 /* N3276 decltype magic only applies to calls at the top level or on the
14117 right side of a comma. */
14122 {
14125 /* Fall through. */
14127 {
14128 tree decl;
14129 cp_id_kind idk;
14134 {
14137 }
14139 /* Look up the name. */
14142 /* By convention, expressions use ERROR_MARK_NODE to indicate
14143 failure, not NULL_TREE. */
14149 integral_constant_expression_p,
14157 input_location);
14161 {
14165 }
14167 }
14170 {
14171 tree object;
14179 {
14182 }
14183 else
14190 else
14192 }
14195 {
14199 {
14200 /* A type conversion to reference type will be enclosed in
14201 such an indirect ref, but the substitution of the cast
14202 will have also added such an indirect ref. */
14205 }
14206 else
14210 }
14218 {
14225 flags));
14226 }
14239 {
14240 tree type;
14246 {
14251 }
14257 {
14275 }
14278 }
14312 else
14314 in_decl);
14349 {
14352 tree r = build_x_binary_op
14356 ? ERROR_MARK
14360 ? ERROR_MARK
14368 }
14385 {
14394 }
14398 /* Fall through */
14401 {
14402 tree r;
14408 {
14409 /* When there are no ARGS, we are trying to evaluate a
14410 non-dependent expression from the parser. Trying to do
14411 the substitutions may not work. */
14414 }
14415 else
14416 {
14421 else
14424 /*integral_constant_expression_p=*/
14428 }
14432 else
14436 {
14438 {
14440 {
14444 }
14445 else
14449 }
14451 }
14453 }
14456 {
14466 }
14480 {
14482 tree r = build_x_modify_expr
14488 /* TREE_NO_WARNING must be set if either the expression was
14489 parenthesized or it uses an operator such as >>= rather
14490 than plain assignment. In the former case, it was already
14491 set and must be copied. In the latter case,
14492 build_x_modify_expr sets it and it must not be reset
14493 here. */
14498 }
14503 /* Remember that there was a reference to this entity. */
14509 {
14514 tree ret;
14518 else
14519 {
14523 }
14525 /* If there was an initializer in the original tree, but it
14526 instantiated to an empty list, then we should pass a
14527 non-NULL empty vector to tell build_new that it was an
14528 empty initializer() rather than no initializer. This can
14529 only happen when the initializer is a pack expansion whose
14530 parameter packs are of length zero. */
14533 else
14534 {
14538 else
14539 {
14542 }
14543 }
14550 complain);
14558 }
14566 complain));
14569 {
14573 integral_constant_expression_p);
14575 op0,
14578 }
14581 {
14582 tree function;
14587 tree ret;
14590 /* When we parsed the expression, we determined whether or
14591 not Koenig lookup should be performed. */
14594 {
14599 }
14601 {
14602 /* Do nothing; calling tsubst_copy_and_build on an identifier
14603 would incorrectly perform unqualified lookup again.
14605 Note that we can also have an IDENTIFIER_NODE if the earlier
14606 unqualified lookup found a member function; in that case
14607 koenig_p will be false and we do want to do the lookup
14608 again to find the instantiated member function.
14610 FIXME but doing that causes c++/15272, so we need to stop
14611 using IDENTIFIER_NODE in that situation. */
14613 }
14614 else
14615 {
14617 {
14623 }
14624 else
14629 /* Avoid error about taking the address of a constructor. */
14633 in_decl,
14635 integral_constant_expression_p);
14639 }
14644 {
14649 else
14650 {
14651 /* Expand the pack expansion and push each entry onto
14652 CALL_ARGS. */
14655 {
14660 {
14665 }
14666 }
14667 else
14668 {
14669 /* A partial substitution. Add one entry. */
14671 }
14672 }
14673 }
14675 /* We do not perform argument-dependent lookup if normal
14676 lookup finds a non-function, in accordance with the
14677 expected resolution of DR 218. */
14680 /* If lookup found a member function, the Koenig lookup is
14681 not appropriate, even if an unqualified-name was used
14682 to denote the function. */
14685 /* Only do this when substitution turns a dependent call
14686 into a non-dependent call. */
14693 {
14695 {
14696 /* For backwards compatibility and good diagnostics, try
14697 the unqualified lookup again if we aren't in SFINAE
14698 context. */
14699 tree unq = (tsubst_copy_and_build
14701 integral_constant_expression_p));
14706 {
14715 "%qD was not declared in this scope, "
14716 "and no declarations were found by "
14717 "argument-dependent lookup at the point "
14719 {
14723 {
14725 input_location);
14727 "declarations in dependent base %qT are "
14733 else
14737 }
14738 else
14741 }
14743 }
14744 }
14746 {
14751 }
14752 }
14754 /* Remember that there was a reference to this entity. */
14758 /* Put back tf_decltype for the actual call. */
14763 complain);
14765 {
14780 complain);
14781 else
14782 ret = (build_new_method_call
14787 complain));
14788 }
14789 else
14792 koenig_p,
14793 complain);
14798 }
14801 {
14806 {
14808 {
14813 }
14814 else
14815 {
14820 }
14821 }
14822 else
14823 {
14826 }
14830 }
14837 input_location));
14840 {
14848 {
14849 /* We have pack expansions, so expand those and
14850 create a new list out of it. */
14853 tree chain;
14856 /* Expand the argument expressions. */
14864 /* Build the rest of the list. */
14869 /* Determine the number of arguments. */
14871 {
14874 }
14877 else
14878 {
14879 /* Since we only performed a partial substitution into
14880 the argument pack, we only RETURN (a single list
14881 node. */
14888 }
14890 /* Convert the argument vectors into a TREE_LIST */
14893 {
14894 /* Grab the Ith values. */
14895 i--;
14898 value
14902 /* Build the list (backwards). */
14904 }
14907 }
14923 }
14926 {
14927 tree object;
14928 tree object_type;
14929 tree member;
14930 tree r;
14934 /* Remember that there was a reference to this entity. */
14944 else
14952 {
14954 {
14959 {
14962 }
14964 {
14969 }
14970 }
14971 }
14974 {
14975 /* Lookup the template functions now that we know what the
14976 scope is. */
14984 {
14987 args);
14988 member = (adjust_result_of_qualified_name_lookup
14990 object_type));
14991 }
14992 else
14993 {
14995 input_location);
14997 }
14998 }
15002 {
15004 {
15008 else
15011 }
15013 }
15015 {
15020 }
15024 complain);
15028 }
15035 {
15043 tree r;
15048 /* digest_init will do the wrong thing if we let it. */
15052 /* We do not want to process the index of aggregate
15053 initializers as they are identifier nodes which will be
15054 looked up by digest_init. */
15060 {
15062 /* An identifier index is looked up in the type
15063 being initialized, not the current scope. */
15068 {
15069 /* Substitute into the pack expansion. */
15071 in_decl);
15075 ;
15077 /* Just move the argument into place. */
15079 else
15080 {
15081 /* Update the length of the final CONSTRUCTOR
15082 arguments vector, and note that we will need to
15083 copy.*/
15086 }
15087 }
15088 else
15090 }
15093 {
15098 {
15100 {
15105 }
15106 else
15108 }
15109 }
15119 }
15122 {
15125 {
15128 }
15129 else
15130 {
15133 }
15134 }
15140 {
15141 /* We don't build decls for an instantiation of a
15142 variadic capture proxy, we instantiate the elements
15143 when needed. */
15146 }
15147 /* Fall through */
15150 {
15154 /* If the original type was a reference, we'll be wrapped in
15155 the appropriate INDIRECT_REF. */
15158 }
15169 {
15178 }
15181 {
15187 integral_constant_expression_p);
15191 /* If the resulting list of expression statement is empty,
15192 fold it further into void_zero_node. */
15197 }
15200 {
15214 /* For a function scope, we want to use tsubst so that we don't
15215 complain about referring to an auto function before its return
15216 type has been deduced. Otherwise, we want to use tsubst_copy so
15217 that we look up the existing field/parameter/variable rather
15218 than build a new one. */
15223 {
15224 /* Look up the parameter we want directly, as tsubst_copy
15225 doesn't do what we need. */
15231 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15234 }
15235 else
15244 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15246 /* Now that we know visibility, instantiate the type so we have a
15247 declaration of the op() for later calls to lambda_function. */
15253 }
15256 /* We can get here for a constant initializer of non-dependent type.
15257 FIXME stop folding in cp_parser_initializer_clause. */
15258 {
15260 complain);
15262 }
15266 integral_constant_expression_p));
15276 complain));
15279 /* Handle Objective-C++ constructs, if appropriate. */
15280 {
15281 tree subst
15286 }
15288 }
15290 #undef RECUR
15291 #undef RETURN
15292 out:
15295 }
15297 /* Verify that the instantiated ARGS are valid. For type arguments,
15298 make sure that the type's linkage is ok. For non-type arguments,
15299 make sure they are constants if they are integral or enumerations.
15300 Emit an error under control of COMPLAIN, and return TRUE on error. */
15302 static bool
15304 {
15308 {
15318 }
15320 {
15321 /* [basic.link]: A name with no linkage (notably, the name
15322 of a class or enumeration declared in a local scope)
15323 shall not be used to declare an entity with linkage.
15324 This implies that names with no linkage cannot be used as
15325 template arguments
15327 DR 757 relaxes this restriction for C++0x. */
15332 {
15333 /* DR 488 makes use of a type with no linkage cause
15334 type deduction to fail. */
15336 {
15339 else
15342 }
15344 }
15345 /* In order to avoid all sorts of complications, we do not
15346 allow variably-modified types as template arguments. */
15348 {
15352 }
15353 }
15354 /* Class template and alias template arguments should be OK. */
15356 ;
15357 /* A non-type argument of integral or enumerated type must be a
15358 constant. */
15362 {
15366 }
15368 }
15370 static bool
15372 {
15377 {
15380 }
15384 }
15386 /* We're out of SFINAE context now, so generate diagnostics for the access
15387 errors we saw earlier when instantiating D from TMPL and ARGS. */
15389 static void
15391 {
15403 }
15405 /* Instantiate the indicated variable, function, or alias template TMPL with
15406 the template arguments in TARG_PTR. */
15408 static tree
15410 {
15412 tree fndecl;
15413 tree gen_tmpl;
15414 tree spec;
15422 /* If this function is a clone, handle it specially. */
15424 {
15425 tree spec;
15426 tree clone;
15428 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15429 DECL_CLONED_FUNCTION. */
15435 /* Look for the clone. */
15439 /* We should always have found the clone by now. */
15442 }
15447 /* Check to see if we already have this specialization. */
15450 /* The TMPL is a partial instantiation. To get a full set of
15451 arguments we must add the arguments used to perform the
15452 partial instantiation. */
15454 targ_ptr);
15456 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15457 but it doesn't seem to be on the hot path. */
15466 {
15468 {
15472 }
15474 }
15477 complain))
15480 /* We are building a FUNCTION_DECL, during which the access of its
15481 parameters and return types have to be checked. However this
15482 FUNCTION_DECL which is the desired context for access checking
15483 is not built yet. We solve this chicken-and-egg problem by
15484 deferring all checks until we have the FUNCTION_DECL. */
15487 /* Instantiation of the function happens in the context of the function
15488 template, not the context of the overload resolution we're doing. */
15490 /* If there are dependent arguments, e.g. because we're doing partial
15491 ordering, make sure processing_template_decl stays set. */
15495 {
15499 }
15500 /* Substitute template parameters to obtain the specialization. */
15508 {
15511 }
15513 /* The DECL_TI_TEMPLATE should always be the immediate parent
15514 template, not the most general template. */
15517 /* Now we know the specialization, compute access previously
15518 deferred. */
15525 /* If we've just instantiated the main entry point for a function,
15526 instantiate all the alternate entry points as well. We do this
15527 by cloning the instantiation of the main entry point, not by
15528 instantiating the template clones. */
15533 {
15535 {
15536 /* Remember to reinstantiate when we're out of SFINAE so the user
15537 can see the errors. */
15539 }
15541 }
15543 }
15545 /* Wrapper for instantiate_template_1. */
15547 tree
15549 {
15550 tree ret;
15555 }
15557 /* Instantiate the alias template TMPL with ARGS. Also push a template
15558 instantiation level, which instantiate_template doesn't do because
15559 functions and variables have sufficient context established by the
15560 callers. */
15562 static tree
15564 {
15571 {
15574 }
15576 args =
15584 /* We can't free this if a pending_template entry or last_error_tinst_level
15585 is pointing at it. */
15591 }
15593 /* PARM is a template parameter pack for FN. Returns true iff
15594 PARM is used in a deducible way in the argument list of FN. */
15596 static bool
15598 {
15601 {
15603 tree packs;
15609 {
15610 /* The template parameter pack is used in a function parameter
15611 pack. If this is the end of the parameter list, the
15612 template parameter pack is deducible. */
15615 else
15616 /* Otherwise, not. Well, it could be deduced from
15617 a non-pack parameter, but doing so would end up with
15618 a deduction mismatch, so don't bother. */
15620 }
15621 }
15622 /* The template parameter pack isn't used in any function parameter
15623 packs, but it might be used deeper, e.g. tuple<Args...>. */
15625 }
15627 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15628 NARGS elements of the arguments that are being used when calling
15629 it. TARGS is a vector into which the deduced template arguments
15630 are placed.
15632 Returns either a FUNCTION_DECL for the matching specialization of FN or
15633 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15634 true, diagnostics will be printed to explain why it failed.
15636 If FN is a conversion operator, or we are trying to produce a specific
15637 specialization, RETURN_TYPE is the return type desired.
15639 The EXPLICIT_TARGS are explicit template arguments provided via a
15640 template-id.
15642 The parameter STRICT is one of:
15644 DEDUCE_CALL:
15645 We are deducing arguments for a function call, as in
15646 [temp.deduct.call].
15648 DEDUCE_CONV:
15649 We are deducing arguments for a conversion function, as in
15650 [temp.deduct.conv].
15652 DEDUCE_EXACT:
15653 We are deducing arguments when doing an explicit instantiation
15654 as in [temp.explicit], when determining an explicit specialization
15655 as in [temp.expl.spec], or when taking the address of a function
15656 template, as in [temp.deduct.funcaddr]. */
15658 tree
15660 tree explicit_targs,
15661 tree targs,
15664 tree return_type,
15665 unification_kind_t strict,
15669 {
15670 tree parms;
15671 tree fntype;
15679 tree tinst;
15685 /* In C++0x, it's possible to have a function template whose type depends
15686 on itself recursively. This is most obvious with decltype, but can also
15687 occur with enumeration scope (c++/48969). So we need to catch infinite
15688 recursion and reject the substitution at deduction time; this function
15689 will return error_mark_node for any repeated substitution.
15691 This also catches excessive recursion such as when f<N> depends on
15692 f<N-1> across all integers, and returns error_mark_node for all the
15693 substitutions back up to the initial one.
15695 This is, of course, not reentrant. */
15705 {
15706 /* [temp.deduct]
15708 The specified template arguments must match the template
15709 parameters in kind (i.e., type, nontype, template), and there
15710 must not be more arguments than there are parameters;
15711 otherwise type deduction fails.
15713 Nontype arguments must match the types of the corresponding
15714 nontype template parameters, or must be convertible to the
15715 types of the corresponding nontype parameters as specified in
15716 _temp.arg.nontype_, otherwise type deduction fails.
15718 All references in the function type of the function template
15719 to the corresponding template parameters are replaced by the
15720 specified template argument values. If a substitution in a
15721 template parameter or in the function type of the function
15722 template results in an invalid type, type deduction fails. */
15727 /* Adjust any explicit template arguments before entering the
15728 substitution context. */
15729 explicit_targs
15731 complain,
15737 /* Substitute the explicit args into the function type. This is
15738 necessary so that, for instance, explicitly declared function
15739 arguments can match null pointed constants. If we were given
15740 an incomplete set of explicit args, we must not do semantic
15741 processing during substitution as we could create partial
15742 instantiations. */
15744 {
15749 /* Dig out the actual parm. */
15752 {
15755 }
15757 {
15760 }
15763 /* No explicit argument for this template parameter. */
15767 {
15768 /* Mark the argument pack as "incomplete". We could
15769 still deduce more arguments during unification.
15770 We remove this mark in type_unification_real. */
15772 {
15776 }
15778 /* We have some incomplete argument packs. */
15780 }
15781 }
15785 {
15788 }
15791 /* Ignore any access checks; we'll see them again in
15792 instantiate_template and they might have the wrong
15793 access path at this point. */
15805 /* Place the explicitly specified arguments in TARGS. */
15808 }
15810 /* Never do unification on the 'this' parameter. */
15814 {
15823 }
15825 /* We allow incomplete unification without an error message here
15826 because the standard doesn't seem to explicitly prohibit it. Our
15827 callers must be ready to deal with unification failures in any
15828 event. */
15831 /* If we aren't explaining yet, push tinst context so we can see where
15832 any errors (e.g. from class instantiations triggered by instantiation
15833 of default template arguments) come from. If we are explaining, this
15834 context is redundant. */
15836 {
15839 }
15841 /* type_unification_real will pass back any access checks from default
15842 template argument substitution. */
15854 /* Now that we have bindings for all of the template arguments,
15855 ensure that the arguments deduced for the template template
15856 parameters have compatible template parameter lists. We cannot
15857 check this property before we have deduced all template
15858 arguments, because the template parameter types of a template
15859 template parameter might depend on prior template parameters
15860 deduced after the template template parameter. The following
15861 ill-formed example illustrates this issue:
15863 template<typename T, template<T> class C> void f(C<5>, T);
15865 template<int N> struct X {};
15867 void g() {
15868 f(X<5>(), 5l); // error: template argument deduction fails
15869 }
15871 The template parameter list of 'C' depends on the template type
15872 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
15873 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
15874 time that we deduce 'C'. */
15877 {
15880 }
15882 /* All is well so far. Now, check:
15884 [temp.deduct]
15886 When all template arguments have been deduced, all uses of
15887 template parameters in nondeduced contexts are replaced with
15888 the corresponding deduced argument values. If the
15889 substitution results in an invalid type, as described above,
15890 type deduction fails. */
15893 {
15896 }
15898 /* Also collect access checks from the instantiation. */
15911 /* Now perform any access checks encountered during substitution. */
15918 /* If we're looking for an exact match, check that what we got
15919 is indeed an exact match. It might not be if some template
15920 parameters are used in non-deduced contexts. But don't check
15921 for an exact match if we have dependent template arguments;
15922 in that case we're doing partial ordering, and we already know
15923 that we have two candidates that will provide the actual type. */
15925 {
15929 tree sarg
15935 {
15939 }
15940 }
15944 fail:
15947 {
15949 /* Reset once we're all the way out. */
15951 }
15953 /* We can't free this if a pending_template entry or last_error_tinst_level
15954 is pointing at it. */
15960 }
15962 /* Adjust types before performing type deduction, as described in
15963 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
15964 sections are symmetric. PARM is the type of a function parameter
15965 or the return type of the conversion function. ARG is the type of
15966 the argument passed to the call, or the type of the value
15967 initialized with the result of the conversion function.
15968 ARG_EXPR is the original argument expression, which may be null. */
15970 static int
15974 tree arg_expr)
15975 {
15979 {
15984 {
15985 /* Swap PARM and ARG throughout the remainder of this
15986 function; the handling is precisely symmetric since PARM
15987 will initialize ARG rather than vice versa. */
15992 }
15995 /* Core issue #873: Do the DR606 thing (see below) for these cases,
15996 too, but here handle it by stripping the reference from PARM
15997 rather than by adding it to ARG. */
16005 /* Nothing else to do in this case. */
16010 }
16013 {
16014 /* [temp.deduct.call]
16016 If P is not a reference type:
16018 --If A is an array type, the pointer type produced by the
16019 array-to-pointer standard conversion (_conv.array_) is
16020 used in place of A for type deduction; otherwise,
16022 --If A is a function type, the pointer type produced by
16023 the function-to-pointer standard conversion
16024 (_conv.func_) is used in place of A for type deduction;
16025 otherwise,
16027 --If A is a cv-qualified type, the top level
16028 cv-qualifiers of A's type are ignored for type
16029 deduction. */
16034 else
16036 }
16038 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16039 of the form T&&, where T is a template parameter, and the argument
16040 is an lvalue, T is deduced as A& */
16046 /* try_one_overload doesn't provide an arg_expr, but
16047 functions are always lvalues. */
16051 /* [temp.deduct.call]
16053 If P is a cv-qualified type, the top level cv-qualifiers
16054 of P's type are ignored for type deduction. If P is a
16055 reference type, the type referred to by P is used for
16056 type deduction. */
16059 {
16062 }
16064 /* DR 322. For conversion deduction, remove a reference type on parm
16065 too (which has been swapped into ARG). */
16070 }
16072 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16073 template which does contain any deducible template parameters; check if
16074 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16075 unify_one_argument. */
16077 static int
16080 {
16081 tree type;
16085 else
16092 {
16096 }
16098 {
16103 }
16107 else
16109 }
16113 /* Returns true iff the expression EXPR is one from which a template
16114 argument can be deduced. In other words, if it's an undecorated
16115 use of a template non-type parameter. */
16117 static bool
16119 {
16121 }
16123 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16124 deducible way; that is, if it has a max value of <PARM> - 1. */
16126 static bool
16128 {
16137 }
16139 /* Returns true iff the template arguments ARGS use a template parameter
16140 in a deducible way. */
16142 static bool
16144 {
16146 {
16151 else
16152 {
16159 else
16161 }
16164 }
16166 }
16168 /* Returns true iff TYPE contains any deducible references to template
16169 parameters, as per 14.8.2.5. */
16171 static bool
16173 {
16177 /* T
16178 cv-list T
16179 TT<T>
16180 TT<i>
16181 TT<> */
16186 /* T*
16187 T&
16188 T&& */
16192 /* T[integer-constant ]
16193 type [i] */
16198 /* T type ::*
16199 type T::*
16200 T T::*
16201 T (type ::*)()
16202 type (T::*)()
16203 type (type ::*)(T)
16204 type (T::*)(T)
16205 T (type ::*)(T)
16206 T (T::*)()
16207 T (T::*)(T) */
16210 || (uses_deducible_template_parms
16213 /* template-name <T> (where template-name refers to a class template)
16214 template-name <i> (where template-name refers to a class template) */
16221 /* type (T)
16222 T()
16223 T(T) */
16226 {
16235 }
16238 }
16240 /* Subroutine of type_unification_real and unify_pack_expansion to
16241 handle unification of a single P/A pair. Parameters are as
16242 for those functions. */
16244 static int
16248 {
16255 /* We can't deduce anything from this, but we might get all the
16256 template args from other function args. */
16259 /* Implicit conversions (Clause 4) will be performed on a function
16260 argument to convert it to the type of the corresponding function
16261 parameter if the parameter type contains no template-parameters that
16262 participate in template argument deduction. */
16264 /* For function parameters that contain no template-parameters at all,
16265 we have historically checked for convertibility in order to shortcut
16266 consideration of this candidate. */
16268 explain_p);
16271 /* For function parameters with only non-deducible template parameters,
16272 just return. */
16276 {
16278 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
16279 | UNIFY_ALLOW_MORE_CV_QUAL
16293 }
16295 /* We only do these transformations if this is the top-level
16296 parameter_type_list in a call or declaration matching; in other
16297 situations (nested function declarators, template argument lists) we
16298 won't be comparing a type to an expression, and we don't do any type
16299 adjustments. */
16301 {
16303 {
16306 {
16307 /* [temp.deduct.type] A template-argument can be
16308 deduced from a pointer to function or pointer
16309 to member function argument if the set of
16310 overloaded functions does not contain function
16311 templates and at most one of a set of
16312 overloaded functions provides a unique
16313 match. */
16320 }
16326 }
16328 arg_strict |=
16330 }
16331 else
16335 /* For deduction from an init-list we need the actual list. */
16339 }
16341 /* Most parms like fn_type_unification.
16343 If SUBR is 1, we're being called recursively (to unify the
16344 arguments of a function or method parameter of a function
16345 template).
16347 CHECKS is a pointer to a vector of access checks encountered while
16348 substituting default template arguments. */
16350 static int
16352 tree targs,
16353 tree xparms,
16357 unification_kind_t strict,
16361 {
16366 tree parms;
16375 /* Reset the number of non-defaulted template arguments contained
16376 in TARGS. */
16379 again:
16387 {
16392 /* For a function parameter pack that occurs at the end of the
16393 parameter-declaration-list, the type A of each remaining
16394 argument of the call is compared with the type P of the
16395 declarator-id of the function parameter pack. */
16401 /* For a function parameter pack that does not occur at the
16402 end of the parameter-declaration-list, the type of the
16403 parameter pack is a non-deduced context. */
16412 }
16417 {
16418 /* Unify the remaining arguments with the pack expansion type. */
16419 tree argvec;
16422 /* Allocate a TREE_VEC and copy in all of the arguments */
16427 /* Copy the parameter into parmvec. */
16433 /* Advance to the end of the list of parameters. */
16435 }
16437 /* Fail if we've reached the end of the parm list, and more args
16438 are present, and the parm list isn't variadic. */
16441 /* Fail if parms are left and they don't have default values. */
16444 {
16448 {
16449 count++;
16451 }
16453 }
16456 {
16457 tsubst_flags_t complain = (explain_p
16458 ? tf_warning_or_error
16462 {
16466 /* Clear the "incomplete" flags on all argument packs now so that
16467 substituting them into later default arguments works. */
16469 {
16472 }
16478 /* If this is an undeduced nontype parameter that depends on
16479 a type parameter, try another pass; its type may have been
16480 deduced from a later argument than the one from which
16481 this parameter can be deduced. */
16487 /* Core issue #226 (C++0x) [temp.deduct]:
16489 If a template argument has not been deduced, its
16490 default template argument, if any, is used.
16492 When we are in C++98 mode, TREE_PURPOSE will either
16493 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16494 to explicitly check cxx_dialect here. */
16496 {
16511 else
16512 {
16514 /* The position of the first default template argument,
16515 is also the number of non-defaulted arguments in TARGS.
16516 Record that. */
16520 }
16521 }
16523 /* If the type parameter is a parameter pack, then it will
16524 be deduced to an empty parameter pack. */
16526 {
16527 tree arg;
16530 {
16534 }
16535 else
16542 }
16545 }
16546 }
16547 #ifdef ENABLE_CHECKING
16550 #endif
16553 }
16555 /* Subroutine of type_unification_real. Args are like the variables
16556 at the call site. ARG is an overloaded function (or template-id);
16557 we try deducing template args from each of the overloads, and if
16558 only one succeeds, we go with that. Modifies TARGS and returns
16559 true on success. */
16561 static bool
16563 tree targs,
16564 tree parm,
16565 tree arg,
16566 unification_kind_t strict,
16569 {
16576 {
16579 }
16580 else
16584 /* Handle `&x' where `x' is some static or non-static member
16585 function name. */
16591 /* Strip baselink information. */
16596 {
16597 /* If we got some explicit template args, we need to plug them into
16598 the affected templates before we try to unify, in case the
16599 explicit args will completely resolve the templates in question. */
16606 {
16619 {
16624 {
16627 }
16628 }
16631 }
16632 /* If no templates (or more than one) are fully resolved by the
16633 explicit arguments, this template-id is a non-deduced context; it
16634 could still be OK if we deduce all template arguments for the
16635 enclosing call through other arguments. */
16638 }
16641 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16642 -- but the deduction does not succeed because the expression is
16643 not just the function on its own. */
16645 else
16651 {
16654 }
16656 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16657 to function or pointer to member function argument if the set of
16658 overloaded functions does not contain function templates and at most
16659 one of a set of overloaded functions provides a unique match.
16661 So if we found multiple possibilities, we return success but don't
16662 deduce anything. */
16665 {
16670 }
16675 }
16677 /* Core DR 115: In contexts where deduction is done and fails, or in
16678 contexts where deduction is not done, if a template argument list is
16679 specified and it, along with any default template arguments, identifies
16680 a single function template specialization, then the template-id is an
16681 lvalue for the function template specialization. */
16683 tree
16685 {
16698 {
16701 }
16703 {
16706 }
16708 {
16711 }
16714 {
16718 /* If we got some explicit template args, we need to plug them into
16719 the affected templates before we try to unify, in case the
16720 explicit args will completely resolve the templates in question. */
16728 {
16741 {
16744 {
16747 }
16749 {
16752 }
16753 }
16754 }
16756 {
16764 {
16765 tree base
16768 }
16772 }
16774 /* There were no good options and at least one bad one, so let the
16775 user know what the problem is. */
16777 }
16779 }
16781 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16782 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16783 different overloads deduce different arguments for a given parm.
16784 ADDR_P is true if the expression for which deduction is being
16785 performed was of the form "& fn" rather than simply "fn".
16787 Returns 1 on success. */
16789 static int
16791 tree orig_targs,
16792 tree targs,
16793 tree parm,
16794 tree arg,
16795 unification_kind_t strict,
16799 {
16801 tree tempargs;
16807 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16808 to function or pointer to member function argument if the set of
16809 overloaded functions does not contain function templates and at most
16810 one of a set of overloaded functions provides a unique match.
16812 So if this is a template, just return success. */
16824 /* We don't copy orig_targs for this because if we have already deduced
16825 some template args from previous args, unify would complain when we
16826 try to deduce a template parameter for the same argument, even though
16827 there isn't really a conflict. */
16834 /* First make sure we didn't deduce anything that conflicts with
16835 explicitly specified args. */
16837 {
16844 /* Since we're unifying against ourselves, we will fill in
16845 template args used in the function parm list with our own
16846 template parms. Discard them. */
16850 }
16853 {
16858 }
16861 }
16863 /* PARM is a template class (perhaps with unbound template
16864 parameters). ARG is a fully instantiated type. If ARG can be
16865 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
16866 TARGS are as for unify. */
16868 static tree
16871 {
16872 tree copy_of_targs;
16879 /* We need to make a new template argument vector for the call to
16880 unify. If we used TARGS, we'd clutter it up with the result of
16881 the attempted unification, even if this class didn't work out.
16882 We also don't want to commit ourselves to all the unifications
16883 we've already done, since unification is supposed to be done on
16884 an argument-by-argument basis. In other words, consider the
16885 following pathological case:
16887 template <int I, int J, int K>
16888 struct S {};
16890 template <int I, int J>
16891 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
16893 template <int I, int J, int K>
16894 void f(S<I, J, K>, S<I, I, I>);
16896 void g() {
16897 S<0, 0, 0> s0;
16898 S<0, 1, 2> s2;
16900 f(s0, s2);
16901 }
16903 Now, by the time we consider the unification involving `s2', we
16904 already know that we must have `f<0, 0, 0>'. But, even though
16905 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
16906 because there are two ways to unify base classes of S<0, 1, 2>
16907 with S<I, I, I>. If we kept the already deduced knowledge, we
16908 would reject the possibility I=1. */
16911 /* If unification failed, we're done. */
16917 }
16919 /* Given a template type PARM and a class type ARG, find the unique
16920 base type in ARG that is an instance of PARM. We do not examine
16921 ARG itself; only its base-classes. If there is not exactly one
16922 appropriate base class, return NULL_TREE. PARM may be the type of
16923 a partial specialization, as well as a plain template type. Used
16924 by unify. */
16926 static enum template_base_result
16929 {
16931 tree binfo;
16937 {
16938 /* The type could not be completed. */
16941 }
16943 /* Walk in inheritance graph order. The search order is not
16944 important, and this avoids multiple walks of virtual bases. */
16946 {
16951 {
16952 /* If there is more than one satisfactory baseclass, then:
16954 [temp.deduct.call]
16956 If they yield more than one possible deduced A, the type
16957 deduction fails.
16959 applies. */
16961 {
16964 }
16967 }
16968 }
16972 }
16974 /* Returns the level of DECL, which declares a template parameter. */
16976 static int
16978 {
16980 {
16990 }
16992 }
16994 /* Decide whether ARG can be unified with PARM, considering only the
16995 cv-qualifiers of each type, given STRICT as documented for unify.
16996 Returns nonzero iff the unification is OK on that basis. */
16998 static int
17000 {
17006 {
17007 /* Although a CVR qualifier is ignored when being applied to a
17008 substituted template parameter ([8.3.2]/1 for example), that
17009 does not allow us to unify "const T" with "int&" because both
17010 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17011 It is ok when we're allowing additional CV qualifiers
17012 at the outer level [14.8.2.1]/3,1st bullet. */
17022 }
17033 }
17035 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17036 void
17038 {
17042 {
17045 }
17046 else
17047 {
17050 }
17051 }
17053 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17054 do { \
17055 if (unify (TP, TA, P, A, S, EP)) \
17056 return 1; \
17057 } while (0);
17059 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17060 expansion at the end of PACKED_PARMS. Returns 0 if the type
17061 deduction succeeds, 1 otherwise. STRICT is the same as in
17062 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17063 call argument list. We'll need to adjust the arguments to make them
17064 types. SUBR tells us if this is from a recursive call to
17065 type_unification_real, or for comparing two template argument
17066 lists. */
17068 static int
17072 {
17073 tree parm
17083 /* Determine the parameter packs we will be deducing from the
17084 pattern, and record their current deductions. */
17087 {
17091 /* Determine the index and level of this parameter pack. */
17094 /* Keep track of the parameter packs and their corresponding
17095 argument packs. */
17098 }
17100 /* Loop through all of the arguments that have not yet been
17101 unified and unify each with the pattern. */
17103 {
17104 tree parm;
17108 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17109 or the element of its argument pack at the current index if
17110 this argument was explicitly specified. */
17112 {
17121 {
17124 }
17126 }
17128 /* If we had explicit template arguments, substitute them into the
17129 pattern before deduction. */
17131 {
17132 /* Some arguments might still be unspecified or dependent. */
17140 NULL_TREE);
17145 }
17146 else
17149 /* Unify the pattern with the current argument. */
17154 /* For each parameter pack, collect the deduced value. */
17156 {
17162 }
17163 }
17165 /* Verify that the results of unification with the parameter packs
17166 produce results consistent with what we've seen before, and make
17167 the deduced argument packs available. */
17169 {
17176 /* By default keep the original deduced argument pack.
17177 If necessary, more specific code is going to update the
17178 resulting deduced argument later down in this function. */
17182 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17183 actually deduce anything. */
17191 {
17192 /* If we had fewer function args than explicit template args,
17193 just use the explicits. */
17198 }
17201 {
17202 tree result;
17203 /* Build the deduced *_ARGUMENT_PACK. */
17205 {
17210 }
17211 else
17216 /* Note the deduced argument packs for this parameter
17217 pack. */
17219 }
17223 {
17224 /* We only had the explicitly-provided arguments before, but
17225 now we have a complete set of arguments. */
17231 }
17232 else
17233 {
17239 /* Inconsistent unification of this parameter pack. */
17241 bad_old_arg,
17242 bad_new_arg);
17243 }
17244 }
17247 }
17249 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17250 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17251 parameters and return value are as for unify. */
17253 static int
17257 {
17258 tree parm_max;
17259 tree arg_max;
17263 /* Our representation of array types uses "N - 1" as the
17264 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17265 not an integer constant. We cannot unify arbitrarily
17266 complex expressions, so we eliminate the MINUS_EXPRs
17267 here. */
17271 {
17274 }
17278 {
17279 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17280 trying to unify the type of a variable with the type
17281 of a template parameter. For example:
17283 template <unsigned int N>
17284 void f (char (&) [N]);
17285 int g();
17286 void h(int i) {
17287 char a[g(i)];
17288 f(a);
17289 }
17291 Here, the type of the ARG will be "int [g(i)]", and
17292 may be a SAVE_EXPR, etc. */
17296 }
17298 /* If only one of the bounds used a MINUS_EXPR, compensate
17299 by adding one to the other bound. */
17302 integer_type_node,
17303 parm_max,
17304 integer_one_node);
17307 integer_type_node,
17308 arg_max,
17309 integer_one_node);
17313 }
17315 /* Deduce the value of template parameters. TPARMS is the (innermost)
17316 set of template parameters to a template. TARGS is the bindings
17317 for those template parameters, as determined thus far; TARGS may
17318 include template arguments for outer levels of template parameters
17319 as well. PARM is a parameter to a template function, or a
17320 subcomponent of that parameter; ARG is the corresponding argument.
17321 This function attempts to match PARM with ARG in a manner
17322 consistent with the existing assignments in TARGS. If more values
17323 are deduced, then TARGS is updated.
17325 Returns 0 if the type deduction succeeds, 1 otherwise. The
17326 parameter STRICT is a bitwise or of the following flags:
17328 UNIFY_ALLOW_NONE:
17329 Require an exact match between PARM and ARG.
17330 UNIFY_ALLOW_MORE_CV_QUAL:
17331 Allow the deduced ARG to be more cv-qualified (by qualification
17332 conversion) than ARG.
17333 UNIFY_ALLOW_LESS_CV_QUAL:
17334 Allow the deduced ARG to be less cv-qualified than ARG.
17335 UNIFY_ALLOW_DERIVED:
17336 Allow the deduced ARG to be a template base class of ARG,
17337 or a pointer to a template base class of the type pointed to by
17338 ARG.
17339 UNIFY_ALLOW_INTEGER:
17340 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17341 case for more information.
17342 UNIFY_ALLOW_OUTER_LEVEL:
17343 This is the outermost level of a deduction. Used to determine validity
17344 of qualification conversions. A valid qualification conversion must
17345 have const qualified pointers leading up to the inner type which
17346 requires additional CV quals, except at the outer level, where const
17347 is not required [conv.qual]. It would be normal to set this flag in
17348 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17349 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17350 This is the outermost level of a deduction, and PARM can be more CV
17351 qualified at this point.
17352 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17353 This is the outermost level of a deduction, and PARM can be less CV
17354 qualified at this point. */
17356 static int
17359 {
17361 tree targ;
17362 tree tparm;
17365 /* I don't think this will do the right thing with respect to types.
17366 But the only case I've seen it in so far has been array bounds, where
17367 signedness is the only information lost, and I think that will be
17368 okay. */
17376 /* We can't deduce anything from this, but we might get all the
17377 template args from other function args. */
17380 /* If PARM uses template parameters, then we can't bail out here,
17381 even if ARG == PARM, since we won't record unifications for the
17382 template parameters. We might need them if we're trying to
17383 figure out which of two things is more specialized. */
17387 /* Handle init lists early, so the rest of the function can assume
17388 we're dealing with a type. */
17390 {
17395 /* Replace T with std::initializer_list<T> for deduction. */
17402 /* We can only deduce from an initializer list argument if the
17403 parameter is std::initializer_list or an array; otherwise this
17404 is a non-deduced context. */
17409 else
17413 {
17420 {
17422 /* It should only be possible to get here for a call. */
17424 elt_strict |= maybe_adjust_types_for_deduction
17427 }
17430 explain_p);
17431 }
17435 {
17436 /* Also deduce from the length of the initializer list. */
17443 }
17445 /* If the std::initializer_list<T> deduction worked, replace the
17446 deduced A with std::initializer_list<A>. */
17448 {
17453 }
17455 }
17457 /* Immediately reject some pairs that won't unify because of
17458 cv-qualification mismatches. */
17461 /* It is the elements of the array which hold the cv quals of an array
17462 type, and the elements might be template type parms. We'll check
17463 when we recurse. */
17465 /* We check the cv-qualifiers when unifying with template type
17466 parameters below. We want to allow ARG `const T' to unify with
17467 PARM `T' for example, when computing which of two templates
17468 is more specialized, for example. */
17482 {
17486 /* In a type which contains a nested-name-specifier, template
17487 argument values cannot be deduced for template parameters used
17488 within the nested-name-specifier. */
17500 /* The PARM is not one we're trying to unify. Just check
17501 to see if it matches ARG. */
17502 {
17507 else
17509 }
17516 /* Check for mixed types and values. */
17524 {
17525 /* ARG must be constructed from a template class or a template
17526 template parameter. */
17530 {
17532 /* An alias template name is never deduced. */
17537 tree parm_parms
17538 = DECL_INNERMOST_TEMPLATE_PARMS
17543 /* The resolution to DR150 makes clear that default
17544 arguments for an N-argument may not be used to bind T
17545 to a template template parameter with fewer than N
17546 parameters. It is not safe to permit the binding of
17547 default arguments as an extension, as that may change
17548 the meaning of a conforming program. Consider:
17550 struct Dense { static const unsigned int dim = 1; };
17552 template <template <typename> class View,
17553 typename Block>
17554 void operator+(float, View<Block> const&);
17556 template <typename Block,
17557 unsigned int Dim = Block::dim>
17558 struct Lvalue_proxy { operator float() const; };
17560 void
17561 test_1d (void) {
17562 Lvalue_proxy<Dense> p;
17563 float b;
17564 b + p;
17565 }
17567 Here, if Lvalue_proxy is permitted to bind to View, then
17568 the global operator+ will be used; if they are not, the
17569 Lvalue_proxy will be converted to float. */
17571 full_argvec,
17573 (explain_p
17574 ? tf_warning_or_error
17581 /* Deduce arguments T, i from TT<T> or TT<i>.
17582 We check each element of PARMVEC and ARGVEC individually
17583 rather than the whole TREE_VEC since they can have
17584 different number of elements. */
17591 /* Check if the parameters end in a pack, making them
17592 variadic. */
17598 /* If the template argument list of P contains a pack
17599 expansion that is not the last template argument, the
17600 entire template argument list is a non-deduced
17601 context. */
17610 {
17615 }
17620 DEDUCE_EXACT,
17623 }
17626 /* Fall through to deduce template name. */
17627 }
17631 {
17632 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17634 /* Simple cases: Value already set, does match or doesn't. */
17639 }
17640 else
17641 {
17642 /* If PARM is `const T' and ARG is only `int', we don't have
17643 a match unless we are allowing additional qualification.
17644 If ARG is `const int' and PARM is just `T' that's OK;
17645 that binds `const int' to `T'. */
17650 /* Consider the case where ARG is `const volatile int' and
17651 PARM is `const T'. Then, T should be `volatile int'. */
17652 arg = cp_build_qualified_type_real
17657 /* Simple cases: Value already set, does match or doesn't. */
17663 /* Make sure that ARG is not a variable-sized array. (Note
17664 that were talking about variable-sized arrays (like
17665 `int[n]'), rather than arrays of unknown size (like
17666 `int[]').) We'll get very confused by such a type since
17667 the bound of the array is not constant, and therefore
17668 not mangleable. Besides, such types are not allowed in
17669 ISO C++, so we can do as we please here. We do allow
17670 them for 'auto' deduction, since that isn't ABI-exposed. */
17674 /* Strip typedefs as in convert_template_argument. */
17676 }
17678 /* If ARG is a parameter pack or an expansion, we cannot unify
17679 against it unless PARM is also a parameter pack. */
17684 /* If the argument deduction results is a METHOD_TYPE,
17685 then there is a problem.
17686 METHOD_TYPE doesn't map to any real C++ type the result of
17687 the deduction can not be of that type. */
17701 {
17702 /* The PARM is not one we're trying to unify. Just check
17703 to see if it matches ARG. */
17709 }
17715 {
17720 }
17722 /* [temp.deduct.type] If, in the declaration of a function template
17723 with a non-type template-parameter, the non-type
17724 template-parameter is used in an expression in the function
17725 parameter-list and, if the corresponding template-argument is
17726 deduced, the template-argument type shall match the type of the
17727 template-parameter exactly, except that a template-argument
17728 deduced from an array bound may be of any integral type.
17729 The non-type parameter might use already deduced type parameters. */
17732 /* Template-parameter dependent expression. Just accept it for now.
17733 It will later be processed in convert_template_argument. */
17734 ;
17739 /* Convert the ARG to the type of PARM; the deduced non-type
17740 template argument must exactly match the types of the
17741 corresponding parameter. */
17744 /* We haven't deduced the type of this parameter yet. Try again
17745 later. */
17747 else
17750 /* If ARG is a parameter pack or an expansion, we cannot unify
17751 against it unless PARM is also a parameter pack. */
17761 {
17762 /* A pointer-to-member constant can be unified only with
17763 another constant. */
17767 /* Just unify the class member. It would be useless (and possibly
17768 wrong, depending on the strict flags) to unify also
17769 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17770 arg refer to the same variable, even if through different
17771 classes. For instance:
17773 struct A { int x; };
17774 struct B : A { };
17776 Unification of &A::x and &B::x must succeed. */
17779 }
17782 {
17786 /* [temp.deduct.call]
17788 A can be another pointer or pointer to member type that can
17789 be converted to the deduced A via a qualification
17790 conversion (_conv.qual_).
17792 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
17793 This will allow for additional cv-qualification of the
17794 pointed-to types if appropriate. */
17797 /* The derived-to-base conversion only persists through one
17798 level of pointers. */
17803 }
17835 /* We have already checked cv-qualification at the top of the
17836 function. */
17840 /* As far as unification is concerned, this wins. Later checks
17841 will invalidate it if necessary. */
17844 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
17845 /* Type INTEGER_CST can come from ordinary constant template args. */
17857 {
17867 /* Check for pack expansions in the parameters. */
17869 {
17871 {
17873 /* We can unify against something with a trailing
17874 parameter pack. */
17876 else
17877 /* [temp.deduct.type]/9: If the template argument list of
17878 P contains a pack expansion that is not the last
17879 template argument, the entire template argument list
17880 is a non-deduced context. */
17882 }
17883 }
17885 /* If we don't have enough arguments to satisfy the parameters
17886 (not counting the pack expression at the end), or we have
17887 too many arguments for a parameter list that doesn't end in
17888 a pack expression, we can't unify. */
17894 /* Unify all of the parameters that precede the (optional)
17895 pack expression. */
17897 {
17902 }
17905 DEDUCE_EXACT,
17908 }
17916 {
17924 }
17927 {
17931 {
17932 /* First, we try to unify the PARM and ARG directly. */
17937 {
17938 /* Fallback to the special case allowed in
17939 [temp.deduct.call]:
17941 If P is a class, and P has the form
17942 template-id, then A can be a derived class of
17943 the deduced A. Likewise, if P is a pointer to
17944 a class of the form template-id, A can be a
17945 pointer to a derived class pointed to by the
17946 deduced A. */
17953 }
17954 }
17958 /* Perhaps PARM is something like S<U> and ARG is S<int>.
17959 Then, we should unify `int' and `U'. */
17961 else
17962 /* There's no chance of unification succeeding. */
17967 }
17974 {
17977 tree a;
17983 /* CV qualifications for methods can never be deduced, they must
17984 match exactly. We need to check them explicitly here,
17985 because type_unification_real treats them as any other
17986 cv-qualified parameter. */
17988 && (!check_cv_quals_for_unify
18008 }
18011 /* Unify a pointer to member with a pointer to member function, which
18012 deduces the type of the member as a function type. */
18014 {
18015 /* Check top-level cv qualifiers */
18023 /* Determine the type of the function we are unifying against. */
18027 }
18046 /* Matched cases are handled by the ARG == PARM test above. */
18050 /* A non-type template parameter that is a variable should be a
18051 an integral constant, in which case, it whould have been
18052 folded into its (constant) value. So we should not be getting
18053 a variable here. */
18064 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18065 or UNDERLYING_TYPE nodes. */
18069 /* Unification fails if we hit an error node. */
18076 /* FALLTHRU */
18079 /* An unresolved overload is a nondeduced context. */
18084 /* We must be looking at an expression. This can happen with
18085 something like:
18087 template <int I>
18088 void foo(S<I>, S<I + 2>);
18090 This is a "nondeduced context":
18092 [deduct.type]
18094 The nondeduced contexts are:
18096 --A type that is a template-id in which one or more of
18097 the template-arguments is an expression that references
18098 a template-parameter.
18100 In these cases, we assume deduction succeeded, but don't
18101 actually infer any unifications. */
18106 else
18108 }
18109 }
18110 #undef RECUR_AND_CHECK_FAILURE
18111 \f
18112 /* Note that DECL can be defined in this translation unit, if
18113 required. */
18115 static void
18117 {
18118 tree clone;
18122 }
18124 /* Called if RESULT is explicitly instantiated, or is a member of an
18125 explicitly instantiated class. */
18127 void
18129 {
18132 /* If this entity has already been written out, it's too late to
18133 make any modifications. */
18137 /* For anonymous namespace we don't need to do anything. */
18139 {
18142 }
18145 /* The TREE_PUBLIC flag for function declarations will have been
18146 set correctly by tsubst. */
18149 /* This might have been set by an earlier implicit instantiation. */
18154 else
18155 {
18158 /* Always make artificials weak. */
18161 /* For WIN32 we also want to put explicit instantiations in
18162 linkonce sections. */
18165 }
18167 /* If EXTERN_P, then this function will not be emitted -- unless
18168 followed by an explicit instantiation, at which point its linkage
18169 will be adjusted. If !EXTERN_P, then this function will be
18170 emitted here. In neither circumstance do we want
18171 import_export_decl to adjust the linkage. */
18173 }
18175 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18176 important template arguments. If any are missing, we check whether
18177 they're important by using error_mark_node for substituting into any
18178 args that were used for partial ordering (the ones between ARGS and END)
18179 and seeing if it bubbles up. */
18181 static bool
18183 {
18188 {
18191 }
18193 {
18197 }
18199 }
18201 /* Given two function templates PAT1 and PAT2, return:
18203 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18204 -1 if PAT2 is more specialized than PAT1.
18205 0 if neither is more specialized.
18207 LEN indicates the number of parameters we should consider
18208 (defaulted parameters should not be considered).
18210 The 1998 std underspecified function template partial ordering, and
18211 DR214 addresses the issue. We take pairs of arguments, one from
18212 each of the templates, and deduce them against each other. One of
18213 the templates will be more specialized if all the *other*
18214 template's arguments deduce against its arguments and at least one
18215 of its arguments *does* *not* deduce against the other template's
18216 corresponding argument. Deduction is done as for class templates.
18217 The arguments used in deduction have reference and top level cv
18218 qualifiers removed. Iff both arguments were originally reference
18219 types *and* deduction succeeds in both directions, an lvalue reference
18220 wins against an rvalue reference and otherwise the template
18221 with the more cv-qualified argument wins for that pairing (if
18222 neither is more cv-qualified, they both are equal). Unlike regular
18223 deduction, after all the arguments have been deduced in this way,
18224 we do *not* verify the deduced template argument values can be
18225 substituted into non-deduced contexts.
18227 The logic can be a bit confusing here, because we look at deduce1 and
18228 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18229 can find template arguments for pat1 to make arg1 look like arg2, that
18230 means that arg2 is at least as specialized as arg1. */
18232 int
18234 {
18247 /* Remove the this parameter from non-static member functions. If
18248 one is a non-static member function and the other is not a static
18249 member function, remove the first parameter from that function
18250 also. This situation occurs for operator functions where we
18251 locate both a member function (with this pointer) and non-member
18252 operator (with explicit first operand). */
18254 {
18259 }
18261 {
18264 {
18265 len--;
18267 }
18268 }
18270 /* If only one is a conversion operator, they are unordered. */
18274 /* Consider the return type for a conversion function */
18276 {
18279 len++;
18280 }
18282 processing_template_decl++;
18288 /* Stop when an ellipsis is seen. */
18290 {
18301 {
18302 /* When both arguments are pack expansions, we need only
18303 unify the patterns themselves. */
18307 /* This is the last comparison we need to do. */
18309 }
18312 {
18316 }
18319 {
18323 }
18329 {
18335 /* Setup the parameter vector, which contains only ARG1. */
18338 /* Setup the argument vector, which contains the remaining
18339 arguments. */
18348 /* We cannot deduce in the other direction, because ARG1 is
18349 a pack expansion but ARG2 is not. */
18351 }
18353 {
18359 /* Setup the parameter vector, which contains only ARG1. */
18362 /* Setup the argument vector, which contains the remaining
18363 arguments. */
18372 /* We cannot deduce in the other direction, because ARG2 is
18373 a pack expansion but ARG1 is not.*/
18375 }
18377 else
18378 {
18379 /* The normal case, where neither argument is a pack
18380 expansion. */
18387 }
18389 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18390 arg2, then arg2 is not as specialized as arg1. */
18396 /* "If, for a given type, deduction succeeds in both directions
18397 (i.e., the types are identical after the transformations above)
18398 and both P and A were reference types (before being replaced with
18399 the type referred to above):
18400 - if the type from the argument template was an lvalue reference and
18401 the type from the parameter template was not, the argument type is
18402 considered to be more specialized than the other; otherwise,
18403 - if the type from the argument template is more cv-qualified
18404 than the type from the parameter template (as described above),
18405 the argument type is considered to be more specialized than the other;
18406 otherwise,
18407 - neither type is more specialized than the other." */
18410 {
18412 {
18415 else
18417 }
18419 {
18424 }
18425 }
18428 /* We've failed to deduce something in either direction.
18429 These must be unordered. */
18434 /* We have already processed all of the arguments in our
18435 handing of the pack expansion type. */
18440 }
18442 /* "In most cases, all template parameters must have values in order for
18443 deduction to succeed, but for partial ordering purposes a template
18444 parameter may remain without a value provided it is not used in the
18445 types being used for partial ordering."
18447 Thus, if we are missing any of the targs1 we need to substitute into
18448 origs1, then pat2 is not as specialized as pat1. This can happen when
18449 there is a nondeduced context. */
18455 processing_template_decl--;
18457 /* All things being equal, if the next argument is a pack expansion
18458 for one function but not for the other, prefer the
18459 non-variadic function. FIXME this is bogus; see c++/41958. */
18463 {
18466 }
18472 else
18474 }
18476 /* Determine which of two partial specializations of TMPL is more
18477 specialized.
18479 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18480 to the first partial specialization. The TREE_VALUE is the
18481 innermost set of template parameters for the partial
18482 specialization. PAT2 is similar, but for the second template.
18484 Return 1 if the first partial specialization is more specialized;
18485 -1 if the second is more specialized; 0 if neither is more
18486 specialized.
18488 See [temp.class.order] for information about determining which of
18489 two templates is more specialized. */
18491 static int
18493 {
18494 tree targs;
18502 /* Just like what happens for functions, if we are ordering between
18503 different class template specializations, we may encounter dependent
18504 types in the arguments, and we need our dependency check functions
18505 to behave correctly. */
18511 {
18514 }
18520 {
18523 }
18526 /* In the case of a tie where at least one of the class templates
18527 has a parameter pack at the end, the template with the most
18528 non-packed parameters wins. */
18530 && any_deductions
18533 {
18539 /* We don't count the pack expansion at the end. */
18549 }
18552 }
18554 /* Return the template arguments that will produce the function signature
18555 DECL from the function template FN, with the explicit template
18556 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18557 also match. Return NULL_TREE if no satisfactory arguments could be
18558 found. */
18560 static tree
18562 {
18566 tree decl_arg_types;
18569 tree arg;
18573 /* Never do unification on the 'this' parameter. */
18594 }
18596 /* Return the innermost template arguments that, when applied to a partial
18597 specialization of TMPL whose innermost template parameters are
18598 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18599 ARGS.
18601 For example, suppose we have:
18603 template <class T, class U> struct S {};
18604 template <class T> struct S<T*, int> {};
18606 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18607 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18608 int}. The resulting vector will be {double}, indicating that `T'
18609 is bound to `double'. */
18611 static tree
18613 {
18615 tree deduced_args;
18616 tree innermost_deduced_args;
18620 {
18624 innermost_deduced_args);
18625 }
18626 else
18639 /* Verify that nondeduced template arguments agree with the type
18640 obtained from argument deduction.
18642 For example:
18644 struct A { typedef int X; };
18645 template <class T, class U> struct C {};
18646 template <class T> struct C<T, typename T::X> {};
18648 Then with the instantiation `C<A, int>', we can deduce that
18649 `T' is `A' but unify () does not check whether `typename T::X'
18650 is `int'. */
18656 /* We only need to check the innermost arguments; the other
18657 arguments will always agree. */
18662 /* Now that we have bindings for all of the template arguments,
18663 ensure that the arguments deduced for the template template
18664 parameters have compatible template parameter lists. See the use
18665 of template_template_parm_bindings_ok_p in fn_type_unification
18666 for more information. */
18671 }
18673 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18674 Return the TREE_LIST node with the most specialized template, if
18675 any. If there is no most specialized template, the error_mark_node
18676 is returned.
18678 Note that this function does not look at, or modify, the
18679 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18680 returned is one of the elements of INSTANTIATIONS, callers may
18681 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18682 and retrieve it from the value returned. */
18684 tree
18686 {
18693 {
18699 fate--;
18704 fate++;
18709 {
18710 /* Equally specialized, move to next function. If there
18711 is no next function, nothing's most specialized. */
18716 }
18717 }
18720 /* Now verify that champ is better than everything earlier in the
18721 instantiation list. */
18729 {
18732 }
18734 processing_template_decl--;
18740 }
18742 /* If DECL is a specialization of some template, return the most
18743 general such template. Otherwise, returns NULL_TREE.
18745 For example, given:
18747 template <class T> struct S { template <class U> void f(U); };
18749 if TMPL is `template <class U> void S<int>::f(U)' this will return
18750 the full template. This function will not trace past partial
18751 specializations, however. For example, given in addition:
18753 template <class T> struct S<T*> { template <class U> void f(U); };
18755 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18756 `template <class T> template <class U> S<T*>::f(U)'. */
18758 tree
18760 {
18761 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
18762 an immediate specialization. */
18764 {
18768 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
18769 template friend. */
18774 }
18776 /* Look for more and more general templates. */
18778 {
18779 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18780 (See cp-tree.h for details.) */
18788 /* Stop if we run into an explicitly specialized class template. */
18795 }
18798 }
18800 /* Return the most specialized of the class template partial
18801 specializations which can produce TYPE, a specialization of some class
18802 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
18803 a _TYPE node corresponding to the partial specialization, while the
18804 TREE_PURPOSE is the set of template arguments that must be
18805 substituted into the TREE_TYPE in order to generate TYPE.
18807 If the choice of partial specialization is ambiguous, a diagnostic
18808 is issued, and the error_mark_node is returned. If there are no
18809 partial specializations matching TYPE, then NULL_TREE is
18810 returned, indicating that the primary template should be used. */
18812 static tree
18814 {
18816 tree t;
18817 tree champ;
18826 /* For determining which partial specialization to use, only the
18827 innermost args are interesting. */
18829 {
18832 }
18835 {
18836 tree partial_spec_args;
18837 tree spec_args;
18846 {
18847 /* Discard the outer levels of args, and then substitute in the
18848 template args from the enclosing class. */
18850 partial_spec_args = tsubst_template_args
18853 /* And the same for the partial specialization TEMPLATE_DECL. */
18855 }
18857 partial_spec_args =
18859 partial_spec_args,
18873 partial_spec_args,
18874 args);
18876 {
18881 }
18882 }
18892 {
18895 ;
18896 else
18897 {
18899 {
18902 {
18905 }
18906 }
18908 }
18909 }
18913 {
18916 {
18919 }
18920 }
18923 {
18931 {
18934 }
18937 }
18940 }
18942 /* Explicitly instantiate DECL. */
18944 void
18946 {
18951 /* An error occurred, for which grokdeclarator has already issued
18952 an appropriate message. */
18955 {
18958 }
18960 {
18961 /* There is an asymmetry here in the way VAR_DECLs and
18962 FUNCTION_DECLs are handled by grokdeclarator. In the case of
18963 the latter, the DECL we get back will be marked as a
18964 template instantiation, and the appropriate
18965 DECL_TEMPLATE_INFO will be set up. This does not happen for
18966 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
18967 should handle VAR_DECLs as it currently handles
18968 FUNCTION_DECLs. */
18970 {
18973 }
18976 {
18979 }
18981 {
18986 }
18987 }
18989 {
18992 }
18993 else
18996 /* Check for various error cases. Note that if the explicit
18997 instantiation is valid the RESULT will currently be marked as an
18998 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
18999 until we get here. */
19002 {
19003 /* DR 259 [temp.spec].
19005 Both an explicit instantiation and a declaration of an explicit
19006 specialization shall not appear in a program unless the explicit
19007 instantiation follows a declaration of the explicit specialization.
19009 For a given set of template parameters, if an explicit
19010 instantiation of a template appears after a declaration of an
19011 explicit specialization for that template, the explicit
19012 instantiation has no effect. */
19014 }
19016 {
19017 /* [temp.spec]
19019 No program shall explicitly instantiate any template more
19020 than once.
19022 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19023 the first instantiation was `extern' and the second is not,
19024 and EXTERN_P for the opposite case. */
19027 /* If an "extern" explicit instantiation follows an ordinary
19028 explicit instantiation, the template is instantiated. */
19031 }
19033 {
19036 }
19038 {
19041 }
19044 ;
19046 {
19049 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19052 }
19053 else
19061 }
19063 static void
19065 {
19071 {
19074 }
19075 }
19077 /* Called from do_type_instantiation through binding_table_foreach to
19078 do recursive instantiation for the type bound in ENTRY. */
19079 static void
19081 {
19087 }
19089 /* Called from do_type_instantiation to instantiate a member
19090 (a member function or a static member variable) of an
19091 explicitly instantiated class template. */
19092 static void
19094 {
19099 }
19101 /* Perform an explicit instantiation of template class T. STORAGE, if
19102 non-null, is the RID for extern, inline or static. COMPLAIN is
19103 nonzero if this is called from the parser, zero if called recursively,
19104 since the standard is unclear (as detailed below). */
19106 void
19108 {
19118 {
19119 tree tmpl =
19123 else
19126 }
19131 {
19134 t);
19136 }
19139 {
19141 {
19143 {
19146 "ISO C++ 1998 forbids the use of %<extern%> on "
19148 }
19149 else
19151 "ISO C++ forbids the use of %qE"
19153 }
19161 else
19162 {
19164 storage);
19166 }
19167 }
19170 {
19171 /* DR 259 [temp.spec].
19173 Both an explicit instantiation and a declaration of an explicit
19174 specialization shall not appear in a program unless the explicit
19175 instantiation follows a declaration of the explicit specialization.
19177 For a given set of template parameters, if an explicit
19178 instantiation of a template appears after a declaration of an
19179 explicit specialization for that template, the explicit
19180 instantiation has no effect. */
19182 }
19184 {
19185 /* [temp.spec]
19187 No program shall explicitly instantiate any template more
19188 than once.
19190 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19191 instantiation was `extern'. If EXTERN_P then the second is.
19192 These cases are OK. */
19199 /* If we've already instantiated the template, just return now. */
19202 }
19210 {
19211 tree tmp;
19213 /* In contrast to implicit instantiation, where only the
19214 declarations, and not the definitions, of members are
19215 instantiated, we have here:
19217 [temp.explicit]
19219 The explicit instantiation of a class template specialization
19220 implies the instantiation of all of its members not
19221 previously explicitly specialized in the translation unit
19222 containing the explicit instantiation.
19224 Of course, we can't instantiate member template classes, since
19225 we don't have any arguments for them. Note that the standard
19226 is unclear on whether the instantiation of the members are
19227 *explicit* instantiations or not. However, the most natural
19228 interpretation is that it should be an explicit instantiation. */
19243 }
19244 }
19246 /* Given a function DECL, which is a specialization of TMPL, modify
19247 DECL to be a re-instantiation of TMPL with the same template
19248 arguments. TMPL should be the template into which tsubst'ing
19249 should occur for DECL, not the most general template.
19251 One reason for doing this is a scenario like this:
19253 template <class T>
19254 void f(const T&, int i);
19256 void g() { f(3, 7); }
19258 template <class T>
19259 void f(const T& t, const int i) { }
19261 Note that when the template is first instantiated, with
19262 instantiate_template, the resulting DECL will have no name for the
19263 first parameter, and the wrong type for the second. So, when we go
19264 to instantiate the DECL, we regenerate it. */
19266 static void
19268 {
19269 /* The arguments used to instantiate DECL, from the most general
19270 template. */
19271 tree args;
19272 tree code_pattern;
19277 /* Make sure that we can see identifiers, and compute access
19278 correctly. */
19282 {
19283 tree decl_parm;
19284 tree pattern_parm;
19285 tree specs;
19299 specs);
19301 /* Merge parameter declarations. */
19304 pattern_parm
19308 {
19309 tree parm_type;
19310 tree attributes;
19315 NULL_TREE);
19321 {
19324 }
19327 }
19328 /* Merge any parameters that match with the function parameter
19329 pack. */
19331 {
19333 tree expanded_types;
19334 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19335 the parameters in this function parameter pack. */
19340 {
19341 tree parm_type;
19342 tree attributes;
19345 /* Rename the parameter to include the index. */
19354 {
19357 }
19359 }
19360 }
19361 /* Merge additional specifiers from the CODE_PATTERN. */
19365 }
19367 {
19375 }
19376 else
19380 }
19382 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19383 substituted to get DECL. */
19385 tree
19387 {
19390 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19391 for the instantiation. This is not always the most general
19392 template. Consider, for example:
19394 template <class T>
19395 struct S { template <class U> void f();
19396 template <> void f<int>(); };
19398 and an instantiation of S<double>::f<int>. We want TD to be the
19399 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19401 more general template. */
19403 /* We must also deal with friend templates. Given:
19405 template <class T> struct S {
19406 template <class U> friend void f() {};
19407 };
19409 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19410 so far as the language is concerned, but that's still
19411 where we get the pattern for the instantiation from. On
19412 other hand, if the definition comes outside the class, say:
19414 template <class T> struct S {
19415 template <class U> friend void f();
19416 };
19417 template <class U> friend void f() {}
19419 we don't need to look any further. That's what the check for
19420 DECL_INITIAL is for. */
19424 {
19425 /* The present template, TD, should not be a definition. If it
19426 were a definition, we should be using it! Note that we
19427 cannot restructure the loop to just keep going until we find
19428 a template with a definition, since that might go too far if
19429 a specialization was declared, but not defined. */
19433 /* Fetch the more general template. */
19435 }
19438 }
19440 /* Returns true if we need to instantiate this template instance even if we
19441 know we aren't going to emit it.. */
19443 bool
19445 {
19446 /* We always instantiate inline functions so that we can inline them. An
19447 explicit instantiation declaration prohibits implicit instantiation of
19448 non-inline functions. With high levels of optimization, we would
19449 normally inline non-inline functions -- but we're not allowed to do
19450 that for "extern template" functions. Therefore, we check
19451 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19455 /* And we need to instantiate static data members so that
19456 their initializers are available in integral constant
19457 expressions. */
19460 }
19462 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19463 instantiate it now, modifying TREE_TYPE (fn). */
19465 void
19467 {
19470 /* Don't instantiate a noexcept-specification from template context. */
19485 {
19487 {
19502 }
19503 else
19505 }
19506 else
19507 {
19508 /* This is an implicitly declared function, so NOEX is a list of
19509 other functions to evaluate and merge. */
19510 tree elt;
19513 {
19515 tree subspec;
19519 }
19520 }
19525 {
19528 else
19530 }
19531 }
19533 /* Produce the definition of D, a _DECL generated from a template. If
19534 DEFER_OK is nonzero, then we don't have to actually do the
19535 instantiation now; we just have to do it sometime. Normally it is
19536 an error if this is an explicit instantiation but D is undefined.
19537 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19538 explicitly instantiated class template. */
19540 tree
19543 {
19545 tree gen_args;
19546 tree args;
19547 tree td;
19548 tree code_pattern;
19549 tree spec;
19550 tree gen_tmpl;
19556 tree fn_context;
19559 /* This function should only be used to instantiate templates for
19560 functions and static member variables. */
19563 /* Variables are never deferred; if instantiation is required, they
19564 are instantiated right away. That allows for better code in the
19565 case that an expression refers to the value of the variable --
19566 if the variable has a constant value the referring expression can
19567 take advantage of that fact. */
19572 /* Don't instantiate cloned functions. Instead, instantiate the
19573 functions they cloned. */
19581 /* D has already been instantiated or explicitly specialized, so
19582 there's nothing for us to do here.
19584 It might seem reasonable to check whether or not D is an explicit
19585 instantiation, and, if so, stop here. But when an explicit
19586 instantiation is deferred until the end of the compilation,
19587 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19588 the instantiation. */
19591 /* Check to see whether we know that this template will be
19592 instantiated in some other file, as with "extern template"
19593 extension. */
19596 /* In general, we do not instantiate such templates. */
19604 /* We should already have the extra args. */
19607 /* And what's in the hash table should match D. */
19611 /* This needs to happen before any tsubsting. */
19617 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19618 for the instantiation. */
19622 /* We should never be trying to instantiate a member of a class
19623 template or partial specialization. */
19628 /* In the case of a friend template whose definition is provided
19629 outside the class, we may have too many arguments. Drop the
19630 ones we don't need. The same is true for specializations. */
19631 args = get_innermost_template_args
19633 else
19639 else
19642 /* We may be in the middle of deferred access check. Disable it now. */
19645 /* Unless an explicit instantiation directive has already determined
19646 the linkage of D, remember that a definition is available for
19647 this entity. */
19657 /* If D is a member of an explicitly instantiated class template,
19658 and no definition is available, treat it like an implicit
19659 instantiation. */
19662 {
19663 /* Leave linkage flags alone on instantiations with anonymous
19664 visibility. */
19666 {
19669 }
19671 }
19676 /* Defer all other templates, unless we have been explicitly
19677 forbidden from doing so. */
19679 template. */
19680 ! pattern_defined
19681 /* If it's OK to postpone instantiation, do so. */
19682 || defer_ok
19683 /* If this is a static data member that will be defined
19684 elsewhere, we don't want to instantiate the entire data
19685 member, but we do want to instantiate the initializer so that
19686 we can substitute that elsewhere. */
19688 {
19689 /* The definition of the static data member is now required so
19690 we must substitute the initializer. */
19694 {
19695 tree ns;
19696 tree init;
19703 args,
19706 /* Make sure the initializer is still constant, in case of
19707 circular dependency (template/instantiate6.C). */
19708 const_init
19712 LOOKUP_ONLYCONVERTING);
19715 }
19717 /* We restore the source position here because it's used by
19718 add_pending_template. */
19724 /* [temp.explicit]
19726 The definition of a non-exported function template, a
19727 non-exported member function template, or a non-exported
19728 member function or static data member of a class template
19729 shall be present in every translation unit in which it is
19730 explicitly instantiated. */
19734 /* If we're in unevaluated context, we just wanted to get the
19735 constant value; this isn't an odr use, so don't queue
19736 a full instantiation. */
19739 /* ??? Historically, we have instantiated inline functions, even
19740 when marked as "extern template". */
19744 }
19745 /* Tell the repository that D is available in this translation unit
19746 -- and see if it is supposed to be instantiated here. */
19748 {
19749 /* In a PCH file, despite the fact that the repository hasn't
19750 requested instantiation in the PCH it is still possible that
19751 an instantiation will be required in a file that includes the
19752 PCH. */
19755 /* Instantiate inline functions so that the inliner can do its
19756 job, even though we'll not be emitting a copy of this
19757 function. */
19760 }
19766 else
19767 {
19772 }
19774 /* Mark D as instantiated so that recursive calls to
19775 instantiate_decl do not try to instantiate it again. */
19778 /* Regenerate the declaration in case the template has been modified
19779 by a subsequent redeclaration. */
19782 /* We already set the file and line above. Reset them now in case
19783 they changed as a result of calling regenerate_decl_from_template. */
19787 {
19788 tree init;
19791 /* Clear out DECL_RTL; whatever was there before may not be right
19792 since we've reset the type of the declaration. */
19796 /* The initializer is placed in DECL_INITIAL by
19797 regenerate_decl_from_template so we don't need to
19798 push/pop_access_scope again here. Pull it out so that
19799 cp_finish_decl can process it. */
19804 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
19805 initializer. That function will defer actual emission until
19806 we have a chance to determine linkage. */
19809 /* Enter the scope of D so that access-checking works correctly. */
19814 }
19818 {
19820 tree subst_decl;
19821 tree tmpl_parm;
19822 tree spec_parm;
19825 /* Save away the current list, in case we are instantiating one
19826 template from within the body of another. */
19829 /* Set up the list of local specializations. */
19832 /* Set up context. */
19836 else
19839 /* Some typedefs referenced from within the template code need to be
19840 access checked at template instantiation time, i.e now. These
19841 types were added to the template at parsing time. Let's get those
19842 and perform the access checks then. */
19844 gen_args);
19846 /* Create substitution entries for the parameters. */
19851 {
19855 }
19857 {
19859 {
19862 }
19863 else
19864 {
19865 /* Register the (value) argument pack as a specialization of
19866 TMPL_PARM, then move on. */
19869 }
19870 }
19873 /* Substitute into the body of the function. */
19877 else
19878 {
19883 /* Set the current input_location to the end of the function
19884 so that finish_function knows where we are. */
19885 input_location
19888 /* Remember if we saw an infinite loop in the template. */
19889 current_function_infinite_loop
19891 }
19893 /* We don't need the local specializations any more. */
19897 /* Finish the function. */
19901 else
19902 {
19905 }
19909 }
19911 /* We're not deferring instantiation any more. */
19919 out:
19929 }
19931 /* Run through the list of templates that we wish we could
19932 instantiate, and instantiate any we can. RETRIES is the
19933 number of times we retry pending template instantiation. */
19935 void
19937 {
19941 /* Instantiating templates may trigger vtable generation. This in turn
19942 may require further template instantiations. We place a limit here
19943 to avoid infinite loop. */
19945 {
19949 " instantiating %q+D, possibly from virtual table generation"
19953 /* Pretend that we defined it. */
19956 }
19958 do
19959 {
19964 {
19969 {
19970 tree fn;
19973 {
19977 fn;
19985 }
19988 }
19989 else
19990 {
19993 {
19994 instantiation
20000 }
20004 }
20007 /* If INSTANTIATION has been instantiated, then we don't
20008 need to consider it again in the future. */
20010 else
20011 {
20014 }
20017 }
20019 }
20023 }
20025 /* Substitute ARGVEC into T, which is a list of initializers for
20026 either base class or a non-static data member. The TREE_PURPOSEs
20027 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20028 instantiate_decl. */
20030 static tree
20032 {
20036 {
20037 tree decl;
20038 tree init;
20044 {
20045 tree expr;
20046 tree arg;
20048 /* Expand the base class expansion type into separate base
20049 classes. */
20051 tf_warning_or_error,
20052 NULL_TREE);
20056 /* We'll be building separate TREE_LISTs of arguments for
20057 each base. */
20063 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20064 expand each argument in the TREE_VALUE of t. */
20071 /* VOID_TYPE_NODE is used to indicate
20072 value-initialization. */
20073 {
20076 }
20077 else
20078 {
20079 /* Substitute parameter packs into each argument in the
20080 TREE_LIST. */
20083 {
20084 tree expanded_exprs;
20086 /* Expand the argument. */
20088 expanded_exprs
20090 tf_warning_or_error,
20091 NULL_TREE);
20095 /* Prepend each of the expanded expressions to the
20096 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20098 {
20103 }
20104 }
20107 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20108 since we built them backwards. */
20110 {
20113 }
20114 }
20115 }
20118 {
20120 {
20124 }
20125 else
20126 {
20127 tree tmp;
20142 /* If we had an initializer but it instantiated to nothing,
20143 value-initialize the object. This will only occur when
20144 the initializer was a pack expansion where the parameter
20145 packs used in that expansion were of length zero. */
20148 }
20151 {
20155 }
20156 }
20157 }
20159 }
20161 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20163 static void
20165 {
20170 else
20172 }
20174 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20175 is the instantiation (which should have been created with
20176 start_enum) and ARGS are the template arguments to use. */
20178 static void
20180 {
20181 tree e;
20187 {
20188 tree value;
20189 tree decl;
20192 /* Note that in a template enum, the TREE_VALUE is the
20193 CONST_DECL, not the corresponding INTEGER_CST. */
20198 /* Give this enumeration constant the correct access. */
20201 /* Actually build the enumerator itself. */
20202 build_enumerator
20204 }
20214 }
20216 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20217 its type -- but without substituting the innermost set of template
20218 arguments. So, innermost set of template parameters will appear in
20219 the type. */
20221 tree
20223 {
20224 tree fn_type;
20225 tree tmpl;
20226 tree targs;
20227 tree tparms;
20235 /* There should be as many levels of arguments as there are levels
20236 of parameters. */
20242 /* No substitution is necessary. */
20243 ;
20244 else
20245 {
20247 tree partial_args;
20249 /* Replace the innermost level of the TARGS with NULL_TREEs to
20250 let tsubst know not to substitute for those parameters. */
20259 /* Make sure that we can see identifiers, and compute access
20260 correctly. */
20264 /* Now, do the (partial) substitution to figure out the
20265 appropriate function type. */
20269 /* Substitute into the template parameters to obtain the real
20270 innermost set of parameters. This step is important if the
20271 innermost set of template parameters contains value
20272 parameters whose types depend on outer template parameters. */
20277 }
20280 }
20282 /* Return truthvalue if we're processing a template different from
20283 the last one involved in diagnostics. */
20284 int
20286 {
20288 }
20290 /* Remember current template involved in diagnostics. */
20291 void
20293 {
20295 }
20299 {
20301 }
20303 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20304 type. Return zero for ok, nonzero for disallowed. Issue error and
20305 warning messages under control of COMPLAIN. */
20307 static int
20309 {
20326 {
20329 else
20331 type);
20332 }
20334 }
20336 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20337 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20339 static bool
20341 {
20342 tree scope;
20344 /* [temp.dep.type]
20346 A type is dependent if it is:
20348 -- a template parameter. Template template parameters are types
20349 for us (since TYPE_P holds true for them) so we handle
20350 them here. */
20354 /* -- a qualified-id with a nested-name-specifier which contains a
20355 class-name that names a dependent type or whose unqualified-id
20356 names a dependent type. */
20359 /* -- a cv-qualified type where the cv-unqualified type is
20360 dependent. */
20362 /* -- a compound type constructed from any dependent type. */
20372 {
20373 tree arg_type;
20378 arg_type;
20383 }
20384 /* -- an array type constructed from any dependent type or whose
20385 size is specified by a constant expression that is
20386 value-dependent.
20388 We checked for type- and value-dependence of the bounds in
20389 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20391 {
20396 }
20398 /* -- a template-id in which either the template name is a template
20399 parameter ... */
20402 /* ... or any of the template arguments is a dependent type or
20403 an expression that is type-dependent or value-dependent. */
20405 && (any_dependent_template_arguments_p
20409 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20410 dependent; if the argument of the `typeof' expression is not
20411 type-dependent, then it should already been have resolved. */
20417 /* A template argument pack is dependent if any of its packed
20418 arguments are. */
20420 {
20426 }
20428 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20429 be template parameters. */
20433 /* The standard does not specifically mention types that are local
20434 to template functions or local classes, but they should be
20435 considered dependent too. For example:
20437 template <int I> void f() {
20438 enum E { a = I };
20439 S<sizeof (E)> s;
20440 }
20442 The size of `E' cannot be known until the value of `I' has been
20443 determined. Therefore, `E' must be considered dependent. */
20447 /* Don't use type_dependent_expression_p here, as it can lead
20448 to infinite recursion trying to determine whether a lambda
20449 nested in a lambda is dependent (c++/47687). */
20453 && (any_dependent_template_arguments_p
20457 /* Other types are non-dependent. */
20459 }
20461 /* Returns TRUE if TYPE is dependent, in the sense of
20462 [temp.dep.type]. Note that a NULL type is considered dependent. */
20464 bool
20466 {
20467 /* If there are no template parameters in scope, then there can't be
20468 any dependent types. */
20470 {
20471 /* If we are not processing a template, then nobody should be
20472 providing us with a dependent type. */
20476 }
20478 /* If the type is NULL, we have not computed a type for the entity
20479 in question; in that case, the type is dependent. */
20483 /* Erroneous types can be considered non-dependent. */
20487 /* If we have not already computed the appropriate value for TYPE,
20488 do so now. */
20490 {
20493 }
20496 }
20498 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20499 lookup. In other words, a dependent type that is not the current
20500 instantiation. */
20502 bool
20504 {
20507 }
20509 /* T is a SCOPE_REF; return whether we need to consider it
20510 instantiation-dependent so that we can check access at instantiation
20511 time even though we know which member it resolves to. */
20513 static bool
20515 {
20521 else
20523 }
20525 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20526 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20527 expression. */
20529 /* Note that this predicate is not appropriate for general expressions;
20530 only constant expressions (that satisfy potential_constant_expression)
20531 can be tested for value dependence. */
20533 bool
20535 {
20539 /* A name declared with a dependent type. */
20544 {
20546 /* A name that has not been looked up -- must be dependent. */
20550 /* A non-type template parm. */
20554 /* A non-type template parm. */
20560 /* A constant with literal type and is initialized
20561 with an expression that is value-dependent.
20563 Note that a non-dependent parenthesized initializer will have
20564 already been replaced with its constant value, so if we see
20565 a TREE_LIST it must be dependent. */
20578 /* These expressions are value-dependent if the type to which
20579 the cast occurs is dependent or the expression being casted
20580 is value-dependent. */
20581 {
20587 /* A functional cast has a list of operands. */
20590 {
20591 /* If there are no operands, it must be an expression such
20592 as "int()". This should not happen for aggregate types
20593 because it would form non-constant expressions. */
20598 }
20604 }
20609 /* FALLTHRU */
20612 /* A `sizeof' expression is value-dependent if the operand is
20613 type-dependent or is a pack expansion. */
20622 /* An 'encode' expression is value-dependent if the operand is
20623 type-dependent. */
20632 /* All instantiation-dependent expressions should also be considered
20633 value-dependent. */
20641 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20642 is value-dependent. */
20643 {
20652 }
20655 {
20659 }
20670 {
20674 }
20677 {
20684 {
20686 /* In a call to a constexpr member function, look through the
20687 implicit ADDR_EXPR on the object argument so that it doesn't
20688 cause the call to be considered value-dependent. We also
20689 look through it in potential_constant_expression. */
20696 }
20698 }
20701 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20702 type-dependent. */
20706 {
20708 tree val;
20713 }
20716 /* Treat a GNU statement expression as dependent to avoid crashing
20717 under fold_non_dependent_expr; it can't be constant. */
20721 /* A constant expression is value-dependent if any subexpression is
20722 value-dependent. */
20724 {
20731 {
20735 {
20738 /* In some cases, some of the operands may be missing.l
20739 (For example, in the case of PREDECREMENT_EXPR, the
20740 amount to increment by may be missing.) That doesn't
20741 make the expression dependent. */
20744 }
20745 }
20749 }
20751 }
20753 /* The expression is not value-dependent. */
20755 }
20757 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20758 [temp.dep.expr]. Note that an expression with no type is
20759 considered dependent. Other parts of the compiler arrange for an
20760 expression with type-dependent subexpressions to have no type, so
20761 this function doesn't have to be fully recursive. */
20763 bool
20765 {
20772 /* An unresolved name is always dependent. */
20776 /* Some expression forms are never type-dependent. */
20789 /* The types of these expressions depends only on the type to which
20790 the cast occurs. */
20799 /* The types of these expressions depends only on the type created
20800 by the expression. */
20803 {
20804 /* For NEW_EXPR tree nodes created inside a template, either
20805 the object type itself or a TREE_LIST may appear as the
20806 operand 1. */
20809 /* This is an array type. We need to check array dimensions
20810 as well. */
20812 || value_dependent_expression_p
20814 else
20816 }
20819 {
20823 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
20824 contains an identifier associated by name lookup with one or more
20825 declarations declared with a dependent type, or...a
20826 nested-name-specifier or qualified-id that names a member of an
20827 unknown specialization. */
20830 }
20835 && (any_dependent_template_arguments_p
20847 {
20848 tree elt;
20852 {
20855 }
20857 }
20859 /* A static data member of the current instantiation with incomplete
20860 array type is type-dependent, as the definition and specializations
20861 can have different bounds. */
20868 /* An array of unknown bound depending on a variadic parameter, eg:
20870 template<typename... Args>
20871 void foo (Args... args)
20872 {
20873 int arr[] = { args... };
20874 }
20876 template<int... vals>
20877 void bar ()
20878 {
20879 int arr[] = { vals... };
20880 }
20882 If the array has no length and has an initializer, it must be that
20883 we couldn't determine its length in cp_complete_array_type because
20884 it is dependent. */
20892 {
20897 {
20903 }
20904 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
20908 /* Always dependent, on the number of arguments if nothing else. */
20916 {
20921 }
20926 {
20930 }
20932 }
20937 }
20939 /* walk_tree callback function for instantiation_dependent_expression_p,
20940 below. Returns non-zero if a dependent subexpression is found. */
20942 static tree
20945 {
20947 {
20948 /* We don't have to worry about decltype currently because decltype
20949 of an instantiation-dependent expr is a dependent type. This
20950 might change depending on the resolution of DR 1172. */
20953 }
20956 {
20957 /* Don't treat an argument list as dependent just because it has no
20958 TREE_TYPE. */
20965 /* A constant with a dependent initializer is dependent. */
20973 /* Handle expressions with type operands. */
20978 {
20983 {
20986 else
20987 {
20990 }
20991 }
20993 }
21005 /* In a template, finish_class_member_access_expr creates a
21006 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21007 type-dependent, so that we can check access control at
21008 instantiation time (PR 42277). See also Core issue 1273. */
21015 else
21018 /* Treat statement-expressions as dependent. */
21024 }
21028 else
21030 }
21032 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21033 sense defined by the ABI:
21035 "An expression is instantiation-dependent if it is type-dependent
21036 or value-dependent, or it has a subexpression that is type-dependent
21037 or value-dependent." */
21039 bool
21041 {
21042 tree result;
21053 }
21055 /* Like type_dependent_expression_p, but it also works while not processing
21056 a template definition, i.e. during substitution or mangling. */
21058 bool
21060 {
21066 }
21068 /* Returns TRUE if ARGS contains a type-dependent expression. */
21070 bool
21072 {
21074 tree arg;
21077 {
21080 }
21082 }
21084 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21085 expressions) contains any type-dependent expressions. */
21087 bool
21089 {
21095 }
21097 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21098 expressions) contains any value-dependent expressions. */
21100 bool
21102 {
21108 }
21110 /* Returns TRUE if the ARG (a template argument) is dependent. */
21112 bool
21114 {
21118 /* Assume a template argument that was wrongly written by the user
21119 is dependent. This is consistent with what
21120 any_dependent_template_arguments_p [that calls this function]
21121 does. */
21132 {
21136 {
21139 }
21142 }
21145 else
21148 }
21150 /* Returns true if ARGS (a collection of template arguments) contains
21151 any types that require structural equality testing. */
21153 bool
21155 {
21165 {
21168 {
21174 {
21175 /* Look inside the argument pack. */
21178 }
21181 {
21194 }
21195 }
21196 }
21199 }
21201 /* Returns true if ARGS (a collection of template arguments) contains
21202 any dependent arguments. */
21204 bool
21206 {
21216 {
21221 }
21224 }
21226 /* Returns TRUE if the template TMPL is dependent. */
21228 bool
21230 {
21232 {
21234 {
21238 }
21240 }
21242 /* Template template parameters are dependent. */
21246 /* So are names that have not been looked up. */
21249 /* So are member templates of dependent classes. */
21253 }
21255 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21257 bool
21259 {
21262 }
21264 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21265 is dependent. */
21267 bool
21269 {
21276 {
21297 {
21301 }
21305 {
21309 {
21314 }
21315 }
21316 }
21319 }
21321 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21322 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21323 no such TYPE can be found. Note that this function peers inside
21324 uninstantiated templates and therefore should be used only in
21325 extremely limited situations. ONLY_CURRENT_P restricts this
21326 peering to the currently open classes hierarchy (which is required
21327 when comparing types). */
21329 tree
21331 {
21332 tree scope;
21333 tree name;
21334 tree decl;
21336 tree pushed_scope;
21337 tree result;
21342 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21343 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21344 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21345 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21346 identifier of the TYPENAME_TYPE anymore.
21347 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21348 TYPENAME_TYPE instead, we avoid messing up with a possible
21349 typedef variant case. */
21352 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21353 it first before we can figure out what NAME refers to. */
21355 {
21357 /* Given a class template A with a dependent base with nested type C,
21358 typedef typename A::C::C C will land us here, as trying to resolve
21359 the initial A::C leads to the local C typedef, which leads back to
21360 A::C::C. So we break the recursion now. */
21362 else
21364 }
21365 /* If we don't know what SCOPE refers to, then we cannot resolve the
21366 TYPENAME_TYPE. */
21369 /* If the SCOPE is a template type parameter, we have no way of
21370 resolving the name. */
21373 /* If the SCOPE is not the current instantiation, there's no reason
21374 to look inside it. */
21377 /* If this is a typedef, we don't want to look inside (c++/11987). */
21380 /* If SCOPE isn't the template itself, it will not have a valid
21381 TYPE_FIELDS list. */
21383 /* scope is either the template itself or a compatible instantiation
21384 like X<T>, so look up the name in the original template. */
21386 else
21387 /* scope is a partial instantiation, so we can't do the lookup or we
21388 will lose the template arguments. */
21390 /* Enter the SCOPE so that name lookup will be resolved as if we
21391 were in the class definition. In particular, SCOPE will no
21392 longer be considered a dependent type. */
21394 /* Look up the declaration. */
21396 tf_warning_or_error);
21400 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21401 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21406 {
21410 }
21413 {
21414 tree tmpl;
21415 tree args;
21416 /* Obtain the template and the arguments. */
21419 /* Instantiate the template. */
21425 }
21427 /* Leave the SCOPE. */
21431 /* If we failed to resolve it, return the original typename. */
21435 /* If lookup found a typename type, resolve that too. */
21437 {
21438 /* Ill-formed programs can cause infinite recursion here, so we
21439 must catch that. */
21443 }
21445 /* Qualify the resulting type. */
21451 }
21453 /* EXPR is an expression which is not type-dependent. Return a proxy
21454 for EXPR that can be used to compute the types of larger
21455 expressions containing EXPR. */
21457 tree
21459 {
21460 tree inner_expr;
21462 #ifdef ENABLE_CHECKING
21463 /* Try to get a constant value for all non-dependent expressions in
21464 order to expose bugs in *_dependent_expression_p and constexpr. */
21467 #endif
21469 /* Preserve OVERLOADs; the functions must be available to resolve
21470 types. */
21481 /* There is no need to return a proxy for a variable. */
21484 /* Preserve string constants; conversions from string constants to
21485 "char *" are allowed, even though normally a "const char *"
21486 cannot be used to initialize a "char *". */
21489 /* Preserve arithmetic constants, as an optimization -- there is no
21490 reason to create a new node. */
21493 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21494 There is at least one place where we want to know that a
21495 particular expression is a throw-expression: when checking a ?:
21496 expression, there are special rules if the second or third
21497 argument is a throw-expression. */
21501 /* Don't wrap an initializer list, we need to be able to look inside. */
21505 /* Don't wrap a dummy object, we need to be able to test for it. */
21524 /* If the type is unknown, it can't really be non-dependent */
21527 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21529 }
21531 /* ARGS is a vector of expressions as arguments to a function call.
21532 Replace the arguments with equivalent non-dependent expressions.
21533 This modifies ARGS in place. */
21535 void
21537 {
21539 tree arg;
21542 {
21546 }
21547 }
21549 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21550 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21551 parms. */
21553 static tree
21555 {
21568 }
21570 tree
21572 {
21574 }
21576 tree
21578 {
21580 }
21582 /* Given type ARG, return std::initializer_list<ARG>. */
21584 static tree
21586 {
21587 tree std_init_list = namespace_binding
21589 tree argvec;
21591 {
21595 }
21600 }
21602 /* Replace auto in TYPE with std::initializer_list<auto>. */
21604 static tree
21606 {
21613 }
21615 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21616 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21618 tree
21620 {
21621 tree targs;
21627 /* Defining a subset of type-dependent expressions that we can deduce
21628 from ahead of time isn't worth the trouble. */
21631 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21632 with either a new invented type template parameter U or, if the
21633 initializer is a braced-init-list (8.5.4), with
21634 std::initializer_list<U>. */
21642 {
21648 {
21651 }
21652 }
21653 else
21654 {
21665 {
21667 /* Try again at instantiation time. */
21670 /* If type is error_mark_node a diagnostic must have been
21671 emitted by now. Also, having a mention to '<type error>'
21672 in the diagnostic is not really useful to the user. */
21673 {
21677 else
21679 }
21681 }
21682 }
21684 /* If the list of declarators contains more than one declarator, the type
21685 of each declared variable is determined as described above. If the
21686 type deduced for the template parameter U is not the same in each
21687 deduction, the program is ill-formed. */
21690 {
21696 else
21700 }
21706 }
21708 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21709 result. */
21711 tree
21713 {
21714 tree argvec;
21721 /* For a late-specified return type in a template type-parameter, we
21722 need to add a dummy argument level for its parmlist. */
21723 argvec = add_to_template_args
21728 }
21730 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21731 'decltype(auto)'. */
21733 bool
21735 {
21740 else
21742 }
21744 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21745 a use of `auto'. Returns NULL_TREE otherwise. */
21747 tree
21749 {
21751 }
21753 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21754 'decltype(auto)' or a concept. */
21756 bool
21758 {
21760 }
21762 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21763 a concept identifier) iff TYPE contains a use of a generic type. Returns
21764 NULL_TREE otherwise. */
21766 tree
21768 {
21770 }
21773 /* For a given template T, return the vector of typedefs referenced
21774 in T for which access check is needed at T instantiation time.
21775 T is either a FUNCTION_DECL or a RECORD_TYPE.
21776 Those typedefs were added to T by the function
21777 append_type_to_template_for_access_check. */
21781 {
21782 tree ti;
21793 {
21798 }
21801 }
21803 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
21804 tied to T. That list of typedefs will be access checked at
21805 T instantiation time.
21806 T is either a FUNCTION_DECL or a RECORD_TYPE.
21807 TYPE_DECL is a TYPE_DECL node representing a typedef.
21808 SCOPE is the scope through which TYPE_DECL is accessed.
21809 LOCATION is the location of the usage point of TYPE_DECL.
21811 This function is a subroutine of
21812 append_type_to_template_for_access_check. */
21814 static void
21816 tree type_decl,
21817 tree scope,
21818 location_t location)
21819 {
21820 qualified_typedef_usage_t typedef_usage;
21821 tree ti;
21828 && type_decl
21842 }
21844 /* Append TYPE_DECL to the template TEMPL.
21845 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
21846 At TEMPL instanciation time, TYPE_DECL will be checked to see
21847 if it can be accessed through SCOPE.
21848 LOCATION is the location of the usage point of TYPE_DECL.
21850 e.g. consider the following code snippet:
21852 class C
21853 {
21854 typedef int myint;
21855 };
21857 template<class U> struct S
21858 {
21859 C::myint mi; // <-- usage point of the typedef C::myint
21860 };
21862 S<char> s;
21864 At S<char> instantiation time, we need to check the access of C::myint
21865 In other words, we need to check the access of the myint typedef through
21866 the C scope. For that purpose, this function will add the myint typedef
21867 and the scope C through which its being accessed to a list of typedefs
21868 tied to the template S. That list will be walked at template instantiation
21869 time and access check performed on each typedefs it contains.
21870 Note that this particular code snippet should yield an error because
21871 myint is private to C. */
21873 void
21875 tree type_decl,
21876 tree scope,
21877 location_t location)
21878 {
21884 /* Make sure we don't append the type to the template twice. */
21891 }
21893 /* Convert the generic type parameters in PARM that match the types given in the
21894 range [START_IDX, END_IDX) from the current_template_parms into generic type
21895 packs. */
21897 tree
21899 {
21910 {
21911 /* Create a distinct parameter pack type from the current parm and add it
21912 to the replacement args to tsubst below into the generic function
21913 parameter. */
21928 }
21934 /* If there are more levels then build up the replacement with the outer
21935 template parms. */
21939 replacement);
21942 }
21945 /* Set up the hash tables for template instantiations. */
21947 void
21949 {
21951 hash_specialization,
21952 eq_specializations,
21953 ggc_free);
21955 hash_specialization,
21956 eq_specializations,
21957 ggc_free);
21958 }
21960 /* Print stats about the template hash tables for -fstats. */
21962 void
21964 {
21973 }