| blob | 2f2066e297cf5aeccbd94022eb1cca6a3177e817 |
1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2019 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". */
46 /* The type of functions taking a tree, and some additional data, and
47 returning an int. */
50 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
51 instantiations have been deferred, either because their definitions
52 were not yet available, or because we were putting off doing the work. */
54 {
57 };
72 /* Live only within one (recursive) call to tsubst_expr. We use
73 this to pass the statement expression node from the STMT_EXPR
74 to the EXPR_STMT that is its result. */
77 // -------------------------------------------------------------------------- //
78 // Local Specialization Stack
79 //
80 // Implementation of the RAII helper for creating new local
81 // specializations.
84 {
87 else
89 }
92 {
95 }
97 /* True if we've recursed into fn_type_unification too many times. */
101 {
102 tree tmpl;
103 tree args;
104 tree spec;
105 };
108 {
111 };
117 /* Contains canonical template parameter types. The vector is indexed by
118 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
119 TREE_LIST, whose TREE_VALUEs contain the canonical template
120 parameters of various types and levels. */
123 #define UNIFY_ALLOW_NONE 0
124 #define UNIFY_ALLOW_MORE_CV_QUAL 1
125 #define UNIFY_ALLOW_LESS_CV_QUAL 2
126 #define UNIFY_ALLOW_DERIVED 4
127 #define UNIFY_ALLOW_INTEGER 8
128 #define UNIFY_ALLOW_OUTER_LEVEL 16
129 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
130 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
133 tbr_incomplete_type,
134 tbr_ambiguous_baseclass,
135 tbr_success
136 };
161 tree);
218 location_t);
230 /* Make the current scope suitable for access checking when we are
231 processing T. T can be FUNCTION_DECL for instantiated function
232 template, VAR_DECL for static member variable, or TYPE_DECL for
233 alias template (needed by instantiate_decl). */
235 static void
237 {
245 else
249 {
250 saved_access_scope = tree_cons
253 }
254 }
256 /* Restore the scope set up by push_access_scope. T is the node we
257 are processing. */
259 static void
261 {
263 {
266 }
270 else
272 }
274 /* Do any processing required when DECL (a member template
275 declaration) is finished. Returns the TEMPLATE_DECL corresponding
276 to DECL, unless it is a specialization, in which case the DECL
277 itself is returned. */
279 tree
281 {
288 {
289 tree type;
297 {
301 }
303 }
307 {
309 {
312 }
313 else
315 }
316 else
320 }
322 /* Create a template info node. */
324 tree
326 {
331 }
333 /* Return the template info node corresponding to T, whatever T is. */
335 tree
337 {
359 }
361 /* Returns the template nesting level of the indicated class TYPE.
363 For example, in:
364 template <class T>
365 struct A
366 {
367 template <class U>
368 struct B {};
369 };
371 A<T>::B<U> has depth two, while A<T> has depth one.
372 Both A<T>::B<int> and A<int>::B<U> have depth one, if
373 they are instantiations, not specializations.
375 This function is guaranteed to return 0 if passed NULL_TREE so
376 that, for example, `template_class_depth (current_class_type)' is
377 always safe. */
379 int
381 {
385 {
396 else
398 }
401 }
403 /* Return TRUE if NODE instantiates a template that has arguments of
404 its own, be it directly a primary template or indirectly through a
405 partial specializations. */
406 static bool
408 {
420 /* So now we know we have a specialization, but it could be a full
421 or a partial specialization. To tell which, compare the depth of
422 its template arguments with those of its context. */
431 }
433 /* Subroutine of maybe_begin_member_template_processing.
434 Returns true if processing DECL needs us to push template parms. */
436 static bool
438 {
444 }
446 /* Subroutine of maybe_begin_member_template_processing.
447 Push the template parms in PARMS, starting from LEVELS steps into the
448 chain, and ending at the beginning, since template parms are listed
449 innermost first. */
451 static void
453 {
461 current_template_parms
467 NULL);
469 {
478 {
485 /* Push the CONST_DECL. */
491 }
492 }
493 }
495 /* Restore the template parameter context for a member template, a
496 friend template defined in a class definition, or a non-template
497 member of template class. */
499 void
501 {
502 tree parms;
507 {
510 /* Disregard full specializations (c++/60999). */
513 }
516 {
521 {
524 }
527 }
529 /* Remember how many levels of template parameters we pushed so that
530 we can pop them later. */
532 }
534 /* Undo the effects of maybe_begin_member_template_processing. */
536 void
538 {
547 {
551 }
552 }
554 /* Return a new template argument vector which contains all of ARGS,
555 but has as its innermost set of arguments the EXTRA_ARGS. */
557 static tree
559 {
560 tree new_args;
578 }
580 /* Like add_to_template_args, but only the outermost ARGS are added to
581 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
582 (EXTRA_ARGS) levels are added. This function is used to combine
583 the template arguments from a partial instantiation with the
584 template arguments used to attain the full instantiation from the
585 partial instantiation. */
587 static tree
589 {
590 tree new_args;
592 /* If there are more levels of EXTRA_ARGS than there are ARGS,
593 something very fishy is going on. */
596 /* If *all* the new arguments will be the EXTRA_ARGS, just return
597 them. */
601 /* For the moment, we make ARGS look like it contains fewer levels. */
606 /* Now, we restore ARGS to its full dimensions. */
610 }
612 /* Return the N levels of innermost template arguments from the ARGS. */
614 tree
616 {
617 tree new_args;
623 /* If N is 1, just return the innermost set of template arguments. */
627 /* If we're not removing anything, just return the arguments we were
628 given. */
634 /* Make a new set of arguments, not containing the outer arguments. */
641 }
643 /* The inverse of get_innermost_template_args: Return all but the innermost
644 EXTRA_LEVELS levels of template arguments from the ARGS. */
646 static tree
648 {
649 tree new_args;
655 /* If N is 1, just return the outermost set of template arguments. */
659 /* If we're not removing anything, just return the arguments we were
660 given. */
665 /* Make a new set of arguments, not containing the inner arguments. */
672 }
674 /* We've got a template header coming up; push to a new level for storing
675 the parms. */
677 void
679 {
680 /* We use a non-tag-transparent scope here, which causes pushtag to
681 put tags in this scope, rather than in the enclosing class or
682 namespace scope. This is the right thing, since we want
683 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
684 global template class, push_template_decl handles putting the
685 TEMPLATE_DECL into top-level scope. For a nested template class,
686 e.g.:
688 template <class T> struct S1 {
689 template <class T> struct S2 {};
690 };
692 pushtag contains special code to insert the TEMPLATE_DECL for S2
693 at the right scope. */
699 /* Add a dummy parameter level while we process the parameter list. */
700 current_template_parms
703 current_template_parms);
704 }
706 /* This routine is called when a specialization is declared. If it is
707 invalid to declare a specialization here, an error is reported and
708 false is returned, otherwise this routine will return true. */
710 static bool
712 {
715 /* [temp.expl.spec]
717 An explicit specialization shall be declared in the namespace of
718 which the template is a member, or, for member templates, in the
719 namespace of which the enclosing class or enclosing class
720 template is a member. An explicit specialization of a member
721 function, member class or static data member of a class template
722 shall be declared in the namespace of which the class template
723 is a member. */
725 {
728 }
730 /* [temp.expl.spec]
732 In an explicit specialization declaration for a member of a class
733 template or a member template that appears in namespace scope,
734 the member template and some of its enclosing class templates may
735 remain unspecialized, except that the declaration shall not
736 explicitly specialize a class member template if its enclosing
737 class templates are not explicitly specialized as well. */
739 {
742 }
745 }
747 /* We've just seen template <>. */
749 bool
751 {
755 }
757 /* Called at then end of processing a declaration preceded by
758 template<>. */
760 void
762 {
765 }
767 /* Any template <>'s that we have seen thus far are not referring to a
768 function specialization. */
770 void
772 {
775 }
777 /* We've just seen a template header. If SPECIALIZATION is nonzero,
778 it was of the form template <>. */
780 static void
782 {
784 template_header_count++;
785 }
787 /* We're beginning an explicit instantiation. */
789 void
791 {
794 }
797 void
799 {
802 }
804 /* An explicit specialization or partial specialization of TMPL is being
805 declared. Check that the namespace in which the specialization is
806 occurring is permissible. Returns false iff it is invalid to
807 specialize TMPL in the current namespace. */
809 static bool
811 {
814 /* [tmpl.expl.spec]
816 An explicit specialization shall be declared in a namespace enclosing the
817 specialized template. An explicit specialization whose declarator-id is
818 not qualified shall be declared in the nearest enclosing namespace of the
819 template, or, if the namespace is inline (7.3.1), any namespace from its
820 enclosing namespace set. */
823 {
826 }
829 /* Same or enclosing namespace. */
831 else
832 {
833 auto_diagnostic_group d;
839 }
840 }
842 /* SPEC is an explicit instantiation. Check that it is valid to
843 perform this explicit instantiation in the current namespace. */
845 static void
847 {
848 tree ns;
850 /* DR 275: An explicit instantiation shall appear in an enclosing
851 namespace of its template. */
857 }
859 // Returns the type of a template specialization only if that
860 // specialization needs to be defined. Otherwise (e.g., if the type has
861 // already been defined), the function returns NULL_TREE.
862 static tree
864 {
865 // An implicit instantiation of an incomplete type implies
866 // the definition of a new class template.
867 //
868 // template<typename T>
869 // struct S;
870 //
871 // template<typename T>
872 // struct S<T*>;
873 //
874 // Here, S<T*> is an implicit instantiation of S whose type
875 // is incomplete.
879 // It can also be the case that TYPE is a completed specialization.
880 // Continuing the previous example, suppose we also declare:
881 //
882 // template<typename T>
883 // requires Integral<T>
884 // struct S<T*>;
885 //
886 // Here, S<T*> refers to the specialization S<T*> defined
887 // above. However, we need to differentiate definitions because
888 // we intend to define a new partial specialization. In this case,
889 // we rely on the fact that the constraints are different for
890 // this declaration than that above.
891 //
892 // Note that we also get here for injected class names and
893 // late-parsed template definitions. We must ensure that we
894 // do not create new type declarations for those cases.
896 {
900 // If there are no template parameters, this cannot be a new
901 // partial template specializtion?
905 // The injected-class-name is not a new partial specialization.
909 // If the constraints are not the same as those of the primary
910 // then, we can probably create a new specialization.
914 {
918 }
920 // Also, if there's a pre-existing specialization with matching
921 // constraints, then this also isn't new.
924 {
932 }
934 // Create a new type node (and corresponding type decl)
935 // for the newly declared specialization.
940 /* We only need a separate type node for storing the definition of this
941 partial specialization; uses of S<T*> are unconstrained, so all are
942 equivalent. So keep TYPE_CANONICAL the same. */
945 // Build the corresponding type decl.
951 }
954 }
956 /* The TYPE is being declared. If it is a template type, that means it
957 is a partial specialization. Do appropriate error-checking. */
959 tree
961 {
962 tree context;
967 /* A lambda that appears in specialization context is not itself a
968 specialization. */
973 {
977 }
982 {
988 else
991 }
993 {
994 /* This is for ordinary explicit specialization and partial
995 specialization of a template class such as:
997 template <> class C<int>;
999 or:
1001 template <class T> class C<T*>;
1003 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
1006 {
1013 {
1018 }
1019 }
1025 /* Trying to define a specialization either without a template<> header
1026 or in an inappropriate place. We've already given an error, so just
1027 bail now so we don't actually define the specialization. */
1029 }
1035 {
1036 /* This is for an explicit specialization of member class
1037 template according to [temp.expl.spec/18]:
1039 template <> template <class U> class C<int>::D;
1041 The context `C<int>' must be an implicit instantiation.
1042 Otherwise this is just a member class template declared
1043 earlier like:
1045 template <> class C<int> { template <class U> class D; };
1046 template <> template <class U> class C<int>::D;
1048 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1049 while in the second case, `C<int>::D' is a primary template
1050 and `C<T>::D' may not exist. */
1054 {
1055 tree t;
1060 {
1065 }
1067 /* Check for invalid specialization after instantiation:
1069 template <> template <> class C<int>::D<int>;
1070 template <> template <class U> class C<int>::D; */
1074 {
1078 {
1079 /* We already have a full specialization of this partial
1080 instantiation, or a full specialization has been
1081 looked up but not instantiated. Reassign it to the
1082 new member specialization template. */
1083 spec_entry elt;
1096 spec_entry **slot
1101 }
1102 else
1103 /* But if we've had an implicit instantiation, that's a
1104 problem ([temp.expl.spec]/6). */
1107 }
1109 /* Mark TYPE as a specialization. And as a result, we only
1110 have one level of template argument for the innermost
1111 class template. */
1116 }
1117 }
1119 {
1120 /* Someday C++0x may allow for enum template specialization. */
1125 else
1126 {
1129 }
1130 }
1133 }
1135 /* Returns nonzero if we can optimize the retrieval of specializations
1136 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1137 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1141 {
1144 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1145 parameter. */
1147 /* The optimized lookup depends on the fact that the
1148 template arguments for the member function template apply
1149 purely to the containing class, which is not true if the
1150 containing class is an explicit or partial
1151 specialization. */
1155 /* It is possible to have a template that is not a member
1156 template and is not a member of a template class:
1158 template <typename T>
1159 struct S { friend A::f(); };
1161 Here, the friend function is a template, but the context does
1162 not have template information. The optimized lookup relies
1163 on having ARGS be the template arguments for both the class
1164 and the function template. */
1166 }
1168 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1169 gone through coerce_template_parms by now. */
1171 static void
1173 {
1175 {
1184 /* Allow typedefs on the type of a non-type argument, since a
1186 else
1188 }
1189 }
1191 static void
1193 {
1198 }
1200 /* Retrieve the specialization (in the sense of [temp.spec] - a
1201 specialization is either an instantiation or an explicit
1202 specialization) of TMPL for the given template ARGS. If there is
1203 no such specialization, return NULL_TREE. The ARGS are a vector of
1204 arguments, or a vector of vectors of arguments, in the case of
1205 templates with more than one level of parameters.
1207 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1208 then we search for a partial specialization matching ARGS. This
1209 parameter is ignored if TMPL is not a class template.
1211 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1212 result is a NONTYPE_ARGUMENT_PACK. */
1214 static tree
1216 {
1226 /* There should be as many levels of arguments as there are
1227 levels of parameters. */
1236 /* Lambda functions in templates aren't instantiated normally, but through
1237 tsubst_lambda_expr. */
1242 {
1243 /* The template arguments actually apply to the containing
1244 class. Find the class specialization with those
1245 arguments. */
1247 tree class_specialization
1252 /* Find the instance of TMPL. */
1255 {
1258 /* using-declarations can add base methods to the method vec,
1259 and we don't want those here. */
1262 }
1264 }
1265 else
1266 {
1268 spec_entry elt;
1277 else
1285 }
1288 }
1290 /* Like retrieve_specialization, but for local declarations. */
1292 tree
1294 {
1300 }
1302 /* Returns nonzero iff DECL is a specialization of TMPL. */
1304 int
1306 {
1307 tree t;
1310 {
1316 }
1317 else
1318 {
1327 }
1330 }
1332 /* Returns nonzero iff DECL is a specialization of friend declaration
1333 FRIEND_DECL according to [temp.friend]. */
1335 bool
1337 {
1344 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1345 of a template class, we want to check if DECL is a specialization
1346 if this. */
1350 {
1351 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1354 }
1359 /* There is nothing to do if this is not a template friend. */
1366 /* [temp.friend/6]
1367 A member of a class template may be declared to be a friend of a
1368 non-template class. In this case, the corresponding member of
1369 every specialization of the class template is a friend of the
1370 class granting friendship.
1372 For example, given a template friend declaration
1374 template <class T> friend void A<T>::f();
1376 the member function below is considered a friend
1378 template <> struct A<int> {
1379 void f();
1380 };
1382 For this type of template friend, TEMPLATE_DEPTH below will be
1383 nonzero. To determine if DECL is a friend of FRIEND, we first
1384 check if the enclosing class is a specialization of another. */
1391 {
1392 /* Next, we check the members themselves. In order to handle
1393 a few tricky cases, such as when FRIEND_DECL's are
1395 template <class T> friend void A<T>::g(T t);
1396 template <class T> template <T t> friend void A<T>::h();
1398 and DECL's are
1400 void A<int>::g(int);
1401 template <int> void A<int>::h();
1403 we need to figure out ARGS, the template arguments from
1404 the context of DECL. This is required for template substitution
1405 of `T' in the function parameter of `g' and template parameter
1406 of `h' in the above examples. Here ARGS corresponds to `int'. */
1413 {
1415 {
1418 else
1420 current_depth++;
1421 }
1423 }
1426 {
1428 tree friend_type;
1429 tree decl_type;
1430 tree friend_args_type;
1431 tree decl_args_type;
1433 /* Make sure that both DECL and FRIEND_DECL are templates or
1434 non-templates. */
1440 {
1441 /* If both are templates, check template parameter list. */
1442 tree friend_parms
1447 friend_parms))
1451 }
1452 else
1460 /* Check if return types match. */
1464 /* Check if function parameter types match, ignoring the
1465 `this' parameter. */
1474 }
1475 else
1476 {
1477 /* DECL is a TYPE_DECL */
1481 /* Make sure that both DECL and FRIEND_DECL are templates or
1482 non-templates. */
1483 is_template
1490 {
1491 tree friend_parms;
1492 /* If both are templates, check the name of the two
1493 TEMPLATE_DECL's first because is_friend didn't. */
1498 /* Now check template parameter list. */
1499 friend_parms
1502 return comp_template_parms
1504 friend_parms);
1505 }
1506 else
1509 }
1510 }
1512 }
1514 /* Register the specialization SPEC as a specialization of TMPL with
1515 the indicated ARGS. IS_FRIEND indicates whether the specialization
1516 is actually just a friend declaration. ATTRLIST is the list of
1517 attributes that the specialization is declared with or NULL when
1518 it isn't. Returns SPEC, or an equivalent prior declaration, if
1519 available.
1521 We also store instantiations of field packs in the hash table, even
1522 though they are not themselves templates, to make lookup easier. */
1524 static tree
1526 hashval_t hash)
1527 {
1528 tree fn;
1530 spec_entry elt;
1538 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1539 register it; we want the corresponding TEMPLATE_DECL instead.
1540 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1541 the more obvious `uses_template_parms (spec)' to avoid problems
1542 with default function arguments. In particular, given
1543 something like this:
1545 template <class T> void f(T t1, T t = T())
1547 the default argument expression is not substituted for in an
1548 instantiation unless and until it is actually needed. */
1552 /* We don't put these specializations in the hash table, but we might
1553 want to give an error about a mismatch. */
1555 else
1556 {
1564 slot =
1568 else
1570 }
1572 /* We can sometimes try to re-register a specialization that we've
1573 already got. In particular, regenerate_decl_from_template calls
1574 duplicate_decls which will update the specialization list. But,
1575 we'll still get called again here anyhow. It's more convenient
1576 to simply allow this than to try to prevent it. */
1580 {
1582 {
1585 {
1587 fn);
1589 }
1590 else
1591 {
1592 tree clone;
1593 /* This situation should occur only if the first
1594 specialization is an implicit instantiation, the
1595 second is an explicit specialization, and the
1596 implicit instantiation has not yet been used. That
1597 situation can occur if we have implicitly
1598 instantiated a member function and then specialized
1599 it later.
1601 We can also wind up here if a friend declaration that
1602 looked like an instantiation turns out to be a
1603 specialization:
1605 template <class T> void foo(T);
1606 class S { friend void foo<>(int) };
1607 template <> void foo(int);
1609 We transform the existing DECL in place so that any
1610 pointers to it become pointers to the updated
1611 declaration.
1613 If there was a definition for the template, but not
1614 for the specialization, we want this to look as if
1615 there were no definition, and vice versa. */
1618 /* The call to duplicate_decls will have applied
1619 [temp.expl.spec]:
1621 An explicit specialization of a function template
1622 is inline only if it is explicitly declared to be,
1623 and independently of whether its function template
1624 is.
1626 to the primary function; now copy the inline bits to
1627 the various clones. */
1629 {
1636 }
1640 }
1641 }
1643 {
1646 /* We've already complained in duplicate_decls. */
1650 /* Dup decl failed, but this is a new definition. Set the
1651 line number so any errors match this new
1652 definition. */
1656 }
1657 }
1661 /* A specialization must be declared in the same namespace as the
1662 template it is specializing. */
1668 {
1677 /* If TMPL is a forward declaration of a template function, keep a list
1678 of all specializations in case we need to reassign them to a friend
1679 template later in tsubst_friend_function.
1681 Also keep a list of all variable template instantiations so that
1682 process_partial_specialization can check whether a later partial
1683 specialization would have used it. */
1686 }
1689 }
1691 /* Returns true iff two spec_entry nodes are equivalent. */
1695 bool
1697 {
1704 /* tmpl could be a FIELD_DECL for a capture pack. */
1708 {
1709 /* Partial specializations of a variable template can be distinguished by
1710 constraints. */
1714 }
1718 }
1720 /* Returns a hash for a template TMPL and template arguments ARGS. */
1722 static hashval_t
1724 {
1727 }
1729 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1730 ignoring SPEC. */
1732 hashval_t
1734 {
1736 }
1738 /* Recursively calculate a hash value for a template argument ARG, for use
1739 in the hash tables of template specializations. */
1741 hashval_t
1743 {
1763 {
1771 {
1776 }
1798 {
1802 {
1805 }
1807 }
1811 {
1814 }
1825 val = iterative_hash_template_arg
1837 val);
1839 val);
1848 /* [temp.over.link] Two lambda-expressions are never considered
1849 equivalent.
1851 So just hash the closure type. */
1862 /* Now hash operands as usual. */
1866 {
1869 {
1873 }
1875 call_expr_arg_iterator ai;
1880 }
1884 }
1887 {
1890 {
1891 // We want an alias specialization that survived strip_typedefs
1892 // to hash differently from its TYPE_CANONICAL, to avoid hash
1893 // collisions that compare as different in template_args_equal.
1894 // These could be dependent specializations that strip_typedefs
1895 // left alone, or untouched specializations because
1896 // coerce_template_parms returns the unconverted template
1897 // arguments if it sees incomplete argument packs.
1900 }
1903 val);
1906 /* Otherwise just compare the types during lookup. */
1915 {
1920 }
1921 }
1924 }
1926 /* Unregister the specialization SPEC as a specialization of TMPL.
1927 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1928 if the SPEC was listed as a specialization of TMPL.
1930 Note that SPEC has been ggc_freed, so we can't look inside it. */
1932 bool
1934 {
1936 spec_entry elt;
1944 {
1949 }
1952 }
1954 /* Like register_specialization, but for local declarations. We are
1955 registering SPEC, an instantiation of TMPL. */
1957 void
1959 {
1962 }
1964 /* TYPE is a class type. Returns true if TYPE is an explicitly
1965 specialized class. */
1967 bool
1969 {
1973 }
1975 /* Print the list of functions at FNS, going through all the overloads
1976 for each element of the list. Alternatively, FNS cannot be a
1977 TREE_LIST, in which case it will be printed together with all the
1978 overloads.
1980 MORE and *STR should respectively be FALSE and NULL when the function
1981 is called from the outside. They are used internally on recursive
1982 calls. print_candidates manages the two parameters and leaves NULL
1983 in *STR when it ends. */
1985 static void
1987 {
1991 else
1993 {
1999 {
2002 else
2005 }
2007 }
2008 }
2010 /* Print the list of candidate FNS in an error message. FNS can also
2011 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
2013 void
2015 {
2019 }
2021 /* Get a (possibly) constrained template declaration for the
2022 purpose of ordering candidates. */
2023 static tree
2025 {
2031 }
2033 /* Among candidates having the same signature, return the
2034 most constrained or NULL_TREE if there is no best candidate.
2035 If the signatures of candidates vary (e.g., template
2036 specialization vs. member function), then there can be no
2037 most constrained.
2039 Note that we don't compare constraints on the functions
2040 themselves, but rather those of their templates. */
2041 static tree
2043 {
2044 // Try to find the best candidate in a first pass.
2047 {
2054 }
2056 // Verify that the champ is better than previous candidates.
2061 }
2064 }
2067 /* Returns the template (one of the functions given by TEMPLATE_ID)
2068 which can be specialized to match the indicated DECL with the
2069 explicit template args given in TEMPLATE_ID. The DECL may be
2070 NULL_TREE if none is available. In that case, the functions in
2071 TEMPLATE_ID are non-members.
2073 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2074 specialization of a member template.
2076 The TEMPLATE_COUNT is the number of references to qualifying
2077 template classes that appeared in the name of the function. See
2078 check_explicit_specialization for a more accurate description.
2080 TSK indicates what kind of template declaration (if any) is being
2081 declared. TSK_TEMPLATE indicates that the declaration given by
2082 DECL, though a FUNCTION_DECL, has template parameters, and is
2083 therefore a template function.
2085 The template args (those explicitly specified and those deduced)
2086 are output in a newly created vector *TARGS_OUT.
2088 If it is impossible to determine the result, an error message is
2089 issued. The error_mark_node is returned to indicate failure. */
2091 static tree
2093 tree decl,
2097 tmpl_spec_kind tsk)
2098 {
2099 tree fns;
2100 tree targs;
2101 tree explicit_targs;
2104 /* A TREE_LIST of templates of which DECL may be a specialization.
2105 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2106 corresponding TREE_PURPOSE is the set of template arguments that,
2107 when used to instantiate the template, would produce a function
2108 with the signature of DECL. */
2118 /* We shouldn't be specializing a member template of an
2119 unspecialized class template; we already gave an error in
2120 check_specialization_scope, now avoid crashing. */
2124 {
2127 }
2135 /* Check for baselinks. */
2140 {
2143 }
2145 {
2148 }
2150 /* Count the number of template headers specified for this
2151 specialization. */
2161 {
2164 tf_warning_or_error,
2168 }
2170 {
2174 {
2175 tree decl_arg_types;
2176 tree fn_arg_types;
2177 tree insttype;
2179 /* In case of explicit specialization, we need to check if
2180 the number of template headers appearing in the specialization
2181 is correct. This is usually done in check_explicit_specialization,
2182 but the check done there cannot be exhaustive when specializing
2183 member functions. Consider the following code:
2185 template <> void A<int>::f(int);
2186 template <> template <> void A<int>::f(int);
2188 Assuming that A<int> is not itself an explicit specialization
2189 already, the first line specializes "f" which is a non-template
2190 member function, whilst the second line specializes "f" which
2191 is a template member function. So both lines are syntactically
2192 correct, and check_explicit_specialization does not reject
2193 them.
2195 Here, we can do better, as we are matching the specialization
2196 against the declarations. We count the number of template
2197 headers, and we check if they match TEMPLATE_COUNT + 1
2198 (TEMPLATE_COUNT is the number of qualifying template classes,
2199 plus there must be another header for the member template
2200 itself).
2202 Notice that if header_count is zero, this is not a
2203 specialization but rather a template instantiation, so there
2204 is no check we can perform here. */
2208 /* Check that the number of template arguments at the
2209 innermost level for DECL is the same as for FN. */
2217 /* DECL might be a specialization of FN. */
2221 /* For a non-static member function, we need to make sure
2222 that the const qualification is the same. Since
2223 get_bindings does not try to merge the "this" parameter,
2224 we must do the comparison explicitly. */
2226 {
2231 /* And the ref-qualification. */
2235 }
2237 /* Skip the "this" parameter and, for constructors of
2238 classes with virtual bases, the VTT parameter. A
2239 full specialization of a constructor will have a VTT
2240 parameter, but a template never will. */
2241 decl_arg_types
2243 fn_arg_types
2246 /* Function templates cannot be specializations; there are
2247 no partial specializations of functions. Therefore, if
2248 the type of DECL does not match FN, there is no
2249 match.
2251 Note that it should never be the case that we have both
2252 candidates added here, and for regular member functions
2253 below. */
2255 {
2259 }
2261 /* See whether this function might be a specialization of this
2262 template. Suppress access control because we might be trying
2263 to make this specialization a friend, and we have already done
2264 access control for the declaration of the specialization. */
2270 /* We cannot deduce template arguments that when used to
2271 specialize TMPL will produce DECL. */
2275 /* We deduced something involving 'auto', which isn't a valid
2276 template argument. */
2279 /* Remove, from the set of candidates, all those functions
2280 whose constraints are not satisfied. */
2284 // Then, try to form the new function type.
2288 fn_arg_types
2293 /* Save this template, and the arguments deduced. */
2295 }
2297 /* FN is an ordinary member function, and we need a
2298 specialization of a member template. */
2299 ;
2301 /* We can get IDENTIFIER_NODEs here in certain erroneous
2302 cases. */
2303 ;
2305 /* This is just an ordinary non-member function. Nothing can
2306 be a specialization of that. */
2307 ;
2309 /* Cannot specialize functions that are created implicitly. */
2310 ;
2311 else
2312 {
2313 tree decl_arg_types;
2315 /* This is an ordinary member function. However, since
2316 we're here, we can assume its enclosing class is a
2317 template class. For example,
2319 template <typename T> struct S { void f(); };
2320 template <> void S<int>::f() {}
2322 Here, S<int>::f is a non-template, but S<int> is a
2323 template class. If FN has the same type as DECL, we
2324 might be in business. */
2327 /* Its enclosing class is an explicit specialization
2328 of a template class. This is not a candidate. */
2333 /* The return types differ. */
2336 /* Adjust the type of DECL in case FN is a static member. */
2343 decl_arg_types))
2351 // If the deduced arguments do not satisfy the constraints,
2352 // this is not a candidate.
2356 // Add the candidate.
2358 }
2359 }
2362 {
2363 /* We have:
2365 [temp.expl.spec]
2367 It is possible for a specialization with a given function
2368 signature to be instantiated from more than one function
2369 template. In such cases, explicit specification of the
2370 template arguments must be used to uniquely identify the
2371 function template specialization being specialized.
2373 Note that here, there's no suggestion that we're supposed to
2374 determine which of the candidate templates is most
2375 specialized. However, we, also have:
2377 [temp.func.order]
2379 Partial ordering of overloaded function template
2380 declarations is used in the following contexts to select
2381 the function template to which a function template
2382 specialization refers:
2384 -- when an explicit specialization refers to a function
2385 template.
2387 So, we do use the partial ordering rules, at least for now.
2388 This extension can only serve to make invalid programs valid,
2389 so it's safe. And, there is strong anecdotal evidence that
2390 the committee intended the partial ordering rules to apply;
2391 the EDG front end has that behavior, and John Spicer claims
2392 that the committee simply forgot to delete the wording in
2393 [temp.expl.spec]. */
2396 {
2399 }
2400 }
2402 // Concepts allows multiple declarations of member functions
2403 // with the same signature. Like above, we need to rely on
2404 // on the partial ordering of those candidates to determine which
2405 // is the best.
2407 {
2409 {
2412 }
2413 }
2416 {
2423 else
2426 }
2430 {
2436 }
2438 /* We have one, and exactly one, match. */
2440 {
2444 // Propagate the candidate's constraints to the declaration.
2447 /* DECL is a re-declaration or partial instantiation of a template
2448 function. */
2451 /* It was a specialization of an ordinary member function in a
2452 template class. */
2454 }
2456 /* It was a specialization of a template. */
2459 {
2464 }
2465 else
2468 }
2470 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2471 but with the default argument values filled in from those in the
2472 TMPL_TYPES. */
2474 static tree
2476 tree tmpl_types)
2477 {
2478 tree new_spec_types;
2486 /* Substitute into the rest of the list. */
2487 new_spec_types =
2491 /* Add the default argument for this parameter. */
2494 new_spec_types);
2495 }
2497 /* DECL is an explicit specialization. Replicate default arguments
2498 from the template it specializes. (That way, code like:
2500 template <class T> void f(T = 3);
2501 template <> void f(double);
2502 void g () { f (); }
2504 works, as required.) An alternative approach would be to look up
2505 the correct default arguments at the call-site, but this approach
2506 is consistent with how implicit instantiations are handled. */
2508 static void
2510 {
2511 tree tmpl;
2512 tree spec_types;
2513 tree tmpl_types;
2514 tree new_spec_types;
2515 tree old_type;
2516 tree new_type;
2517 tree t;
2522 /* See if there's anything we need to do. */
2535 {
2536 /* Remove the this pointer, but remember the object's type for
2537 CV quals. */
2543 {
2544 /* DECL may contain more parameters than TMPL due to the extra
2545 in-charge parameter in constructors and destructors. */
2548 }
2550 {
2553 }
2554 }
2556 /* Compute the merged default arguments. */
2557 new_spec_types =
2560 /* Compute the new FUNCTION_TYPE. */
2562 {
2566 new_spec_types);
2569 /* Put the in-charge parameter back. */
2572 new_spec_types);
2576 new_spec_types);
2577 }
2578 else
2580 new_spec_types);
2586 }
2588 /* Return the number of template headers we expect to see for a definition
2589 or specialization of CTYPE or one of its non-template members. */
2591 int
2593 {
2597 {
2598 /* You're supposed to have one `template <...>' for every
2599 template class, but you don't need one for a full
2600 specialization. For example:
2602 template <class T> struct S{};
2603 template <> struct S<int> { void f(); };
2604 void S<int>::f () {}
2606 is correct; there shouldn't be a `template <>' for the
2607 definition of `S<int>::f'. */
2609 /* If CTYPE does not have template information of any
2610 kind, then it is not a template, nor is it nested
2611 within a template. */
2619 }
2622 }
2624 /* Do a simple sanity check on the template headers that precede the
2625 variable declaration DECL. */
2627 void
2629 {
2634 {
2637 "variable templates only available with "
2640 // Namespace-scope variable templates should have a template header.
2642 }
2644 {
2645 auto_diagnostic_group d;
2647 "too many template headers for %qD "
2653 "members of an explicitly specialized class are defined "
2655 }
2656 }
2658 /* An explicit specialization whose declarator-id or class-head-name is not
2659 qualified shall be declared in the nearest enclosing namespace of the
2660 template, or, if the namespace is inline (7.3.1), any namespace from its
2661 enclosing namespace set.
2663 If the name declared in the explicit instantiation is an unqualified name,
2664 the explicit instantiation shall appear in the namespace where its template
2665 is declared or, if that namespace is inline (7.3.1), any namespace from its
2666 enclosing namespace set. */
2668 void
2670 {
2675 {
2681 /* This was allowed in C++98, so only pedwarn. */
2683 "outside its namespace must use a nested-name-"
2685 }
2686 }
2688 /* Warn for a template specialization SPEC that is missing some of a set
2689 of function or type attributes that the template TEMPL is declared with.
2690 ATTRLIST is a list of additional attributes that SPEC should be taken
2691 to ultimately be declared with. */
2693 static void
2695 {
2699 /* Avoid warning if the difference between the primary and
2700 the specialization is not in one of the attributes below. */
2704 };
2706 /* Put together a list of the black listed attributes that the primary
2707 template is declared with that the specialization is not, in case
2708 it's not apparent from the most recent declaration of the primary. */
2709 pretty_printer str;
2716 auto_diagnostic_group d;
2719 spec))
2725 }
2727 /* Check to see if the function just declared, as indicated in
2728 DECLARATOR, and in DECL, is a specialization of a function
2729 template. We may also discover that the declaration is an explicit
2730 instantiation at this point.
2732 Returns DECL, or an equivalent declaration that should be used
2733 instead if all goes well. Issues an error message if something is
2734 amiss. Returns error_mark_node if the error is not easily
2735 recoverable.
2737 FLAGS is a bitmask consisting of the following flags:
2739 2: The function has a definition.
2740 4: The function is a friend.
2742 The TEMPLATE_COUNT is the number of references to qualifying
2743 template classes that appeared in the name of the function. For
2744 example, in
2746 template <class T> struct S { void f(); };
2747 void S<int>::f();
2749 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2750 classes are not counted in the TEMPLATE_COUNT, so that in
2752 template <class T> struct S {};
2753 template <> struct S<int> { void f(); }
2754 template <> void S<int>::f();
2756 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2757 invalid; there should be no template <>.)
2759 If the function is a specialization, it is marked as such via
2760 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2761 is set up correctly, and it is added to the list of specializations
2762 for that template. */
2764 tree
2766 tree decl,
2769 tree attrlist)
2770 {
2779 tmpl_spec_kind tsk;
2782 {
2785 else
2787 }
2788 else
2792 {
2795 {
2798 }
2800 {
2802 /* This could be something like:
2804 template <class T> void f(T);
2805 class S { friend void f<>(int); } */
2807 else
2808 {
2809 /* This case handles bogus declarations like template <>
2810 template <class T> void f<int>(); */
2813 declarator);
2815 }
2816 }
2820 /* The error has already been reported in
2821 check_specialization_scope. */
2827 /* Fall through. */
2840 decl);
2843 else
2847 /* Fall through. */
2853 /* In cases like template<> constexpr bool v = true;
2854 We'll give an error in check_template_variable. */
2860 else
2866 {
2867 /* This case handles bogus declarations like template <>
2868 template <class T> void f<int>(); */
2872 declarator);
2874 {
2875 /* Partial specialization of variable template. */
2879 }
2883 else
2887 ok:;
2888 }
2891 /* This is a specialization of a member template, without
2892 specialization the containing class. Something like:
2894 template <class T> struct S {
2895 template <class U> void f (U);
2896 };
2897 template <> template <class U> void S<int>::f(U) {}
2899 That's a specialization -- but of the entire template. */
2905 }
2908 /* This doesn't apply to variable templates. */
2911 {
2915 {
2919 }
2920 }
2923 {
2928 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2930 {
2931 tree fns;
2936 else
2937 {
2938 /* If there is no class context, the explicit instantiation
2939 must be at namespace scope. */
2942 /* Find the namespace binding, using the declaration
2943 context. */
2947 /* If lookup fails, look for a friend declaration so we can
2948 give a better diagnostic. */
2954 {
2957 }
2958 }
2961 }
2967 {
2969 /* A specialization in class scope. This is invalid,
2970 but the error will already have been flagged by
2971 check_specialization_scope. */
2973 else
2974 {
2975 /* It's not valid to write an explicit instantiation in
2976 class scope, e.g.:
2978 class C { template void f(); }
2980 This case is caught by the parser. However, on
2981 something like:
2983 template class C { void f(); };
2985 (which is invalid) we can get here. The error will be
2986 issued later. */
2987 ;
2988 }
2991 }
2994 {
2995 // We'll match variable templates in start_decl.
2999 /* Find the list of functions in ctype that have the same
3000 name as the declared function. */
3004 {
3008 {
3009 /* From [temp.expl.spec]:
3011 If such an explicit specialization for the member
3012 of a class template names an implicitly-declared
3013 special member function (clause _special_), the
3014 program is ill-formed.
3016 Similar language is found in [temp.explicit]. */
3019 }
3022 }
3024 /* For a type-conversion operator, We might be looking for
3025 `operator int' which will be a specialization of
3026 `operator T'. Grab all the conversion operators, and
3027 then select from them. */
3032 {
3035 }
3036 else
3038 }
3040 /* Figure out what exactly is being specialized at this point.
3041 Note that for an explicit instantiation, even one for a
3042 member function, we cannot tell a priori whether the
3043 instantiation is for a member template, or just a member
3044 function of a template class. Even if a member template is
3045 being instantiated, the member template arguments may be
3046 elided if they can be deduced from the rest of the
3047 declaration. */
3050 member_specialization,
3051 template_count,
3052 tsk);
3055 /* We couldn't figure out what this declaration was
3056 specializing. */
3058 else
3059 {
3062 {
3063 auto_diagnostic_group d;
3065 "friend declaration %qD is not visible to "
3069 }
3077 {
3078 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
3079 is done by do_decl_instantiation later. */
3085 {
3086 /* If TMPL is not the most general template (for
3087 example, if TMPL is a friend template that is
3088 injected into namespace scope), then there will
3089 be too many levels of TARGS. Remove some of them
3090 here. */
3092 tree new_targs;
3099 }
3102 }
3104 /* If we thought that the DECL was a member function, but it
3105 turns out to be specializing a static member function,
3106 make DECL a static member function as well. */
3112 /* If this is a specialization of a member template of a
3113 template class, we want to return the TEMPLATE_DECL, not
3114 the specialization of it. */
3116 {
3121 {
3122 tree parm;
3126 /* We want to use the argument list specified in the
3127 definition, not in the original declaration. */
3132 }
3135 }
3137 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3143 /* Inherit default function arguments from the template
3144 DECL is specializing. */
3148 /* This specialization has the same protection as the
3149 template it specializes. */
3153 /* 7.1.1-1 [dcl.stc]
3155 A storage-class-specifier shall not be specified in an
3156 explicit specialization...
3158 The parser rejects these, so unless action is taken here,
3159 explicit function specializations will always appear with
3160 global linkage.
3162 The action recommended by the C++ CWG in response to C++
3163 defect report 605 is to make the storage class and linkage
3164 of the explicit specialization match the templated function:
3166 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3167 */
3169 {
3173 /* A concept cannot be specialized. */
3175 {
3177 gen_tmpl);
3179 }
3181 /* This specialization has the same linkage and visibility as
3182 the function template it specializes. */
3185 {
3188 }
3191 {
3194 }
3195 }
3197 /* If DECL is a friend declaration, declared using an
3198 unqualified name, the namespace associated with DECL may
3199 have been set incorrectly. For example, in:
3201 template <typename T> void f(T);
3202 namespace N {
3203 struct S { friend void f<int>(int); }
3204 }
3206 we will have set the DECL_CONTEXT for the friend
3207 declaration to N, rather than to the global namespace. */
3212 /* This is not really a declaration of a specialization.
3213 It's just the name of an instantiation. But, it's not
3214 a request for an instantiation, either. */
3217 /* A specialization is not necessarily COMDAT. */
3223 /* If this is a full specialization, register it so that we can find
3224 it again. Partial specializations will be registered in
3225 process_partial_specialization. */
3227 {
3232 }
3235 /* A 'structor should already have clones. */
3241 }
3242 }
3245 }
3247 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3248 parameters. These are represented in the same format used for
3249 DECL_TEMPLATE_PARMS. */
3251 int
3253 {
3254 const_tree p1;
3255 const_tree p2;
3263 {
3275 {
3279 /* If either of the template parameters are invalid, assume
3280 they match for the sake of error recovery. */
3293 }
3294 }
3297 /* One set of parameters has more parameters lists than the
3298 other. */
3302 }
3304 /* Determine whether PARM is a parameter pack. */
3306 bool
3308 {
3309 /* Determine if we have a non-type template parameter pack. */
3316 /* If this is a list of template parameters, we could get a
3317 TYPE_DECL or a TEMPLATE_DECL. */
3321 /* Otherwise it must be a type template parameter. */
3325 }
3327 /* Determine if T is a function parameter pack. */
3329 bool
3331 {
3335 }
3337 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3338 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3340 tree
3342 {
3349 }
3351 /* Return true iff the function parameter PARAM_DECL was expanded
3352 from the function parameter pack PACK. */
3354 bool
3356 {
3361 /* The parameter pack and its pack arguments have the same
3362 DECL_PARM_INDEX. */
3364 }
3366 /* Determine whether ARGS describes a variadic template args list,
3367 i.e., one that is terminated by a template argument pack. */
3369 static bool
3371 {
3373 tree last_parm;
3387 }
3389 /* Generate a new name for the parameter pack name NAME (an
3390 IDENTIFIER_NODE) that incorporates its */
3392 static tree
3394 {
3395 /* Munge the name to include the parameter index. */
3396 #define NUMBUF_LEN 128
3410 }
3412 /* Return true if T is a primary function, class or alias template
3413 specialization, not including the template pattern. */
3415 bool
3417 {
3433 }
3435 /* Return true if PARM is a template template parameter. */
3437 bool
3439 {
3441 }
3443 /* Return true iff PARM is a DECL representing a type template
3444 parameter. */
3446 bool
3448 {
3453 }
3455 /* Return the template parameters of T if T is a
3456 primary template instantiation, NULL otherwise. */
3458 tree
3460 {
3465 parms = INNERMOST_TEMPLATE_PARMS
3469 }
3471 /* Return the template parameters of the LEVELth level from the full list
3472 of template parameters PARMS. */
3474 tree
3476 {
3477 tree p;
3488 }
3490 /* Returns the template arguments of T if T is a template instantiation,
3491 NULL otherwise. */
3493 tree
3495 {
3503 }
3505 /* Return the argument pack elements of T if T is a template argument pack,
3506 NULL otherwise. */
3508 tree
3510 {
3516 }
3518 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3519 ARGUMENT_PACK_SELECT represents. */
3521 static tree
3523 {
3527 /* If the selected argument is an expansion E, that most likely means we were
3528 called from gen_elem_of_pack_expansion_instantiation during the
3529 substituting of an argument pack (of which the Ith element is a pack
3530 expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
3531 In this case, the Ith element resulting from this substituting is going to
3532 be a pack expansion, which pattern is the pattern of E. Let's return the
3533 pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
3534 resulting pack expansion from it. */
3536 {
3537 /* Make sure we aren't throwing away arg info. */
3540 }
3543 }
3546 /* True iff FN is a function representing a built-in variadic parameter
3547 pack. */
3549 bool
3551 {
3561 }
3563 /* True iff CALL is a call to a function representing a built-in variadic
3564 parameter pack. */
3566 static bool
3568 {
3572 }
3574 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3576 static tree
3578 tree in_decl)
3579 {
3585 {
3587 {
3590 }
3595 }
3596 else
3597 {
3601 /* Calculate the largest value of len that won't make the size of the vec
3602 overflow an int. The compiler will exceed resource limits long before
3603 this, but it seems a decent place to diagnose. */
3607 {
3612 }
3620 }
3621 }
3623 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3624 CALL. */
3626 static tree
3628 tree in_decl)
3629 {
3639 }
3641 /* Structure used to track the progress of find_parameter_packs_r. */
3642 struct find_parameter_pack_data
3643 {
3644 /* TREE_LIST that will contain all of the parameter packs found by
3645 the traversal. */
3648 /* Set of AST nodes that have been visited by the traversal. */
3651 /* True iff we're making a type pack expansion. */
3653 };
3655 /* Identifies all of the argument packs that occur in a template
3656 argument and appends them to the TREE_LIST inside DATA, which is a
3657 find_parameter_pack_data structure. This is a subroutine of
3658 make_pack_expansion and uses_parameter_packs. */
3659 static tree
3661 {
3667 /* Handle type aliases/typedefs. */
3669 {
3676 }
3678 /* Identify whether this is a parameter pack or not. */
3680 {
3688 /* FALLTHRU */
3690 /* If the placeholder appears in the decl-specifier-seq of a function
3691 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3692 is a pack expansion, the invented template parameter is a template
3693 parameter pack. */
3703 {
3704 /* We don't want to walk into the type of a PARM_DECL,
3705 because we don't want to see the type parameter pack. */
3708 }
3713 {
3714 /* We don't want to walk into the type of a variadic capture proxy,
3715 because we don't want to see the type parameter pack. */
3718 }
3720 {
3722 find_parameter_packs_r,
3725 }
3737 /* Not a parameter pack. */
3739 }
3742 {
3743 /* Add this parameter pack to the list. */
3745 }
3751 /* This switch statement will return immediately if we don't find a
3752 parameter pack. */
3754 {
3759 /* Check the template itself. */
3762 /* Check the template arguments. */
3776 /* Ignore the declaration of a capture proxy for a parameter pack. */
3784 /* Fall through. */
3829 {
3830 /* Look at explicit captures. */
3835 /* Since we defer implicit capture, look in the parms and body. */
3843 }
3846 {
3847 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3848 type_pack_expansion_p to false so that any placeholders
3849 within the expression don't get marked as parameter packs. */
3857 }
3866 /* Don't walk into IF_STMT_EXTRA_ARGS. */
3872 }
3875 }
3877 /* Determines if the expression or type T uses any parameter packs. */
3878 bool
3880 {
3889 }
3891 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3892 representation a base-class initializer into a parameter pack
3893 expansion. If all goes well, the resulting node will be an
3894 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3895 respectively. */
3896 tree
3898 {
3899 tree result;
3908 {
3909 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3910 class initializer. In this case, the TREE_PURPOSE will be a
3911 _TYPE node (representing the base class expansion we're
3912 initializing) and the TREE_VALUE will be a TREE_LIST
3913 containing the initialization arguments.
3915 The resulting expansion looks somewhat different from most
3916 expansions. Rather than returning just one _EXPANSION, we
3917 return a TREE_LIST whose TREE_PURPOSE is a
3918 TYPE_PACK_EXPANSION containing the bases that will be
3919 initialized. The TREE_VALUE will be identical to the
3920 original TREE_VALUE, which is a list of arguments that will
3921 be passed to each base. We do not introduce any new pack
3922 expansion nodes into the TREE_VALUE (although it is possible
3923 that some already exist), because the TREE_PURPOSE and
3924 TREE_VALUE all need to be expanded together with the same
3925 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3926 resulting TREE_PURPOSE will mention the parameter packs in
3927 both the bases and the arguments to the bases. */
3928 tree purpose;
3929 tree value;
3932 /* Determine which parameter packs will be used by the base
3933 class expansion. */
3942 {
3945 arg);
3948 }
3951 {
3952 /* Collect the sets of parameter packs used in each of the
3953 initialization arguments. */
3955 {
3956 /* Determine which parameter packs will be expanded in this
3957 argument. */
3960 }
3961 }
3965 /* Create the pack expansion type for the base type. */
3971 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3972 they will rarely be compared to anything. */
3976 }
3981 /* Build the PACK_EXPANSION_* node. */
3982 result = for_types
3987 {
3988 /* Propagate type and const-expression information. */
3991 /* Mark this read now, since the expansion might be length 0. */
3993 }
3994 else
3995 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3996 they will rarely be compared to anything. */
3999 /* Determine which parameter packs will be expanded. */
4006 /* Make sure we found some parameter packs. */
4008 {
4010 {
4013 else
4015 }
4017 }
4023 }
4025 /* Checks T for any "bare" parameter packs, which have not yet been
4026 expanded, and issues an error if any are found. This operation can
4027 only be done on full expressions or types (e.g., an expression
4028 statement, "if" condition, etc.), because we could have expressions like:
4030 foo(f(g(h(args)))...)
4032 where "args" is a parameter pack. check_for_bare_parameter_packs
4033 should not be called for the subexpressions args, h(args),
4034 g(h(args)), or f(g(h(args))), because we would produce erroneous
4035 error messages.
4037 Returns TRUE and emits an error if there were bare parameter packs,
4038 returns FALSE otherwise. */
4039 bool
4041 {
4048 /* A lambda might use a parameter pack from the containing context. */
4063 {
4068 {
4079 else
4084 else
4088 }
4091 }
4094 }
4096 /* Expand any parameter packs that occur in the template arguments in
4097 ARGS. */
4098 tree
4100 {
4109 /* First, determine if we need to expand anything, and the number of
4110 slots we'll need. */
4112 {
4117 {
4121 else
4123 }
4124 else
4125 {
4127 num_result_args++;
4128 }
4129 }
4131 /* If no expansion is necessary, we're done. */
4135 /* Expand arguments. */
4138 non_default_args_count =
4141 {
4144 {
4151 }
4152 else
4153 {
4156 }
4157 }
4161 }
4163 /* Checks if DECL shadows a template parameter.
4165 [temp.local]: A template-parameter shall not be redeclared within its
4166 scope (including nested scopes).
4168 Emits an error and returns TRUE if the DECL shadows a parameter,
4169 returns FALSE otherwise. */
4171 bool
4173 {
4174 tree olddecl;
4176 /* If we're not in a template, we can't possibly shadow a template
4177 parameter. */
4181 /* Figure out what we're shadowing. */
4185 /* If there's no previous binding for this name, we're not shadowing
4186 anything, let alone a template parameter. */
4190 /* If we're not shadowing a template parameter, we're done. Note
4191 that OLDDECL might be an OVERLOAD (or perhaps even an
4192 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4193 node. */
4197 /* We check for decl != olddecl to avoid bogus errors for using a
4198 name inside a class. We check TPFI to avoid duplicate errors for
4199 inline member templates. */
4205 /* Don't complain about the injected class name, as we've already
4206 complained about the class itself. */
4213 else
4218 }
4220 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4221 ORIG_LEVEL, DECL, and TYPE. */
4223 static tree
4227 tree decl,
4228 tree type)
4229 {
4240 }
4242 /* Find the canonical type parameter for the given template type
4243 parameter. Returns the canonical type parameter, which may be TYPE
4244 if no such parameter existed. */
4246 static tree
4248 {
4249 tree list;
4263 else
4264 {
4268 }
4269 }
4271 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4272 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4273 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4274 new one is created. */
4276 static tree
4278 tsubst_flags_t complain)
4279 {
4284 {
4303 /* Template template parameters need this. */
4305 {
4312 }
4313 }
4316 }
4318 /* Process information from new template parameter PARM and append it
4319 to the LIST being built. This new parameter is a non-type
4320 parameter iff IS_NON_TYPE is true. This new parameter is a
4321 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4322 is in PARM_LOC. */
4324 tree
4327 {
4336 {
4340 {
4344 else
4346 }
4349 }
4352 {
4358 {
4359 /* [temp.param]
4361 The top-level cv-qualifiers on the template-parameter are
4362 ignored when determining its type. */
4367 && !is_parameter_pack
4368 /* If we're in a nested template parameter list, the template
4369 template parameter could be a parameter pack. */
4371 {
4372 /* This template parameter is not a parameter pack, but it
4373 should be. Complain about "bare" parameter packs. */
4376 /* Recover by calling this a parameter pack. */
4378 }
4379 }
4381 /* A template parameter is not modifiable. */
4390 processing_template_decl,
4395 }
4396 else
4397 {
4398 tree t;
4402 {
4404 /* This is for distinguishing between real templates and template
4405 template parameters */
4409 }
4410 else
4411 {
4413 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4416 }
4423 processing_template_decl,
4427 }
4431 /* Build requirements for the type/template parameter.
4432 This must be done after SET_DECL_TEMPLATE_PARM_P or
4433 process_template_parm could fail. */
4440 /* Build the parameter node linking the parameter declaration,
4441 its default argument (if any), and its constraints (if any). */
4446 }
4448 /* The end of a template parameter list has been reached. Process the
4449 tree list into a parameter vector, converting each parameter into a more
4450 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4451 as PARM_DECLs. */
4453 tree
4455 {
4460 /* Pop the dummy parameter level and add the real one. */
4463 current_template_parms
4468 {
4472 }
4477 }
4479 // Explicitly indicate the end of the template parameter list. We assume
4480 // that the current template parameters have been constructed and/or
4481 // managed explicitly, as when creating new template template parameters
4482 // from a shorthand constraint.
4483 void
4485 {
4487 }
4489 /* end_template_decl is called after a template declaration is seen. */
4491 void
4493 {
4499 /* This matches the pushlevel in begin_template_parm_list. */
4504 }
4506 /* Takes a TREE_LIST representing a template parameter and convert it
4507 into an argument suitable to be passed to the type substitution
4508 functions. Note that If the TREE_LIST contains an error_mark
4509 node, the returned argument is error_mark_node. */
4511 tree
4513 {
4526 {
4530 {
4531 /* Turn this argument into a TYPE_ARGUMENT_PACK
4532 with a single element, which expands T. */
4541 }
4542 }
4543 else
4544 {
4548 {
4549 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4550 with a single element, which expands T. */
4560 }
4561 else
4563 }
4565 }
4567 /* Given a single level of template parameters (a TREE_VEC), return it
4568 as a set of template arguments. */
4570 static tree
4572 {
4582 }
4584 /* Given a set of template parameters, return them as a set of template
4585 arguments. The template parameters are represented as a TREE_VEC, in
4586 the form documented in cp-tree.h for template arguments. */
4588 static tree
4590 {
4591 tree header;
4596 /* If there is only one level of template parameters, we do not
4597 create a TREE_VEC of TREE_VECs. Instead, we return a single
4598 TREE_VEC containing the arguments. */
4603 {
4608 else
4610 }
4613 }
4615 /* Within the declaration of a template, return the currently active
4616 template parameters as an argument TREE_VEC. */
4618 static tree
4620 {
4622 }
4624 /* Update the declared TYPE by doing any lookups which were thought to be
4625 dependent, but are not now that we know the SCOPE of the declarator. */
4627 tree
4629 {
4640 /* Don't bother building up the args in this case. */
4642 {
4643 /* tsubst in the args corresponding to the template parameters,
4644 including auto if present. Most things will be unchanged, but
4645 make_typename_type and tsubst_qualified_id will resolve
4646 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4649 tree pushed;
4651 {
4655 }
4660 }
4666 {
4669 else
4671 }
4673 }
4675 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4676 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4677 the new template is a member template. */
4679 static tree
4681 {
4690 }
4692 struct template_parm_data
4693 {
4694 /* The level of the template parameters we are currently
4695 processing. */
4698 /* The index of the specialization argument we are currently
4699 processing. */
4702 /* An array whose size is the number of template parameters. The
4703 elements are nonzero if the parameter has been used in any one
4704 of the arguments processed so far. */
4707 /* An array whose size is the number of template arguments. The
4708 elements are nonzero if the argument makes use of template
4709 parameters of this level. */
4711 };
4713 /* Subroutine of push_template_decl used to see if each template
4714 parameter in a partial specialization is used in the explicit
4715 argument list. If T is of the LEVEL given in DATA (which is
4716 treated as a template_parm_data*), then DATA->PARMS is marked
4717 appropriately. */
4719 static int
4721 {
4729 {
4732 }
4734 /* In C++17 the type of a non-type argument is a deduced context. */
4739 data,
4740 NULL,
4743 /* Return zero so that for_each_template_parm will continue the
4744 traversal of the tree; we want to mark *every* template parm. */
4746 }
4748 /* Process the partial specialization DECL. */
4750 static tree
4752 {
4759 tree inner_parms;
4760 tree inst;
4770 /* A concept cannot be specialized. */
4772 {
4775 }
4780 /* We check that each of the template parameters given in the
4781 partial specialization is used in the argument list to the
4782 specialization. For example:
4784 template <class T> struct S;
4785 template <class T> struct S<T*>;
4787 The second declaration is OK because `T*' uses the template
4788 parameter T, whereas
4790 template <class T> struct S<int>;
4792 is no good. Even trickier is:
4794 template <class T>
4795 struct S1
4796 {
4797 template <class U>
4798 struct S2;
4799 template <class U>
4800 struct S2<T>;
4801 };
4803 The S2<T> declaration is actually invalid; it is a
4804 full-specialization. Of course,
4806 template <class U>
4807 struct S2<T (*)(U)>;
4809 or some such would have been OK. */
4817 {
4822 NULL,
4824 }
4827 {
4828 /* One of the template parms was not used in a deduced context in the
4829 specialization. */
4831 {
4835 }
4839 }
4844 /* [temp.class.spec]
4846 The argument list of the specialization shall not be identical to
4847 the implicit argument list of the primary template. */
4848 tree main_args
4851 && (!flag_concepts
4854 {
4857 "any template arguments; to define the primary template, "
4859 else
4861 "template arguments and is not more constrained than "
4862 "the primary template; to define the primary template, "
4865 }
4867 /* A partial specialization that replaces multiple parameters of the
4868 primary template with a pack expansion is less specialized for those
4869 parameters. */
4871 {
4873 "primary template because it replaces multiple parameters "
4876 /* Avoid crash in process_partial_specialization. */
4878 }
4880 /* If we aren't in a dependent class, we can actually try deduction. */
4882 /* FIXME we should be able to handle a partial specialization of a
4883 partial instantiation, but currently we can't (c++/41727). */
4886 {
4887 auto_diagnostic_group d;
4891 maintmpl);
4892 }
4894 /* [temp.class.spec]
4896 A partially specialized non-type argument expression shall not
4897 involve template parameters of the partial specialization except
4898 when the argument expression is a simple identifier.
4900 The type of a template parameter corresponding to a specialized
4901 non-type argument shall not be dependent on a parameter of the
4902 specialization.
4904 Also, we verify that pack expansions only occur at the
4905 end of the argument list. */
4909 {
4916 {
4917 /* Extract the arguments from the argument pack. We'll be
4918 iterating over these in the following loop. */
4921 }
4924 {
4926 /* Get the Jth argument in the parameter pack. */
4930 {
4931 /* Pack expansions must come at the end of the
4932 argument list. */
4935 {
4939 else
4942 }
4943 }
4946 /* We only care about the pattern. */
4952 /* This next two lines are the `argument expression is not just a
4953 simple identifier' condition and also the `specialized
4954 non-type argument' bit. */
4958 {
4962 arg);
4963 else
4964 {
4965 /* Look at the corresponding template parameter,
4966 marking which template parameters its type depends
4967 upon. */
4971 {
4972 /* We haven't yet initialized TPD2. Do so now. */
4974 /* The number of parameters here is the number in the
4975 main template, which, as checked in the assertion
4976 above, is NARGS. */
4980 }
4982 /* Mark the template parameters. But this time, we're
4983 looking for the template parameters of the main
4984 template, not in the specialization. */
4991 NULL,
4995 {
4996 /* The type depended on some template parameters.
4997 If they are fully specialized in the
4998 specialization, that's OK. */
5007 "type %qT of template argument %qE depends "
5009 "type %qT of template argument %qE depends "
5011 type,
5012 arg);
5013 }
5014 }
5015 }
5016 }
5017 }
5019 /* We should only get here once. */
5023 // Build the template decl.
5032 /* Give template template parms a DECL_CONTEXT of the template
5033 for which they are a parameter. */
5035 {
5039 }
5042 /* We didn't register this in check_explicit_specialization so we could
5043 wait until the constraints were set. */
5045 else
5055 {
5061 {
5069 "declaration of %qD ambiguates earlier template "
5073 "partial specialization of %qD after instantiation "
5075 }
5076 }
5079 }
5081 /* PARM is a template parameter of some form; return the corresponding
5082 TEMPLATE_PARM_INDEX. */
5084 static tree
5086 {
5099 }
5101 /* Subroutine of fixed_parameter_pack_p below. Look for any template
5102 parameter packs used by the template parameter PARM. */
5104 static void
5106 {
5107 /* A type parm can't refer to another parm. */
5111 {
5115 }
5121 {
5125 else
5127 }
5128 }
5130 /* PARM is a template parameter pack. Return any parameter packs used in
5131 its type or the type of any of its template parameters. If there are
5132 any such packs, it will be instantiated into a fixed template parameter
5133 list by partial instantiation rather than be fully deduced. */
5135 tree
5137 {
5138 /* This can only be true in a member template. */
5141 /* This can only be true for a parameter pack. */
5144 /* A type parm can't refer to another parm. */
5158 }
5160 /* Check that a template declaration's use of default arguments and
5161 parameter packs is not invalid. Here, PARMS are the template
5162 parameters. IS_PRIMARY is true if DECL is the thing declared by
5163 a primary template. IS_PARTIAL is true if DECL is a partial
5164 specialization.
5166 IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5167 function template declaration or a friend class template
5168 declaration. In the function case, 1 indicates a declaration, 2
5169 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5170 emitted for extraneous default arguments.
5172 Returns TRUE if there were no errors found, FALSE otherwise. */
5174 bool
5177 {
5180 tree parm_level;
5183 /* [temp.param]
5185 A default template-argument shall not be specified in a
5186 function template declaration or a function template definition, nor
5187 in the template-parameter-list of the definition of a member of a
5188 class template. */
5192 /* You can't have a function template declaration in a local
5193 scope, nor you can you define a member of a class template in a
5194 local scope. */
5202 /* A lambda doesn't have an explicit declaration; don't complain
5203 about the parms of the enclosing class. */
5210 /* If this is either a friend defined in the scope of the class
5211 or a member function. */
5217 /* And, if it was a member function, it really was defined in
5218 the scope of the class. */
5221 /* We already checked these parameters when the template was
5222 declared, so there's no need to do it again now. This function
5223 was defined in class scope, but we're processing its body now
5224 that the class is complete. */
5227 /* Core issue 226 (C++0x only): the following only applies to class
5228 templates. */
5231 {
5232 /* [temp.param]
5234 If a template-parameter has a default template-argument, all
5235 subsequent template-parameters shall have a default
5236 template-argument supplied. */
5238 {
5245 {
5255 {
5257 /* For better subsequent error-recovery, we indicate that
5258 there should have been a default argument. */
5261 }
5263 && !is_friend_decl
5264 /* Don't complain about an enclosing partial
5265 specialization. */
5270 /* A fixed parameter pack will be partially
5271 instantiated into a fixed length list. */
5273 {
5274 /* A primary class template can only have one
5275 parameter pack, at the end of the template
5276 parameter list. */
5284 }
5285 }
5286 }
5287 }
5290 || is_partial
5291 || !is_primary
5293 /* For an ordinary class template, default template arguments are
5294 allowed at the innermost level, e.g.:
5295 template <class T = int>
5296 struct S {};
5297 but, in a partial specialization, they're not allowed even
5298 there, as we have in [temp.class.spec]:
5300 The template parameter list of a specialization shall not
5301 contain default template argument values.
5303 So, for a partial specialization, or for a function template
5304 (in C++98/C++03), we look at all of them. */
5305 ;
5306 else
5307 /* But, for a primary class template that is not a partial
5308 specialization we look at all template parameters except the
5309 innermost ones. */
5312 /* Figure out what error message to issue. */
5327 else
5328 /* Per [temp.param]/9, "A default template-argument shall not be
5329 specified in the template-parameter-lists of the definition of
5330 a member of a class template that appears outside of the member's
5331 class.", thus if we aren't handling a member of a class template
5332 there is no need to examine the parameters. */
5336 /* If we're inside a class definition, there's no need to
5337 examine the parameters to the class itself. On the one
5338 hand, they will be checked when the class is defined, and,
5339 on the other, default arguments are valid in things like:
5340 template <class T = double>
5341 struct S { template <class U> void f(U); };
5342 Here the default argument for `S' has no bearing on the
5343 declaration of `f'. */
5345 else
5346 /* Check everything. */
5352 {
5359 {
5364 {
5366 {
5373 }
5375 /* Clear out the default argument so that we are not
5376 confused later. */
5378 }
5379 }
5381 /* At this point, if we're still interested in issuing messages,
5382 they must apply to classes surrounding the object declared. */
5386 }
5389 }
5391 /* Worker for push_template_decl_real, called via
5392 for_each_template_parm. DATA is really an int, indicating the
5393 level of the parameters we are interested in. If T is a template
5394 parameter of that level, return nonzero. */
5396 static int
5398 {
5404 else
5407 }
5409 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5410 DATA is really an int, indicating the innermost outer level of parameters.
5411 If T is a template parameter of that level or further out, return
5412 nonzero. */
5414 static int
5416 {
5422 else
5425 }
5427 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5428 parameters given by current_template_args, or reuses a
5429 previously existing one, if appropriate. Returns the DECL, or an
5430 equivalent one, if it is replaced via a call to duplicate_decls.
5432 If IS_FRIEND is true, DECL is a friend declaration. */
5434 tree
5436 {
5437 tree tmpl;
5438 tree args;
5439 tree info;
5440 tree ctx;
5444 /* True if the template is a member template, in the sense of
5445 [temp.mem]. */
5451 /* See if this is a partial specialization. */
5464 /* For a friend, we want the context of the friend, not
5465 the type of which it is a friend. */
5469 /* In the case of a virtual function, we want the class in which
5470 it is defined. */
5472 else
5473 /* Otherwise, if we're currently defining some class, the DECL
5474 is assumed to be a member of the class. */
5483 /* See if this is a primary template. */
5486 /* A friend template that specifies a class context, i.e.
5487 template <typename T> friend void A<T>::f();
5488 is not primary. */
5493 else
5497 {
5504 {
5507 }
5509 {
5511 {
5514 }
5516 {
5517 /* [temp.mem]
5519 A destructor shall not be a member template. */
5522 }
5529 {
5530 /* [basic.stc.dynamic.allocation]
5532 An allocation function can be a function
5533 template. ... Template allocation functions shall
5534 have two or more parameters. */
5537 }
5538 }
5541 {
5542 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5545 {
5551 }
5552 }
5555 /* alias-declaration */
5559 else
5560 {
5563 }
5564 }
5566 /* Check to see that the rules regarding the use of default
5567 arguments are not being violated. We check args for a friend
5568 functions when we know whether it's a definition, introducing
5569 declaration or re-declaration. */
5574 /* Ensure that there are no parameter packs in the type of this
5575 declaration that have not been expanded. */
5577 {
5578 /* Check each of the arguments individually to see if there are
5579 any bare parameter packs. */
5585 {
5588 {
5589 /* This is a PARM_DECL that contains unexpanded parameter
5590 packs. We have already complained about this in the
5591 check_for_bare_parameter_packs call, so just replace
5592 these types with ERROR_MARK_NODE. */
5595 }
5599 }
5601 /* Check for bare parameter packs in the return type and the
5602 exception specifiers. */
5604 /* Errors were already issued, set return type to int
5605 as the frontend doesn't expect error_mark_node as
5606 the return type. */
5610 }
5615 {
5618 }
5631 {
5636 /* If DECL is a TYPE_DECL for a class-template, then there won't
5637 be DECL_LANG_SPECIFIC. The information equivalent to
5638 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5642 {
5643 /* Since a template declaration already existed for this
5644 class-type, we must be redeclaring it here. Make sure
5645 that the redeclaration is valid. */
5647 current_template_parms,
5649 /* We don't need to create a new TEMPLATE_DECL; just use the
5650 one we already had. */
5652 }
5653 else
5654 {
5656 member_template_p);
5661 {
5662 /* A specialization of a member template of a template
5663 class. */
5667 }
5668 }
5669 }
5670 else
5671 {
5677 {
5680 }
5688 {
5689 tree new_tmpl;
5691 /* The declaration is a specialization of a member
5692 template, declared outside the class. Therefore, the
5693 innermost template arguments will be NULL, so we
5694 replace them with the arguments determined by the
5695 earlier call to check_explicit_specialization. */
5698 new_tmpl
5700 member_template_p);
5710 args,
5713 }
5715 /* Make sure the template headers we got make sense. */
5720 {
5725 }
5726 else
5728 {
5733 {
5737 else
5741 /* Avoid crash in import_export_decl. */
5744 }
5749 /* Can happen in erroneous input. */
5751 else
5753 }
5755 /* Check that the parms are used in the appropriate qualifying scopes
5756 in the declarator. */
5760 {
5766 /* Avoid crash in import_export_decl. */
5769 }
5770 }
5775 /* Push template declarations for global functions and types. Note
5776 that we do not try to push a global template friend declared in a
5777 template class; such a thing may well depend on the template
5778 parameters of the class. */
5781 {
5786 /* Hide template friend classes that haven't been declared yet. */
5788 {
5791 }
5792 }
5795 {
5800 /* Give template template parms a DECL_CONTEXT of the template
5801 for which they are a parameter. */
5804 {
5808 }
5814 }
5816 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5817 back to its most general template. If TMPL is a specialization,
5818 ARGS may only have the innermost set of arguments. Add the missing
5819 argument levels if necessary. */
5827 else
5828 {
5833 }
5836 && !is_friend
5839 /* Set DECL_COMDAT on template instantiations; if we force
5840 them to be emitted by explicit instantiation or -frepo,
5841 mark_needed will tell cgraph to do the right thing. */
5845 }
5847 tree
5849 {
5851 }
5853 /* FN is an inheriting constructor that inherits from the constructor
5854 template INHERITED; turn FN into a constructor template with a matching
5855 template header. */
5857 tree
5859 {
5860 tree inner_parms
5863 tree parms
5874 }
5876 /* Called when a class template TYPE is redeclared with the indicated
5877 template PARMS, e.g.:
5879 template <class T> struct S;
5880 template <class T> struct S {}; */
5882 bool
5884 {
5885 tree tmpl;
5886 tree tmpl_parms;
5890 {
5893 }
5897 /* The type is nested in some template class. Nothing to worry
5898 about here; there are no new template parameters for the nested
5899 type. */
5903 {
5905 tmpl);
5907 }
5913 {
5923 }
5926 {
5927 tree tmpl_parm;
5928 tree parm;
5929 tree tmpl_default;
5930 tree parm_default;
5944 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5945 TEMPLATE_DECL. */
5955 {
5959 }
5962 {
5963 /* We have in [temp.param]:
5965 A template-parameter may not be given default arguments
5966 by two different declarations in the same scope. */
5971 }
5974 /* Update the previous template parameters (which are the ones
5975 that will really count) with the new default value. */
5978 /* Update the new parameters, too; they'll be used as the
5979 parameters for any members. */
5982 /* Give each template template parm in this redeclaration a
5983 DECL_CONTEXT of the template for which they are a parameter. */
5985 {
5988 }
5992 }
5994 // Cannot redeclare a class template with a different set of constraints.
5996 {
6001 }
6004 }
6006 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
6007 to be used when the caller has already checked
6008 (processing_template_decl
6009 && !instantiation_dependent_expression_p (expr)
6010 && potential_constant_expression (expr))
6011 and cleared processing_template_decl. */
6013 tree
6015 {
6018 complain,
6022 }
6024 /* Simplify EXPR if it is a non-dependent expression. Returns the
6025 (possibly simplified) expression. */
6027 tree
6029 {
6033 /* If we're in a template, but EXPR isn't value dependent, simplify
6034 it. We're supposed to treat:
6036 template <typename T> void f(T[1 + 1]);
6037 template <typename T> void f(T[2]);
6039 as two declarations of the same function, for example. */
6042 {
6043 processing_template_decl_sentinel s;
6045 }
6047 }
6049 tree
6051 {
6053 }
6055 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
6056 an uninstantiated expression. */
6058 tree
6060 {
6064 {
6067 else
6068 {
6069 processing_template_decl_sentinel s;
6071 }
6072 }
6074 }
6076 /* True iff T is a specialization of a variable template. */
6078 bool
6080 {
6085 }
6087 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6088 template declaration, or a TYPE_DECL for an alias declaration. */
6090 bool
6092 {
6100 }
6102 /* Return TRUE iff T is a specialization of an alias template. */
6104 bool
6106 {
6107 /* It's an alias template specialization if it's an alias and its
6108 TYPE_NAME is a specialization of a primary template. */
6114 }
6116 /* An alias template is complex from a SFINAE perspective if a template-id
6117 using that alias can be ill-formed when the expansion is not, as with
6118 the void_t template. We determine this by checking whether the
6119 expansion for the alias template uses all its template parameters. */
6121 struct uses_all_template_parms_data
6122 {
6125 };
6127 static int
6129 {
6137 }
6139 static bool
6141 {
6156 }
6158 /* Return TRUE iff T is a specialization of a complex alias template with
6159 dependent template-arguments. */
6161 bool
6163 {
6176 }
6178 /* Return the number of innermost template parameters in TMPL. */
6180 static int
6182 {
6185 }
6187 /* Return either TMPL or another template that it is equivalent to under DR
6188 1286: An alias that just changes the name of a template is equivalent to
6189 the other template. */
6191 static tree
6193 {
6196 {
6197 /* Determine if the alias is equivalent to an underlying template. */
6209 tree alias_args = INNERMOST_TEMPLATE_ARGS
6214 /* Alias is equivalent. Strip it and repeat. */
6216 }
6219 }
6221 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6222 must be a reference-to-function or a pointer-to-function type, as specified
6223 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6224 and check that the resulting function has external linkage. */
6226 static tree
6228 tsubst_flags_t complain)
6229 {
6232 linkage_kind linkage;
6247 /* [temp.arg.nontype]/1
6249 A template-argument for a non-type, non-template template-parameter
6250 shall be one of:
6251 [...]
6252 -- the address of an object or function with external [C++11: or
6253 internal] linkage. */
6257 {
6259 {
6265 else
6268 }
6270 }
6274 {
6276 {
6281 else
6285 }
6287 }
6289 accept:
6291 {
6294 else
6296 }
6301 }
6303 /* Subroutine of convert_nontype_argument.
6304 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6305 Emit an error otherwise. */
6307 static bool
6309 tsubst_flags_t complain)
6310 {
6327 {
6332 else
6334 }
6336 }
6338 /* Returns TRUE iff the address of OP is value-dependent.
6340 14.6.2.4 [temp.dep.temp]:
6341 A non-integral non-type template-argument is dependent if its type is
6342 dependent or it has either of the following forms
6343 qualified-id
6344 & qualified-id
6345 and contains a nested-name-specifier which specifies a class-name that
6346 names a dependent type.
6348 We generalize this to just say that the address of a member of a
6349 dependent class is value-dependent; the above doesn't cover the
6350 address of a static data member named with an unqualified-id. */
6352 static bool
6354 {
6355 /* We could use get_inner_reference here, but there's no need;
6356 this is only relevant for template non-type arguments, which
6357 can only be expressed as &id-expression. */
6359 {
6363 }
6366 }
6368 /* The next set of functions are used for providing helpful explanatory
6369 diagnostics for failed overload resolution. Their messages should be
6370 indented by two spaces for consistency with the messages in
6371 call.c */
6373 static int
6375 {
6377 }
6379 /* Other failure functions should call this one, to provide a single function
6380 for setting a breakpoint on. */
6382 static int
6384 {
6386 }
6388 static int
6390 {
6395 }
6397 static int
6399 {
6405 }
6407 static int
6409 {
6413 }
6415 static int
6417 {
6420 " template parameter %qD is not a parameter pack, but "
6424 }
6426 static int
6428 {
6431 " template argument %qE does not match "
6435 }
6437 static int
6439 {
6443 }
6445 static int
6447 {
6453 }
6455 static int
6457 {
6459 {
6464 else
6466 " deduced conflicting values for non-type parameter "
6468 }
6470 }
6472 static int
6474 {
6477 " variable-sized array type %qT is not "
6479 arg);
6481 }
6483 static int
6485 {
6489 arg);
6491 }
6493 static int
6495 {
6497 {
6503 else
6508 }
6510 }
6512 static int
6514 {
6516 }
6518 static int
6521 {
6523 }
6525 static int
6528 {
6534 }
6536 static int
6539 {
6542 {
6550 }
6552 }
6554 static int
6556 {
6559 " template parameters of a template template argument are "
6562 }
6564 static int
6566 {
6572 }
6574 static int
6576 {
6581 }
6583 /* True if T is a C++20 template parameter object to store the argument for a
6584 template parameter of class type. */
6586 bool
6588 {
6591 }
6593 /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
6594 argument for TYPE, points to an unsuitable object. */
6596 static bool
6598 {
6600 {
6601 CASE_CONVERT:
6603 complain);
6607 complain);
6610 {
6615 }
6619 {
6623 {
6628 }
6630 {
6636 }
6639 {
6644 }
6645 /* C++17: For a non-type template-parameter of reference or pointer
6646 type, the value of the constant expression shall not refer to (or
6647 for a pointer type, shall not be the address of):
6648 * a subobject (4.5),
6649 * a temporary object (15.2),
6650 * a string literal (5.13.5),
6651 * the result of a typeid expression (8.2.8), or
6652 * a predefined __func__ variable (11.4.1). */
6654 {
6657 decl);
6659 }
6663 {
6668 }
6670 {
6674 decl);
6676 }
6677 }
6685 else
6686 {
6688 {
6691 "because %qD is a variable, not the address of "
6694 }
6695 else
6696 {
6702 }
6703 }
6704 }
6707 }
6709 /* Return a VAR_DECL for the C++20 template parameter object corresponding to
6710 template argument EXPR. */
6712 static tree
6714 {
6719 {
6724 }
6744 }
6746 /* Attempt to convert the non-type template parameter EXPR to the
6747 indicated TYPE. If the conversion is successful, return the
6748 converted value. If the conversion is unsuccessful, return
6749 NULL_TREE if we issued an error message, or error_mark_node if we
6750 did not. We issue error messages for out-and-out bad template
6751 parameters, but not simply because the conversion failed, since we
6752 might be just trying to do argument deduction. Both TYPE and EXPR
6753 must be non-dependent.
6755 The conversion follows the special rules described in
6756 [temp.arg.nontype], and it is much more strict than an implicit
6757 conversion.
6759 This function is called twice for each template argument (see
6760 lookup_template_class for a more accurate description of this
6761 problem). This means that we need to handle expressions which
6762 are not valid in a C++ source, but can be created from the
6763 first call (for instance, casts to perform conversions). These
6764 hacks can go away after we fix the double coercion problem. */
6766 static tree
6768 {
6769 tree expr_type;
6772 /* Detect immediately string literals as invalid non-type argument.
6773 This special-case is not needed for correctness (we would easily
6774 catch this later), but only to provide better diagnostic for this
6775 common user mistake. As suggested by DR 100, we do not mention
6776 linkage issues in the diagnostic as this is not the point. */
6778 {
6784 }
6786 /* Add the ADDR_EXPR now for the benefit of
6787 value_dependent_expression_p. */
6790 {
6794 }
6796 /* If we are in a template, EXPR may be non-dependent, but still
6797 have a syntactic, rather than semantic, form. For example, EXPR
6798 might be a SCOPE_REF, rather than the VAR_DECL to which the
6799 SCOPE_REF refers. Preserving the qualifying scope is necessary
6800 so that access checking can be performed when the template is
6801 instantiated -- but here we need the resolved form so that we can
6802 convert the argument. */
6814 /* If the argument is non-dependent, perform any conversions in
6815 non-dependent context as well. */
6823 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6824 to a non-type argument of "nullptr". */
6828 /* In C++11, integral or enumeration non-type template arguments can be
6829 arbitrary constant expressions. Pointer and pointer to
6830 member arguments can be general constant expressions that evaluate
6831 to a null value, but otherwise still need to be of a specific form. */
6833 {
6835 /* A PTRMEM_CST is already constant, and a valid template
6836 argument for a parameter of pointer to member type, we just want
6837 to leave it in that form rather than lower it to a
6841 {
6842 /* Calling build_converted_constant_expr might create a call to
6843 a conversion function with a value-dependent argument, which
6844 could invoke taking the address of a temporary representing
6845 the result of the conversion. */
6850 {
6854 }
6855 /* C++17: A template-argument for a non-type template-parameter shall
6856 be a converted constant expression (8.20) of the type of the
6857 template-parameter. */
6860 /* Make sure we return NULL_TREE only if we have really issued
6861 an error, as described above. */
6866 }
6868 {
6874 }
6875 }
6879 else
6882 /* HACK: Due to double coercion, we can get a
6883 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6884 which is the tree that we built on the first call (see
6885 below when coercing to reference to object or to reference to
6886 function). We just strip everything and get to the arg.
6887 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6888 for examples. */
6890 {
6896 {
6897 /* ??? Maybe we could use convert_from_reference here, but we
6898 would need to relax its constraints because the NOP_EXPR
6899 could actually change the type to something more cv-qualified,
6900 and this is not folded by convert_from_reference. */
6905 && (same_type_ignoring_top_level_qualifiers_p
6908 {
6911 }
6912 }
6913 }
6915 /* [temp.arg.nontype]/5, bullet 1
6917 For a non-type template-parameter of integral or enumeration type,
6918 integral promotions (_conv.prom_) and integral conversions
6919 (_conv.integral_) are applied. */
6921 {
6923 {
6928 }
6933 /* Notice that there are constant expressions like '4 % 0' which
6934 do not fold into integer constants. */
6937 {
6939 {
6943 else
6949 /* else cxx_constant_value complained but gave us
6950 a real constant, so go ahead. */
6952 {
6953 /* Some assemble time constant expressions like
6954 (intptr_t)&&lab1 - (intptr_t)&&lab2 or
6955 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
6956 as we can emit them into .rodata initializers of
6957 variables, yet they can't fold into an INTEGER_CST at
6958 compile time. Refuse them here. */
6963 }
6964 }
6965 else
6967 }
6969 /* Avoid typedef problems. */
6972 }
6973 /* [temp.arg.nontype]/5, bullet 2
6975 For a non-type template-parameter of type pointer to object,
6976 qualification conversions (_conv.qual_) and the array-to-pointer
6977 conversion (_conv.array_) are applied. */
6979 {
6982 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6983 decay_conversion or an explicit cast. If it's a problematic cast,
6984 we'll complain about it below. */
6986 {
6991 {
6994 }
6995 }
6997 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6999 A template-argument for a non-type, non-template template-parameter
7000 shall be one of: [...]
7002 -- the name of a non-type template-parameter;
7003 -- the address of an object or function with external linkage, [...]
7004 expressed as "& id-expression" where the & is optional if the name
7005 refers to a function or array, or if the corresponding
7006 template-parameter is a reference.
7008 Here, we do not care about functions, as they are invalid anyway
7009 for a parameter of type pointer-to-object. */
7012 /* Non-type template parameters are OK. */
7013 ;
7018 /* Other values, like integer constants, might be valid
7019 non-type arguments of some other type. */
7029 }
7030 /* [temp.arg.nontype]/5, bullet 3
7032 For a non-type template-parameter of type reference to object, no
7033 conversions apply. The type referred to by the reference may be more
7034 cv-qualified than the (otherwise identical) type of the
7035 template-argument. The template-parameter is bound directly to the
7036 template-argument, which must be an lvalue. */
7038 {
7040 expr_type))
7044 {
7049 }
7052 {
7057 }
7059 /* [temp.arg.nontype]/1
7061 A template-argument for a non-type, non-template template-parameter
7062 shall be one of: [...]
7064 -- the address of an object or function with external linkage. */
7067 {
7070 {
7073 "because a reference variable does not have a constant "
7076 }
7077 }
7081 /* OK, dependent reference. We don't want to ask whether a DECL is
7083 else
7084 {
7089 }
7093 }
7094 /* [temp.arg.nontype]/5, bullet 4
7096 For a non-type template-parameter of type pointer to function, only
7097 the function-to-pointer conversion (_conv.func_) is applied. If the
7098 template-argument represents a set of overloaded functions (or a
7099 pointer to such), the matching function is selected from the set
7100 (_over.over_). */
7102 {
7103 /* If the argument is a template-id, we might not have enough
7104 context information to decay the pointer. */
7106 {
7110 }
7113 /* Null pointer values are OK in C++11. */
7119 }
7120 /* [temp.arg.nontype]/5, bullet 5
7122 For a non-type template-parameter of type reference to function, no
7123 conversions apply. If the template-argument represents a set of
7124 overloaded functions, the matching function is selected from the set
7125 (_over.over_). */
7127 {
7129 {
7131 {
7136 }
7138 }
7143 }
7144 /* [temp.arg.nontype]/5, bullet 6
7146 For a non-type template-parameter of type pointer to member function,
7147 no conversions apply. If the template-argument represents a set of
7148 overloaded member functions, the matching member function is selected
7149 from the set (_over.over_). */
7151 {
7156 /* [temp.arg.nontype] bullet 1 says the pointer to member
7157 expression must be a pointer-to-member constant. */
7162 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
7163 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
7166 }
7167 /* [temp.arg.nontype]/5, bullet 7
7169 For a non-type template-parameter of type pointer to data member,
7170 qualification conversions (_conv.qual_) are applied. */
7172 {
7173 /* [temp.arg.nontype] bullet 1 says the pointer to member
7174 expression must be a pointer-to-member constant. */
7182 }
7184 {
7186 {
7191 }
7193 }
7195 {
7196 /* Replace the argument with a reference to the corresponding template
7197 parameter object. */
7202 }
7203 /* A template non-type parameter must be one of the above. */
7204 else
7207 /* Sanity check: did we actually convert the argument to the
7208 right type? */
7212 }
7214 /* Subroutine of coerce_template_template_parms, which returns 1 if
7215 PARM_PARM and ARG_PARM match using the rule for the template
7216 parameters of template template parameters. Both PARM and ARG are
7217 template parameters; the rest of the arguments are the same as for
7218 coerce_template_template_parms.
7219 */
7220 static int
7222 tree arg,
7223 tsubst_flags_t complain,
7224 tree in_decl,
7225 tree outer_args)
7226 {
7235 {
7237 /* We encounter instantiations of templates like
7238 template <template <template <class> class> class TT>
7239 class C; */
7240 {
7247 }
7248 /* Fall through. */
7253 /* Argument is a parameter pack but parameter is not. */
7258 /* The tsubst call is used to handle cases such as
7260 template <int> class C {};
7261 template <class T, template <T> class TT> class D {};
7262 D<int, C> d;
7264 i.e. the parameter list of TT depends on earlier parameters. */
7266 {
7271 }
7275 /* Argument is a parameter pack but parameter is not. */
7282 }
7285 }
7287 /* Coerce template argument list ARGLIST for use with template
7288 template-parameter TEMPL. */
7290 static tree
7292 tsubst_flags_t complain)
7293 {
7294 /* Consider an example where a template template parameter declared as
7296 template <class T, class U = std::allocator<T> > class TT
7298 The template parameter level of T and U are one level larger than
7299 of TT. To proper process the default argument of U, say when an
7300 instantiation `TT<int>' is seen, we need to build the full
7301 arguments containing {int} as the innermost level. Outer levels,
7302 available when not appearing as default template argument, can be
7303 obtained from the arguments of the enclosing template.
7305 Suppose that TT is later substituted with std::vector. The above
7306 instantiation is `TT<int, std::allocator<T> >' with TT at
7307 level 1, and T at level 2, while the template arguments at level 1
7308 becomes {std::vector} and the inner level 2 is {int}. */
7312 {
7314 /* We want arguments for the partial specialization, not arguments for
7315 the primary template. */
7317 else
7319 }
7321 {
7322 /* This is an argument of the current template, so we haven't set
7323 DECL_CONTEXT yet. */
7324 tree relevant_template_parms;
7326 /* Parameter levels that are greater than the level of the given
7327 template template parm are irrelevant. */
7334 }
7341 complain,
7344 }
7346 /* A cache of template template parameters with match-all default
7347 arguments. */
7349 static void
7351 {
7355 }
7356 static tree
7358 {
7363 }
7365 /* T is a bound template template-parameter. Copy its arguments into default
7366 arguments of the template template-parameter's template parameters. */
7368 static tree
7370 {
7393 {
7396 {
7399 }
7400 }
7404 }
7406 /* ARG is a bound potential template template-argument, and PARGS is a list
7407 of arguments for the corresponding template template-parameter. Adjust
7408 PARGS as appropriate for application to ARG's template, and if ARG is a
7409 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7410 arguments to the template template parameter. */
7412 static tree
7414 {
7418 {
7419 /* When comparing two template template-parameters in partial ordering,
7420 rewrite the one currently being used as an argument to have default
7421 arguments for all parameters. */
7427 }
7428 else
7429 {
7430 tree aparms
7435 }
7438 }
7440 /* Subroutine of unify for the case when PARM is a
7441 BOUND_TEMPLATE_TEMPLATE_PARM. */
7443 static int
7446 {
7450 /* The template template parm might be variadic and the argument
7451 not, so flatten both argument lists. */
7456 {
7457 /* In keeping with P0522R0, adjust P's template arguments
7458 to apply to A's template; then flatten it again. */
7467 /* If the P0522 adjustment eliminated a pack expansion, deduce
7468 empty packs. */
7474 }
7475 else
7476 {
7477 /* Deduce arguments T, i from TT<T> or TT<i>.
7478 We check each element of PARMVEC and ARGVEC individually
7479 rather than the whole TREE_VEC since they can have
7480 different number of elements, which is allowed under N2555. */
7484 /* Check if the parameters end in a pack, making them
7485 variadic. */
7492 /* If the template argument list of P contains a pack
7493 expansion that is not the last template argument, the
7494 entire template argument list is a non-deduced
7495 context. */
7513 DEDUCE_EXACT,
7516 }
7519 }
7521 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7522 template template parameters. Both PARM_PARMS and ARG_PARMS are
7523 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7524 or PARM_DECL.
7526 Consider the example:
7527 template <class T> class A;
7528 template<template <class U> class TT> class B;
7530 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7531 the parameters to A, and OUTER_ARGS contains A. */
7533 static int
7535 tree arg_parms,
7536 tsubst_flags_t complain,
7537 tree in_decl,
7538 tree outer_args)
7539 {
7551 {
7552 /* P0522R0: A template template-parameter P is at least as specialized as
7553 a template template-argument A if, given the following rewrite to two
7554 function templates, the function template corresponding to P is at
7555 least as specialized as the function template corresponding to A
7556 according to the partial ordering rules for function templates
7557 ([temp.func.order]). Given an invented class template X with the
7558 template parameter list of A (including default arguments):
7560 * Each of the two function templates has the same template parameters,
7561 respectively, as P or A.
7563 * Each function template has a single function parameter whose type is
7564 a specialization of X with template arguments corresponding to the
7565 template parameters from the respective function template where, for
7566 each template parameter PP in the template parameter list of the
7567 function template, a corresponding template argument AA is formed. If
7568 PP declares a parameter pack, then AA is the pack expansion
7569 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7571 If the rewrite produces an invalid type, then P is not at least as
7572 specialized as A. */
7574 /* So coerce P's args to apply to A's parms, and then deduce between A's
7575 args and the converted args. If that succeeds, A is at least as
7576 specialized as P, so they match.*/
7584 {
7590 }
7591 }
7593 /* Determine whether we have a parameter pack at the end of the
7594 template template parameter's template parameter list. */
7596 {
7603 {
7617 }
7618 }
7624 /* Check all of the template parameters except the parameter pack at
7625 the end (if any). */
7627 {
7636 outer_args))
7639 }
7642 {
7643 /* Check each of the template parameters in the template
7644 argument against the template parameter pack at the end of
7645 the template template parameter. */
7652 {
7659 outer_args))
7661 }
7662 }
7665 }
7667 /* Verifies that the deduced template arguments (in TARGS) for the
7668 template template parameters (in TPARMS) represent valid bindings,
7669 by comparing the template parameter list of each template argument
7670 to the template parameter list of its corresponding template
7671 template parameter, in accordance with DR150. This
7672 routine can only be called after all template arguments have been
7673 deduced. It will return TRUE if all of the template template
7674 parameter bindings are okay, FALSE otherwise. */
7675 bool
7677 {
7681 /* We're dealing with template parms in this process. */
7687 {
7692 {
7697 {
7698 /* Look inside the argument pack. */
7701 }
7704 {
7708 /* Extract the next argument from the argument
7709 pack. */
7713 /* Look at the pattern of the pack expansion. */
7716 /* Extract the template parameters from the template
7717 argument. */
7723 /* Verify that we can coerce the template template
7724 parameters from the template argument to the template
7725 parameter. This requires an exact match. */
7727 && !coerce_template_template_parms
7729 targ_parms,
7730 tf_none,
7731 tparm,
7732 targs))
7733 {
7736 }
7737 }
7738 }
7739 }
7741 out:
7745 }
7747 /* Since type attributes aren't mangled, we need to strip them from
7748 template type arguments. */
7750 static tree
7752 {
7762 }
7764 /* And from inside dependent non-type arguments like sizeof(Type). */
7766 static tree
7768 {
7778 }
7780 // A template declaration can be substituted for a constrained
7781 // template template parameter only when the argument is more
7782 // constrained than the parameter.
7783 static bool
7785 {
7788 /* For now, allow constrained template template arguments
7789 and unconstrained template template parameters. */
7795 // If the template parameter is constrained, we need to rewrite its
7796 // constraints in terms of the ARG's template parameters. This ensures
7797 // that all of the template parameter types will have the same depth.
7798 //
7799 // Note that this is only valid when coerce_template_template_parm is
7800 // true for the innermost template parameters of PARM and ARG. In other
7801 // words, because coercion is successful, this conversion will be valid.
7803 {
7810 }
7813 }
7815 // Convert a placeholder argument into a binding to the original
7816 // parameter. The original parameter is saved as the TREE_TYPE of
7817 // ARG.
7820 {
7823 }
7825 /* We can't fully resolve ARG given as a non-type template argument to TYPE,
7826 because one of them is dependent. But we need to represent the
7827 conversion for the benefit of cp_tree_equal. */
7829 static tree
7831 {
7832 /* Auto parms get no conversion. */
7835 /* We don't need or want to add this conversion now if we're going to use the
7836 argument for deduction. */
7848 }
7850 /* Convert the indicated template ARG as necessary to match the
7851 indicated template PARM. Returns the converted ARG, or
7852 error_mark_node if the conversion was unsuccessful. Error and
7853 warning messages are issued under control of COMPLAIN. This
7854 conversion is for the Ith parameter in the parameter list. ARGS is
7855 the full set of template arguments deduced so far. */
7857 static tree
7859 tree arg,
7860 tree args,
7861 tsubst_flags_t complain,
7863 tree in_decl)
7864 {
7865 tree orig_arg;
7866 tree val;
7872 /* Trivially convert placeholders. */
7881 {
7882 /* The template argument was the name of some
7883 member function. That's usually
7884 invalid, but static members are OK. In any
7885 case, grab the underlying fields/functions
7886 and issue an error later if required. */
7889 }
7897 /* When determining whether an argument pack expansion is a template,
7898 look at the pattern. */
7902 /* Deal with an injected-class-name used as a template template arg. */
7904 {
7907 {
7917 }
7918 }
7920 is_tmpl_type =
7936 {
7938 {
7942 }
7945 "to refer to a type member of a template parameter, "
7950 typename_type,
7951 complain);
7954 }
7956 {
7958 {
7960 {
7972 else
7975 }
7976 }
7978 }
7980 {
7982 {
7989 else
7992 }
7994 }
7997 /* We already did the appropriate conversion when packing args. */
8000 {
8002 {
8004 /* The number of argument required is not known yet.
8005 Just accept it for now. */
8007 else
8008 {
8010 tree argparm;
8012 /* Strip alias templates that are equivalent to another
8013 template. */
8019 args))
8020 {
8023 /* TEMPLATE_TEMPLATE_PARM node is preferred over
8024 TEMPLATE_DECL. */
8026 {
8031 }
8032 }
8033 else
8034 {
8036 {
8043 }
8046 }
8048 // Check that the constraints are compatible before allowing the
8049 // substitution.
8052 {
8054 {
8060 }
8062 }
8063 }
8064 }
8065 else
8067 /* We only form one instance of each template specialization.
8068 Therefore, if we use a non-canonical variant (i.e., a
8069 typedef), any future messages referring to the type will use
8070 the typedef, which is confusing if those future uses do not
8071 themselves also use the typedef. */
8074 }
8075 else
8076 {
8081 /* We don't have enough levels of args to do any substitution. This
8084 {
8088 }
8089 else
8100 /* We used to call digest_init here. However, digest_init
8101 will report errors, which we don't want when complain
8102 is zero. More importantly, digest_init will try too
8103 hard to convert things: for example, `0' should not be
8104 converted to pointer type at this point according to
8105 the standard. Accepting this is not merely an
8106 extension, since deciding whether or not these
8107 conversions can occur is part of determining which
8108 function template to call, or whether a given explicit
8109 argument specification is valid. */
8111 else
8112 {
8115 }
8125 {
8126 /* Reject template arguments that are references to built-in
8127 functions with no library fallbacks. */
8136 }
8139 {
8140 /* Strip typedefs from the SCOPE_REF. */
8143 complain);
8146 }
8147 }
8150 }
8152 /* Coerces the remaining template arguments in INNER_ARGS (from
8153 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
8154 Returns the coerced argument pack. PARM_IDX is the position of this
8155 parameter in the template parameter list. ARGS is the original
8156 template argument list. */
8157 static tree
8160 tree args,
8161 tree inner_args,
8163 tree new_args,
8165 tree in_decl,
8166 tsubst_flags_t complain)
8167 {
8170 tree packed_args;
8171 tree argument_pack;
8178 {
8179 /* When the template parameter is a non-type template parameter pack
8180 or template template parameter pack whose type or template
8181 parameters use parameter packs, we know exactly how many arguments
8182 we are looking for. Build a vector of the instantiated decls for
8183 these template parameters in PACKED_PARMS. */
8184 /* We can't use make_pack_expansion here because it would interpret a
8185 _DECL as a use rather than a declaration. */
8199 /* If we're doing a partial instantiation of a member template,
8200 verify that all of the types used for the non-type
8201 template parameter pack are, in fact, valid for non-type
8202 template parameters. */
8205 {
8208 {
8213 }
8214 /* We don't know how many args we have yet, just
8215 use the unconverted ones for now. */
8217 }
8220 }
8221 /* Check if we have a placeholder pack, which indicates we're
8222 in the context of a introduction list. In that case we want
8223 to match this pack to the single placeholder. */
8227 {
8230 }
8231 else
8234 /* Convert the remaining arguments, which will be a part of the
8235 parameter pack "parm". */
8238 {
8244 {
8245 /* Once we've packed as many args as we have types, stop. */
8249 /* We don't know how many args we have yet, just
8250 use the unconverted ones for now. */
8252 else
8254 }
8257 {
8260 }
8261 else
8264 in_decl);
8268 }
8272 {
8277 }
8282 else
8283 {
8286 }
8293 }
8295 /* Returns the number of pack expansions in the template argument vector
8296 ARGS. */
8298 static int
8300 {
8305 {
8309 }
8311 }
8313 /* Convert all template arguments to their appropriate types, and
8314 return a vector containing the innermost resulting template
8315 arguments. If any error occurs, return error_mark_node. Error and
8316 warning messages are issued under control of COMPLAIN.
8318 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
8319 for arguments not specified in ARGS. Otherwise, if
8320 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
8321 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
8322 USE_DEFAULT_ARGS is false, then all arguments must be specified in
8323 ARGS. */
8325 static tree
8327 tree args,
8328 tree in_decl,
8329 tsubst_flags_t complain,
8332 {
8334 tree orig_inner_args;
8335 tree inner_args;
8336 tree new_args;
8337 tree new_inner_args;
8339 /* When used as a boolean value, indicates whether this is a
8340 variadic template parameter list. Since it's an int, we can also
8341 subtract it from nparms to get the number of non-variadic
8342 parameters. */
8347 /* Adjustment to nparms for fixed parameter packs. */
8352 /* Likewise for parameters with default arguments. */
8360 /* Determine if there are any parameter packs or default arguments. */
8362 {
8370 }
8373 /* If there are no parameters that follow a parameter pack, we need to
8374 expand any argument packs so that we can deduce a parameter pack from
8375 some non-packed args followed by an argument pack, as in variadic85.C.
8376 If there are such parameters, we need to leave argument packs intact
8377 so the arguments are assigned properly. This can happen when dealing
8378 with a nested class inside a partial specialization of a class
8379 template, as in variadic92.C, or when deducing a template parameter pack
8380 from a sub-declarator, as in variadic114.C. */
8384 /* Count any pack expansion args. */
8390 && require_all_args
8391 && !variadic_args_p
8392 && (!use_default_args
8395 {
8396 bad_nargs:
8398 {
8400 {
8404 }
8405 else
8412 }
8415 }
8416 /* We can't pass a pack expansion to a non-pack parameter of an alias
8417 template (DR 1430). */
8421 && variadic_args_p
8423 {
8425 {
8427 {
8433 {
8436 "pack expansion argument for non-pack parameter "
8438 else
8440 "pack expansion argument for non-pack parameter "
8444 }
8445 }
8447 found:;
8448 }
8450 }
8452 /* We need to evaluate the template arguments, even though this
8453 template-id may be nested within a "sizeof". */
8454 cp_evaluated ev;
8460 {
8461 tree arg;
8462 tree parm;
8464 /* Get the Ith template parameter. */
8468 {
8471 }
8473 /* Calculate the next argument. */
8476 else
8482 {
8483 /* Some arguments will be placed in the
8484 template parameter pack PARM. */
8491 {
8492 /* We don't know how many args we have yet, just use the
8493 unconverted (and still packed) ones for now. */
8497 }
8501 /* Store this argument. */
8503 {
8504 lost++;
8505 /* We are done with all of the arguments. */
8508 }
8509 else
8510 {
8514 {
8517 }
8518 }
8521 }
8523 {
8525 {
8526 /* "If every valid specialization of a variadic template
8527 requires an empty template parameter pack, the template is
8528 ill-formed, no diagnostic required." So check that the
8529 pattern works with this parameter. */
8534 in_decl);
8536 {
8541 }
8543 /* Recover from missing typename. */
8547 /* We don't know how many args we have yet, just
8548 use the unconverted ones for now. */
8552 }
8553 }
8555 {
8556 /* There must be a default arg in this case. */
8559 /* The position of the first default template argument,
8560 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8561 Record that. */
8565 }
8566 else
8570 {
8573 }
8575 {
8576 /* This can occur if there was an error in the template
8577 parameter list itself (which we would already have
8578 reported) that we are trying to recover from, e.g., a class
8579 template with a parameter list such as
8580 template<typename..., typename> (cpp0x/variadic150.C). */
8583 /* This can also happen with a fixed parameter pack (71834). */
8586 }
8587 else
8593 lost++;
8595 }
8598 {
8599 /* If we had fixed parameter packs, we didn't know how many arguments we
8600 actually needed earlier; now we do. */
8604 }
8607 {
8608 /* We had some pack expansion arguments that will only work if the packs
8609 are empty, but wait until instantiation time to complain.
8610 See variadic-ttp3.C. */
8620 }
8623 {
8626 }
8633 }
8635 /* Convert all template arguments to their appropriate types, and
8636 return a vector containing the innermost resulting template
8637 arguments. If any error occurs, return error_mark_node. Error and
8638 warning messages are not issued.
8640 Note that no function argument deduction is performed, and default
8641 arguments are used to fill in unspecified arguments. */
8642 tree
8644 {
8646 }
8648 /* Convert all template arguments to their appropriate type, and
8649 instantiate default arguments as needed. This returns a vector
8650 containing the innermost resulting template arguments, or
8651 error_mark_node if unsuccessful. */
8652 tree
8654 tsubst_flags_t complain)
8655 {
8657 }
8659 /* Like coerce_template_parms. If PARMS represents all template
8660 parameters levels, this function returns a vector of vectors
8661 representing all the resulting argument levels. Note that in this
8662 case, only the innermost arguments are coerced because the
8663 outermost ones are supposed to have been coerced already.
8665 Otherwise, if PARMS represents only (the innermost) vector of
8666 parameters, this function returns a vector containing just the
8667 innermost resulting arguments. */
8669 static tree
8671 tree args,
8672 tree in_decl,
8673 tsubst_flags_t complain,
8676 {
8679 tree coerced_args;
8682 {
8684 tree level;
8690 {
8691 tree l;
8695 require_all_args,
8696 use_default_args);
8697 else
8704 }
8705 }
8706 else
8709 require_all_args,
8710 use_default_args);
8712 }
8714 /* Returns 1 if template args OT and NT are equivalent. */
8716 int
8718 {
8727 /* For member templates */
8736 {
8753 }
8757 {
8760 /* Don't treat an alias template specialization with dependent
8761 arguments as equivalent to its underlying type when used as a
8762 template argument; we need them to be distinct so that we
8763 substitute into the specialization arguments at instantiation
8764 time. And aliases can't be equivalent without being ==, so
8765 we don't need to look any deeper.
8767 During partial ordering, however, we need to treat them normally so
8768 that we can order uses of the same alias with different
8769 cv-qualification (79960). */
8773 else
8775 }
8778 else
8779 {
8780 /* Try to treat a template non-type argument that has been converted
8781 to the parameter type as equivalent to one that hasn't yet. */
8794 }
8795 }
8797 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8798 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8799 NEWARG_PTR with the offending arguments if they are non-NULL. */
8801 int
8805 {
8818 {
8823 {
8829 }
8830 }
8832 }
8836 {
8838 }
8840 /* Implement a freelist interface for objects of type T.
8842 Head is a separate object, rather than a regular member, so that we
8843 can define it as a GTY deletable pointer, which is highly
8844 desirable. A data member could be declared that way, but then the
8845 containing object would implicitly get GTY((user)), which would
8846 prevent us from instantiating freelists as global objects.
8847 Although this way we can create freelist global objects, they're
8848 such thin wrappers that instantiating temporaries at every use
8849 loses nothing and saves permanent storage for the freelist object.
8851 Member functions next, anew, poison and reinit have default
8852 implementations that work for most of the types we're interested
8853 in, but if they don't work for some type, they should be explicitly
8854 specialized. See the comments before them for requirements, and
8855 the example specializations for the tree_list_freelist. */
8857 class freelist
8858 {
8859 /* Return the next object in a chain. We could just do type
8860 punning, but if we access the object with its underlying type, we
8861 avoid strict-aliasing trouble. This needs only work between
8862 poison and reinit. */
8865 /* Return a newly allocated, uninitialized or minimally-initialized
8866 object of type T. Any initialization performed by anew should
8867 either remain across the life of the object and the execution of
8868 poison, or be redone by reinit. */
8871 /* Optionally scribble all over the bits holding the object, so that
8872 they become (mostly?) uninitialized memory. This is called while
8873 preparing to make the object part of the free list. */
8878 #ifdef ENABLE_GC_CHECKING
8879 /* Poison the data, to indicate the data is garbage. */
8882 #endif
8883 /* Let valgrind know the object is free. */
8886 /* Let valgrind know the next portion of the object is available,
8887 but uninitialized. */
8889 }
8891 /* Bring an object that underwent at least one lifecycle after anew
8892 and before the most recent free and poison, back to a usable
8893 state, reinitializing whatever is needed for it to be
8894 functionally equivalent to an object just allocated and returned
8895 by anew. This may poison or clear the next field, used by
8896 freelist housekeeping after poison was called. */
8900 #ifdef ENABLE_GC_CHECKING
8902 #endif
8903 /* Let valgrind know the entire object is available, but
8904 uninitialized. */
8906 }
8908 /* Reference a GTY-deletable pointer that points to the first object
8909 in the free list proper. */
8912 /* Construct a freelist object chaining objects off of HEAD. */
8915 /* Add OBJ to the free object list. The former head becomes OBJ's
8916 successor. */
8918 {
8922 }
8924 /* Take an object from the free list, if one is available, or
8925 allocate a new one. Objects taken from the free list should be
8926 regarded as filled with garbage, except for bits that are
8927 configured to be preserved across free and alloc. */
8929 {
8931 {
8936 }
8937 else
8939 }
8940 };
8942 /* Explicitly specialize the interfaces for freelist<tree_node>: we
8943 want to allocate a TREE_LIST using the usual interface, and ensure
8944 TREE_CHAIN remains functional. Alas, we have to duplicate a bit of
8945 build_tree_list logic in reinit, so this could go out of sync. */
8949 {
8951 }
8953 inline tree
8955 {
8957 }
8961 {
8967 #ifdef ENABLE_GC_CHECKING
8970 /* Poison the data, to indicate the data is garbage. */
8973 #endif
8974 /* Let valgrind know the object is free. */
8976 /* But we still want to use the TREE_CODE and TREE_CHAIN parts. */
8980 #ifdef ENABLE_GC_CHECKING
8982 /* Keep TREE_CHAIN functional. */
8984 #else
8986 #endif
8987 }
8991 {
8994 #ifdef ENABLE_GC_CHECKING
8998 #endif
9000 /* Let valgrind know the entire object is available, but
9001 uninitialized. */
9004 #ifdef ENABLE_GC_CHECKING
9006 #else
9008 #endif
9009 }
9011 /* Point to the first object in the TREE_LIST freelist. */
9013 /* Return the/an actual TREE_LIST freelist. */
9016 {
9018 }
9020 /* Point to the first object in the tinst_level freelist. */
9022 /* Return the/an actual tinst_level freelist. */
9025 {
9027 }
9029 /* Point to the first object in the pending_template freelist. */
9031 /* Return the/an actual pending_template freelist. */
9034 {
9036 }
9038 /* Build the TREE_LIST object out of a split list, store it
9039 permanently, and return it. */
9040 tree
9042 {
9051 }
9055 /* Increment OBJ's refcount unless it is already infinite. */
9058 {
9062 }
9064 /* Release storage for OBJ and node, if it's a TREE_LIST. */
9065 void
9067 {
9071 }
9073 /* Decrement OBJ's refcount if not infinite. If it reaches zero, release
9074 OBJ's DECL and OBJ, and start over with the tinst_level object that
9075 used to be referenced by OBJ's NEXT. */
9076 static void
9078 {
9082 {
9086 }
9087 }
9089 /* Modify PTR so that it points to OBJ, adjusting the refcounts of OBJ
9090 and of the former PTR. Omitting the second argument is equivalent
9091 to passing (T*)NULL; this is allowed because passing the
9092 zero-valued integral constant NULL confuses type deduction and/or
9093 overload resolution. */
9095 static void
9097 {
9101 }
9103 static void
9105 {
9115 /* We are called both from instantiate_decl, where we've already had a
9116 tinst_level pushed, and instantiate_template, where we haven't.
9117 Compensate. */
9119 level = !current_tinst_level
9131 else
9140 }
9143 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
9144 ARGLIST. Valid choices for FNS are given in the cp-tree.def
9145 documentation for TEMPLATE_ID_EXPR. */
9147 tree
9149 {
9156 {
9159 }
9162 {
9164 unknown_type_node,
9166 arglist);
9168 }
9171 }
9173 /* Within the scope of a template class S<T>, the name S gets bound
9174 (in build_self_reference) to a TYPE_DECL for the class, not a
9175 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
9176 or one of its enclosing classes, and that type is a template,
9177 return the associated TEMPLATE_DECL. Otherwise, the original
9178 DECL is returned.
9180 Also handle the case when DECL is a TREE_LIST of ambiguous
9181 injected-class-names from different bases. */
9183 tree
9185 {
9189 /* DR 176: A lookup that finds an injected-class-name (10.2
9190 [class.member.lookup]) can result in an ambiguity in certain cases
9191 (for example, if it is found in more than one base class). If all of
9192 the injected-class-names that are found refer to specializations of
9193 the same class template, and if the name is followed by a
9194 template-argument-list, the reference refers to the class template
9195 itself and not a specialization thereof, and is not ambiguous. */
9197 {
9200 {
9206 }
9209 else
9211 }
9217 }
9219 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
9220 parameters, find the desired type.
9222 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
9224 IN_DECL, if non-NULL, is the template declaration we are trying to
9225 instantiate.
9227 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
9228 the class we are looking up.
9230 Issue error and warning messages under control of COMPLAIN.
9232 If the template class is really a local class in a template
9233 function, then the FUNCTION_CONTEXT is the function in which it is
9234 being instantiated.
9236 ??? Note that this function is currently called *twice* for each
9237 template-id: the first time from the parser, while creating the
9238 incomplete type (finish_template_type), and the second type during the
9239 real instantiation (instantiate_template_class). This is surely something
9240 that we want to avoid. It also causes some problems with argument
9241 coercion (see convert_nontype_argument for more information on this). */
9243 static tree
9246 {
9248 tree t;
9251 spec_entry elt;
9252 hashval_t hash;
9255 {
9259 else
9260 {
9267 }
9270 }
9272 {
9275 /* If we are declaring a constructor, say A<T>::A<T>, we will get
9276 an implicit typename for the second A. Deal with it. */
9281 {
9284 }
9285 }
9288 {
9291 }
9293 {
9297 }
9299 {
9302 }
9304 /* Issue an error message if we didn't find a template. */
9306 {
9310 }
9313 /* Make sure it's a user visible template, if it was named by
9314 the user. */
9317 {
9319 {
9323 }
9325 }
9329 /* An alias that just changes the name of a template is equivalent to the
9330 other template, so if any of the arguments are pack expansions, strip
9331 the alias to avoid problems with a pack expansion passed to a non-pack
9332 alias template parameter (DR 1430). */
9337 {
9338 tree parm;
9347 }
9348 else
9349 {
9351 tree gen_tmpl;
9352 tree type_decl;
9360 /* An error occurred while building the template TEMPL, and a
9361 diagnostic has most certainly been emitted for that
9362 already. Let's propagate that error. */
9371 {
9372 /* We've been given an incomplete set of template arguments.
9373 For example, given:
9375 template <class T> struct S1 {
9376 template <class U> struct S2 {};
9377 template <class U> struct S2<U*> {};
9378 };
9380 we will be called with an ARGLIST of `U*', but the
9381 TEMPLATE will be `template <class T> template
9382 <class U> struct S1<T>::S2'. We must fill in the missing
9383 arguments. */
9387 }
9389 /* Now we should have enough arguments. */
9392 /* From here on, we're only interested in the most general
9393 template. */
9395 /* Calculate the BOUND_ARGS. These will be the args that are
9396 actually tsubst'd into the definition to create the
9397 instantiation. */
9399 complain,
9404 /* We were unable to bind the arguments. */
9407 /* In the scope of a template class, explicit references to the
9408 template class refer to the type of the template, not any
9409 instantiation of it. For example, in:
9411 template <class T> class C { void f(C<T>); }
9413 the `C<T>' is just the same as `C'. Outside of the
9414 class, however, such a reference is an instantiation. */
9418 {
9423 }
9425 /* If we already have this specialization, return it. */
9435 /* If the the template's constraints are not satisfied,
9436 then we cannot form a valid type.
9438 Note that the check is deferred until after the hash
9439 lookup. This prevents redundant checks on previously
9440 instantiated specializations. */
9442 {
9444 {
9445 auto_diagnostic_group d;
9448 }
9450 }
9454 /* If the deduced arguments are invalid, then the binding
9455 failed. */
9459 complain))
9466 {
9471 }
9475 {
9478 }
9479 else
9488 /* Create the type. */
9490 {
9491 /* The user referred to a specialization of an alias
9492 template represented by GEN_TMPL.
9494 [temp.alias]/2 says:
9496 When a template-id refers to the specialization of an
9497 alias template, it is equivalent to the associated
9498 type obtained by substitution of its
9499 template-arguments for the template-parameters in the
9500 type-id of the alias template. */
9503 /* Note that the call above (by indirectly calling
9504 register_specialization in tsubst_decl) registers the
9505 TYPE_DECL representing the specialization of the alias
9506 template. So next time someone substitutes ARGLIST for
9507 the template parms into the alias template (GEN_TMPL),
9508 she'll get that TYPE_DECL back. */
9512 }
9514 {
9516 {
9527 }
9528 else
9529 {
9530 /* We don't want to call start_enum for this type, since
9531 the values for the enumeration constants may involve
9532 template parameters. And, no one should be interested
9533 in the enumeration constants for such a type. */
9536 }
9540 }
9542 {
9543 /* Lambda closures are regenerated in tsubst_lambda_expr, not
9544 instantiated here. */
9552 /* A local class. Make sure the decl gets registered properly. */
9559 /* This instantiation is another name for the primary
9560 template type. Set the TYPE_CANONICAL field
9561 appropriately. */
9564 /* Some of the template arguments require structural
9565 equality testing, so this template class requires
9566 structural equality testing. */
9568 }
9569 else
9572 /* If we called start_enum or pushtag above, this information
9573 will already be set up. */
9575 {
9582 }
9583 else
9587 {
9593 {
9596 }
9597 }
9601 {
9605 {
9606 tree attributes
9614 }
9615 }
9617 /* Let's consider the explicit specialization of a member
9618 of a class template specialization that is implicitly instantiated,
9619 e.g.:
9620 template<class T>
9621 struct S
9622 {
9623 template<class U> struct M {}; //#0
9624 };
9626 template<>
9627 template<>
9628 struct S<int>::M<char> //#1
9629 {
9630 int i;
9631 };
9632 [temp.expl.spec]/4 says this is valid.
9634 In this case, when we write:
9635 S<int>::M<char> m;
9637 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
9638 the one of #0.
9640 When we encounter #1, we want to store the partial instantiation
9641 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
9643 For all cases other than this "explicit specialization of member of a
9644 class template", we just want to store the most general template into
9645 the CLASSTYPE_TI_TEMPLATE of M.
9647 This case of "explicit specialization of member of a class template"
9648 only happens when:
9649 1/ the enclosing class is an instantiation of, and therefore not
9650 the same as, the context of the most general template, and
9651 2/ we aren't looking at the partial instantiation itself, i.e.
9652 the innermost arguments are not the same as the innermost parms of
9653 the most general template.
9655 So it's only when 1/ and 2/ happens that we want to use the partial
9656 instantiation of the member template in lieu of its most general
9657 template. */
9661 /* the enclosing class must be an instantiation... */
9664 {
9668 tree partial_inst_args =
9675 use_partial_inst_tmpl =
9676 /*...and we must not be looking at the partial instantiation
9677 itself. */
9679 partial_inst_args);
9680 }
9683 /* This case is easy; there are no member templates involved. */
9685 else
9686 {
9687 /* This is a full instantiation of a member template. Find
9688 the partial instantiation of which this is an instance. */
9690 /* Temporarily reduce by one the number of levels in the ARGLIST
9691 so as to avoid comparing the last set of arguments. */
9695 /* FOUND is either a proper class type, or an alias
9696 template specialization. In the later case, it's a
9697 TYPE_DECL, resulting from the substituting of arguments
9698 for parameters in the TYPE_DECL of the alias template
9699 done earlier. So be careful while getting the template
9700 of FOUND. */
9702 ? found
9709 {
9710 /* If this partial instantiation is specialized, we want to
9711 use it for hash table lookup. */
9715 }
9716 }
9718 // Build template info for the new specialization.
9728 /* Note this use of the partial instantiation so we can check it
9729 later in maybe_process_partial_specialization. */
9736 /* Now that the type has been registered on the instantiations
9737 list, we set up the enumerators. Because the enumeration
9738 constants may involve the enumeration type itself, we make
9739 sure to register the type first, and then create the
9740 constants. That way, doing tsubst_expr for the enumeration
9741 constants won't result in recursive calls here; we'll find
9742 the instantiation and exit above. */
9746 /* If the type makes use of template parameters, the
9747 code that generates debugging information will crash. */
9750 /* Possibly limit visibility based on template args. */
9757 }
9758 }
9760 /* Wrapper for lookup_template_class_1. */
9762 tree
9765 {
9766 tree ret;
9772 }
9774 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9776 tree
9778 {
9779 /* The type of the expression is NULL_TREE since the template-id could refer
9780 to an explicit or partial specialization. */
9783 /* Except that concepts are always bool. */
9786 }
9788 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9790 tree
9792 {
9796 /* We never want to return a VAR_DECL for a variable concept, since they
9797 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9812 {
9814 {
9815 auto_diagnostic_group d;
9818 }
9820 }
9822 /* If a template-id refers to a specialization of a variable
9823 concept, then the expression is true if and only if the
9824 concept's constraints are satisfied by the given template
9825 arguments.
9827 NOTE: This is an extension of Concepts Lite TS that
9828 allows constraints to be used in expressions. */
9830 {
9833 }
9836 }
9838 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9839 TARGS template args, and instantiate it if it's not dependent. */
9841 tree
9843 tsubst_flags_t complain)
9844 {
9847 {
9850 }
9853 }
9855 \f
9856 struct pair_fn_data
9857 {
9858 tree_fn_t fn;
9859 tree_fn_t any_fn;
9861 /* True when we should also visit template parameters that occur in
9862 non-deduced contexts. */
9865 };
9867 /* Called from for_each_template_parm via walk_tree. */
9869 static tree
9871 {
9878 #define WALK_SUBTREE(NODE) \
9879 do \
9880 { \
9881 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9882 pfd->include_nondeduced_p, \
9883 pfd->any_fn); \
9884 if (result) goto out; \
9885 } \
9886 while (0)
9896 {
9900 /* Fall through. */
9906 else
9916 /* Since we're not going to walk subtrees, we have to do this
9917 explicitly here. */
9919 /* Fall through. */
9922 /* Check the return type. */
9925 /* Check the parameter types. Since default arguments are not
9926 instantiated until they are needed, the TYPE_ARG_TYPES may
9927 contain expressions that involve template parameters. But,
9928 no-one should be looking at them yet. And, once they're
9929 instantiated, they don't contain template parameters, so
9930 there's no point in looking at them then, either. */
9931 {
9932 tree parm;
9937 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9938 want walk_tree walking into them itself. */
9940 }
9943 {
9947 }
9966 /* Fall through. */
9978 /* Record template parameters such as `T' inside `TT<T>'. */
9980 /* Fall through. */
9992 /* A template template parameter is encountered. */
9996 /* Already substituted template template parameter */
10001 /* A template-id in a TYPENAME_TYPE might be a deduced context after
10002 partial instantiation. */
10014 /* If there's no type, then this thing must be some expression
10015 involving template parameters. */
10037 }
10039 #undef WALK_SUBTREE
10041 /* We didn't find any template parameters we liked. */
10042 out:
10044 }
10046 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
10047 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
10048 call FN with the parameter and the DATA.
10049 If FN returns nonzero, the iteration is terminated, and
10050 for_each_template_parm returns 1. Otherwise, the iteration
10051 continues. If FN never returns a nonzero value, the value
10052 returned by for_each_template_parm is 0. If FN is NULL, it is
10053 considered to be the function which always returns 1.
10055 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
10056 parameters that occur in non-deduced contexts. When false, only
10057 visits those template parameters that can be deduced. */
10059 static tree
10063 tree_fn_t any_fn)
10064 {
10066 tree result;
10068 /* Set up. */
10074 /* Walk the tree. (Conceptually, we would like to walk without
10075 duplicates, but for_each_template_parm_r recursively calls
10076 for_each_template_parm, so we would need to reorganize a fair
10077 bit to use walk_tree_without_duplicates, so we keep our own
10078 visited list.) */
10081 else
10084 for_each_template_parm_r,
10088 /* Clean up. */
10090 {
10093 }
10096 }
10098 /* Returns true if T depends on any template parameter. */
10100 int
10102 {
10132 else
10133 {
10136 }
10141 }
10143 /* Returns true iff current_function_decl is an incompletely instantiated
10144 template. Useful instead of processing_template_decl because the latter
10145 is set to 0 during instantiate_non_dependent_expr. */
10147 bool
10149 {
10158 }
10160 /* Returns true if T depends on any template parameter with level LEVEL. */
10162 bool
10164 {
10167 }
10169 /* Returns true if the signature of DECL depends on any template parameter from
10170 its enclosing class. */
10172 bool
10174 {
10184 template_parm_outer_level,
10194 }
10196 /* Returns TRUE iff INST is an instantiation we don't need to do in an
10197 ill-formed translation unit, i.e. a variable or function that isn't
10198 usable in a constant expression. */
10202 {
10207 }
10209 /* Returns TRUE iff we should refuse to instantiate DECL because it's
10210 neglectable and instantiated from within an erroneous instantiation. */
10212 static bool
10214 {
10225 }
10233 /* We're starting to instantiate D; record the template instantiation context
10234 at LOC for diagnostics and to restore it later. */
10236 static bool
10238 {
10242 {
10243 /* Tell error.c not to try to instantiate any templates. */
10246 "template instantiation depth exceeds maximum of %d"
10248 max_tinst_depth);
10250 }
10252 /* If the current instantiation caused problems, don't let it instantiate
10253 anything else. Do allow deduction substitution and decls usable in
10254 constant expressions. */
10258 /* When not -quiet, dump template instantiations other than functions, since
10259 announce_function will take care of those. */
10280 }
10282 /* We're starting substitution of TMPL<ARGS>; record the template
10283 substitution context for diagnostics and to restore it later. */
10285 static bool
10287 {
10289 }
10291 /* We're starting to instantiate D; record INPUT_LOCATION and the
10292 template instantiation context for diagnostics and to restore it
10293 later. */
10295 bool
10297 {
10299 }
10301 /* Likewise, but record LOC as the program location. */
10303 bool
10305 {
10308 }
10310 /* We're done instantiating this template; return to the instantiation
10311 context. */
10313 void
10315 {
10316 /* Restore the filename and line number stashed away when we started
10317 this instantiation. */
10321 }
10323 /* We're instantiating a deferred template; restore the template
10324 instantiation context in which the instantiation was requested, which
10325 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
10327 static tree
10329 {
10341 }
10343 /* Returns the TINST_LEVEL which gives the original instantiation
10344 context. */
10348 {
10354 }
10356 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
10357 vector of template arguments, as for tsubst.
10359 Returns an appropriate tsubst'd friend declaration. */
10361 static tree
10363 {
10364 tree new_friend;
10369 /* This was a friend declared with an explicit template
10370 argument list, e.g.:
10372 friend void f<>(T);
10374 to indicate that f was a template instantiation, not a new
10375 function declaration. Now, we have to figure out what
10376 instantiation of what template. */
10377 {
10379 tree new_args;
10380 tree tmpl;
10383 /* Friend functions are looked up in the containing namespace scope.
10384 We must enter that scope, to avoid finding member functions of the
10385 current class with same name. */
10400 tsk_none);
10402 }
10406 /* The NEW_FRIEND will look like an instantiation, to the
10407 compiler, but is not an instantiation from the point of view of
10408 the language. For example, we might have had:
10410 template <class T> struct S {
10411 template <class U> friend void f(T, U);
10412 };
10414 Then, in S<int>, template <class U> void f(int, U) is not an
10415 instantiation of anything. */
10421 {
10425 }
10427 /* The mangled name for the NEW_FRIEND is incorrect. The function
10428 is not a template instantiation and should not be mangled like
10429 one. Therefore, we forget the mangling here; we'll recompute it
10430 later if we need it. */
10432 {
10435 }
10438 {
10439 tree old_decl;
10440 tree new_friend_template_info;
10441 tree new_friend_result_template_info;
10442 tree ns;
10445 /* We must save some information from NEW_FRIEND before calling
10446 duplicate decls since that function will free NEW_FRIEND if
10447 possible. */
10449 new_friend_is_defn =
10454 {
10455 /* This declaration is a `primary' template. */
10458 new_friend_result_template_info
10460 }
10461 else
10464 /* Inside pushdecl_namespace_level, we will push into the
10465 current namespace. However, the friend function should go
10466 into the namespace of the template. */
10476 {
10477 /* This new friend declaration matched an existing
10478 declaration. For example, given:
10480 template <class T> void f(T);
10481 template <class U> class C {
10482 template <class T> friend void f(T) {}
10483 };
10485 the friend declaration actually provides the definition
10486 of `f', once C has been instantiated for some type. So,
10487 old_decl will be the out-of-class template declaration,
10488 while new_friend is the in-class definition.
10490 But, if `f' was called before this point, the
10491 instantiation of `f' will have DECL_TI_ARGS corresponding
10492 to `T' but not to `U', references to which might appear
10493 in the definition of `f'. Previously, the most general
10494 template for an instantiation of `f' was the out-of-class
10495 version; now it is the in-class version. Therefore, we
10496 run through all specialization of `f', adding to their
10497 DECL_TI_ARGS appropriately. In particular, they need a
10498 new set of outer arguments, corresponding to the
10499 arguments for this class instantiation.
10501 The same situation can arise with something like this:
10503 friend void f(int);
10504 template <class T> class C {
10505 friend void f(T) {}
10506 };
10508 when `C<int>' is instantiated. Now, `f(int)' is defined
10509 in the class. */
10512 /* On the other hand, if the in-class declaration does
10513 *not* provide a definition, then we don't want to alter
10514 existing definitions. We can just leave everything
10515 alone. */
10516 ;
10517 else
10518 {
10522 /* Overwrite whatever template info was there before, if
10523 any, with the new template information pertaining to
10524 the declaration. */
10528 {
10529 /* We should have called reregister_specialization in
10530 duplicate_decls. */
10535 /* Instantiate it if the global has already been used. */
10539 }
10540 else
10541 {
10542 tree t;
10544 /* Indicate that the old function template is a partial
10545 instantiation. */
10553 /* Reassign any specializations already in the hash table
10554 to the new more general template, and add the
10555 additional template args. */
10559 {
10561 spec_entry elt;
10573 register_specialization
10576 }
10578 }
10579 }
10581 /* The information from NEW_FRIEND has been merged into OLD_DECL
10582 by duplicate_decls. */
10584 }
10585 }
10586 else
10587 {
10591 /* In the code
10592 template <class T> class C {
10593 template <class U> friend void C1<U>::f (); // case 1
10594 friend void C2<T>::f (); // case 2
10595 };
10596 we only need to make sure CONTEXT is a complete type for
10597 case 2. To distinguish between the two cases, we note that
10598 CONTEXT of case 1 remains dependent type after tsubst while
10599 this isn't true for case 2. */
10609 {
10611 /* do_friend adds the TEMPLATE_DECL for any member friend
10612 template even if it isn't a member template, i.e.
10613 template <class T> friend A<T>::f();
10614 Look through it in that case. */
10618 /* Check to see that the declaration is really present, and,
10619 possibly obtain an improved declaration. */
10624 }
10625 }
10628 }
10630 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
10631 template arguments, as for tsubst.
10633 Returns an appropriate tsubst'd friend type or error_mark_node on
10634 failure. */
10636 static tree
10638 {
10639 tree tmpl;
10642 {
10645 }
10650 else
10651 {
10654 }
10661 {
10662 /* The friend template has already been declared. Just
10663 check to see that the declarations match, and install any new
10664 default parameters. We must tsubst the default parameters,
10665 of course. We only need the innermost template parameters
10666 because that is all that redeclare_class_template will look
10667 at. */
10670 {
10678 }
10679 }
10680 else
10681 {
10682 /* The friend template has not already been declared. In this
10683 case, the instantiation of the template class will cause the
10684 injection of this template into the namespace scope. */
10688 {
10689 /* The new TMPL is not an instantiation of anything, so we
10690 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE
10691 for the new type because that is supposed to be the
10692 corresponding template decl, i.e., TMPL. */
10699 /* It is hidden. */
10704 /* Inject this template into the enclosing namspace scope. */
10706 }
10707 }
10711 else
10715 }
10717 /* Returns zero if TYPE cannot be completed later due to circularity.
10718 Otherwise returns one. */
10720 static int
10722 {
10732 else
10734 }
10739 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10740 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10742 static tree
10745 {
10754 {
10761 clauses
10765 else
10767 }
10768 /* If the first attribute argument is an identifier, don't
10769 pass it through tsubst. Attributes like mode, format,
10770 cleanup and several target specific attributes expect it
10771 unmodified. */
10773 {
10774 tree chain
10779 }
10781 {
10782 /* An attribute pack expansion. */
10791 {
10795 }
10797 }
10798 else
10805 }
10807 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10808 unchanged or a new TREE_LIST chain. */
10810 static tree
10813 {
10818 {
10822 }
10826 {
10829 {
10832 {
10838 }
10839 }
10841 }
10844 }
10846 /* Apply any attributes which had to be deferred until instantiation
10847 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10848 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10850 static void
10853 {
10855 tree t;
10862 {
10866 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10867 to our attributes parameter. */
10869 }
10870 else
10871 {
10873 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10874 lookup_template_class_1, and should be preserved. */
10878 }
10882 {
10886 }
10890 {
10895 {
10898 {
10904 }
10905 else
10907 }
10910 }
10911 }
10913 /* Perform (or defer) access check for typedefs that were referenced
10914 from within the template TMPL code.
10915 This is a subroutine of instantiate_decl and instantiate_class_template.
10916 TMPL is the template to consider and TARGS is the list of arguments of
10917 that template. */
10919 static void
10921 {
10922 location_t saved_location;
10933 {
10945 /* Make access check error messages point to the location
10946 of the use of the typedef. */
10950 tf_warning_or_error);
10951 }
10953 }
10955 static tree
10957 {
10959 tree typedecl;
10960 tree pbinfo;
10961 tree base_list;
10963 tree fn_context;
10972 /* Figure out which template is being instantiated. */
10976 /* Mark the type as in the process of being defined. */
10979 /* We may be in the middle of deferred access check. Disable
10980 it now. */
10983 /* Determine what specialization of the original template to
10984 instantiate. */
10989 {
10990 /* This TYPE is actually an instantiation of a partial
10991 specialization. We replace the innermost set of ARGS with
10992 the arguments appropriate for substitution. For example,
10993 given:
10995 template <class T> struct S {};
10996 template <class T> struct S<T*> {};
10998 and supposing that we are instantiating S<int*>, ARGS will
10999 presently be {int*} -- but we need {int}. */
11002 }
11003 else
11004 {
11007 }
11009 /* If the template we're instantiating is incomplete, then clearly
11010 there's nothing we can do. */
11012 {
11013 /* We can try again later. */
11016 }
11018 /* If we've recursively instantiated too many templates, stop. */
11026 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
11031 else
11032 {
11035 }
11036 /* Use #pragma pack from the template context. */
11042 /* Set the input location to the most specialized template definition.
11043 This is needed if tsubsting causes an error. */
11055 {
11058 /* Adjust visibility for template arguments. */
11060 }
11066 /* We should never instantiate a nested class before its enclosing
11067 class; we need to look up the nested class by name before we can
11068 instantiate it, and that lookup should instantiate the enclosing
11069 class. */
11075 {
11076 tree pbase_binfo;
11077 tree pushed_scope;
11080 /* We must enter the scope containing the type, as that is where
11081 the accessibility of types named in dependent bases are
11082 looked up from. */
11085 /* Substitute into each of the bases to determine the actual
11086 basetypes. */
11088 {
11089 tree base;
11095 {
11096 expanded_bases =
11103 }
11106 {
11108 /* Extract the already-expanded base class. */
11110 else
11111 /* Substitute to figure out the base class. */
11113 NULL_TREE);
11121 }
11122 }
11124 /* The list is now in reverse order; correct that. */
11129 }
11130 /* Now call xref_basetypes to set up all the base-class
11131 information. */
11139 /* Now that our base classes are set up, enter the scope of the
11140 class, so that name lookups into base classes, etc. will work
11141 correctly. This is precisely analogous to what we do in
11142 begin_class_definition when defining an ordinary non-template
11143 class, except we also need to push the enclosing classes. */
11146 /* Now members are processed in the order of declaration. */
11149 {
11153 {
11155 {
11157 /* A closure type for a lambda in an NSDMI or default argument.
11158 Ignore it; it will be regenerated when needed. */
11161 /* Build new CLASSTYPE_NESTED_UTDS. */
11163 tree newtag;
11169 /* If the member is a class template, then -- even after
11170 substitution -- there may be dependent types in the
11171 template argument list for the class. We increment
11172 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
11173 that function will assume that no types are dependent
11174 when outside of a template. */
11184 {
11188 /* Unfortunately, lookup_template_class sets
11189 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
11190 instantiation (i.e., for the type of a member
11191 template class nested within a template class.)
11192 This behavior is required for
11193 maybe_process_partial_specialization to work
11194 correctly, but is not accurate in this case;
11195 the TAG is not an instantiation of anything.
11196 (The corresponding TEMPLATE_DECL is an
11197 instantiation, but the TYPE is not.) */
11200 /* Now, we call pushtag to put this NEWTAG into the scope of
11201 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
11202 pushtag calling push_template_decl. We don't have to do
11203 this for enums because it will already have been done in
11204 tsubst_enum. */
11208 }
11209 }
11211 {
11212 tree r;
11221 /* Instantiate members marked with attribute used. */
11227 }
11230 /* A closure type for a lambda in an NSDMI or default argument.
11232 else
11233 {
11234 /* Build new TYPE_FIELDS. */
11236 {
11237 tree condition;
11240 condition =
11250 }
11252 {
11253 tree r;
11257 /* The file and line for this declaration, to
11258 assist in error message reporting. Since we
11259 called push_tinst_level above, we don't need to
11260 restore these. */
11270 {
11271 /* A capture pack became multiple fields. */
11274 }
11277 {
11281 {
11282 /* In [temp.inst]:
11284 [t]he initialization (and any associated
11285 side-effects) of a static data member does
11286 not occur unless the static data member is
11287 itself used in a way that requires the
11288 definition of the static data member to
11289 exist.
11291 Therefore, we do not substitute into the
11292 initialized for the static data member here. */
11293 finish_static_data_member_decl
11299 /* Instantiate members marked with attribute used. */
11302 }
11304 {
11305 /* Determine whether R has a valid type and can be
11306 completed later. If R is invalid, then its type
11307 is replaced by error_mark_node. */
11313 {
11314 /* If R's type couldn't be completed and
11315 it isn't a flexible array member (whose
11316 type is incomplete by definition) give
11317 an error. */
11320 }
11325 {
11328 }
11329 }
11331 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
11332 such a thing will already have been added to the field
11333 list by tsubst_enum in finish_member_declaration in the
11334 CLASSTYPE_NESTED_UTDS case above. */
11338 {
11341 }
11342 }
11343 }
11344 }
11345 }
11346 else
11347 {
11350 {
11351 /* Build new CLASSTYPE_FRIEND_CLASSES. */
11357 {
11358 /* template <class T> friend class C; */
11361 }
11363 {
11364 /* template <class T> friend class C::D; */
11370 }
11373 {
11374 /* This could be either
11376 friend class T::C;
11378 when dependent_type_p is false or
11380 template <class U> friend class T::C;
11382 otherwise. */
11383 /* Bump processing_template_decl in case this is something like
11384 template <class T> friend struct A<T>::B. */
11391 }
11395 {
11396 /* friend class C;
11398 where C hasn't been declared yet. Let's lookup name
11399 from namespace scope directly, bypassing any name that
11400 come from dependent base class. */
11403 /* The call to xref_tag_from_type does injection for friend
11404 classes. */
11406 friend_type =
11410 }
11412 /* friend class C<T>; */
11415 /* Otherwise it's
11417 friend class C;
11419 where C is already declared or
11421 friend class C<int>;
11423 We don't have to do anything in these cases. */
11426 /* Trick make_friend_class into realizing that the friend
11427 we're adding is a template, not an ordinary class. It's
11428 important that we use make_friend_class since it will
11429 perform some error-checking and output cross-reference
11430 information. */
11438 }
11439 else
11440 {
11441 /* Build new DECL_FRIENDLIST. */
11442 tree r;
11444 /* The file and line for this declaration, to
11445 assist in error message reporting. Since we
11446 called push_tinst_level above, we don't need to
11447 restore these. */
11451 {
11454 }
11459 {
11462 }
11463 }
11464 }
11465 }
11468 {
11469 /* Restore these before substituting into the lambda capture
11470 initializers. */
11473 }
11475 /* Set the file and line number information to whatever is given for
11476 the class itself. This puts error messages involving generated
11477 implicit functions at a predictable point, and the same point
11478 that would be used for non-template classes. */
11485 /* We don't instantiate default arguments for member functions. 14.7.1:
11487 The implicit instantiation of a class template specialization causes
11488 the implicit instantiation of the declarations, but not of the
11489 definitions or default arguments, of the class member functions,
11490 member classes, static data members and member templates.... */
11492 /* Some typedefs referenced from within the template code need to be access
11493 checked at template instantiation time, i.e now. These types were
11494 added to the template at parsing time. Let's get those and perform
11495 the access checks then. */
11504 /* The vtable for a template class can be emitted in any translation
11505 unit in which the class is instantiated. When there is no key
11506 method, however, finish_struct_1 will already have added TYPE to
11507 the keyed_classes. */
11512 }
11514 /* Wrapper for instantiate_class_template_1. */
11516 tree
11518 {
11519 tree ret;
11524 }
11526 static tree
11528 {
11529 tree r;
11535 else
11536 {
11543 }
11545 }
11547 /* Given a function parameter pack TMPL_PARM and some function parameters
11548 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
11549 and set *SPEC_P to point at the next point in the list. */
11551 tree
11553 {
11554 /* Collect all of the extra "packed" parameters into an
11555 argument pack. */
11556 tree parmvec;
11566 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
11570 {
11575 }
11577 /* Build the argument packs. */
11582 }
11584 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
11585 NONTYPE_ARGUMENT_PACK. */
11587 static tree
11589 {
11591 }
11593 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
11594 pack expansion with no extra args, 2 if it has extra args, or 0
11595 if it is not a pack expansion. */
11597 static int
11599 {
11601 /* We're being called before this happens in tsubst_pack_expansion. */
11608 /* A decl pack is itself an expansion. */
11615 }
11618 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11620 static tree
11622 {
11629 }
11631 /* This is a subroutine of tsubst_pack_expansion.
11633 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11634 mechanism to store the (non complete list of) arguments of the
11635 substitution and return a non substituted pack expansion, in order
11636 to wait for when we have enough arguments to really perform the
11637 substitution. */
11639 static bool
11643 {
11644 /* If one pack has an expansion and another pack has a normal
11645 argument or if one pack has an empty argument and an another
11646 one hasn't then tsubst_pack_expansion cannot perform the
11647 substitution and need to fall back on the
11648 PACK_EXPANSION_EXTRA mechanism. */
11656 {
11659 parm_pack;
11661 {
11666 /* We can't substitute a pack expansion with extra args into
11667 our pattern. */
11671 else
11673 }
11677 }
11679 }
11681 /* [temp.variadic]/6 says that:
11683 The instantiation of a pack expansion [...]
11684 produces a list E1,E2, ..., En, where N is the number of elements
11685 in the pack expansion parameters.
11687 This subroutine of tsubst_pack_expansion produces one of these Ei.
11689 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11690 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11691 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11692 INDEX is the index 'i' of the element Ei to produce. ARGS,
11693 COMPLAIN, and IN_DECL are the same parameters as for the
11694 tsubst_pack_expansion function.
11696 The function returns the resulting Ei upon successful completion,
11697 or error_mark_node.
11699 Note that this function possibly modifies the ARGS parameter, so
11700 it's the responsibility of the caller to restore it. */
11702 static tree
11704 tree parm_packs,
11706 tree args /* This parm gets
11708 tsubst_flags_t complain,
11709 tree in_decl)
11710 {
11711 tree t;
11714 /* For each parameter pack, change the substitution of the parameter
11715 pack to the ith argument in its argument pack, then expand the
11716 pattern. */
11718 {
11723 ith_elem_is_expansion |=
11726 /* Select the Ith argument from the pack. */
11730 {
11732 {
11737 }
11738 else
11740 }
11741 else
11742 {
11747 {
11749 /* Update the corresponding argument. */
11751 }
11752 else
11753 /* Re-use the ARGUMENT_PACK_SELECT. */
11755 }
11757 }
11759 // Any local specialization bindings arising from this substitution
11760 // cannot be reused for a different INDEX.
11763 /* Substitute into the PATTERN with the (possibly altered)
11764 arguments. */
11766 /* Expanding a fixed parameter pack from
11767 coerce_template_parameter_pack. */
11772 {
11775 else
11778 }
11782 else
11785 /* If the Ith argument pack element is a pack expansion, then
11786 the Ith element resulting from the substituting is going to
11787 be a pack expansion as well. */
11792 }
11794 /* When the unexpanded parameter pack in a fold expression expands to an empty
11795 sequence, the value of the expression is as follows; the program is
11796 ill-formed if the operator is not listed in this table.
11798 && true
11799 || false
11800 , void() */
11802 tree
11804 {
11808 {
11817 }
11823 }
11825 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11826 form an expression that combines the two terms using the
11827 operator of T. */
11829 static tree
11831 {
11835 // Handle compound assignment operators.
11840 {
11848 complain);
11849 }
11850 }
11852 /* Substitute ARGS into the pack of a fold expression T. */
11856 {
11858 }
11860 /* Substitute ARGS into the pack of a fold expression T. */
11864 {
11866 }
11868 /* Expand a PACK of arguments into a grouped as left fold.
11869 Given a pack containing elements A0, A1, ..., An and an
11870 operator @, this builds the expression:
11872 ((A0 @ A1) @ A2) ... @ An
11874 Note that PACK must not be empty.
11876 The operator is defined by the original fold expression T. */
11878 static tree
11880 {
11883 {
11886 }
11888 }
11890 /* Substitute into a unary left fold expression. */
11892 static tree
11894 tree in_decl)
11895 {
11900 {
11904 }
11907 else
11909 }
11911 /* Substitute into a binary left fold expression.
11913 Do ths by building a single (non-empty) vector of argumnts and
11914 building the expression from those elements. */
11916 static tree
11918 tree in_decl)
11919 {
11928 {
11933 }
11941 }
11943 /* Expand a PACK of arguments into a grouped as right fold.
11944 Given a pack containing elementns A0, A1, ..., and an
11945 operator @, this builds the expression:
11947 A0@ ... (An-2 @ (An-1 @ An))
11949 Note that PACK must not be empty.
11951 The operator is defined by the original fold expression T. */
11953 tree
11955 {
11956 // Build the expression.
11960 {
11963 }
11965 }
11967 /* Substitute into a unary right fold expression. */
11969 static tree
11971 tree in_decl)
11972 {
11977 {
11981 }
11984 else
11986 }
11988 /* Substitute into a binary right fold expression.
11990 Do ths by building a single (non-empty) vector of arguments and
11991 building the expression from those elements. */
11993 static tree
11995 tree in_decl)
11996 {
12005 {
12010 }
12019 }
12021 /* Walk through the pattern of a pack expansion, adding everything in
12022 local_specializations to a list. */
12024 struct el_data
12025 {
12027 tree extra;
12028 tsubst_flags_t complain;
12032 };
12033 static tree
12035 {
12041 /* Remember local typedefs (85214). */
12047 {
12049 /* Don't mess with variables declared within the pattern. */
12052 {
12053 /* Maybe pull out the PARM_DECL for a partial instantiation. */
12056 {
12062 }
12064 {
12065 /* Handle lambda capture here, since we aren't doing any
12066 substitution now, and so tsubst_copy won't call
12067 process_outer_var_ref. */
12071 {
12077 {
12078 /* Make a new NONTYPE_ARGUMENT_PACK of the capture
12079 proxies. */
12081 {
12086 }
12088 }
12089 }
12090 }
12091 }
12095 }
12097 }
12098 static tree
12100 {
12104 }
12106 /* Extract any uses of local_specializations from PATTERN and add them to ARGS
12107 for use in PACK_EXPANSION_EXTRA_ARGS. */
12109 tree
12111 {
12117 }
12119 /* Apply any local specializations from PACK_EXPANSION_EXTRA_ARGS and add the
12120 normal template args to ARGS. */
12122 tree
12124 {
12126 {
12128 {
12129 /* The partial instantiation involved local declarations collected in
12130 extract_local_specs; map from the general template to our local
12131 context. */
12137 /* else inst is already a full instantiation of the pack. */
12139 }
12142 }
12144 }
12146 /* Substitute ARGS into T, which is an pack expansion
12147 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
12148 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
12149 (if only a partial substitution could be performed) or
12150 ERROR_MARK_NODE if there was an error. */
12151 tree
12153 tree in_decl)
12154 {
12155 tree pattern;
12160 tree result;
12168 /* Add in any args remembered from an earlier partial instantiation. */
12173 /* Determine the argument packs that will instantiate the parameter
12174 packs used in the expansion expression. While we're at it,
12175 compute the number of arguments to be expanded and make sure it
12176 is consistent. */
12179 {
12186 {
12192 complain);
12193 else
12197 }
12199 {
12201 {
12204 parm_pack);
12206 }
12209 }
12211 {
12212 /* We know we have correct local_specializations if this
12213 expansion is at function scope, or if we're dealing with a
12214 local parameter in a requires expression; for the latter,
12215 tsubst_requires_expr set it up appropriately. */
12218 else
12219 /* We can't rely on local_specializations for a parameter
12220 name used later in a function declaration (such as in a
12221 late-specified return type). Even if it exists, it might
12222 have the wrong value for a recursive call. */
12226 {
12227 /* This parameter pack was used in an unevaluated context. Just
12228 make a dummy decl, since it's only used for its type. */
12233 /* Partial instantiation of the parm_pack, we can't build
12234 up an argument pack yet. */
12236 else
12238 }
12240 /* This argument pack isn't fully instantiated yet. We set this
12241 flag rather than clear arg_pack because we do want to do the
12242 optimization below, and we don't want to substitute directly
12243 into the pattern (as that would expose a NONTYPE_ARGUMENT_PACK
12244 where it isn't expected). */
12246 }
12248 {
12252 }
12253 else
12254 {
12260 }
12267 /* This can only happen if we forget to expand an argument
12268 pack somewhere else. Just return an error, silently. */
12269 {
12273 }
12276 {
12280 /* Don't bother trying to do a partial substitution with
12281 incomplete packs; we'll try again after deduction. */
12289 {
12294 pattern);
12295 else
12297 pattern);
12299 }
12301 /* Keep track of the parameter packs and their corresponding
12302 argument packs. */
12305 }
12306 else
12307 {
12308 /* We can't substitute for this parameter pack. We use a flag as
12309 well as the missing_level counter because function parameter
12310 packs don't have a level. */
12313 }
12314 }
12316 /* If the expansion is just T..., return the matching argument pack, unless
12317 we need to call convert_from_reference on all the elements. This is an
12318 important optimization; see c++/68422. */
12321 {
12324 /* If the argument pack is a single pack expansion, pull it out. */
12329 /* Types need no adjustment, nor does sizeof..., and if we still have
12330 some pack expansion args we won't do anything yet. */
12335 /* Also optimize expression pack expansions if we can tell that the
12336 elements won't have reference type. */
12342 /* Otherwise use the normal path so we get convert_from_reference. */
12343 }
12345 /* We cannot expand this expansion expression, because we don't have
12346 all of the argument packs we need. */
12348 {
12349 /* We got some full packs, but we can't substitute them in until we
12350 have values for all the packs. So remember these until then. */
12356 }
12358 {
12359 /* There were no real arguments, we're just replacing a parameter
12360 pack with another version of itself. Substitute into the
12361 pattern and return a PACK_EXPANSION_*. The caller will need to
12362 deal with that. */
12366 else
12370 }
12375 {
12376 /* We're in a late-specified return type, so create our own local
12377 specializations map; the current map is either NULL or (in the
12378 case of recursive unification) might have bindings that we don't
12379 want to use or alter. */
12382 }
12384 /* For each argument in each argument pack, substitute into the
12385 pattern. */
12389 {
12391 i,
12393 in_decl);
12396 {
12399 }
12400 }
12402 /* Update ARGS to restore the substitution from parameter packs to
12403 their argument packs. */
12405 {
12412 else
12413 {
12421 /* Update the corresponding argument. */
12425 else
12427 }
12428 }
12431 {
12434 }
12436 /* If the dependent pack arguments were such that we end up with only a
12437 single pack expansion again, there's no need to keep it in a TREE_VEC. */
12443 }
12445 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
12446 TMPL. We do this using DECL_PARM_INDEX, which should work even with
12447 parameter packs; all parms generated from a function parameter pack will
12448 have the same DECL_PARM_INDEX. */
12450 tree
12452 {
12454 tree patparm;
12457 {
12463 }
12464 else
12465 {
12470 }
12473 }
12475 /* Make an argument pack out of the TREE_VEC VEC. */
12477 static tree
12479 {
12480 tree pack;
12484 else
12485 {
12488 }
12491 }
12493 /* Return an exact copy of template args T that can be modified
12494 independently. */
12496 static tree
12498 {
12506 {
12511 }
12517 }
12519 /* Substitute ARGS into the vector or list of template arguments T. */
12521 static tree
12523 {
12535 {
12537 tree new_arg;
12542 {
12543 /* Substitute into an expansion expression. */
12547 /* Add to the expanded length adjustment the number of
12548 expanded arguments. We subtract one from this
12549 measurement, because the argument pack expression
12550 itself is already counted as 1 in
12551 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
12552 the argument pack is empty. */
12554 }
12556 {
12557 /* Substitute into each of the arguments. */
12566 else
12571 }
12572 else
12581 }
12586 /* Make space for the expanded arguments coming from template
12587 argument packs. */
12589 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
12590 arguments for a member template.
12591 In that case each TREE_VEC in ORIG_T represents a level of template
12592 arguments, and ORIG_T won't carry any non defaulted argument count.
12593 It will rather be the nested TREE_VECs that will carry one.
12594 In other words, ORIG_T carries a non defaulted argument count only
12595 if it doesn't contain any nested TREE_VEC. */
12597 {
12601 }
12603 {
12607 {
12610 /* Now expand the template argument pack "in place". */
12613 }
12614 else
12615 {
12617 out++;
12618 }
12619 }
12622 }
12624 /* Substitute ARGS into one level PARMS of template parameters. */
12626 static tree
12628 {
12635 {
12643 }
12646 }
12648 /* Return the result of substituting ARGS into the template parameters
12649 given by PARMS. If there are m levels of ARGS and m + n levels of
12650 PARMS, then the result will contain n levels of PARMS. For
12651 example, if PARMS is `template <class T> template <class U>
12652 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
12653 result will be `template <int*, double, class V>'. */
12655 static tree
12657 {
12661 /* When substituting into a template, we must set
12662 PROCESSING_TEMPLATE_DECL as the template parameters may be
12663 dependent if they are based on one-another, and the dependency
12664 predicates are short-circuit outside of templates. */
12671 {
12678 }
12683 }
12685 /* Return the result of substituting ARGS into one template parameter
12686 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
12687 parameter and which TREE_PURPOSE is the default argument of the
12688 template parameter. */
12690 static tree
12692 {
12713 }
12715 /* Substitute the ARGS into the indicated aggregate (or enumeration)
12716 type T. If T is not an aggregate or enumeration type, it is
12717 handled as if by tsubst. IN_DECL is as for tsubst. If
12718 ENTERING_SCOPE is nonzero, T is the context for a template which
12719 we are presently tsubst'ing. Return the substituted value. */
12721 static tree
12723 tree args,
12724 tsubst_flags_t complain,
12725 tree in_decl,
12727 {
12732 {
12737 /* Fall through. */
12741 {
12742 tree argvec;
12743 tree context;
12744 tree r;
12746 /* In "sizeof(X<I>)" we need to evaluate "I". */
12747 cp_evaluated ev;
12749 /* First, determine the context for the type we are looking
12750 up. */
12753 {
12756 /* If context is a nested class inside a class template,
12757 it may still need to be instantiated (c++/33959). */
12759 }
12761 /* Then, figure out what arguments are appropriate for the
12762 type we are trying to find. For example, given:
12764 template <class T> struct S;
12765 template <class T, class U> void f(T, U) { S<U> su; }
12767 and supposing that we are instantiating f<int, double>,
12768 then our ARGS will be {int, double}, but, when looking up
12769 S we only want {double}. */
12774 else
12775 {
12779 }
12782 }
12783 else
12784 /* This is not a template type, so there's nothing to do. */
12789 }
12790 }
12794 /* Substitute into the default argument ARG (a default argument for
12795 FN), which has the indicated TYPE. */
12797 tree
12799 tsubst_flags_t complain)
12800 {
12803 /* This can happen in invalid code. */
12821 /* This default argument came from a template. Instantiate the
12822 default argument here, not in tsubst. In the case of
12823 something like:
12825 template <class T>
12826 struct S {
12827 static T t();
12828 void f(T = t());
12829 };
12831 we must be careful to do name lookup in the scope of S<T>,
12832 rather than in the current class. */
12838 /* The default argument expression may cause implicitly defined
12839 member functions to be synthesized, which will result in garbage
12840 collection. We must treat this situation as if we were within
12841 the body of function so as to avoid collecting live data on the
12842 stack. */
12851 /* Make sure the default argument is reasonable. */
12864 {
12868 }
12871 }
12873 /* Substitute into all the default arguments for FN. */
12875 static void
12877 {
12878 tree arg;
12879 tree tmpl_args;
12883 /* If this function is not yet instantiated, we certainly don't need
12884 its default arguments. */
12887 /* Don't do this again for clones. */
12893 arg;
12899 complain);
12900 }
12902 /* Hash table mapping a FUNCTION_DECL to its dependent explicit-specifier. */
12905 /* Store a pair to EXPLICIT_SPECIFIER_MAP. */
12907 void
12909 {
12914 }
12916 /* Lookup an element in EXPLICIT_SPECIFIER_MAP. */
12918 static tree
12920 {
12922 }
12924 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12926 static tree
12928 tree lambda_fntype)
12929 {
12934 /* Nobody should be tsubst'ing into non-template functions. */
12938 {
12939 /* If T is not dependent, just return it. */
12944 /* Calculate the most general template of which R is a
12945 specialization. */
12948 /* We're substituting a lambda function under tsubst_lambda_expr but not
12949 directly from it; find the matching function we're already inside.
12950 But don't do this if T is a generic lambda with a single level of
12951 template parms, as in that case we're doing a normal instantiation. */
12957 /* Calculate the complete set of arguments used to
12958 specialize R. */
12960 (DECL_TEMPLATE_RESULT
12966 /* Check to see if we already have this specialization. */
12968 {
12972 }
12974 /* We can see more levels of arguments than parameters if
12975 there was a specialization of a member template, like
12976 this:
12978 template <class T> struct S { template <class U> void f(); }
12979 template <> template <class U> void S<int>::f(U);
12981 Here, we'll be substituting into the specialization,
12982 because that's where we can find the code we actually
12983 want to generate, but we'll have enough arguments for
12984 the most general template.
12986 We also deal with the peculiar case:
12988 template <class T> struct S {
12989 template <class U> friend void f();
12990 };
12991 template <class U> void f() {}
12992 template S<int>;
12993 template void f<double>();
12995 Here, the ARGS for the instantiation of will be {int,
12996 double}. But, we only need as many ARGS as there are
12997 levels of template parameters in CODE_PATTERN. We are
12998 careful not to get fooled into reducing the ARGS in
12999 situations like:
13001 template <class T> struct S { template <class U> void f(U); }
13002 template <class T> template <> void S<T>::f(int) {}
13004 which we can spot because the pattern will be a
13005 specialization in this case. */
13012 }
13013 else
13014 {
13015 /* This special case arises when we have something like this:
13017 template <class T> struct S {
13018 friend void f<int>(int, double);
13019 };
13021 Here, the DECL_TI_TEMPLATE for the friend declaration
13022 will be an IDENTIFIER_NODE. We are being called from
13023 tsubst_friend_function, and we want only to create a
13024 new decl (R) with appropriate types so that we can call
13025 determine_specialization. */
13028 }
13045 /* If we hit excessive deduction depth, the type is bogus even if
13046 it isn't error_mark_node, so don't build a decl. */
13050 /* We do NOT check for matching decls pushed separately at this
13051 point, as they may not represent instantiations of this
13052 template, and in any case are considered separate under the
13053 discrete model. */
13057 /* Clear out the mangled name and RTL for the instantiation. */
13060 /* Leave DECL_INITIAL set on deleted instantiations. */
13065 /* Handle explicit(dependent-expr). */
13067 {
13074 }
13076 /* OpenMP UDRs have the only argument a reference to the declared
13077 type. We want to diagnose if the declared type is a reference,
13078 which is invalid, but as references to references are usually
13079 quietly merged, diagnose it here. */
13081 {
13082 tree argtype
13087 "reference type %qT in "
13091 argtype);
13092 }
13095 /* Type-conversion operator. Reconstruct the name, in
13096 case it's the name of one of the template's parameters. */
13106 {
13110 }
13117 /* If this is an instantiation of a function with internal
13118 linkage, we already know what object file linkage will be
13119 assigned to the instantiation. */
13128 /* We'll re-clone as appropriate in instantiate_template. */
13131 /* If we aren't complaining now, return on error before we register
13132 the specialization so that we'll complain eventually. */
13138 /* When instantiating a constrained member, substitute
13139 into the constraints to create a new constraint. */
13142 {
13145 }
13152 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
13153 this in the special friend case mentioned above where
13154 GEN_TMPL is NULL. */
13156 {
13161 tree new_r
13164 /* We instantiated this while substituting into
13165 the type earlier (template/friend54.C). */
13168 /* We're not supposed to instantiate default arguments
13169 until they are called, for a template. But, for a
13170 declaration like:
13172 template <class T> void f ()
13173 { extern void g(int i = T()); }
13175 we should do the substitution when the template is
13176 instantiated. We handle the member function case in
13177 instantiate_class_template since the default arguments
13178 might refer to other members of the class. */
13183 }
13184 else
13187 /* Copy the list of befriending classes. */
13191 {
13195 }
13198 {
13202 /* If this is an instantiation of a member template, clone it.
13203 If it isn't, that'll be handled by
13204 clone_constructors_and_destructors. */
13207 }
13213 /* Possibly limit visibility based on template args. */
13216 {
13220 }
13229 }
13231 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
13233 static tree
13235 tree lambda_fntype)
13236 {
13237 /* We can get here when processing a member function template,
13238 member class template, or template template parameter. */
13241 tree spec;
13242 tree tmpl_args;
13243 tree full_args;
13244 tree r;
13248 {
13249 /* Template template parameter is treated here. */
13253 /* If we get a real template back, return it. This can happen in
13254 the context of most_specialized_partial_spec. */
13257 else
13258 /* The new TEMPLATE_DECL was built in
13259 reduce_template_parm_level. */
13262 }
13265 {
13266 /* We might already have an instance of this template.
13267 The ARGS are for the surrounding class type, so the
13268 full args contain the tsubst'd args for the context,
13269 plus the innermost args from the template decl. */
13273 /* Because this is a template, the arguments will still be
13274 dependent, even after substitution. If
13275 PROCESSING_TEMPLATE_DECL is not set, the dependency
13276 predicates will short-circuit. */
13284 /* If this is a default template template argument,
13285 tsubst might not have changed anything. */
13292 {
13294 /* Type partial instantiations are stored as the type by
13295 lookup_template_class_1, not here as the template. */
13298 }
13299 }
13301 /* Make a new template decl. It will be similar to the
13302 original, but will record the current template arguments.
13303 We also create a new function declaration, which is just
13304 like the old one, but points to this new template, rather
13305 than the old one. */
13310 // Build new template info linking to the original template decl.
13312 {
13315 }
13316 else
13319 /* The template parameters for this new template are all the
13320 template parameters for the old template, except the
13321 outermost level of parameters. */
13324 complain);
13328 {
13329 tree new_type;
13337 /* For a partial specialization, we need to keep pointing to
13338 the primary template. */
13344 }
13345 else
13346 {
13347 tree new_decl;
13351 else
13361 {
13364 }
13365 else
13366 {
13369 }
13370 }
13380 /* Record this non-type partial instantiation. */
13386 }
13388 /* True if FN is the op() for a lambda in an uninstantiated template. */
13390 bool
13392 {
13397 }
13399 /* True if FN is the substitution (via tsubst_lambda_expr) of a function for
13400 which the above is true. */
13402 bool
13404 {
13410 }
13412 /* We're instantiating a variable from template function TCTX. Return the
13413 corresponding current enclosing scope. This gets complicated because lambda
13414 functions in templates are regenerated rather than instantiated, but generic
13415 lambda functions are subsequently instantiated. */
13417 static tree
13419 {
13429 {
13440 {
13444 }
13448 }
13450 }
13452 /* Substitute the ARGS into the T, which is a _DECL. Return the
13453 result of the substitution. Issue error and warning messages under
13454 control of COMPLAIN. */
13456 static tree
13458 {
13459 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13460 location_t saved_loc;
13465 /* Set the filename and linenumber to improve error-reporting. */
13470 {
13480 {
13488 {
13489 /* If there is a local specialization that isn't a
13490 parameter pack, it means that we're doing a "simple"
13491 substitution from inside tsubst_pack_expansion. Just
13492 return the local specialization (which will be a single
13493 parm). */
13500 /* Expand the TYPE_PACK_EXPANSION that provides the types for
13501 the parameters in this function parameter pack. */
13505 {
13508 /* Zero-length parameter packs are boring. Just substitute
13509 into the chain. */
13513 }
13514 else
13515 {
13516 /* All we did was update the type. Make a note of that. */
13519 }
13520 }
13522 /* Loop through all of the parameters we'll build. When T is
13523 a function parameter pack, LEN is the number of expanded
13524 types in EXPANDED_TYPES; otherwise, LEN is 1. */
13527 {
13534 /* We're on the Ith parameter of the function parameter
13535 pack. */
13536 {
13537 /* Get the Ith type. */
13540 /* Rename the parameter to include the index. */
13543 }
13545 /* We're dealing with a normal parameter. */
13553 {
13556 else
13559 }
13569 /* Keep track of the first new parameter we
13570 generate. That's what will be returned to the
13571 caller. */
13575 /* Build a proper chain of parameters when substituting
13576 into a function parameter pack. */
13579 }
13581 /* If cp_unevaluated_operand is set, we're just looking for a
13582 single dummy parameter, so don't keep going. */
13587 /* FIRST_R contains the start of the chain we've built. */
13589 }
13593 {
13600 {
13601 /* This field is a lambda capture pack. Return a TREE_VEC of
13602 the expanded fields to instantiate_class_template_1. */
13606 {
13609 }
13610 else
13611 {
13612 /* All we did was update the type. Make a note of that. */
13615 }
13616 }
13619 {
13622 {
13626 }
13636 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
13637 number of bits. */
13643 {
13644 /* Set up DECL_TEMPLATE_INFO so that we can get at the
13645 NSDMI in perform_member_init. Still set DECL_INITIAL
13646 so that we know there is one. */
13651 }
13652 /* We don't have to set DECL_CONTEXT here; it is set by
13653 finish_member_declaration. */
13661 }
13665 }
13669 /* We reach here only for member using decls. We also need to check
13670 uses_template_parms because DECL_DEPENDENT_P is not set for a
13671 using-declaration that designates a member of the current
13672 instantiation (c++/53549). */
13675 {
13679 {
13684 {
13688 {
13691 }
13692 else
13693 {
13696 }
13698 }
13699 }
13700 else
13701 {
13707 else
13708 {
13711 }
13712 }
13713 }
13714 else
13715 {
13718 }
13723 {
13726 tree spec;
13728 tree ctx;
13737 {
13738 /* If this is the canonical decl, we don't have to
13739 mess with instantiations, and often we can't (for
13740 typename, template type parms and such). Note that
13741 TYPE_NAME is not correct for the above test if
13742 we've copied the type for a typedef. */
13748 }
13750 /* Check to see if we already have the specialization we
13751 need. */
13754 {
13755 /* T is a static data member or namespace-scope entity.
13756 We have to substitute into namespace-scope variables
13757 (not just variable templates) because of cases like:
13759 template <class T> void f() { extern T t; }
13761 where the entity referenced is not known until
13762 instantiation time. */
13766 {
13768 complain,
13770 /* If CTX is unchanged, then T is in fact the
13771 specialization we want. That situation occurs when
13772 referencing a static data member within in its own
13773 class. We can use pointer equality, rather than
13774 same_type_p, because DECL_CONTEXT is always
13775 canonical... */
13777 /* ... unless T is a member template; in which
13778 case our caller can be willing to create a
13779 specialization of that template represented
13780 by T. */
13784 }
13787 {
13792 argvec = (coerce_innermost_template_parms
13800 }
13801 }
13802 else
13803 {
13804 /* A local variable. */
13806 /* Subsequent calls to pushdecl will fill this in. */
13808 /* Unless this is a reference to a static variable from an
13809 enclosing function, in which case we need to fill it in now. */
13811 {
13815 }
13817 }
13818 /* If we already have the specialization we need, there is
13819 nothing more to do. */
13821 {
13824 }
13826 /* Create a new node for the specialization we need. */
13828 {
13831 else
13839 {
13840 /* Mask off any template args past the variable's context so we
13841 don't replace the auto with an unrelated argument. */
13845 /* This should never happen with the new lambda instantiation
13846 model, but keep the handling just in case. */
13849 }
13851 /* Substituting the type might have recursively instantiated this
13852 same alias (c++/86171). */
13855 {
13858 }
13859 }
13862 {
13868 {
13869 /* It may seem that this case cannot occur, since:
13871 typedef void f();
13872 void g() { f x; }
13874 declares a function, not a variable. However:
13876 typedef void f();
13877 template <typename T> void g() { T t; }
13878 template void g<f>();
13880 is an attempt to declare a variable with function
13881 type. */
13883 /* R is not yet sufficiently initialized, so we
13884 just use its name. */
13887 }
13889 /* Wait until cp_finish_decl to set this again, to handle
13890 circular dependency (template/instantiate6.C). */
13895 {
13900 {
13903 }
13905 }
13909 }
13915 /* Clear out the mangled name and RTL for the instantiation. */
13919 /* The initializer must not be expanded until it is required;
13920 see [temp.inst]. */
13924 {
13930 /* Possibly limit visibility based on template args. */
13933 {
13937 }
13939 }
13942 {
13943 /* A static data member declaration is always marked
13944 external when it is declared in-class, even if an
13945 initializer is present. We mimic the non-template
13946 processing here. */
13955 }
13956 else
13957 {
13962 }
13970 /* Preserve a typedef that names a type. */
13972 {
13976 /* An alias template specialization can be dependent
13977 even if its underlying type is not. */
13979 }
13982 }
13987 }
13988 #undef RETURN
13990 out:
13991 /* Restore the file and line information. */
13995 }
13997 /* Substitute into the ARG_TYPES of a function type.
13998 If END is a TREE_CHAIN, leave it and any following types
13999 un-substituted. */
14001 static tree
14003 tree args,
14004 tree end,
14005 tsubst_flags_t complain,
14006 tree in_decl)
14007 {
14008 tree remaining_arg_types;
14012 tree default_arg;
14023 {
14024 /* For a pack expansion, perform substitution on the
14025 entire expression. Later on, we'll handle the arguments
14026 one-by-one. */
14031 /* So that we'll spin through the parameters, one by one. */
14033 else
14034 {
14035 /* We only partially substituted into the parameter
14036 pack. Our type is TYPE_PACK_EXPANSION. */
14039 }
14040 }
14053 {
14055 {
14059 }
14061 }
14062 /* DR 657. */
14066 /* Do array-to-pointer, function-to-pointer conversion, and ignore
14067 top-level qualifiers as required. */
14070 /* We do not substitute into default arguments here. The standard
14071 mandates that they be instantiated only when needed, which is
14072 done in build_over_call. */
14075 /* Except that we do substitute default arguments under tsubst_lambda_expr,
14076 since the new op() won't have any associated template arguments for us
14077 to refer to later. */
14083 {
14084 /* We've instantiated a template before its default arguments
14085 have been parsed. This can happen for a nested template
14086 class, and is not an error unless we require the default
14087 argument in a call of this function. */
14088 remaining_arg_types =
14091 }
14092 else
14093 remaining_arg_types =
14095 }
14098 }
14100 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
14101 *not* handle the exception-specification for FNTYPE, because the
14102 initial substitution of explicitly provided template parameters
14103 during argument deduction forbids substitution into the
14104 exception-specification:
14106 [temp.deduct]
14108 All references in the function type of the function template to the
14109 corresponding template parameters are replaced by the specified tem-
14110 plate argument values. If a substitution in a template parameter or
14111 in the function type of the function template results in an invalid
14112 type, type deduction fails. [Note: The equivalent substitution in
14113 exception specifications is done only when the function is instanti-
14114 ated, at which point a program is ill-formed if the substitution
14115 results in an invalid type.] */
14117 static tree
14119 tree args,
14120 tsubst_flags_t complain,
14121 tree in_decl)
14122 {
14123 tree return_type;
14125 tree fntype;
14127 /* The TYPE_CONTEXT is not used for function/method types. */
14130 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
14131 failure. */
14135 {
14136 /* Substitute the argument types. */
14148 {
14149 /* DR 1207: 'this' is in scope in the trailing return type. */
14151 }
14153 /* Substitute the return type. */
14157 {
14160 }
14161 }
14162 else
14163 /* Substitute the return type. */
14168 /* DR 486 clarifies that creation of a function type with an
14169 invalid return type is a deduction failure. */
14172 {
14174 {
14177 else
14179 }
14181 }
14182 /* And DR 657. */
14187 {
14188 /* Substitute the argument types. */
14193 }
14195 /* Construct a new type node and return it. */
14197 {
14200 }
14201 else
14202 {
14204 /* Don't pick up extra function qualifiers from the basetype. */
14207 {
14208 /* [temp.deduct]
14210 Type deduction may fail for any of the following
14211 reasons:
14213 -- Attempting to create "pointer to member of T" when T
14214 is not a class type. */
14217 r);
14219 }
14223 }
14226 /* See comment above. */
14232 }
14234 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
14235 ARGS into that specification, and return the substituted
14236 specification. If there is no specification, return NULL_TREE. */
14238 static tree
14240 tree args,
14241 tsubst_flags_t complain,
14242 tree in_decl,
14244 {
14245 tree specs;
14246 tree new_specs;
14251 {
14252 /* A noexcept-specifier. */
14257 {
14258 /* Defer instantiation of noexcept-specifiers to avoid
14259 excessive instantiations (c++/49107). */
14262 {
14263 /* We already partially instantiated this member template,
14264 so combine the new args with the old. */
14269 }
14270 else
14271 {
14274 }
14275 }
14276 else
14277 {
14279 {
14281 args);
14283 }
14284 new_specs = tsubst_copy_and_build
14287 }
14289 }
14291 {
14294 else
14296 {
14297 tree spec;
14302 {
14303 /* Expand the pack expansion type. */
14306 in_decl);
14312 else
14313 {
14314 /* We're substituting into a member template, so
14315 we got a TYPE_PACK_EXPANSION back. Add that
14316 expansion and move on. */
14320 expanded_specs,
14321 complain);
14324 }
14325 }
14328 {
14331 else
14336 complain);
14337 }
14340 }
14341 }
14343 }
14345 /* Take the tree structure T and replace template parameters used
14346 therein with the argument vector ARGS. IN_DECL is an associated
14347 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
14348 Issue error and warning messages under control of COMPLAIN. Note
14349 that we must be relatively non-tolerant of extensions here, in
14350 order to preserve conformance; if we allow substitutions that
14351 should not be allowed, we may allow argument deductions that should
14352 not succeed, and therefore report ambiguous overload situations
14353 where there are none. In theory, we could allow the substitution,
14354 but indicate that it should have failed, and allow our caller to
14355 make sure that the right thing happens, but we don't try to do this
14356 yet.
14358 This function is used for dealing with types, decls and the like;
14359 for expressions, use tsubst_expr or tsubst_copy. */
14361 tree
14363 {
14386 else
14391 /* Reuse typedefs. We need to do this to handle dependent attributes,
14392 such as attribute aligned. */
14395 {
14399 {
14400 /* DECL represents an alias template and we want to
14401 instantiate it. */
14405 }
14409 {
14413 }
14418 else
14419 /* The typedef is from a non-template context. */
14423 {
14425 r = cp_build_qualified_type_real
14429 }
14430 else
14431 {
14432 /* We don't have an instantiation yet, so drop the typedef. */
14437 }
14438 }
14455 {
14481 {
14487 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
14488 needed. */
14494 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
14495 with TREE_SIDE_EFFECTS that indicates this is not an integral
14496 constant expression. */
14499 {
14502 }
14505 }
14511 {
14517 /* Early in template argument deduction substitution, we don't
14518 want to reduce the level of 'auto', or it will be confused
14519 with a normal template parm in subsequent deduction. */
14531 {
14534 /* See through ARGUMENT_PACK_SELECT arguments. */
14537 }
14542 {
14544 /* If ARG is an argument pack, we don't actually want to
14545 perform a substitution here, because substitutions
14546 for argument packs are only done
14547 element-by-element. We can get to this point when
14548 substituting the type of a non-type template
14549 parameter pack, when that type actually contains
14550 template parameter packs from an outer template, e.g.,
14552 template<typename... Types> struct A {
14553 template<Types... Values> struct B { };
14554 }; */
14558 {
14564 return cp_build_qualified_type_real
14566 }
14568 {
14569 /* We are processing a type constructed from a
14570 template template parameter. */
14581 /* Consider this code:
14583 template <template <class> class Template>
14584 struct Internal {
14585 template <class Arg> using Bind = Template<Arg>;
14586 };
14588 template <template <class> class Template, class Arg>
14589 using Instantiate = Template<Arg>; //#0
14591 template <template <class> class Template,
14592 class Argument>
14593 using Bind =
14594 Instantiate<Internal<Template>::template Bind,
14595 Argument>; //#1
14597 When #1 is parsed, the
14598 BOUND_TEMPLATE_TEMPLATE_PARM representing the
14599 parameter `Template' in #0 matches the
14600 UNBOUND_CLASS_TEMPLATE representing the argument
14601 `Internal<Template>::template Bind'; We then want
14602 to assemble the type `Bind<Argument>' that can't
14603 be fully created right now, because
14604 `Internal<Template>' not being complete, the Bind
14605 template cannot be looked up in that context. So
14606 we need to "store" `Bind<Argument>' for later
14607 when the context of Bind becomes complete. Let's
14608 store that in a TYPENAME_TYPE. */
14612 argvec),
14613 typename_type,
14614 complain);
14616 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
14617 are resolving nested-types in the signature of a
14618 member function templates. Otherwise ARG is a
14619 TEMPLATE_DECL and is the real template to be
14620 instantiated. */
14628 complain);
14629 return cp_build_qualified_type_real
14631 }
14634 else
14635 /* TEMPLATE_PARM_INDEX. */
14637 }
14640 /* This can happen during the attempted tsubst'ing in
14641 unify. This means that we don't yet have any information
14642 about the template parameter in question. */
14645 /* If we get here, we must have been looking at a parm for a
14646 more deeply nested template. Make a new version of this
14647 template parameter, but with a lower level. */
14649 {
14654 {
14656 r = cp_build_qualified_type_real
14660 }
14667 /* Break infinite recursion when substituting the constraints
14676 /* Cache the simple case of lowering a type parameter. */
14678 else
14679 {
14690 {
14691 /* Propagate constraints on placeholders. */
14696 {
14699 }
14700 }
14703 /* We have reduced the level of the template
14704 template parameter, but not the levels of its
14705 template parameters, so canonical_type_parameter
14706 will not be able to find the canonical template
14707 template parameter for this level. Thus, we
14708 require structural equality checking to compare
14709 TEMPLATE_TEMPLATE_PARMs. */
14713 else
14717 {
14719 /* We might need to substitute into the types of non-type
14720 template parameters. */
14732 }
14733 }
14737 /* OK, now substitute the type of the non-type parameter. We
14738 couldn't do it earlier because it might be an auto parameter,
14739 and we wouldn't need to if we had an argument. */
14748 }
14751 }
14754 {
14762 {
14766 }
14769 {
14773 }
14776 {
14780 }
14786 }
14789 /* We should never be tsubsting a binfo. */
14793 /* A vector of template arguments. */
14799 {
14803 /* [temp.deduct]
14805 Type deduction may fail for any of the following
14806 reasons:
14808 -- Attempting to create a pointer to reference type.
14809 -- Attempting to create a reference to a reference type or
14810 a reference to void.
14812 Core issue 106 says that creating a reference to a reference
14813 during instantiation is no longer a cause for failure. We
14814 only enforce this check in strict C++98 mode. */
14818 {
14821 /* We keep track of the last time we issued this error
14822 message to avoid spewing a ton of messages during a
14823 single bad template instantiation. */
14826 {
14831 else
14834 }
14837 }
14841 {
14843 {
14846 type);
14847 else
14849 type);
14850 }
14852 }
14854 {
14858 }
14860 /* In C++0x, during template argument substitution, when there is an
14861 attempt to create a reference to a reference type, reference
14862 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14864 "If a template-argument for a template-parameter T names a type
14865 that is a reference to a type A, an attempt to create the type
14866 'lvalue reference to cv T' creates the type 'lvalue reference to
14867 A,' while an attempt to create the type type rvalue reference to
14868 cv T' creates the type T"
14869 */
14870 r = cp_build_reference_type
14873 else
14878 /* Will this ever be needed for TYPE_..._TO values? */
14882 }
14884 {
14887 {
14888 /* [temp.deduct]
14890 Type deduction may fail for any of the following
14891 reasons:
14893 -- Attempting to create "pointer to member of T" when T
14894 is not a class type. */
14898 }
14900 {
14904 }
14906 {
14910 }
14913 {
14914 /* The type of the implicit object parameter gets its
14915 cv-qualifiers from the FUNCTION_TYPE. */
14916 tree memptr;
14917 tree method_type
14922 complain);
14923 }
14924 else
14927 complain);
14928 }
14931 {
14932 tree fntype;
14933 tree specs;
14938 /* Substitute the exception specification. */
14946 }
14948 {
14953 /* As an optimization, we avoid regenerating the array type if
14954 it will obviously be the same as T. */
14958 /* These checks should match the ones in create_array_type_for_decl.
14960 [temp.deduct]
14962 The deduction may fail for any of the following reasons:
14964 -- Attempting to create an array with an element type that
14965 is void, a function type, or a reference type, or [DR337]
14966 an abstract class type. */
14972 {
14976 }
14988 {
14991 }
14994 }
14997 {
15000 {
15006 {
15011 }
15013 }
15014 else
15026 {
15030 }
15032 {
15033 /* Normally, make_typename_type does not require that the CTX
15034 have complete type in order to allow things like:
15036 template <class T> struct S { typename S<T>::X Y; };
15038 But, such constructs have already been resolved by this
15039 point, so here CTX really should have complete type, unless
15040 it's a partial instantiation. */
15043 {
15047 }
15048 }
15055 {
15058 }
15061 {
15063 {
15067 else
15069 }
15071 {
15075 else
15077 }
15078 }
15080 return cp_build_qualified_type_real
15082 }
15085 {
15097 }
15100 {
15101 tree type;
15117 complain);
15118 }
15121 {
15122 tree type;
15133 {
15135 {
15139 }
15142 }
15153 else
15154 {
15158 /* In a template ~id could be either a complement expression
15159 or an unqualified-id naming a destructor; if instantiating
15160 it produces an expression, it's not an id-expression or
15161 member access. */
15164 }
15169 }
15172 {
15176 }
15180 {
15181 tree r;
15185 else
15193 }
15208 /* We should use one of the expression tsubsts for these codes. */
15214 }
15215 }
15217 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
15218 expression on the left-hand side of the "." or "->" operator. We
15219 only do the lookup if we had a dependent BASELINK. Otherwise we
15220 adjust it onto the instantiated heirarchy. */
15222 static tree
15225 {
15237 {
15244 }
15251 {
15257 /* Treat as-if non-dependent below. */
15262 {
15268 }
15272 }
15273 else
15274 /* We're going to overwrite pieces below, make a duplicate. */
15277 /* If lookup found a single function, mark it as used at this point.
15278 (If lookup found multiple functions the one selected later by
15279 overload resolution will be marked as used at that point.) */
15281 {
15287 /* We might have instantiated an auto function. */
15289 }
15292 {
15293 /* Add back the template arguments, if present. */
15298 /* Update the conversion operator type. */
15300 }
15306 {
15308 qualifying_scope,
15309 object_type);
15311 /* We need to call adjust_result_of_qualified_name_lookup in case the
15312 destructor names a base class, but we unset BASELINK_QUALIFIED_P
15313 so that we still get virtual function binding. */
15315 }
15318 }
15320 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
15321 true if the qualified-id will be a postfix-expression in-and-of
15322 itself; false if more of the postfix-expression follows the
15323 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
15324 of "&". */
15326 static tree
15330 {
15331 tree expr;
15332 tree scope;
15333 tree name;
15335 tree template_args;
15340 /* Figure out what name to look up. */
15343 {
15353 }
15354 else
15355 {
15358 }
15360 /* Substitute into the qualifying scope. When there are no ARGS, we
15361 are just trying to simplify a non-dependent expression. In that
15362 case the qualifying scope may be dependent, and, in any case,
15363 substituting will not help. */
15366 {
15369 }
15370 else
15374 {
15381 }
15384 {
15386 {
15387 /* A BIT_NOT_EXPR is used to represent a destructor. */
15389 {
15393 }
15394 else
15397 }
15398 else
15402 {
15404 {
15408 }
15410 }
15411 }
15414 {
15416 scope);
15417 /* Remember that there was a reference to this entity. */
15420 }
15423 {
15429 }
15432 {
15433 /* We may be repeating a check already done during parsing, but
15434 if it was well-formed and passed then, it will pass again
15435 now, and if it didn't, we wouldn't have got here. The case
15436 we want to catch is when we couldn't tell then, and can now,
15437 namely when templ prior to substitution was an
15438 identifier. */
15444 complain);
15445 else
15447 }
15453 {
15454 expr = (adjust_result_of_qualified_name_lookup
15456 expr = (finish_qualified_id_expr
15460 }
15462 /* Expressions do not generally have reference type. */
15464 /* However, if we're about to form a pointer-to-member, we just
15465 want the referenced member referenced. */
15473 }
15475 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
15476 initializer, DECL is the substituted VAR_DECL. Other arguments are as
15477 for tsubst. */
15479 static tree
15482 {
15491 {
15493 {
15495 {
15500 }
15501 }
15503 {
15504 /* If we had an initializer but it
15505 instantiated to nothing,
15506 value-initialize the object. This will
15507 only occur when the initializer was a
15508 pack expansion where the parameter packs
15509 used in that expansion were of length
15510 zero. */
15516 }
15517 }
15520 }
15522 /* Like tsubst, but deals with expressions. This function just replaces
15523 template parms; to finish processing the resultant expression, use
15524 tsubst_copy_and_build or tsubst_expr. */
15526 static tree
15528 {
15530 tree r;
15538 {
15543 {
15544 /* We get here for a use of 'this' in an NSDMI. */
15548 /* This can happen for a parameter name used later in a function
15549 declaration (such as in a late-specified return type). Just
15550 make a dummy decl, since it's only used for its type. */
15553 /* Give it the template pattern as its context; its true context
15554 hasn't been instantiated yet and this is good enough for
15555 mangling. */
15557 }
15566 {
15567 tree enum_type;
15568 tree v;
15572 /* There is no need to substitute into namespace-scope
15573 enumerators. */
15576 /* If ARGS is NULL, then T is known to be non-dependent. */
15580 /* Unfortunately, we cannot just call lookup_name here.
15581 Consider:
15583 template <int I> int f() {
15584 enum E { a = I };
15585 struct S { void g() { E e = a; } };
15586 };
15588 When we instantiate f<7>::S::g(), say, lookup_name is not
15589 clever enough to find f<7>::a. */
15590 enum_type
15600 /* We didn't find the name. That should never happen; if
15601 name-lookup found it during preliminary parsing, we
15602 should find it again here during instantiation. */
15604 }
15609 {
15610 tree ctx;
15615 {
15618 {
15622 }
15624 }
15625 }
15635 {
15638 {
15639 /* First try name lookup to find the instantiation. */
15642 {
15644 {
15645 /* During error-recovery we may find a non-variable,
15646 even an OVERLOAD: just bail out and avoid ICEs and
15647 duplicate diagnostics (c++/62207). */
15650 }
15652 {
15653 /* Make sure the one we found is the one we want. */
15657 }
15658 }
15662 else
15663 {
15664 /* This can happen for a variable used in a
15665 late-specified return type of a local lambda, or for a
15666 local static or constant. Building a new VAR_DECL
15667 should be OK in all those cases. */
15670 /* Avoid infinite recursion (79640). */
15673 {
15674 /* We can't call cp_finish_decl, so handle the
15675 initializer by hand. */
15690 }
15697 }
15698 /* Remember this for subsequent uses. */
15701 }
15704 }
15705 else
15729 {
15730 /* Template template argument like the following example need
15731 special treatment:
15733 template <template <class> class TT> struct C {};
15734 template <class T> struct D {
15735 template <class U> struct E {};
15736 C<E> c; // #1
15737 };
15738 D<int> d; // #2
15740 We are processing the template argument `E' in #1 for
15741 the template instantiation #2. Originally, `E' is a
15742 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
15743 have to substitute this with one having context `D<int>'. */
15747 {
15748 /* When rewriting a constructor into a deduction guide, a
15749 non-dependent name can become dependent, so memtmpl<args>
15750 becomes context::template memtmpl<args>. */
15754 }
15756 }
15757 else
15758 /* Ordinary template template argument. */
15763 {
15764 /* Handle location wrappers by substituting the wrapped node
15765 first, *then* reusing the resulting type. Doing the type
15766 first ensures that we handle template parameters and
15767 parameter pack expansions. */
15769 {
15773 }
15777 {
15778 /* Wrapper to make a C++20 template parameter object const. */
15781 {
15784 }
15785 else
15786 {
15789 }
15790 }
15791 /* We shouldn't see any other uses of these in templates. */
15793 }
15803 {
15807 }
15812 {
15821 /* We only want to compute the number of arguments. */
15824 else
15831 {
15833 /* Set TREE_USED for the benefit of -Wunused. */
15837 }
15845 {
15850 else
15857 else
15860 }
15861 else
15863 }
15865 {
15873 }
15874 /* Fall through */
15890 {
15897 }
15900 {
15901 tree object;
15902 tree name;
15907 {
15911 }
15914 {
15924 }
15929 in_decl);
15930 else
15933 }
15971 {
15975 }
15978 {
15983 }
15986 {
15990 }
15993 {
16001 }
16007 {
16014 }
16017 {
16024 }
16027 {
16034 }
16037 {
16038 /* Substituted template arguments */
16047 }
16050 {
16070 }
16095 /* Fall through. */
16098 {
16101 }
16102 else
16106 /* This is handled by tsubst_copy_and_build. */
16110 {
16114 }
16117 /* We shouldn't have built any of these during initial template
16118 generation. Instead, they should be built during instantiation
16119 in response to the saved STMT_IS_FULL_EXPR_P setting. */
16123 {
16133 }
16151 {
16152 /* Instantiate any typedefs in the type. */
16157 }
16160 /* These can sometimes show up in a partial instantiation, but never
16161 involve template parms. */
16177 /* ??? There's no point in copying it for now, but maybe some
16178 day it will contain more information, such as a pointer back
16179 to the containing function, inlined copy or so. */
16183 /* We shouldn't get here, but keep going if !flag_checking. */
16187 }
16188 }
16190 /* Helper function for tsubst_omp_clauses, used for instantiation of
16191 OMP_CLAUSE_DECL of clauses. */
16193 static tree
16196 {
16200 /* Handle OpenMP iterators. */
16204 {
16205 tree ret;
16208 else
16209 {
16213 {
16228 }
16232 }
16236 }
16238 /* Handle an OpenMP array section represented as a TREE_LIST (or
16239 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
16240 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
16241 TREE_LIST. We can handle it exactly the same as an array section
16242 (purpose, value, and a chain), even though the nomenclature
16243 (low_bound, length, etc) is different. */
16245 {
16246 tree low_bound
16261 }
16264 /* Undo convert_from_reference tsubst_expr could have called. */
16270 }
16272 /* Like tsubst_copy, but specifically for OpenMP clauses. */
16274 static tree
16277 {
16283 {
16289 {
16292 {
16298 }
16299 /* FALLTHRU */
16349 {
16352 {
16359 }
16360 else
16362 }
16381 {
16384 }
16389 else
16392 in_decl,
16418 }
16421 {
16433 /* tsubst_expr on SCOPE_REF results in returning
16434 finish_non_static_data_member result. Undo that here. */
16438 {
16443 {
16447 CASE_CONVERT:
16456 /* FALLTHRU */
16460 }
16461 }
16467 {
16470 {
16473 }
16474 }
16478 }
16479 }
16483 {
16488 {
16491 }
16492 }
16494 }
16496 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
16498 static tree
16500 tree in_decl)
16501 {
16502 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
16522 {
16525 else
16526 {
16530 }
16531 }
16536 #undef RECUR
16537 }
16539 /* Used to temporarily communicate the list of #pragma omp parallel
16540 clauses to #pragma omp for instantiation if they are combined
16541 together. */
16548 /* Substitute one OMP_FOR iterator. */
16550 static bool
16555 {
16556 #define RECUR(NODE) \
16557 tsubst_expr ((NODE), args, complain, in_decl, \
16558 integral_constant_expression_p)
16570 {
16573 {
16578 {
16588 else
16590 {
16592 {
16598 }
16601 }
16602 }
16603 }
16607 }
16609 {
16610 /* We need to jump through some hoops to handle declarations in the
16611 init-statement, since we might need to handle auto deduction,
16612 but we need to keep control of initialization. */
16616 }
16617 else
16618 {
16620 {
16623 {
16627 {
16631 CASE_CONVERT:
16639 {
16642 }
16643 /* FALLTHRU */
16647 }
16648 }
16649 }
16650 else
16652 }
16656 {
16662 NULL_TREE);
16663 else
16665 }
16668 {
16675 {
16680 }
16683 }
16693 {
16695 {
16696 /* Declare the variable, but don't let that initialize it. */
16701 }
16704 {
16708 {
16713 }
16714 else
16718 }
16724 }
16727 {
16728 /* Declare and initialize the variable. */
16731 }
16733 {
16737 {
16739 {
16745 {
16748 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
16753 }
16756 {
16758 decl);
16760 }
16763 {
16765 decl);
16767 }
16768 else
16770 }
16773 }
16775 {
16780 {
16783 }
16784 }
16785 }
16788 {
16792 }
16793 else
16797 {
16808 {
16816 }
16817 else
16823 {
16829 }
16833 {
16841 }
16842 else
16848 }
16857 #undef RECUR
16858 }
16860 /* Helper function of tsubst_expr, find OMP_TEAMS inside
16861 of OMP_TARGET's body. */
16863 static tree
16865 {
16868 {
16877 }
16879 }
16881 /* Helper function for tsubst_expr. For decomposition declaration
16882 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
16883 also the corresponding decls representing the identifiers
16884 of the decomposition declaration. Return DECL if successful
16885 or error_mark_node otherwise, set *FIRST to the first decl
16886 in the list chained through DECL_CHAIN and *CNT to the number
16887 of such decls. */
16889 static tree
16893 {
16898 decl2
16903 {
16905 {
16908 }
16920 else
16921 {
16925 }
16932 {
16935 }
16936 else
16938 }
16941 }
16943 /* Return the proper local_specialization for init-capture pack DECL. */
16945 static tree
16947 {
16948 /* We handle normal pack captures by forwarding to the specialization of the
16949 captured parameter. We can't do that for pack init-captures; we need them
16950 to have their own local_specialization. We created the individual
16951 VAR_DECLs (if any) under build_capture_proxy, and we need to collect them
16952 when we process the DECL_EXPR for the pack init-capture in the template.
16953 So, how do we find them? We don't know the capture proxy pack when
16954 building the individual resulting proxies, and we don't know the
16955 individual proxies when instantiating the pack. What we have in common is
16956 the FIELD_DECL.
16958 So...when we instantiate the FIELD_DECL, we stick the result in
16959 local_specializations. Then at the DECL_EXPR we look up that result, see
16960 how many elements it has, synthesize the names, and look them up. */
16974 {
16979 }
16981 {
16986 else
16988 }
16990 }
16992 /* Like tsubst_copy for expressions, etc. but also does semantic
16993 processing. */
16995 tree
16998 {
16999 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
17000 #define RECUR(NODE) \
17001 tsubst_expr ((NODE), args, complain, in_decl, \
17002 integral_constant_expression_p)
17005 tree r;
17006 location_t loc;
17018 {
17020 {
17021 tree_stmt_iterator i;
17025 }
17040 else
17050 {
17052 tree init;
17058 {
17068 else
17070 }
17073 {
17074 /* We're in tsubst_lambda_expr, we've already inserted a new
17075 capture proxy, so look it up and register it. */
17076 tree inst;
17078 {
17083 }
17085 {
17086 inst = (retrieve_local_specialization
17089 }
17090 else
17095 }
17102 /* Don't copy the old closure; we'll create a new one in
17103 tsubst_lambda_expr. */
17105 else
17106 {
17110 {
17111 /* By marking the declaration as instantiated, we avoid
17112 trying to instantiate it. Since instantiate_decl can't
17113 handle local variables, and since we've already done
17114 all that needs to be done, that's the right thing to
17115 do. */
17120 /* Anonymous aggregates are a special case. */
17123 {
17126 {
17130 }
17132 }
17138 {
17143 }
17144 else
17145 {
17161 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
17171 }
17172 }
17173 }
17176 }
17186 {
17190 }
17195 {
17196 /* Construct another range_for, if this is not a final
17197 substitution (for inside inside a generic lambda of a
17198 template). Otherwise convert to a regular for. */
17200 stmt = (processing_template_decl
17217 {
17223 }
17224 else
17225 {
17231 }
17237 }
17244 {
17248 }
17254 {
17258 }
17273 {
17274 /* We're partially instantiating a generic lambda, but the condition
17275 of the constexpr if is still dependent. Don't substitute into the
17276 branches now, just remember the template arguments. */
17284 }
17287 else
17288 {
17296 }
17302 {
17312 }
17320 else
17328 else
17349 {
17355 {
17360 }
17361 }
17365 {
17367 tree label;
17374 }
17380 /* Computed goto's must be tsubst'd into. On the other hand,
17381 non-computed gotos must not be; the identifier in question
17382 will have no binding. */
17384 else
17390 {
17406 }
17411 {
17416 }
17417 else
17418 {
17423 else
17430 else
17436 else
17438 }
17442 {
17446 {
17448 /* Prevent instantiate_decl from trying to instantiate
17449 this variable. We've already done all that needs to be
17450 done. */
17453 }
17458 }
17464 {
17465 /* Local classes are not independent templates; they are
17466 instantiated along with their containing function. And this
17467 way we don't have to deal with pushing out of one local class
17468 to instantiate a member of another local class. */
17469 /* Closures are handled by the LAMBDA_EXPR. */
17479 }
17483 {
17484 tree condition;
17487 condition =
17489 args,
17498 }
17504 in_decl);
17526 {
17533 }
17548 {
17562 in_decl);
17564 {
17571 }
17582 any_range_for
17586 integral_constant_expression_p);
17590 {
17599 }
17600 else
17605 else
17612 else
17613 {
17621 }
17624 t));
17626 }
17631 /* FALLTHRU */
17639 in_decl);
17641 {
17646 }
17647 else
17648 {
17652 }
17664 {
17667 {
17672 }
17673 else
17674 {
17678 }
17680 }
17681 else
17683 OMP_CLAUSE_DEPEND_SOURCE,
17692 in_decl);
17703 {
17706 {
17707 /* For combined target teams, ensure the num_teams and
17708 thread_limit clause expressions are evaluated on the host,
17709 before entering the target construct. */
17710 tree c;
17716 {
17725 OMP_CLAUSE_FIRSTPRIVATE);
17729 }
17730 }
17731 }
17794 {
17799 {
17802 }
17808 }
17809 else
17810 {
17817 {
17820 }
17823 {
17828 {
17831 }
17837 }
17838 else
17839 {
17843 }
17846 }
17850 {
17856 {
17860 {
17865 }
17869 }
17870 else
17871 {
17876 }
17877 }
17881 {
17885 }
17898 /* If the first operand was a statement, we're done with it. */
17902 complain));
17919 integral_constant_expression_p));
17920 }
17923 out:
17926 #undef RECUR
17927 #undef RETURN
17928 }
17930 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
17931 function. For description of the body see comment above
17932 cp_parser_omp_declare_reduction_exprs. */
17934 static void
17936 {
17942 tree_stmt_iterator tsi;
17953 {
17972 }
17974 {
17994 }
17995 }
17997 /* T is a postfix-expression that is not being used in a function
17998 call. Return the substituted version of T. */
18000 static tree
18002 tsubst_flags_t complain,
18003 tree in_decl)
18004 {
18008 else
18014 }
18016 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
18017 instantiation context. Instantiating a pack expansion containing a lambda
18018 might result in multiple lambdas all based on the same lambda in the
18019 template. */
18021 tree
18023 {
18027 /* If we have already specialized this lambda expr, reuse it. See
18028 PR c++/87322. */
18046 /* A lambda in a default argument outside a class gets no
18047 LAMBDA_EXPR_EXTRA_SCOPE, as specified by the ABI. But
18048 tsubst_default_argument calls start_lambda_scope, so we need to
18049 specifically ignore it here, and use the global scope. */
18051 else
18061 {
18068 {
18069 /* Remember these for when we've pushed local_specializations. */
18072 }
18080 else
18085 {
18094 }
18095 else
18096 {
18102 }
18103 }
18109 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
18127 else
18128 {
18129 /* The body of a lambda-expression is not a subexpression of the
18130 enclosing expression. Parms are to have DECL_CHAIN tsubsted,
18131 which would be skipped if cp_unevaluated_operand. */
18132 cp_evaluated ev;
18134 /* Fix the type of 'this'. */
18140 {
18144 }
18145 else
18146 {
18150 }
18152 /* Let finish_function set this. */
18158 else
18159 /* Still increment function_depth so that we don't GC in the
18160 middle of an expression. */
18167 /* Now record them for lookup_init_capture_pack. */
18170 {
18174 }
18180 {
18181 /* We might not partially instantiate some parts of the function, so
18182 copy these flags from the original template. */
18188 }
18190 /* [temp.deduct] A lambda-expression appearing in a function type or a
18191 template parameter is not considered part of the immediate context for
18192 the purposes of template argument deduction. */
18202 else
18205 /* The capture list was built up in reverse order; fix that now. */
18212 }
18219 }
18221 /* Like tsubst but deals with expressions and performs semantic
18222 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
18224 tree
18226 tree args,
18227 tsubst_flags_t complain,
18228 tree in_decl,
18231 {
18232 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
18233 #define RECUR(NODE) \
18234 tsubst_copy_and_build (NODE, args, complain, in_decl, \
18236 integral_constant_expression_p)
18239 location_t loc;
18248 /* N3276 decltype magic only applies to calls at the top level or on the
18249 right side of a comma. */
18254 {
18257 /* Fall through. */
18259 {
18260 tree decl;
18261 cp_id_kind idk;
18266 {
18269 }
18271 /* Look up the name. */
18274 /* By convention, expressions use ERROR_MARK_NODE to indicate
18275 failure, not NULL_TREE. */
18281 integral_constant_expression_p,
18289 input_location);
18293 {
18297 }
18299 }
18302 {
18303 tree object;
18313 {
18318 }
18324 {
18327 }
18328 else
18335 else
18337 }
18340 {
18344 {
18345 /* A type conversion to reference type will be enclosed in
18346 such an indirect ref, but the substitution of the cast
18347 will have also added such an indirect ref. */
18349 }
18350 else
18358 }
18361 {
18365 }
18368 {
18372 {
18377 }
18379 /* We'll pass this to convert_nontype_argument again, we don't need
18380 to actually perform any conversion here. */
18388 flags));
18389 }
18392 {
18398 }
18405 {
18406 tree type;
18412 {
18417 }
18424 {
18442 }
18445 }
18478 else
18480 in_decl);
18515 {
18522 tree r = build_x_binary_op
18524 op0,
18526 ? ERROR_MARK
18528 op1,
18530 ? ERROR_MARK
18538 }
18541 {
18545 }
18561 /* Fall through */
18564 {
18565 tree r;
18573 {
18574 /* When there are no ARGS, we are trying to evaluate a
18575 non-dependent expression from the parser. Trying to do
18576 the substitutions may not work. */
18579 }
18580 else
18581 {
18586 else
18589 /*integral_constant_expression_p=*/
18593 }
18597 else
18601 {
18603 {
18605 {
18609 }
18610 else
18614 }
18616 }
18618 }
18621 {
18631 }
18647 {
18651 tree r = build_x_modify_expr
18654 /* TREE_NO_WARNING must be set if either the expression was
18655 parenthesized or it uses an operator such as >>= rather
18656 than plain assignment. In the former case, it was already
18657 set and must be copied. In the latter case,
18658 build_x_modify_expr sets it and it must not be reset
18659 here. */
18664 }
18669 /* Remember that there was a reference to this entity. */
18676 {
18681 tree ret;
18685 else
18686 {
18690 }
18692 /* If there was an initializer in the original tree, but it
18693 instantiated to an empty list, then we should pass a
18694 non-NULL empty vector to tell build_new that it was an
18695 empty initializer() rather than no initializer. This can
18696 only happen when the initializer is a pack expansion whose
18697 parameter packs are of length zero. */
18700 else
18701 {
18705 else
18706 {
18709 }
18710 }
18712 /* Avoid passing an enclosing decl to valid_array_size_p. */
18719 complain);
18727 }
18730 {
18736 complain));
18737 }
18740 {
18744 integral_constant_expression_p);
18746 op0,
18749 }
18752 {
18753 tree function;
18758 tree ret;
18761 /* Internal function with no arguments. */
18765 /* When we parsed the expression, we determined whether or
18766 not Koenig lookup should be performed. */
18769 {
18772 }
18774 {
18779 }
18781 {
18782 /* Do nothing; calling tsubst_copy_and_build on an identifier
18783 would incorrectly perform unqualified lookup again.
18785 Note that we can also have an IDENTIFIER_NODE if the earlier
18786 unqualified lookup found a member function; in that case
18787 koenig_p will be false and we do want to do the lookup
18788 again to find the instantiated member function.
18790 FIXME but doing that causes c++/15272, so we need to stop
18791 using IDENTIFIER_NODE in that situation. */
18793 }
18794 else
18795 {
18797 {
18803 }
18804 else
18809 /* Avoid error about taking the address of a constructor. */
18813 in_decl,
18815 integral_constant_expression_p);
18819 }
18824 {
18829 else
18830 {
18831 /* Expand the pack expansion and push each entry onto
18832 CALL_ARGS. */
18835 {
18840 {
18845 }
18846 }
18847 else
18848 {
18849 /* A partial substitution. Add one entry. */
18851 }
18852 }
18853 }
18855 /* Stripped-down processing for a call in a thunk. Specifically, in
18856 the thunk template for a generic lambda. */
18858 {
18861 {
18868 }
18869 /* We aren't going to do normal overload resolution, so force the
18870 template-id to resolve. */
18873 {
18874 /* In a thunk, pass through args directly, without any
18875 conversions. */
18880 }
18882 {
18883 /* Shift the other args over to make room. */
18889 }
18892 /* The thunk location is not interesting. */
18900 }
18902 /* We do not perform argument-dependent lookup if normal
18903 lookup finds a non-function, in accordance with the
18904 expected resolution of DR 218. */
18907 /* If lookup found a member function, the Koenig lookup is
18908 not appropriate, even if an unqualified-name was used
18909 to denote the function. */
18912 /* Only do this when substitution turns a dependent call
18913 into a non-dependent call. */
18921 {
18923 {
18924 /* For backwards compatibility and good diagnostics, try
18925 the unqualified lookup again if we aren't in SFINAE
18926 context. */
18927 tree unq = (tsubst_copy_and_build
18929 integral_constant_expression_p));
18931 {
18934 }
18937 {
18938 /* In a lambda fn, we have to be careful to not
18939 introduce new this captures. Legacy code can't
18940 be using lambdas anyway, so it's ok to be
18941 stricter. */
18946 "and no declarations were found by "
18947 "argument-dependent lookup at the point "
18954 else
18958 {
18969 {
18971 input_location);
18973 "declarations in dependent base %qT are "
18979 else
18983 }
18984 else
18986 "%qD declared here, later in the "
18989 {
18992 }
18993 }
18996 }
18997 }
18999 {
19004 }
19005 }
19007 /* Remember that there was a reference to this entity. */
19011 {
19014 }
19016 /* Put back tf_decltype for the actual call. */
19021 {
19025 {
19027 "wrong number of arguments to "
19030 }
19031 else
19033 input_location),
19040 {
19042 "wrong number of arguments to "
19046 }
19050 complain);
19052 {
19055 }
19059 /* Unsupported internal function with arguments. */
19061 }
19066 complain);
19068 {
19083 complain);
19084 else
19085 ret = (build_new_method_call
19090 complain));
19091 }
19092 else
19095 koenig_p,
19096 complain);
19101 {
19106 {
19111 }
19112 }
19115 }
19118 {
19125 {
19127 {
19132 }
19133 else
19134 {
19139 }
19141 }
19142 else
19143 {
19146 }
19151 }
19154 {
19159 input_location));
19160 }
19163 {
19171 {
19172 /* We have pack expansions, so expand those and
19173 create a new list out of it. */
19176 tree chain;
19179 /* Expand the argument expressions. */
19187 /* Build the rest of the list. */
19192 /* Determine the number of arguments. */
19194 {
19197 }
19200 else
19201 {
19202 /* Since we only performed a partial substitution into
19203 the argument pack, we only RETURN (a single list
19204 node. */
19211 }
19213 /* Convert the argument vectors into a TREE_LIST */
19216 {
19217 /* Grab the Ith values. */
19218 i--;
19221 value
19225 /* Build the list (backwards). */
19227 }
19230 }
19246 }
19249 {
19250 tree object;
19251 tree object_type;
19252 tree member;
19253 tree r;
19257 /* Remember that there was a reference to this entity. */
19268 else
19274 {
19279 }
19283 {
19285 {
19290 {
19293 }
19295 {
19300 }
19301 }
19302 }
19305 {
19306 /* Lookup the template functions now that we know what the
19307 scope is. */
19315 {
19318 args);
19319 member = (adjust_result_of_qualified_name_lookup
19321 object_type));
19322 }
19323 else
19324 {
19326 input_location);
19328 }
19329 }
19333 {
19335 {
19339 else
19342 }
19344 }
19348 complain);
19352 }
19359 {
19367 tree r;
19372 /* We do not want to process the index of aggregate
19373 initializers as they are identifier nodes which will be
19374 looked up by digest_init. */
19378 {
19381 }
19386 {
19388 /* An identifier index is looked up in the type
19389 being initialized, not the current scope. */
19394 {
19395 /* Substitute into the pack expansion. */
19397 in_decl);
19401 ;
19403 /* Just move the argument into place. */
19405 else
19406 {
19407 /* Update the length of the final CONSTRUCTOR
19408 arguments vector, and note that we will need to
19409 copy.*/
19412 }
19413 }
19414 else
19416 }
19419 {
19424 {
19426 {
19431 }
19432 else
19434 }
19435 }
19443 {
19448 }
19452 }
19455 {
19458 {
19461 }
19462 else
19463 {
19466 }
19467 }
19472 /* Fall through */
19475 {
19477 /* ??? We're doing a subset of finish_id_expression here. */
19479 /* Replace an evaluated use of the thread_local variable with
19480 a call to its wrapper. */
19486 /* If the original type was a reference, we'll be wrapped in
19487 the appropriate INDIRECT_REF. */
19490 }
19493 {
19497 }
19500 {
19501 tree object_ptr
19508 }
19515 {
19526 }
19529 {
19535 integral_constant_expression_p);
19539 /* If the resulting list of expression statement is empty,
19540 fold it further into void_node. */
19545 }
19548 {
19550 {
19551 /* We don't have a full set of template arguments yet; don't touch
19552 the lambda at all. */
19555 }
19559 }
19562 /* We can get here for a constant initializer of non-dependent type.
19563 FIXME stop folding in cp_parser_initializer_clause. */
19564 {
19566 complain);
19568 }
19572 integral_constant_expression_p));
19578 {
19583 complain));
19584 }
19590 /* No need to substitute further, a RANGE_EXPR will always be built
19591 with constant operands. */
19597 /* We need to do this here as well as in tsubst_copy so we get the
19598 other tsubst_copy_and_build semantics for a PARM_DECL operand. */
19601 /* fallthrough. */
19604 /* Handle Objective-C++ constructs, if appropriate. */
19605 {
19606 tree subst
19611 }
19613 }
19615 #undef RECUR
19616 #undef RETURN
19617 out:
19620 }
19622 /* Verify that the instantiated ARGS are valid. For type arguments,
19623 make sure that the type's linkage is ok. For non-type arguments,
19624 make sure they are constants if they are integral or enumerations.
19625 Emit an error under control of COMPLAIN, and return TRUE on error. */
19627 static bool
19629 {
19633 {
19643 }
19645 {
19646 /* [basic.link]: A name with no linkage (notably, the name
19647 of a class or enumeration declared in a local scope)
19648 shall not be used to declare an entity with linkage.
19649 This implies that names with no linkage cannot be used as
19650 template arguments
19652 DR 757 relaxes this restriction for C++0x. */
19657 {
19658 /* DR 488 makes use of a type with no linkage cause
19659 type deduction to fail. */
19661 {
19664 else
19667 }
19669 }
19670 /* In order to avoid all sorts of complications, we do not
19671 allow variably-modified types as template arguments. */
19673 {
19677 }
19678 }
19679 /* Class template and alias template arguments should be OK. */
19681 ;
19682 /* A non-type argument of integral or enumerated type must be a
19683 constant. */
19688 {
19692 }
19694 }
19696 static bool
19698 {
19703 {
19706 }
19710 }
19712 /* We're out of SFINAE context now, so generate diagnostics for the access
19713 errors we saw earlier when instantiating D from TMPL and ARGS. */
19715 static void
19717 {
19729 }
19731 /* Instantiate the indicated variable, function, or alias template TMPL with
19732 the template arguments in TARG_PTR. */
19734 static tree
19736 {
19738 tree fndecl;
19739 tree gen_tmpl;
19740 tree spec;
19748 /* If this function is a clone, handle it specially. */
19750 {
19751 tree spec;
19752 tree clone;
19754 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
19755 DECL_CLONED_FUNCTION. */
19761 /* Look for the clone. */
19765 /* We should always have found the clone by now. */
19768 }
19773 /* Check to see if we already have this specialization. */
19777 /* targ_ptr only has the innermost template args, so add the outer ones
19778 from tmpl, which could be either a partial instantiation or gen_tmpl (in
19779 the case of a non-dependent call within a template definition). */
19780 targ_ptr = (add_outermost_template_args
19782 targ_ptr));
19784 /* It would be nice to avoid hashing here and then again in tsubst_decl,
19785 but it doesn't seem to be on the hot path. */
19794 {
19796 {
19800 }
19802 }
19805 complain))
19808 /* We are building a FUNCTION_DECL, during which the access of its
19809 parameters and return types have to be checked. However this
19810 FUNCTION_DECL which is the desired context for access checking
19811 is not built yet. We solve this chicken-and-egg problem by
19812 deferring all checks until we have the FUNCTION_DECL. */
19815 /* Instantiation of the function happens in the context of the function
19816 template, not the context of the overload resolution we're doing. */
19818 /* If there are dependent arguments, e.g. because we're doing partial
19819 ordering, make sure processing_template_decl stays set. */
19823 {
19827 }
19833 {
19834 /* We need to determine if we're using a partial or explicit
19835 specialization now, because the type of the variable could be
19836 different. */
19842 {
19847 }
19848 }
19850 /* Substitute template parameters to obtain the specialization. */
19858 {
19861 }
19863 /* The DECL_TI_TEMPLATE should always be the immediate parent
19864 template, not the most general template. */
19868 /* Now we know the specialization, compute access previously
19869 deferred. Do no access control for inheriting constructors,
19870 as we already checked access for the inherited constructor. */
19873 {
19878 }
19881 /* If we've just instantiated the main entry point for a function,
19882 instantiate all the alternate entry points as well. We do this
19883 by cloning the instantiation of the main entry point, not by
19884 instantiating the template clones. */
19889 {
19891 {
19892 /* Remember to reinstantiate when we're out of SFINAE so the user
19893 can see the errors. */
19895 }
19897 }
19899 }
19901 /* Wrapper for instantiate_template_1. */
19903 tree
19905 {
19906 tree ret;
19911 }
19913 /* Instantiate the alias template TMPL with ARGS. Also push a template
19914 instantiation level, which instantiate_template doesn't do because
19915 functions and variables have sufficient context established by the
19916 callers. */
19918 static tree
19920 {
19926 args =
19936 }
19938 /* PARM is a template parameter pack for FN. Returns true iff
19939 PARM is used in a deducible way in the argument list of FN. */
19941 static bool
19943 {
19946 {
19948 tree packs;
19954 {
19955 /* The template parameter pack is used in a function parameter
19956 pack. If this is the end of the parameter list, the
19957 template parameter pack is deducible. */
19960 else
19961 /* Otherwise, not. Well, it could be deduced from
19962 a non-pack parameter, but doing so would end up with
19963 a deduction mismatch, so don't bother. */
19965 }
19966 }
19967 /* The template parameter pack isn't used in any function parameter
19968 packs, but it might be used deeper, e.g. tuple<Args...>. */
19970 }
19972 /* Subroutine of fn_type_unification: check non-dependent parms for
19973 convertibility. */
19975 static int
19979 {
19980 /* Non-constructor methods need to leave a conversion for 'this', which
19981 isn't included in nargs here. */
19987 {
19993 /* For a function parameter pack that occurs at the end of the
19994 parameter-declaration-list, the type A of each remaining
19995 argument of the call is compared with the type P of the
19996 declarator-id of the function parameter pack. */
20002 /* For a function parameter pack that does not occur at the
20003 end of the parameter-declaration-list, the type of the
20004 parameter pack is a non-deduced context. */
20008 {
20016 }
20019 }
20022 }
20024 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
20025 NARGS elements of the arguments that are being used when calling
20026 it. TARGS is a vector into which the deduced template arguments
20027 are placed.
20029 Returns either a FUNCTION_DECL for the matching specialization of FN or
20030 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
20031 true, diagnostics will be printed to explain why it failed.
20033 If FN is a conversion operator, or we are trying to produce a specific
20034 specialization, RETURN_TYPE is the return type desired.
20036 The EXPLICIT_TARGS are explicit template arguments provided via a
20037 template-id.
20039 The parameter STRICT is one of:
20041 DEDUCE_CALL:
20042 We are deducing arguments for a function call, as in
20043 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
20044 deducing arguments for a call to the result of a conversion
20045 function template, as in [over.call.object].
20047 DEDUCE_CONV:
20048 We are deducing arguments for a conversion function, as in
20049 [temp.deduct.conv].
20051 DEDUCE_EXACT:
20052 We are deducing arguments when doing an explicit instantiation
20053 as in [temp.explicit], when determining an explicit specialization
20054 as in [temp.expl.spec], or when taking the address of a function
20055 template, as in [temp.deduct.funcaddr]. */
20057 tree
20059 tree explicit_targs,
20060 tree targs,
20063 tree return_type,
20064 unification_kind_t strict,
20069 {
20070 tree parms;
20071 tree fntype;
20076 /* type_unification_real will pass back any access checks from default
20077 template argument substitution. */
20079 /* We don't have all the template args yet. */
20092 full_targs = (add_outermost_template_args
20094 targs));
20099 /* In C++0x, it's possible to have a function template whose type depends
20100 on itself recursively. This is most obvious with decltype, but can also
20101 occur with enumeration scope (c++/48969). So we need to catch infinite
20102 recursion and reject the substitution at deduction time; this function
20103 will return error_mark_node for any repeated substitution.
20105 This also catches excessive recursion such as when f<N> depends on
20106 f<N-1> across all integers, and returns error_mark_node for all the
20107 substitutions back up to the initial one.
20109 This is, of course, not reentrant. */
20118 {
20119 /* [temp.deduct]
20121 The specified template arguments must match the template
20122 parameters in kind (i.e., type, nontype, template), and there
20123 must not be more arguments than there are parameters;
20124 otherwise type deduction fails.
20126 Nontype arguments must match the types of the corresponding
20127 nontype template parameters, or must be convertible to the
20128 types of the corresponding nontype parameters as specified in
20129 _temp.arg.nontype_, otherwise type deduction fails.
20131 All references in the function type of the function template
20132 to the corresponding template parameters are replaced by the
20133 specified template argument values. If a substitution in a
20134 template parameter or in the function type of the function
20135 template results in an invalid type, type deduction fails. */
20146 explicit_targs);
20148 /* Adjust any explicit template arguments before entering the
20149 substitution context. */
20150 explicit_targs
20158 /* Substitute the explicit args into the function type. This is
20159 necessary so that, for instance, explicitly declared function
20160 arguments can match null pointed constants. If we were given
20161 an incomplete set of explicit args, we must not do semantic
20162 processing during substitution as we could create partial
20163 instantiations. */
20165 {
20170 /* Dig out the actual parm. */
20173 {
20176 }
20178 {
20181 }
20184 /* No explicit argument for this template parameter. */
20187 {
20188 /* Mark the argument pack as "incomplete". We could
20189 still deduce more arguments during unification.
20190 We remove this mark in type_unification_real. */
20195 /* We have some incomplete argument packs. */
20197 }
20198 }
20201 {
20203 {
20206 }
20209 /* Ignore any access checks; we'll see them again in
20210 instantiate_template and they might have the wrong
20211 access path at this point. */
20222 }
20224 /* Place the explicitly specified arguments in TARGS. */
20230 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
20232 }
20235 {
20241 }
20246 /* Never do unification on the 'this' parameter. */
20250 {
20251 /* We're deducing for a call to the result of a template conversion
20252 function. The parms we really want are in return_type. */
20256 }
20258 {
20260 }
20262 /* We allow incomplete unification without an error message here
20263 because the standard doesn't seem to explicitly prohibit it. Our
20264 callers must be ready to deal with unification failures in any
20265 event. */
20267 /* If we aren't explaining yet, push tinst context so we can see where
20268 any errors (e.g. from class instantiations triggered by instantiation
20269 of default template arguments) come from. If we are explaining, this
20270 context is redundant. */
20272 {
20275 }
20285 /* Now that we have bindings for all of the template arguments,
20286 ensure that the arguments deduced for the template template
20287 parameters have compatible template parameter lists. We cannot
20288 check this property before we have deduced all template
20289 arguments, because the template parameter types of a template
20290 template parameter might depend on prior template parameters
20291 deduced after the template template parameter. The following
20292 ill-formed example illustrates this issue:
20294 template<typename T, template<T> class C> void f(C<5>, T);
20296 template<int N> struct X {};
20298 void g() {
20299 f(X<5>(), 5l); // error: template argument deduction fails
20300 }
20302 The template parameter list of 'C' depends on the template type
20303 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
20304 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
20305 time that we deduce 'C'. */
20308 {
20311 }
20313 /* DR 1391: All parameters have args, now check non-dependent parms for
20314 convertibility. */
20319 deduced:
20320 /* All is well so far. Now, check:
20322 [temp.deduct]
20324 When all template arguments have been deduced, all uses of
20325 template parameters in nondeduced contexts are replaced with
20326 the corresponding deduced argument values. If the
20327 substitution results in an invalid type, as described above,
20328 type deduction fails. */
20330 {
20333 }
20335 /* Also collect access checks from the instantiation. */
20348 /* Now perform any access checks encountered during substitution. */
20355 /* If we're looking for an exact match, check that what we got
20356 is indeed an exact match. It might not be if some template
20357 parameters are used in non-deduced contexts. But don't check
20358 for an exact match if we have dependent template arguments;
20359 in that case we're doing partial ordering, and we already know
20360 that we have two candidates that will provide the actual type. */
20362 {
20366 tree sarg
20372 {
20376 }
20377 }
20379 /* After doing deduction with the inherited constructor, actually return an
20380 instantiation of the inheriting constructor. */
20386 fail:
20389 {
20391 /* Reset once we're all the way out. */
20393 }
20396 }
20398 /* Adjust types before performing type deduction, as described in
20399 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
20400 sections are symmetric. PARM is the type of a function parameter
20401 or the return type of the conversion function. ARG is the type of
20402 the argument passed to the call, or the type of the value
20403 initialized with the result of the conversion function.
20404 ARG_EXPR is the original argument expression, which may be null. */
20406 static int
20410 tree arg_expr)
20411 {
20415 {
20420 /* Swap PARM and ARG throughout the remainder of this
20421 function; the handling is precisely symmetric since PARM
20422 will initialize ARG rather than vice versa. */
20427 /* Core issue #873: Do the DR606 thing (see below) for these cases,
20428 too, but here handle it by stripping the reference from PARM
20429 rather than by adding it to ARG. */
20437 /* Nothing else to do in this case. */
20442 }
20445 {
20446 /* [temp.deduct.call]
20448 If P is not a reference type:
20450 --If A is an array type, the pointer type produced by the
20451 array-to-pointer standard conversion (_conv.array_) is
20452 used in place of A for type deduction; otherwise,
20454 --If A is a function type, the pointer type produced by
20455 the function-to-pointer standard conversion
20456 (_conv.func_) is used in place of A for type deduction;
20457 otherwise,
20459 --If A is a cv-qualified type, the top level
20460 cv-qualifiers of A's type are ignored for type
20461 deduction. */
20466 else
20468 }
20470 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
20471 reference to a cv-unqualified template parameter that does not represent a
20472 template parameter of a class template (during class template argument
20473 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
20474 an lvalue, the type "lvalue reference to A" is used in place of A for type
20475 deduction. */
20482 /* try_one_overload doesn't provide an arg_expr, but
20483 functions are always lvalues. */
20487 /* [temp.deduct.call]
20489 If P is a cv-qualified type, the top level cv-qualifiers
20490 of P's type are ignored for type deduction. If P is a
20491 reference type, the type referred to by P is used for
20492 type deduction. */
20495 {
20498 }
20500 /* DR 322. For conversion deduction, remove a reference type on parm
20501 too (which has been swapped into ARG). */
20506 }
20508 /* Subroutine of fn_type_unification. PARM is a function parameter of a
20509 template which doesn't contain any deducible template parameters; check if
20510 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
20511 unify_one_argument. */
20513 static int
20517 {
20518 tree type;
20522 else
20530 {
20533 }
20535 {
20539 /* Avoid recalculating this in add_function_candidate. */
20540 ok = (*conv_p
20542 else
20546 }
20550 else
20552 }
20556 /* Returns true iff the expression EXPR is one from which a template
20557 argument can be deduced. In other words, if it's an undecorated
20558 use of a template non-type parameter. */
20560 static bool
20562 {
20563 /* Strip implicit conversions. */
20567 }
20569 /* Returns true iff the array domain DOMAIN uses a template parameter in a
20570 deducible way; that is, if it has a max value of <PARM> - 1. */
20572 static bool
20574 {
20583 }
20585 /* Returns true iff the template arguments ARGS use a template parameter
20586 in a deducible way. */
20588 static bool
20590 {
20592 {
20597 else
20598 {
20605 else
20607 }
20610 }
20612 }
20614 /* Returns true iff TYPE contains any deducible references to template
20615 parameters, as per 14.8.2.5. */
20617 static bool
20619 {
20623 /* T
20624 cv-list T
20625 TT<T>
20626 TT<i>
20627 TT<> */
20632 /* T*
20633 T&
20634 T&& */
20638 /* T[integer-constant ]
20639 type [i] */
20644 /* T type ::*
20645 type T::*
20646 T T::*
20647 T (type ::*)()
20648 type (T::*)()
20649 type (type ::*)(T)
20650 type (T::*)(T)
20651 T (type ::*)(T)
20652 T (T::*)()
20653 T (T::*)(T) */
20656 || (uses_deducible_template_parms
20659 /* template-name <T> (where template-name refers to a class template)
20660 template-name <i> (where template-name refers to a class template) */
20667 /* type (T)
20668 T()
20669 T(T) */
20672 {
20681 }
20684 }
20686 /* Subroutine of type_unification_real and unify_pack_expansion to
20687 handle unification of a single P/A pair. Parameters are as
20688 for those functions. */
20690 static int
20694 {
20701 /* We can't deduce anything from this, but we might get all the
20702 template args from other function args. */
20705 /* Implicit conversions (Clause 4) will be performed on a function
20706 argument to convert it to the type of the corresponding function
20707 parameter if the parameter type contains no template-parameters that
20708 participate in template argument deduction. */
20711 /* For function parameters with no deducible template parameters,
20712 just return. We'll check non-dependent conversions later. */
20716 {
20718 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
20719 | UNIFY_ALLOW_MORE_CV_QUAL
20733 }
20735 /* We only do these transformations if this is the top-level
20736 parameter_type_list in a call or declaration matching; in other
20737 situations (nested function declarators, template argument lists) we
20738 won't be comparing a type to an expression, and we don't do any type
20739 adjustments. */
20741 {
20743 {
20746 {
20747 /* [temp.deduct.type] A template-argument can be
20748 deduced from a pointer to function or pointer
20749 to member function argument if the set of
20750 overloaded functions does not contain function
20751 templates and at most one of a set of
20752 overloaded functions provides a unique
20753 match. */
20757 /* If a unique match was not found, this is a
20758 non-deduced context, so we still succeed. */
20760 }
20766 }
20768 arg_strict |=
20770 }
20771 else
20776 /* For deduction from an init-list we need the actual list. */
20780 }
20782 /* for_each_template_parm callback that always returns 0. */
20784 static int
20786 {
20788 }
20790 /* for_each_template_parm any_fn callback to handle deduction of a template
20791 type argument from the type of an array bound. */
20793 static int
20795 {
20803 {
20809 }
20811 /* Keep walking. */
20813 }
20815 /* Try to deduce any not-yet-deduced template type arguments from the type of
20816 an array bound. This is handled separately from unify because 14.8.2.5 says
20817 "The type of a type parameter is only deduced from an array bound if it is
20818 not otherwise deduced." */
20820 static void
20822 {
20827 }
20829 /* Most parms like fn_type_unification.
20831 If SUBR is 1, we're being called recursively (to unify the
20832 arguments of a function or method parameter of a function
20833 template).
20835 CHECKS is a pointer to a vector of access checks encountered while
20836 substituting default template arguments. */
20838 static int
20840 tree full_targs,
20841 tree xparms,
20845 unification_kind_t strict,
20848 {
20853 tree parms;
20864 /* Reset the number of non-defaulted template arguments contained
20865 in TARGS. */
20868 again:
20876 {
20881 /* For a function parameter pack that occurs at the end of the
20882 parameter-declaration-list, the type A of each remaining
20883 argument of the call is compared with the type P of the
20884 declarator-id of the function parameter pack. */
20890 /* For a function parameter pack that does not occur at the
20891 end of the parameter-declaration-list, the type of the
20892 parameter pack is a non-deduced context. */
20899 explain_p))
20901 }
20906 {
20907 /* Unify the remaining arguments with the pack expansion type. */
20908 tree argvec;
20911 /* Allocate a TREE_VEC and copy in all of the arguments */
20916 /* Copy the parameter into parmvec. */
20922 /* Advance to the end of the list of parameters. */
20924 }
20926 /* Fail if we've reached the end of the parm list, and more args
20927 are present, and the parm list isn't variadic. */
20930 /* Fail if parms are left and they don't have default values and
20931 they aren't all deduced as empty packs (c++/57397). This is
20932 consistent with sufficient_parms_p. */
20935 {
20939 do
20940 {
20943 count++;
20945 }
20949 type_pack_p);
20950 }
20953 {
20954 tsubst_flags_t complain = (explain_p
20955 ? tf_warning_or_error
20960 {
20964 /* Clear the "incomplete" flags on all argument packs now so that
20965 substituting them into later default arguments works. */
20967 {
20970 }
20978 {
20983 }
20985 /* If this is an undeduced nontype parameter that depends on
20986 a type parameter, try another pass; its type may have been
20987 deduced from a later argument than the one from which
20988 this parameter can be deduced. */
20992 {
20995 }
20997 /* Core issue #226 (C++0x) [temp.deduct]:
20999 If a template argument has not been deduced, its
21000 default template argument, if any, is used.
21002 When we are in C++98 mode, TREE_PURPOSE will either
21003 be NULL_TREE or ERROR_MARK_NODE, so we do not need
21004 to explicitly check cxx_dialect here. */
21006 /* OK, there is a default argument. Wait until after the
21007 conversion check to do substitution. */
21010 /* If the type parameter is a parameter pack, then it will
21011 be deduced to an empty parameter pack. */
21013 {
21014 tree arg;
21017 {
21020 }
21021 else
21028 }
21031 }
21033 /* Now substitute into the default template arguments. */
21035 {
21051 {
21052 /* The type of this non-type parameter depends on undeduced
21053 parameters. Don't try to use its default argument yet,
21054 since we might deduce an argument for it on the next pass,
21055 but do check whether the arguments we already have cause
21056 substitution failure, so that that happens before we try
21057 later default arguments (78489). */
21060 NULL_TREE);
21064 else
21066 }
21067 else
21068 {
21069 /* Even if the call is happening in template context, getting
21070 here means it's non-dependent, and a default argument is
21071 considered a separate definition under [temp.decls], so we can
21072 do this substitution without processing_template_decl. This
21073 is important if the default argument contains something that
21074 might be instantiation-dependent like access (87480). */
21075 processing_template_decl_sentinel s;
21078 {
21079 /* First instatiate in template context, in case we still
21080 depend on undeduced template parameters. */
21083 NULL_TREE);
21087 /* We replaced all the tparms, substitute again out of
21088 template context. */
21090 }
21093 NULL_TREE);
21100 else
21102 }
21111 {
21113 /* The position of the first default template argument,
21114 is also the number of non-defaulted arguments in TARGS.
21115 Record that. */
21118 }
21119 }
21123 }
21129 }
21131 /* Subroutine of type_unification_real. Args are like the variables
21132 at the call site. ARG is an overloaded function (or template-id);
21133 we try deducing template args from each of the overloads, and if
21134 only one succeeds, we go with that. Modifies TARGS and returns
21135 true on success. */
21137 static bool
21139 tree targs,
21140 tree parm,
21141 tree arg,
21142 unification_kind_t strict,
21145 {
21152 {
21155 }
21156 else
21160 /* Handle `&x' where `x' is some static or non-static member
21161 function name. */
21167 /* Strip baselink information. */
21172 {
21173 /* If we got some explicit template args, we need to plug them into
21174 the affected templates before we try to unify, in case the
21175 explicit args will completely resolve the templates in question. */
21182 {
21195 {
21200 {
21203 }
21204 }
21207 }
21208 /* If no templates (or more than one) are fully resolved by the
21209 explicit arguments, this template-id is a non-deduced context; it
21210 could still be OK if we deduce all template arguments for the
21211 enclosing call through other arguments. */
21214 }
21217 /* If ARG is, for example, "(0, &f)" then its type will be unknown
21218 -- but the deduction does not succeed because the expression is
21219 not just the function on its own. */
21221 else
21223 {
21228 {
21231 }
21232 }
21234 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21235 to function or pointer to member function argument if the set of
21236 overloaded functions does not contain function templates and at most
21237 one of a set of overloaded functions provides a unique match.
21239 So if we found multiple possibilities, we return success but don't
21240 deduce anything. */
21243 {
21247 {
21252 /* Don't forget explicit template arguments in a pack. */
21256 }
21257 }
21262 }
21264 /* Core DR 115: In contexts where deduction is done and fails, or in
21265 contexts where deduction is not done, if a template argument list is
21266 specified and it, along with any default template arguments, identifies
21267 a single function template specialization, then the template-id is an
21268 lvalue for the function template specialization. */
21270 tree
21272 {
21285 {
21288 }
21290 {
21293 }
21295 {
21298 }
21301 {
21305 /* If we got some explicit template args, we need to plug them into
21306 the affected templates before we try to unify, in case the
21307 explicit args will completely resolve the templates in question. */
21315 {
21328 {
21331 {
21334 }
21336 {
21339 }
21340 }
21341 }
21343 {
21351 {
21352 tree base
21355 }
21359 }
21361 /* There were no good options and at least one bad one, so let the
21362 user know what the problem is. */
21364 }
21366 }
21368 /* As above, but error out if the expression remains overloaded. */
21370 tree
21372 {
21375 {
21379 }
21381 }
21383 /* Subroutine of resolve_overloaded_unification; does deduction for a single
21384 overload. Fills TARGS with any deduced arguments, or error_mark_node if
21385 different overloads deduce different arguments for a given parm.
21386 ADDR_P is true if the expression for which deduction is being
21387 performed was of the form "& fn" rather than simply "fn".
21389 Returns 1 on success. */
21391 static int
21393 tree orig_targs,
21394 tree targs,
21395 tree parm,
21396 tree arg,
21397 unification_kind_t strict,
21401 {
21403 tree tempargs;
21409 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21410 to function or pointer to member function argument if the set of
21411 overloaded functions does not contain function templates and at most
21412 one of a set of overloaded functions provides a unique match.
21414 So if this is a template, just return success. */
21426 /* We don't copy orig_targs for this because if we have already deduced
21427 some template args from previous args, unify would complain when we
21428 try to deduce a template parameter for the same argument, even though
21429 there isn't really a conflict. */
21436 /* First make sure we didn't deduce anything that conflicts with
21437 explicitly specified args. */
21439 {
21446 /* Since we're unifying against ourselves, we will fill in
21447 template args used in the function parm list with our own
21448 template parms. Discard them. */
21451 {
21452 /* Check that the argument at each index of the deduced argument pack
21453 is equivalent to the corresponding explicitly specified argument.
21454 We may have deduced more arguments than were explicitly specified,
21455 and that's OK. */
21457 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
21458 that's wrong if we deduce the same argument pack from multiple
21459 function arguments: it's only incomplete the first time. */
21472 }
21475 }
21478 {
21483 }
21486 }
21488 /* PARM is a template class (perhaps with unbound template
21489 parameters). ARG is a fully instantiated type. If ARG can be
21490 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
21491 TARGS are as for unify. */
21493 static tree
21496 {
21497 tree copy_of_targs;
21507 /* We need to make a new template argument vector for the call to
21508 unify. If we used TARGS, we'd clutter it up with the result of
21509 the attempted unification, even if this class didn't work out.
21510 We also don't want to commit ourselves to all the unifications
21511 we've already done, since unification is supposed to be done on
21512 an argument-by-argument basis. In other words, consider the
21513 following pathological case:
21515 template <int I, int J, int K>
21516 struct S {};
21518 template <int I, int J>
21519 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
21521 template <int I, int J, int K>
21522 void f(S<I, J, K>, S<I, I, I>);
21524 void g() {
21525 S<0, 0, 0> s0;
21526 S<0, 1, 2> s2;
21528 f(s0, s2);
21529 }
21531 Now, by the time we consider the unification involving `s2', we
21532 already know that we must have `f<0, 0, 0>'. But, even though
21533 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
21534 because there are two ways to unify base classes of S<0, 1, 2>
21535 with S<I, I, I>. If we kept the already deduced knowledge, we
21536 would reject the possibility I=1. */
21540 {
21544 }
21546 /* If unification failed, we're done. */
21552 }
21554 /* Given a template type PARM and a class type ARG, find the unique
21555 base type in ARG that is an instance of PARM. We do not examine
21556 ARG itself; only its base-classes. If there is not exactly one
21557 appropriate base class, return NULL_TREE. PARM may be the type of
21558 a partial specialization, as well as a plain template type. Used
21559 by unify. */
21561 static enum template_base_result
21564 {
21566 tree binfo;
21572 {
21573 /* The type could not be completed. */
21576 }
21578 /* Walk in inheritance graph order. The search order is not
21579 important, and this avoids multiple walks of virtual bases. */
21581 {
21586 {
21587 /* If there is more than one satisfactory baseclass, then:
21589 [temp.deduct.call]
21591 If they yield more than one possible deduced A, the type
21592 deduction fails.
21594 applies. */
21596 {
21599 }
21602 }
21603 }
21607 }
21609 /* Returns the level of DECL, which declares a template parameter. */
21611 static int
21613 {
21615 {
21625 }
21627 }
21629 /* Decide whether ARG can be unified with PARM, considering only the
21630 cv-qualifiers of each type, given STRICT as documented for unify.
21631 Returns nonzero iff the unification is OK on that basis. */
21633 static int
21635 {
21641 {
21642 /* Although a CVR qualifier is ignored when being applied to a
21643 substituted template parameter ([8.3.2]/1 for example), that
21644 does not allow us to unify "const T" with "int&" because both
21645 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
21646 It is ok when we're allowing additional CV qualifiers
21647 at the outer level [14.8.2.1]/3,1st bullet. */
21657 }
21668 }
21670 /* Determines the LEVEL and INDEX for the template parameter PARM. */
21671 void
21673 {
21677 {
21680 }
21681 else
21682 {
21685 }
21686 }
21688 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
21689 do { \
21690 if (unify (TP, TA, P, A, S, EP)) \
21691 return 1; \
21692 } while (0)
21694 /* Unifies the remaining arguments in PACKED_ARGS with the pack
21695 expansion at the end of PACKED_PARMS. Returns 0 if the type
21696 deduction succeeds, 1 otherwise. STRICT is the same as in
21697 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
21698 function call argument list. We'll need to adjust the arguments to make them
21699 types. SUBR tells us if this is from a recursive call to
21700 type_unification_real, or for comparing two template argument
21701 lists. */
21703 static int
21707 {
21708 tree parm
21714 /* Add in any args remembered from an earlier partial instantiation. */
21722 /* Determine the parameter packs we will be deducing from the
21723 pattern, and record their current deductions. */
21726 {
21730 /* Only template parameter packs can be deduced, not e.g. function
21731 parameter packs or __bases or __integer_pack. */
21735 /* Determine the index and level of this parameter pack. */
21740 /* Keep track of the parameter packs and their corresponding
21741 argument packs. */
21744 }
21746 /* Loop through all of the arguments that have not yet been
21747 unified and unify each with the pattern. */
21749 {
21750 tree parm;
21754 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
21755 or the element of its argument pack at the current index if
21756 this argument was explicitly specified. */
21758 {
21767 {
21770 }
21772 }
21774 /* If we had explicit template arguments, substitute them into the
21775 pattern before deduction. */
21777 {
21778 /* Some arguments might still be unspecified or dependent. */
21786 NULL_TREE);
21791 }
21792 else
21795 /* Unify the pattern with the current argument. */
21797 explain_p))
21800 /* For each parameter pack, collect the deduced value. */
21802 {
21808 }
21809 }
21811 /* Verify that the results of unification with the parameter packs
21812 produce results consistent with what we've seen before, and make
21813 the deduced argument packs available. */
21815 {
21822 /* By default keep the original deduced argument pack.
21823 If necessary, more specific code is going to update the
21824 resulting deduced argument later down in this function. */
21828 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
21829 actually deduce anything. */
21837 {
21838 /* If we had fewer function args than explicit template args,
21839 just use the explicits. */
21844 }
21847 {
21848 tree result;
21849 /* Build the deduced *_ARGUMENT_PACK. */
21851 {
21854 }
21855 else
21860 /* Note the deduced argument packs for this parameter
21861 pack. */
21863 }
21867 {
21868 /* We only had the explicitly-provided arguments before, but
21869 now we have a complete set of arguments. */
21875 }
21876 else
21877 {
21883 /* Inconsistent unification of this parameter pack. */
21885 bad_old_arg,
21886 bad_new_arg);
21887 }
21888 }
21891 }
21893 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
21894 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
21895 parameters and return value are as for unify. */
21897 static int
21901 {
21902 tree parm_max;
21903 tree arg_max;
21907 /* Our representation of array types uses "N - 1" as the
21908 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
21909 not an integer constant. We cannot unify arbitrarily
21910 complex expressions, so we eliminate the MINUS_EXPRs
21911 here. */
21915 {
21918 }
21922 {
21923 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
21924 trying to unify the type of a variable with the type
21925 of a template parameter. For example:
21927 template <unsigned int N>
21928 void f (char (&) [N]);
21929 int g();
21930 void h(int i) {
21931 char a[g(i)];
21932 f(a);
21933 }
21935 Here, the type of the ARG will be "int [g(i)]", and
21936 may be a SAVE_EXPR, etc. */
21940 }
21942 /* If only one of the bounds used a MINUS_EXPR, compensate
21943 by adding one to the other bound. */
21946 integer_type_node,
21947 parm_max,
21948 integer_one_node);
21951 integer_type_node,
21952 arg_max,
21953 integer_one_node);
21957 }
21959 /* Returns whether T, a P or A in unify, is a type, template or expression. */
21963 static pa_kind_t
21965 {
21974 else
21976 }
21978 /* Deduce the value of template parameters. TPARMS is the (innermost)
21979 set of template parameters to a template. TARGS is the bindings
21980 for those template parameters, as determined thus far; TARGS may
21981 include template arguments for outer levels of template parameters
21982 as well. PARM is a parameter to a template function, or a
21983 subcomponent of that parameter; ARG is the corresponding argument.
21984 This function attempts to match PARM with ARG in a manner
21985 consistent with the existing assignments in TARGS. If more values
21986 are deduced, then TARGS is updated.
21988 Returns 0 if the type deduction succeeds, 1 otherwise. The
21989 parameter STRICT is a bitwise or of the following flags:
21991 UNIFY_ALLOW_NONE:
21992 Require an exact match between PARM and ARG.
21993 UNIFY_ALLOW_MORE_CV_QUAL:
21994 Allow the deduced ARG to be more cv-qualified (by qualification
21995 conversion) than ARG.
21996 UNIFY_ALLOW_LESS_CV_QUAL:
21997 Allow the deduced ARG to be less cv-qualified than ARG.
21998 UNIFY_ALLOW_DERIVED:
21999 Allow the deduced ARG to be a template base class of ARG,
22000 or a pointer to a template base class of the type pointed to by
22001 ARG.
22002 UNIFY_ALLOW_INTEGER:
22003 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
22004 case for more information.
22005 UNIFY_ALLOW_OUTER_LEVEL:
22006 This is the outermost level of a deduction. Used to determine validity
22007 of qualification conversions. A valid qualification conversion must
22008 have const qualified pointers leading up to the inner type which
22009 requires additional CV quals, except at the outer level, where const
22010 is not required [conv.qual]. It would be normal to set this flag in
22011 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
22012 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
22013 This is the outermost level of a deduction, and PARM can be more CV
22014 qualified at this point.
22015 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
22016 This is the outermost level of a deduction, and PARM can be less CV
22017 qualified at this point. */
22019 static int
22022 {
22024 tree targ;
22025 tree tparm;
22027 tsubst_flags_t complain = (explain_p
22028 ? tf_warning_or_error
22031 /* I don't think this will do the right thing with respect to types.
22032 But the only case I've seen it in so far has been array bounds, where
22033 signedness is the only information lost, and I think that will be
22034 okay. */
22042 /* We can't deduce anything from this, but we might get all the
22043 template args from other function args. */
22049 /* If PARM uses template parameters, then we can't bail out here,
22050 even if ARG == PARM, since we won't record unifications for the
22051 template parameters. We might need them if we're trying to
22052 figure out which of two things is more specialized. */
22056 /* Handle init lists early, so the rest of the function can assume
22057 we're dealing with a type. */
22059 {
22064 /* Replace T with std::initializer_list<T> for deduction. */
22071 /* We can only deduce from an initializer list argument if the
22072 parameter is std::initializer_list or an array; otherwise this
22073 is a non-deduced context. */
22078 else
22079 {
22081 /* Deduction is defined in terms of a single type, so just punt
22082 on the (bizarre) std::initializer_list<T...>. */
22085 }
22090 /* If ELTTYPE has no deducible template parms, skip deduction from
22092 else
22094 {
22101 {
22105 /* It should only be possible to get here for a call. */
22107 elt_strict |= maybe_adjust_types_for_deduction
22110 }
22113 explain_p);
22114 }
22118 {
22119 /* Also deduce from the length of the initializer list. */
22126 }
22128 /* If the std::initializer_list<T> deduction worked, replace the
22129 deduced A with std::initializer_list<A>. */
22131 {
22136 }
22138 }
22140 /* If parm and arg aren't the same kind of thing (template, type, or
22141 expression), fail early. */
22145 /* Immediately reject some pairs that won't unify because of
22146 cv-qualification mismatches. */
22149 /* It is the elements of the array which hold the cv quals of an array
22150 type, and the elements might be template type parms. We'll check
22151 when we recurse. */
22153 /* We check the cv-qualifiers when unifying with template type
22154 parameters below. We want to allow ARG `const T' to unify with
22155 PARM `T' for example, when computing which of two templates
22156 is more specialized, for example. */
22170 {
22174 /* In a type which contains a nested-name-specifier, template
22175 argument values cannot be deduced for template parameters used
22176 within the nested-name-specifier. */
22188 /* The PARM is not one we're trying to unify. Just check
22189 to see if it matches ARG. */
22190 {
22195 else
22197 }
22204 /* Check for mixed types and values. */
22212 {
22215 {
22216 /* First try to match ARG directly. */
22218 explain_p);
22220 {
22221 /* Otherwise, look for a suitable base of ARG, as below. */
22228 }
22229 }
22230 /* ARG must be constructed from a template class or a template
22231 template parameter. */
22236 /* Deduce arguments T, i from TT<T> or TT<i>. */
22242 /* Fall through to deduce template name. */
22243 }
22247 {
22248 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
22250 /* Simple cases: Value already set, does match or doesn't. */
22255 }
22256 else
22257 {
22258 /* If PARM is `const T' and ARG is only `int', we don't have
22259 a match unless we are allowing additional qualification.
22260 If ARG is `const int' and PARM is just `T' that's OK;
22261 that binds `const int' to `T'. */
22266 /* Consider the case where ARG is `const volatile int' and
22267 PARM is `const T'. Then, T should be `volatile int'. */
22268 arg = cp_build_qualified_type_real
22273 /* Simple cases: Value already set, does match or doesn't. */
22279 /* Make sure that ARG is not a variable-sized array. (Note
22280 that were talking about variable-sized arrays (like
22281 `int[n]'), rather than arrays of unknown size (like
22282 `int[]').) We'll get very confused by such a type since
22283 the bound of the array is not constant, and therefore
22284 not mangleable. Besides, such types are not allowed in
22285 ISO C++, so we can do as we please here. We do allow
22286 them for 'auto' deduction, since that isn't ABI-exposed. */
22290 /* Strip typedefs as in convert_template_argument. */
22292 }
22294 /* If ARG is a parameter pack or an expansion, we cannot unify
22295 against it unless PARM is also a parameter pack. */
22300 /* If the argument deduction results is a METHOD_TYPE,
22301 then there is a problem.
22302 METHOD_TYPE doesn't map to any real C++ type the result of
22303 the deduction cannot be of that type. */
22317 {
22318 /* The PARM is not one we're trying to unify. Just check
22319 to see if it matches ARG. */
22325 }
22331 {
22335 /* We're deducing from an array bound, the type doesn't matter. */
22341 }
22343 /* [temp.deduct.type] If, in the declaration of a function template
22344 with a non-type template-parameter, the non-type
22345 template-parameter is used in an expression in the function
22346 parameter-list and, if the corresponding template-argument is
22347 deduced, the template-argument type shall match the type of the
22348 template-parameter exactly, except that a template-argument
22349 deduced from an array bound may be of any integral type.
22350 The non-type parameter might use already deduced type parameters. */
22353 /* We don't have enough levels of args to do any substitution. This
22355 else
22356 {
22362 {
22366 }
22367 }
22370 /* Template-parameter dependent expression. Just accept it for now.
22371 It will later be processed in convert_template_argument. */
22372 ;
22378 /* Convert the ARG to the type of PARM; the deduced non-type
22379 template argument must exactly match the types of the
22380 corresponding parameter. */
22383 {
22384 /* We haven't deduced the type of this parameter yet. */
22386 /* We deduce from array bounds in try_array_deduction. */
22388 {
22389 /* Deduce it from the non-type argument. */
22394 }
22395 else
22396 /* Try again later. */
22398 }
22399 else
22402 /* If ARG is a parameter pack or an expansion, we cannot unify
22403 against it unless PARM is also a parameter pack. */
22408 {
22411 }
22416 {
22417 /* A pointer-to-member constant can be unified only with
22418 another constant. */
22422 /* Just unify the class member. It would be useless (and possibly
22423 wrong, depending on the strict flags) to unify also
22424 PTRMEM_CST_CLASS, because we want to be sure that both parm and
22425 arg refer to the same variable, even if through different
22426 classes. For instance:
22428 struct A { int x; };
22429 struct B : A { };
22431 Unification of &A::x and &B::x must succeed. */
22434 }
22437 {
22441 /* [temp.deduct.call]
22443 A can be another pointer or pointer to member type that can
22444 be converted to the deduced A via a qualification
22445 conversion (_conv.qual_).
22447 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
22448 This will allow for additional cv-qualification of the
22449 pointed-to types if appropriate. */
22452 /* The derived-to-base conversion only persists through one
22453 level of pointers. */
22458 }
22490 /* We have already checked cv-qualification at the top of the
22491 function. */
22495 /* As far as unification is concerned, this wins. Later checks
22496 will invalidate it if necessary. */
22499 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
22500 /* Type INTEGER_CST can come from ordinary constant template args. */
22512 {
22522 /* Check for pack expansions in the parameters. */
22524 {
22526 {
22528 /* We can unify against something with a trailing
22529 parameter pack. */
22531 else
22532 /* [temp.deduct.type]/9: If the template argument list of
22533 P contains a pack expansion that is not the last
22534 template argument, the entire template argument list
22535 is a non-deduced context. */
22537 }
22538 }
22540 /* If we don't have enough arguments to satisfy the parameters
22541 (not counting the pack expression at the end), or we have
22542 too many arguments for a parameter list that doesn't end in
22543 a pack expression, we can't unify. */
22549 /* Unify all of the parameters that precede the (optional)
22550 pack expression. */
22552 {
22557 }
22560 DEDUCE_EXACT,
22563 }
22571 {
22579 }
22584 {
22588 {
22589 /* First, we try to unify the PARM and ARG directly. */
22594 {
22595 /* Fallback to the special case allowed in
22596 [temp.deduct.call]:
22598 If P is a class, and P has the form
22599 template-id, then A can be a derived class of
22600 the deduced A. Likewise, if P is a pointer to
22601 a class of the form template-id, A can be a
22602 pointer to a derived class pointed to by the
22603 deduced A. */
22609 {
22610 /* Don't give the derived diagnostic if we're
22611 already dealing with the same template. */
22612 bool same_template
22618 }
22619 }
22620 }
22624 /* Perhaps PARM is something like S<U> and ARG is S<int>.
22625 Then, we should unify `int' and `U'. */
22627 else
22628 /* There's no chance of unification succeeding. */
22633 }
22640 {
22643 tree a;
22649 /* CV qualifications for methods can never be deduced, they must
22650 match exactly. We need to check them explicitly here,
22651 because type_unification_real treats them as any other
22652 cv-qualified parameter. */
22654 && (!check_cv_quals_for_unify
22682 {
22694 }
22697 }
22700 /* Unify a pointer to member with a pointer to member function, which
22701 deduces the type of the member as a function type. */
22703 {
22704 /* Check top-level cv qualifiers */
22712 /* Determine the type of the function we are unifying against. */
22716 }
22735 /* Matched cases are handled by the ARG == PARM test above. */
22739 /* We might get a variable as a non-type template argument in parm if the
22740 corresponding parameter is type-dependent. Make any necessary
22741 adjustments based on whether arg is a reference. */
22745 {
22750 }
22751 /* Now use the normal expression code to check whether they match. */
22762 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
22763 or UNDERLYING_TYPE nodes. */
22767 /* Unification fails if we hit an error node. */
22772 {
22782 }
22783 /* FALLTHRU */
22786 /* An unresolved overload is a nondeduced context. */
22790 expr:
22791 /* We must be looking at an expression. This can happen with
22792 something like:
22794 template <int I>
22795 void foo(S<I>, S<I + 2>);
22797 This is a "nondeduced context":
22799 [deduct.type]
22801 The nondeduced contexts are:
22803 --A type that is a template-id in which one or more of
22804 the template-arguments is an expression that references
22805 a template-parameter.
22807 In these cases, we assume deduction succeeded, but don't
22808 actually infer any unifications. */
22813 else
22815 }
22816 }
22817 #undef RECUR_AND_CHECK_FAILURE
22818 \f
22819 /* Note that DECL can be defined in this translation unit, if
22820 required. */
22822 static void
22824 {
22825 tree clone;
22829 }
22831 /* Called if RESULT is explicitly instantiated, or is a member of an
22832 explicitly instantiated class. */
22834 void
22836 {
22839 /* If this entity has already been written out, it's too late to
22840 make any modifications. */
22844 /* For anonymous namespace we don't need to do anything. */
22846 {
22849 }
22852 /* The TREE_PUBLIC flag for function declarations will have been
22853 set correctly by tsubst. */
22856 /* This might have been set by an earlier implicit instantiation. */
22861 else
22862 {
22865 /* Always make artificials weak. */
22868 /* For WIN32 we also want to put explicit instantiations in
22869 linkonce sections. */
22874 /* If the function has already been instantiated, clear DECL_EXTERNAL,
22875 since start_preparsed_function wouldn't have if we had an earlier
22876 extern explicit instantiation. */
22878 }
22880 /* If EXTERN_P, then this function will not be emitted -- unless
22881 followed by an explicit instantiation, at which point its linkage
22882 will be adjusted. If !EXTERN_P, then this function will be
22883 emitted here. In neither circumstance do we want
22884 import_export_decl to adjust the linkage. */
22886 }
22888 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
22889 important template arguments. If any are missing, we check whether
22890 they're important by using error_mark_node for substituting into any
22891 args that were used for partial ordering (the ones between ARGS and END)
22892 and seeing if it bubbles up. */
22894 static bool
22896 {
22901 {
22904 }
22906 {
22910 }
22912 }
22914 /* Given two function templates PAT1 and PAT2, return:
22916 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
22917 -1 if PAT2 is more specialized than PAT1.
22918 0 if neither is more specialized.
22920 LEN indicates the number of parameters we should consider
22921 (defaulted parameters should not be considered).
22923 The 1998 std underspecified function template partial ordering, and
22924 DR214 addresses the issue. We take pairs of arguments, one from
22925 each of the templates, and deduce them against each other. One of
22926 the templates will be more specialized if all the *other*
22927 template's arguments deduce against its arguments and at least one
22928 of its arguments *does* *not* deduce against the other template's
22929 corresponding argument. Deduction is done as for class templates.
22930 The arguments used in deduction have reference and top level cv
22931 qualifiers removed. Iff both arguments were originally reference
22932 types *and* deduction succeeds in both directions, an lvalue reference
22933 wins against an rvalue reference and otherwise the template
22934 with the more cv-qualified argument wins for that pairing (if
22935 neither is more cv-qualified, they both are equal). Unlike regular
22936 deduction, after all the arguments have been deduced in this way,
22937 we do *not* verify the deduced template argument values can be
22938 substituted into non-deduced contexts.
22940 The logic can be a bit confusing here, because we look at deduce1 and
22941 targs1 to see if pat2 is at least as specialized, and vice versa; if we
22942 can find template arguments for pat1 to make arg1 look like arg2, that
22943 means that arg2 is at least as specialized as arg1. */
22945 int
22947 {
22960 /* Remove the this parameter from non-static member functions. If
22961 one is a non-static member function and the other is not a static
22962 member function, remove the first parameter from that function
22963 also. This situation occurs for operator functions where we
22964 locate both a member function (with this pointer) and non-member
22965 operator (with explicit first operand). */
22967 {
22972 }
22974 {
22977 {
22978 len--;
22980 }
22981 }
22983 /* If only one is a conversion operator, they are unordered. */
22987 /* Consider the return type for a conversion function */
22989 {
22992 len++;
22993 }
22995 processing_template_decl++;
23001 /* Stop when an ellipsis is seen. */
23003 {
23014 {
23015 /* When both arguments are pack expansions, we need only
23016 unify the patterns themselves. */
23020 /* This is the last comparison we need to do. */
23022 }
23024 /* DR 1847: If a particular P contains no template-parameters that
23025 participate in template argument deduction, that P is not used to
23026 determine the ordering. */
23032 {
23036 }
23039 {
23043 }
23049 {
23055 /* Setup the parameter vector, which contains only ARG1. */
23058 /* Setup the argument vector, which contains the remaining
23059 arguments. */
23068 /* We cannot deduce in the other direction, because ARG1 is
23069 a pack expansion but ARG2 is not. */
23071 }
23073 {
23079 /* Setup the parameter vector, which contains only ARG1. */
23082 /* Setup the argument vector, which contains the remaining
23083 arguments. */
23092 /* We cannot deduce in the other direction, because ARG2 is
23093 a pack expansion but ARG1 is not.*/
23095 }
23097 else
23098 {
23099 /* The normal case, where neither argument is a pack
23100 expansion. */
23107 }
23109 /* If we couldn't deduce arguments for tparms1 to make arg1 match
23110 arg2, then arg2 is not as specialized as arg1. */
23116 /* "If, for a given type, deduction succeeds in both directions
23117 (i.e., the types are identical after the transformations above)
23118 and both P and A were reference types (before being replaced with
23119 the type referred to above):
23120 - if the type from the argument template was an lvalue reference and
23121 the type from the parameter template was not, the argument type is
23122 considered to be more specialized than the other; otherwise,
23123 - if the type from the argument template is more cv-qualified
23124 than the type from the parameter template (as described above),
23125 the argument type is considered to be more specialized than the other;
23126 otherwise,
23127 - neither type is more specialized than the other." */
23130 {
23132 {
23135 else
23137 }
23139 {
23144 }
23145 }
23148 /* We've failed to deduce something in either direction.
23149 These must be unordered. */
23152 next:
23156 /* We have already processed all of the arguments in our
23157 handing of the pack expansion type. */
23162 }
23164 /* "In most cases, all template parameters must have values in order for
23165 deduction to succeed, but for partial ordering purposes a template
23166 parameter may remain without a value provided it is not used in the
23167 types being used for partial ordering."
23169 Thus, if we are missing any of the targs1 we need to substitute into
23170 origs1, then pat2 is not as specialized as pat1. This can happen when
23171 there is a nondeduced context. */
23177 processing_template_decl--;
23179 /* If both deductions succeed, the partial ordering selects the more
23180 constrained template. */
23182 {
23187 }
23189 /* All things being equal, if the next argument is a pack expansion
23190 for one function but not for the other, prefer the
23191 non-variadic function. FIXME this is bogus; see c++/41958. */
23195 {
23198 }
23204 else
23206 }
23208 /* Determine which of two partial specializations of TMPL is more
23209 specialized.
23211 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
23212 to the first partial specialization. The TREE_PURPOSE is the
23213 innermost set of template parameters for the partial
23214 specialization. PAT2 is similar, but for the second template.
23216 Return 1 if the first partial specialization is more specialized;
23217 -1 if the second is more specialized; 0 if neither is more
23218 specialized.
23220 See [temp.class.order] for information about determining which of
23221 two templates is more specialized. */
23223 static int
23225 {
23226 tree targs;
23235 /* Just like what happens for functions, if we are ordering between
23236 different template specializations, we may encounter dependent
23237 types in the arguments, and we need our dependency check functions
23238 to behave correctly. */
23242 {
23245 }
23249 {
23252 }
23255 /* If both deductions succeed, the partial ordering selects the more
23256 constrained template. */
23260 /* In the case of a tie where at least one of the templates
23261 has a parameter pack at the end, the template with the most
23262 non-packed parameters wins. */
23264 && any_deductions
23267 {
23273 /* We don't count the pack expansion at the end. */
23283 }
23286 }
23288 /* Return the template arguments that will produce the function signature
23289 DECL from the function template FN, with the explicit template
23290 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
23291 also match. Return NULL_TREE if no satisfactory arguments could be
23292 found. */
23294 static tree
23296 {
23300 tree decl_arg_types;
23303 tree arg;
23307 /* Never do unification on the 'this' parameter. */
23329 }
23331 /* Return the innermost template arguments that, when applied to a partial
23332 specialization SPEC_TMPL of TMPL, yield the ARGS.
23334 For example, suppose we have:
23336 template <class T, class U> struct S {};
23337 template <class T> struct S<T*, int> {};
23339 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
23340 partial specialization and the ARGS will be {double*, int}. The resulting
23341 vector will be {double}, indicating that `T' is bound to `double'. */
23343 static tree
23345 {
23347 tree spec_args
23350 tree deduced_args;
23351 tree innermost_deduced_args;
23355 {
23359 innermost_deduced_args);
23360 }
23361 else
23365 again:
23374 {
23376 {
23382 }
23384 }
23387 {
23390 }
23392 /* Verify that nondeduced template arguments agree with the type
23393 obtained from argument deduction.
23395 For example:
23397 struct A { typedef int X; };
23398 template <class T, class U> struct C {};
23399 template <class T> struct C<T, typename T::X> {};
23401 Then with the instantiation `C<A, int>', we can deduce that
23402 `T' is `A' but unify () does not check whether `typename T::X'
23403 is `int'. */
23414 /* We only need to check the innermost arguments; the other
23415 arguments will always agree. */
23420 /* Now that we have bindings for all of the template arguments,
23421 ensure that the arguments deduced for the template template
23422 parameters have compatible template parameter lists. See the use
23423 of template_template_parm_bindings_ok_p in fn_type_unification
23424 for more information. */
23429 }
23431 // Compare two function templates T1 and T2 by deducing bindings
23432 // from one against the other. If both deductions succeed, compare
23433 // constraints to see which is more constrained.
23434 static int
23436 {
23441 {
23444 }
23447 {
23450 }
23452 // If both deductions succeed, then one may be more constrained.
23457 }
23459 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
23460 Return the TREE_LIST node with the most specialized template, if
23461 any. If there is no most specialized template, the error_mark_node
23462 is returned.
23464 Note that this function does not look at, or modify, the
23465 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
23466 returned is one of the elements of INSTANTIATIONS, callers may
23467 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
23468 and retrieve it from the value returned. */
23470 tree
23472 {
23479 {
23485 {
23486 /* Equally specialized, move to next function. If there
23487 is no next function, nothing's most specialized. */
23492 }
23493 }
23496 /* Now verify that champ is better than everything earlier in the
23497 instantiation list. */
23500 {
23503 }
23504 }
23506 processing_template_decl--;
23512 }
23514 /* If DECL is a specialization of some template, return the most
23515 general such template. Otherwise, returns NULL_TREE.
23517 For example, given:
23519 template <class T> struct S { template <class U> void f(U); };
23521 if TMPL is `template <class U> void S<int>::f(U)' this will return
23522 the full template. This function will not trace past partial
23523 specializations, however. For example, given in addition:
23525 template <class T> struct S<T*> { template <class U> void f(U); };
23527 if TMPL is `template <class U> void S<int*>::f(U)' this will return
23528 `template <class T> template <class U> S<T*>::f(U)'. */
23530 tree
23532 {
23534 {
23537 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
23538 template friend, or a FIELD_DECL for a capture pack. */
23541 }
23543 /* Look for more and more general templates. */
23545 {
23546 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
23547 (See cp-tree.h for details.) */
23556 /* Stop if we run into an explicitly specialized class template. */
23563 }
23566 }
23568 /* Return the most specialized of the template partial specializations
23569 which can produce TARGET, a specialization of some class or variable
23570 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
23571 a TEMPLATE_DECL node corresponding to the partial specialization, while
23572 the TREE_PURPOSE is the set of template arguments that must be
23573 substituted into the template pattern in order to generate TARGET.
23575 If the choice of partial specialization is ambiguous, a diagnostic
23576 is issued, and the error_mark_node is returned. If there are no
23577 partial specializations matching TARGET, then NULL_TREE is
23578 returned, indicating that the primary template should be used. */
23580 static tree
23582 {
23584 tree t;
23585 tree champ;
23592 {
23596 }
23598 {
23601 }
23603 {
23607 }
23608 else
23613 /* For determining which partial specialization to use, only the
23614 innermost args are interesting. */
23616 {
23619 }
23621 /* The caller hasn't called push_to_top_level yet, but we need
23622 get_partial_spec_bindings to be done in non-template context so that we'll
23623 fully resolve everything. */
23624 processing_template_decl_sentinel ptds;
23627 {
23628 tree spec_args;
23632 {
23633 /* Substitute in the template args from the enclosing class. */
23637 }
23644 {
23648 /* Keep the candidate only if the constraints are satisfied,
23649 or if we're not compiling with concepts. */
23652 {
23655 }
23656 }
23657 }
23667 {
23670 ;
23671 else
23672 {
23674 {
23677 {
23680 }
23681 }
23683 }
23684 }
23688 {
23691 {
23694 }
23695 }
23698 {
23705 else
23709 {
23714 }
23717 }
23720 }
23722 /* Explicitly instantiate DECL. */
23724 void
23726 {
23731 /* An error occurred, for which grokdeclarator has already issued
23732 an appropriate message. */
23735 {
23738 }
23740 {
23743 else
23746 }
23752 {
23753 /* There is an asymmetry here in the way VAR_DECLs and
23754 FUNCTION_DECLs are handled by grokdeclarator. In the case of
23755 the latter, the DECL we get back will be marked as a
23756 template instantiation, and the appropriate
23757 DECL_TEMPLATE_INFO will be set up. This does not happen for
23758 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
23759 should handle VAR_DECLs as it currently handles
23760 FUNCTION_DECLs. */
23762 {
23765 }
23768 {
23771 }
23773 {
23778 }
23779 }
23781 {
23784 }
23785 else
23788 /* Check for various error cases. Note that if the explicit
23789 instantiation is valid the RESULT will currently be marked as an
23790 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
23791 until we get here. */
23794 {
23795 /* DR 259 [temp.spec].
23797 Both an explicit instantiation and a declaration of an explicit
23798 specialization shall not appear in a program unless the explicit
23799 instantiation follows a declaration of the explicit specialization.
23801 For a given set of template parameters, if an explicit
23802 instantiation of a template appears after a declaration of an
23803 explicit specialization for that template, the explicit
23804 instantiation has no effect. */
23806 }
23808 {
23809 /* [temp.spec]
23811 No program shall explicitly instantiate any template more
23812 than once.
23814 We check DECL_NOT_REALLY_EXTERN so as not to complain when
23815 the first instantiation was `extern' and the second is not,
23816 and EXTERN_P for the opposite case. */
23819 /* If an "extern" explicit instantiation follows an ordinary
23820 explicit instantiation, the template is instantiated. */
23823 }
23825 {
23828 }
23830 {
23833 }
23836 ;
23838 {
23841 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
23844 }
23845 else
23853 }
23855 static void
23857 {
23863 {
23866 }
23867 }
23869 /* Called from do_type_instantiation through binding_table_foreach to
23870 do recursive instantiation for the type bound in ENTRY. */
23871 static void
23873 {
23880 }
23882 /* Perform an explicit instantiation of template class T. STORAGE, if
23883 non-null, is the RID for extern, inline or static. COMPLAIN is
23884 nonzero if this is called from the parser, zero if called recursively,
23885 since the standard is unclear (as detailed below). */
23887 void
23889 {
23899 {
23900 tree tmpl =
23904 else
23907 }
23912 {
23915 t);
23917 }
23920 {
23922 {
23924 {
23927 "ISO C++ 1998 forbids the use of %<extern%> on "
23929 }
23930 else
23932 "ISO C++ forbids the use of %qE"
23934 }
23942 else
23943 {
23945 storage);
23947 }
23948 }
23951 {
23952 /* DR 259 [temp.spec].
23954 Both an explicit instantiation and a declaration of an explicit
23955 specialization shall not appear in a program unless the explicit
23956 instantiation follows a declaration of the explicit specialization.
23958 For a given set of template parameters, if an explicit
23959 instantiation of a template appears after a declaration of an
23960 explicit specialization for that template, the explicit
23961 instantiation has no effect. */
23963 }
23965 {
23966 /* [temp.spec]
23968 No program shall explicitly instantiate any template more
23969 than once.
23971 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
23972 instantiation was `extern'. If EXTERN_P then the second is.
23973 These cases are OK. */
23980 /* If we've already instantiated the template, just return now. */
23983 }
23991 /* In contrast to implicit instantiation, where only the
23992 declarations, and not the definitions, of members are
23993 instantiated, we have here:
23995 [temp.explicit]
23997 The explicit instantiation of a class template specialization
23998 implies the instantiation of all of its members not
23999 previously explicitly specialized in the translation unit
24000 containing the explicit instantiation.
24002 Of course, we can't instantiate member template classes, since we
24003 don't have any arguments for them. Note that the standard is
24004 unclear on whether the instantiation of the members are
24005 *explicit* instantiations or not. However, the most natural
24006 interpretation is that it should be an explicit
24007 instantiation. */
24011 && !static_p
24014 {
24019 }
24024 }
24026 /* Given a function DECL, which is a specialization of TMPL, modify
24027 DECL to be a re-instantiation of TMPL with the same template
24028 arguments. TMPL should be the template into which tsubst'ing
24029 should occur for DECL, not the most general template.
24031 One reason for doing this is a scenario like this:
24033 template <class T>
24034 void f(const T&, int i);
24036 void g() { f(3, 7); }
24038 template <class T>
24039 void f(const T& t, const int i) { }
24041 Note that when the template is first instantiated, with
24042 instantiate_template, the resulting DECL will have no name for the
24043 first parameter, and the wrong type for the second. So, when we go
24044 to instantiate the DECL, we regenerate it. */
24046 static void
24048 {
24049 /* The arguments used to instantiate DECL, from the most general
24050 template. */
24051 tree code_pattern;
24055 /* Make sure that we can see identifiers, and compute access
24056 correctly. */
24060 {
24061 tree decl_parm;
24062 tree pattern_parm;
24063 tree specs;
24072 /* Instantiate a dynamic exception-specification. noexcept will be
24073 handled below. */
24076 {
24082 specs);
24083 }
24085 /* Merge parameter declarations. */
24088 pattern_parm
24092 {
24093 tree parm_type;
24094 tree attributes;
24099 NULL_TREE);
24105 {
24108 }
24111 }
24112 /* Merge any parameters that match with the function parameter
24113 pack. */
24115 {
24117 tree expanded_types;
24118 /* Expand the TYPE_PACK_EXPANSION that provides the types for
24119 the parameters in this function parameter pack. */
24124 {
24125 tree parm_type;
24126 tree attributes;
24129 /* Rename the parameter to include the index. */
24138 {
24141 }
24143 }
24144 }
24145 /* Merge additional specifiers from the CODE_PATTERN. */
24151 }
24153 {
24162 }
24163 else
24167 }
24169 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
24170 substituted to get DECL. */
24172 tree
24174 {
24177 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
24178 for the instantiation. This is not always the most general
24179 template. Consider, for example:
24181 template <class T>
24182 struct S { template <class U> void f();
24183 template <> void f<int>(); };
24185 and an instantiation of S<double>::f<int>. We want TD to be the
24186 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
24188 more general template. */
24190 /* We must also deal with friend templates. Given:
24192 template <class T> struct S {
24193 template <class U> friend void f() {};
24194 };
24196 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
24197 so far as the language is concerned, but that's still
24198 where we get the pattern for the instantiation from. On
24199 other hand, if the definition comes outside the class, say:
24201 template <class T> struct S {
24202 template <class U> friend void f();
24203 };
24204 template <class U> friend void f() {}
24206 we don't need to look any further. That's what the check for
24207 DECL_INITIAL is for. */
24211 {
24212 /* The present template, TD, should not be a definition. If it
24213 were a definition, we should be using it! Note that we
24214 cannot restructure the loop to just keep going until we find
24215 a template with a definition, since that might go too far if
24216 a specialization was declared, but not defined. */
24218 /* Fetch the more general template. */
24220 }
24223 }
24225 /* Returns true if we need to instantiate this template instance even if we
24226 know we aren't going to emit it. */
24228 bool
24230 {
24231 /* We always instantiate inline functions so that we can inline them. An
24232 explicit instantiation declaration prohibits implicit instantiation of
24233 non-inline functions. With high levels of optimization, we would
24234 normally inline non-inline functions -- but we're not allowed to do
24235 that for "extern template" functions. Therefore, we check
24236 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
24240 /* And we need to instantiate static data members so that
24241 their initializers are available in integral constant
24242 expressions. */
24245 }
24247 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
24248 instantiate it now, modifying TREE_TYPE (fn). Returns false on
24249 error, true otherwise. */
24251 bool
24253 {
24256 /* Don't instantiate a noexcept-specification from template context. */
24265 /* For a member friend template we can get a TEMPLATE_DECL. Let's use
24266 its FUNCTION_DECL for the rest of this function -- push_access_scope
24267 doesn't accept TEMPLATE_DECLs. */
24269 {
24272 }
24283 {
24287 {
24290 /* This might have failed because of an unparsed DMI, so
24291 let's try again later. */
24293 }
24295 {
24296 /* If hash_set::add returns true, the element was already there. */
24301 fn);
24303 }
24305 {
24312 /* If needed, set current_class_ptr for the benefit of
24313 tsubst_copy/PARM_DECL. */
24316 {
24321 }
24323 /* If this function is represented by a TEMPLATE_DECL, then
24324 the deferred noexcept-specification might still contain
24325 dependent types, even after substitution. And we need the
24326 dependency check functions to work in build_noexcept_spec. */
24330 /* Do deferred instantiation of the noexcept-specifier. */
24340 /* Build up the noexcept-specification. */
24349 }
24350 else
24357 {
24358 /* This failed with a hard error, so let's go with false. */
24361 }
24366 }
24369 {
24372 else
24374 }
24377 }
24379 /* We're starting to process the function INST, an instantiation of PATTERN;
24380 add their parameters to local_specializations. */
24382 static void
24384 {
24388 {
24392 }
24394 {
24396 {
24399 }
24400 else
24401 {
24402 /* Register the (value) argument pack as a specialization of
24403 TMPL_PARM, then move on. */
24406 }
24407 }
24409 }
24411 /* Produce the definition of D, a _DECL generated from a template. If
24412 DEFER_OK is true, then we don't have to actually do the
24413 instantiation now; we just have to do it sometime. Normally it is
24414 an error if this is an explicit instantiation but D is undefined.
24415 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
24416 instantiated class template. */
24418 tree
24420 {
24422 tree gen_args;
24423 tree args;
24424 tree td;
24425 tree code_pattern;
24426 tree spec;
24427 tree gen_tmpl;
24435 /* This function should only be used to instantiate templates for
24436 functions and static member variables. */
24439 /* A concept is never instantiated. */
24442 /* Variables are never deferred; if instantiation is required, they
24443 are instantiated right away. That allows for better code in the
24444 case that an expression refers to the value of the variable --
24445 if the variable has a constant value the referring expression can
24446 take advantage of that fact. */
24450 /* Don't instantiate cloned functions. Instead, instantiate the
24451 functions they cloned. */
24459 /* D has already been instantiated or explicitly specialized, so
24460 there's nothing for us to do here.
24462 It might seem reasonable to check whether or not D is an explicit
24463 instantiation, and, if so, stop here. But when an explicit
24464 instantiation is deferred until the end of the compilation,
24465 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
24466 the instantiation. */
24469 /* Check to see whether we know that this template will be
24470 instantiated in some other file, as with "extern template"
24471 extension. */
24474 /* In general, we do not instantiate such templates. */
24482 /* We should already have the extra args. */
24485 /* And what's in the hash table should match D. */
24489 /* This needs to happen before any tsubsting. */
24495 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
24496 for the instantiation. */
24501 {
24502 /* Look up an explicit specialization, if any. */
24506 {
24509 }
24510 }
24514 /* We should never be trying to instantiate a member of a class
24515 template or partial specialization. */
24520 /* In the case of a friend template whose definition is provided
24521 outside the class, we may have too many arguments. Drop the
24522 ones we don't need. The same is true for specializations. */
24523 args = get_innermost_template_args
24527 {
24533 }
24534 else
24535 {
24539 else
24541 }
24543 /* We may be in the middle of deferred access check. Disable it now. */
24546 /* Unless an explicit instantiation directive has already determined
24547 the linkage of D, remember that a definition is available for
24548 this entity. */
24558 /* If D is a member of an explicitly instantiated class template,
24559 and no definition is available, treat it like an implicit
24560 instantiation. */
24563 {
24564 /* Leave linkage flags alone on instantiations with anonymous
24565 visibility. */
24567 {
24570 }
24572 }
24574 /* Defer all other templates, unless we have been explicitly
24575 forbidden from doing so. */
24577 template. */
24578 ! pattern_defined
24579 /* If it's OK to postpone instantiation, do so. */
24580 || defer_ok
24581 /* If this is a static data member that will be defined
24582 elsewhere, we don't want to instantiate the entire data
24583 member, but we do want to instantiate the initializer so that
24584 we can substitute that elsewhere. */
24586 /* Handle here a deleted function too, avoid generating
24587 its body (c++/61080). */
24589 {
24590 /* The definition of the static data member is now required so
24591 we must substitute the initializer. */
24595 {
24596 tree ns;
24597 tree init;
24606 args,
24609 /* If instantiating the initializer involved instantiating this
24610 again, don't call cp_finish_decl twice. */
24612 {
24613 /* Make sure the initializer is still constant, in case of
24614 circular dependency (template/instantiate6.C). */
24615 const_init
24619 LOOKUP_ONLYCONVERTING);
24620 }
24624 }
24626 /* We restore the source position here because it's used by
24627 add_pending_template. */
24633 /* [temp.explicit]
24635 The definition of a non-exported function template, a
24636 non-exported member function template, or a non-exported
24637 member function or static data member of a class template
24638 shall be present in every translation unit in which it is
24639 explicitly instantiated. */
24643 /* If we're in unevaluated context, we just wanted to get the
24644 constant value; this isn't an odr use, so don't queue
24645 a full instantiation. */
24648 /* ??? Historically, we have instantiated inline functions, even
24649 when marked as "extern template". */
24653 }
24654 /* Tell the repository that D is available in this translation unit
24655 -- and see if it is supposed to be instantiated here. */
24657 {
24658 /* In a PCH file, despite the fact that the repository hasn't
24659 requested instantiation in the PCH it is still possible that
24660 an instantiation will be required in a file that includes the
24661 PCH. */
24664 /* Instantiate inline functions so that the inliner can do its
24665 job, even though we'll not be emitting a copy of this
24666 function. */
24669 }
24672 tree fn_context;
24675 /* tsubst_lambda_expr resolved any references to enclosing functions. */
24686 else
24687 {
24692 }
24694 /* Mark D as instantiated so that recursive calls to
24695 instantiate_decl do not try to instantiate it again. */
24698 /* Regenerate the declaration in case the template has been modified
24699 by a subsequent redeclaration. */
24702 /* We already set the file and line above. Reset them now in case
24703 they changed as a result of calling regenerate_decl_from_template. */
24707 {
24708 tree init;
24711 /* Clear out DECL_RTL; whatever was there before may not be right
24712 since we've reset the type of the declaration. */
24716 /* The initializer is placed in DECL_INITIAL by
24717 regenerate_decl_from_template so we don't need to
24718 push/pop_access_scope again here. Pull it out so that
24719 cp_finish_decl can process it. */
24724 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
24725 initializer. That function will defer actual emission until
24726 we have a chance to determine linkage. */
24729 /* Enter the scope of D so that access-checking works correctly. */
24742 }
24746 {
24747 /* Set up the list of local specializations. */
24751 /* Set up context. */
24755 else
24758 /* Some typedefs referenced from within the template code need to be
24759 access checked at template instantiation time, i.e now. These
24760 types were added to the template at parsing time. Let's get those
24761 and perform the access checks then. */
24763 args);
24765 /* Create substitution entries for the parameters. */
24768 /* Substitute into the body of the function. */
24772 else
24773 {
24778 /* Set the current input_location to the end of the function
24779 so that finish_function knows where we are. */
24780 input_location
24783 /* Remember if we saw an infinite loop in the template. */
24784 current_function_infinite_loop
24786 }
24788 /* Finish the function. */
24792 else
24793 {
24796 }
24800 }
24802 /* We're not deferring instantiation any more. */
24807 else
24813 out:
24822 }
24824 /* Run through the list of templates that we wish we could
24825 instantiate, and instantiate any we can. RETRIES is the
24826 number of times we retry pending template instantiation. */
24828 void
24830 {
24834 /* Instantiating templates may trigger vtable generation. This in turn
24835 may require further template instantiations. We place a limit here
24836 to avoid infinite loop. */
24838 {
24842 "template instantiation depth exceeds maximum of %d"
24843 " instantiating %q+D, possibly from virtual table generation"
24847 /* Pretend that we defined it. */
24850 }
24852 do
24853 {
24858 {
24863 {
24865 {
24880 }
24883 }
24884 else
24885 {
24888 {
24889 instantiation
24895 }
24899 }
24902 {
24903 /* If INSTANTIATION has been instantiated, then we don't
24904 need to consider it again in the future. */
24909 }
24910 else
24911 {
24914 }
24917 }
24919 }
24923 }
24925 /* Substitute ARGVEC into T, which is a list of initializers for
24926 either base class or a non-static data member. The TREE_PURPOSEs
24927 are DECLs, and the TREE_VALUEs are the initializer values. Used by
24928 instantiate_decl. */
24930 static tree
24932 {
24937 {
24938 tree decl;
24939 tree init;
24945 {
24946 tree expr;
24947 tree arg;
24949 /* Expand the base class expansion type into separate base
24950 classes. */
24952 tf_warning_or_error,
24953 NULL_TREE);
24957 /* We'll be building separate TREE_LISTs of arguments for
24958 each base. */
24964 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
24965 expand each argument in the TREE_VALUE of t. */
24972 /* VOID_TYPE_NODE is used to indicate
24973 value-initialization. */
24974 {
24977 }
24978 else
24979 {
24980 /* Substitute parameter packs into each argument in the
24981 TREE_LIST. */
24984 {
24985 tree expanded_exprs;
24987 /* Expand the argument. */
24989 expanded_exprs
24991 tf_warning_or_error,
24992 NULL_TREE);
24996 /* Prepend each of the expanded expressions to the
24997 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
24999 {
25004 }
25005 }
25008 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
25009 since we built them backwards. */
25011 {
25014 }
25015 }
25016 }
25019 {
25021 {
25025 }
25026 else
25027 {
25028 tree tmp;
25043 /* If we had an initializer but it instantiated to nothing,
25044 value-initialize the object. This will only occur when
25045 the initializer was a pack expansion where the parameter
25046 packs used in that expansion were of length zero. */
25049 }
25053 {
25055 decl);
25057 }
25058 /* Look for a target constructor. */
25062 {
25065 {
25069 }
25071 }
25074 {
25078 }
25079 }
25080 }
25082 }
25084 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
25086 static void
25088 {
25093 else
25095 }
25097 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
25098 is the instantiation (which should have been created with
25099 start_enum) and ARGS are the template arguments to use. */
25101 static void
25103 {
25104 tree e;
25110 {
25111 tree value;
25112 tree decl;
25115 /* Note that in a template enum, the TREE_VALUE is the
25116 CONST_DECL, not the corresponding INTEGER_CST. */
25121 /* Give this enumeration constant the correct access. */
25124 /* Actually build the enumerator itself. Here we're assuming that
25125 enumerators can't have dependent attributes. */
25128 }
25138 }
25140 /* DECL is a FUNCTION_DECL that is a template specialization. Return
25141 its type -- but without substituting the innermost set of template
25142 arguments. So, innermost set of template parameters will appear in
25143 the type. */
25145 tree
25147 {
25148 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
25150 }
25152 /* Return truthvalue if we're processing a template different from
25153 the last one involved in diagnostics. */
25154 bool
25156 {
25158 }
25160 /* Remember current template involved in diagnostics. */
25161 void
25163 {
25165 }
25169 {
25171 }
25173 /* Return TRUE if current_function_decl is being instantiated, false
25174 otherwise. */
25176 bool
25178 {
25182 }
25184 /* [temp.param] Check that template non-type parm TYPE is of an allowable
25185 type. Return false for ok, true for disallowed. Issue error and
25186 inform messages under control of COMPLAIN. */
25188 static bool
25190 {
25208 /* A bound template template parm could later be instantiated to have a valid
25209 nontype parm type via an alias template. */
25214 {
25216 {
25220 }
25224 {
25229 }
25231 {
25235 }
25236 /* FIXME check op<=> and strong structural equality once spaceship is
25237 implemented. */
25239 }
25242 {
25245 else
25247 type);
25248 }
25250 }
25252 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
25253 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
25255 static bool
25257 {
25258 tree scope;
25260 /* [temp.dep.type]
25262 A type is dependent if it is:
25264 -- a template parameter. Template template parameters are types
25265 for us (since TYPE_P holds true for them) so we handle
25266 them here. */
25270 /* -- a qualified-id with a nested-name-specifier which contains a
25271 class-name that names a dependent type or whose unqualified-id
25272 names a dependent type. */
25276 /* An alias template specialization can be dependent even if the
25277 resulting type is not. */
25281 /* -- a cv-qualified type where the cv-unqualified type is
25282 dependent.
25283 No code is necessary for this bullet; the code below handles
25284 cv-qualified types, and we don't want to strip aliases with
25285 TYPE_MAIN_VARIANT because of DR 1558. */
25286 /* -- a compound type constructed from any dependent type. */
25295 {
25296 tree arg_type;
25301 arg_type;
25306 /* A value-dependent noexcept-specifier makes the type dependent. */
25309 /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
25310 affect overload resolution and treating it as dependent breaks
25311 things. */
25316 }
25317 /* -- an array type constructed from any dependent type or whose
25318 size is specified by a constant expression that is
25319 value-dependent.
25321 We checked for type- and value-dependence of the bounds in
25322 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
25324 {
25329 }
25331 /* -- a template-id in which either the template name is a template
25332 parameter ... */
25335 /* ... or any of the template arguments is a dependent type or
25336 an expression that is type-dependent or value-dependent. */
25338 && (any_dependent_template_arguments_p
25342 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
25343 dependent; if the argument of the `typeof' expression is not
25344 type-dependent, then it should already been have resolved. */
25350 /* A template argument pack is dependent if any of its packed
25351 arguments are. */
25353 {
25359 }
25361 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
25362 be template parameters. */
25369 /* The standard does not specifically mention types that are local
25370 to template functions or local classes, but they should be
25371 considered dependent too. For example:
25373 template <int I> void f() {
25374 enum E { a = I };
25375 S<sizeof (E)> s;
25376 }
25378 The size of `E' cannot be known until the value of `I' has been
25379 determined. Therefore, `E' must be considered dependent. */
25383 /* Don't use type_dependent_expression_p here, as it can lead
25384 to infinite recursion trying to determine whether a lambda
25385 nested in a lambda is dependent (c++/47687). */
25389 && (any_dependent_template_arguments_p
25393 /* Other types are non-dependent. */
25395 }
25397 /* Returns TRUE if TYPE is dependent, in the sense of
25398 [temp.dep.type]. Note that a NULL type is considered dependent. */
25400 bool
25402 {
25403 /* If there are no template parameters in scope, then there can't be
25404 any dependent types. */
25406 {
25407 /* If we are not processing a template, then nobody should be
25408 providing us with a dependent type. */
25412 }
25414 /* If the type is NULL, we have not computed a type for the entity
25415 in question; in that case, the type is dependent. */
25419 /* Erroneous types can be considered non-dependent. */
25423 /* Getting here with global_type_node means we improperly called this
25424 function on the TREE_TYPE of an IDENTIFIER_NODE. */
25427 /* If we have not already computed the appropriate value for TYPE,
25428 do so now. */
25430 {
25433 }
25436 }
25438 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
25439 lookup. In other words, a dependent type that is not the current
25440 instantiation. */
25442 bool
25444 {
25447 }
25449 /* T is a SCOPE_REF. Return whether it represents a non-static member of
25450 an unknown base of 'this' (and is therefore instantiation-dependent). */
25452 static bool
25454 {
25471 }
25473 /* T is a SCOPE_REF; return whether we need to consider it
25474 instantiation-dependent so that we can check access at instantiation
25475 time even though we know which member it resolves to. */
25477 static bool
25479 {
25486 else
25488 }
25490 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
25491 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
25492 expression. */
25494 /* Note that this predicate is not appropriate for general expressions;
25495 only constant expressions (that satisfy potential_constant_expression)
25496 can be tested for value dependence. */
25498 bool
25500 {
25504 /* A type-dependent expression is also value-dependent. */
25509 {
25511 /* A dependent member function of the current instantiation. */
25515 /* A dependent member function of the current instantiation. */
25522 /* A name that has not been looked up -- must be dependent. */
25526 /* A non-type template parm. */
25530 /* A non-type template parm. */
25536 /* A constant with literal type and is initialized
25537 with an expression that is value-dependent. */
25539 /* FIXME cp_finish_decl doesn't fold reference initializers. */
25543 {
25547 }
25556 /* These expressions are value-dependent if the type to which
25557 the cast occurs is dependent or the expression being casted
25558 is value-dependent. */
25559 {
25565 /* A functional cast has a list of operands. */
25568 {
25569 /* If there are no operands, it must be an expression such
25570 as "int()". This should not happen for aggregate types
25571 because it would form non-constant expressions. */
25576 }
25582 }
25587 /* FALLTHRU */
25590 /* A `sizeof' expression is value-dependent if the operand is
25591 type-dependent or is a pack expansion. */
25600 /* An 'encode' expression is value-dependent if the operand is
25601 type-dependent. */
25610 /* All instantiation-dependent expressions should also be considered
25611 value-dependent. */
25619 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
25620 is value-dependent. */
25621 {
25630 }
25633 {
25650 }
25661 {
25665 }
25668 /* Treat all requires-expressions as value-dependent so
25669 we don't try to fold them. */
25676 {
25683 {
25685 /* In a call to a constexpr member function, look through the
25686 implicit ADDR_EXPR on the object argument so that it doesn't
25687 cause the call to be considered value-dependent. We also
25688 look through it in potential_constant_expression. */
25695 }
25697 }
25703 {
25705 tree val;
25712 }
25715 /* Treat a GNU statement expression as dependent to avoid crashing
25716 under instantiate_non_dependent_expr; it can't be constant. */
25720 /* A constant expression is value-dependent if any subexpression is
25721 value-dependent. */
25723 {
25730 {
25734 {
25737 /* In some cases, some of the operands may be missing.
25738 (For example, in the case of PREDECREMENT_EXPR, the
25739 amount to increment by may be missing.) That doesn't
25740 make the expression dependent. */
25743 }
25744 }
25748 }
25750 }
25752 /* The expression is not value-dependent. */
25754 }
25756 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
25757 [temp.dep.expr]. Note that an expression with no type is
25758 considered dependent. Other parts of the compiler arrange for an
25759 expression with type-dependent subexpressions to have no type, so
25760 this function doesn't have to be fully recursive. */
25762 bool
25764 {
25773 /* An unresolved name is always dependent. */
25779 /* A lambda-expression in template context is dependent. dependent_type_p is
25780 true for a lambda in the scope of a class or function template, but that
25781 doesn't cover all template contexts, like a default template argument. */
25785 /* A fold expression is type-dependent. */
25792 /* Some expression forms are never type-dependent. */
25806 /* The types of these expressions depends only on the type to which
25807 the cast occurs. */
25816 /* The types of these expressions depends only on the type created
25817 by the expression. */
25820 {
25821 /* For NEW_EXPR tree nodes created inside a template, either
25822 the object type itself or a TREE_LIST may appear as the
25823 operand 1. */
25826 /* This is an array type. We need to check array dimensions
25827 as well. */
25829 || value_dependent_expression_p
25831 else
25833 }
25836 {
25840 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
25841 contains an identifier associated by name lookup with one or more
25842 declarations declared with a dependent type, or...a
25843 nested-name-specifier or qualified-id that names a member of an
25844 unknown specialization. */
25847 }
25857 {
25858 tree elt;
25862 {
25865 }
25867 }
25869 /* A static data member of the current instantiation with incomplete
25870 array type is type-dependent, as the definition and specializations
25871 can have different bounds. */
25878 /* An array of unknown bound depending on a variadic parameter, eg:
25880 template<typename... Args>
25881 void foo (Args... args)
25882 {
25883 int arr[] = { args... };
25884 }
25886 template<int... vals>
25887 void bar ()
25888 {
25889 int arr[] = { vals... };
25890 }
25892 If the array has no length and has an initializer, it must be that
25893 we couldn't determine its length in cp_complete_array_type because
25894 it is dependent. */
25902 /* A function or variable template-id is type-dependent if it has any
25903 dependent template arguments. */
25907 {
25908 /* Consider the innermost template arguments, since those are the ones
25909 that come from the template-id; the template arguments for the
25910 enclosing class do not make it type-dependent unless they are used in
25911 the type of the decl. */
25913 && (any_dependent_template_arguments_p
25916 }
25918 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
25919 type-dependent. Checking this is important for functions with auto return
25920 type, which looks like a dependent type. */
25929 {
25933 }
25935 /* Always dependent, on the number of arguments if nothing else. */
25940 {
25945 {
25951 }
25952 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
25957 {
25962 }
25965 {
25972 }
25982 }
25986 /* Dependent type attributes might not have made it from the decl to
25987 the type yet. */
25993 }
25995 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
25996 type-dependent if the expression refers to a member of the current
25997 instantiation and the type of the referenced member is dependent, or the
25998 class member access expression refers to a member of an unknown
25999 specialization.
26001 This function returns true if the OBJECT in such a class member access
26002 expression is of an unknown specialization. */
26004 bool
26006 {
26007 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
26008 dependent. */
26013 }
26015 /* walk_tree callback function for instantiation_dependent_expression_p,
26016 below. Returns non-zero if a dependent subexpression is found. */
26018 static tree
26021 {
26023 {
26024 /* We don't have to worry about decltype currently because decltype
26025 of an instantiation-dependent expr is a dependent type. This
26026 might change depending on the resolution of DR 1172. */
26029 }
26032 {
26033 /* Don't treat an argument list as dependent just because it has no
26034 TREE_TYPE. */
26045 /* We'll check value-dependence separately. */
26048 /* Handle expressions with type operands. */
26053 {
26058 {
26061 else
26062 {
26065 }
26066 }
26068 }
26072 /* In a template, finish_class_member_access_expr creates a
26073 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
26074 type-dependent, so that we can check access control at
26075 instantiation time (PR 42277). See also Core issue 1273. */
26082 else
26085 /* Treat statement-expressions as dependent. */
26089 /* Treat requires-expressions as dependent. */
26094 /* Treat calls to function concepts as dependent. */
26100 /* And variable concepts. */
26112 }
26116 else
26118 }
26120 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
26121 sense defined by the ABI:
26123 "An expression is instantiation-dependent if it is type-dependent
26124 or value-dependent, or it has a subexpression that is type-dependent
26125 or value-dependent."
26127 Except don't actually check value-dependence for unevaluated expressions,
26128 because in sizeof(i) we don't care about the value of i. Checking
26129 type-dependence will in turn check value-dependence of array bounds/template
26130 arguments as needed. */
26132 bool
26134 {
26135 tree result;
26146 }
26148 /* As above, but also check value-dependence of the expression as a whole. */
26150 bool
26152 {
26155 }
26157 /* Like type_dependent_expression_p, but it also works while not processing
26158 a template definition, i.e. during substitution or mangling. */
26160 bool
26162 {
26168 }
26170 /* Returns TRUE if ARGS contains a type-dependent expression. */
26172 bool
26174 {
26176 tree arg;
26179 {
26182 }
26184 }
26186 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26187 expressions) contains any type-dependent expressions. */
26189 bool
26191 {
26197 }
26199 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26200 expressions) contains any value-dependent expressions. */
26202 bool
26204 {
26210 }
26212 /* Returns TRUE if the ARG (a template argument) is dependent. */
26214 bool
26216 {
26220 /* Assume a template argument that was wrongly written by the user
26221 is dependent. This is consistent with what
26222 any_dependent_template_arguments_p [that calls this function]
26223 does. */
26233 {
26236 /* A member template of a dependent class is not necessarily
26237 type-dependent, but it is a dependent template argument because it
26238 will be a member of an unknown specialization to that template. */
26241 }
26243 {
26247 {
26250 }
26253 }
26256 else
26259 }
26261 /* Returns true if ARGS (a collection of template arguments) contains
26262 any types that require structural equality testing. */
26264 bool
26266 {
26276 {
26279 {
26285 {
26286 /* Look inside the argument pack. */
26289 }
26292 {
26305 }
26306 }
26307 }
26310 }
26312 /* Returns true if ARGS (a collection of template arguments) contains
26313 any dependent arguments. */
26315 bool
26317 {
26327 {
26332 }
26335 }
26337 /* Returns true if ARGS contains any errors. */
26339 bool
26341 {
26349 {
26352 else
26354 }
26360 {
26365 }
26368 }
26370 /* Returns TRUE if the template TMPL is type-dependent. */
26372 bool
26374 {
26376 {
26381 }
26383 /* Template template parameters are dependent. */
26387 /* So are names that have not been looked up. */
26391 }
26393 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
26395 bool
26397 {
26400 }
26402 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
26403 are dependent. */
26405 bool
26407 {
26414 {
26439 {
26443 }
26447 {
26451 {
26457 /* If this loop has a class iterator with != comparison
26458 with increment other than i++/++i/i--/--i, make sure the
26459 increment is constant. */
26462 {
26465 else
26469 }
26470 }
26471 }
26472 }
26475 }
26477 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
26478 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
26479 no such TYPE can be found. Note that this function peers inside
26480 uninstantiated templates and therefore should be used only in
26481 extremely limited situations. ONLY_CURRENT_P restricts this
26482 peering to the currently open classes hierarchy (which is required
26483 when comparing types). */
26485 tree
26487 {
26488 tree scope;
26489 tree name;
26490 tree decl;
26492 tree pushed_scope;
26493 tree result;
26498 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
26501 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
26502 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
26503 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
26504 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
26505 identifier of the TYPENAME_TYPE anymore.
26506 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
26507 TYPENAME_TYPE instead, we avoid messing up with a possible
26508 typedef variant case. */
26511 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
26512 it first before we can figure out what NAME refers to. */
26514 {
26516 /* Given a class template A with a dependent base with nested type C,
26517 typedef typename A::C::C C will land us here, as trying to resolve
26518 the initial A::C leads to the local C typedef, which leads back to
26519 A::C::C. So we break the recursion now. */
26521 else
26523 }
26524 /* If we don't know what SCOPE refers to, then we cannot resolve the
26525 TYPENAME_TYPE. */
26528 /* If this is a typedef, we don't want to look inside (c++/11987). */
26531 /* If SCOPE isn't the template itself, it will not have a valid
26532 TYPE_FIELDS list. */
26534 /* scope is either the template itself or a compatible instantiation
26535 like X<T>, so look up the name in the original template. */
26537 /* If scope has no fields, it can't be a current instantiation. Check this
26538 before currently_open_class to avoid infinite recursion (71515). */
26541 /* If the SCOPE is not the current instantiation, there's no reason
26542 to look inside it. */
26545 /* Enter the SCOPE so that name lookup will be resolved as if we
26546 were in the class definition. In particular, SCOPE will no
26547 longer be considered a dependent type. */
26549 /* Look up the declaration. */
26551 tf_warning_or_error);
26555 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
26556 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
26562 {
26566 }
26569 {
26570 /* Obtain the template and the arguments. */
26573 {
26574 /* We get here with a plain identifier because a previous tentative
26575 parse of the nested-name-specifier as part of a ptr-operator saw
26576 ::template X<A>. The use of ::template is necessary in a
26577 ptr-operator, but wrong in a declarator-id.
26579 [temp.names]: In a qualified-id of a declarator-id, the keyword
26580 template shall not appear at the top level. */
26584 }
26586 /* Instantiate the template. */
26592 }
26594 /* Leave the SCOPE. */
26598 /* If we failed to resolve it, return the original typename. */
26602 /* If lookup found a typename type, resolve that too. */
26604 {
26605 /* Ill-formed programs can cause infinite recursion here, so we
26606 must catch that. */
26610 }
26612 /* Qualify the resulting type. */
26618 }
26620 /* EXPR is an expression which is not type-dependent. Return a proxy
26621 for EXPR that can be used to compute the types of larger
26622 expressions containing EXPR. */
26624 tree
26626 {
26628 tree inner_expr;
26630 /* When checking, try to get a constant value for all non-dependent
26631 expressions in order to expose bugs in *_dependent_expression_p
26632 and constexpr. This can affect code generation, see PR70704, so
26633 only do this for -fchecking=2. */
26636 /* Don't do this during nsdmi parsing as it can lead to
26637 unexpected recursive instantiations. */
26639 /* Don't do this during concept expansion either and for
26640 the same reason. */
26646 /* Preserve OVERLOADs; the functions must be available to resolve
26647 types. */
26658 /* There is no need to return a proxy for a variable or enumerator. */
26661 /* Preserve string constants; conversions from string constants to
26662 "char *" are allowed, even though normally a "const char *"
26663 cannot be used to initialize a "char *". */
26666 /* Preserve void and arithmetic constants, as an optimization -- there is no
26667 reason to create a new node. */
26672 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
26673 There is at least one place where we want to know that a
26674 particular expression is a throw-expression: when checking a ?:
26675 expression, there are special rules if the second or third
26676 argument is a throw-expression. */
26680 /* Don't wrap an initializer list, we need to be able to look inside. */
26684 /* Don't wrap a dummy object, we need to be able to test for it. */
26703 /* If the type is unknown, it can't really be non-dependent */
26706 /* Otherwise, build a NON_DEPENDENT_EXPR. */
26709 }
26711 /* ARGS is a vector of expressions as arguments to a function call.
26712 Replace the arguments with equivalent non-dependent expressions.
26713 This modifies ARGS in place. */
26715 void
26717 {
26719 tree arg;
26722 {
26726 }
26727 }
26729 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
26730 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
26731 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
26733 static tree
26735 {
26749 }
26751 tree
26753 {
26755 }
26757 tree
26759 {
26761 }
26763 /* Return a C++17 deduction placeholder for class template TMPL. */
26765 tree
26767 {
26770 /* Our canonical type depends on the placeholder. */
26773 }
26775 /* True iff T is a C++17 class template deduction placeholder. */
26777 bool
26779 {
26781 }
26783 /* Make a "constrained auto" type-specifier. This is an
26784 auto type with constraints that must be associated after
26785 deduction. The constraint is formed from the given
26786 CONC and its optional sequence of arguments, which are
26787 non-null if written as partial-concept-id. */
26789 tree
26791 {
26794 /* Build the constraint. */
26802 /* Our canonical type depends on the constraint. */
26805 /* Attach the constraint to the type declaration. */
26808 }
26810 /* Given type ARG, return std::initializer_list<ARG>. */
26812 static tree
26814 {
26818 {
26822 "deducing from brace-enclosed initializer list"
26826 }
26832 }
26834 /* Replace auto in TYPE with std::initializer_list<auto>. */
26836 static tree
26838 {
26845 }
26847 /* Hash traits for hashing possibly constrained 'auto'
26848 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
26851 {
26854 };
26856 /* Hash the 'auto' T. */
26858 inline hashval_t
26860 {
26862 /* Matching constrained-type-specifiers denote the same template
26863 parameter, so hash the constraint. */
26865 else
26866 /* But unconstrained autos are all separate, so just hash the pointer. */
26868 }
26870 /* Compare two 'auto's. */
26874 {
26881 /* Two unconstrained autos are distinct. */
26886 }
26888 /* for_each_template_parm callback for extract_autos: if t is a (possibly
26889 constrained) auto, add it to the vector. */
26891 static int
26893 {
26896 {
26897 /* All the autos were built with index 0; fix that up now. */
26901 /* If this is a repeated constrained-type-specifier, use the index we
26902 chose before. */
26904 else
26905 {
26906 /* Otherwise this is new, so use the current count. */
26909 }
26911 }
26913 /* Always keep walking. */
26915 }
26917 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
26918 says they can appear anywhere in the type. */
26920 static tree
26922 {
26931 {
26936 }
26939 }
26941 /* The stem for deduction guide names. */
26944 /* Return the name for a deduction guide for class template TMPL. */
26946 tree
26948 {
26959 }
26961 /* True if NAME is the name of a deduction guide. */
26963 bool
26965 {
26970 }
26972 /* True if FN is a deduction guide. */
26974 bool
26976 {
26981 }
26983 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
26985 bool
26987 {
26994 }
26996 /* True if FN is a guide generated from a constructor template. */
26998 bool
27000 {
27008 }
27010 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
27011 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
27012 template parameter types. Note that the handling of template template
27013 parameters relies on current_template_parms being set appropriately for the
27014 new template. */
27016 static tree
27019 {
27025 tree newtype;
27028 {
27035 }
27036 else
27037 {
27040 {
27041 // Substitute once to fix references to other template parameters.
27044 // Now substitute again to reduce the level of the auto.
27047 }
27048 else
27051 }
27053 tree newdecl
27058 tree newidx;
27061 {
27071 {
27076 // First create a copy (ttargs) of tsubst_args with an
27077 // additional level for the template template parameter's own
27078 // template parameters (ttparms).
27079 tree ttparms = (INNERMOST_TEMPLATE_PARMS
27087 // Substitute ttargs into ttparms to fix references to
27088 // other template parameters.
27091 // Now substitute again with args based on tparms, to reduce
27092 // the level of the ttparms.
27095 complain);
27096 // Finally, tack the adjusted parms onto tparms.
27098 current_template_parms);
27100 }
27101 }
27102 else
27103 {
27105 tree newconst
27117 }
27120 }
27122 /* Returns a C++17 class deduction guide template based on the constructor
27123 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
27124 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
27126 static tree
27128 {
27132 location_t loc;
27136 {
27140 {
27143 }
27144 else
27154 }
27155 else
27156 {
27160 fn_tmpl
27170 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
27171 fully specialized args for the enclosing class. Strip those off, as
27172 the deduction guide won't have those template parameters. */
27175 /* Discard the 'this' parameter. */
27183 {
27186 /* For a member template constructor, we need to flatten the two
27187 template parameter lists into one, and then adjust the function
27188 signature accordingly. This gets...complicated. */
27191 /* For a member template we should have two levels of parms/args, one
27192 for the class and one for the constructor. We stripped
27193 specialized args for further enclosing classes above. */
27197 /* Template args for translating references to the two-level template
27198 parameters into references to the one-level template parameters we
27199 are creating. */
27204 /* Template parms for the constructor template. */
27207 /* Template parms for the class template. */
27211 /* Template parms for the deduction guide start as a copy of the
27212 template parms for the class. We set current_template_parms for
27213 lookup_template_class_1. */
27219 /* Now we need to rewrite the constructor parms to append them to the
27220 class parms. */
27222 {
27239 }
27241 /* Now we have a final set of template parms to substitute into the
27242 function signature. */
27253 }
27258 }
27261 {
27262 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
27266 }
27270 FUNCTION_DECL,
27287 }
27289 /* Deduce template arguments for the class template placeholder PTYPE for
27290 template TMPL based on the initializer INIT, and return the resulting
27291 type. */
27293 static tree
27295 tsubst_flags_t complain)
27296 {
27298 {
27299 /* We should have handled this in the caller. */
27305 }
27307 /* Using the template parm as its own argument. */
27319 {
27322 {
27323 /* As an exception, the first phase in 16.3.1.7 (considering the
27324 initializer list as a single argument) is omitted if the
27325 initializer list consists of a single expression of type cv U,
27326 where U is a specialization of C or a class derived from a
27327 specialization of C. */
27330 {
27332 tree tparms = (INNERMOST_TEMPLATE_PARMS
27340 }
27341 }
27344 else
27346 }
27347 else
27358 /* Prune explicit deduction guides in copy-initialization context. */
27360 {
27366 {
27367 /* Found a nonconverting guide, prune the candidates. */
27374 }
27375 }
27380 {
27383 }
27386 // FIXME cache artificial deduction guides
27388 {
27389 /* Skip inherited constructors. */
27399 else
27403 }
27407 /* If this is list-initialization and the class has a list constructor, first
27408 try deducing from the list as a single argument, as [over.match.list]. */
27412 {
27416 }
27418 {
27424 {
27425 /* That didn't work, now try treating the list as a sequence of
27426 arguments. */
27429 }
27430 }
27432 /* Maybe generate an implicit deduction guide. */
27434 {
27438 /* Generate a copy guide. */
27441 /* Generate a default guide. */
27445 {
27450 }
27451 }
27454 {
27456 " of %qT, as it has no non-explicit deduction guides or "
27459 }
27461 {
27465 }
27468 {
27472 }
27475 {
27485 }
27490 }
27492 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
27493 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
27494 The CONTEXT determines the context in which auto deduction is performed
27495 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
27496 OUTER_TARGS are used during template argument deduction
27497 (context == adc_unify) to properly substitute the result, and is ignored
27498 in other contexts.
27500 For partial-concept-ids, extra args may be appended to the list of deduced
27501 template arguments prior to determining constraint satisfaction. */
27503 tree
27507 {
27508 tree targs;
27515 /* Defining a subset of type-dependent expressions that we can deduce
27516 from ahead of time isn't worth the trouble. */
27519 /* Similarly, we can't deduce from another undeduced decl. */
27523 /* We may be doing a partial substitution, but we still want to replace
27524 auto_node. */
27528 /* C++17 class template argument deduction. */
27532 /* Nothing we can do with this, even in deduction context. */
27535 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
27536 with either a new invented type template parameter U or, if the
27537 initializer is a braced-init-list (8.5.4), with
27538 std::initializer_list<U>. */
27540 {
27545 else
27546 {
27548 {
27552 "for deduction to %<std::initializer_list%>, use copy-"
27554 }
27556 }
27557 }
27568 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
27569 and initializer has array type, deduce cv-qualified array type. */
27571 complain);
27573 {
27583 {
27587 }
27588 }
27589 else
27590 {
27592 tree tparms;
27596 else
27597 {
27601 }
27605 DEDUCE_CALL,
27608 {
27610 /* Try again at instantiation time. */
27614 /* If type is error_mark_node a diagnostic must have been
27615 emitted by now. Also, having a mention to '<type error>'
27616 in the diagnostic is not really useful to the user. */
27617 {
27621 else
27624 DEDUCE_CALL,
27626 }
27628 }
27629 }
27631 /* Check any placeholder constraints against the deduced type. */
27634 {
27635 /* Use the deduced type to check the associated constraints. If we
27636 have a partial-concept-id, rebuild the argument list so that
27637 we check using the extra arguments. */
27641 {
27644 }
27645 else
27648 {
27650 {
27651 auto_diagnostic_group d;
27653 {
27671 }
27673 }
27675 }
27676 }
27682 }
27684 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
27685 result. */
27687 tree
27689 {
27691 {
27697 /* In an abbreviated function template we didn't know we were dealing
27698 with a function template when we saw the auto return type, so update
27699 it to have the correct level. */
27701 }
27703 }
27705 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
27706 'decltype(auto)' or a deduced class template. */
27708 bool
27710 {
27715 else
27717 }
27719 /* for_each_template_parm callback for type_uses_auto. */
27721 int
27723 {
27725 }
27727 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
27728 a use of `auto'. Returns NULL_TREE otherwise. */
27730 tree
27732 {
27736 {
27737 /* The Concepts TS allows multiple autos in one type-specifier; just
27738 return the first one we find, do_auto_deduction will collect all of
27739 them. */
27743 else
27745 }
27746 else
27748 }
27750 /* Report ill-formed occurrences of auto types in ARGUMENTS. If
27751 concepts are enabled, auto is acceptable in template arguments, but
27752 only when TEMPL identifies a template class. Return TRUE if any
27753 such errors were reported. */
27755 bool
27757 {
27758 /* If there were previous errors, nevermind. */
27762 /* If TMPL is an identifier, we're parsing and we can't tell yet
27763 whether TMPL is supposed to be a type, a function or a variable.
27764 We'll only be able to tell during template substitution, so we
27765 expect to be called again then. If concepts are enabled and we
27766 know we have a type, we're ok. */
27774 /* Quickly search for any occurrences of auto; usually there won't
27775 be any, and then we'll avoid allocating the vector. */
27783 {
27788 }
27791 }
27793 /* For a given template T, return the vector of typedefs referenced
27794 in T for which access check is needed at T instantiation time.
27795 T is either a FUNCTION_DECL or a RECORD_TYPE.
27796 Those typedefs were added to T by the function
27797 append_type_to_template_for_access_check. */
27801 {
27802 tree ti;
27813 {
27818 }
27821 }
27823 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
27824 tied to T. That list of typedefs will be access checked at
27825 T instantiation time.
27826 T is either a FUNCTION_DECL or a RECORD_TYPE.
27827 TYPE_DECL is a TYPE_DECL node representing a typedef.
27828 SCOPE is the scope through which TYPE_DECL is accessed.
27829 LOCATION is the location of the usage point of TYPE_DECL.
27831 This function is a subroutine of
27832 append_type_to_template_for_access_check. */
27834 static void
27836 tree type_decl,
27837 tree scope,
27838 location_t location)
27839 {
27840 qualified_typedef_usage_t typedef_usage;
27841 tree ti;
27848 && type_decl
27862 }
27864 /* Append TYPE_DECL to the template TEMPL.
27865 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
27866 At TEMPL instanciation time, TYPE_DECL will be checked to see
27867 if it can be accessed through SCOPE.
27868 LOCATION is the location of the usage point of TYPE_DECL.
27870 e.g. consider the following code snippet:
27872 class C
27873 {
27874 typedef int myint;
27875 };
27877 template<class U> struct S
27878 {
27879 C::myint mi; // <-- usage point of the typedef C::myint
27880 };
27882 S<char> s;
27884 At S<char> instantiation time, we need to check the access of C::myint
27885 In other words, we need to check the access of the myint typedef through
27886 the C scope. For that purpose, this function will add the myint typedef
27887 and the scope C through which its being accessed to a list of typedefs
27888 tied to the template S. That list will be walked at template instantiation
27889 time and access check performed on each typedefs it contains.
27890 Note that this particular code snippet should yield an error because
27891 myint is private to C. */
27893 void
27895 tree type_decl,
27896 tree scope,
27897 location_t location)
27898 {
27904 /* Make sure we don't append the type to the template twice. */
27911 }
27913 /* Convert the generic type parameters in PARM that match the types given in the
27914 range [START_IDX, END_IDX) from the current_template_parms into generic type
27915 packs. */
27917 tree
27919 {
27930 {
27931 /* Create a distinct parameter pack type from the current parm and add it
27932 to the replacement args to tsubst below into the generic function
27933 parameter. */
27948 }
27954 /* If there are more levels then build up the replacement with the outer
27955 template parms. */
27959 replacement);
27962 }
27964 /* Entries in the decl_constraint hash table. */
27966 {
27967 tree decl;
27968 tree ci;
27969 };
27971 /* Hashing function and equality for constraint entries. */
27973 {
27975 {
27977 }
27980 {
27982 }
27983 };
27985 /* A mapping from declarations to constraint information. Note that
27986 both templates and their underlying declarations are mapped to the
27987 same constraint information.
27989 FIXME: This is defined in pt.c because garbage collection
27990 code is not being generated for constraint.cc. */
27994 /* Returns the template constraints of declaration T. If T is not
27995 constrained, return NULL_TREE. Note that T must be non-null. */
27997 tree
27999 {
28010 else
28012 }
28014 /* Associate the given constraint information CI with the declaration
28015 T. If T is a template, then the constraints are associated with
28016 its underlying declaration. Don't build associations if CI is
28017 NULL_TREE. */
28019 void
28021 {
28033 }
28035 /* Remove the associated constraints of the declaration T. */
28037 void
28039 {
28048 }
28050 /* Memoized satisfaction results for declarations. This
28051 maps the pair (constraint_info, arguments) to the result computed
28052 by constraints_satisfied_p. */
28055 {
28056 tree ci;
28057 tree args;
28058 tree result;
28059 };
28061 /* Hashing function and equality for constraint entries. */
28064 {
28066 {
28069 }
28072 {
28074 }
28075 };
28077 /* Memoized satisfaction results for concept checks. */
28080 {
28081 tree tmpl;
28082 tree args;
28083 tree result;
28084 };
28086 /* Hashing function and equality for constraint entries. */
28089 {
28091 {
28093 }
28096 {
28101 }
28102 };
28107 /* Search for a memoized satisfaction result. Returns one of the
28108 truth value nodes if previously memoized, or NULL_TREE otherwise. */
28110 tree
28112 {
28117 else
28119 }
28121 /* Memoize the result of a satisfication test. Returns the saved result. */
28123 tree
28125 {
28132 }
28134 /* Search for a memoized satisfaction result for a concept. */
28136 tree
28138 {
28143 else
28145 }
28147 /* Memoize the result of a concept check. Returns the saved result. */
28149 tree
28151 {
28158 }
28162 /* Returns a prior concept specialization. This returns the substituted
28163 and normalized constraints defined by the concept. */
28165 tree
28167 {
28172 else
28174 }
28176 /* Save a concept expansion for later. */
28178 tree
28180 {
28187 }
28189 static hashval_t
28191 {
28200 }
28202 /* Compare the constraints of two subsumption entries. The LEFT1 and
28203 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
28204 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
28206 static bool
28208 {
28216 }
28218 /* Key/value pair for learning and memoizing subsumption results. This
28219 associates a pair of check constraints (including arguments) with
28220 a boolean value indicating the result. */
28223 {
28224 tree t1;
28225 tree t2;
28227 };
28229 /* Hashing function and equality for constraint entries. */
28232 {
28234 {
28236 }
28239 {
28244 }
28245 };
28249 /* Search for a previously cached subsumption result. */
28253 {
28258 else
28260 }
28262 /* Save a subsumption result. */
28264 bool
28266 {
28273 }
28275 /* Set up the hash table for constraint association. */
28277 void
28279 {
28288 }
28290 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
28291 0..N-1. */
28293 void
28295 {
28298 integer_type_node,
28299 NULL_TREE),
28305 }
28307 /* Set up the hash tables for template instantiations. */
28309 void
28311 {
28317 }
28319 /* Print stats about the template hash tables for -fstats. */
28321 void
28323 {
28332 }
28334 #if CHECKING_P
28338 /* Verify that build_non_dependent_expr () works, for various expressions,
28339 and that location wrappers don't affect the results. */
28341 static void
28343 {
28346 /* Verify constants, without and with location wrappers. */
28363 }
28365 /* Verify that type_dependent_expression_p () works correctly, even
28366 in the presence of location wrapper nodes. */
28368 static void
28370 {
28375 /* If no templates are involved, nothing is type-dependent. */
28381 /* Within a template, an unresolved name is always type-dependent. */
28384 /* Ensure it copes with NULL_TREE and errors. */
28388 /* A USING_DECL in a template should be type-dependent, even if wrapped
28389 with a location wrapper (PR c++/83799). */
28398 }
28400 /* Run all of the selftests within this file. */
28402 void
28404 {
28407 }