| blob | 43e6e706f20a2eee424cdbd1e3a3a9fff081ef8c |
1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992-2013 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
48 /* The type of functions taking a tree, and some additional data, and
49 returning an int. */
52 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
53 instantiations have been deferred, either because their definitions
54 were not yet available, or because we were putting off doing the work. */
58 };
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
80 local variables. */
83 // -------------------------------------------------------------------------- //
84 // Local Specialization Stack
85 //
86 // Implementation of the RAII helper for creating new local
87 // specializations.
90 {
92 }
95 {
98 }
100 /* True if we've recursed into fn_type_unification too many times. */
104 {
105 tree tmpl;
106 tree args;
107 tree spec;
111 htab_t decl_specializations;
114 htab_t type_specializations;
116 /* Contains canonical template parameter types. The vector is indexed by
117 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
118 TREE_LIST, whose TREE_VALUEs contain the canonical template
119 parameters of various types and levels. */
122 #define UNIFY_ALLOW_NONE 0
123 #define UNIFY_ALLOW_MORE_CV_QUAL 1
124 #define UNIFY_ALLOW_LESS_CV_QUAL 2
125 #define UNIFY_ALLOW_DERIVED 4
126 #define UNIFY_ALLOW_INTEGER 8
127 #define UNIFY_ALLOW_OUTER_LEVEL 16
128 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
129 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
132 tbr_incomplete_type,
133 tbr_ambiguous_baseclass,
134 tbr_success
135 };
158 tree);
218 location_t);
224 /* Make the current scope suitable for access checking when we are
225 processing T. T can be FUNCTION_DECL for instantiated function
226 template, VAR_DECL for static member variable, or TYPE_DECL for
227 alias template (needed by instantiate_decl). */
229 static void
231 {
239 else
243 {
244 saved_access_scope = tree_cons
247 }
248 }
250 /* Restore the scope set up by push_access_scope. T is the node we
251 are processing. */
253 static void
255 {
257 {
260 }
264 else
266 }
268 /* Do any processing required when DECL (a member template
269 declaration) is finished. Returns the TEMPLATE_DECL corresponding
270 to DECL, unless it is a specialization, in which case the DECL
271 itself is returned. */
273 tree
275 {
282 {
283 tree type;
291 {
295 }
297 }
301 {
303 {
306 }
307 else
309 }
310 else
314 }
316 /* Create a template info node. */
318 tree
320 {
325 }
327 /* Return the template info node corresponding to T, whatever T is. */
329 tree
331 {
349 }
351 /* Returns the template nesting level of the indicated class TYPE.
353 For example, in:
354 template <class T>
355 struct A
356 {
357 template <class U>
358 struct B {};
359 };
361 A<T>::B<U> has depth two, while A<T> has depth one.
362 Both A<T>::B<int> and A<int>::B<U> have depth one, if
363 they are instantiations, not specializations.
365 This function is guaranteed to return 0 if passed NULL_TREE so
366 that, for example, `template_class_depth (current_class_type)' is
367 always safe. */
369 int
371 {
378 {
384 }
387 }
389 /* Subroutine of maybe_begin_member_template_processing.
390 Returns true if processing DECL needs us to push template parms. */
392 static bool
394 {
400 }
402 /* Subroutine of maybe_begin_member_template_processing.
403 Push the template parms in PARMS, starting from LEVELS steps into the
404 chain, and ending at the beginning, since template parms are listed
405 innermost first. */
407 static void
409 {
417 current_template_parms
423 NULL);
425 {
434 {
441 {
442 /* Make a CONST_DECL as is done in process_template_parm.
443 It is ugly that we recreate this here; the original
444 version built in process_template_parm is no longer
445 available. */
455 }
460 }
461 }
462 }
464 /* Restore the template parameter context for a member template, a
465 friend template defined in a class definition, or a non-template
466 member of template class. */
468 void
470 {
471 tree parms;
481 {
486 {
489 }
492 }
494 /* Remember how many levels of template parameters we pushed so that
495 we can pop them later. */
497 }
499 /* Undo the effects of maybe_begin_member_template_processing. */
501 void
503 {
512 {
516 }
517 }
519 /* Return a new template argument vector which contains all of ARGS,
520 but has as its innermost set of arguments the EXTRA_ARGS. */
522 static tree
524 {
525 tree new_args;
543 }
545 /* Like add_to_template_args, but only the outermost ARGS are added to
546 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
547 (EXTRA_ARGS) levels are added. This function is used to combine
548 the template arguments from a partial instantiation with the
549 template arguments used to attain the full instantiation from the
550 partial instantiation. */
552 static tree
554 {
555 tree new_args;
557 /* If there are more levels of EXTRA_ARGS than there are ARGS,
558 something very fishy is going on. */
561 /* If *all* the new arguments will be the EXTRA_ARGS, just return
562 them. */
566 /* For the moment, we make ARGS look like it contains fewer levels. */
571 /* Now, we restore ARGS to its full dimensions. */
575 }
577 /* Return the N levels of innermost template arguments from the ARGS. */
579 tree
581 {
582 tree new_args;
588 /* If N is 1, just return the innermost set of template arguments. */
592 /* If we're not removing anything, just return the arguments we were
593 given. */
599 /* Make a new set of arguments, not containing the outer arguments. */
606 }
608 /* The inverse of get_innermost_template_args: Return all but the innermost
609 EXTRA_LEVELS levels of template arguments from the ARGS. */
611 static tree
613 {
614 tree new_args;
620 /* If N is 1, just return the outermost set of template arguments. */
624 /* If we're not removing anything, just return the arguments we were
625 given. */
630 /* Make a new set of arguments, not containing the inner arguments. */
637 }
639 /* We've got a template header coming up; push to a new level for storing
640 the parms. */
642 void
644 {
645 /* We use a non-tag-transparent scope here, which causes pushtag to
646 put tags in this scope, rather than in the enclosing class or
647 namespace scope. This is the right thing, since we want
648 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
649 global template class, push_template_decl handles putting the
650 TEMPLATE_DECL into top-level scope. For a nested template class,
651 e.g.:
653 template <class T> struct S1 {
654 template <class T> struct S2 {};
655 };
657 pushtag contains special code to call pushdecl_with_scope on the
658 TEMPLATE_DECL for S2. */
663 }
665 /* This routine is called when a specialization is declared. If it is
666 invalid to declare a specialization here, an error is reported and
667 false is returned, otherwise this routine will return true. */
669 static bool
671 {
674 /* [temp.expl.spec]
676 An explicit specialization shall be declared in the namespace of
677 which the template is a member, or, for member templates, in the
678 namespace of which the enclosing class or enclosing class
679 template is a member. An explicit specialization of a member
680 function, member class or static data member of a class template
681 shall be declared in the namespace of which the class template
682 is a member. */
684 {
687 }
689 /* [temp.expl.spec]
691 In an explicit specialization declaration for a member of a class
692 template or a member template that appears in namespace scope,
693 the member template and some of its enclosing class templates may
694 remain unspecialized, except that the declaration shall not
695 explicitly specialize a class member template if its enclosing
696 class templates are not explicitly specialized as well. */
698 {
701 }
704 }
706 /* We've just seen template <>. */
708 bool
710 {
714 }
716 /* Called at then end of processing a declaration preceded by
717 template<>. */
719 void
721 {
724 }
726 /* Any template <>'s that we have seen thus far are not referring to a
727 function specialization. */
729 void
731 {
734 }
736 /* We've just seen a template header. If SPECIALIZATION is nonzero,
737 it was of the form template <>. */
739 static void
741 {
743 template_header_count++;
744 }
746 /* We're beginning an explicit instantiation. */
748 void
750 {
753 }
756 void
758 {
761 }
763 /* An explicit specialization or partial specialization of TMPL is being
764 declared. Check that the namespace in which the specialization is
765 occurring is permissible. Returns false iff it is invalid to
766 specialize TMPL in the current namespace. */
768 static bool
770 {
773 /* [tmpl.expl.spec]
775 An explicit specialization shall be declared in the namespace of
776 which the template is a member, or, for member templates, in the
777 namespace of which the enclosing class or enclosing class
778 template is a member. An explicit specialization of a member
779 function, member class or static data member of a class template
780 shall be declared in the namespace of which the class template is
781 a member. */
784 {
787 }
789 /* Same or super-using namespace. */
791 else
792 {
796 }
797 }
799 /* SPEC is an explicit instantiation. Check that it is valid to
800 perform this explicit instantiation in the current namespace. */
802 static void
804 {
805 tree ns;
807 /* DR 275: An explicit instantiation shall appear in an enclosing
808 namespace of its template. */
814 }
816 // Returns the TEMPLATE_DECL that defines the partial template specialization
817 // TYPE. If TYPE is not found in the list of partial specializations, then
818 // it must be an explicit specialization.
819 static tree
821 {
826 {
831 }
833 }
835 // Return the template constraints for the template specialization TYPE.
838 {
839 // If TYPE is a partial specialization, return the constraints for
840 // that type. If it is an explicit specialization, return null since
841 // non-templates cannot be constrained.
844 else
846 }
848 // Returns the type of a template specialization only if that
849 // specialization needs to defined. Otherwise (e.g., if the type has
850 // already been defined), the function returns NULL_TREE.
851 static tree
853 {
854 // An implicit instantiation of an incomplete type implies
855 // the definition of a new class template.
856 //
857 // template<typename T>
858 // struct S;
859 //
860 // template<typename T>
861 // struct S<T*>;
862 //
863 // Here, S<T*> is an implicit instantiation of S whose type
864 // is incomplete.
868 // It can also be the case that is a completed specialization.
869 // Continuing the previous example, suppose we also declare:
870 //
871 // template<typename T>
872 // requires Integral<T>
873 // struct S<T*>;
874 //
875 // Here, S<T*> refers to the specialization S<T*> defined
876 // above. However, we need to differentiate definitions because
877 // we intend to define a new partial specialization. In this case,
878 // we rely on the fact that the constraints are different for
879 // this declaration than that above.
880 //
881 // Note that we also get here for injected class names and
882 // late-parsed template definitions. We must ensure that we
883 // do not create new type declarations for those cases.
885 {
888 {
892 // Create a new type node (and corresponding type decl) that
893 // for the newly declared specialization.
901 // Build the corresponding type decl.
907 }
908 }
910 }
912 /* The TYPE is being declared. If it is a template type, that means it
913 is a partial specialization. Do appropriate error-checking. */
915 tree
917 {
918 tree context;
923 /* A lambda that appears in specialization context is not itself a
924 specialization. */
929 {
933 }
938 {
943 else
946 }
948 {
949 /* This is for ordinary explicit specialization and partial
950 specialization of a template class such as:
952 template <> class C<int>;
954 or:
956 template <class T> class C<T*>;
958 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
961 {
966 {
971 }
972 }
978 /* Trying to define a specialization either without a template<> header
979 or in an inappropriate place. We've already given an error, so just
980 bail now so we don't actually define the specialization. */
982 }
988 {
989 /* This is for an explicit specialization of member class
990 template according to [temp.expl.spec/18]:
992 template <> template <class U> class C<int>::D;
994 The context `C<int>' must be an implicit instantiation.
995 Otherwise this is just a member class template declared
996 earlier like:
998 template <> class C<int> { template <class U> class D; };
999 template <> template <class U> class C<int>::D;
1001 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1002 while in the second case, `C<int>::D' is a primary template
1003 and `C<T>::D' may not exist. */
1007 {
1008 tree t;
1013 {
1016 }
1018 /* Check for invalid specialization after instantiation:
1020 template <> template <> class C<int>::D<int>;
1021 template <> template <class U> class C<int>::D; */
1025 {
1028 {
1029 /* We already have a full specialization of this partial
1030 instantiation. Reassign it to the new member
1031 specialization template. */
1032 spec_entry elt;
1049 }
1051 /* But if we've had an implicit instantiation, that's a
1052 problem ([temp.expl.spec]/6). */
1055 }
1057 /* Mark TYPE as a specialization. And as a result, we only
1058 have one level of template argument for the innermost
1059 class template. */
1064 }
1065 }
1067 {
1068 /* Someday C++0x may allow for enum template specialization. */
1073 else
1074 {
1077 }
1078 }
1081 }
1083 /* Returns nonzero if we can optimize the retrieval of specializations
1084 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1085 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1089 {
1092 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1093 parameter. */
1095 /* The optimized lookup depends on the fact that the
1096 template arguments for the member function template apply
1097 purely to the containing class, which is not true if the
1098 containing class is an explicit or partial
1099 specialization. */
1103 /* It is possible to have a template that is not a member
1104 template and is not a member of a template class:
1106 template <typename T>
1107 struct S { friend A::f(); };
1109 Here, the friend function is a template, but the context does
1110 not have template information. The optimized lookup relies
1111 on having ARGS be the template arguments for both the class
1112 and the function template. */
1114 }
1116 /* Retrieve the specialization (in the sense of [temp.spec] - a
1117 specialization is either an instantiation or an explicit
1118 specialization) of TMPL for the given template ARGS. If there is
1119 no such specialization, return NULL_TREE. The ARGS are a vector of
1120 arguments, or a vector of vectors of arguments, in the case of
1121 templates with more than one level of parameters.
1123 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1124 then we search for a partial specialization matching ARGS. This
1125 parameter is ignored if TMPL is not a class template.
1127 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1128 result is a NONTYPE_ARGUMENT_PACK. */
1130 static tree
1132 {
1142 /* There should be as many levels of arguments as there are
1143 levels of parameters. */
1150 {
1151 tree class_template;
1152 tree class_specialization;
1154 tree fns;
1157 /* The template arguments actually apply to the containing
1158 class. Find the class specialization with those
1159 arguments. */
1161 class_specialization
1165 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1166 for the specialization. */
1170 /* Iterate through the methods with the indicated name, looking
1171 for the one that has an instance of TMPL. */
1174 {
1177 /* using-declarations can add base methods to the method vec,
1178 and we don't want those here. */
1181 }
1183 }
1184 else
1185 {
1187 spec_entry elt;
1188 htab_t specializations;
1196 else
1204 }
1207 }
1209 /* Like retrieve_specialization, but for local declarations. */
1211 tree
1213 {
1221 }
1223 /* Returns nonzero iff DECL is a specialization of TMPL. */
1225 int
1227 {
1228 tree t;
1231 {
1237 }
1238 else
1239 {
1248 }
1251 }
1253 /* Returns nonzero iff DECL is a specialization of friend declaration
1254 FRIEND_DECL according to [temp.friend]. */
1256 bool
1258 {
1265 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1266 of a template class, we want to check if DECL is a specialization
1267 if this. */
1271 {
1272 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1275 }
1280 /* There is nothing to do if this is not a template friend. */
1287 /* [temp.friend/6]
1288 A member of a class template may be declared to be a friend of a
1289 non-template class. In this case, the corresponding member of
1290 every specialization of the class template is a friend of the
1291 class granting friendship.
1293 For example, given a template friend declaration
1295 template <class T> friend void A<T>::f();
1297 the member function below is considered a friend
1299 template <> struct A<int> {
1300 void f();
1301 };
1303 For this type of template friend, TEMPLATE_DEPTH below will be
1304 nonzero. To determine if DECL is a friend of FRIEND, we first
1305 check if the enclosing class is a specialization of another. */
1312 {
1313 /* Next, we check the members themselves. In order to handle
1314 a few tricky cases, such as when FRIEND_DECL's are
1316 template <class T> friend void A<T>::g(T t);
1317 template <class T> template <T t> friend void A<T>::h();
1319 and DECL's are
1321 void A<int>::g(int);
1322 template <int> void A<int>::h();
1324 we need to figure out ARGS, the template arguments from
1325 the context of DECL. This is required for template substitution
1326 of `T' in the function parameter of `g' and template parameter
1327 of `h' in the above examples. Here ARGS corresponds to `int'. */
1334 {
1336 {
1339 else
1341 current_depth++;
1342 }
1344 }
1347 {
1349 tree friend_type;
1350 tree decl_type;
1351 tree friend_args_type;
1352 tree decl_args_type;
1354 /* Make sure that both DECL and FRIEND_DECL are templates or
1355 non-templates. */
1361 {
1362 /* If both are templates, check template parameter list. */
1363 tree friend_parms
1368 friend_parms))
1372 }
1373 else
1381 /* Check if return types match. */
1385 /* Check if function parameter types match, ignoring the
1386 `this' parameter. */
1395 }
1396 else
1397 {
1398 /* DECL is a TYPE_DECL */
1402 /* Make sure that both DECL and FRIEND_DECL are templates or
1403 non-templates. */
1404 is_template
1411 {
1412 tree friend_parms;
1413 /* If both are templates, check the name of the two
1414 TEMPLATE_DECL's first because is_friend didn't. */
1419 /* Now check template parameter list. */
1420 friend_parms
1423 return comp_template_parms
1425 friend_parms);
1426 }
1427 else
1430 }
1431 }
1433 }
1435 /* Register the specialization SPEC as a specialization of TMPL with
1436 the indicated ARGS. IS_FRIEND indicates whether the specialization
1437 is actually just a friend declaration. Returns SPEC, or an
1438 equivalent prior declaration, if available.
1440 We also store instantiations of field packs in the hash table, even
1441 though they are not themselves templates, to make lookup easier. */
1443 static tree
1445 hashval_t hash)
1446 {
1447 tree fn;
1449 spec_entry elt;
1457 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1458 register it; we want the corresponding TEMPLATE_DECL instead.
1459 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1460 the more obvious `uses_template_parms (spec)' to avoid problems
1461 with default function arguments. In particular, given
1462 something like this:
1464 template <class T> void f(T t1, T t = T())
1466 the default argument expression is not substituted for in an
1467 instantiation unless and until it is actually needed. */
1471 /* We don't put these specializations in the hash table, but we might
1472 want to give an error about a mismatch. */
1474 else
1475 {
1483 slot =
1487 else
1489 }
1491 /* We can sometimes try to re-register a specialization that we've
1492 already got. In particular, regenerate_decl_from_template calls
1493 duplicate_decls which will update the specialization list. But,
1494 we'll still get called again here anyhow. It's more convenient
1495 to simply allow this than to try to prevent it. */
1499 {
1501 {
1504 {
1506 fn);
1508 }
1509 else
1510 {
1511 tree clone;
1512 /* This situation should occur only if the first
1513 specialization is an implicit instantiation, the
1514 second is an explicit specialization, and the
1515 implicit instantiation has not yet been used. That
1516 situation can occur if we have implicitly
1517 instantiated a member function and then specialized
1518 it later.
1520 We can also wind up here if a friend declaration that
1521 looked like an instantiation turns out to be a
1522 specialization:
1524 template <class T> void foo(T);
1525 class S { friend void foo<>(int) };
1526 template <> void foo(int);
1528 We transform the existing DECL in place so that any
1529 pointers to it become pointers to the updated
1530 declaration.
1532 If there was a definition for the template, but not
1533 for the specialization, we want this to look as if
1534 there were no definition, and vice versa. */
1537 /* The call to duplicate_decls will have applied
1538 [temp.expl.spec]:
1540 An explicit specialization of a function template
1541 is inline only if it is explicitly declared to be,
1542 and independently of whether its function template
1543 is.
1545 to the primary function; now copy the inline bits to
1546 the various clones. */
1548 {
1553 }
1557 }
1558 }
1560 {
1562 /* Dup decl failed, but this is a new definition. Set the
1563 line number so any errors match this new
1564 definition. */
1568 }
1569 }
1573 /* A specialization must be declared in the same namespace as the
1574 template it is specializing. */
1580 {
1588 /* TMPL is a forward declaration of a template function; keep a list
1589 of all specializations in case we need to reassign them to a friend
1590 template later in tsubst_friend_function. */
1593 }
1596 }
1598 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1599 TMPL and ARGS members, ignores SPEC. */
1603 static int
1605 {
1616 }
1618 /* Returns a hash for a template TMPL and template arguments ARGS. */
1620 static hashval_t
1622 {
1625 }
1627 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1628 ignoring SPEC. */
1630 static hashval_t
1632 {
1635 }
1637 /* Recursively calculate a hash value for a template argument ARG, for use
1638 in the hash tables of template specializations. */
1640 hashval_t
1642 {
1654 /* We can get one of these when re-hashing a previous entry in the middle
1655 of substituting into a pack expansion. Just look through it. */
1664 {
1672 {
1677 }
1699 {
1702 {
1705 }
1707 }
1711 {
1714 }
1725 val = iterative_hash_template_arg
1737 val);
1739 val);
1748 /* A lambda can't appear in a template arg, but don't crash on
1749 erroneous input. */
1761 /* Now hash operands as usual. */
1766 }
1769 {
1773 val);
1776 /* Otherwise just compare the types during lookup. */
1785 {
1790 }
1791 }
1794 }
1796 /* Unregister the specialization SPEC as a specialization of TMPL.
1797 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1798 if the SPEC was listed as a specialization of TMPL.
1800 Note that SPEC has been ggc_freed, so we can't look inside it. */
1802 bool
1804 {
1806 spec_entry elt;
1814 {
1819 }
1822 }
1824 /* Like register_specialization, but for local declarations. We are
1825 registering SPEC, an instantiation of TMPL. */
1827 void
1829 {
1834 }
1836 /* TYPE is a class type. Returns true if TYPE is an explicitly
1837 specialized class. */
1839 bool
1841 {
1845 }
1847 /* Print the list of functions at FNS, going through all the overloads
1848 for each element of the list. Alternatively, FNS can not be a
1849 TREE_LIST, in which case it will be printed together with all the
1850 overloads.
1852 MORE and *STR should respectively be FALSE and NULL when the function
1853 is called from the outside. They are used internally on recursive
1854 calls. print_candidates manages the two parameters and leaves NULL
1855 in *STR when it ends. */
1857 static void
1859 {
1865 {
1869 }
1870 else
1871 {
1874 {
1875 /* Pick the prefix string. */
1877 {
1881 }
1885 }
1888 }
1891 {
1894 }
1895 }
1897 /* Print the list of candidate FNS in an error message. FNS can also
1898 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1900 void
1902 {
1906 }
1908 /* Returns the template (one of the functions given by TEMPLATE_ID)
1909 which can be specialized to match the indicated DECL with the
1910 explicit template args given in TEMPLATE_ID. The DECL may be
1911 NULL_TREE if none is available. In that case, the functions in
1912 TEMPLATE_ID are non-members.
1914 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1915 specialization of a member template.
1917 The TEMPLATE_COUNT is the number of references to qualifying
1918 template classes that appeared in the name of the function. See
1919 check_explicit_specialization for a more accurate description.
1921 TSK indicates what kind of template declaration (if any) is being
1922 declared. TSK_TEMPLATE indicates that the declaration given by
1923 DECL, though a FUNCTION_DECL, has template parameters, and is
1924 therefore a template function.
1926 The template args (those explicitly specified and those deduced)
1927 are output in a newly created vector *TARGS_OUT.
1929 If it is impossible to determine the result, an error message is
1930 issued. The error_mark_node is returned to indicate failure. */
1932 static tree
1934 tree decl,
1938 tmpl_spec_kind tsk)
1939 {
1940 tree fns;
1941 tree targs;
1942 tree explicit_targs;
1944 /* A TREE_LIST of templates of which DECL may be a specialization.
1945 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1946 corresponding TREE_PURPOSE is the set of template arguments that,
1947 when used to instantiate the template, would produce a function
1948 with the signature of DECL. */
1958 /* We shouldn't be specializing a member template of an
1959 unspecialized class template; we already gave an error in
1960 check_specialization_scope, now avoid crashing. */
1963 {
1966 }
1974 /* Check for baselinks. */
1979 {
1982 }
1984 /* Count the number of template headers specified for this
1985 specialization. */
1993 {
1997 {
1998 tree decl_arg_types;
1999 tree fn_arg_types;
2000 tree insttype;
2002 /* In case of explicit specialization, we need to check if
2003 the number of template headers appearing in the specialization
2004 is correct. This is usually done in check_explicit_specialization,
2005 but the check done there cannot be exhaustive when specializing
2006 member functions. Consider the following code:
2008 template <> void A<int>::f(int);
2009 template <> template <> void A<int>::f(int);
2011 Assuming that A<int> is not itself an explicit specialization
2012 already, the first line specializes "f" which is a non-template
2013 member function, whilst the second line specializes "f" which
2014 is a template member function. So both lines are syntactically
2015 correct, and check_explicit_specialization does not reject
2016 them.
2018 Here, we can do better, as we are matching the specialization
2019 against the declarations. We count the number of template
2020 headers, and we check if they match TEMPLATE_COUNT + 1
2021 (TEMPLATE_COUNT is the number of qualifying template classes,
2022 plus there must be another header for the member template
2023 itself).
2025 Notice that if header_count is zero, this is not a
2026 specialization but rather a template instantiation, so there
2027 is no check we can perform here. */
2031 /* Check that the number of template arguments at the
2032 innermost level for DECL is the same as for FN. */
2040 /* DECL might be a specialization of FN. */
2044 /* For a non-static member function, we need to make sure
2045 that the const qualification is the same. Since
2046 get_bindings does not try to merge the "this" parameter,
2047 we must do the comparison explicitly. */
2053 /* Skip the "this" parameter and, for constructors of
2054 classes with virtual bases, the VTT parameter. A
2055 full specialization of a constructor will have a VTT
2056 parameter, but a template never will. */
2057 decl_arg_types
2059 fn_arg_types
2062 /* Function templates cannot be specializations; there are
2063 no partial specializations of functions. Therefore, if
2064 the type of DECL does not match FN, there is no
2065 match. */
2067 {
2071 }
2073 /* See whether this function might be a specialization of this
2074 template. Suppress access control because we might be trying
2075 to make this specialization a friend, and we have already done
2076 access control for the declaration of the specialization. */
2082 /* We cannot deduce template arguments that when used to
2083 specialize TMPL will produce DECL. */
2086 // Make sure that the deduced arguments actually work. First,
2087 // check that any template constraints are satisfied.
2088 //
2089 // TODO: Make sure that we get reasonable diagnostics for these
2090 // kinds of failures.
2094 // Then, try to form the new function type.
2098 fn_arg_types
2103 /* Save this template, and the arguments deduced. */
2105 }
2107 /* FN is an ordinary member function, and we need a
2108 specialization of a member template. */
2109 ;
2111 /* We can get IDENTIFIER_NODEs here in certain erroneous
2112 cases. */
2113 ;
2115 /* This is just an ordinary non-member function. Nothing can
2116 be a specialization of that. */
2117 ;
2119 /* Cannot specialize functions that are created implicitly. */
2120 ;
2121 else
2122 {
2123 tree decl_arg_types;
2125 /* This is an ordinary member function. However, since
2126 we're here, we can assume its enclosing class is a
2127 template class. For example,
2129 template <typename T> struct S { void f(); };
2130 template <> void S<int>::f() {}
2132 Here, S<int>::f is a non-template, but S<int> is a
2133 template class. If FN has the same type as DECL, we
2134 might be in business. */
2137 /* Its enclosing class is an explicit specialization
2138 of a template class. This is not a candidate. */
2143 /* The return types differ. */
2146 /* Adjust the type of DECL in case FN is a static member. */
2153 decl_arg_types))
2154 /* They match! */
2156 }
2157 }
2160 {
2161 /* We have:
2163 [temp.expl.spec]
2165 It is possible for a specialization with a given function
2166 signature to be instantiated from more than one function
2167 template. In such cases, explicit specification of the
2168 template arguments must be used to uniquely identify the
2169 function template specialization being specialized.
2171 Note that here, there's no suggestion that we're supposed to
2172 determine which of the candidate templates is most
2173 specialized. However, we, also have:
2175 [temp.func.order]
2177 Partial ordering of overloaded function template
2178 declarations is used in the following contexts to select
2179 the function template to which a function template
2180 specialization refers:
2182 -- when an explicit specialization refers to a function
2183 template.
2185 So, we do use the partial ordering rules, at least for now.
2186 This extension can only serve to make invalid programs valid,
2187 so it's safe. And, there is strong anecdotal evidence that
2188 the committee intended the partial ordering rules to apply;
2189 the EDG front end has that behavior, and John Spicer claims
2190 that the committee simply forgot to delete the wording in
2191 [temp.expl.spec]. */
2194 {
2197 }
2198 }
2201 {
2209 }
2213 {
2219 }
2221 /* We have one, and exactly one, match. */
2223 {
2226 /* DECL is a re-declaration or partial instantiation of a template
2227 function. */
2230 /* It was a specialization of an ordinary member function in a
2231 template class. */
2233 }
2235 /* It was a specialization of a template. */
2238 {
2243 }
2244 else
2247 }
2249 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2250 but with the default argument values filled in from those in the
2251 TMPL_TYPES. */
2253 static tree
2255 tree tmpl_types)
2256 {
2257 tree new_spec_types;
2265 /* Substitute into the rest of the list. */
2266 new_spec_types =
2270 /* Add the default argument for this parameter. */
2273 new_spec_types);
2274 }
2276 /* DECL is an explicit specialization. Replicate default arguments
2277 from the template it specializes. (That way, code like:
2279 template <class T> void f(T = 3);
2280 template <> void f(double);
2281 void g () { f (); }
2283 works, as required.) An alternative approach would be to look up
2284 the correct default arguments at the call-site, but this approach
2285 is consistent with how implicit instantiations are handled. */
2287 static void
2289 {
2290 tree tmpl;
2291 tree spec_types;
2292 tree tmpl_types;
2293 tree new_spec_types;
2294 tree old_type;
2295 tree new_type;
2296 tree t;
2301 /* See if there's anything we need to do. */
2314 {
2315 /* Remove the this pointer, but remember the object's type for
2316 CV quals. */
2322 {
2323 /* DECL may contain more parameters than TMPL due to the extra
2324 in-charge parameter in constructors and destructors. */
2327 }
2329 {
2332 }
2333 }
2335 /* Compute the merged default arguments. */
2336 new_spec_types =
2339 /* Compute the new FUNCTION_TYPE. */
2341 {
2345 new_spec_types);
2348 /* Put the in-charge parameter back. */
2351 new_spec_types);
2355 new_spec_types);
2356 }
2357 else
2359 new_spec_types);
2365 }
2367 /* Return the number of template headers we expect to see for a definition
2368 or specialization of CTYPE or one of its non-template members. */
2370 int
2372 {
2376 {
2377 /* You're supposed to have one `template <...>' for every
2378 template class, but you don't need one for a full
2379 specialization. For example:
2381 template <class T> struct S{};
2382 template <> struct S<int> { void f(); };
2383 void S<int>::f () {}
2385 is correct; there shouldn't be a `template <>' for the
2386 definition of `S<int>::f'. */
2388 /* If CTYPE does not have template information of any
2389 kind, then it is not a template, nor is it nested
2390 within a template. */
2398 }
2401 }
2403 /* Do a simple sanity check on the template headers that precede the
2404 variable declaration DECL. */
2406 void
2408 {
2415 {
2421 "members of an explicitly specialized class are defined "
2423 }
2424 }
2426 /* Check to see if the function just declared, as indicated in
2427 DECLARATOR, and in DECL, is a specialization of a function
2428 template. We may also discover that the declaration is an explicit
2429 instantiation at this point.
2431 Returns DECL, or an equivalent declaration that should be used
2432 instead if all goes well. Issues an error message if something is
2433 amiss. Returns error_mark_node if the error is not easily
2434 recoverable.
2436 FLAGS is a bitmask consisting of the following flags:
2438 2: The function has a definition.
2439 4: The function is a friend.
2441 The TEMPLATE_COUNT is the number of references to qualifying
2442 template classes that appeared in the name of the function. For
2443 example, in
2445 template <class T> struct S { void f(); };
2446 void S<int>::f();
2448 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2449 classes are not counted in the TEMPLATE_COUNT, so that in
2451 template <class T> struct S {};
2452 template <> struct S<int> { void f(); }
2453 template <> void S<int>::f();
2455 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2456 invalid; there should be no template <>.)
2458 If the function is a specialization, it is marked as such via
2459 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2460 is set up correctly, and it is added to the list of specializations
2461 for that template. */
2463 tree
2465 tree decl,
2468 {
2477 tmpl_spec_kind tsk;
2480 {
2483 else
2485 }
2486 else
2490 {
2493 {
2496 }
2498 {
2500 /* This could be something like:
2502 template <class T> void f(T);
2503 class S { friend void f<>(int); } */
2505 else
2506 {
2507 /* This case handles bogus declarations like template <>
2508 template <class T> void f<int>(); */
2511 declarator);
2513 }
2514 }
2518 /* The error has already been reported in
2519 check_specialization_scope. */
2525 /* Fall through. */
2538 decl);
2541 else
2545 /* Fall through. */
2549 // if (DECL_DECLARED_CONCEPT_P (decl))
2550 // error ("explicit specialization of concept %qD", decl);
2555 else
2561 {
2562 /* This case handles bogus declarations like template <>
2563 template <class T> void f<int>(); */
2568 else
2570 declarator);
2572 }
2575 /* This is a specialization of a member template, without
2576 specialization the containing class. Something like:
2578 template <class T> struct S {
2579 template <class U> void f (U);
2580 };
2581 template <> template <class U> void S<int>::f(U) {}
2583 That's a specialization -- but of the entire template. */
2589 }
2592 {
2596 {
2600 }
2601 }
2604 {
2608 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2610 {
2611 tree fns;
2616 else
2617 {
2618 /* If there is no class context, the explicit instantiation
2619 must be at namespace scope. */
2622 /* Find the namespace binding, using the declaration
2623 context. */
2627 {
2630 }
2631 else
2632 {
2638 }
2639 }
2642 }
2648 {
2650 /* A specialization in class scope. This is invalid,
2651 but the error will already have been flagged by
2652 check_specialization_scope. */
2654 else
2655 {
2656 /* It's not valid to write an explicit instantiation in
2657 class scope, e.g.:
2659 class C { template void f(); }
2661 This case is caught by the parser. However, on
2662 something like:
2664 template class C { void f(); };
2666 (which is invalid) we can get here. The error will be
2667 issued later. */
2668 ;
2669 }
2672 }
2675 {
2676 /* Find the list of functions in ctype that have the same
2677 name as the declared function. */
2683 {
2688 {
2689 /* From [temp.expl.spec]:
2691 If such an explicit specialization for the member
2692 of a class template names an implicitly-declared
2693 special member function (clause _special_), the
2694 program is ill-formed.
2696 Similar language is found in [temp.explicit]. */
2699 }
2702 }
2705 {
2709 }
2710 else
2711 {
2713 tree ovl;
2715 /* For a type-conversion operator, we cannot do a
2716 name-based lookup. We might be looking for `operator
2717 int' which will be a specialization of `operator T'.
2718 So, we find *all* the conversion operators, and then
2719 select from them. */
2727 {
2729 /* There are no more conversion functions. */
2732 /* Glue all these conversion functions together
2733 with those we already have. */
2736 }
2737 }
2740 {
2743 }
2744 else
2746 }
2748 /* Figure out what exactly is being specialized at this point.
2749 Note that for an explicit instantiation, even one for a
2750 member function, we cannot tell apriori whether the
2751 instantiation is for a member template, or just a member
2752 function of a template class. Even if a member template is
2753 being instantiated, the member template arguments may be
2754 elided if they can be deduced from the rest of the
2755 declaration. */
2758 member_specialization,
2759 template_count,
2760 tsk);
2763 /* We couldn't figure out what this declaration was
2764 specializing. */
2766 else
2767 {
2771 {
2772 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2773 is done by do_decl_instantiation later. */
2779 {
2780 /* If TMPL is not the most general template (for
2781 example, if TMPL is a friend template that is
2782 injected into namespace scope), then there will
2783 be too many levels of TARGS. Remove some of them
2784 here. */
2786 tree new_targs;
2793 }
2796 }
2798 /* If we thought that the DECL was a member function, but it
2799 turns out to be specializing a static member function,
2800 make DECL a static member function as well. */
2805 /* If this is a specialization of a member template of a
2806 template class, we want to return the TEMPLATE_DECL, not
2807 the specialization of it. */
2809 {
2814 {
2815 tree parm;
2819 /* We want to use the argument list specified in the
2820 definition, not in the original declaration. */
2825 }
2828 }
2830 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2833 /* Inherit default function arguments from the template
2834 DECL is specializing. */
2837 /* This specialization has the same protection as the
2838 template it specializes. */
2842 /* 7.1.1-1 [dcl.stc]
2844 A storage-class-specifier shall not be specified in an
2845 explicit specialization...
2847 The parser rejects these, so unless action is taken here,
2848 explicit function specializations will always appear with
2849 global linkage.
2851 The action recommended by the C++ CWG in response to C++
2852 defect report 605 is to make the storage class and linkage
2853 of the explicit specialization match the templated function:
2855 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2856 */
2858 {
2862 // A concept cannot be specialized.
2864 {
2867 }
2869 /* This specialization has the same linkage and visibility as
2870 the function template it specializes. */
2873 {
2876 }
2879 {
2882 }
2883 }
2885 /* If DECL is a friend declaration, declared using an
2886 unqualified name, the namespace associated with DECL may
2887 have been set incorrectly. For example, in:
2889 template <typename T> void f(T);
2890 namespace N {
2891 struct S { friend void f<int>(int); }
2892 }
2894 we will have set the DECL_CONTEXT for the friend
2895 declaration to N, rather than to the global namespace. */
2900 /* This is not really a declaration of a specialization.
2901 It's just the name of an instantiation. But, it's not
2902 a request for an instantiation, either. */
2905 /* This is indeed a specialization. In case of constructors
2906 and destructors, we need in-charge and not-in-charge
2907 versions in V3 ABI. */
2910 /* Register this specialization so that we can find it
2911 again. */
2913 }
2914 }
2917 }
2919 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2920 parameters. These are represented in the same format used for
2921 DECL_TEMPLATE_PARMS. */
2923 int
2925 {
2926 const_tree p1;
2927 const_tree p2;
2935 {
2947 {
2951 /* If either of the template parameters are invalid, assume
2952 they match for the sake of error recovery. */
2965 }
2966 }
2969 /* One set of parameters has more parameters lists than the
2970 other. */
2974 }
2976 /* Determine whether PARM is a parameter pack. */
2978 bool
2980 {
2981 /* Determine if we have a non-type template parameter pack. */
2988 /* If this is a list of template parameters, we could get a
2989 TYPE_DECL or a TEMPLATE_DECL. */
2993 /* Otherwise it must be a type template parameter. */
2997 }
2999 /* Determine if T is a function parameter pack. */
3001 bool
3003 {
3007 }
3009 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3010 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3012 tree
3014 {
3021 }
3023 /* Return true iff the function parameter PARAM_DECL was expanded
3024 from the function parameter pack PACK. */
3026 bool
3028 {
3033 /* The parameter pack and its pack arguments have the same
3034 DECL_PARM_INDEX. */
3036 }
3038 /* Determine whether ARGS describes a variadic template args list,
3039 i.e., one that is terminated by a template argument pack. */
3041 static bool
3043 {
3045 tree last_parm;
3059 }
3061 /* Generate a new name for the parameter pack name NAME (an
3062 IDENTIFIER_NODE) that incorporates its */
3064 static tree
3066 {
3067 /* Munge the name to include the parameter index. */
3068 #define NUMBUF_LEN 128
3082 }
3084 /* Return true if T is a primary function, class or alias template
3085 instantiation. */
3087 bool
3089 {
3103 }
3105 /* Return true if PARM is a template template parameter. */
3107 bool
3109 {
3111 }
3113 /* Return true iff PARM is a DECL representing a type template
3114 parameter. */
3116 bool
3118 {
3123 }
3125 /* Return the template parameters of T if T is a
3126 primary template instantiation, NULL otherwise. */
3128 tree
3130 {
3135 parms = INNERMOST_TEMPLATE_PARMS
3139 }
3141 /* Return the template parameters of the LEVELth level from the full list
3142 of template parameters PARMS. */
3144 tree
3146 {
3147 tree p;
3158 }
3160 /* Returns the template arguments of T if T is a template instantiation,
3161 NULL otherwise. */
3163 tree
3165 {
3173 }
3175 /* Return the argument pack elements of T if T is a template argument pack,
3176 NULL otherwise. */
3178 tree
3180 {
3186 }
3188 /* Structure used to track the progress of find_parameter_packs_r. */
3189 struct find_parameter_pack_data
3190 {
3191 /* TREE_LIST that will contain all of the parameter packs found by
3192 the traversal. */
3195 /* Set of AST nodes that have been visited by the traversal. */
3197 };
3199 /* Identifies all of the argument packs that occur in a template
3200 argument and appends them to the TREE_LIST inside DATA, which is a
3201 find_parameter_pack_data structure. This is a subroutine of
3202 make_pack_expansion and uses_parameter_packs. */
3203 static tree
3205 {
3211 /* Handle type aliases/typedefs. */
3213 {
3220 }
3222 /* Identify whether this is a parameter pack or not. */
3224 {
3240 {
3241 /* We don't want to walk into the type of a PARM_DECL,
3242 because we don't want to see the type parameter pack. */
3245 }
3248 /* Look through a lambda capture proxy to the field pack. */
3251 {
3257 }
3264 /* Not a parameter pack. */
3266 }
3269 {
3270 /* Add this parameter pack to the list. */
3272 }
3278 /* This switch statement will return immediately if we don't find a
3279 parameter pack. */
3281 {
3286 /* Check the template itself. */
3289 /* Check the template arguments. */
3305 /* Fall through. */
3347 }
3350 }
3352 /* Determines if the expression or type T uses any parameter packs. */
3353 bool
3355 {
3363 }
3365 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3366 representation a base-class initializer into a parameter pack
3367 expansion. If all goes well, the resulting node will be an
3368 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3369 respectively. */
3370 tree
3372 {
3373 tree result;
3382 {
3383 /* The only time we will see a TREE_LIST here is for a base
3384 class initializer. In this case, the TREE_PURPOSE will be a
3385 _TYPE node (representing the base class expansion we're
3386 initializing) and the TREE_VALUE will be a TREE_LIST
3387 containing the initialization arguments.
3389 The resulting expansion looks somewhat different from most
3390 expansions. Rather than returning just one _EXPANSION, we
3391 return a TREE_LIST whose TREE_PURPOSE is a
3392 TYPE_PACK_EXPANSION containing the bases that will be
3393 initialized. The TREE_VALUE will be identical to the
3394 original TREE_VALUE, which is a list of arguments that will
3395 be passed to each base. We do not introduce any new pack
3396 expansion nodes into the TREE_VALUE (although it is possible
3397 that some already exist), because the TREE_PURPOSE and
3398 TREE_VALUE all need to be expanded together with the same
3399 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3400 resulting TREE_PURPOSE will mention the parameter packs in
3401 both the bases and the arguments to the bases. */
3402 tree purpose;
3403 tree value;
3406 /* Determine which parameter packs will be used by the base
3407 class expansion. */
3414 {
3418 }
3421 {
3422 /* Collect the sets of parameter packs used in each of the
3423 initialization arguments. */
3425 {
3426 /* Determine which parameter packs will be expanded in this
3427 argument. */
3430 }
3431 }
3435 /* Create the pack expansion type for the base type. */
3440 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3441 they will rarely be compared to anything. */
3445 }
3450 /* Build the PACK_EXPANSION_* node. */
3451 result = for_types
3456 {
3457 /* Propagate type and const-expression information. */
3460 }
3461 else
3462 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3463 they will rarely be compared to anything. */
3466 /* Determine which parameter packs will be expanded. */
3472 /* Make sure we found some parameter packs. */
3474 {
3477 else
3480 }
3486 }
3488 /* Checks T for any "bare" parameter packs, which have not yet been
3489 expanded, and issues an error if any are found. This operation can
3490 only be done on full expressions or types (e.g., an expression
3491 statement, "if" condition, etc.), because we could have expressions like:
3493 foo(f(g(h(args)))...)
3495 where "args" is a parameter pack. check_for_bare_parameter_packs
3496 should not be called for the subexpressions args, h(args),
3497 g(h(args)), or f(g(h(args))), because we would produce erroneous
3498 error messages.
3500 Returns TRUE and emits an error if there were bare parameter packs,
3501 returns FALSE otherwise. */
3502 bool
3504 {
3520 {
3523 {
3532 else
3537 else
3541 }
3544 }
3547 }
3549 /* Expand any parameter packs that occur in the template arguments in
3550 ARGS. */
3551 tree
3553 {
3559 /* First, determine if we need to expand anything, and the number of
3560 slots we'll need. */
3562 {
3567 {
3571 else
3573 }
3574 else
3575 {
3577 num_result_args++;
3578 }
3579 }
3581 /* If no expansion is necessary, we're done. */
3585 /* Expand arguments. */
3588 non_default_args_count =
3591 {
3594 {
3601 }
3602 else
3603 {
3606 }
3607 }
3611 }
3613 /* Checks if DECL shadows a template parameter.
3615 [temp.local]: A template-parameter shall not be redeclared within its
3616 scope (including nested scopes).
3618 Emits an error and returns TRUE if the DECL shadows a parameter,
3619 returns FALSE otherwise. */
3621 bool
3623 {
3624 tree olddecl;
3626 /* If we're not in a template, we can't possibly shadow a template
3627 parameter. */
3631 /* Figure out what we're shadowing. */
3636 /* If there's no previous binding for this name, we're not shadowing
3637 anything, let alone a template parameter. */
3641 /* If we're not shadowing a template parameter, we're done. Note
3642 that OLDDECL might be an OVERLOAD (or perhaps even an
3643 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3644 node. */
3648 /* We check for decl != olddecl to avoid bogus errors for using a
3649 name inside a class. We check TPFI to avoid duplicate errors for
3650 inline member templates. */
3659 }
3661 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3662 ORIG_LEVEL, DECL, and TYPE. */
3664 static tree
3668 tree decl,
3669 tree type)
3670 {
3681 }
3683 /* Find the canonical type parameter for the given template type
3684 parameter. Returns the canonical type parameter, which may be TYPE
3685 if no such parameter existed. */
3687 static tree
3689 {
3690 tree list;
3704 else
3705 {
3710 }
3711 }
3713 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3714 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3715 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3716 new one is created. */
3718 static tree
3720 tsubst_flags_t complain)
3721 {
3726 {
3745 /* Template template parameters need this. */
3750 }
3753 }
3755 /* Process information from new template parameter PARM and append it
3756 to the LIST being built. This new parameter is a non-type
3757 parameter iff IS_NON_TYPE is true. This new parameter is a
3758 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3759 is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template
3760 parameter list PARM belongs to. This is used used to create a
3761 proper canonical type for the type of PARM that is to be created,
3762 iff PARM is a type. If the size is not known, this parameter shall
3763 be set to 0. */
3765 tree
3768 {
3770 tree err_parm_list;
3779 {
3783 {
3787 else
3789 }
3792 }
3793 else
3797 {
3803 {
3807 }
3808 else
3809 {
3810 /* [temp.param]
3812 The top-level cv-qualifiers on the template-parameter are
3813 ignored when determining its type. */
3816 {
3820 }
3823 {
3824 /* This template parameter is not a parameter pack, but it
3825 should be. Complain about "bare" parameter packs. */
3828 /* Recover by calling this a parameter pack. */
3830 }
3831 }
3833 /* A template parameter is not modifiable. */
3842 processing_template_decl,
3848 // Build requirements for the parameter.
3850 }
3851 else
3852 {
3853 tree t;
3857 {
3859 /* This is for distinguishing between real templates and template
3860 template parameters */
3864 }
3865 else
3866 {
3868 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3871 }
3878 processing_template_decl,
3883 // Build requirements for the type/template parameter.
3885 }
3890 // Build the parameter node linking the parameter declaration, its
3891 // default argument (if any), and its constraints (if any).
3896 }
3898 /* The end of a template parameter list has been reached. Process the
3899 tree list into a parameter vector, converting each parameter into a more
3900 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3901 as PARM_DECLs. */
3903 tree
3905 {
3910 current_template_parms
3915 {
3919 }
3924 }
3926 // Explicitly indicate the end of the template parameter list. We assume
3927 // that the current template parameters have been constructed and/or
3928 // managed explicitly, as when creating new template template parameters
3929 // from a shorthand constraint.
3930 void
3932 {
3934 }
3936 /* end_template_decl is called after a template declaration is seen. */
3938 void
3940 {
3946 /* This matches the pushlevel in begin_template_parm_list. */
3951 }
3953 /* Takes a TREE_LIST representing a template parameter and convert it
3954 into an argument suitable to be passed to the type substitution
3955 functions. Note that If the TREE_LIST contains an error_mark
3956 node, the returned argument is error_mark_node. */
3958 tree
3960 {
3973 {
3977 {
3978 /* Turn this argument into a TYPE_ARGUMENT_PACK
3979 with a single element, which expands T. */
3981 #ifdef ENABLE_CHECKING
3982 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3984 #endif
3989 }
3990 }
3991 else
3992 {
3996 {
3997 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3998 with a single element, which expands T. */
4001 #ifdef ENABLE_CHECKING
4002 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
4004 #endif
4010 }
4011 }
4013 }
4015 /* Given a set of template parameters, return them as a set of template
4016 arguments. The template parameters are represented as a TREE_VEC, in
4017 the form documented in cp-tree.h for template arguments. */
4019 static tree
4021 {
4022 tree header;
4027 /* If there is only one level of template parameters, we do not
4028 create a TREE_VEC of TREE_VECs. Instead, we return a single
4029 TREE_VEC containing the arguments. */
4034 {
4042 #ifdef ENABLE_CHECKING
4044 #endif
4048 else
4050 }
4053 /* This can happen for template parms of a template template
4054 parameter, e.g:
4056 template<template<class T, class U> class TT> struct S;
4058 Consider the level of the parms of TT; T and U both have
4059 level 2; TT has no template parm of level 1. So in this case
4060 the first element of full_template_args is NULL_TREE. If we
4061 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
4062 of 2. This will make tsubst wrongly consider that T and U
4063 have level 1. Instead, let's create a dummy vector as the
4064 first element of full_template_args so that TMPL_ARGS_DEPTH
4065 returns the correct depth for args. */
4068 }
4070 /* Within the declaration of a template, return the currently active
4071 template parameters as an argument TREE_VEC. */
4073 static tree
4075 {
4077 }
4079 /* Update the declared TYPE by doing any lookups which were thought to be
4080 dependent, but are not now that we know the SCOPE of the declarator. */
4082 tree
4084 {
4095 /* Don't bother building up the args in this case. */
4097 {
4098 /* tsubst in the args corresponding to the template parameters,
4099 including auto if present. Most things will be unchanged, but
4100 make_typename_type and tsubst_qualified_id will resolve
4101 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4104 tree pushed;
4106 {
4110 }
4115 }
4121 {
4124 else
4126 }
4128 }
4130 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4131 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4132 the new template is a member template. */
4134 tree
4136 {
4145 }
4147 struct template_parm_data
4148 {
4149 /* The level of the template parameters we are currently
4150 processing. */
4153 /* The index of the specialization argument we are currently
4154 processing. */
4157 /* An array whose size is the number of template parameters. The
4158 elements are nonzero if the parameter has been used in any one
4159 of the arguments processed so far. */
4162 /* An array whose size is the number of template arguments. The
4163 elements are nonzero if the argument makes use of template
4164 parameters of this level. */
4166 };
4168 /* Subroutine of push_template_decl used to see if each template
4169 parameter in a partial specialization is used in the explicit
4170 argument list. If T is of the LEVEL given in DATA (which is
4171 treated as a template_parm_data*), then DATA->PARMS is marked
4172 appropriately. */
4174 static int
4176 {
4182 {
4185 }
4186 else
4187 {
4190 }
4193 {
4196 }
4198 /* Return zero so that for_each_template_parm will continue the
4199 traversal of the tree; we want to mark *every* template parm. */
4201 }
4203 /* Process the partial specialization DECL. */
4205 static tree
4207 {
4213 tree inner_parms;
4214 tree inst;
4224 // When defining a constrained partial specialization, DECL's type
4225 // will have been assigned to the canonical type of the primary.
4226 // That is:
4227 //
4228 // template<typename T>
4229 // struct S; // Has canonical type S<T>
4230 //
4231 // template<typename T>
4232 // requires C<T>
4233 // struct S<T>; // binds to the primary template.
4234 //
4235 // However, the the constraints differ, so we should be constructing
4236 // a new type. We do this by making the DECL's type its own
4237 // canonical type.
4238 //
4239 // TODO: Do we need to compare the current requirements to make
4240 // sure this isn't a redeclaration?
4247 /* We check that each of the template parameters given in the
4248 partial specialization is used in the argument list to the
4249 specialization. For example:
4251 template <class T> struct S;
4252 template <class T> struct S<T*>;
4254 The second declaration is OK because `T*' uses the template
4255 parameter T, whereas
4257 template <class T> struct S<int>;
4259 is no good. Even trickier is:
4261 template <class T>
4262 struct S1
4263 {
4264 template <class U>
4265 struct S2;
4266 template <class U>
4267 struct S2<T>;
4268 };
4270 The S2<T> declaration is actually invalid; it is a
4271 full-specialization. Of course,
4273 template <class U>
4274 struct S2<T (*)(U)>;
4276 or some such would have been OK. */
4284 {
4289 NULL,
4291 }
4294 {
4295 /* One of the template parms was not used in the
4296 specialization. */
4298 {
4301 }
4304 }
4309 /* [temp.class.spec]
4311 The argument list of the specialization shall not be identical to
4312 the implicit argument list of the primary template.
4314 Note that concepts allow partial specializations with the same list of
4315 arguments but different constraints. */
4324 /* A partial specialization that replaces multiple parameters of the
4325 primary template with a pack expansion is less specialized for those
4326 parameters. */
4328 {
4330 "primary template because it replaces multiple parameters "
4334 }
4336 /* [temp.class.spec]
4338 A partially specialized non-type argument expression shall not
4339 involve template parameters of the partial specialization except
4340 when the argument expression is a simple identifier.
4342 The type of a template parameter corresponding to a specialized
4343 non-type argument shall not be dependent on a parameter of the
4344 specialization.
4346 Also, we verify that pack expansions only occur at the
4347 end of the argument list. */
4351 {
4358 {
4359 /* Extract the arguments from the argument pack. We'll be
4360 iterating over these in the following loop. */
4363 }
4366 {
4368 /* Get the Jth argument in the parameter pack. */
4372 {
4373 /* Pack expansions must come at the end of the
4374 argument list. */
4377 {
4381 else
4384 }
4385 }
4388 /* We only care about the pattern. */
4394 /* This next line is the `argument expression is not just a
4395 simple identifier' condition and also the `specialized
4396 non-type argument' bit. */
4398 {
4402 arg);
4403 else
4404 {
4405 /* Look at the corresponding template parameter,
4406 marking which template parameters its type depends
4407 upon. */
4411 {
4412 /* We haven't yet initialized TPD2. Do so now. */
4414 /* The number of parameters here is the number in the
4415 main template, which, as checked in the assertion
4416 above, is NARGS. */
4420 }
4422 /* Mark the template parameters. But this time, we're
4423 looking for the template parameters of the main
4424 template, not in the specialization. */
4431 NULL,
4435 {
4436 /* The type depended on some template parameters.
4437 If they are fully specialized in the
4438 specialization, that's OK. */
4447 "type %qT of template argument %qE depends "
4449 "type %qT of template argument %qE depends "
4451 type,
4452 arg);
4453 }
4454 }
4455 }
4456 }
4457 }
4459 /* We should only get here once. */
4462 // Build the template decl.
4464 current_template_parms,
4465 current_template_reqs,
4480 {
4484 {
4488 "partial specialization of %qT after instantiation "
4490 }
4491 }
4494 }
4496 /* Check that a template declaration's use of default arguments and
4497 parameter packs is not invalid. Here, PARMS are the template
4498 parameters. IS_PRIMARY is true if DECL is the thing declared by
4499 a primary template. IS_PARTIAL is true if DECL is a partial
4500 specialization.
4502 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4503 declaration (but not a definition); 1 indicates a declaration, 2
4504 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4505 emitted for extraneous default arguments.
4507 Returns TRUE if there were no errors found, FALSE otherwise. */
4509 bool
4512 {
4515 tree parm_level;
4518 /* [temp.param]
4520 A default template-argument shall not be specified in a
4521 function template declaration or a function template definition, nor
4522 in the template-parameter-list of the definition of a member of a
4523 class template. */
4526 /* You can't have a function template declaration in a local
4527 scope, nor you can you define a member of a class template in a
4528 local scope. */
4534 /* A lambda doesn't have an explicit declaration; don't complain
4535 about the parms of the enclosing class. */
4542 /* If this is either a friend defined in the scope of the class
4543 or a member function. */
4549 /* And, if it was a member function, it really was defined in
4550 the scope of the class. */
4553 /* We already checked these parameters when the template was
4554 declared, so there's no need to do it again now. This function
4555 was defined in class scope, but we're processing its body now
4556 that the class is complete. */
4559 /* Core issue 226 (C++0x only): the following only applies to class
4560 templates. */
4563 {
4564 /* [temp.param]
4566 If a template-parameter has a default template-argument, all
4567 subsequent template-parameters shall have a default
4568 template-argument supplied. */
4570 {
4577 {
4587 {
4589 /* For better subsequent error-recovery, we indicate that
4590 there should have been a default argument. */
4593 }
4595 && !is_friend_decl
4596 /* Don't complain about an enclosing partial
4597 specialization. */
4602 {
4603 /* A primary class template can only have one
4604 parameter pack, at the end of the template
4605 parameter list. */
4610 else
4618 }
4619 }
4620 }
4621 }
4624 || is_partial
4625 || !is_primary
4627 /* For an ordinary class template, default template arguments are
4628 allowed at the innermost level, e.g.:
4629 template <class T = int>
4630 struct S {};
4631 but, in a partial specialization, they're not allowed even
4632 there, as we have in [temp.class.spec]:
4634 The template parameter list of a specialization shall not
4635 contain default template argument values.
4637 So, for a partial specialization, or for a function template
4638 (in C++98/C++03), we look at all of them. */
4639 ;
4640 else
4641 /* But, for a primary class template that is not a partial
4642 specialization we look at all template parameters except the
4643 innermost ones. */
4646 /* Figure out what error message to issue. */
4659 else
4663 /* If we're inside a class definition, there's no need to
4664 examine the parameters to the class itself. On the one
4665 hand, they will be checked when the class is defined, and,
4666 on the other, default arguments are valid in things like:
4667 template <class T = double>
4668 struct S { template <class U> void f(U); };
4669 Here the default argument for `S' has no bearing on the
4670 declaration of `f'. */
4672 else
4673 /* Check everything. */
4679 {
4686 {
4691 {
4693 {
4700 }
4702 /* Clear out the default argument so that we are not
4703 confused later. */
4705 }
4706 }
4708 /* At this point, if we're still interested in issuing messages,
4709 they must apply to classes surrounding the object declared. */
4713 }
4716 }
4718 /* Worker for push_template_decl_real, called via
4719 for_each_template_parm. DATA is really an int, indicating the
4720 level of the parameters we are interested in. If T is a template
4721 parameter of that level, return nonzero. */
4723 static int
4725 {
4731 else
4734 }
4736 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4737 parameters given by current_template_args, or reuses a
4738 previously existing one, if appropriate. Returns the DECL, or an
4739 equivalent one, if it is replaced via a call to duplicate_decls.
4741 If IS_FRIEND is true, DECL is a friend declaration. */
4743 tree
4745 {
4746 tree tmpl;
4747 tree args;
4748 tree info;
4749 tree ctx;
4753 /* True if the template is a member template, in the sense of
4754 [temp.mem]. */
4760 /* See if this is a partial specialization. */
4769 /* For a friend, we want the context of the friend function, not
4770 the type of which it is a friend. */
4774 /* In the case of a virtual function, we want the class in which
4775 it is defined. */
4777 else
4778 /* Otherwise, if we're currently defining some class, the DECL
4779 is assumed to be a member of the class. */
4788 /* See if this is a primary template. */
4790 /* A friend template that specifies a class context, i.e.
4791 template <typename T> friend void A<T>::f();
4792 is not primary. */
4794 else
4798 {
4803 {
4806 }
4808 {
4810 {
4811 /* [temp.mem]
4813 A destructor shall not be a member template. */
4816 }
4823 {
4824 /* [basic.stc.dynamic.allocation]
4826 An allocation function can be a function
4827 template. ... Template allocation functions shall
4828 have two or more parameters. */
4831 }
4832 }
4838 /* alias-declaration */
4840 else
4841 {
4844 }
4845 }
4847 /* Check to see that the rules regarding the use of default
4848 arguments are not being violated. */
4852 /* Ensure that there are no parameter packs in the type of this
4853 declaration that have not been expanded. */
4855 {
4856 /* Check each of the arguments individually to see if there are
4857 any bare parameter packs. */
4863 {
4866 {
4867 /* This is a PARM_DECL that contains unexpanded parameter
4868 packs. We have already complained about this in the
4869 check_for_bare_parameter_packs call, so just replace
4870 these types with ERROR_MARK_NODE. */
4873 }
4877 }
4879 /* Check for bare parameter packs in the return type and the
4880 exception specifiers. */
4882 /* Errors were already issued, set return type to int
4883 as the frontend doesn't expect error_mark_node as
4884 the return type. */
4888 }
4893 {
4896 }
4909 {
4914 /* If DECL is a TYPE_DECL for a class-template, then there won't
4915 be DECL_LANG_SPECIFIC. The information equivalent to
4916 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4920 {
4921 /* Since a template declaration already existed for this
4922 class-type, we must be redeclaring it here. Make sure
4923 that the redeclaration is valid. */
4925 current_template_parms,
4926 current_template_reqs);
4927 /* We don't need to create a new TEMPLATE_DECL; just use the
4928 one we already had. */
4930 }
4931 else
4932 {
4934 current_template_parms,
4935 current_template_reqs,
4936 member_template_p);
4941 {
4942 /* A specialization of a member template of a template
4943 class. */
4947 }
4948 }
4949 }
4950 else
4951 {
4957 {
4960 }
4968 {
4969 tree new_tmpl;
4971 /* The declaration is a specialization of a member
4972 template, declared outside the class. Therefore, the
4973 innermost template arguments will be NULL, so we
4974 replace them with the arguments determined by the
4975 earlier call to check_explicit_specialization. */
4979 current_template_parms,
4980 current_template_reqs,
4981 member_template_p);
4990 args,
4993 }
4995 /* Make sure the template headers we got make sense. */
5000 {
5003 }
5004 else
5006 {
5011 {
5015 else
5019 /* Avoid crash in import_export_decl. */
5022 }
5027 /* Can happen in erroneous input. */
5029 else
5031 }
5033 /* Check that the parms are used in the appropriate qualifying scopes
5034 in the declarator. */
5038 {
5044 /* Avoid crash in import_export_decl. */
5047 }
5048 }
5053 /* Push template declarations for global functions and types. Note
5054 that we do not try to push a global template friend declared in a
5055 template class; such a thing may well depend on the template
5056 parameters of the class. */
5059 {
5064 /* Hide template friend classes that haven't been declared yet. */
5066 {
5069 }
5070 }
5073 {
5079 {
5082 /* It is a conversion operator. See if the type converted to
5083 depends on innermost template operands. */
5086 depth))
5088 }
5090 /* Give template template parms a DECL_CONTEXT of the template
5091 for which they are a parameter. */
5094 {
5098 }
5099 }
5101 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5102 back to its most general template. If TMPL is a specialization,
5103 ARGS may only have the innermost set of arguments. Add the missing
5104 argument levels if necessary. */
5112 else
5113 {
5118 }
5121 }
5123 tree
5125 {
5127 }
5129 /* FN is an inheriting constructor that inherits from the constructor
5130 template INHERITED; turn FN into a constructor template with a matching
5131 template header. */
5133 tree
5135 {
5136 tree inner_parms
5139 tree parms
5145 // If the inherited constructor was constrained, then also
5146 // propagate the constraints to the new declaration by
5147 // rewriting them in terms of the local template parameters.
5150 {
5155 }
5163 }
5165 /* Called when a class template TYPE is redeclared with the indicated
5166 template PARMS, e.g.:
5168 template <class T> struct S;
5169 template <class T> struct S {}; */
5171 bool
5173 {
5174 tree tmpl;
5175 tree tmpl_parms;
5179 {
5182 }
5186 /* The type is nested in some template class. Nothing to worry
5187 about here; there are no new template parameters for the nested
5188 type. */
5192 {
5194 tmpl);
5196 }
5202 {
5212 }
5215 {
5216 tree tmpl_parm;
5217 tree parm;
5218 tree tmpl_default;
5219 tree parm_default;
5233 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5234 TEMPLATE_DECL. */
5244 {
5248 }
5251 {
5252 /* We have in [temp.param]:
5254 A template-parameter may not be given default arguments
5255 by two different declarations in the same scope. */
5260 }
5263 /* Update the previous template parameters (which are the ones
5264 that will really count) with the new default value. */
5267 /* Update the new parameters, too; they'll be used as the
5268 parameters for any members. */
5270 }
5272 // Cannot redeclare a class template with a different set of constraints.
5274 {
5279 }
5282 }
5284 /* Simplify EXPR if it is a non-dependent expression. Returns the
5285 (possibly simplified) expression. */
5287 tree
5289 {
5293 /* If we're in a template, but EXPR isn't value dependent, simplify
5294 it. We're supposed to treat:
5296 template <typename T> void f(T[1 + 1]);
5297 template <typename T> void f(T[2]);
5299 as two declarations of the same function, for example. */
5303 {
5304 HOST_WIDE_INT saved_processing_template_decl;
5310 complain,
5315 }
5317 }
5319 tree
5321 {
5323 }
5325 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5326 template declaration, or a TYPE_DECL for an alias declaration. */
5328 bool
5330 {
5338 }
5340 /* Return TRUE iff is a specialization of an alias template. */
5342 bool
5344 {
5352 }
5354 /* Return either TMPL or another template that it is equivalent to under DR
5355 1286: An alias that just changes the name of a template is equivalent to
5356 the other template. */
5358 static tree
5360 {
5363 {
5366 {
5370 {
5371 /* The alias type is equivalent to the pattern of the
5372 underlying template, so strip the alias. */
5375 }
5376 }
5378 }
5380 }
5382 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5383 must be a function or a pointer-to-function type, as specified
5384 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5385 and check that the resulting function has external linkage. */
5387 static tree
5389 {
5392 linkage_kind linkage;
5404 /* [temp.arg.nontype]/1
5406 A template-argument for a non-type, non-template template-parameter
5407 shall be one of:
5408 [...]
5409 -- the address of an object or function with external [C++11: or
5410 internal] linkage. */
5413 {
5417 else
5420 }
5424 {
5429 else
5434 }
5437 }
5439 /* Subroutine of convert_nontype_argument.
5440 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5441 Emit an error otherwise. */
5443 static bool
5445 tsubst_flags_t complain)
5446 {
5453 {
5457 }
5459 }
5461 /* Returns TRUE iff the address of OP is value-dependent.
5463 14.6.2.4 [temp.dep.temp]:
5464 A non-integral non-type template-argument is dependent if its type is
5465 dependent or it has either of the following forms
5466 qualified-id
5467 & qualified-id
5468 and contains a nested-name-specifier which specifies a class-name that
5469 names a dependent type.
5471 We generalize this to just say that the address of a member of a
5472 dependent class is value-dependent; the above doesn't cover the
5473 address of a static data member named with an unqualified-id. */
5475 static bool
5477 {
5478 /* We could use get_inner_reference here, but there's no need;
5479 this is only relevant for template non-type arguments, which
5480 can only be expressed as &id-expression. */
5482 {
5486 }
5489 }
5491 /* The next set of functions are used for providing helpful explanatory
5492 diagnostics for failed overload resolution. Their messages should be
5493 indented by two spaces for consistency with the messages in
5494 call.c */
5496 static int
5498 {
5500 }
5502 static int
5504 {
5509 }
5511 static int
5513 {
5515 }
5517 static int
5519 {
5525 }
5527 static int
5529 {
5533 }
5535 static int
5537 {
5540 " template parameter %qD is not a parameter pack, but "
5544 }
5546 static int
5548 {
5551 " template argument %qE does not match "
5555 }
5557 static int
5559 {
5563 }
5565 static int
5567 {
5573 }
5575 static int
5577 {
5579 {
5584 else
5586 " deduced conflicting values for non-type parameter "
5588 }
5590 }
5592 static int
5594 {
5597 " variable-sized array type %qT is not "
5599 arg);
5601 }
5603 static int
5605 {
5609 arg);
5611 }
5613 static int
5615 {
5622 }
5624 static int
5626 {
5628 }
5630 static int
5632 {
5634 }
5636 static int
5639 {
5645 }
5647 static int
5650 {
5653 {
5661 }
5663 }
5665 static int
5667 {
5670 " template parameters of a template template argument are "
5673 }
5675 static int
5677 {
5683 }
5685 static int
5687 {
5692 }
5694 static int
5696 {
5700 arg);
5702 }
5704 /* Attempt to convert the non-type template parameter EXPR to the
5705 indicated TYPE. If the conversion is successful, return the
5706 converted value. If the conversion is unsuccessful, return
5707 NULL_TREE if we issued an error message, or error_mark_node if we
5708 did not. We issue error messages for out-and-out bad template
5709 parameters, but not simply because the conversion failed, since we
5710 might be just trying to do argument deduction. Both TYPE and EXPR
5711 must be non-dependent.
5713 The conversion follows the special rules described in
5714 [temp.arg.nontype], and it is much more strict than an implicit
5715 conversion.
5717 This function is called twice for each template argument (see
5718 lookup_template_class for a more accurate description of this
5719 problem). This means that we need to handle expressions which
5720 are not valid in a C++ source, but can be created from the
5721 first call (for instance, casts to perform conversions). These
5722 hacks can go away after we fix the double coercion problem. */
5724 static tree
5726 {
5727 tree expr_type;
5729 /* Detect immediately string literals as invalid non-type argument.
5730 This special-case is not needed for correctness (we would easily
5731 catch this later), but only to provide better diagnostic for this
5732 common user mistake. As suggested by DR 100, we do not mention
5733 linkage issues in the diagnostic as this is not the point. */
5734 /* FIXME we're making this OK. */
5736 {
5742 }
5744 /* Add the ADDR_EXPR now for the benefit of
5745 value_dependent_expression_p. */
5748 {
5752 }
5754 /* If we are in a template, EXPR may be non-dependent, but still
5755 have a syntactic, rather than semantic, form. For example, EXPR
5756 might be a SCOPE_REF, rather than the VAR_DECL to which the
5757 SCOPE_REF refers. Preserving the qualifying scope is necessary
5758 so that access checking can be performed when the template is
5759 instantiated -- but here we need the resolved form so that we can
5760 convert the argument. */
5771 else
5774 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5775 to a non-type argument of "nullptr". */
5779 /* In C++11, integral or enumeration non-type template arguments can be
5780 arbitrary constant expressions. Pointer and pointer to
5781 member arguments can be general constant expressions that evaluate
5782 to a null value, but otherwise still need to be of a specific form. */
5784 {
5786 /* A PTRMEM_CST is already constant, and a valid template
5787 argument for a parameter of pointer to member type, we just want
5788 to leave it in that form rather than lower it to a
5793 {
5798 }
5799 }
5801 /* HACK: Due to double coercion, we can get a
5802 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5803 which is the tree that we built on the first call (see
5804 below when coercing to reference to object or to reference to
5805 function). We just strip everything and get to the arg.
5806 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5807 for examples. */
5809 {
5815 {
5816 /* ??? Maybe we could use convert_from_reference here, but we
5817 would need to relax its constraints because the NOP_EXPR
5818 could actually change the type to something more cv-qualified,
5819 and this is not folded by convert_from_reference. */
5824 && (same_type_ignoring_top_level_qualifiers_p
5827 {
5830 }
5831 }
5832 }
5834 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5835 parameter is a pointer to object, through decay and
5836 qualification conversion. Let's strip everything. */
5838 {
5843 {
5844 /* Skip the ADDR_EXPR only if it is part of the decay for
5845 an array. Otherwise, it is part of the original argument
5846 in the source code. */
5851 }
5852 }
5854 /* [temp.arg.nontype]/5, bullet 1
5856 For a non-type template-parameter of integral or enumeration type,
5857 integral promotions (_conv.prom_) and integral conversions
5858 (_conv.integral_) are applied. */
5860 {
5869 /* Notice that there are constant expressions like '4 % 0' which
5870 do not fold into integer constants. */
5872 {
5874 {
5885 /* else cxx_constant_value complained but gave us
5886 a real constant, so go ahead. */
5888 }
5889 else
5891 }
5893 /* Avoid typedef problems. */
5896 }
5897 /* [temp.arg.nontype]/5, bullet 2
5899 For a non-type template-parameter of type pointer to object,
5900 qualification conversions (_conv.qual_) and the array-to-pointer
5901 conversion (_conv.array_) are applied. */
5903 {
5904 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5906 A template-argument for a non-type, non-template template-parameter
5907 shall be one of: [...]
5909 -- the name of a non-type template-parameter;
5910 -- the address of an object or function with external linkage, [...]
5911 expressed as "& id-expression" where the & is optional if the name
5912 refers to a function or array, or if the corresponding
5913 template-parameter is a reference.
5915 Here, we do not care about functions, as they are invalid anyway
5916 for a parameter of type pointer-to-object. */
5919 /* Non-type template parameters are OK. */
5920 ;
5925 {
5927 {
5929 "because %qD is a variable, not the address of "
5933 }
5935 {
5940 }
5941 /* Other values, like integer constants, might be valid
5942 non-type arguments of some other type. */
5944 }
5945 else
5946 {
5947 tree decl;
5952 {
5957 }
5959 {
5964 }
5966 {
5971 }
5972 }
5981 }
5982 /* [temp.arg.nontype]/5, bullet 3
5984 For a non-type template-parameter of type reference to object, no
5985 conversions apply. The type referred to by the reference may be more
5986 cv-qualified than the (otherwise identical) type of the
5987 template-argument. The template-parameter is bound directly to the
5988 template-argument, which must be an lvalue. */
5990 {
5992 expr_type))
5996 {
6000 }
6003 {
6007 }
6009 /* [temp.arg.nontype]/1
6011 A template-argument for a non-type, non-template template-parameter
6012 shall be one of: [...]
6014 -- the address of an object or function with external linkage. */
6017 {
6020 {
6022 "because a reference variable does not have a constant "
6025 }
6026 }
6029 {
6034 }
6037 {
6042 }
6045 }
6046 /* [temp.arg.nontype]/5, bullet 4
6048 For a non-type template-parameter of type pointer to function, only
6049 the function-to-pointer conversion (_conv.func_) is applied. If the
6050 template-argument represents a set of overloaded functions (or a
6051 pointer to such), the matching function is selected from the set
6052 (_over.over_). */
6054 {
6055 /* If the argument is a template-id, we might not have enough
6056 context information to decay the pointer. */
6058 {
6062 }
6065 /* Null pointer values are OK in C++11. */
6071 }
6072 /* [temp.arg.nontype]/5, bullet 5
6074 For a non-type template-parameter of type reference to function, no
6075 conversions apply. If the template-argument represents a set of
6076 overloaded functions, the matching function is selected from the set
6077 (_over.over_). */
6079 {
6081 {
6086 }
6093 }
6094 /* [temp.arg.nontype]/5, bullet 6
6096 For a non-type template-parameter of type pointer to member function,
6097 no conversions apply. If the template-argument represents a set of
6098 overloaded member functions, the matching member function is selected
6099 from the set (_over.over_). */
6101 {
6106 /* [temp.arg.nontype] bullet 1 says the pointer to member
6107 expression must be a pointer-to-member constant. */
6111 /* There is no way to disable standard conversions in
6112 resolve_address_of_overloaded_function (called by
6113 instantiate_type). It is possible that the call succeeded by
6114 converting &B::I to &D::I (where B is a base of D), so we need
6115 to reject this conversion here.
6117 Actually, even if there was a way to disable standard conversions,
6118 it would still be better to reject them here so that we can
6119 provide a superior diagnostic. */
6121 {
6125 /* If we are just one standard conversion off, explain. */
6130 }
6131 }
6132 /* [temp.arg.nontype]/5, bullet 7
6134 For a non-type template-parameter of type pointer to data member,
6135 qualification conversions (_conv.qual_) are applied. */
6137 {
6138 /* [temp.arg.nontype] bullet 1 says the pointer to member
6139 expression must be a pointer-to-member constant. */
6146 }
6148 {
6150 {
6154 }
6156 }
6157 /* A template non-type parameter must be one of the above. */
6158 else
6161 /* Sanity check: did we actually convert the argument to the
6162 right type? */
6166 }
6168 /* Subroutine of coerce_template_template_parms, which returns 1 if
6169 PARM_PARM and ARG_PARM match using the rule for the template
6170 parameters of template template parameters. Both PARM and ARG are
6171 template parameters; the rest of the arguments are the same as for
6172 coerce_template_template_parms.
6173 */
6174 static int
6176 tree arg,
6177 tsubst_flags_t complain,
6178 tree in_decl,
6179 tree outer_args)
6180 {
6189 {
6191 /* We encounter instantiations of templates like
6192 template <template <template <class> class> class TT>
6193 class C; */
6194 {
6201 }
6202 /* Fall through. */
6207 /* Argument is a parameter pack but parameter is not. */
6212 /* The tsubst call is used to handle cases such as
6214 template <int> class C {};
6215 template <class T, template <T> class TT> class D {};
6216 D<int, C> d;
6218 i.e. the parameter list of TT depends on earlier parameters. */
6220 && !same_type_p
6227 /* Argument is a parameter pack but parameter is not. */
6234 }
6237 }
6240 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6241 template template parameters. Both PARM_PARMS and ARG_PARMS are
6242 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6243 or PARM_DECL.
6245 Consider the example:
6246 template <class T> class A;
6247 template<template <class U> class TT> class B;
6249 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6250 the parameters to A, and OUTER_ARGS contains A. */
6252 static int
6254 tree arg_parms,
6255 tsubst_flags_t complain,
6256 tree in_decl,
6257 tree outer_args)
6258 {
6269 /* Determine whether we have a parameter pack at the end of the
6270 template template parameter's template parameter list. */
6272 {
6279 {
6293 }
6294 }
6300 /* Check all of the template parameters except the parameter pack at
6301 the end (if any). */
6303 {
6312 outer_args))
6315 }
6318 {
6319 /* Check each of the template parameters in the template
6320 argument against the template parameter pack at the end of
6321 the template template parameter. */
6328 {
6335 outer_args))
6337 }
6338 }
6341 }
6343 /* Verifies that the deduced template arguments (in TARGS) for the
6344 template template parameters (in TPARMS) represent valid bindings,
6345 by comparing the template parameter list of each template argument
6346 to the template parameter list of its corresponding template
6347 template parameter, in accordance with DR150. This
6348 routine can only be called after all template arguments have been
6349 deduced. It will return TRUE if all of the template template
6350 parameter bindings are okay, FALSE otherwise. */
6351 bool
6353 {
6357 /* We're dealing with template parms in this process. */
6363 {
6368 {
6373 {
6374 /* Look inside the argument pack. */
6377 }
6380 {
6384 /* Extract the next argument from the argument
6385 pack. */
6389 /* Look at the pattern of the pack expansion. */
6392 /* Extract the template parameters from the template
6393 argument. */
6399 /* Verify that we can coerce the template template
6400 parameters from the template argument to the template
6401 parameter. This requires an exact match. */
6403 && !coerce_template_template_parms
6405 targ_parms,
6406 tf_none,
6407 tparm,
6408 targs))
6409 {
6412 }
6413 }
6414 }
6415 }
6417 out:
6421 }
6423 /* Since type attributes aren't mangled, we need to strip them from
6424 template type arguments. */
6426 static tree
6428 {
6429 tree mv;
6436 {
6441 }
6443 }
6445 // A template declaration can be substituted for a constrained
6446 // template template parameter only when the argument is more
6447 // constrained than the parameter.
6448 static bool
6450 {
6451 // TODO: The argument may not have a decl result. This seems to
6452 // happen in some classes with nested template template
6453 // parameters (e.g., a rebind struct in a class taking a template
6454 // template parameter. If this is the case, just return true and
6455 // allow things to happen as they always did.
6457 {
6460 }
6465 // If the template parameter is constrained, we need to rewrite its
6466 // constraints in terms of the ARG's template parameters. This ensures
6467 // that all of the template parameter types will have the same depth.
6468 //
6469 // Note that this is only valid when coerce_template_template_parm is
6470 // true for the innermost template parameters of PARM and ARG. In other
6471 // words, because coercion is successful, this conversion will be valid.
6473 {
6481 }
6484 }
6486 // Convert a placeholder argument into a binding to the original
6487 // parameter. The original parameter is saved as the TREE_TYPE of
6488 // ARG.
6491 {
6494 }
6496 /* Convert the indicated template ARG as necessary to match the
6497 indicated template PARM. Returns the converted ARG, or
6498 error_mark_node if the conversion was unsuccessful. Error and
6499 warning messages are issued under control of COMPLAIN. This
6500 conversion is for the Ith parameter in the parameter list. ARGS is
6501 the full set of template arguments deduced so far. */
6503 static tree
6505 tree arg,
6506 tree args,
6507 tsubst_flags_t complain,
6509 tree in_decl)
6510 {
6511 tree orig_arg;
6512 tree val;
6515 // Trivially convert placeholders.
6521 {
6522 /* The template argument was the name of some
6523 member function. That's usually
6524 invalid, but static members are OK. In any
6525 case, grab the underlying fields/functions
6526 and issue an error later if required. */
6529 }
6537 /* When determining whether an argument pack expansion is a template,
6538 look at the pattern. */
6542 /* Deal with an injected-class-name used as a template template arg. */
6544 {
6547 {
6557 }
6558 }
6560 is_tmpl_type =
6576 {
6578 {
6582 }
6585 "to refer to a type member of a template parameter, "
6590 typename_type,
6591 complain);
6594 }
6596 {
6598 {
6600 {
6610 else
6612 }
6613 }
6615 }
6617 {
6619 {
6625 else
6627 }
6629 }
6632 {
6634 {
6638 /* The number of argument required is not known yet.
6639 Just accept it for now. */
6641 else
6642 {
6646 /* Strip alias templates that are equivalent to another
6647 template. */
6653 args))
6654 {
6657 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6658 TEMPLATE_DECL. */
6660 {
6665 }
6666 }
6667 else
6668 {
6670 {
6676 }
6679 }
6681 // Check that the constraints are compatible before allowing the
6682 // substitution.
6685 {
6687 {
6693 }
6695 }
6696 }
6697 }
6698 else
6700 /* We only form one instance of each template specialization.
6701 Therefore, if we use a non-canonical variant (i.e., a
6702 typedef), any future messages referring to the type will use
6703 the typedef, which is confusing if those future uses do not
6704 themselves also use the typedef. */
6707 }
6708 else
6709 {
6716 {
6719 else
6720 {
6721 /* Not sure if this is reachable, but it doesn't hurt
6722 to be robust. */
6725 }
6726 }
6729 /* We used to call digest_init here. However, digest_init
6730 will report errors, which we don't want when complain
6731 is zero. More importantly, digest_init will try too
6732 hard to convert things: for example, `0' should not be
6733 converted to pointer type at this point according to
6734 the standard. Accepting this is not merely an
6735 extension, since deciding whether or not these
6736 conversions can occur is part of determining which
6737 function template to call, or whether a given explicit
6738 argument specification is valid. */
6740 else
6749 {
6750 /* Strip typedefs from the SCOPE_REF. */
6753 complain);
6756 }
6757 }
6760 }
6762 /* Coerces the remaining template arguments in INNER_ARGS (from
6763 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6764 Returns the coerced argument pack. PARM_IDX is the position of this
6765 parameter in the template parameter list. ARGS is the original
6766 template argument list. */
6767 static tree
6770 tree args,
6771 tree inner_args,
6773 tree new_args,
6775 tree in_decl,
6776 tsubst_flags_t complain)
6777 {
6780 tree packed_args;
6781 tree argument_pack;
6791 {
6792 /* When the template parameter is a non-type template
6793 parameter pack whose type uses parameter packs, we need
6794 to look at each of the template arguments
6795 separately. Build a vector of the types for these
6796 non-type template parameters in PACKED_TYPES. */
6797 tree expansion
6805 /* Check that we have the right number of arguments. */
6809 {
6810 int needed_parms
6815 }
6817 /* If we aren't able to check the actual arguments now
6818 (because they haven't been expanded yet), we can at least
6819 verify that all of the types used for the non-type
6820 template parameter pack are, in fact, valid for non-type
6821 template parameters. */
6824 {
6827 {
6831 }
6832 }
6833 }
6835 /* Convert the remaining arguments, which will be a part of the
6836 parameter pack "parm". */
6838 {
6843 {
6844 /* When we have a vector of types (corresponding to the
6845 non-type template parameter pack that uses parameter
6846 packs in its type, as mention above), and the
6847 argument is not an expansion (which expands to a
6848 currently unknown number of arguments), clone the
6849 parm and give it the next type in PACKED_TYPES. */
6853 }
6856 {
6859 }
6860 else
6863 in_decl);
6867 }
6872 else
6873 {
6878 }
6881 #ifdef ENABLE_CHECKING
6884 #endif
6886 }
6888 /* Returns the number of pack expansions in the template argument vector
6889 ARGS. */
6891 static int
6893 {
6898 {
6902 }
6904 }
6906 /* Convert all template arguments to their appropriate types, and
6907 return a vector containing the innermost resulting template
6908 arguments. If any error occurs, return error_mark_node. Error and
6909 warning messages are issued under control of COMPLAIN.
6911 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6912 for arguments not specified in ARGS. Otherwise, if
6913 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6914 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6915 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6916 ARGS. */
6918 static tree
6920 tree args,
6921 tree in_decl,
6922 tsubst_flags_t complain,
6925 {
6927 tree inner_args;
6928 tree new_args;
6929 tree new_inner_args;
6933 /* When used as a boolean value, indicates whether this is a
6934 variadic template parameter list. Since it's an int, we can also
6935 subtract it from nparms to get the number of non-variadic
6936 parameters. */
6946 /* Determine if there are any parameter packs. */
6948 {
6954 }
6957 /* If there are no parameters that follow a parameter pack, we need to
6958 expand any argument packs so that we can deduce a parameter pack from
6959 some non-packed args followed by an argument pack, as in variadic85.C.
6960 If there are such parameters, we need to leave argument packs intact
6961 so the arguments are assigned properly. This can happen when dealing
6962 with a nested class inside a partial specialization of a class
6963 template, as in variadic92.C, or when deducing a template parameter pack
6964 from a sub-declarator, as in variadic114.C. */
6968 /* Count any pack expansion args. */
6974 && require_all_args
6975 && !variadic_args_p
6976 && (!use_default_args
6979 {
6981 {
6983 {
6987 }
6988 else
6994 }
6997 }
6998 /* We can't pass a pack expansion to a non-pack parameter of an alias
6999 template (DR 1430). */
7001 && variadic_args_p
7003 {
7005 {
7007 {
7013 {
7018 }
7019 }
7021 found:;
7022 }
7024 }
7026 /* We need to evaluate the template arguments, even though this
7027 template-id may be nested within a "sizeof". */
7035 {
7036 tree arg;
7037 tree parm;
7039 /* Get the Ith template parameter. */
7043 {
7046 }
7048 /* Calculate the next argument. */
7051 else
7056 {
7057 /* All remaining arguments will be placed in the
7058 template parameter pack PARM. */
7064 /* Store this argument. */
7066 lost++;
7069 /* We are done with all of the arguments. */
7073 }
7075 {
7077 {
7078 /* We don't know how many args we have yet, just
7079 use the unconverted ones for now. */
7082 }
7083 }
7085 {
7086 /* There must be a default arg in this case. */
7089 /* The position of the first default template argument,
7090 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7091 Record that. */
7094 }
7095 else
7099 {
7102 }
7104 /* This only occurs if there was an error in the template
7105 parameter list itself (which we would already have
7106 reported) that we are trying to recover from, e.g., a class
7107 template with a parameter list such as
7108 template<typename..., typename>. */
7110 else
7116 lost++;
7118 }
7125 #ifdef ENABLE_CHECKING
7129 #endif
7132 }
7134 // Convert all template arguments to their appropriate types, and
7135 // return a vector containing the innermost resulting template
7136 // arguments. If any error occurs, return error_mark_node. Error and
7137 // warning messages are not issued.
7138 //
7139 // Note that no function argument deduction is performed, and default
7140 // arguments are used to fill in unspecified arguments.
7141 tree
7143 {
7145 }
7147 /* Like coerce_template_parms. If PARMS represents all template
7148 parameters levels, this function returns a vector of vectors
7149 representing all the resulting argument levels. Note that in this
7150 case, only the innermost arguments are coerced because the
7151 outermost ones are supposed to have been coerced already.
7153 Otherwise, if PARMS represents only (the innermost) vector of
7154 parameters, this function returns a vector containing just the
7155 innermost resulting arguments. */
7157 static tree
7159 tree args,
7160 tree in_decl,
7161 tsubst_flags_t complain,
7164 {
7167 tree coerced_args;
7170 {
7172 tree level;
7178 {
7179 tree l;
7183 require_all_args,
7184 use_default_args);
7185 else
7192 }
7193 }
7194 else
7197 require_all_args,
7198 use_default_args);
7200 }
7202 /* Returns 1 if template args OT and NT are equivalent. */
7204 static int
7206 {
7213 /* For member templates */
7222 {
7239 }
7241 {
7242 /* We get here probably because we are in the middle of substituting
7243 into the pattern of a pack expansion. In that case the
7244 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7245 interested in. So we want to use the initial pack argument for
7246 the comparison. */
7251 }
7256 else
7258 }
7260 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7261 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7262 NEWARG_PTR with the offending arguments if they are non-NULL. */
7264 static int
7267 {
7280 {
7285 {
7291 }
7292 }
7294 }
7296 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7297 of template arguments. Returns 0 otherwise. */
7299 int
7301 {
7303 }
7305 static void
7307 {
7317 /* We are called both from instantiate_decl, where we've already had a
7318 tinst_level pushed, and instantiate_template, where we haven't.
7319 Compensate. */
7330 else
7339 }
7342 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7343 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7344 documentation for TEMPLATE_ID_EXPR. */
7346 tree
7348 {
7349 tree type;
7357 {
7360 }
7363 {
7365 unknown_type_node,
7367 arglist);
7369 }
7376 }
7378 /* Within the scope of a template class S<T>, the name S gets bound
7379 (in build_self_reference) to a TYPE_DECL for the class, not a
7380 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7381 or one of its enclosing classes, and that type is a template,
7382 return the associated TEMPLATE_DECL. Otherwise, the original
7383 DECL is returned.
7385 Also handle the case when DECL is a TREE_LIST of ambiguous
7386 injected-class-names from different bases. */
7388 tree
7390 {
7394 /* DR 176: A lookup that finds an injected-class-name (10.2
7395 [class.member.lookup]) can result in an ambiguity in certain cases
7396 (for example, if it is found in more than one base class). If all of
7397 the injected-class-names that are found refer to specializations of
7398 the same class template, and if the name is followed by a
7399 template-argument-list, the reference refers to the class template
7400 itself and not a specialization thereof, and is not ambiguous. */
7402 {
7405 {
7411 }
7414 else
7416 }
7422 }
7424 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7425 parameters, find the desired type.
7427 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7429 IN_DECL, if non-NULL, is the template declaration we are trying to
7430 instantiate.
7432 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7433 the class we are looking up.
7435 Issue error and warning messages under control of COMPLAIN.
7437 If the template class is really a local class in a template
7438 function, then the FUNCTION_CONTEXT is the function in which it is
7439 being instantiated.
7441 ??? Note that this function is currently called *twice* for each
7442 template-id: the first time from the parser, while creating the
7443 incomplete type (finish_template_type), and the second type during the
7444 real instantiation (instantiate_template_class). This is surely something
7445 that we want to avoid. It also causes some problems with argument
7446 coercion (see convert_nontype_argument for more information on this). */
7448 static tree
7451 {
7453 tree t;
7456 spec_entry elt;
7457 hashval_t hash;
7460 {
7464 else
7465 {
7472 }
7475 }
7477 {
7480 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7481 an implicit typename for the second A. Deal with it. */
7486 {
7489 }
7490 }
7493 {
7496 }
7500 {
7504 }
7506 {
7509 }
7511 /* Issue an error message if we didn't find a template. */
7513 {
7517 }
7520 /* Make sure it's a user visible template, if it was named by
7521 the user. */
7524 {
7526 {
7530 }
7532 }
7536 /* An alias that just changes the name of a template is equivalent to the
7537 other template, so if any of the arguments are pack expansions, strip
7538 the alias to avoid problems with a pack expansion passed to a non-pack
7539 alias template parameter (DR 1430). */
7544 {
7545 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7546 template arguments */
7548 tree parm;
7549 tree arglist2;
7550 tree outer;
7554 /* Consider an example where a template template parameter declared as
7556 template <class T, class U = std::allocator<T> > class TT
7558 The template parameter level of T and U are one level larger than
7559 of TT. To proper process the default argument of U, say when an
7560 instantiation `TT<int>' is seen, we need to build the full
7561 arguments containing {int} as the innermost level. Outer levels,
7562 available when not appearing as default template argument, can be
7563 obtained from the arguments of the enclosing template.
7565 Suppose that TT is later substituted with std::vector. The above
7566 instantiation is `TT<int, std::allocator<T> >' with TT at
7567 level 1, and T at level 2, while the template arguments at level 1
7568 becomes {std::vector} and the inner level 2 is {int}. */
7574 /* This is an argument of the current template, so we haven't set
7575 DECL_CONTEXT yet. */
7582 complain,
7592 }
7593 else
7594 {
7596 tree gen_tmpl;
7597 tree type_decl;
7605 /* An error occurred while building the template TEMPL, and a
7606 diagnostic has most certainly been emitted for that
7607 already. Let's propagate that error. */
7616 {
7617 /* We've been given an incomplete set of template arguments.
7618 For example, given:
7620 template <class T> struct S1 {
7621 template <class U> struct S2 {};
7622 template <class U> struct S2<U*> {};
7623 };
7625 we will be called with an ARGLIST of `U*', but the
7626 TEMPLATE will be `template <class T> template
7627 <class U> struct S1<T>::S2'. We must fill in the missing
7628 arguments. */
7629 arglist
7631 arglist);
7633 }
7635 /* Now we should have enough arguments. */
7638 /* From here on, we're only interested in the most general
7639 template. */
7641 /* Calculate the BOUND_ARGS. These will be the args that are
7642 actually tsubst'd into the definition to create the
7643 instantiation. */
7645 {
7646 /* We have multiple levels of arguments to coerce, at once. */
7656 {
7657 tree a;
7661 complain,
7664 else
7665 /* Outer levels should have already been coerced. */
7668 /* Don't process further if one of the levels fails. */
7670 {
7671 /* Restore the ARGLIST to its full size. */
7674 }
7678 /* We temporarily reduce the length of the ARGLIST so
7679 that coerce_template_parms will see only the arguments
7680 corresponding to the template parameters it is
7681 examining. */
7683 }
7685 /* Restore the ARGLIST to its full size. */
7689 }
7690 else
7691 arglist
7694 gen_tmpl,
7695 complain,
7700 /* We were unable to bind the arguments. */
7703 /* In the scope of a template class, explicit references to the
7704 template class refer to the type of the template, not any
7705 instantiation of it. For example, in:
7707 template <class T> class C { void f(C<T>); }
7709 the `C<T>' is just the same as `C'. Outside of the
7710 class, however, such a reference is an instantiation. */
7714 /* comp_template_args is expensive, check it last. */
7716 arglist))
7719 /* If we already have this specialization, return it. */
7729 // If the the template's constraints are not satisfied, then we
7730 // cannot form a valid type.
7731 //
7732 // Note that the check is deferred until after the hash-lookup.
7733 // This prevents redundant checks on specializations.
7735 {
7736 // Diagnose constraints here since they are not diagnosed
7737 // anywhere else.
7739 {
7742 }
7744 }
7748 /* If the deduced arguments are invalid, then the binding
7749 failed. */
7753 complain))
7760 {
7765 }
7775 /* Create the type. */
7777 {
7778 /* The user referred to a specialization of an alias
7779 template represented by GEN_TMPL.
7781 [temp.alias]/2 says:
7783 When a template-id refers to the specialization of an
7784 alias template, it is equivalent to the associated
7785 type obtained by substitution of its
7786 template-arguments for the template-parameters in the
7787 type-id of the alias template. */
7790 /* Note that the call above (by indirectly calling
7791 register_specialization in tsubst_decl) registers the
7792 TYPE_DECL representing the specialization of the alias
7793 template. So next time someone substitutes ARGLIST for
7794 the template parms into the alias template (GEN_TMPL),
7795 she'll get that TYPE_DECL back. */
7799 }
7801 {
7803 {
7809 }
7810 else
7811 {
7812 /* We don't want to call start_enum for this type, since
7813 the values for the enumeration constants may involve
7814 template parameters. And, no one should be interested
7815 in the enumeration constants for such a type. */
7818 }
7822 }
7824 {
7831 /* A local class. Make sure the decl gets registered properly. */
7836 /* This instantiation is another name for the primary
7837 template type. Set the TYPE_CANONICAL field
7838 appropriately. */
7841 /* Some of the template arguments require structural
7842 equality testing, so this template class requires
7843 structural equality testing. */
7845 }
7846 else
7849 /* If we called start_enum or pushtag above, this information
7850 will already be set up. */
7852 {
7859 }
7860 else
7864 {
7870 {
7873 }
7874 }
7876 /* Let's consider the explicit specialization of a member
7877 of a class template specialization that is implicitely instantiated,
7878 e.g.:
7879 template<class T>
7880 struct S
7881 {
7882 template<class U> struct M {}; //#0
7883 };
7885 template<>
7886 template<>
7887 struct S<int>::M<char> //#1
7888 {
7889 int i;
7890 };
7891 [temp.expl.spec]/4 says this is valid.
7893 In this case, when we write:
7894 S<int>::M<char> m;
7896 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7897 the one of #0.
7899 When we encounter #1, we want to store the partial instantiation
7900 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7902 For all cases other than this "explicit specialization of member of a
7903 class template", we just want to store the most general template into
7904 the CLASSTYPE_TI_TEMPLATE of M.
7906 This case of "explicit specialization of member of a class template"
7907 only happens when:
7908 1/ the enclosing class is an instantiation of, and therefore not
7909 the same as, the context of the most general template, and
7910 2/ we aren't looking at the partial instantiation itself, i.e.
7911 the innermost arguments are not the same as the innermost parms of
7912 the most general template.
7914 So it's only when 1/ and 2/ happens that we want to use the partial
7915 instantiation of the member template in lieu of its most general
7916 template. */
7920 /* the enclosing class must be an instantiation... */
7923 {
7924 tree partial_inst_args;
7927 partial_inst_args =
7933 use_partial_inst_tmpl =
7934 /*...and we must not be looking at the partial instantiation
7935 itself. */
7937 partial_inst_args);
7938 }
7941 /* This case is easy; there are no member templates involved. */
7943 else
7944 {
7945 /* This is a full instantiation of a member template. Find
7946 the partial instantiation of which this is an instance. */
7948 /* Temporarily reduce by one the number of levels in the ARGLIST
7949 so as to avoid comparing the last set of arguments. */
7953 /* FOUND is either a proper class type, or an alias
7954 template specialization. In the later case, it's a
7955 TYPE_DECL, resulting from the substituting of arguments
7956 for parameters in the TYPE_DECL of the alias template
7957 done earlier. So be careful while getting the template
7958 of FOUND. */
7962 }
7964 // Build template info for the new specialization.
7974 /* Note this use of the partial instantiation so we can check it
7975 later in maybe_process_partial_specialization. */
7982 /* Now that the type has been registered on the instantiations
7983 list, we set up the enumerators. Because the enumeration
7984 constants may involve the enumeration type itself, we make
7985 sure to register the type first, and then create the
7986 constants. That way, doing tsubst_expr for the enumeration
7987 constants won't result in recursive calls here; we'll find
7988 the instantiation and exit above. */
7992 /* If the type makes use of template parameters, the
7993 code that generates debugging information will crash. */
7996 /* Possibly limit visibility based on template args. */
8001 }
8002 }
8004 /* Wrapper for lookup_template_class_1. */
8006 tree
8009 {
8010 tree ret;
8016 }
8017 \f
8018 struct pair_fn_data
8019 {
8020 tree_fn_t fn;
8022 /* True when we should also visit template parameters that occur in
8023 non-deduced contexts. */
8026 };
8028 /* Called from for_each_template_parm via walk_tree. */
8030 static tree
8032 {
8045 {
8049 /* Fall through. */
8072 /* Since we're not going to walk subtrees, we have to do this
8073 explicitly here. */
8077 /* Fall through. */
8080 /* Check the return type. */
8085 /* Check the parameter types. Since default arguments are not
8086 instantiated until they are needed, the TYPE_ARG_TYPES may
8087 contain expressions that involve template parameters. But,
8088 no-one should be looking at them yet. And, once they're
8089 instantiated, they don't contain template parameters, so
8090 there's no point in looking at them then, either. */
8091 {
8092 tree parm;
8099 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8100 want walk_tree walking into them itself. */
8102 }
8120 /* Fall through. */
8136 /* Record template parameters such as `T' inside `TT<T>'. */
8140 /* Fall through. */
8152 /* A template template parameter is encountered. */
8158 /* Already substituted template template parameter */
8181 /* If there's no type, then this thing must be some expression
8182 involving template parameters. */
8204 }
8206 /* We didn't find any template parameters we liked. */
8208 }
8210 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8211 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8212 call FN with the parameter and the DATA.
8213 If FN returns nonzero, the iteration is terminated, and
8214 for_each_template_parm returns 1. Otherwise, the iteration
8215 continues. If FN never returns a nonzero value, the value
8216 returned by for_each_template_parm is 0. If FN is NULL, it is
8217 considered to be the function which always returns 1.
8219 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8220 parameters that occur in non-deduced contexts. When false, only
8221 visits those template parameters that can be deduced. */
8223 static int
8227 {
8231 /* Set up. */
8236 /* Walk the tree. (Conceptually, we would like to walk without
8237 duplicates, but for_each_template_parm_r recursively calls
8238 for_each_template_parm, so we would need to reorganize a fair
8239 bit to use walk_tree_without_duplicates, so we keep our own
8240 visited list.) */
8243 else
8246 for_each_template_parm_r,
8250 /* Clean up. */
8252 {
8255 }
8258 }
8260 /* Returns true if T depends on any template parameter. */
8262 int
8264 {
8291 else
8292 {
8295 }
8300 }
8302 /* Returns true iff current_function_decl is an incompletely instantiated
8303 template. Useful instead of processing_template_decl because the latter
8304 is set to 0 during fold_non_dependent_expr. */
8306 bool
8308 {
8317 }
8319 /* Returns true if T depends on any template parameter with level LEVEL. */
8321 int
8323 {
8326 }
8328 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8329 ill-formed translation unit, i.e. a variable or function that isn't
8330 usable in a constant expression. */
8334 {
8338 }
8340 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8341 neglectable and instantiated from within an erroneous instantiation. */
8343 static bool
8345 {
8356 }
8364 /* We're starting to instantiate D; record the template instantiation context
8365 for diagnostics and to restore it later. */
8367 int
8369 {
8373 {
8379 else
8387 }
8389 /* If the current instantiation caused problems, don't let it instantiate
8390 anything else. Do allow deduction substitution and decls usable in
8391 constant expressions. */
8408 }
8410 /* We're done instantiating this template; return to the instantiation
8411 context. */
8413 void
8415 {
8416 /* Restore the filename and line number stashed away when we started
8417 this instantiation. */
8421 }
8423 /* We're instantiating a deferred template; restore the template
8424 instantiation context in which the instantiation was requested, which
8425 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8427 static tree
8429 {
8441 }
8443 /* Returns the TINST_LEVEL which gives the original instantiation
8444 context. */
8448 {
8454 }
8456 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8457 vector of template arguments, as for tsubst.
8459 Returns an appropriate tsubst'd friend declaration. */
8461 static tree
8463 {
8464 tree new_friend;
8469 /* This was a friend declared with an explicit template
8470 argument list, e.g.:
8472 friend void f<>(T);
8474 to indicate that f was a template instantiation, not a new
8475 function declaration. Now, we have to figure out what
8476 instantiation of what template. */
8477 {
8479 tree new_args;
8480 tree tmpl;
8483 /* Friend functions are looked up in the containing namespace scope.
8484 We must enter that scope, to avoid finding member functions of the
8485 current class with same name. */
8500 tsk_none);
8502 }
8506 /* The NEW_FRIEND will look like an instantiation, to the
8507 compiler, but is not an instantiation from the point of view of
8508 the language. For example, we might have had:
8510 template <class T> struct S {
8511 template <class U> friend void f(T, U);
8512 };
8514 Then, in S<int>, template <class U> void f(int, U) is not an
8515 instantiation of anything. */
8521 {
8525 }
8527 /* The mangled name for the NEW_FRIEND is incorrect. The function
8528 is not a template instantiation and should not be mangled like
8529 one. Therefore, we forget the mangling here; we'll recompute it
8530 later if we need it. */
8532 {
8535 }
8538 {
8539 tree old_decl;
8540 tree new_friend_template_info;
8541 tree new_friend_result_template_info;
8542 tree ns;
8545 /* We must save some information from NEW_FRIEND before calling
8546 duplicate decls since that function will free NEW_FRIEND if
8547 possible. */
8549 new_friend_is_defn =
8554 {
8555 /* This declaration is a `primary' template. */
8558 new_friend_result_template_info
8560 }
8561 else
8564 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8568 /* Inside pushdecl_namespace_level, we will push into the
8569 current namespace. However, the friend function should go
8570 into the namespace of the template. */
8580 {
8581 /* This new friend declaration matched an existing
8582 declaration. For example, given:
8584 template <class T> void f(T);
8585 template <class U> class C {
8586 template <class T> friend void f(T) {}
8587 };
8589 the friend declaration actually provides the definition
8590 of `f', once C has been instantiated for some type. So,
8591 old_decl will be the out-of-class template declaration,
8592 while new_friend is the in-class definition.
8594 But, if `f' was called before this point, the
8595 instantiation of `f' will have DECL_TI_ARGS corresponding
8596 to `T' but not to `U', references to which might appear
8597 in the definition of `f'. Previously, the most general
8598 template for an instantiation of `f' was the out-of-class
8599 version; now it is the in-class version. Therefore, we
8600 run through all specialization of `f', adding to their
8601 DECL_TI_ARGS appropriately. In particular, they need a
8602 new set of outer arguments, corresponding to the
8603 arguments for this class instantiation.
8605 The same situation can arise with something like this:
8607 friend void f(int);
8608 template <class T> class C {
8609 friend void f(T) {}
8610 };
8612 when `C<int>' is instantiated. Now, `f(int)' is defined
8613 in the class. */
8616 /* On the other hand, if the in-class declaration does
8617 *not* provide a definition, then we don't want to alter
8618 existing definitions. We can just leave everything
8619 alone. */
8620 ;
8621 else
8622 {
8626 /* Overwrite whatever template info was there before, if
8627 any, with the new template information pertaining to
8628 the declaration. */
8632 {
8633 /* We should have called reregister_specialization in
8634 duplicate_decls. */
8639 /* Instantiate it if the global has already been used. */
8643 }
8644 else
8645 {
8646 tree t;
8648 /* Indicate that the old function template is a partial
8649 instantiation. */
8657 /* Reassign any specializations already in the hash table
8658 to the new more general template, and add the
8659 additional template args. */
8663 {
8665 spec_entry elt;
8677 register_specialization
8680 }
8682 }
8683 }
8685 /* The information from NEW_FRIEND has been merged into OLD_DECL
8686 by duplicate_decls. */
8688 }
8689 }
8690 else
8691 {
8695 /* In the code
8696 template <class T> class C {
8697 template <class U> friend void C1<U>::f (); // case 1
8698 friend void C2<T>::f (); // case 2
8699 };
8700 we only need to make sure CONTEXT is a complete type for
8701 case 2. To distinguish between the two cases, we note that
8702 CONTEXT of case 1 remains dependent type after tsubst while
8703 this isn't true for case 2. */
8713 {
8714 /* Check to see that the declaration is really present, and,
8715 possibly obtain an improved declaration. */
8721 }
8722 }
8725 }
8727 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8728 template arguments, as for tsubst.
8730 Returns an appropriate tsubst'd friend type or error_mark_node on
8731 failure. */
8733 static tree
8735 {
8736 tree friend_type;
8737 tree tmpl;
8738 tree context;
8741 {
8744 }
8749 {
8752 else
8754 }
8756 /* Look for a class template declaration. We look for hidden names
8757 because two friend declarations of the same template are the
8758 same. For example, in:
8760 struct A {
8761 template <typename> friend class F;
8762 };
8763 template <typename> struct B {
8764 template <typename> friend class F;
8765 };
8767 both F templates are the same. */
8771 /* But, if we don't find one, it might be because we're in a
8772 situation like this:
8774 template <class T>
8775 struct S {
8776 template <class U>
8777 friend struct S;
8778 };
8780 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8781 for `S<int>', not the TEMPLATE_DECL. */
8783 {
8786 }
8789 {
8790 /* The friend template has already been declared. Just
8791 check to see that the declarations match, and install any new
8792 default parameters. We must tsubst the default parameters,
8793 of course. We only need the innermost template parameters
8794 because that is all that redeclare_class_template will look
8795 at. */
8798 {
8799 tree parms;
8800 location_t saved_input_location;
8810 }
8813 }
8814 else
8815 {
8816 /* The friend template has not already been declared. In this
8817 case, the instantiation of the template class will cause the
8818 injection of this template into the global scope. */
8823 /* The new TMPL is not an instantiation of anything, so we
8824 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8825 the new type because that is supposed to be the corresponding
8826 template decl, i.e., TMPL. */
8833 /* Inject this template into the global scope. */
8835 }
8838 {
8841 else
8843 }
8846 }
8848 /* Returns zero if TYPE cannot be completed later due to circularity.
8849 Otherwise returns one. */
8851 static int
8853 {
8863 else
8865 }
8869 /* Apply any attributes which had to be deferred until instantiation
8870 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8871 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8873 static void
8876 {
8878 tree t;
8883 {
8887 }
8890 {
8894 }
8895 else
8899 {
8904 {
8907 {
8914 {
8921 clauses
8925 else
8927 }
8928 /* If the first attribute argument is an identifier, don't
8929 pass it through tsubst. Attributes like mode, format,
8930 cleanup and several target specific attributes expect it
8931 unmodified. */
8933 {
8934 tree chain
8936 in_decl,
8941 chain);
8942 }
8943 else
8949 }
8950 else
8952 }
8955 }
8956 }
8958 /* Perform (or defer) access check for typedefs that were referenced
8959 from within the template TMPL code.
8960 This is a subroutine of instantiate_decl and instantiate_class_template.
8961 TMPL is the template to consider and TARGS is the list of arguments of
8962 that template. */
8964 static void
8966 {
8967 location_t saved_location;
8978 {
8990 /* Make access check error messages point to the location
8991 of the use of the typedef. */
8995 tf_warning_or_error);
8996 }
8998 }
9000 static tree
9002 {
9004 tree typedecl;
9005 tree pbinfo;
9006 tree base_list;
9008 tree fn_context;
9017 /* Figure out which template is being instantiated. */
9021 /* Determine what specialization of the original template to
9022 instantiate. */
9025 {
9028 }
9030 {
9031 /* This TYPE is actually an instantiation of a partial
9032 specialization. We replace the innermost set of ARGS with
9033 the arguments appropriate for substitution. For example,
9034 given:
9036 template <class T> struct S {};
9037 template <class T> struct S<T*> {};
9039 and supposing that we are instantiating S<int*>, ARGS will
9040 presently be {int*} -- but we need {int}. */
9043 }
9044 else
9045 {
9048 }
9050 /* If the template we're instantiating is incomplete, then clearly
9051 there's nothing we can do. */
9055 /* If we've recursively instantiated too many templates, stop. */
9059 /* Now we're really doing the instantiation. Mark the type as in
9060 the process of being defined. */
9063 /* We may be in the middle of deferred access check. Disable
9064 it now. */
9070 /* Use #pragma pack from the template context. */
9076 /* Set the input location to the most specialized template definition.
9077 This is needed if tsubsting causes an error. */
9089 {
9092 /* Adjust visibility for template arguments. */
9094 }
9100 /* We should never instantiate a nested class before its enclosing
9101 class; we need to look up the nested class by name before we can
9102 instantiate it, and that lookup should instantiate the enclosing
9103 class. */
9109 {
9110 tree pbase_binfo;
9111 tree pushed_scope;
9114 /* We must enter the scope containing the type, as that is where
9115 the accessibility of types named in dependent bases are
9116 looked up from. */
9119 /* Substitute into each of the bases to determine the actual
9120 basetypes. */
9122 {
9123 tree base;
9129 {
9130 expanded_bases =
9137 }
9140 {
9142 /* Extract the already-expanded base class. */
9144 else
9145 /* Substitute to figure out the base class. */
9147 NULL_TREE);
9155 }
9156 }
9158 /* The list is now in reverse order; correct that. */
9163 }
9164 /* Now call xref_basetypes to set up all the base-class
9165 information. */
9173 /* Now that our base classes are set up, enter the scope of the
9174 class, so that name lookups into base classes, etc. will work
9175 correctly. This is precisely analogous to what we do in
9176 begin_class_definition when defining an ordinary non-template
9177 class, except we also need to push the enclosing classes. */
9180 /* Now members are processed in the order of declaration. */
9183 {
9187 {
9189 {
9190 /* Build new CLASSTYPE_NESTED_UTDS. */
9192 tree newtag;
9198 /* If the member is a class template, then -- even after
9199 substitution -- there may be dependent types in the
9200 template argument list for the class. We increment
9201 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9202 that function will assume that no types are dependent
9203 when outside of a template. */
9213 {
9217 /* Unfortunately, lookup_template_class sets
9218 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9219 instantiation (i.e., for the type of a member
9220 template class nested within a template class.)
9221 This behavior is required for
9222 maybe_process_partial_specialization to work
9223 correctly, but is not accurate in this case;
9224 the TAG is not an instantiation of anything.
9225 (The corresponding TEMPLATE_DECL is an
9226 instantiation, but the TYPE is not.) */
9229 /* Now, we call pushtag to put this NEWTAG into the scope of
9230 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9231 pushtag calling push_template_decl. We don't have to do
9232 this for enums because it will already have been done in
9233 tsubst_enum. */
9237 }
9238 }
9240 {
9241 /* Build new TYPE_METHODS. */
9242 tree r;
9251 /* Instantiate members marked with attribute used. */
9257 }
9258 else
9259 {
9260 /* Build new TYPE_FIELDS. */
9262 {
9263 tree condition;
9266 condition =
9276 }
9278 {
9279 tree r;
9283 /* The file and line for this declaration, to
9284 assist in error message reporting. Since we
9285 called push_tinst_level above, we don't need to
9286 restore these. */
9296 {
9297 /* A capture pack became multiple fields. */
9300 }
9303 {
9307 {
9308 /* In [temp.inst]:
9310 [t]he initialization (and any associated
9311 side-effects) of a static data member does
9312 not occur unless the static data member is
9313 itself used in a way that requires the
9314 definition of the static data member to
9315 exist.
9317 Therefore, we do not substitute into the
9318 initialized for the static data member here. */
9319 finish_static_data_member_decl
9325 /* Instantiate members marked with attribute used. */
9328 }
9330 {
9331 /* Determine whether R has a valid type and can be
9332 completed later. If R is invalid, then its type
9333 is replaced by error_mark_node. */
9339 {
9342 }
9343 }
9345 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9346 such a thing will already have been added to the field
9347 list by tsubst_enum in finish_member_declaration in the
9348 CLASSTYPE_NESTED_UTDS case above. */
9352 {
9355 }
9356 }
9357 }
9358 }
9359 }
9360 else
9361 {
9364 {
9365 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9371 {
9372 /* template <class T> friend class C; */
9375 }
9377 {
9378 /* template <class T> friend class C::D; */
9384 }
9387 {
9388 /* This could be either
9390 friend class T::C;
9392 when dependent_type_p is false or
9394 template <class U> friend class T::C;
9396 otherwise. */
9399 /* Bump processing_template_decl for correct
9400 dependent_type_p calculation. */
9405 }
9408 {
9409 /* friend class C;
9411 where C hasn't been declared yet. Let's lookup name
9412 from namespace scope directly, bypassing any name that
9413 come from dependent base class. */
9416 /* The call to xref_tag_from_type does injection for friend
9417 classes. */
9419 friend_type =
9423 }
9425 /* friend class C<T>; */
9428 /* Otherwise it's
9430 friend class C;
9432 where C is already declared or
9434 friend class C<int>;
9436 We don't have to do anything in these cases. */
9439 /* Trick make_friend_class into realizing that the friend
9440 we're adding is a template, not an ordinary class. It's
9441 important that we use make_friend_class since it will
9442 perform some error-checking and output cross-reference
9443 information. */
9451 }
9452 else
9453 {
9454 /* Build new DECL_FRIENDLIST. */
9455 tree r;
9457 /* The file and line for this declaration, to
9458 assist in error message reporting. Since we
9459 called push_tinst_level above, we don't need to
9460 restore these. */
9464 {
9467 }
9472 {
9475 }
9476 }
9477 }
9478 }
9481 {
9484 {
9489 /* We need to instantiate the capture list from the template
9490 after we've instantiated the closure members, but before we
9491 consider adding the conversion op. Also keep any captures
9492 that may have been added during instantiation of the op(). */
9494 tree tmpl_cap
9503 }
9504 else
9506 }
9508 /* Set the file and line number information to whatever is given for
9509 the class itself. This puts error messages involving generated
9510 implicit functions at a predictable point, and the same point
9511 that would be used for non-template classes. */
9518 /* We don't instantiate default arguments for member functions. 14.7.1:
9520 The implicit instantiation of a class template specialization causes
9521 the implicit instantiation of the declarations, but not of the
9522 definitions or default arguments, of the class member functions,
9523 member classes, static data members and member templates.... */
9525 /* Some typedefs referenced from within the template code need to be access
9526 checked at template instantiation time, i.e now. These types were
9527 added to the template at parsing time. Let's get those and perform
9528 the access checks then. */
9538 /* The vtable for a template class can be emitted in any translation
9539 unit in which the class is instantiated. When there is no key
9540 method, however, finish_struct_1 will already have added TYPE to
9541 the keyed_classes list. */
9546 }
9548 /* Wrapper for instantiate_class_template_1. */
9550 tree
9552 {
9553 tree ret;
9558 }
9560 static tree
9562 {
9563 tree r;
9569 else
9570 {
9577 /* Preserve the raw-reference nature of T. */
9581 }
9583 }
9585 /* Given a function parameter pack TMPL_PARM and some function parameters
9586 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9587 and set *SPEC_P to point at the next point in the list. */
9589 tree
9591 {
9592 /* Collect all of the extra "packed" parameters into an
9593 argument pack. */
9594 tree parmvec;
9595 tree parmtypevec;
9606 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9611 {
9614 }
9616 /* Build the argument packs. */
9623 }
9625 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9626 NONTYPE_ARGUMENT_PACK. */
9628 static tree
9630 {
9632 }
9634 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9635 pack expansion. */
9637 static bool
9639 {
9644 }
9647 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9649 static tree
9651 {
9658 }
9660 /* This is a subroutine of tsubst_pack_expansion.
9662 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9663 mechanism to store the (non complete list of) arguments of the
9664 substitution and return a non substituted pack expansion, in order
9665 to wait for when we have enough arguments to really perform the
9666 substitution. */
9668 static bool
9672 {
9673 /* If one pack has an expansion and another pack has a normal
9674 argument or if one pack has an empty argument and an another
9675 one hasn't then tsubst_pack_expansion cannot perform the
9676 substitution and need to fall back on the
9677 PACK_EXPANSION_EXTRA mechanism. */
9685 {
9688 parm_pack;
9690 {
9695 else
9697 }
9701 }
9703 }
9705 /* [temp.variadic]/6 says that:
9707 The instantiation of a pack expansion [...]
9708 produces a list E1,E2, ..., En, where N is the number of elements
9709 in the pack expansion parameters.
9711 This subroutine of tsubst_pack_expansion produces one of these Ei.
9713 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9714 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9715 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9716 INDEX is the index 'i' of the element Ei to produce. ARGS,
9717 COMPLAIN, and IN_DECL are the same parameters as for the
9718 tsubst_pack_expansion function.
9720 The function returns the resulting Ei upon successful completion,
9721 or error_mark_node.
9723 Note that this function possibly modifies the ARGS parameter, so
9724 it's the responsibility of the caller to restore it. */
9726 static tree
9728 tree parm_packs,
9730 tree args /* This parm gets
9732 tsubst_flags_t complain,
9733 tree in_decl)
9734 {
9735 tree t;
9738 /* For each parameter pack, change the substitution of the parameter
9739 pack to the ith argument in its argument pack, then expand the
9740 pattern. */
9742 {
9747 ith_elem_is_expansion |=
9750 /* Select the Ith argument from the pack. */
9753 {
9755 {
9759 }
9760 else
9762 }
9763 else
9764 {
9769 {
9771 /* Update the corresponding argument. */
9773 }
9774 else
9775 /* Re-use the ARGUMENT_PACK_SELECT. */
9777 }
9779 }
9781 /* Substitute into the PATTERN with the (possibly altered)
9782 arguments. */
9786 else
9789 /* If the Ith argument pack element is a pack expansion, then
9790 the Ith element resulting from the substituting is going to
9791 be a pack expansion as well. */
9796 }
9798 // Substitute args into the pack expansion T, and rewrite the resulting
9799 // list as a conjuntion of the specified terms. If the result is an empty
9800 // expression, return boolean_true_node.
9801 tree
9803 tree in_decl)
9804 {
9807 // If the resulting expression is type- or value-dependent, then
9808 // return it after setting the result type to bool (so it can be
9809 // expanded as a conjunction).
9810 //
9811 // This happens when instantiating constrained variadic
9812 // member function templates.
9814 {
9817 }
9819 // Conjoin requirements. An empty conjunction is equivalent to ture.
9822 else
9824 }
9827 /* Substitute ARGS into T, which is an pack expansion
9828 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9829 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9830 (if only a partial substitution could be performed) or
9831 ERROR_MARK_NODE if there was an error. */
9832 tree
9834 tree in_decl)
9835 {
9836 tree pattern;
9840 tree result;
9848 /* Add in any args remembered from an earlier partial instantiation. */
9853 /* Determine the argument packs that will instantiate the parameter
9854 packs used in the expansion expression. While we're at it,
9855 compute the number of arguments to be expanded and make sure it
9856 is consistent. */
9859 {
9866 {
9870 else
9873 }
9875 {
9878 else
9879 {
9880 /* We can't rely on local_specializations for a parameter
9881 name used later in a function declaration (such as in a
9882 late-specified return type). Even if it exists, it might
9883 have the wrong value for a recursive call. Just make a
9884 dummy decl, since it's only used for its type. */
9887 /* Partial instantiation of the parm_pack, we can't build
9888 up an argument pack yet. */
9890 else
9893 }
9894 }
9897 else
9898 {
9904 }
9911 /* This can only happen if we forget to expand an argument
9912 pack somewhere else. Just return an error, silently. */
9913 {
9917 }
9920 {
9924 /* Don't bother trying to do a partial substitution with
9925 incomplete packs; we'll try again after deduction. */
9932 {
9938 pattern);
9939 else
9942 pattern);
9944 }
9946 /* Keep track of the parameter packs and their corresponding
9947 argument packs. */
9950 }
9951 else
9952 {
9953 /* We can't substitute for this parameter pack. We use a flag as
9954 well as the missing_level counter because function parameter
9955 packs don't have a level. */
9957 }
9958 }
9960 /* We cannot expand this expansion expression, because we don't have
9961 all of the argument packs we need. */
9963 {
9964 /* We got some full packs, but we can't substitute them in until we
9965 have values for all the packs. So remember these until then. */
9970 }
9972 {
9973 /* There were no real arguments, we're just replacing a parameter
9974 pack with another version of itself. Substitute into the
9975 pattern and return a PACK_EXPANSION_*. The caller will need to
9976 deal with that. */
9980 else
9984 }
9989 {
9990 /* We're in a late-specified return type, so create our own local
9991 specializations map; the current map is either NULL or (in the
9992 case of recursive unification) might have bindings that we don't
9993 want to use or alter. */
9996 }
9998 /* For each argument in each argument pack, substitute into the
9999 pattern. */
10002 {
10004 i,
10006 in_decl);
10009 {
10012 }
10013 }
10015 /* Update ARGS to restore the substitution from parameter packs to
10016 their argument packs. */
10018 {
10024 else
10025 {
10033 /* Update the corresponding argument. */
10037 else
10039 }
10040 }
10043 {
10046 }
10049 }
10051 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10052 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10053 parameter packs; all parms generated from a function parameter pack will
10054 have the same DECL_PARM_INDEX. */
10056 tree
10058 {
10060 tree patparm;
10063 {
10069 }
10070 else
10071 {
10076 }
10079 }
10081 /* Substitute ARGS into the vector or list of template arguments T. */
10083 static tree
10085 {
10097 {
10099 tree new_arg;
10104 {
10105 /* Substitute into an expansion expression. */
10109 /* Add to the expanded length adjustment the number of
10110 expanded arguments. We subtract one from this
10111 measurement, because the argument pack expression
10112 itself is already counted as 1 in
10113 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10114 the argument pack is empty. */
10116 }
10118 {
10119 /* Substitute into each of the arguments. */
10125 new_arg,
10139 }
10140 }
10141 else
10150 }
10155 /* Make space for the expanded arguments coming from template
10156 argument packs. */
10158 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10159 arguments for a member template.
10160 In that case each TREE_VEC in ORIG_T represents a level of template
10161 arguments, and ORIG_T won't carry any non defaulted argument count.
10162 It will rather be the nested TREE_VECs that will carry one.
10163 In other words, ORIG_T carries a non defaulted argument count only
10164 if it doesn't contain any nested TREE_VEC. */
10166 {
10170 }
10172 {
10176 {
10179 /* Now expand the template argument pack "in place". */
10182 }
10183 else
10184 {
10186 out++;
10187 }
10188 }
10191 }
10193 /* Return the result of substituting ARGS into the template parameters
10194 given by PARMS. If there are m levels of ARGS and m + n levels of
10195 PARMS, then the result will contain n levels of PARMS. For
10196 example, if PARMS is `template <class T> template <class U>
10197 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10198 result will be `template <int*, double, class V>'. */
10200 static tree
10202 {
10206 /* When substituting into a template, we must set
10207 PROCESSING_TEMPLATE_DECL as the template parameters may be
10208 dependent if they are based on one-another, and the dependency
10209 predicates are short-circuit outside of templates. */
10216 {
10217 tree new_vec =
10222 {
10223 tree tuple;
10235 }
10241 }
10246 }
10248 /* Return the result of substituting ARGS into one template parameter
10249 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10250 parameter and which TREE_PURPOSE is the default argument of the
10251 template parameter. */
10253 static tree
10255 {
10276 }
10278 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10279 type T. If T is not an aggregate or enumeration type, it is
10280 handled as if by tsubst. IN_DECL is as for tsubst. If
10281 ENTERING_SCOPE is nonzero, T is the context for a template which
10282 we are presently tsubst'ing. Return the substituted value. */
10284 static tree
10286 tree args,
10287 tsubst_flags_t complain,
10288 tree in_decl,
10290 {
10295 {
10300 /* Else fall through. */
10304 {
10305 tree argvec;
10306 tree context;
10307 tree r;
10311 /* In "sizeof(X<I>)" we need to evaluate "I". */
10317 /* First, determine the context for the type we are looking
10318 up. */
10321 {
10324 /* If context is a nested class inside a class template,
10325 it may still need to be instantiated (c++/33959). */
10327 }
10329 /* Then, figure out what arguments are appropriate for the
10330 type we are trying to find. For example, given:
10332 template <class T> struct S;
10333 template <class T, class U> void f(T, U) { S<U> su; }
10335 and supposing that we are instantiating f<int, double>,
10336 then our ARGS will be {int, double}, but, when looking up
10337 S we only want {double}. */
10342 else
10343 {
10347 }
10353 }
10354 else
10355 /* This is not a template type, so there's nothing to do. */
10360 }
10361 }
10363 /* Substitute into the default argument ARG (a default argument for
10364 FN), which has the indicated TYPE. */
10366 tree
10368 {
10373 /* This can happen in invalid code. */
10377 /* This default argument came from a template. Instantiate the
10378 default argument here, not in tsubst. In the case of
10379 something like:
10381 template <class T>
10382 struct S {
10383 static T t();
10384 void f(T = t());
10385 };
10387 we must be careful to do name lookup in the scope of S<T>,
10388 rather than in the current class. */
10390 /* The "this" pointer is not valid in a default argument. */
10392 {
10397 }
10400 /* The default argument expression may cause implicitly defined
10401 member functions to be synthesized, which will result in garbage
10402 collection. We must treat this situation as if we were within
10403 the body of function so as to avoid collecting live data on the
10404 stack. */
10412 /* Restore the "this" pointer. */
10414 {
10417 }
10424 /* Make sure the default argument is reasonable. */
10430 }
10432 /* Substitute into all the default arguments for FN. */
10434 static void
10436 {
10437 tree arg;
10438 tree tmpl_args;
10442 /* If this function is not yet instantiated, we certainly don't need
10443 its default arguments. */
10446 /* Don't do this again for clones. */
10451 arg;
10457 complain);
10458 }
10460 /* Substitute the ARGS into the T, which is a _DECL. Return the
10461 result of the substitution. Issue error and warning messages under
10462 control of COMPLAIN. */
10464 static tree
10466 {
10467 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10468 location_t saved_loc;
10473 /* Set the filename and linenumber to improve error-reporting. */
10478 {
10480 {
10481 /* We can get here when processing a member function template,
10482 member class template, or template template parameter. */
10485 tree spec;
10486 tree tmpl_args;
10487 tree full_args;
10490 {
10491 /* Template template parameter is treated here. */
10495 /* If we get a real template back, return it. This can happen in
10496 the context of most_specialized_class. */
10508 complain);
10511 }
10513 /* We might already have an instance of this template.
10514 The ARGS are for the surrounding class type, so the
10515 full args contain the tsubst'd args for the context,
10516 plus the innermost args from the template decl. */
10520 /* Because this is a template, the arguments will still be
10521 dependent, even after substitution. If
10522 PROCESSING_TEMPLATE_DECL is not set, the dependency
10523 predicates will short-circuit. */
10531 /* If this is a default template template argument,
10532 tsubst might not have changed anything. */
10539 {
10542 }
10544 /* Make a new template decl. It will be similar to the
10545 original, but will record the current template arguments.
10546 We also create a new function declaration, which is just
10547 like the old one, but points to this new template, rather
10548 than the old one. */
10553 // Build new template info linking to the original template decl.
10558 {
10559 tree new_type;
10567 /* For a partial specialization, we need to keep pointing to
10568 the primary template. */
10574 }
10575 else
10576 {
10577 tree new_decl;
10589 }
10595 /* The template parameters for this new template are all the
10596 template parameters for the old template, except the
10597 outermost level of parameters. */
10600 complain);
10602 // If constrained, also instantiate requirements.
10603 // TODO: Instantiate shorthand constraints on parameters also.
10604 // See tsubst_template_parms for that.
10606 {
10609 }
10615 /* Record this non-type partial instantiation. */
10619 }
10623 {
10624 tree ctx;
10627 tree gen_tmpl;
10628 tree type;
10633 /* Nobody should be tsubst'ing into non-template functions. */
10637 {
10638 tree spec;
10641 /* If T is not dependent, just return it. We have to
10642 increment PROCESSING_TEMPLATE_DECL because
10643 value_dependent_expression_p assumes that nothing is
10644 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10651 /* Calculate the most general template of which R is a
10652 specialization, and the complete set of arguments used to
10653 specialize R. */
10656 (DECL_TEMPLATE_RESULT
10662 /* Check to see if we already have this specialization. */
10667 {
10670 }
10672 /* We can see more levels of arguments than parameters if
10673 there was a specialization of a member template, like
10674 this:
10676 template <class T> struct S { template <class U> void f(); }
10677 template <> template <class U> void S<int>::f(U);
10679 Here, we'll be substituting into the specialization,
10680 because that's where we can find the code we actually
10681 want to generate, but we'll have enough arguments for
10682 the most general template.
10684 We also deal with the peculiar case:
10686 template <class T> struct S {
10687 template <class U> friend void f();
10688 };
10689 template <class U> void f() {}
10690 template S<int>;
10691 template void f<double>();
10693 Here, the ARGS for the instantiation of will be {int,
10694 double}. But, we only need as many ARGS as there are
10695 levels of template parameters in CODE_PATTERN. We are
10696 careful not to get fooled into reducing the ARGS in
10697 situations like:
10699 template <class T> struct S { template <class U> void f(U); }
10700 template <class T> template <> void S<T>::f(int) {}
10702 which we can spot because the pattern will be a
10703 specialization in this case. */
10705 parms_depth =
10710 }
10711 else
10712 {
10713 /* This special case arises when we have something like this:
10715 template <class T> struct S {
10716 friend void f<int>(int, double);
10717 };
10719 Here, the DECL_TI_TEMPLATE for the friend declaration
10720 will be an IDENTIFIER_NODE. We are being called from
10721 tsubst_friend_function, and we want only to create a
10722 new decl (R) with appropriate types so that we can call
10723 determine_specialization. */
10725 }
10728 {
10731 else
10735 }
10736 else
10737 {
10740 }
10745 /* If we hit excessive deduction depth, the type is bogus even if
10746 it isn't error_mark_node, so don't build a decl. */
10750 /* We do NOT check for matching decls pushed separately at this
10751 point, as they may not represent instantiations of this
10752 template, and in any case are considered separate under the
10753 discrete model. */
10757 /* Clear out the mangled name and RTL for the instantiation. */
10760 /* Leave DECL_INITIAL set on deleted instantiations. */
10765 /* OpenMP UDRs have the only argument a reference to the declared
10766 type. We want to diagnose if the declared type is a reference,
10767 which is invalid, but as references to references are usually
10768 quietly merged, diagnose it here. */
10770 {
10771 tree argtype
10776 "reference type %qT in "
10780 argtype);
10781 }
10784 /* Type-conversion operator. Reconstruct the name, in
10785 case it's the name of one of the template's parameters. */
10795 /* If this is an instantiation of a function with internal
10796 linkage, we already know what object file linkage will be
10797 assigned to the instantiation. */
10806 /* We'll re-clone as appropriate in instantiate_template. */
10809 /* If we aren't complaining now, return on error before we register
10810 the specialization so that we'll complain eventually. */
10816 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10817 this in the special friend case mentioned above where
10818 GEN_TMPL is NULL. */
10820 {
10824 tree new_r
10827 /* We instantiated this while substituting into
10828 the type earlier (template/friend54.C). */
10831 /* We're not supposed to instantiate default arguments
10832 until they are called, for a template. But, for a
10833 declaration like:
10835 template <class T> void f ()
10836 { extern void g(int i = T()); }
10838 we should do the substitution when the template is
10839 instantiated. We handle the member function case in
10840 instantiate_class_template since the default arguments
10841 might refer to other members of the class. */
10846 }
10847 else
10850 /* Copy the list of befriending classes. */
10854 {
10858 in_decl);
10859 }
10862 {
10868 /* If this is an instantiation of a member template, clone it.
10869 If it isn't, that'll be handled by
10870 clone_constructors_and_destructors. */
10873 }
10884 /* Possibly limit visibility based on template args. */
10887 {
10891 }
10899 }
10903 {
10911 {
10912 /* If there is a local specialization that isn't a
10913 parameter pack, it means that we're doing a "simple"
10914 substitution from inside tsubst_pack_expansion. Just
10915 return the local specialization (which will be a single
10916 parm). */
10923 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10924 the parameters in this function parameter pack. */
10928 {
10931 /* Zero-length parameter packs are boring. Just substitute
10932 into the chain. */
10936 }
10937 else
10938 {
10939 /* All we did was update the type. Make a note of that. */
10942 }
10943 }
10945 /* Loop through all of the parameters we'll build. When T is
10946 a function parameter pack, LEN is the number of expanded
10947 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10950 {
10957 /* We're on the Ith parameter of the function parameter
10958 pack. */
10959 {
10960 /* Get the Ith type. */
10963 // An argument of a function parameter pack is a function
10964 // parameter pack if its type is also a pack. This can
10965 // happen when instantiating templates with other template
10966 // parameters.
10967 // DECL_PACK_P (r) = PACK_EXPANSION_P (type);
10969 /* Rename the parameter to include the index. */
10972 }
10974 /* We're dealing with a normal parameter. */
10982 {
10985 else
10988 }
10998 /* Keep track of the first new parameter we
10999 generate. That's what will be returned to the
11000 caller. */
11004 /* Build a proper chain of parameters when substituting
11005 into a function parameter pack. */
11008 }
11010 /* If cp_unevaluated_operand is set, we're just looking for a
11011 single dummy parameter, so don't keep going. */
11016 /* FIRST_R contains the start of the chain we've built. */
11018 }
11022 {
11029 {
11030 /* This field is a lambda capture pack. Return a TREE_VEC of
11031 the expanded fields to instantiate_class_template_1 and
11032 store them in the specializations hash table as a
11033 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11037 {
11040 }
11041 else
11042 {
11043 /* All we did was update the type. Make a note of that. */
11046 }
11047 }
11050 {
11053 {
11057 }
11067 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11068 non-bit-fields DECL_INITIAL is a non-static data member
11069 initializer, which gets deferred instantiation. */
11075 {
11076 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11077 NSDMI in perform_member_init. Still set DECL_INITIAL
11078 so that we know there is one. */
11083 }
11084 /* We don't have to set DECL_CONTEXT here; it is set by
11085 finish_member_declaration. */
11093 }
11096 {
11104 }
11105 }
11109 /* We reach here only for member using decls. We also need to check
11110 uses_template_parms because DECL_DEPENDENT_P is not set for a
11111 using-declaration that designates a member of the current
11112 instantiation (c++/53549). */
11115 {
11122 else
11123 {
11126 }
11127 }
11128 else
11129 {
11132 }
11137 {
11140 tree spec;
11142 tree ctx;
11148 {
11149 /* If this is the canonical decl, we don't have to
11150 mess with instantiations, and often we can't (for
11151 typename, template type parms and such). Note that
11152 TYPE_NAME is not correct for the above test if
11153 we've copied the type for a typedef. */
11159 }
11161 /* Check to see if we already have the specialization we
11162 need. */
11165 {
11166 /* T is a static data member or namespace-scope entity.
11167 We have to substitute into namespace-scope variables
11168 (even though such entities are never templates) because
11169 of cases like:
11171 template <class T> void f() { extern T t; }
11173 where the entity referenced is not known until
11174 instantiation time. */
11178 {
11180 complain,
11182 /* If CTX is unchanged, then T is in fact the
11183 specialization we want. That situation occurs when
11184 referencing a static data member within in its own
11185 class. We can use pointer equality, rather than
11186 same_type_p, because DECL_CONTEXT is always
11187 canonical... */
11190 /* ... unless T is a member template; in which
11191 case our caller can be willing to create a
11192 specialization of that template represented
11193 by T. */
11197 }
11200 {
11208 }
11209 }
11210 else
11211 {
11212 /* A local variable. */
11214 /* Subsequent calls to pushdecl will fill this in. */
11217 }
11218 /* If we already have the specialization we need, there is
11219 nothing more to do. */
11221 {
11224 }
11226 /* Create a new node for the specialization we need. */
11229 {
11232 else
11239 }
11241 {
11242 /* Even if the original location is out of scope, the
11243 newly substituted one is not. */
11250 {
11251 /* It may seem that this case cannot occur, since:
11253 typedef void f();
11254 void g() { f x; }
11256 declares a function, not a variable. However:
11258 typedef void f();
11259 template <typename T> void g() { T t; }
11260 template void g<f>();
11262 is an attempt to declare a variable with function
11263 type. */
11265 /* R is not yet sufficiently initialized, so we
11266 just use its name. */
11269 }
11271 /* Wait until cp_finish_decl to set this again, to handle
11272 circular dependency (template/instantiate6.C). */
11277 {
11282 {
11285 }
11287 }
11288 }
11294 /* Clear out the mangled name and RTL for the instantiation. */
11298 /* The initializer must not be expanded until it is required;
11299 see [temp.inst]. */
11305 {
11306 /* Possibly limit visibility based on template args. */
11309 {
11313 }
11315 }
11318 {
11319 /* A static data member declaration is always marked
11320 external when it is declared in-class, even if an
11321 initializer is present. We mimic the non-template
11322 processing here. */
11329 }
11332 else
11341 /* Preserve a typedef that names a type. */
11343 {
11346 }
11349 }
11354 }
11355 #undef RETURN
11357 out:
11358 /* Restore the file and line information. */
11362 }
11364 /* Substitute into the ARG_TYPES of a function type.
11365 If END is a TREE_CHAIN, leave it and any following types
11366 un-substituted. */
11368 static tree
11370 tree args,
11371 tree end,
11372 tsubst_flags_t complain,
11373 tree in_decl)
11374 {
11375 tree remaining_arg_types;
11379 tree default_arg;
11390 {
11391 /* For a pack expansion, perform substitution on the
11392 entire expression. Later on, we'll handle the arguments
11393 one-by-one. */
11398 /* So that we'll spin through the parameters, one by one. */
11400 else
11401 {
11402 /* We only partially substituted into the parameter
11403 pack. Our type is TYPE_PACK_EXPANSION. */
11406 }
11407 }
11420 {
11422 {
11426 }
11428 }
11429 /* DR 657. */
11433 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11434 top-level qualifiers as required. */
11437 /* We do not substitute into default arguments here. The standard
11438 mandates that they be instantiated only when needed, which is
11439 done in build_over_call. */
11443 {
11444 /* We've instantiated a template before its default arguments
11445 have been parsed. This can happen for a nested template
11446 class, and is not an error unless we require the default
11447 argument in a call of this function. */
11448 remaining_arg_types =
11451 }
11452 else
11453 remaining_arg_types =
11455 }
11458 }
11460 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11461 *not* handle the exception-specification for FNTYPE, because the
11462 initial substitution of explicitly provided template parameters
11463 during argument deduction forbids substitution into the
11464 exception-specification:
11466 [temp.deduct]
11468 All references in the function type of the function template to the
11469 corresponding template parameters are replaced by the specified tem-
11470 plate argument values. If a substitution in a template parameter or
11471 in the function type of the function template results in an invalid
11472 type, type deduction fails. [Note: The equivalent substitution in
11473 exception specifications is done only when the function is instanti-
11474 ated, at which point a program is ill-formed if the substitution
11475 results in an invalid type.] */
11477 static tree
11479 tree args,
11480 tsubst_flags_t complain,
11481 tree in_decl)
11482 {
11483 tree return_type;
11484 tree arg_types;
11485 tree fntype;
11487 /* The TYPE_CONTEXT is not used for function/method types. */
11490 /* Substitute the return type. */
11494 /* DR 486 clarifies that creation of a function type with an
11495 invalid return type is a deduction failure. */
11498 {
11500 {
11503 else
11505 }
11507 }
11508 /* And DR 657. */
11512 /* Substitute the argument types. */
11518 /* Construct a new type node and return it. */
11520 {
11525 }
11526 else
11527 {
11530 {
11531 /* [temp.deduct]
11533 Type deduction may fail for any of the following
11534 reasons:
11536 -- Attempting to create "pointer to member of T" when T
11537 is not a class type. */
11540 r);
11542 }
11547 }
11551 }
11553 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11554 ARGS into that specification, and return the substituted
11555 specification. If there is no specification, return NULL_TREE. */
11557 static tree
11559 tree args,
11560 tsubst_flags_t complain,
11561 tree in_decl,
11563 {
11564 tree specs;
11565 tree new_specs;
11570 {
11571 /* A noexcept-specifier. */
11576 {
11577 /* Defer instantiation of noexcept-specifiers to avoid
11578 excessive instantiations (c++/49107). */
11581 {
11582 /* We already partially instantiated this member template,
11583 so combine the new args with the old. */
11588 }
11589 else
11590 {
11593 }
11594 }
11595 else
11596 new_specs = tsubst_copy_and_build
11600 }
11602 {
11605 else
11607 {
11608 tree spec;
11613 {
11614 /* Expand the pack expansion type. */
11617 in_decl);
11623 else
11624 {
11625 /* We're substituting into a member template, so
11626 we got a TYPE_PACK_EXPANSION back. Add that
11627 expansion and move on. */
11631 expanded_specs,
11632 complain);
11635 }
11636 }
11639 {
11642 else
11647 complain);
11648 }
11651 }
11652 }
11654 }
11656 /* Take the tree structure T and replace template parameters used
11657 therein with the argument vector ARGS. IN_DECL is an associated
11658 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11659 Issue error and warning messages under control of COMPLAIN. Note
11660 that we must be relatively non-tolerant of extensions here, in
11661 order to preserve conformance; if we allow substitutions that
11662 should not be allowed, we may allow argument deductions that should
11663 not succeed, and therefore report ambiguous overload situations
11664 where there are none. In theory, we could allow the substitution,
11665 but indicate that it should have failed, and allow our caller to
11666 make sure that the right thing happens, but we don't try to do this
11667 yet.
11669 This function is used for dealing with types, decls and the like;
11670 for expressions, use tsubst_expr or tsubst_copy. */
11672 tree
11674 {
11697 else
11702 /* Reuse typedefs. We need to do this to handle dependent attributes,
11703 such as attribute aligned. */
11706 {
11710 {
11711 /* DECL represents an alias template and we want to
11712 instantiate it. */
11716 }
11720 {
11724 }
11729 else
11730 /* The typedef is from a non-template context. */
11734 {
11736 r = cp_build_qualified_type_real
11740 }
11741 else
11742 {
11743 /* We don't have an instantiation yet, so drop the typedef. */
11748 }
11749 }
11762 {
11788 {
11794 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11795 needed. */
11801 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11802 with TREE_SIDE_EFFECTS that indicates this is not an integral
11803 constant expression. */
11806 {
11809 }
11812 }
11818 {
11831 {
11835 {
11836 /* See through ARGUMENT_PACK_SELECT arguments. */
11838 /* If the selected argument is an expansion E, that most
11839 likely means we were called from
11840 gen_elem_of_pack_expansion_instantiation during the
11841 substituting of pack an argument pack (which Ith
11842 element is a pack expansion, where I is
11843 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11844 In this case, the Ith element resulting from this
11845 substituting is going to be a pack expansion, which
11846 pattern is the pattern of E. Let's return the
11847 pattern of E, and
11848 gen_elem_of_pack_expansion_instantiation will
11849 build the resulting pack expansion from it. */
11852 }
11853 }
11858 {
11860 /* If ARG is an argument pack, we don't actually want to
11861 perform a substitution here, because substitutions
11862 for argument packs are only done
11863 element-by-element. We can get to this point when
11864 substituting the type of a non-type template
11865 parameter pack, when that type actually contains
11866 template parameter packs from an outer template, e.g.,
11868 template<typename... Types> struct A {
11869 template<Types... Values> struct B { };
11870 }; */
11874 {
11880 return cp_build_qualified_type_real
11882 }
11884 {
11885 /* We are processing a type constructed from a
11886 template template parameter. */
11897 /* Consider this code:
11899 template <template <class> class Template>
11900 struct Internal {
11901 template <class Arg> using Bind = Template<Arg>;
11902 };
11904 template <template <class> class Template, class Arg>
11905 using Instantiate = Template<Arg>; //#0
11907 template <template <class> class Template,
11908 class Argument>
11909 using Bind =
11910 Instantiate<Internal<Template>::template Bind,
11911 Argument>; //#1
11913 When #1 is parsed, the
11914 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11915 parameter `Template' in #0 matches the
11916 UNBOUND_CLASS_TEMPLATE representing the argument
11917 `Internal<Template>::template Bind'; We then want
11918 to assemble the type `Bind<Argument>' that can't
11919 be fully created right now, because
11920 `Internal<Template>' not being complete, the Bind
11921 template cannot be looked up in that context. So
11922 we need to "store" `Bind<Argument>' for later
11923 when the context of Bind becomes complete. Let's
11924 store that in a TYPENAME_TYPE. */
11928 argvec),
11929 typename_type,
11930 complain);
11932 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11933 are resolving nested-types in the signature of a
11934 member function templates. Otherwise ARG is a
11935 TEMPLATE_DECL and is the real template to be
11936 instantiated. */
11944 complain);
11945 return cp_build_qualified_type_real
11947 }
11948 else
11949 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11951 }
11954 /* This can happen during the attempted tsubst'ing in
11955 unify. This means that we don't yet have any information
11956 about the template parameter in question. */
11959 /* Early in template argument deduction substitution, we don't
11960 want to reduce the level of 'auto', or it will be confused
11961 with a normal template parm in subsequent deduction. */
11965 /* If we get here, we must have been looking at a parm for a
11966 more deeply nested template. Make a new version of this
11967 template parameter, but with a lower level. */
11969 {
11974 {
11976 r = cp_build_qualified_type_real
11980 }
11981 else
11982 {
11993 /* We have reduced the level of the template
11994 template parameter, but not the levels of its
11995 template parameters, so canonical_type_parameter
11996 will not be able to find the canonical template
11997 template parameter for this level. Thus, we
11998 require structural equality checking to compare
11999 TEMPLATE_TEMPLATE_PARMs. */
12003 else
12007 {
12015 }
12016 }
12025 }
12028 }
12031 {
12039 {
12043 }
12046 {
12050 }
12053 {
12057 }
12063 }
12066 /* We should never be tsubsting a binfo. */
12070 /* A vector of template arguments. */
12076 {
12080 /* [temp.deduct]
12082 Type deduction may fail for any of the following
12083 reasons:
12085 -- Attempting to create a pointer to reference type.
12086 -- Attempting to create a reference to a reference type or
12087 a reference to void.
12089 Core issue 106 says that creating a reference to a reference
12090 during instantiation is no longer a cause for failure. We
12091 only enforce this check in strict C++98 mode. */
12095 {
12098 /* We keep track of the last time we issued this error
12099 message to avoid spewing a ton of messages during a
12100 single bad template instantiation. */
12103 {
12108 else
12111 }
12114 }
12118 {
12120 {
12123 type);
12124 else
12126 type);
12127 }
12129 }
12131 {
12135 }
12137 /* In C++0x, during template argument substitution, when there is an
12138 attempt to create a reference to a reference type, reference
12139 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12141 "If a template-argument for a template-parameter T names a type
12142 that is a reference to a type A, an attempt to create the type
12143 'lvalue reference to cv T' creates the type 'lvalue reference to
12144 A,' while an attempt to create the type type rvalue reference to
12145 cv T' creates the type T"
12146 */
12147 r = cp_build_reference_type
12150 else
12157 {
12159 pedwarn
12161 code == REFERENCE_TYPE
12164 else
12166 }
12169 /* Will this ever be needed for TYPE_..._TO values? */
12173 }
12175 {
12178 {
12179 /* [temp.deduct]
12181 Type deduction may fail for any of the following
12182 reasons:
12184 -- Attempting to create "pointer to member of T" when T
12185 is not a class type. */
12189 }
12191 {
12195 }
12197 {
12201 }
12204 {
12205 /* The type of the implicit object parameter gets its
12206 cv-qualifiers from the FUNCTION_TYPE. */
12207 tree memptr;
12208 tree method_type
12213 complain);
12214 }
12215 else
12218 complain);
12219 }
12222 {
12223 tree fntype;
12224 tree specs;
12229 /* Substitute the exception specification. */
12237 }
12239 {
12244 /* As an optimization, we avoid regenerating the array type if
12245 it will obviously be the same as T. */
12249 /* These checks should match the ones in grokdeclarator.
12251 [temp.deduct]
12253 The deduction may fail for any of the following reasons:
12255 -- Attempting to create an array with an element type that
12256 is void, a function type, or a reference type, or [DR337]
12257 an abstract class type. */
12261 {
12265 }
12273 {
12276 }
12279 }
12282 {
12292 {
12296 }
12298 {
12299 /* Normally, make_typename_type does not require that the CTX
12300 have complete type in order to allow things like:
12302 template <class T> struct S { typename S<T>::X Y; };
12304 But, such constructs have already been resolved by this
12305 point, so here CTX really should have complete type, unless
12306 it's a partial instantiation. */
12309 {
12313 }
12314 }
12321 {
12324 }
12327 {
12329 {
12333 else
12335 }
12337 {
12341 else
12343 }
12344 }
12346 return cp_build_qualified_type_real
12348 }
12351 {
12363 }
12366 {
12367 tree type;
12383 complain);
12384 }
12387 {
12388 tree type;
12406 else
12407 {
12411 /* In a template ~id could be either a complement expression
12412 or an unqualified-id naming a destructor; if instantiating
12413 it produces an expression, it's not an id-expression or
12414 member access. */
12417 }
12421 complain);
12422 }
12425 {
12429 }
12433 {
12435 tree packed_out =
12437 args,
12438 complain,
12439 in_decl);
12442 /* For template nontype argument packs, also substitute into
12443 the type. */
12448 }
12463 /* We should use one of the expression tsubsts for these codes. */
12469 }
12470 }
12472 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12473 type of the expression on the left-hand side of the "." or "->"
12474 operator. */
12476 static tree
12479 {
12480 tree name;
12481 tree qualifying_scope;
12482 tree fns;
12483 tree optype;
12488 /* A baselink indicates a function from a base class. Both the
12489 BASELINK_ACCESS_BINFO and the base class referenced may
12490 indicate bases of the template class, rather than the
12491 instantiated class. In addition, lookups that were not
12492 ambiguous before may be ambiguous now. Therefore, we perform
12493 the lookup again. */
12500 {
12507 }
12515 /* If lookup found a single function, mark it as used at this
12516 point. (If it lookup found multiple functions the one selected
12517 later by overload resolution will be marked as used at that
12518 point.) */
12524 /* Add back the template arguments, if present. */
12529 template_args);
12530 /* Update the conversion operator type. */
12538 qualifying_scope,
12539 object_type);
12541 }
12543 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12544 true if the qualified-id will be a postfix-expression in-and-of
12545 itself; false if more of the postfix-expression follows the
12546 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12547 of "&". */
12549 static tree
12553 {
12554 tree expr;
12555 tree scope;
12556 tree name;
12558 tree template_args;
12563 /* Figure out what name to look up. */
12566 {
12574 }
12575 else
12576 {
12579 }
12581 /* Substitute into the qualifying scope. When there are no ARGS, we
12582 are just trying to simplify a non-dependent expression. In that
12583 case the qualifying scope may be dependent, and, in any case,
12584 substituting will not help. */
12587 {
12590 }
12591 else
12595 {
12600 }
12603 {
12605 {
12606 /* A BIT_NOT_EXPR is used to represent a destructor. */
12608 {
12612 }
12613 else
12616 }
12617 else
12621 {
12623 {
12627 }
12629 }
12630 }
12633 {
12635 scope);
12636 /* Remember that there was a reference to this entity. */
12638 }
12641 {
12647 }
12656 {
12657 expr = (adjust_result_of_qualified_name_lookup
12659 expr = (finish_qualified_id_expr
12663 }
12665 /* Expressions do not generally have reference type. */
12667 /* However, if we're about to form a pointer-to-member, we just
12668 want the referenced member referenced. */
12673 }
12675 /* Like tsubst, but deals with expressions. This function just replaces
12676 template parms; to finish processing the resultant expression, use
12677 tsubst_copy_and_build or tsubst_expr. */
12679 static tree
12681 {
12683 tree r;
12691 {
12696 {
12697 /* We get here for a use of 'this' in an NSDMI. */
12703 /* This can happen for a parameter name used later in a function
12704 declaration (such as in a late-specified return type). Just
12705 make a dummy decl, since it's only used for its type. */
12708 /* Give it the template pattern as its context; its true context
12709 hasn't been instantiated yet and this is good enough for
12710 mangling. */
12712 }
12720 {
12721 tree enum_type;
12722 tree v;
12726 /* There is no need to substitute into namespace-scope
12727 enumerators. */
12730 /* If ARGS is NULL, then T is known to be non-dependent. */
12734 /* Unfortunately, we cannot just call lookup_name here.
12735 Consider:
12737 template <int I> int f() {
12738 enum E { a = I };
12739 struct S { void g() { E e = a; } };
12740 };
12742 When we instantiate f<7>::S::g(), say, lookup_name is not
12743 clever enough to find f<7>::a. */
12744 enum_type
12754 /* We didn't find the name. That should never happen; if
12755 name-lookup found it during preliminary parsing, we
12756 should find it again here during instantiation. */
12758 }
12763 {
12764 /* Check for a local specialization set up by
12765 tsubst_pack_expansion. */
12768 {
12772 }
12774 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12775 tsubst_decl put in the hash table. */
12777 }
12780 {
12781 tree ctx;
12786 {
12789 {
12793 }
12795 }
12796 }
12805 {
12808 {
12810 {
12811 /* Just use name lookup to find a member alias for an
12812 anonymous union, but then add it to the hash table. */
12816 }
12817 else
12818 {
12821 }
12822 }
12823 }
12824 else
12833 /* An OVERLOAD will always be a non-dependent overload set; an
12834 overload set from function scope will just be represented with an
12835 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12851 {
12852 /* Template template argument like the following example need
12853 special treatment:
12855 template <template <class> class TT> struct C {};
12856 template <class T> struct D {
12857 template <class U> struct E {};
12858 C<E> c; // #1
12859 };
12860 D<int> d; // #2
12862 We are processing the template argument `E' in #1 for
12863 the template instantiation #2. Originally, `E' is a
12864 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12865 have to substitute this with one having context `D<int>'. */
12869 }
12870 else
12871 /* Ordinary template template argument. */
12882 return build1
12888 {
12898 /* We only want to compute the number of arguments. */
12912 {
12919 else
12922 }
12923 else
12925 }
12927 {
12935 }
12936 /* Fall through */
12952 return build1
12957 {
12958 tree object;
12959 tree name;
12964 {
12968 }
12971 {
12981 }
12986 in_decl);
12987 else
12990 }
13028 return build_nt
13041 return build_nt
13048 {
13056 }
13062 {
13063 r = build_nt
13069 }
13072 {
13073 r = build_nt
13079 }
13082 {
13083 r = build_nt
13089 }
13092 {
13093 /* Substituted template arguments */
13102 }
13105 {
13125 }
13152 /* Fall through. */
13155 {
13158 }
13159 else
13163 /* This is handled by tsubst_copy_and_build. */
13169 in_decl),
13173 /* We shouldn't have built any of these during initial template
13174 generation. Instead, they should be built during instantiation
13175 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13179 r = build2
13188 // Expansions of variadic constraints are viable, expanding
13189 // to a conunction of the expanded terms.
13204 {
13205 /* Instantiate any typedefs in the type. */
13210 }
13213 /* These can sometimes show up in a partial instantiation, but never
13214 involve template parms. */
13219 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13222 }
13223 }
13225 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13227 static tree
13230 {
13234 {
13240 {
13243 {
13249 }
13250 /* FALLTHRU */
13278 {
13281 {
13288 }
13289 else
13291 }
13321 }
13322 }
13328 }
13330 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13332 static tree
13334 tree in_decl)
13335 {
13336 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13356 {
13359 else
13360 {
13364 }
13365 }
13370 #undef RECUR
13371 }
13373 /* Substitute one OMP_FOR iterator. */
13375 static void
13380 {
13381 #define RECUR(NODE) \
13382 tsubst_expr ((NODE), args, complain, in_decl, \
13383 integral_constant_expression_p)
13391 /* Do this before substituting into decl to handle 'auto'. */
13396 {
13400 }
13405 {
13412 complain);
13413 else
13420 }
13423 {
13424 tree c;
13426 {
13437 }
13439 {
13444 {
13447 }
13448 }
13449 }
13455 else
13459 {
13470 {
13477 }
13478 else
13484 {
13490 }
13494 {
13501 }
13502 else
13508 }
13514 #undef RECUR
13515 }
13517 /* Like tsubst_copy for expressions, etc. but also does semantic
13518 processing. */
13520 tree
13523 {
13524 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13525 #define RECUR(NODE) \
13526 tsubst_expr ((NODE), args, complain, in_decl, \
13527 integral_constant_expression_p)
13530 tree r;
13531 location_t loc;
13543 {
13545 {
13546 tree_stmt_iterator i;
13550 }
13565 else
13574 {
13576 tree init;
13582 {
13585 tree decl;
13593 else
13595 }
13597 {
13598 /* Don't build up decls for a variadic capture proxy, we'll
13599 instantiate the elements directly as needed. */
13601 }
13602 else
13603 {
13607 {
13608 /* By marking the declaration as instantiated, we avoid
13609 trying to instantiate it. Since instantiate_decl can't
13610 handle local variables, and since we've already done
13611 all that needs to be done, that's the right thing to
13612 do. */
13617 /* Anonymous aggregates are a special case. */
13620 {
13623 {
13627 }
13629 }
13635 {
13640 }
13641 else
13642 {
13647 {
13648 /* For __PRETTY_FUNCTION__ we have to adjust the
13649 initializer. */
13653 }
13654 else
13655 {
13659 {
13660 /* If we had an initializer but it
13661 instantiated to nothing,
13662 value-initialize the object. This will
13663 only occur when the initializer was a
13664 pack expansion where the parameter packs
13665 used in that expansion were of length
13666 zero. */
13668 complain);
13671 }
13672 else
13674 }
13677 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13680 }
13681 }
13682 }
13685 }
13700 {
13710 }
13737 {
13741 }
13749 else
13757 else
13784 {
13786 tree label;
13791 }
13797 /* Computed goto's must be tsubst'd into. On the other hand,
13798 non-computed gotos must not be; the identifier in question
13799 will have no binding. */
13801 else
13807 tmp = finish_asm_stmt
13814 {
13819 }
13824 {
13829 }
13830 else
13831 {
13836 else
13843 else
13849 else
13851 }
13855 {
13859 {
13861 /* Prevent instantiate_decl from trying to instantiate
13862 this variable. We've already done all that needs to be
13863 done. */
13866 }
13871 }
13877 {
13878 /* Local classes are not independent templates; they are
13879 instantiated along with their containing function. And this
13880 way we don't have to deal with pushing out of one local class
13881 to instantiate a member of another local class. */
13882 tree fn;
13883 /* Closures are handled by the LAMBDA_EXPR. */
13889 }
13893 {
13894 tree condition;
13897 condition =
13899 args,
13908 }
13932 {
13941 {
13946 }
13958 integral_constant_expression_p);
13967 else
13968 {
13976 }
13979 }
14024 {
14029 {
14032 }
14038 }
14039 else
14040 {
14047 {
14050 }
14053 {
14058 {
14061 }
14067 }
14068 else
14069 {
14073 }
14076 }
14080 {
14086 {
14090 {
14095 }
14099 }
14100 else
14101 {
14106 }
14107 }
14115 // Expansions of variadic constraints are viable, expanding
14116 // to a conunction of the expanded terms.
14130 /* If the first operand was a statement, we're done with it. */
14134 complain));
14141 integral_constant_expression_p));
14142 }
14145 out:
14148 #undef RECUR
14149 #undef RETURN
14150 }
14152 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14153 function. For description of the body see comment above
14154 cp_parser_omp_declare_reduction_exprs. */
14156 static void
14158 {
14164 tree_stmt_iterator tsi;
14175 {
14194 }
14196 {
14216 }
14217 }
14219 /* T is a postfix-expression that is not being used in a function
14220 call. Return the substituted version of T. */
14222 static tree
14224 tsubst_flags_t complain,
14225 tree in_decl)
14226 {
14230 else
14236 }
14238 /* Like tsubst but deals with expressions and performs semantic
14239 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14241 tree
14243 tree args,
14244 tsubst_flags_t complain,
14245 tree in_decl,
14248 {
14249 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14250 #define RECUR(NODE) \
14251 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14253 integral_constant_expression_p)
14256 location_t loc;
14265 /* N3276 decltype magic only applies to calls at the top level or on the
14266 right side of a comma. */
14271 {
14274 /* Fall through. */
14276 {
14277 tree decl;
14278 cp_id_kind idk;
14283 {
14286 }
14288 /* Look up the name. */
14291 /* By convention, expressions use ERROR_MARK_NODE to indicate
14292 failure, not NULL_TREE. */
14298 integral_constant_expression_p,
14306 input_location);
14310 {
14314 }
14316 }
14319 {
14320 tree object;
14328 {
14331 }
14332 else
14339 else
14341 }
14344 {
14348 {
14349 /* A type conversion to reference type will be enclosed in
14350 such an indirect ref, but the substitution of the cast
14351 will have also added such an indirect ref. */
14354 }
14355 else
14359 }
14367 {
14374 flags));
14375 }
14388 {
14389 tree type;
14395 {
14400 }
14406 {
14424 }
14428 }
14462 else
14464 in_decl);
14499 {
14500 tree r;
14504 r = build_x_binary_op
14508 ? ERROR_MARK
14512 ? ERROR_MARK
14522 }
14535 {
14544 }
14548 /* Fall through */
14551 {
14552 tree r;
14558 {
14559 /* When there are no ARGS, we are trying to evaluate a
14560 non-dependent expression from the parser. Trying to do
14561 the substitutions may not work. */
14564 }
14565 else
14566 {
14571 else
14574 /*integral_constant_expression_p=*/
14578 }
14582 else
14586 {
14588 {
14590 {
14594 }
14595 else
14599 }
14601 }
14603 }
14606 {
14616 }
14630 {
14631 tree r;
14635 r = build_x_modify_expr
14641 /* TREE_NO_WARNING must be set if either the expression was
14642 parenthesized or it uses an operator such as >>= rather
14643 than plain assignment. In the former case, it was already
14644 set and must be copied. In the latter case,
14645 build_x_modify_expr sets it and it must not be reset
14646 here. */
14653 }
14658 /* Remember that there was a reference to this entity. */
14664 {
14669 tree ret;
14673 else
14674 {
14678 }
14680 /* If there was an initializer in the original tree, but it
14681 instantiated to an empty list, then we should pass a
14682 non-NULL empty vector to tell build_new that it was an
14683 empty initializer() rather than no initializer. This can
14684 only happen when the initializer is a pack expansion whose
14685 parameter packs are of length zero. */
14688 else
14689 {
14693 else
14694 {
14697 }
14698 }
14705 complain);
14713 }
14721 complain));
14724 {
14728 integral_constant_expression_p);
14730 op0,
14733 }
14736 {
14737 tree function;
14742 tree ret;
14745 /* When we parsed the expression, we determined whether or
14746 not Koenig lookup should be performed. */
14749 {
14754 }
14756 {
14757 /* Do nothing; calling tsubst_copy_and_build on an identifier
14758 would incorrectly perform unqualified lookup again.
14760 Note that we can also have an IDENTIFIER_NODE if the earlier
14761 unqualified lookup found a member function; in that case
14762 koenig_p will be false and we do want to do the lookup
14763 again to find the instantiated member function.
14765 FIXME but doing that causes c++/15272, so we need to stop
14766 using IDENTIFIER_NODE in that situation. */
14768 }
14769 else
14770 {
14772 {
14778 }
14779 else
14784 /* Avoid error about taking the address of a constructor. */
14788 in_decl,
14790 integral_constant_expression_p);
14794 }
14799 {
14804 else
14805 {
14806 /* Expand the pack expansion and push each entry onto
14807 CALL_ARGS. */
14810 {
14815 {
14820 }
14821 }
14822 else
14823 {
14824 /* A partial substitution. Add one entry. */
14826 }
14827 }
14828 }
14830 /* We do not perform argument-dependent lookup if normal
14831 lookup finds a non-function, in accordance with the
14832 expected resolution of DR 218. */
14835 /* If lookup found a member function, the Koenig lookup is
14836 not appropriate, even if an unqualified-name was used
14837 to denote the function. */
14840 /* Only do this when substitution turns a dependent call
14841 into a non-dependent call. */
14845 tf_none);
14849 {
14851 {
14852 /* For backwards compatibility and good diagnostics, try
14853 the unqualified lookup again if we aren't in SFINAE
14854 context. */
14855 tree unq = (tsubst_copy_and_build
14857 integral_constant_expression_p));
14862 {
14871 "%qD was not declared in this scope, "
14872 "and no declarations were found by "
14873 "argument-dependent lookup at the point "
14875 {
14879 {
14881 "declarations in dependent base %qT are "
14887 else
14891 }
14892 else
14895 }
14897 }
14898 }
14900 {
14905 }
14906 }
14908 /* Remember that there was a reference to this entity. */
14912 /* Put back tf_decltype for the actual call. */
14917 complain);
14919 {
14934 complain);
14935 else
14936 ret = (build_new_method_call
14941 complain));
14942 }
14943 else
14946 koenig_p,
14947 complain);
14952 }
14955 {
14960 {
14962 {
14967 }
14968 else
14969 {
14974 }
14975 }
14976 else
14977 {
14980 }
14984 }
14991 input_location));
14994 {
15002 {
15003 /* We have pack expansions, so expand those and
15004 create a new list out of it. */
15007 tree chain;
15010 /* Expand the argument expressions. */
15018 /* Build the rest of the list. */
15023 /* Determine the number of arguments. */
15025 {
15028 }
15031 else
15032 {
15033 /* Since we only performed a partial substitution into
15034 the argument pack, we only RETURN (a single list
15035 node. */
15042 }
15044 /* Convert the argument vectors into a TREE_LIST */
15047 {
15048 /* Grab the Ith values. */
15049 i--;
15052 value
15056 /* Build the list (backwards). */
15058 }
15061 }
15077 }
15080 {
15081 tree object;
15082 tree object_type;
15083 tree member;
15087 /* Remember that there was a reference to this entity. */
15097 else
15105 {
15107 {
15112 {
15115 }
15117 {
15122 }
15123 }
15124 }
15127 {
15128 /* Lookup the template functions now that we know what the
15129 scope is. */
15137 {
15140 args);
15141 member = (adjust_result_of_qualified_name_lookup
15143 object_type));
15144 }
15145 else
15146 {
15148 input_location);
15150 }
15151 }
15155 {
15157 {
15161 else
15164 }
15166 }
15172 complain));
15173 }
15180 {
15188 tree r;
15193 /* digest_init will do the wrong thing if we let it. */
15197 /* We do not want to process the index of aggregate
15198 initializers as they are identifier nodes which will be
15199 looked up by digest_init. */
15205 {
15207 /* An identifier index is looked up in the type
15208 being initialized, not the current scope. */
15213 {
15214 /* Substitute into the pack expansion. */
15216 in_decl);
15220 ;
15222 /* Just move the argument into place. */
15224 else
15225 {
15226 /* Update the length of the final CONSTRUCTOR
15227 arguments vector, and note that we will need to
15228 copy.*/
15231 }
15232 }
15233 else
15235 }
15238 {
15243 {
15245 {
15250 }
15251 else
15253 }
15254 }
15264 }
15267 {
15270 {
15273 }
15274 else
15275 {
15278 }
15279 }
15285 {
15286 /* We don't build decls for an instantiation of a
15287 variadic capture proxy, we instantiate the elements
15288 when needed. */
15291 }
15292 /* Fall through */
15295 {
15299 /* If the original type was a reference, we'll be wrapped in
15300 the appropriate INDIRECT_REF. */
15303 // If the type of the argument is a pack expansion, then
15304 // the parameter must also be expanded.
15309 }
15320 {
15329 }
15332 {
15338 integral_constant_expression_p);
15342 /* If the resulting list of expression statement is empty,
15343 fold it further into void_zero_node. */
15348 }
15351 {
15365 /* For a function scope, we want to use tsubst so that we don't
15366 complain about referring to an auto function before its return
15367 type has been deduced. Otherwise, we want to use tsubst_copy so
15368 that we look up the existing field/parameter/variable rather
15369 than build a new one. */
15374 {
15375 /* Look up the parameter we want directly, as tsubst_copy
15376 doesn't do what we need. */
15382 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15385 }
15386 else
15395 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15397 /* Now that we know visibility, instantiate the type so we have a
15398 declaration of the op() for later calls to lambda_function. */
15404 }
15407 /* We can get here for a constant initializer of non-dependent type.
15408 FIXME stop folding in cp_parser_initializer_clause. */
15409 {
15411 complain);
15413 }
15417 integral_constant_expression_p));
15427 complain));
15441 // Normally, *_REQ are reduced out of requiremetns when used
15442 // as constraints. If a concept is checked directly via e.g.,
15443 // a static_assert, however, these appear in the input tree.
15455 /* Handle Objective-C++ constructs, if appropriate. */
15456 {
15457 tree subst
15462 }
15464 }
15466 #undef RECUR
15467 #undef RETURN
15468 out:
15471 }
15473 /* Verify that the instantiated ARGS are valid. For type arguments,
15474 make sure that the type's linkage is ok. For non-type arguments,
15475 make sure they are constants if they are integral or enumerations.
15476 Emit an error under control of COMPLAIN, and return TRUE on error. */
15478 static bool
15480 {
15484 {
15494 }
15496 {
15497 /* [basic.link]: A name with no linkage (notably, the name
15498 of a class or enumeration declared in a local scope)
15499 shall not be used to declare an entity with linkage.
15500 This implies that names with no linkage cannot be used as
15501 template arguments
15503 DR 757 relaxes this restriction for C++0x. */
15508 {
15509 /* DR 488 makes use of a type with no linkage cause
15510 type deduction to fail. */
15512 {
15515 else
15518 }
15520 }
15521 /* In order to avoid all sorts of complications, we do not
15522 allow variably-modified types as template arguments. */
15524 {
15528 }
15529 }
15530 /* Class template and alias template arguments should be OK. */
15532 ;
15533 /* A non-type argument of integral or enumerated type must be a
15534 constant. */
15538 {
15542 }
15544 }
15546 static bool
15548 {
15553 {
15556 }
15560 }
15562 /* We're out of SFINAE context now, so generate diagnostics for the access
15563 errors we saw earlier when instantiating D from TMPL and ARGS. */
15565 static void
15567 {
15579 }
15581 /* Instantiate the indicated variable, function, or alias template TMPL with
15582 the template arguments in TARG_PTR. */
15584 static tree
15586 {
15588 tree fndecl;
15589 tree gen_tmpl;
15590 tree spec;
15598 /* If this function is a clone, handle it specially. */
15600 {
15601 tree spec;
15602 tree clone;
15604 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15605 DECL_CLONED_FUNCTION. */
15611 /* Look for the clone. */
15615 /* We should always have found the clone by now. */
15618 }
15620 /* Check to see if we already have this specialization. */
15623 /* The TMPL is a partial instantiation. To get a full set of
15624 arguments we must add the arguments used to perform the
15625 partial instantiation. */
15627 targ_ptr);
15629 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15630 but it doesn't seem to be on the hot path. */
15639 {
15641 {
15645 }
15647 }
15650 complain))
15653 /* We are building a FUNCTION_DECL, during which the access of its
15654 parameters and return types have to be checked. However this
15655 FUNCTION_DECL which is the desired context for access checking
15656 is not built yet. We solve this chicken-and-egg problem by
15657 deferring all checks until we have the FUNCTION_DECL. */
15660 /* Instantiation of the function happens in the context of the function
15661 template, not the context of the overload resolution we're doing. */
15663 /* If there are dependent arguments, e.g. because we're doing partial
15664 ordering, make sure processing_template_decl stays set. */
15668 {
15672 }
15673 /* Substitute template parameters to obtain the specialization. */
15681 {
15684 }
15686 /* The DECL_TI_TEMPLATE should always be the immediate parent
15687 template, not the most general template. */
15690 /* Now we know the specialization, compute access previously
15691 deferred. */
15698 /* If we've just instantiated the main entry point for a function,
15699 instantiate all the alternate entry points as well. We do this
15700 by cloning the instantiation of the main entry point, not by
15701 instantiating the template clones. */
15706 {
15708 {
15709 /* Remember to reinstantiate when we're out of SFINAE so the user
15710 can see the errors. */
15712 }
15714 }
15716 }
15718 /* Wrapper for instantiate_template_1. */
15720 tree
15722 {
15723 tree ret;
15728 }
15730 /* Instantiate the alias template TMPL with ARGS. Also push a template
15731 instantiation level, which instantiate_template doesn't do because
15732 functions and variables have sufficient context established by the
15733 callers. */
15735 static tree
15737 {
15744 {
15747 }
15749 args =
15757 /* We can't free this if a pending_template entry or last_error_tinst_level
15758 is pointing at it. */
15764 }
15766 /* PARM is a template parameter pack for FN. Returns true iff
15767 PARM is used in a deducible way in the argument list of FN. */
15769 static bool
15771 {
15774 {
15776 tree packs;
15782 {
15783 /* The template parameter pack is used in a function parameter
15784 pack. If this is the end of the parameter list, the
15785 template parameter pack is deducible. */
15788 else
15789 /* Otherwise, not. Well, it could be deduced from
15790 a non-pack parameter, but doing so would end up with
15791 a deduction mismatch, so don't bother. */
15793 }
15794 }
15795 /* The template parameter pack isn't used in any function parameter
15796 packs, but it might be used deeper, e.g. tuple<Args...>. */
15798 }
15800 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15801 NARGS elements of the arguments that are being used when calling
15802 it. TARGS is a vector into which the deduced template arguments
15803 are placed.
15805 Return zero for success, 2 for an incomplete match that doesn't resolve
15806 all the types, and 1 for complete failure. An error message will be
15807 printed only for an incomplete match.
15809 If FN is a conversion operator, or we are trying to produce a specific
15810 specialization, RETURN_TYPE is the return type desired.
15812 The EXPLICIT_TARGS are explicit template arguments provided via a
15813 template-id.
15815 The parameter STRICT is one of:
15817 DEDUCE_CALL:
15818 We are deducing arguments for a function call, as in
15819 [temp.deduct.call].
15821 DEDUCE_CONV:
15822 We are deducing arguments for a conversion function, as in
15823 [temp.deduct.conv].
15825 DEDUCE_EXACT:
15826 We are deducing arguments when doing an explicit instantiation
15827 as in [temp.explicit], when determining an explicit specialization
15828 as in [temp.expl.spec], or when taking the address of a function
15829 template, as in [temp.deduct.funcaddr]. */
15831 tree
15833 tree explicit_targs,
15834 tree targs,
15837 tree return_type,
15838 unification_kind_t strict,
15842 {
15843 tree parms;
15844 tree fntype;
15852 tree tinst;
15858 /* In C++0x, it's possible to have a function template whose type depends
15859 on itself recursively. This is most obvious with decltype, but can also
15860 occur with enumeration scope (c++/48969). So we need to catch infinite
15861 recursion and reject the substitution at deduction time; this function
15862 will return error_mark_node for any repeated substitution.
15864 This also catches excessive recursion such as when f<N> depends on
15865 f<N-1> across all integers, and returns error_mark_node for all the
15866 substitutions back up to the initial one.
15868 This is, of course, not reentrant. */
15878 {
15879 /* [temp.deduct]
15881 The specified template arguments must match the template
15882 parameters in kind (i.e., type, nontype, template), and there
15883 must not be more arguments than there are parameters;
15884 otherwise type deduction fails.
15886 Nontype arguments must match the types of the corresponding
15887 nontype template parameters, or must be convertible to the
15888 types of the corresponding nontype parameters as specified in
15889 _temp.arg.nontype_, otherwise type deduction fails.
15891 All references in the function type of the function template
15892 to the corresponding template parameters are replaced by the
15893 specified template argument values. If a substitution in a
15894 template parameter or in the function type of the function
15895 template results in an invalid type, type deduction fails. */
15900 /* Adjust any explicit template arguments before entering the
15901 substitution context. */
15902 explicit_targs
15904 complain,
15910 /* Substitute the explicit args into the function type. This is
15911 necessary so that, for instance, explicitly declared function
15912 arguments can match null pointed constants. If we were given
15913 an incomplete set of explicit args, we must not do semantic
15914 processing during substitution as we could create partial
15915 instantiations. */
15917 {
15922 /* Dig out the actual parm. */
15925 {
15928 }
15930 {
15933 }
15936 /* No explicit argument for this template parameter. */
15940 {
15941 /* Mark the argument pack as "incomplete". We could
15942 still deduce more arguments during unification.
15943 We remove this mark in type_unification_real. */
15945 {
15949 }
15951 /* We have some incomplete argument packs. */
15953 }
15954 }
15958 {
15961 }
15964 /* Ignore any access checks; we'll see them again in
15965 instantiate_template and they might have the wrong
15966 access path at this point. */
15978 /* Place the explicitly specified arguments in TARGS. */
15981 }
15983 /* Never do unification on the 'this' parameter. */
15987 {
15996 }
15998 /* We allow incomplete unification without an error message here
15999 because the standard doesn't seem to explicitly prohibit it. Our
16000 callers must be ready to deal with unification failures in any
16001 event. */
16004 /* If we aren't explaining yet, push tinst context so we can see where
16005 any errors (e.g. from class instantiations triggered by instantiation
16006 of default template arguments) come from. If we are explaining, this
16007 context is redundant. */
16009 {
16012 }
16014 /* type_unification_real will pass back any access checks from default
16015 template argument substitution. */
16027 /* Now that we have bindings for all of the template arguments,
16028 ensure that the arguments deduced for the template template
16029 parameters have compatible template parameter lists. We cannot
16030 check this property before we have deduced all template
16031 arguments, because the template parameter types of a template
16032 template parameter might depend on prior template parameters
16033 deduced after the template template parameter. The following
16034 ill-formed example illustrates this issue:
16036 template<typename T, template<T> class C> void f(C<5>, T);
16038 template<int N> struct X {};
16040 void g() {
16041 f(X<5>(), 5l); // error: template argument deduction fails
16042 }
16044 The template parameter list of 'C' depends on the template type
16045 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16046 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16047 time that we deduce 'C'. */
16050 {
16053 }
16055 // All is well so far. Now, check that the template constraints
16056 // are satisfied.
16058 {
16062 }
16064 /* All is well so far. Now, check:
16066 [temp.deduct]
16068 When all template arguments have been deduced, all uses of
16069 template parameters in nondeduced contexts are replaced with
16070 the corresponding deduced argument values. If the
16071 substitution results in an invalid type, as described above,
16072 type deduction fails. */
16075 {
16078 }
16080 /* Also collect access checks from the instantiation. */
16093 /* Now perform any access checks encountered during substitution. */
16100 /* If we're looking for an exact match, check that what we got
16101 is indeed an exact match. It might not be if some template
16102 parameters are used in non-deduced contexts. */
16104 {
16108 tree sarg
16114 {
16118 }
16119 }
16123 fail:
16126 {
16128 /* Reset once we're all the way out. */
16130 }
16132 /* We can't free this if a pending_template entry or last_error_tinst_level
16133 is pointing at it. */
16139 }
16141 /* Adjust types before performing type deduction, as described in
16142 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16143 sections are symmetric. PARM is the type of a function parameter
16144 or the return type of the conversion function. ARG is the type of
16145 the argument passed to the call, or the type of the value
16146 initialized with the result of the conversion function.
16147 ARG_EXPR is the original argument expression, which may be null. */
16149 static int
16153 tree arg_expr)
16154 {
16158 {
16163 {
16164 /* Swap PARM and ARG throughout the remainder of this
16165 function; the handling is precisely symmetric since PARM
16166 will initialize ARG rather than vice versa. */
16171 }
16174 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16175 too, but here handle it by stripping the reference from PARM
16176 rather than by adding it to ARG. */
16184 /* Nothing else to do in this case. */
16189 }
16192 {
16193 /* [temp.deduct.call]
16195 If P is not a reference type:
16197 --If A is an array type, the pointer type produced by the
16198 array-to-pointer standard conversion (_conv.array_) is
16199 used in place of A for type deduction; otherwise,
16201 --If A is a function type, the pointer type produced by
16202 the function-to-pointer standard conversion
16203 (_conv.func_) is used in place of A for type deduction;
16204 otherwise,
16206 --If A is a cv-qualified type, the top level
16207 cv-qualifiers of A's type are ignored for type
16208 deduction. */
16213 else
16215 }
16217 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16218 of the form T&&, where T is a template parameter, and the argument
16219 is an lvalue, T is deduced as A& */
16225 /* try_one_overload doesn't provide an arg_expr, but
16226 functions are always lvalues. */
16230 /* [temp.deduct.call]
16232 If P is a cv-qualified type, the top level cv-qualifiers
16233 of P's type are ignored for type deduction. If P is a
16234 reference type, the type referred to by P is used for
16235 type deduction. */
16238 {
16241 }
16243 /* DR 322. For conversion deduction, remove a reference type on parm
16244 too (which has been swapped into ARG). */
16249 }
16251 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16252 template which does contain any deducible template parameters; check if
16253 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16254 unify_one_argument. */
16256 static int
16259 {
16260 tree type;
16264 else
16271 {
16275 }
16277 {
16282 }
16286 else
16288 }
16292 /* Returns true iff the expression EXPR is one from which a template
16293 argument can be deduced. In other words, if it's an undecorated
16294 use of a template non-type parameter. */
16296 static bool
16298 {
16300 }
16302 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16303 deducible way; that is, if it has a max value of <PARM> - 1. */
16305 static bool
16307 {
16316 }
16318 /* Returns true iff the template arguments ARGS use a template parameter
16319 in a deducible way. */
16321 static bool
16323 {
16325 {
16330 else
16331 {
16338 else
16340 }
16343 }
16345 }
16347 /* Returns true iff TYPE contains any deducible references to template
16348 parameters, as per 14.8.2.5. */
16350 static bool
16352 {
16356 /* T
16357 cv-list T
16358 TT<T>
16359 TT<i>
16360 TT<> */
16365 /* T*
16366 T&
16367 T&& */
16371 /* T[integer-constant ]
16372 type [i] */
16377 /* T type ::*
16378 type T::*
16379 T T::*
16380 T (type ::*)()
16381 type (T::*)()
16382 type (type ::*)(T)
16383 type (T::*)(T)
16384 T (type ::*)(T)
16385 T (T::*)()
16386 T (T::*)(T) */
16389 || (uses_deducible_template_parms
16392 /* template-name <T> (where template-name refers to a class template)
16393 template-name <i> (where template-name refers to a class template) */
16400 /* type (T)
16401 T()
16402 T(T) */
16405 {
16414 }
16417 }
16419 /* Subroutine of type_unification_real and unify_pack_expansion to
16420 handle unification of a single P/A pair. Parameters are as
16421 for those functions. */
16423 static int
16427 {
16434 /* We can't deduce anything from this, but we might get all the
16435 template args from other function args. */
16438 /* Implicit conversions (Clause 4) will be performed on a function
16439 argument to convert it to the type of the corresponding function
16440 parameter if the parameter type contains no template-parameters that
16441 participate in template argument deduction. */
16443 /* For function parameters that contain no template-parameters at all,
16444 we have historically checked for convertibility in order to shortcut
16445 consideration of this candidate. */
16447 explain_p);
16450 /* For function parameters with only non-deducible template parameters,
16451 just return. */
16455 {
16457 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
16458 | UNIFY_ALLOW_MORE_CV_QUAL
16472 }
16474 /* We only do these transformations if this is the top-level
16475 parameter_type_list in a call or declaration matching; in other
16476 situations (nested function declarators, template argument lists) we
16477 won't be comparing a type to an expression, and we don't do any type
16478 adjustments. */
16480 {
16482 {
16485 {
16486 /* [temp.deduct.type] A template-argument can be
16487 deduced from a pointer to function or pointer
16488 to member function argument if the set of
16489 overloaded functions does not contain function
16490 templates and at most one of a set of
16491 overloaded functions provides a unique
16492 match. */
16499 }
16505 }
16507 arg_strict |=
16509 }
16510 else
16514 /* For deduction from an init-list we need the actual list. */
16518 }
16520 /* Most parms like fn_type_unification.
16522 If SUBR is 1, we're being called recursively (to unify the
16523 arguments of a function or method parameter of a function
16524 template).
16526 CHECKS is a pointer to a vector of access checks encountered while
16527 substituting default template arguments. */
16529 static int
16531 tree targs,
16532 tree xparms,
16536 unification_kind_t strict,
16540 {
16545 tree parms;
16554 /* Reset the number of non-defaulted template arguments contained
16555 in TARGS. */
16558 again:
16566 {
16571 /* For a function parameter pack that occurs at the end of the
16572 parameter-declaration-list, the type A of each remaining
16573 argument of the call is compared with the type P of the
16574 declarator-id of the function parameter pack. */
16580 /* For a function parameter pack that does not occur at the
16581 end of the parameter-declaration-list, the type of the
16582 parameter pack is a non-deduced context. */
16591 }
16596 {
16597 /* Unify the remaining arguments with the pack expansion type. */
16598 tree argvec;
16601 /* Allocate a TREE_VEC and copy in all of the arguments */
16606 /* Copy the parameter into parmvec. */
16612 /* Advance to the end of the list of parameters. */
16614 }
16616 /* Fail if we've reached the end of the parm list, and more args
16617 are present, and the parm list isn't variadic. */
16620 /* Fail if parms are left and they don't have default values. */
16623 {
16627 {
16628 count++;
16630 }
16632 }
16635 {
16636 tsubst_flags_t complain = (explain_p
16637 ? tf_warning_or_error
16641 {
16645 /* Clear the "incomplete" flags on all argument packs now so that
16646 substituting them into later default arguments works. */
16648 {
16651 }
16657 /* If this is an undeduced nontype parameter that depends on
16658 a type parameter, try another pass; its type may have been
16659 deduced from a later argument than the one from which
16660 this parameter can be deduced. */
16666 /* Core issue #226 (C++0x) [temp.deduct]:
16668 If a template argument has not been deduced, its
16669 default template argument, if any, is used.
16671 When we are in C++98 mode, TREE_PURPOSE will either
16672 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16673 to explicitly check cxx_dialect here. */
16675 {
16690 else
16691 {
16693 /* The position of the first default template argument,
16694 is also the number of non-defaulted arguments in TARGS.
16695 Record that. */
16699 }
16700 }
16702 /* If the type parameter is a parameter pack, then it will
16703 be deduced to an empty parameter pack. */
16705 {
16706 tree arg;
16709 {
16713 }
16714 else
16721 }
16724 }
16725 }
16726 #ifdef ENABLE_CHECKING
16729 #endif
16732 }
16734 /* Subroutine of type_unification_real. Args are like the variables
16735 at the call site. ARG is an overloaded function (or template-id);
16736 we try deducing template args from each of the overloads, and if
16737 only one succeeds, we go with that. Modifies TARGS and returns
16738 true on success. */
16740 static bool
16742 tree targs,
16743 tree parm,
16744 tree arg,
16745 unification_kind_t strict,
16748 {
16755 {
16758 }
16759 else
16763 /* Handle `&x' where `x' is some static or non-static member
16764 function name. */
16770 /* Strip baselink information. */
16775 {
16776 /* If we got some explicit template args, we need to plug them into
16777 the affected templates before we try to unify, in case the
16778 explicit args will completely resolve the templates in question. */
16785 {
16798 {
16803 {
16806 }
16807 }
16810 }
16811 /* If no templates (or more than one) are fully resolved by the
16812 explicit arguments, this template-id is a non-deduced context; it
16813 could still be OK if we deduce all template arguments for the
16814 enclosing call through other arguments. */
16817 }
16820 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16821 -- but the deduction does not succeed because the expression is
16822 not just the function on its own. */
16824 else
16830 {
16833 }
16835 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16836 to function or pointer to member function argument if the set of
16837 overloaded functions does not contain function templates and at most
16838 one of a set of overloaded functions provides a unique match.
16840 So if we found multiple possibilities, we return success but don't
16841 deduce anything. */
16844 {
16849 }
16854 }
16856 /* Core DR 115: In contexts where deduction is done and fails, or in
16857 contexts where deduction is not done, if a template argument list is
16858 specified and it, along with any default template arguments, identifies
16859 a single function template specialization, then the template-id is an
16860 lvalue for the function template specialization. */
16862 tree
16864 {
16877 {
16880 }
16882 {
16885 }
16887 {
16890 }
16893 {
16897 /* If we got some explicit template args, we need to plug them into
16898 the affected templates before we try to unify, in case the
16899 explicit args will completely resolve the templates in question. */
16907 {
16920 {
16923 {
16926 }
16928 {
16931 }
16932 }
16933 }
16935 {
16943 {
16944 tree base
16947 }
16951 }
16953 /* There were no good options and at least one bad one, so let the
16954 user know what the problem is. */
16956 }
16958 }
16960 /* Subroutine of resolve_overloaded_unification; does deduction for a single
16961 overload. Fills TARGS with any deduced arguments, or error_mark_node if
16962 different overloads deduce different arguments for a given parm.
16963 ADDR_P is true if the expression for which deduction is being
16964 performed was of the form "& fn" rather than simply "fn".
16966 Returns 1 on success. */
16968 static int
16970 tree orig_targs,
16971 tree targs,
16972 tree parm,
16973 tree arg,
16974 unification_kind_t strict,
16978 {
16980 tree tempargs;
16986 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16987 to function or pointer to member function argument if the set of
16988 overloaded functions does not contain function templates and at most
16989 one of a set of overloaded functions provides a unique match.
16991 So if this is a template, just return success. */
17003 /* We don't copy orig_targs for this because if we have already deduced
17004 some template args from previous args, unify would complain when we
17005 try to deduce a template parameter for the same argument, even though
17006 there isn't really a conflict. */
17013 /* First make sure we didn't deduce anything that conflicts with
17014 explicitly specified args. */
17016 {
17023 /* Since we're unifying against ourselves, we will fill in
17024 template args used in the function parm list with our own
17025 template parms. Discard them. */
17029 }
17032 {
17037 }
17040 }
17042 /* PARM is a template class (perhaps with unbound template
17043 parameters). ARG is a fully instantiated type. If ARG can be
17044 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17045 TARGS are as for unify. */
17047 static tree
17050 {
17051 tree copy_of_targs;
17058 /* We need to make a new template argument vector for the call to
17059 unify. If we used TARGS, we'd clutter it up with the result of
17060 the attempted unification, even if this class didn't work out.
17061 We also don't want to commit ourselves to all the unifications
17062 we've already done, since unification is supposed to be done on
17063 an argument-by-argument basis. In other words, consider the
17064 following pathological case:
17066 template <int I, int J, int K>
17067 struct S {};
17069 template <int I, int J>
17070 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17072 template <int I, int J, int K>
17073 void f(S<I, J, K>, S<I, I, I>);
17075 void g() {
17076 S<0, 0, 0> s0;
17077 S<0, 1, 2> s2;
17079 f(s0, s2);
17080 }
17082 Now, by the time we consider the unification involving `s2', we
17083 already know that we must have `f<0, 0, 0>'. But, even though
17084 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17085 because there are two ways to unify base classes of S<0, 1, 2>
17086 with S<I, I, I>. If we kept the already deduced knowledge, we
17087 would reject the possibility I=1. */
17090 /* If unification failed, we're done. */
17096 }
17098 /* Given a template type PARM and a class type ARG, find the unique
17099 base type in ARG that is an instance of PARM. We do not examine
17100 ARG itself; only its base-classes. If there is not exactly one
17101 appropriate base class, return NULL_TREE. PARM may be the type of
17102 a partial specialization, as well as a plain template type. Used
17103 by unify. */
17105 static enum template_base_result
17108 {
17110 tree binfo;
17116 {
17117 /* The type could not be completed. */
17120 }
17122 /* Walk in inheritance graph order. The search order is not
17123 important, and this avoids multiple walks of virtual bases. */
17125 {
17130 {
17131 /* If there is more than one satisfactory baseclass, then:
17133 [temp.deduct.call]
17135 If they yield more than one possible deduced A, the type
17136 deduction fails.
17138 applies. */
17140 {
17143 }
17146 }
17147 }
17151 }
17153 /* Returns the level of DECL, which declares a template parameter. */
17155 static int
17157 {
17159 {
17169 }
17171 }
17173 /* Decide whether ARG can be unified with PARM, considering only the
17174 cv-qualifiers of each type, given STRICT as documented for unify.
17175 Returns nonzero iff the unification is OK on that basis. */
17177 static int
17179 {
17185 {
17186 /* Although a CVR qualifier is ignored when being applied to a
17187 substituted template parameter ([8.3.2]/1 for example), that
17188 does not allow us to unify "const T" with "int&" because both
17189 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17190 It is ok when we're allowing additional CV qualifiers
17191 at the outer level [14.8.2.1]/3,1st bullet. */
17201 }
17212 }
17214 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17215 void
17217 {
17221 {
17224 }
17225 else
17226 {
17229 }
17230 }
17232 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17233 do { \
17234 if (unify (TP, TA, P, A, S, EP)) \
17235 return 1; \
17236 } while (0);
17238 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17239 expansion at the end of PACKED_PARMS. Returns 0 if the type
17240 deduction succeeds, 1 otherwise. STRICT is the same as in
17241 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17242 call argument list. We'll need to adjust the arguments to make them
17243 types. SUBR tells us if this is from a recursive call to
17244 type_unification_real, or for comparing two template argument
17245 lists. */
17247 static int
17251 {
17252 tree parm
17259 /* Determine the parameter packs we will be deducing from the
17260 pattern, and record their current deductions. */
17263 {
17267 /* Determine the index and level of this parameter pack. */
17270 /* Keep track of the parameter packs and their corresponding
17271 argument packs. */
17274 }
17276 /* Loop through all of the arguments that have not yet been
17277 unified and unify each with the pattern. */
17279 {
17280 tree parm;
17284 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17285 or the element of its argument pack at the current index if
17286 this argument was explicitly specified. */
17288 {
17297 {
17300 }
17302 }
17304 /* If we had explicit template arguments, substitute them into the
17305 pattern before deduction. */
17307 {
17308 /* Some arguments might still be unspecified or dependent. */
17316 NULL_TREE);
17321 }
17322 else
17325 /* Unify the pattern with the current argument. */
17330 /* For each parameter pack, collect the deduced value. */
17332 {
17338 }
17339 }
17341 /* Verify that the results of unification with the parameter packs
17342 produce results consistent with what we've seen before, and make
17343 the deduced argument packs available. */
17345 {
17352 /* By default keep the original deduced argument pack.
17353 If necessary, more specific code is going to update the
17354 resulting deduced argument later down in this function. */
17358 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17359 actually deduce anything. */
17367 {
17368 /* If we had fewer function args than explicit template args,
17369 just use the explicits. */
17374 }
17377 {
17378 tree result;
17379 /* Build the deduced *_ARGUMENT_PACK. */
17381 {
17386 }
17387 else
17392 /* Note the deduced argument packs for this parameter
17393 pack. */
17395 }
17399 {
17400 /* We only had the explicitly-provided arguments before, but
17401 now we have a complete set of arguments. */
17407 }
17408 else
17409 {
17415 /* Inconsistent unification of this parameter pack. */
17417 bad_old_arg,
17418 bad_new_arg);
17419 }
17420 }
17423 }
17425 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17426 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17427 parameters and return value are as for unify. */
17429 static int
17433 {
17434 tree parm_max;
17435 tree arg_max;
17439 /* Our representation of array types uses "N - 1" as the
17440 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17441 not an integer constant. We cannot unify arbitrarily
17442 complex expressions, so we eliminate the MINUS_EXPRs
17443 here. */
17447 {
17450 }
17454 {
17455 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17456 trying to unify the type of a variable with the type
17457 of a template parameter. For example:
17459 template <unsigned int N>
17460 void f (char (&) [N]);
17461 int g();
17462 void h(int i) {
17463 char a[g(i)];
17464 f(a);
17465 }
17467 Here, the type of the ARG will be "int [g(i)]", and
17468 may be a SAVE_EXPR, etc. */
17472 }
17474 /* If only one of the bounds used a MINUS_EXPR, compensate
17475 by adding one to the other bound. */
17478 integer_type_node,
17479 parm_max,
17480 integer_one_node);
17483 integer_type_node,
17484 arg_max,
17485 integer_one_node);
17489 }
17491 /* Deduce the value of template parameters. TPARMS is the (innermost)
17492 set of template parameters to a template. TARGS is the bindings
17493 for those template parameters, as determined thus far; TARGS may
17494 include template arguments for outer levels of template parameters
17495 as well. PARM is a parameter to a template function, or a
17496 subcomponent of that parameter; ARG is the corresponding argument.
17497 This function attempts to match PARM with ARG in a manner
17498 consistent with the existing assignments in TARGS. If more values
17499 are deduced, then TARGS is updated.
17501 Returns 0 if the type deduction succeeds, 1 otherwise. The
17502 parameter STRICT is a bitwise or of the following flags:
17504 UNIFY_ALLOW_NONE:
17505 Require an exact match between PARM and ARG.
17506 UNIFY_ALLOW_MORE_CV_QUAL:
17507 Allow the deduced ARG to be more cv-qualified (by qualification
17508 conversion) than ARG.
17509 UNIFY_ALLOW_LESS_CV_QUAL:
17510 Allow the deduced ARG to be less cv-qualified than ARG.
17511 UNIFY_ALLOW_DERIVED:
17512 Allow the deduced ARG to be a template base class of ARG,
17513 or a pointer to a template base class of the type pointed to by
17514 ARG.
17515 UNIFY_ALLOW_INTEGER:
17516 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17517 case for more information.
17518 UNIFY_ALLOW_OUTER_LEVEL:
17519 This is the outermost level of a deduction. Used to determine validity
17520 of qualification conversions. A valid qualification conversion must
17521 have const qualified pointers leading up to the inner type which
17522 requires additional CV quals, except at the outer level, where const
17523 is not required [conv.qual]. It would be normal to set this flag in
17524 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17525 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17526 This is the outermost level of a deduction, and PARM can be more CV
17527 qualified at this point.
17528 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17529 This is the outermost level of a deduction, and PARM can be less CV
17530 qualified at this point. */
17532 static int
17535 {
17537 tree targ;
17538 tree tparm;
17541 /* I don't think this will do the right thing with respect to types.
17542 But the only case I've seen it in so far has been array bounds, where
17543 signedness is the only information lost, and I think that will be
17544 okay. */
17552 /* We can't deduce anything from this, but we might get all the
17553 template args from other function args. */
17556 /* If PARM uses template parameters, then we can't bail out here,
17557 even if ARG == PARM, since we won't record unifications for the
17558 template parameters. We might need them if we're trying to
17559 figure out which of two things is more specialized. */
17563 /* Handle init lists early, so the rest of the function can assume
17564 we're dealing with a type. */
17566 {
17571 /* Replace T with std::initializer_list<T> for deduction. */
17578 /* We can only deduce from an initializer list argument if the
17579 parameter is std::initializer_list or an array; otherwise this
17580 is a non-deduced context. */
17585 else
17589 {
17596 {
17598 /* It should only be possible to get here for a call. */
17600 elt_strict |= maybe_adjust_types_for_deduction
17603 }
17606 explain_p);
17607 }
17610 {
17611 /* Also deduce from the length of the initializer list. */
17616 }
17618 /* If the std::initializer_list<T> deduction worked, replace the
17619 deduced A with std::initializer_list<A>. */
17621 {
17626 }
17628 }
17630 /* Immediately reject some pairs that won't unify because of
17631 cv-qualification mismatches. */
17634 /* It is the elements of the array which hold the cv quals of an array
17635 type, and the elements might be template type parms. We'll check
17636 when we recurse. */
17638 /* We check the cv-qualifiers when unifying with template type
17639 parameters below. We want to allow ARG `const T' to unify with
17640 PARM `T' for example, when computing which of two templates
17641 is more specialized, for example. */
17655 {
17659 /* In a type which contains a nested-name-specifier, template
17660 argument values cannot be deduced for template parameters used
17661 within the nested-name-specifier. */
17673 /* The PARM is not one we're trying to unify. Just check
17674 to see if it matches ARG. */
17675 {
17680 else
17682 }
17689 /* Check for mixed types and values. */
17697 {
17698 /* ARG must be constructed from a template class or a template
17699 template parameter. */
17704 {
17708 tree parm_parms
17709 = DECL_INNERMOST_TEMPLATE_PARMS
17714 /* The resolution to DR150 makes clear that default
17715 arguments for an N-argument may not be used to bind T
17716 to a template template parameter with fewer than N
17717 parameters. It is not safe to permit the binding of
17718 default arguments as an extension, as that may change
17719 the meaning of a conforming program. Consider:
17721 struct Dense { static const unsigned int dim = 1; };
17723 template <template <typename> class View,
17724 typename Block>
17725 void operator+(float, View<Block> const&);
17727 template <typename Block,
17728 unsigned int Dim = Block::dim>
17729 struct Lvalue_proxy { operator float() const; };
17731 void
17732 test_1d (void) {
17733 Lvalue_proxy<Dense> p;
17734 float b;
17735 b + p;
17736 }
17738 Here, if Lvalue_proxy is permitted to bind to View, then
17739 the global operator+ will be used; if they are not, the
17740 Lvalue_proxy will be converted to float. */
17742 full_argvec,
17744 (explain_p
17745 ? tf_warning_or_error
17752 /* Deduce arguments T, i from TT<T> or TT<i>.
17753 We check each element of PARMVEC and ARGVEC individually
17754 rather than the whole TREE_VEC since they can have
17755 different number of elements. */
17762 /* Check if the parameters end in a pack, making them
17763 variadic. */
17769 /* If the template argument list of P contains a pack
17770 expansion that is not the last template argument, the
17771 entire template argument list is a non-deduced
17772 context. */
17781 {
17786 }
17791 DEDUCE_EXACT,
17794 }
17797 /* Fall through to deduce template name. */
17798 }
17802 {
17803 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17805 /* Simple cases: Value already set, does match or doesn't. */
17810 }
17811 else
17812 {
17813 /* If PARM is `const T' and ARG is only `int', we don't have
17814 a match unless we are allowing additional qualification.
17815 If ARG is `const int' and PARM is just `T' that's OK;
17816 that binds `const int' to `T'. */
17821 /* Consider the case where ARG is `const volatile int' and
17822 PARM is `const T'. Then, T should be `volatile int'. */
17823 arg = cp_build_qualified_type_real
17828 /* Simple cases: Value already set, does match or doesn't. */
17834 /* Make sure that ARG is not a variable-sized array. (Note
17835 that were talking about variable-sized arrays (like
17836 `int[n]'), rather than arrays of unknown size (like
17837 `int[]').) We'll get very confused by such a type since
17838 the bound of the array is not constant, and therefore
17839 not mangleable. Besides, such types are not allowed in
17840 ISO C++, so we can do as we please here. We do allow
17841 them for 'auto' deduction, since that isn't ABI-exposed. */
17845 /* Strip typedefs as in convert_template_argument. */
17847 }
17849 /* If ARG is a parameter pack or an expansion, we cannot unify
17850 against it unless PARM is also a parameter pack. */
17855 /* If the argument deduction results is a METHOD_TYPE,
17856 then there is a problem.
17857 METHOD_TYPE doesn't map to any real C++ type the result of
17858 the deduction can not be of that type. */
17872 {
17873 /* The PARM is not one we're trying to unify. Just check
17874 to see if it matches ARG. */
17880 }
17886 {
17891 }
17893 /* [temp.deduct.type] If, in the declaration of a function template
17894 with a non-type template-parameter, the non-type
17895 template-parameter is used in an expression in the function
17896 parameter-list and, if the corresponding template-argument is
17897 deduced, the template-argument type shall match the type of the
17898 template-parameter exactly, except that a template-argument
17899 deduced from an array bound may be of any integral type.
17900 The non-type parameter might use already deduced type parameters. */
17903 /* Template-parameter dependent expression. Just accept it for now.
17904 It will later be processed in convert_template_argument. */
17905 ;
17910 /* Convert the ARG to the type of PARM; the deduced non-type
17911 template argument must exactly match the types of the
17912 corresponding parameter. */
17915 /* We haven't deduced the type of this parameter yet. Try again
17916 later. */
17918 else
17921 /* If ARG is a parameter pack or an expansion, we cannot unify
17922 against it unless PARM is also a parameter pack. */
17932 {
17933 /* A pointer-to-member constant can be unified only with
17934 another constant. */
17938 /* Just unify the class member. It would be useless (and possibly
17939 wrong, depending on the strict flags) to unify also
17940 PTRMEM_CST_CLASS, because we want to be sure that both parm and
17941 arg refer to the same variable, even if through different
17942 classes. For instance:
17944 struct A { int x; };
17945 struct B : A { };
17947 Unification of &A::x and &B::x must succeed. */
17950 }
17953 {
17957 /* [temp.deduct.call]
17959 A can be another pointer or pointer to member type that can
17960 be converted to the deduced A via a qualification
17961 conversion (_conv.qual_).
17963 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
17964 This will allow for additional cv-qualification of the
17965 pointed-to types if appropriate. */
17968 /* The derived-to-base conversion only persists through one
17969 level of pointers. */
17974 }
18006 /* We have already checked cv-qualification at the top of the
18007 function. */
18011 /* As far as unification is concerned, this wins. Later checks
18012 will invalidate it if necessary. */
18015 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18016 /* Type INTEGER_CST can come from ordinary constant template args. */
18028 {
18038 /* Check for pack expansions in the parameters. */
18040 {
18042 {
18044 /* We can unify against something with a trailing
18045 parameter pack. */
18047 else
18048 /* [temp.deduct.type]/9: If the template argument list of
18049 P contains a pack expansion that is not the last
18050 template argument, the entire template argument list
18051 is a non-deduced context. */
18053 }
18054 }
18056 /* If we don't have enough arguments to satisfy the parameters
18057 (not counting the pack expression at the end), or we have
18058 too many arguments for a parameter list that doesn't end in
18059 a pack expression, we can't unify. */
18065 /* Unify all of the parameters that precede the (optional)
18066 pack expression. */
18068 {
18073 }
18076 DEDUCE_EXACT,
18079 }
18087 {
18095 }
18098 {
18102 {
18103 /* First, we try to unify the PARM and ARG directly. */
18108 {
18109 /* Fallback to the special case allowed in
18110 [temp.deduct.call]:
18112 If P is a class, and P has the form
18113 template-id, then A can be a derived class of
18114 the deduced A. Likewise, if P is a pointer to
18115 a class of the form template-id, A can be a
18116 pointer to a derived class pointed to by the
18117 deduced A. */
18124 }
18125 }
18129 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18130 Then, we should unify `int' and `U'. */
18132 else
18133 /* There's no chance of unification succeeding. */
18138 }
18145 {
18148 tree a;
18154 /* CV qualifications for methods can never be deduced, they must
18155 match exactly. We need to check them explicitly here,
18156 because type_unification_real treats them as any other
18157 cv-qualified parameter. */
18159 && (!check_cv_quals_for_unify
18179 }
18182 /* Unify a pointer to member with a pointer to member function, which
18183 deduces the type of the member as a function type. */
18185 {
18186 /* Check top-level cv qualifiers */
18194 /* Determine the type of the function we are unifying against. */
18198 }
18217 /* Matched cases are handled by the ARG == PARM test above. */
18221 /* A non-type template parameter that is a variable should be a
18222 an integral constant, in which case, it whould have been
18223 folded into its (constant) value. So we should not be getting
18224 a variable here. */
18235 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18236 or UNDERLYING_TYPE nodes. */
18240 /* Unification fails if we hit an error node. */
18244 /* An unresolved overload is a nondeduced context. */
18249 /* We must be looking at an expression. This can happen with
18250 something like:
18252 template <int I>
18253 void foo(S<I>, S<I + 2>);
18255 This is a "nondeduced context":
18257 [deduct.type]
18259 The nondeduced contexts are:
18261 --A type that is a template-id in which one or more of
18262 the template-arguments is an expression that references
18263 a template-parameter.
18265 In these cases, we assume deduction succeeded, but don't
18266 actually infer any unifications. */
18271 else
18273 }
18274 }
18275 #undef RECUR_AND_CHECK_FAILURE
18276 \f
18277 /* Note that DECL can be defined in this translation unit, if
18278 required. */
18280 static void
18282 {
18283 tree clone;
18287 }
18289 /* Called if RESULT is explicitly instantiated, or is a member of an
18290 explicitly instantiated class. */
18292 void
18294 {
18297 /* If this entity has already been written out, it's too late to
18298 make any modifications. */
18302 /* For anonymous namespace we don't need to do anything. */
18304 {
18307 }
18310 /* The TREE_PUBLIC flag for function declarations will have been
18311 set correctly by tsubst. */
18314 /* This might have been set by an earlier implicit instantiation. */
18319 else
18320 {
18322 /* Always make artificials weak. */
18325 /* For WIN32 we also want to put explicit instantiations in
18326 linkonce sections. */
18329 }
18331 /* If EXTERN_P, then this function will not be emitted -- unless
18332 followed by an explicit instantiation, at which point its linkage
18333 will be adjusted. If !EXTERN_P, then this function will be
18334 emitted here. In neither circumstance do we want
18335 import_export_decl to adjust the linkage. */
18337 }
18339 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18340 important template arguments. If any are missing, we check whether
18341 they're important by using error_mark_node for substituting into any
18342 args that were used for partial ordering (the ones between ARGS and END)
18343 and seeing if it bubbles up. */
18345 static bool
18347 {
18352 {
18355 }
18357 {
18361 }
18363 }
18365 /* Given two function templates PAT1 and PAT2, return:
18367 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18368 -1 if PAT2 is more specialized than PAT1.
18369 0 if neither is more specialized.
18371 LEN indicates the number of parameters we should consider
18372 (defaulted parameters should not be considered).
18374 The 1998 std underspecified function template partial ordering, and
18375 DR214 addresses the issue. We take pairs of arguments, one from
18376 each of the templates, and deduce them against each other. One of
18377 the templates will be more specialized if all the *other*
18378 template's arguments deduce against its arguments and at least one
18379 of its arguments *does* *not* deduce against the other template's
18380 corresponding argument. Deduction is done as for class templates.
18381 The arguments used in deduction have reference and top level cv
18382 qualifiers removed. Iff both arguments were originally reference
18383 types *and* deduction succeeds in both directions, an lvalue reference
18384 wins against an rvalue reference and otherwise the template
18385 with the more cv-qualified argument wins for that pairing (if
18386 neither is more cv-qualified, they both are equal). Unlike regular
18387 deduction, after all the arguments have been deduced in this way,
18388 we do *not* verify the deduced template argument values can be
18389 substituted into non-deduced contexts.
18391 The logic can be a bit confusing here, because we look at deduce1 and
18392 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18393 can find template arguments for pat1 to make arg1 look like arg2, that
18394 means that arg2 is at least as specialized as arg1. */
18396 int
18398 {
18411 /* Remove the this parameter from non-static member functions. If
18412 one is a non-static member function and the other is not a static
18413 member function, remove the first parameter from that function
18414 also. This situation occurs for operator functions where we
18415 locate both a member function (with this pointer) and non-member
18416 operator (with explicit first operand). */
18418 {
18423 }
18425 {
18428 {
18429 len--;
18431 }
18432 }
18434 /* If only one is a conversion operator, they are unordered. */
18438 /* Consider the return type for a conversion function */
18440 {
18443 len++;
18444 }
18446 processing_template_decl++;
18452 /* Stop when an ellipsis is seen. */
18454 {
18465 {
18466 /* When both arguments are pack expansions, we need only
18467 unify the patterns themselves. */
18471 /* This is the last comparison we need to do. */
18473 }
18476 {
18480 }
18483 {
18487 }
18493 {
18499 /* Setup the parameter vector, which contains only ARG1. */
18502 /* Setup the argument vector, which contains the remaining
18503 arguments. */
18512 /* We cannot deduce in the other direction, because ARG1 is
18513 a pack expansion but ARG2 is not. */
18515 }
18517 {
18523 /* Setup the parameter vector, which contains only ARG1. */
18526 /* Setup the argument vector, which contains the remaining
18527 arguments. */
18536 /* We cannot deduce in the other direction, because ARG2 is
18537 a pack expansion but ARG1 is not.*/
18539 }
18541 else
18542 {
18543 /* The normal case, where neither argument is a pack
18544 expansion. */
18551 }
18553 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18554 arg2, then arg2 is not as specialized as arg1. */
18560 /* "If, for a given type, deduction succeeds in both directions
18561 (i.e., the types are identical after the transformations above)
18562 and both P and A were reference types (before being replaced with
18563 the type referred to above):
18564 - if the type from the argument template was an lvalue reference and
18565 the type from the parameter template was not, the argument type is
18566 considered to be more specialized than the other; otherwise,
18567 - if the type from the argument template is more cv-qualified
18568 than the type from the parameter template (as described above),
18569 the argument type is considered to be more specialized than the other;
18570 otherwise,
18571 - neither type is more specialized than the other." */
18574 {
18576 {
18579 else
18581 }
18583 {
18588 }
18589 }
18592 /* We've failed to deduce something in either direction.
18593 These must be unordered. */
18598 /* We have already processed all of the arguments in our
18599 handing of the pack expansion type. */
18604 }
18606 /* "In most cases, all template parameters must have values in order for
18607 deduction to succeed, but for partial ordering purposes a template
18608 parameter may remain without a value provided it is not used in the
18609 types being used for partial ordering."
18611 Thus, if we are missing any of the targs1 we need to substitute into
18612 origs1, then pat2 is not as specialized as pat1. This can happen when
18613 there is a nondeduced context. */
18619 processing_template_decl--;
18621 /* All things being equal, if the next argument is a pack expansion
18622 for one function but not for the other, prefer the
18623 non-variadic function. FIXME this is bogus; see c++/41958. */
18627 {
18630 }
18632 // All things still being equal, determine if one is more constrained.
18634 {
18637 }
18643 else
18645 }
18647 /* Determine which of two partial specializations of MAIN_TMPL is more
18648 specialized.
18650 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18651 to the first partial specialization. The TREE_VALUE is the
18652 innermost set of template parameters for the partial
18653 specialization. PAT2 is similar, but for the second template.
18655 Return 1 if the first partial specialization is more specialized;
18656 -1 if the second is more specialized; 0 if neither is more
18657 specialized.
18659 See [temp.class.order] for information about determining which of
18660 two templates is more specialized. */
18662 static int
18664 {
18665 tree targs;
18674 /* Just like what happens for functions, if we are ordering between
18675 different class template specializations, we may encounter dependent
18676 types in the arguments, and we need our dependency check functions
18677 to behave correctly. */
18683 {
18686 }
18692 {
18695 }
18698 /* In the case of a tie where at least one of the class templates
18699 has a parameter pack at the end, the template with the most
18700 non-packed parameters wins. */
18702 && any_deductions
18705 {
18711 /* We don't count the pack expansion at the end. */
18721 }
18729 }
18731 /* Return the template arguments that will produce the function signature
18732 DECL from the function template FN, with the explicit template
18733 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18734 also match. Return NULL_TREE if no satisfactory arguments could be
18735 found. */
18737 static tree
18739 {
18743 tree decl_arg_types;
18746 tree arg;
18750 /* Never do unification on the 'this' parameter. */
18771 }
18773 /* Return the innermost template arguments that, when applied to a partial
18774 specialization of MAIN_TMPL whose innermost template parameters are
18775 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18776 ARGS.
18778 For example, suppose we have:
18780 template <class T, class U> struct S {};
18781 template <class T> struct S<T*, int> {};
18783 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18784 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18785 int}. The resulting vector will be {double}, indicating that `T'
18786 is bound to `double'. */
18788 static tree
18791 {
18793 tree deduced_args;
18794 tree innermost_deduced_args;
18798 {
18802 innermost_deduced_args);
18803 }
18804 else
18817 /* Verify that nondeduced template arguments agree with the type
18818 obtained from argument deduction.
18820 For example:
18822 struct A { typedef int X; };
18823 template <class T, class U> struct C {};
18824 template <class T> struct C<T, typename T::X> {};
18826 Then with the instantiation `C<A, int>', we can deduce that
18827 `T' is `A' but unify () does not check whether `typename T::X'
18828 is `int'. */
18834 /* We only need to check the innermost arguments; the other
18835 arguments will always agree. */
18840 /* Now that we have bindings for all of the template arguments,
18841 ensure that the arguments deduced for the template template
18842 parameters have compatible template parameter lists. See the use
18843 of template_template_parm_bindings_ok_p in fn_type_unification
18844 for more information. */
18848 // Having computed and checked the binding, make sure that the
18849 // deduced arguments actually satisfy the template constraints.
18850 // If not, it is equivalent to having failed to compute the binding.
18855 }
18857 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18858 Return the TREE_LIST node with the most specialized template, if
18859 any. If there is no most specialized template, the error_mark_node
18860 is returned.
18862 Note that this function does not look at, or modify, the
18863 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18864 returned is one of the elements of INSTANTIATIONS, callers may
18865 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18866 and retrieve it from the value returned. */
18868 tree
18870 {
18877 {
18883 fate--;
18888 fate++;
18893 {
18894 /* Equally specialized, move to next function. If there
18895 is no next function, nothing's most specialized. */
18900 }
18901 }
18904 /* Now verify that champ is better than everything earlier in the
18905 instantiation list. */
18913 {
18916 }
18918 processing_template_decl--;
18924 }
18926 /* If DECL is a specialization of some template, return the most
18927 general such template. Otherwise, returns NULL_TREE.
18929 For example, given:
18931 template <class T> struct S { template <class U> void f(U); };
18933 if TMPL is `template <class U> void S<int>::f(U)' this will return
18934 the full template. This function will not trace past partial
18935 specializations, however. For example, given in addition:
18937 template <class T> struct S<T*> { template <class U> void f(U); };
18939 if TMPL is `template <class U> void S<int*>::f(U)' this will return
18940 `template <class T> template <class U> S<T*>::f(U)'. */
18942 tree
18944 {
18945 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
18946 an immediate specialization. */
18948 {
18952 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
18953 template friend. */
18958 }
18960 /* Look for more and more general templates. */
18962 {
18963 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
18964 (See cp-tree.h for details.) */
18972 /* Stop if we run into an explicitly specialized class template. */
18979 }
18982 }
18984 /* Return the most specialized of the class template partial
18985 specializations of TMPL which can produce TYPE, a specialization of
18986 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
18987 a _TYPE node corresponding to the partial specialization, while the
18988 TREE_PURPOSE is the set of template arguments that must be
18989 substituted into the TREE_TYPE in order to generate TYPE.
18991 If the choice of partial specialization is ambiguous, a diagnostic
18992 is issued, and the error_mark_node is returned. If there are no
18993 partial specializations of TMPL matching TYPE, then NULL_TREE is
18994 returned. */
18996 static tree
18998 {
19000 tree t;
19001 tree champ;
19004 tree args;
19010 /* For determining which partial specialization to use, only the
19011 innermost args are interesting. */
19013 {
19016 }
19019 {
19020 tree partial_spec_args;
19021 tree spec_args;
19030 {
19031 /* Discard the outer levels of args, and then substitute in the
19032 template args from the enclosing class. */
19034 partial_spec_args = tsubst_template_args
19037 /* And the same for the partial specialization TEMPLATE_DECL. */
19039 }
19041 partial_spec_args =
19044 partial_spec_args),
19058 partial_spec_args,
19059 args);
19061 {
19066 }
19067 }
19077 {
19080 ;
19081 else
19082 {
19084 {
19087 {
19090 }
19091 }
19093 }
19094 }
19098 {
19101 {
19104 }
19105 }
19108 {
19116 {
19119 }
19122 }
19125 }
19127 /* Explicitly instantiate DECL. */
19129 void
19131 {
19136 /* An error occurred, for which grokdeclarator has already issued
19137 an appropriate message. */
19140 {
19143 }
19145 {
19146 /* There is an asymmetry here in the way VAR_DECLs and
19147 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19148 the latter, the DECL we get back will be marked as a
19149 template instantiation, and the appropriate
19150 DECL_TEMPLATE_INFO will be set up. This does not happen for
19151 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19152 should handle VAR_DECLs as it currently handles
19153 FUNCTION_DECLs. */
19155 {
19158 }
19161 {
19164 }
19166 {
19171 }
19172 }
19174 {
19177 }
19178 else
19181 /* Check for various error cases. Note that if the explicit
19182 instantiation is valid the RESULT will currently be marked as an
19183 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19184 until we get here. */
19187 {
19188 /* DR 259 [temp.spec].
19190 Both an explicit instantiation and a declaration of an explicit
19191 specialization shall not appear in a program unless the explicit
19192 instantiation follows a declaration of the explicit specialization.
19194 For a given set of template parameters, if an explicit
19195 instantiation of a template appears after a declaration of an
19196 explicit specialization for that template, the explicit
19197 instantiation has no effect. */
19199 }
19201 {
19202 /* [temp.spec]
19204 No program shall explicitly instantiate any template more
19205 than once.
19207 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19208 the first instantiation was `extern' and the second is not,
19209 and EXTERN_P for the opposite case. */
19212 /* If an "extern" explicit instantiation follows an ordinary
19213 explicit instantiation, the template is instantiated. */
19216 }
19218 {
19221 }
19223 {
19226 }
19229 ;
19231 {
19234 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19237 }
19238 else
19246 }
19248 static void
19250 {
19256 {
19259 }
19260 }
19262 /* Called from do_type_instantiation through binding_table_foreach to
19263 do recursive instantiation for the type bound in ENTRY. */
19264 static void
19266 {
19272 }
19274 /* Called from do_type_instantiation to instantiate a member
19275 (a member function or a static member variable) of an
19276 explicitly instantiated class template. */
19277 static void
19279 {
19284 }
19286 /* Perform an explicit instantiation of template class T. STORAGE, if
19287 non-null, is the RID for extern, inline or static. COMPLAIN is
19288 nonzero if this is called from the parser, zero if called recursively,
19289 since the standard is unclear (as detailed below). */
19291 void
19293 {
19303 {
19304 tree tmpl =
19308 else
19311 }
19316 {
19319 t);
19321 }
19324 {
19326 {
19328 {
19331 "ISO C++ 1998 forbids the use of %<extern%> on "
19333 }
19334 else
19336 "ISO C++ forbids the use of %qE"
19338 }
19346 else
19347 {
19349 storage);
19351 }
19352 }
19355 {
19356 /* DR 259 [temp.spec].
19358 Both an explicit instantiation and a declaration of an explicit
19359 specialization shall not appear in a program unless the explicit
19360 instantiation follows a declaration of the explicit specialization.
19362 For a given set of template parameters, if an explicit
19363 instantiation of a template appears after a declaration of an
19364 explicit specialization for that template, the explicit
19365 instantiation has no effect. */
19367 }
19369 {
19370 /* [temp.spec]
19372 No program shall explicitly instantiate any template more
19373 than once.
19375 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19376 instantiation was `extern'. If EXTERN_P then the second is.
19377 These cases are OK. */
19384 /* If we've already instantiated the template, just return now. */
19387 }
19395 {
19396 tree tmp;
19398 /* In contrast to implicit instantiation, where only the
19399 declarations, and not the definitions, of members are
19400 instantiated, we have here:
19402 [temp.explicit]
19404 The explicit instantiation of a class template specialization
19405 implies the instantiation of all of its members not
19406 previously explicitly specialized in the translation unit
19407 containing the explicit instantiation.
19409 Of course, we can't instantiate member template classes, since
19410 we don't have any arguments for them. Note that the standard
19411 is unclear on whether the instantiation of the members are
19412 *explicit* instantiations or not. However, the most natural
19413 interpretation is that it should be an explicit instantiation. */
19428 }
19429 }
19431 /* Given a function DECL, which is a specialization of TMPL, modify
19432 DECL to be a re-instantiation of TMPL with the same template
19433 arguments. TMPL should be the template into which tsubst'ing
19434 should occur for DECL, not the most general template.
19436 One reason for doing this is a scenario like this:
19438 template <class T>
19439 void f(const T&, int i);
19441 void g() { f(3, 7); }
19443 template <class T>
19444 void f(const T& t, const int i) { }
19446 Note that when the template is first instantiated, with
19447 instantiate_template, the resulting DECL will have no name for the
19448 first parameter, and the wrong type for the second. So, when we go
19449 to instantiate the DECL, we regenerate it. */
19451 static void
19453 {
19454 /* The arguments used to instantiate DECL, from the most general
19455 template. */
19456 tree args;
19457 tree code_pattern;
19462 /* Make sure that we can see identifiers, and compute access
19463 correctly. */
19467 {
19468 tree decl_parm;
19469 tree pattern_parm;
19470 tree specs;
19484 specs);
19486 /* Merge parameter declarations. */
19489 pattern_parm
19493 {
19494 tree parm_type;
19495 tree attributes;
19500 NULL_TREE);
19506 {
19509 }
19512 }
19513 /* Merge any parameters that match with the function parameter
19514 pack. */
19516 {
19518 tree expanded_types;
19519 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19520 the parameters in this function parameter pack. */
19525 {
19526 tree parm_type;
19527 tree attributes;
19530 /* Rename the parameter to include the index. */
19539 {
19542 }
19544 }
19545 }
19546 /* Merge additional specifiers from the CODE_PATTERN. */
19550 }
19552 {
19560 }
19561 else
19565 }
19567 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19568 substituted to get DECL. */
19570 tree
19572 {
19575 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19576 for the instantiation. This is not always the most general
19577 template. Consider, for example:
19579 template <class T>
19580 struct S { template <class U> void f();
19581 template <> void f<int>(); };
19583 and an instantiation of S<double>::f<int>. We want TD to be the
19584 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19586 more general template. */
19588 /* We must also deal with friend templates. Given:
19590 template <class T> struct S {
19591 template <class U> friend void f() {};
19592 };
19594 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19595 so far as the language is concerned, but that's still
19596 where we get the pattern for the instantiation from. On
19597 other hand, if the definition comes outside the class, say:
19599 template <class T> struct S {
19600 template <class U> friend void f();
19601 };
19602 template <class U> friend void f() {}
19604 we don't need to look any further. That's what the check for
19605 DECL_INITIAL is for. */
19609 {
19610 /* The present template, TD, should not be a definition. If it
19611 were a definition, we should be using it! Note that we
19612 cannot restructure the loop to just keep going until we find
19613 a template with a definition, since that might go too far if
19614 a specialization was declared, but not defined. */
19618 /* Fetch the more general template. */
19620 }
19623 }
19625 /* Returns true if we need to instantiate this template instance even if we
19626 know we aren't going to emit it.. */
19628 bool
19630 {
19631 /* We always instantiate inline functions so that we can inline them. An
19632 explicit instantiation declaration prohibits implicit instantiation of
19633 non-inline functions. With high levels of optimization, we would
19634 normally inline non-inline functions -- but we're not allowed to do
19635 that for "extern template" functions. Therefore, we check
19636 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19640 /* And we need to instantiate static data members so that
19641 their initializers are available in integral constant
19642 expressions. */
19645 }
19647 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19648 instantiate it now, modifying TREE_TYPE (fn). */
19650 void
19652 {
19666 {
19668 {
19683 }
19684 else
19686 }
19687 else
19688 {
19689 /* This is an implicitly declared function, so NOEX is a list of
19690 other functions to evaluate and merge. */
19691 tree elt;
19694 {
19696 tree subspec;
19700 }
19701 }
19706 {
19709 else
19711 }
19712 }
19714 /* Produce the definition of D, a _DECL generated from a template. If
19715 DEFER_OK is nonzero, then we don't have to actually do the
19716 instantiation now; we just have to do it sometime. Normally it is
19717 an error if this is an explicit instantiation but D is undefined.
19718 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19719 explicitly instantiated class template. */
19721 tree
19724 {
19726 tree gen_args;
19727 tree args;
19728 tree td;
19729 tree code_pattern;
19730 tree spec;
19731 tree gen_tmpl;
19737 tree fn_context;
19740 /* This function should only be used to instantiate templates for
19741 functions and static member variables. */
19744 /* Variables are never deferred; if instantiation is required, they
19745 are instantiated right away. That allows for better code in the
19746 case that an expression refers to the value of the variable --
19747 if the variable has a constant value the referring expression can
19748 take advantage of that fact. */
19753 /* Don't instantiate cloned functions. Instead, instantiate the
19754 functions they cloned. */
19762 /* D has already been instantiated or explicitly specialized, so
19763 there's nothing for us to do here.
19765 It might seem reasonable to check whether or not D is an explicit
19766 instantiation, and, if so, stop here. But when an explicit
19767 instantiation is deferred until the end of the compilation,
19768 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19769 the instantiation. */
19772 /* Check to see whether we know that this template will be
19773 instantiated in some other file, as with "extern template"
19774 extension. */
19777 /* In general, we do not instantiate such templates. */
19785 /* We should already have the extra args. */
19788 /* And what's in the hash table should match D. */
19792 /* This needs to happen before any tsubsting. */
19798 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19799 for the instantiation. */
19803 /* We should never be trying to instantiate a member of a class
19804 template or partial specialization. */
19809 /* In the case of a friend template whose definition is provided
19810 outside the class, we may have too many arguments. Drop the
19811 ones we don't need. The same is true for specializations. */
19812 args = get_innermost_template_args
19814 else
19820 else
19823 /* We may be in the middle of deferred access check. Disable it now. */
19826 /* Unless an explicit instantiation directive has already determined
19827 the linkage of D, remember that a definition is available for
19828 this entity. */
19838 /* If D is a member of an explicitly instantiated class template,
19839 and no definition is available, treat it like an implicit
19840 instantiation. */
19843 {
19844 /* Leave linkage flags alone on instantiations with anonymous
19845 visibility. */
19847 {
19850 }
19852 }
19857 /* Defer all other templates, unless we have been explicitly
19858 forbidden from doing so. */
19860 template. */
19861 ! pattern_defined
19862 /* If it's OK to postpone instantiation, do so. */
19863 || defer_ok
19864 /* If this is a static data member that will be defined
19865 elsewhere, we don't want to instantiate the entire data
19866 member, but we do want to instantiate the initializer so that
19867 we can substitute that elsewhere. */
19869 {
19870 /* The definition of the static data member is now required so
19871 we must substitute the initializer. */
19875 {
19876 tree ns;
19877 tree init;
19884 args,
19887 /* Make sure the initializer is still constant, in case of
19888 circular dependency (template/instantiate6.C). */
19889 const_init
19893 LOOKUP_ONLYCONVERTING);
19896 }
19898 /* We restore the source position here because it's used by
19899 add_pending_template. */
19905 /* [temp.explicit]
19907 The definition of a non-exported function template, a
19908 non-exported member function template, or a non-exported
19909 member function or static data member of a class template
19910 shall be present in every translation unit in which it is
19911 explicitly instantiated. */
19915 /* If we're in unevaluated context, we just wanted to get the
19916 constant value; this isn't an odr use, so don't queue
19917 a full instantiation. */
19920 /* ??? Historically, we have instantiated inline functions, even
19921 when marked as "extern template". */
19925 }
19926 /* Tell the repository that D is available in this translation unit
19927 -- and see if it is supposed to be instantiated here. */
19929 {
19930 /* In a PCH file, despite the fact that the repository hasn't
19931 requested instantiation in the PCH it is still possible that
19932 an instantiation will be required in a file that includes the
19933 PCH. */
19936 /* Instantiate inline functions so that the inliner can do its
19937 job, even though we'll not be emitting a copy of this
19938 function. */
19941 }
19947 else
19948 {
19953 }
19955 /* Mark D as instantiated so that recursive calls to
19956 instantiate_decl do not try to instantiate it again. */
19959 /* Regenerate the declaration in case the template has been modified
19960 by a subsequent redeclaration. */
19963 /* We already set the file and line above. Reset them now in case
19964 they changed as a result of calling regenerate_decl_from_template. */
19968 {
19969 tree init;
19972 /* Clear out DECL_RTL; whatever was there before may not be right
19973 since we've reset the type of the declaration. */
19977 /* The initializer is placed in DECL_INITIAL by
19978 regenerate_decl_from_template so we don't need to
19979 push/pop_access_scope again here. Pull it out so that
19980 cp_finish_decl can process it. */
19985 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
19986 initializer. That function will defer actual emission until
19987 we have a chance to determine linkage. */
19990 /* Enter the scope of D so that access-checking works correctly. */
19995 }
19999 {
20001 tree subst_decl;
20002 tree tmpl_parm;
20003 tree spec_parm;
20006 /* Save away the current list, in case we are instantiating one
20007 template from within the body of another. */
20010 /* Set up the list of local specializations. */
20013 /* Set up context. */
20017 else
20020 /* Some typedefs referenced from within the template code need to be
20021 access checked at template instantiation time, i.e now. These
20022 types were added to the template at parsing time. Let's get those
20023 and perform the access checks then. */
20025 gen_args);
20027 /* Create substitution entries for the parameters. */
20032 {
20036 }
20038 {
20040 {
20043 }
20044 else
20045 {
20046 /* Register the (value) argument pack as a specialization of
20047 TMPL_PARM, then move on. */
20050 }
20051 }
20054 /* Substitute into the body of the function. */
20058 else
20059 {
20064 /* Set the current input_location to the end of the function
20065 so that finish_function knows where we are. */
20066 input_location
20068 }
20070 /* We don't need the local specializations any more. */
20074 /* Finish the function. */
20078 else
20079 {
20082 }
20086 }
20088 /* We're not deferring instantiation any more. */
20096 out:
20106 }
20108 /* Run through the list of templates that we wish we could
20109 instantiate, and instantiate any we can. RETRIES is the
20110 number of times we retry pending template instantiation. */
20112 void
20114 {
20118 /* Instantiating templates may trigger vtable generation. This in turn
20119 may require further template instantiations. We place a limit here
20120 to avoid infinite loop. */
20122 {
20126 " instantiating %q+D, possibly from virtual table generation"
20130 /* Pretend that we defined it. */
20133 }
20135 do
20136 {
20141 {
20146 {
20147 tree fn;
20150 {
20154 fn;
20162 }
20165 }
20166 else
20167 {
20170 {
20171 instantiation
20177 }
20181 }
20184 /* If INSTANTIATION has been instantiated, then we don't
20185 need to consider it again in the future. */
20187 else
20188 {
20191 }
20194 }
20196 }
20200 }
20202 /* Substitute ARGVEC into T, which is a list of initializers for
20203 either base class or a non-static data member. The TREE_PURPOSEs
20204 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20205 instantiate_decl. */
20207 static tree
20209 {
20213 {
20214 tree decl;
20215 tree init;
20221 {
20222 tree expr;
20223 tree arg;
20225 /* Expand the base class expansion type into separate base
20226 classes. */
20228 tf_warning_or_error,
20229 NULL_TREE);
20233 /* We'll be building separate TREE_LISTs of arguments for
20234 each base. */
20240 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20241 expand each argument in the TREE_VALUE of t. */
20248 /* VOID_TYPE_NODE is used to indicate
20249 value-initialization. */
20250 {
20253 }
20254 else
20255 {
20256 /* Substitute parameter packs into each argument in the
20257 TREE_LIST. */
20260 {
20261 tree expanded_exprs;
20263 /* Expand the argument. */
20265 expanded_exprs
20267 tf_warning_or_error,
20268 NULL_TREE);
20272 /* Prepend each of the expanded expressions to the
20273 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20275 {
20280 }
20281 }
20284 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20285 since we built them backwards. */
20287 {
20290 }
20291 }
20292 }
20295 {
20297 {
20301 }
20302 else
20303 {
20304 tree tmp;
20319 /* If we had an initializer but it instantiated to nothing,
20320 value-initialize the object. This will only occur when
20321 the initializer was a pack expansion where the parameter
20322 packs used in that expansion were of length zero. */
20325 }
20328 {
20332 }
20333 }
20334 }
20336 }
20338 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20340 static void
20342 {
20347 else
20349 }
20351 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20352 is the instantiation (which should have been created with
20353 start_enum) and ARGS are the template arguments to use. */
20355 static void
20357 {
20358 tree e;
20364 {
20365 tree value;
20366 tree decl;
20369 /* Note that in a template enum, the TREE_VALUE is the
20370 CONST_DECL, not the corresponding INTEGER_CST. */
20375 /* Give this enumeration constant the correct access. */
20378 /* Actually build the enumerator itself. */
20379 build_enumerator
20381 }
20391 }
20393 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20394 its type -- but without substituting the innermost set of template
20395 arguments. So, innermost set of template parameters will appear in
20396 the type. */
20398 tree
20400 {
20401 tree fn_type;
20402 tree tmpl;
20403 tree targs;
20404 tree tparms;
20412 /* There should be as many levels of arguments as there are levels
20413 of parameters. */
20419 /* No substitution is necessary. */
20420 ;
20421 else
20422 {
20424 tree partial_args;
20426 /* Replace the innermost level of the TARGS with NULL_TREEs to
20427 let tsubst know not to substitute for those parameters. */
20436 /* Make sure that we can see identifiers, and compute access
20437 correctly. */
20441 /* Now, do the (partial) substitution to figure out the
20442 appropriate function type. */
20446 /* Substitute into the template parameters to obtain the real
20447 innermost set of parameters. This step is important if the
20448 innermost set of template parameters contains value
20449 parameters whose types depend on outer template parameters. */
20454 }
20457 }
20459 /* Return truthvalue if we're processing a template different from
20460 the last one involved in diagnostics. */
20461 int
20463 {
20465 }
20467 /* Remember current template involved in diagnostics. */
20468 void
20470 {
20472 }
20476 {
20478 }
20480 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20481 type. Return zero for ok, nonzero for disallowed. Issue error and
20482 warning messages under control of COMPLAIN. */
20484 static int
20486 {
20503 {
20506 else
20508 type);
20509 }
20511 }
20513 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20514 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20516 static bool
20518 {
20519 tree scope;
20521 /* [temp.dep.type]
20523 A type is dependent if it is:
20525 -- a template parameter. Template template parameters are types
20526 for us (since TYPE_P holds true for them) so we handle
20527 them here. */
20531 /* -- a qualified-id with a nested-name-specifier which contains a
20532 class-name that names a dependent type or whose unqualified-id
20533 names a dependent type. */
20536 /* -- a cv-qualified type where the cv-unqualified type is
20537 dependent. */
20539 /* -- a compound type constructed from any dependent type. */
20549 {
20550 tree arg_type;
20555 arg_type;
20560 }
20561 /* -- an array type constructed from any dependent type or whose
20562 size is specified by a constant expression that is
20563 value-dependent.
20565 We checked for type- and value-dependence of the bounds in
20566 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20568 {
20573 }
20575 /* -- a template-id in which either the template name is a template
20576 parameter ... */
20579 /* ... or any of the template arguments is a dependent type or
20580 an expression that is type-dependent or value-dependent. */
20582 && (any_dependent_template_arguments_p
20586 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20587 dependent; if the argument of the `typeof' expression is not
20588 type-dependent, then it should already been have resolved. */
20594 /* A template argument pack is dependent if any of its packed
20595 arguments are. */
20597 {
20603 }
20605 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20606 be template parameters. */
20610 /* The standard does not specifically mention types that are local
20611 to template functions or local classes, but they should be
20612 considered dependent too. For example:
20614 template <int I> void f() {
20615 enum E { a = I };
20616 S<sizeof (E)> s;
20617 }
20619 The size of `E' cannot be known until the value of `I' has been
20620 determined. Therefore, `E' must be considered dependent. */
20624 /* Don't use type_dependent_expression_p here, as it can lead
20625 to infinite recursion trying to determine whether a lambda
20626 nested in a lambda is dependent (c++/47687). */
20630 && (any_dependent_template_arguments_p
20634 /* Other types are non-dependent. */
20636 }
20638 /* Returns TRUE if TYPE is dependent, in the sense of
20639 [temp.dep.type]. Note that a NULL type is considered dependent. */
20641 bool
20643 {
20644 /* If there are no template parameters in scope, then there can't be
20645 any dependent types. */
20647 {
20648 /* If we are not processing a template, then nobody should be
20649 providing us with a dependent type. */
20653 }
20655 /* If the type is NULL, we have not computed a type for the entity
20656 in question; in that case, the type is dependent. */
20660 /* Erroneous types can be considered non-dependent. */
20664 /* If we have not already computed the appropriate value for TYPE,
20665 do so now. */
20667 {
20670 }
20673 }
20675 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20676 lookup. In other words, a dependent type that is not the current
20677 instantiation. */
20679 bool
20681 {
20684 }
20686 /* T is a SCOPE_REF; return whether we need to consider it
20687 instantiation-dependent so that we can check access at instantiation
20688 time even though we know which member it resolves to. */
20690 static bool
20692 {
20698 else
20700 }
20702 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20703 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20704 expression. */
20706 /* Note that this predicate is not appropriate for general expressions;
20707 only constant expressions (that satisfy potential_constant_expression)
20708 can be tested for value dependence. */
20710 bool
20712 {
20716 /* A name declared with a dependent type. */
20721 {
20723 /* A name that has not been looked up -- must be dependent. */
20727 /* A non-type template parm. */
20731 /* A non-type template parm. */
20737 /* A constant with literal type and is initialized
20738 with an expression that is value-dependent.
20740 Note that a non-dependent parenthesized initializer will have
20741 already been replaced with its constant value, so if we see
20742 a TREE_LIST it must be dependent. */
20755 /* These expressions are value-dependent if the type to which
20756 the cast occurs is dependent or the expression being casted
20757 is value-dependent. */
20758 {
20764 /* A functional cast has a list of operands. */
20767 {
20768 /* If there are no operands, it must be an expression such
20769 as "int()". This should not happen for aggregate types
20770 because it would form non-constant expressions. */
20775 }
20781 }
20786 /* FALLTHRU */
20789 /* A `sizeof' expression is value-dependent if the operand is
20790 type-dependent or is a pack expansion. */
20799 /* An 'encode' expression is value-dependent if the operand is
20800 type-dependent. */
20809 /* All instantiation-dependent expressions should also be considered
20810 value-dependent. */
20818 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20819 is value-dependent. */
20820 {
20829 }
20832 {
20836 }
20847 {
20851 }
20854 {
20861 {
20863 /* In a call to a constexpr member function, look through the
20864 implicit ADDR_EXPR on the object argument so that it doesn't
20865 cause the call to be considered value-dependent. We also
20866 look through it in potential_constant_expression. */
20873 }
20875 }
20878 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20879 type-dependent. */
20883 {
20885 tree val;
20890 }
20893 /* Treat a GNU statement expression as dependent to avoid crashing
20894 under fold_non_dependent_expr; it can't be constant. */
20898 /* A constant expression is value-dependent if any subexpression is
20899 value-dependent. */
20901 {
20908 {
20912 {
20915 /* In some cases, some of the operands may be missing.l
20916 (For example, in the case of PREDECREMENT_EXPR, the
20917 amount to increment by may be missing.) That doesn't
20918 make the expression dependent. */
20921 }
20922 }
20926 }
20928 }
20930 /* The expression is not value-dependent. */
20932 }
20934 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
20935 [temp.dep.expr]. Note that an expression with no type is
20936 considered dependent. Other parts of the compiler arrange for an
20937 expression with type-dependent subexpressions to have no type, so
20938 this function doesn't have to be fully recursive. */
20940 bool
20942 {
20949 /* An unresolved name is always dependent. */
20955 /* Some expression forms are never type-dependent. */
20968 /* The types of these expressions depends only on the type to which
20969 the cast occurs. */
20978 /* The types of these expressions depends only on the type created
20979 by the expression. */
20982 {
20983 /* For NEW_EXPR tree nodes created inside a template, either
20984 the object type itself or a TREE_LIST may appear as the
20985 operand 1. */
20988 /* This is an array type. We need to check array dimensions
20989 as well. */
20991 || value_dependent_expression_p
20993 else
20995 }
20998 {
21002 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21003 contains an identifier associated by name lookup with one or more
21004 declarations declared with a dependent type, or...a
21005 nested-name-specifier or qualified-id that names a member of an
21006 unknown specialization. */
21009 }
21014 && (any_dependent_template_arguments_p
21026 {
21027 tree elt;
21031 {
21034 }
21036 }
21038 /* A static data member of the current instantiation with incomplete
21039 array type is type-dependent, as the definition and specializations
21040 can have different bounds. */
21047 /* An array of unknown bound depending on a variadic parameter, eg:
21049 template<typename... Args>
21050 void foo (Args... args)
21051 {
21052 int arr[] = { args... };
21053 }
21055 template<int... vals>
21056 void bar ()
21057 {
21058 int arr[] = { vals... };
21059 }
21061 If the array has no length and has an initializer, it must be that
21062 we couldn't determine its length in cp_complete_array_type because
21063 it is dependent. */
21071 {
21076 {
21082 }
21083 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21087 /* Always dependent, on the number of arguments if nothing else. */
21095 {
21100 }
21105 {
21109 }
21111 }
21116 }
21118 /* walk_tree callback function for instantiation_dependent_expression_p,
21119 below. Returns non-zero if a dependent subexpression is found. */
21121 static tree
21124 {
21126 {
21127 /* We don't have to worry about decltype currently because decltype
21128 of an instantiation-dependent expr is a dependent type. This
21129 might change depending on the resolution of DR 1172. */
21132 }
21135 {
21136 /* Don't treat an argument list as dependent just because it has no
21137 TREE_TYPE. */
21144 /* A constant with a dependent initializer is dependent. */
21152 /* Handle expressions with type operands. */
21157 {
21162 {
21165 else
21166 {
21169 }
21170 }
21172 }
21175 {
21183 }
21187 /* In a template, finish_class_member_access_expr creates a
21188 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21189 type-dependent, so that we can check access control at
21190 instantiation time (PR 42277). See also Core issue 1273. */
21197 else
21200 /* Treat statement-expressions as dependent. */
21206 }
21210 else
21212 }
21214 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21215 sense defined by the ABI:
21217 "An expression is instantiation-dependent if it is type-dependent
21218 or value-dependent, or it has a subexpression that is type-dependent
21219 or value-dependent." */
21221 bool
21223 {
21224 tree result;
21235 }
21237 /* Like type_dependent_expression_p, but it also works while not processing
21238 a template definition, i.e. during substitution or mangling. */
21240 bool
21242 {
21248 }
21250 /* Returns TRUE if ARGS contains a type-dependent expression. */
21252 bool
21254 {
21256 tree arg;
21259 {
21262 }
21264 }
21266 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21267 expressions) contains any type-dependent expressions. */
21269 bool
21271 {
21277 }
21279 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21280 expressions) contains any value-dependent expressions. */
21282 bool
21284 {
21290 }
21292 /* Returns TRUE if the ARG (a template argument) is dependent. */
21294 bool
21296 {
21300 /* Assume a template argument that was wrongly written by the user
21301 is dependent. This is consistent with what
21302 any_dependent_template_arguments_p [that calls this function]
21303 does. */
21314 {
21318 {
21321 }
21324 }
21327 else
21330 }
21332 /* Returns true if ARGS (a collection of template arguments) contains
21333 any types that require structural equality testing. */
21335 bool
21337 {
21347 {
21350 {
21356 {
21357 /* Look inside the argument pack. */
21360 }
21363 {
21376 }
21377 }
21378 }
21381 }
21383 /* Returns true if ARGS (a collection of template arguments) contains
21384 any dependent arguments. */
21386 bool
21388 {
21398 {
21403 }
21406 }
21408 /* Returns TRUE if the template TMPL is dependent. */
21410 bool
21412 {
21414 {
21416 {
21420 }
21422 }
21424 /* Template template parameters are dependent. */
21428 /* So are names that have not been looked up. */
21431 /* So are member templates of dependent classes. */
21435 }
21437 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21439 bool
21441 {
21444 }
21446 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21447 is dependent. */
21449 bool
21451 {
21458 {
21479 {
21483 }
21487 {
21491 {
21496 }
21497 }
21498 }
21501 }
21503 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21504 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21505 no such TYPE can be found. Note that this function peers inside
21506 uninstantiated templates and therefore should be used only in
21507 extremely limited situations. ONLY_CURRENT_P restricts this
21508 peering to the currently open classes hierarchy (which is required
21509 when comparing types). */
21511 tree
21513 {
21514 tree scope;
21515 tree name;
21516 tree decl;
21518 tree pushed_scope;
21519 tree result;
21524 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21525 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21526 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21527 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21528 identifier of the TYPENAME_TYPE anymore.
21529 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21530 TYPENAME_TYPE instead, we avoid messing up with a possible
21531 typedef variant case. */
21534 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21535 it first before we can figure out what NAME refers to. */
21537 {
21539 /* Given a class template A with a dependent base with nested type C,
21540 typedef typename A::C::C C will land us here, as trying to resolve
21541 the initial A::C leads to the local C typedef, which leads back to
21542 A::C::C. So we break the recursion now. */
21544 else
21546 }
21547 /* If we don't know what SCOPE refers to, then we cannot resolve the
21548 TYPENAME_TYPE. */
21551 /* If the SCOPE is a template type parameter, we have no way of
21552 resolving the name. */
21555 /* If the SCOPE is not the current instantiation, there's no reason
21556 to look inside it. */
21559 /* If this is a typedef, we don't want to look inside (c++/11987). */
21562 /* If SCOPE isn't the template itself, it will not have a valid
21563 TYPE_FIELDS list. */
21565 /* scope is either the template itself or a compatible instantiation
21566 like X<T>, so look up the name in the original template. */
21568 else
21569 /* scope is a partial instantiation, so we can't do the lookup or we
21570 will lose the template arguments. */
21572 /* Enter the SCOPE so that name lookup will be resolved as if we
21573 were in the class definition. In particular, SCOPE will no
21574 longer be considered a dependent type. */
21576 /* Look up the declaration. */
21578 tf_warning_or_error);
21582 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21583 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21588 {
21592 }
21595 {
21596 tree tmpl;
21597 tree args;
21598 /* Obtain the template and the arguments. */
21601 /* Instantiate the template. */
21607 }
21609 /* Leave the SCOPE. */
21613 /* If we failed to resolve it, return the original typename. */
21617 /* If lookup found a typename type, resolve that too. */
21619 {
21620 /* Ill-formed programs can cause infinite recursion here, so we
21621 must catch that. */
21625 }
21627 /* Qualify the resulting type. */
21633 }
21635 /* EXPR is an expression which is not type-dependent. Return a proxy
21636 for EXPR that can be used to compute the types of larger
21637 expressions containing EXPR. */
21639 tree
21641 {
21642 tree inner_expr;
21644 #ifdef ENABLE_CHECKING
21645 /* Try to get a constant value for all non-dependent expressions in
21646 order to expose bugs in *_dependent_expression_p and constexpr. */
21649 #endif
21651 /* Preserve OVERLOADs; the functions must be available to resolve
21652 types. */
21663 /* There is no need to return a proxy for a variable. */
21666 /* Preserve string constants; conversions from string constants to
21667 "char *" are allowed, even though normally a "const char *"
21668 cannot be used to initialize a "char *". */
21671 /* Preserve arithmetic constants, as an optimization -- there is no
21672 reason to create a new node. */
21675 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21676 There is at least one place where we want to know that a
21677 particular expression is a throw-expression: when checking a ?:
21678 expression, there are special rules if the second or third
21679 argument is a throw-expression. */
21683 /* Don't wrap an initializer list, we need to be able to look inside. */
21687 /* Don't wrap a dummy object, we need to be able to test for it. */
21706 /* If the type is unknown, it can't really be non-dependent */
21709 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21711 }
21713 /* ARGS is a vector of expressions as arguments to a function call.
21714 Replace the arguments with equivalent non-dependent expressions.
21715 This modifies ARGS in place. */
21717 void
21719 {
21721 tree arg;
21724 {
21728 }
21729 }
21731 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21732 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21733 parms. */
21735 static tree
21737 {
21750 }
21752 tree
21754 {
21756 }
21758 tree
21760 {
21762 }
21764 /* Given type ARG, return std::initializer_list<ARG>. */
21766 static tree
21768 {
21769 tree std_init_list = namespace_binding
21771 tree argvec;
21773 {
21777 }
21782 }
21784 /* Replace auto in TYPE with std::initializer_list<auto>. */
21786 static tree
21788 {
21795 }
21797 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21798 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21800 tree
21802 {
21803 tree targs;
21809 /* Defining a subset of type-dependent expressions that we can deduce
21810 from ahead of time isn't worth the trouble. */
21813 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21814 with either a new invented type template parameter U or, if the
21815 initializer is a braced-init-list (8.5.4), with
21816 std::initializer_list<U>. */
21824 {
21829 {
21832 }
21833 }
21834 else
21835 {
21846 {
21848 /* Try again at instantiation time. */
21851 /* If type is error_mark_node a diagnostic must have been
21852 emitted by now. Also, having a mention to '<type error>'
21853 in the diagnostic is not really useful to the user. */
21854 {
21858 else
21860 }
21862 }
21863 }
21865 /* If the list of declarators contains more than one declarator, the type
21866 of each declared variable is determined as described above. If the
21867 type deduced for the template parameter U is not the same in each
21868 deduction, the program is ill-formed. */
21871 {
21877 else
21881 }
21887 }
21889 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
21890 result. */
21892 tree
21894 {
21895 tree argvec;
21902 /* For a late-specified return type in a template type-parameter, we
21903 need to add a dummy argument level for its parmlist. */
21904 argvec = add_to_template_args
21909 }
21911 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
21912 'decltype(auto)'. */
21914 bool
21916 {
21921 else
21923 }
21925 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
21926 a use of `auto'. Returns NULL_TREE otherwise. */
21928 tree
21930 {
21932 }
21934 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
21935 'decltype(auto)' or a concept. */
21937 bool
21939 {
21941 }
21943 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
21944 a concept identifier) iff TYPE contains a use of a generic type. Returns
21945 NULL_TREE otherwise. */
21947 tree
21949 {
21951 }
21954 /* For a given template T, return the vector of typedefs referenced
21955 in T for which access check is needed at T instantiation time.
21956 T is either a FUNCTION_DECL or a RECORD_TYPE.
21957 Those typedefs were added to T by the function
21958 append_type_to_template_for_access_check. */
21962 {
21963 tree ti;
21974 {
21979 }
21982 }
21984 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
21985 tied to T. That list of typedefs will be access checked at
21986 T instantiation time.
21987 T is either a FUNCTION_DECL or a RECORD_TYPE.
21988 TYPE_DECL is a TYPE_DECL node representing a typedef.
21989 SCOPE is the scope through which TYPE_DECL is accessed.
21990 LOCATION is the location of the usage point of TYPE_DECL.
21992 This function is a subroutine of
21993 append_type_to_template_for_access_check. */
21995 static void
21997 tree type_decl,
21998 tree scope,
21999 location_t location)
22000 {
22001 qualified_typedef_usage_t typedef_usage;
22002 tree ti;
22009 && type_decl
22023 }
22025 /* Append TYPE_DECL to the template TEMPL.
22026 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22027 At TEMPL instanciation time, TYPE_DECL will be checked to see
22028 if it can be accessed through SCOPE.
22029 LOCATION is the location of the usage point of TYPE_DECL.
22031 e.g. consider the following code snippet:
22033 class C
22034 {
22035 typedef int myint;
22036 };
22038 template<class U> struct S
22039 {
22040 C::myint mi; // <-- usage point of the typedef C::myint
22041 };
22043 S<char> s;
22045 At S<char> instantiation time, we need to check the access of C::myint
22046 In other words, we need to check the access of the myint typedef through
22047 the C scope. For that purpose, this function will add the myint typedef
22048 and the scope C through which its being accessed to a list of typedefs
22049 tied to the template S. That list will be walked at template instantiation
22050 time and access check performed on each typedefs it contains.
22051 Note that this particular code snippet should yield an error because
22052 myint is private to C. */
22054 void
22056 tree type_decl,
22057 tree scope,
22058 location_t location)
22059 {
22065 /* Make sure we don't append the type to the template twice. */
22072 }
22074 /* Convert the generic type parameters in PARM that match the types given in the
22075 range [START_IDX, END_IDX) from the current_template_parms into generic type
22076 packs. */
22078 tree
22080 {
22091 {
22092 /* Create a distinct parameter pack type from the current parm and add it
22093 to the replacement args to tsubst below into the generic function
22094 parameter. */
22109 }
22115 /* If there are more levels then build up the replacement with the outer
22116 template parms. */
22120 replacement);
22123 }
22126 /* Set up the hash tables for template instantiations. */
22128 void
22130 {
22132 hash_specialization,
22133 eq_specializations,
22134 ggc_free);
22136 hash_specialization,
22137 eq_specializations,
22138 ggc_free);
22139 }
22141 /* Print stats about the template hash tables for -fstats. */
22143 void
22145 {
22154 }