| blob | eec89dbce5b19dda91dcdfd6a4b5d1deeb278e2c |
1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2017 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
45 /* The type of functions taking a tree, and some additional data, and
46 returning an int. */
49 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
50 instantiations have been deferred, either because their definitions
51 were not yet available, or because we were putting off doing the work. */
55 };
70 /* Live only within one (recursive) call to tsubst_expr. We use
71 this to pass the statement expression node from the STMT_EXPR
72 to the EXPR_STMT that is its result. */
75 // -------------------------------------------------------------------------- //
76 // Local Specialization Stack
77 //
78 // Implementation of the RAII helper for creating new local
79 // specializations.
82 {
84 }
87 {
90 }
92 /* True if we've recursed into fn_type_unification too many times. */
96 {
97 tree tmpl;
98 tree args;
99 tree spec;
100 };
103 {
106 };
112 /* Contains canonical template parameter types. The vector is indexed by
113 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
114 TREE_LIST, whose TREE_VALUEs contain the canonical template
115 parameters of various types and levels. */
118 #define UNIFY_ALLOW_NONE 0
119 #define UNIFY_ALLOW_MORE_CV_QUAL 1
120 #define UNIFY_ALLOW_LESS_CV_QUAL 2
121 #define UNIFY_ALLOW_DERIVED 4
122 #define UNIFY_ALLOW_INTEGER 8
123 #define UNIFY_ALLOW_OUTER_LEVEL 16
124 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
125 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
128 tbr_incomplete_type,
129 tbr_ambiguous_baseclass,
130 tbr_success
131 };
154 tree);
211 location_t);
221 /* Make the current scope suitable for access checking when we are
222 processing T. T can be FUNCTION_DECL for instantiated function
223 template, VAR_DECL for static member variable, or TYPE_DECL for
224 alias template (needed by instantiate_decl). */
226 static void
228 {
236 else
240 {
241 saved_access_scope = tree_cons
244 }
245 }
247 /* Restore the scope set up by push_access_scope. T is the node we
248 are processing. */
250 static void
252 {
254 {
257 }
261 else
263 }
265 /* Do any processing required when DECL (a member template
266 declaration) is finished. Returns the TEMPLATE_DECL corresponding
267 to DECL, unless it is a specialization, in which case the DECL
268 itself is returned. */
270 tree
272 {
279 {
280 tree type;
288 {
292 }
294 }
298 {
300 {
303 }
304 else
306 }
307 else
311 }
313 /* Create a template info node. */
315 tree
317 {
322 }
324 /* Return the template info node corresponding to T, whatever T is. */
326 tree
328 {
350 }
352 /* Returns the template nesting level of the indicated class TYPE.
354 For example, in:
355 template <class T>
356 struct A
357 {
358 template <class U>
359 struct B {};
360 };
362 A<T>::B<U> has depth two, while A<T> has depth one.
363 Both A<T>::B<int> and A<int>::B<U> have depth one, if
364 they are instantiations, not specializations.
366 This function is guaranteed to return 0 if passed NULL_TREE so
367 that, for example, `template_class_depth (current_class_type)' is
368 always safe. */
370 int
372 {
376 {
387 else
389 }
392 }
394 /* Subroutine of maybe_begin_member_template_processing.
395 Returns true if processing DECL needs us to push template parms. */
397 static bool
399 {
405 }
407 /* Subroutine of maybe_begin_member_template_processing.
408 Push the template parms in PARMS, starting from LEVELS steps into the
409 chain, and ending at the beginning, since template parms are listed
410 innermost first. */
412 static void
414 {
422 current_template_parms
428 NULL);
430 {
439 {
446 /* Push the CONST_DECL. */
452 }
453 }
454 }
456 /* Restore the template parameter context for a member template, a
457 friend template defined in a class definition, or a non-template
458 member of template class. */
460 void
462 {
463 tree parms;
468 {
471 /* Disregard full specializations (c++/60999). */
474 }
477 {
482 {
485 }
488 }
490 /* Remember how many levels of template parameters we pushed so that
491 we can pop them later. */
493 }
495 /* Undo the effects of maybe_begin_member_template_processing. */
497 void
499 {
508 {
512 }
513 }
515 /* Return a new template argument vector which contains all of ARGS,
516 but has as its innermost set of arguments the EXTRA_ARGS. */
518 static tree
520 {
521 tree new_args;
539 }
541 /* Like add_to_template_args, but only the outermost ARGS are added to
542 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
543 (EXTRA_ARGS) levels are added. This function is used to combine
544 the template arguments from a partial instantiation with the
545 template arguments used to attain the full instantiation from the
546 partial instantiation. */
548 static tree
550 {
551 tree new_args;
553 /* If there are more levels of EXTRA_ARGS than there are ARGS,
554 something very fishy is going on. */
557 /* If *all* the new arguments will be the EXTRA_ARGS, just return
558 them. */
562 /* For the moment, we make ARGS look like it contains fewer levels. */
567 /* Now, we restore ARGS to its full dimensions. */
571 }
573 /* Return the N levels of innermost template arguments from the ARGS. */
575 tree
577 {
578 tree new_args;
584 /* If N is 1, just return the innermost set of template arguments. */
588 /* If we're not removing anything, just return the arguments we were
589 given. */
595 /* Make a new set of arguments, not containing the outer arguments. */
602 }
604 /* The inverse of get_innermost_template_args: Return all but the innermost
605 EXTRA_LEVELS levels of template arguments from the ARGS. */
607 static tree
609 {
610 tree new_args;
616 /* If N is 1, just return the outermost set of template arguments. */
620 /* If we're not removing anything, just return the arguments we were
621 given. */
626 /* Make a new set of arguments, not containing the inner arguments. */
633 }
635 /* We've got a template header coming up; push to a new level for storing
636 the parms. */
638 void
640 {
641 /* We use a non-tag-transparent scope here, which causes pushtag to
642 put tags in this scope, rather than in the enclosing class or
643 namespace scope. This is the right thing, since we want
644 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
645 global template class, push_template_decl handles putting the
646 TEMPLATE_DECL into top-level scope. For a nested template class,
647 e.g.:
649 template <class T> struct S1 {
650 template <class T> struct S2 {};
651 };
653 pushtag contains special code to insert the TEMPLATE_DECL for S2
654 at the right scope. */
660 /* Add a dummy parameter level while we process the parameter list. */
661 current_template_parms
664 current_template_parms);
665 }
667 /* This routine is called when a specialization is declared. If it is
668 invalid to declare a specialization here, an error is reported and
669 false is returned, otherwise this routine will return true. */
671 static bool
673 {
676 /* [temp.expl.spec]
678 An explicit specialization shall be declared in the namespace of
679 which the template is a member, or, for member templates, in the
680 namespace of which the enclosing class or enclosing class
681 template is a member. An explicit specialization of a member
682 function, member class or static data member of a class template
683 shall be declared in the namespace of which the class template
684 is a member. */
686 {
689 }
691 /* [temp.expl.spec]
693 In an explicit specialization declaration for a member of a class
694 template or a member template that appears in namespace scope,
695 the member template and some of its enclosing class templates may
696 remain unspecialized, except that the declaration shall not
697 explicitly specialize a class member template if its enclosing
698 class templates are not explicitly specialized as well. */
700 {
703 }
706 }
708 /* We've just seen template <>. */
710 bool
712 {
716 }
718 /* Called at then end of processing a declaration preceded by
719 template<>. */
721 void
723 {
726 }
728 /* Any template <>'s that we have seen thus far are not referring to a
729 function specialization. */
731 void
733 {
736 }
738 /* We've just seen a template header. If SPECIALIZATION is nonzero,
739 it was of the form template <>. */
741 static void
743 {
745 template_header_count++;
746 }
748 /* We're beginning an explicit instantiation. */
750 void
752 {
755 }
758 void
760 {
763 }
765 /* An explicit specialization or partial specialization of TMPL is being
766 declared. Check that the namespace in which the specialization is
767 occurring is permissible. Returns false iff it is invalid to
768 specialize TMPL in the current namespace. */
770 static bool
772 {
775 /* [tmpl.expl.spec]
777 An explicit specialization shall be declared in a namespace enclosing the
778 specialized template. An explicit specialization whose declarator-id is
779 not qualified shall be declared in the nearest enclosing namespace of the
780 template, or, if the namespace is inline (7.3.1), any namespace from its
781 enclosing namespace set. */
784 {
787 }
790 /* Same or enclosing namespace. */
792 else
793 {
799 }
800 }
802 /* SPEC is an explicit instantiation. Check that it is valid to
803 perform this explicit instantiation in the current namespace. */
805 static void
807 {
808 tree ns;
810 /* DR 275: An explicit instantiation shall appear in an enclosing
811 namespace of its template. */
817 }
819 // Returns the type of a template specialization only if that
820 // specialization needs to be defined. Otherwise (e.g., if the type has
821 // already been defined), the function returns NULL_TREE.
822 static tree
824 {
825 // An implicit instantiation of an incomplete type implies
826 // the definition of a new class template.
827 //
828 // template<typename T>
829 // struct S;
830 //
831 // template<typename T>
832 // struct S<T*>;
833 //
834 // Here, S<T*> is an implicit instantiation of S whose type
835 // is incomplete.
839 // It can also be the case that TYPE is a completed specialization.
840 // Continuing the previous example, suppose we also declare:
841 //
842 // template<typename T>
843 // requires Integral<T>
844 // struct S<T*>;
845 //
846 // Here, S<T*> refers to the specialization S<T*> defined
847 // above. However, we need to differentiate definitions because
848 // we intend to define a new partial specialization. In this case,
849 // we rely on the fact that the constraints are different for
850 // this declaration than that above.
851 //
852 // Note that we also get here for injected class names and
853 // late-parsed template definitions. We must ensure that we
854 // do not create new type declarations for those cases.
856 {
860 // If there are no template parameters, this cannot be a new
861 // partial template specializtion?
865 // The injected-class-name is not a new partial specialization.
869 // If the constraints are not the same as those of the primary
870 // then, we can probably create a new specialization.
874 {
878 }
880 // Also, if there's a pre-existing specialization with matching
881 // constraints, then this also isn't new.
884 {
892 }
894 // Create a new type node (and corresponding type decl)
895 // for the newly declared specialization.
900 /* We only need a separate type node for storing the definition of this
901 partial specialization; uses of S<T*> are unconstrained, so all are
902 equivalent. So keep TYPE_CANONICAL the same. */
905 // Build the corresponding type decl.
911 }
914 }
916 /* The TYPE is being declared. If it is a template type, that means it
917 is a partial specialization. Do appropriate error-checking. */
919 tree
921 {
922 tree context;
927 /* A lambda that appears in specialization context is not itself a
928 specialization. */
933 {
937 }
942 {
948 else
951 }
953 {
954 /* This is for ordinary explicit specialization and partial
955 specialization of a template class such as:
957 template <> class C<int>;
959 or:
961 template <class T> class C<T*>;
963 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
966 {
973 {
978 }
979 }
985 /* Trying to define a specialization either without a template<> header
986 or in an inappropriate place. We've already given an error, so just
987 bail now so we don't actually define the specialization. */
989 }
995 {
996 /* This is for an explicit specialization of member class
997 template according to [temp.expl.spec/18]:
999 template <> template <class U> class C<int>::D;
1001 The context `C<int>' must be an implicit instantiation.
1002 Otherwise this is just a member class template declared
1003 earlier like:
1005 template <> class C<int> { template <class U> class D; };
1006 template <> template <class U> class C<int>::D;
1008 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1009 while in the second case, `C<int>::D' is a primary template
1010 and `C<T>::D' may not exist. */
1014 {
1015 tree t;
1020 {
1025 }
1027 /* Check for invalid specialization after instantiation:
1029 template <> template <> class C<int>::D<int>;
1030 template <> template <class U> class C<int>::D; */
1034 {
1038 {
1039 /* We already have a full specialization of this partial
1040 instantiation, or a full specialization has been
1041 looked up but not instantiated. Reassign it to the
1042 new member specialization template. */
1043 spec_entry elt;
1055 spec_entry **slot
1060 }
1061 else
1062 /* But if we've had an implicit instantiation, that's a
1063 problem ([temp.expl.spec]/6). */
1066 }
1068 /* Mark TYPE as a specialization. And as a result, we only
1069 have one level of template argument for the innermost
1070 class template. */
1075 }
1076 }
1078 {
1079 /* Someday C++0x may allow for enum template specialization. */
1084 else
1085 {
1088 }
1089 }
1092 }
1094 /* Returns nonzero if we can optimize the retrieval of specializations
1095 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1096 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1100 {
1103 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1104 parameter. */
1106 /* The optimized lookup depends on the fact that the
1107 template arguments for the member function template apply
1108 purely to the containing class, which is not true if the
1109 containing class is an explicit or partial
1110 specialization. */
1114 /* It is possible to have a template that is not a member
1115 template and is not a member of a template class:
1117 template <typename T>
1118 struct S { friend A::f(); };
1120 Here, the friend function is a template, but the context does
1121 not have template information. The optimized lookup relies
1122 on having ARGS be the template arguments for both the class
1123 and the function template. */
1125 }
1127 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1128 gone through coerce_template_parms by now. */
1130 static void
1132 {
1135 {
1138 {
1145 /* Allow typedefs on the type of a non-type argument, since a
1147 else
1149 }
1150 }
1152 }
1154 /* Retrieve the specialization (in the sense of [temp.spec] - a
1155 specialization is either an instantiation or an explicit
1156 specialization) of TMPL for the given template ARGS. If there is
1157 no such specialization, return NULL_TREE. The ARGS are a vector of
1158 arguments, or a vector of vectors of arguments, in the case of
1159 templates with more than one level of parameters.
1161 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1162 then we search for a partial specialization matching ARGS. This
1163 parameter is ignored if TMPL is not a class template.
1165 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1166 result is a NONTYPE_ARGUMENT_PACK. */
1168 static tree
1170 {
1180 /* There should be as many levels of arguments as there are
1181 levels of parameters. */
1191 {
1192 /* The template arguments actually apply to the containing
1193 class. Find the class specialization with those
1194 arguments. */
1196 tree class_specialization
1201 /* Find the instance of TMPL. */
1204 {
1207 /* using-declarations can add base methods to the method vec,
1208 and we don't want those here. */
1211 }
1213 }
1214 else
1215 {
1217 spec_entry elt;
1226 else
1234 }
1237 }
1239 /* Like retrieve_specialization, but for local declarations. */
1241 tree
1243 {
1249 }
1251 /* Returns nonzero iff DECL is a specialization of TMPL. */
1253 int
1255 {
1256 tree t;
1259 {
1265 }
1266 else
1267 {
1276 }
1279 }
1281 /* Returns nonzero iff DECL is a specialization of friend declaration
1282 FRIEND_DECL according to [temp.friend]. */
1284 bool
1286 {
1293 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1294 of a template class, we want to check if DECL is a specialization
1295 if this. */
1299 {
1300 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1303 }
1308 /* There is nothing to do if this is not a template friend. */
1315 /* [temp.friend/6]
1316 A member of a class template may be declared to be a friend of a
1317 non-template class. In this case, the corresponding member of
1318 every specialization of the class template is a friend of the
1319 class granting friendship.
1321 For example, given a template friend declaration
1323 template <class T> friend void A<T>::f();
1325 the member function below is considered a friend
1327 template <> struct A<int> {
1328 void f();
1329 };
1331 For this type of template friend, TEMPLATE_DEPTH below will be
1332 nonzero. To determine if DECL is a friend of FRIEND, we first
1333 check if the enclosing class is a specialization of another. */
1340 {
1341 /* Next, we check the members themselves. In order to handle
1342 a few tricky cases, such as when FRIEND_DECL's are
1344 template <class T> friend void A<T>::g(T t);
1345 template <class T> template <T t> friend void A<T>::h();
1347 and DECL's are
1349 void A<int>::g(int);
1350 template <int> void A<int>::h();
1352 we need to figure out ARGS, the template arguments from
1353 the context of DECL. This is required for template substitution
1354 of `T' in the function parameter of `g' and template parameter
1355 of `h' in the above examples. Here ARGS corresponds to `int'. */
1362 {
1364 {
1367 else
1369 current_depth++;
1370 }
1372 }
1375 {
1377 tree friend_type;
1378 tree decl_type;
1379 tree friend_args_type;
1380 tree decl_args_type;
1382 /* Make sure that both DECL and FRIEND_DECL are templates or
1383 non-templates. */
1389 {
1390 /* If both are templates, check template parameter list. */
1391 tree friend_parms
1396 friend_parms))
1400 }
1401 else
1409 /* Check if return types match. */
1413 /* Check if function parameter types match, ignoring the
1414 `this' parameter. */
1423 }
1424 else
1425 {
1426 /* DECL is a TYPE_DECL */
1430 /* Make sure that both DECL and FRIEND_DECL are templates or
1431 non-templates. */
1432 is_template
1439 {
1440 tree friend_parms;
1441 /* If both are templates, check the name of the two
1442 TEMPLATE_DECL's first because is_friend didn't. */
1447 /* Now check template parameter list. */
1448 friend_parms
1451 return comp_template_parms
1453 friend_parms);
1454 }
1455 else
1458 }
1459 }
1461 }
1463 /* Register the specialization SPEC as a specialization of TMPL with
1464 the indicated ARGS. IS_FRIEND indicates whether the specialization
1465 is actually just a friend declaration. Returns SPEC, or an
1466 equivalent prior declaration, if available.
1468 We also store instantiations of field packs in the hash table, even
1469 though they are not themselves templates, to make lookup easier. */
1471 static tree
1473 hashval_t hash)
1474 {
1475 tree fn;
1477 spec_entry elt;
1485 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1486 register it; we want the corresponding TEMPLATE_DECL instead.
1487 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1488 the more obvious `uses_template_parms (spec)' to avoid problems
1489 with default function arguments. In particular, given
1490 something like this:
1492 template <class T> void f(T t1, T t = T())
1494 the default argument expression is not substituted for in an
1495 instantiation unless and until it is actually needed. */
1499 /* We don't put these specializations in the hash table, but we might
1500 want to give an error about a mismatch. */
1502 else
1503 {
1511 slot =
1515 else
1517 }
1519 /* We can sometimes try to re-register a specialization that we've
1520 already got. In particular, regenerate_decl_from_template calls
1521 duplicate_decls which will update the specialization list. But,
1522 we'll still get called again here anyhow. It's more convenient
1523 to simply allow this than to try to prevent it. */
1527 {
1529 {
1532 {
1534 fn);
1536 }
1537 else
1538 {
1539 tree clone;
1540 /* This situation should occur only if the first
1541 specialization is an implicit instantiation, the
1542 second is an explicit specialization, and the
1543 implicit instantiation has not yet been used. That
1544 situation can occur if we have implicitly
1545 instantiated a member function and then specialized
1546 it later.
1548 We can also wind up here if a friend declaration that
1549 looked like an instantiation turns out to be a
1550 specialization:
1552 template <class T> void foo(T);
1553 class S { friend void foo<>(int) };
1554 template <> void foo(int);
1556 We transform the existing DECL in place so that any
1557 pointers to it become pointers to the updated
1558 declaration.
1560 If there was a definition for the template, but not
1561 for the specialization, we want this to look as if
1562 there were no definition, and vice versa. */
1565 /* The call to duplicate_decls will have applied
1566 [temp.expl.spec]:
1568 An explicit specialization of a function template
1569 is inline only if it is explicitly declared to be,
1570 and independently of whether its function template
1571 is.
1573 to the primary function; now copy the inline bits to
1574 the various clones. */
1576 {
1583 }
1587 }
1588 }
1590 {
1593 /* We've already complained in duplicate_decls. */
1597 /* Dup decl failed, but this is a new definition. Set the
1598 line number so any errors match this new
1599 definition. */
1603 }
1604 }
1608 /* A specialization must be declared in the same namespace as the
1609 template it is specializing. */
1615 {
1624 /* If TMPL is a forward declaration of a template function, keep a list
1625 of all specializations in case we need to reassign them to a friend
1626 template later in tsubst_friend_function.
1628 Also keep a list of all variable template instantiations so that
1629 process_partial_specialization can check whether a later partial
1630 specialization would have used it. */
1633 }
1636 }
1638 /* Returns true iff two spec_entry nodes are equivalent. */
1642 bool
1644 {
1651 /* tmpl could be a FIELD_DECL for a capture pack. */
1655 {
1656 /* Partial specializations of a variable template can be distinguished by
1657 constraints. */
1661 }
1665 }
1667 /* Returns a hash for a template TMPL and template arguments ARGS. */
1669 static hashval_t
1671 {
1674 }
1676 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1677 ignoring SPEC. */
1679 hashval_t
1681 {
1683 }
1685 /* Recursively calculate a hash value for a template argument ARG, for use
1686 in the hash tables of template specializations. */
1688 hashval_t
1690 {
1710 {
1718 {
1723 }
1745 {
1749 {
1752 }
1754 }
1758 {
1761 }
1772 val = iterative_hash_template_arg
1784 val);
1786 val);
1795 /* A lambda can't appear in a template arg, but don't crash on
1796 erroneous input. */
1808 /* Now hash operands as usual. */
1813 }
1816 {
1819 {
1820 // We want an alias specialization that survived strip_typedefs
1821 // to hash differently from its TYPE_CANONICAL, to avoid hash
1822 // collisions that compare as different in template_args_equal.
1823 // These could be dependent specializations that strip_typedefs
1824 // left alone, or untouched specializations because
1825 // coerce_template_parms returns the unconverted template
1826 // arguments if it sees incomplete argument packs.
1829 }
1832 val);
1835 /* Otherwise just compare the types during lookup. */
1844 {
1849 }
1850 }
1853 }
1855 /* Unregister the specialization SPEC as a specialization of TMPL.
1856 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1857 if the SPEC was listed as a specialization of TMPL.
1859 Note that SPEC has been ggc_freed, so we can't look inside it. */
1861 bool
1863 {
1865 spec_entry elt;
1873 {
1878 }
1881 }
1883 /* Like register_specialization, but for local declarations. We are
1884 registering SPEC, an instantiation of TMPL. */
1886 void
1888 {
1890 }
1892 /* TYPE is a class type. Returns true if TYPE is an explicitly
1893 specialized class. */
1895 bool
1897 {
1901 }
1903 /* Print the list of functions at FNS, going through all the overloads
1904 for each element of the list. Alternatively, FNS can not be a
1905 TREE_LIST, in which case it will be printed together with all the
1906 overloads.
1908 MORE and *STR should respectively be FALSE and NULL when the function
1909 is called from the outside. They are used internally on recursive
1910 calls. print_candidates manages the two parameters and leaves NULL
1911 in *STR when it ends. */
1913 static void
1915 {
1919 else
1921 {
1927 {
1930 else
1933 }
1935 }
1936 }
1938 /* Print the list of candidate FNS in an error message. FNS can also
1939 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1941 void
1943 {
1947 }
1949 /* Get a (possibly) constrained template declaration for the
1950 purpose of ordering candidates. */
1951 static tree
1953 {
1959 }
1961 /* Among candidates having the same signature, return the
1962 most constrained or NULL_TREE if there is no best candidate.
1963 If the signatures of candidates vary (e.g., template
1964 specialization vs. member function), then there can be no
1965 most constrained.
1967 Note that we don't compare constraints on the functions
1968 themselves, but rather those of their templates. */
1969 static tree
1971 {
1972 // Try to find the best candidate in a first pass.
1975 {
1982 }
1984 // Verify that the champ is better than previous candidates.
1989 }
1992 }
1995 /* Returns the template (one of the functions given by TEMPLATE_ID)
1996 which can be specialized to match the indicated DECL with the
1997 explicit template args given in TEMPLATE_ID. The DECL may be
1998 NULL_TREE if none is available. In that case, the functions in
1999 TEMPLATE_ID are non-members.
2001 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2002 specialization of a member template.
2004 The TEMPLATE_COUNT is the number of references to qualifying
2005 template classes that appeared in the name of the function. See
2006 check_explicit_specialization for a more accurate description.
2008 TSK indicates what kind of template declaration (if any) is being
2009 declared. TSK_TEMPLATE indicates that the declaration given by
2010 DECL, though a FUNCTION_DECL, has template parameters, and is
2011 therefore a template function.
2013 The template args (those explicitly specified and those deduced)
2014 are output in a newly created vector *TARGS_OUT.
2016 If it is impossible to determine the result, an error message is
2017 issued. The error_mark_node is returned to indicate failure. */
2019 static tree
2021 tree decl,
2025 tmpl_spec_kind tsk)
2026 {
2027 tree fns;
2028 tree targs;
2029 tree explicit_targs;
2032 /* A TREE_LIST of templates of which DECL may be a specialization.
2033 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2034 corresponding TREE_PURPOSE is the set of template arguments that,
2035 when used to instantiate the template, would produce a function
2036 with the signature of DECL. */
2046 /* We shouldn't be specializing a member template of an
2047 unspecialized class template; we already gave an error in
2048 check_specialization_scope, now avoid crashing. */
2051 {
2054 }
2062 /* Check for baselinks. */
2067 {
2070 }
2072 {
2075 }
2077 /* Count the number of template headers specified for this
2078 specialization. */
2088 {
2091 tf_warning_or_error,
2095 }
2097 {
2101 {
2102 tree decl_arg_types;
2103 tree fn_arg_types;
2104 tree insttype;
2106 /* In case of explicit specialization, we need to check if
2107 the number of template headers appearing in the specialization
2108 is correct. This is usually done in check_explicit_specialization,
2109 but the check done there cannot be exhaustive when specializing
2110 member functions. Consider the following code:
2112 template <> void A<int>::f(int);
2113 template <> template <> void A<int>::f(int);
2115 Assuming that A<int> is not itself an explicit specialization
2116 already, the first line specializes "f" which is a non-template
2117 member function, whilst the second line specializes "f" which
2118 is a template member function. So both lines are syntactically
2119 correct, and check_explicit_specialization does not reject
2120 them.
2122 Here, we can do better, as we are matching the specialization
2123 against the declarations. We count the number of template
2124 headers, and we check if they match TEMPLATE_COUNT + 1
2125 (TEMPLATE_COUNT is the number of qualifying template classes,
2126 plus there must be another header for the member template
2127 itself).
2129 Notice that if header_count is zero, this is not a
2130 specialization but rather a template instantiation, so there
2131 is no check we can perform here. */
2135 /* Check that the number of template arguments at the
2136 innermost level for DECL is the same as for FN. */
2144 /* DECL might be a specialization of FN. */
2148 /* For a non-static member function, we need to make sure
2149 that the const qualification is the same. Since
2150 get_bindings does not try to merge the "this" parameter,
2151 we must do the comparison explicitly. */
2157 /* Skip the "this" parameter and, for constructors of
2158 classes with virtual bases, the VTT parameter. A
2159 full specialization of a constructor will have a VTT
2160 parameter, but a template never will. */
2161 decl_arg_types
2163 fn_arg_types
2166 /* Function templates cannot be specializations; there are
2167 no partial specializations of functions. Therefore, if
2168 the type of DECL does not match FN, there is no
2169 match.
2171 Note that it should never be the case that we have both
2172 candidates added here, and for regular member functions
2173 below. */
2175 {
2179 }
2181 /* See whether this function might be a specialization of this
2182 template. Suppress access control because we might be trying
2183 to make this specialization a friend, and we have already done
2184 access control for the declaration of the specialization. */
2190 /* We cannot deduce template arguments that when used to
2191 specialize TMPL will produce DECL. */
2194 /* Remove, from the set of candidates, all those functions
2195 whose constraints are not satisfied. */
2199 // Then, try to form the new function type.
2203 fn_arg_types
2208 /* Save this template, and the arguments deduced. */
2210 }
2212 /* FN is an ordinary member function, and we need a
2213 specialization of a member template. */
2214 ;
2216 /* We can get IDENTIFIER_NODEs here in certain erroneous
2217 cases. */
2218 ;
2220 /* This is just an ordinary non-member function. Nothing can
2221 be a specialization of that. */
2222 ;
2224 /* Cannot specialize functions that are created implicitly. */
2225 ;
2226 else
2227 {
2228 tree decl_arg_types;
2230 /* This is an ordinary member function. However, since
2231 we're here, we can assume its enclosing class is a
2232 template class. For example,
2234 template <typename T> struct S { void f(); };
2235 template <> void S<int>::f() {}
2237 Here, S<int>::f is a non-template, but S<int> is a
2238 template class. If FN has the same type as DECL, we
2239 might be in business. */
2242 /* Its enclosing class is an explicit specialization
2243 of a template class. This is not a candidate. */
2248 /* The return types differ. */
2251 /* Adjust the type of DECL in case FN is a static member. */
2258 decl_arg_types))
2261 // If the deduced arguments do not satisfy the constraints,
2262 // this is not a candidate.
2266 // Add the candidate.
2268 }
2269 }
2272 {
2273 /* We have:
2275 [temp.expl.spec]
2277 It is possible for a specialization with a given function
2278 signature to be instantiated from more than one function
2279 template. In such cases, explicit specification of the
2280 template arguments must be used to uniquely identify the
2281 function template specialization being specialized.
2283 Note that here, there's no suggestion that we're supposed to
2284 determine which of the candidate templates is most
2285 specialized. However, we, also have:
2287 [temp.func.order]
2289 Partial ordering of overloaded function template
2290 declarations is used in the following contexts to select
2291 the function template to which a function template
2292 specialization refers:
2294 -- when an explicit specialization refers to a function
2295 template.
2297 So, we do use the partial ordering rules, at least for now.
2298 This extension can only serve to make invalid programs valid,
2299 so it's safe. And, there is strong anecdotal evidence that
2300 the committee intended the partial ordering rules to apply;
2301 the EDG front end has that behavior, and John Spicer claims
2302 that the committee simply forgot to delete the wording in
2303 [temp.expl.spec]. */
2306 {
2309 }
2310 }
2312 // Concepts allows multiple declarations of member functions
2313 // with the same signature. Like above, we need to rely on
2314 // on the partial ordering of those candidates to determine which
2315 // is the best.
2317 {
2319 {
2322 }
2323 }
2326 {
2333 else
2336 }
2340 {
2346 }
2348 /* We have one, and exactly one, match. */
2350 {
2354 // Propagate the candidate's constraints to the declaration.
2357 /* DECL is a re-declaration or partial instantiation of a template
2358 function. */
2361 /* It was a specialization of an ordinary member function in a
2362 template class. */
2364 }
2366 /* It was a specialization of a template. */
2369 {
2374 }
2375 else
2378 }
2380 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2381 but with the default argument values filled in from those in the
2382 TMPL_TYPES. */
2384 static tree
2386 tree tmpl_types)
2387 {
2388 tree new_spec_types;
2396 /* Substitute into the rest of the list. */
2397 new_spec_types =
2401 /* Add the default argument for this parameter. */
2404 new_spec_types);
2405 }
2407 /* DECL is an explicit specialization. Replicate default arguments
2408 from the template it specializes. (That way, code like:
2410 template <class T> void f(T = 3);
2411 template <> void f(double);
2412 void g () { f (); }
2414 works, as required.) An alternative approach would be to look up
2415 the correct default arguments at the call-site, but this approach
2416 is consistent with how implicit instantiations are handled. */
2418 static void
2420 {
2421 tree tmpl;
2422 tree spec_types;
2423 tree tmpl_types;
2424 tree new_spec_types;
2425 tree old_type;
2426 tree new_type;
2427 tree t;
2432 /* See if there's anything we need to do. */
2445 {
2446 /* Remove the this pointer, but remember the object's type for
2447 CV quals. */
2453 {
2454 /* DECL may contain more parameters than TMPL due to the extra
2455 in-charge parameter in constructors and destructors. */
2458 }
2460 {
2463 }
2464 }
2466 /* Compute the merged default arguments. */
2467 new_spec_types =
2470 /* Compute the new FUNCTION_TYPE. */
2472 {
2476 new_spec_types);
2479 /* Put the in-charge parameter back. */
2482 new_spec_types);
2486 new_spec_types);
2487 }
2488 else
2490 new_spec_types);
2500 }
2502 /* Return the number of template headers we expect to see for a definition
2503 or specialization of CTYPE or one of its non-template members. */
2505 int
2507 {
2511 {
2512 /* You're supposed to have one `template <...>' for every
2513 template class, but you don't need one for a full
2514 specialization. For example:
2516 template <class T> struct S{};
2517 template <> struct S<int> { void f(); };
2518 void S<int>::f () {}
2520 is correct; there shouldn't be a `template <>' for the
2521 definition of `S<int>::f'. */
2523 /* If CTYPE does not have template information of any
2524 kind, then it is not a template, nor is it nested
2525 within a template. */
2533 }
2536 }
2538 /* Do a simple sanity check on the template headers that precede the
2539 variable declaration DECL. */
2541 void
2543 {
2548 {
2551 "variable templates only available with "
2554 // Namespace-scope variable templates should have a template header.
2556 }
2558 {
2560 "too many template headers for %qD "
2566 "members of an explicitly specialized class are defined "
2568 }
2569 }
2571 /* An explicit specialization whose declarator-id or class-head-name is not
2572 qualified shall be declared in the nearest enclosing namespace of the
2573 template, or, if the namespace is inline (7.3.1), any namespace from its
2574 enclosing namespace set.
2576 If the name declared in the explicit instantiation is an unqualified name,
2577 the explicit instantiation shall appear in the namespace where its template
2578 is declared or, if that namespace is inline (7.3.1), any namespace from its
2579 enclosing namespace set. */
2581 void
2583 {
2588 {
2594 /* This was allowed in C++98, so only pedwarn. */
2596 "outside its namespace must use a nested-name-"
2598 }
2599 }
2601 /* Check to see if the function just declared, as indicated in
2602 DECLARATOR, and in DECL, is a specialization of a function
2603 template. We may also discover that the declaration is an explicit
2604 instantiation at this point.
2606 Returns DECL, or an equivalent declaration that should be used
2607 instead if all goes well. Issues an error message if something is
2608 amiss. Returns error_mark_node if the error is not easily
2609 recoverable.
2611 FLAGS is a bitmask consisting of the following flags:
2613 2: The function has a definition.
2614 4: The function is a friend.
2616 The TEMPLATE_COUNT is the number of references to qualifying
2617 template classes that appeared in the name of the function. For
2618 example, in
2620 template <class T> struct S { void f(); };
2621 void S<int>::f();
2623 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2624 classes are not counted in the TEMPLATE_COUNT, so that in
2626 template <class T> struct S {};
2627 template <> struct S<int> { void f(); }
2628 template <> void S<int>::f();
2630 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2631 invalid; there should be no template <>.)
2633 If the function is a specialization, it is marked as such via
2634 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2635 is set up correctly, and it is added to the list of specializations
2636 for that template. */
2638 tree
2640 tree decl,
2643 {
2652 tmpl_spec_kind tsk;
2655 {
2658 else
2660 }
2661 else
2665 {
2668 {
2671 }
2673 {
2675 /* This could be something like:
2677 template <class T> void f(T);
2678 class S { friend void f<>(int); } */
2680 else
2681 {
2682 /* This case handles bogus declarations like template <>
2683 template <class T> void f<int>(); */
2686 declarator);
2688 }
2689 }
2693 /* The error has already been reported in
2694 check_specialization_scope. */
2700 /* Fall through. */
2713 decl);
2716 else
2720 /* Fall through. */
2726 /* In cases like template<> constexpr bool v = true;
2727 We'll give an error in check_template_variable. */
2733 else
2739 {
2740 /* This case handles bogus declarations like template <>
2741 template <class T> void f<int>(); */
2745 declarator);
2747 {
2748 /* Partial specialization of variable template. */
2752 }
2756 else
2760 ok:;
2761 }
2764 /* This is a specialization of a member template, without
2765 specialization the containing class. Something like:
2767 template <class T> struct S {
2768 template <class U> void f (U);
2769 };
2770 template <> template <class U> void S<int>::f(U) {}
2772 That's a specialization -- but of the entire template. */
2778 }
2781 /* This doesn't apply to variable templates. */
2784 {
2788 {
2792 }
2793 }
2796 {
2801 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2803 {
2804 tree fns;
2809 else
2810 {
2811 /* If there is no class context, the explicit instantiation
2812 must be at namespace scope. */
2815 /* Find the namespace binding, using the declaration
2816 context. */
2820 /* If lookup fails, look for a friend declaration so we can
2821 give a better diagnostic. */
2827 {
2830 }
2831 }
2834 }
2840 {
2842 /* A specialization in class scope. This is invalid,
2843 but the error will already have been flagged by
2844 check_specialization_scope. */
2846 else
2847 {
2848 /* It's not valid to write an explicit instantiation in
2849 class scope, e.g.:
2851 class C { template void f(); }
2853 This case is caught by the parser. However, on
2854 something like:
2856 template class C { void f(); };
2858 (which is invalid) we can get here. The error will be
2859 issued later. */
2860 ;
2861 }
2864 }
2867 {
2868 // We'll match variable templates in start_decl.
2872 /* Find the list of functions in ctype that have the same
2873 name as the declared function. */
2877 {
2881 {
2882 /* From [temp.expl.spec]:
2884 If such an explicit specialization for the member
2885 of a class template names an implicitly-declared
2886 special member function (clause _special_), the
2887 program is ill-formed.
2889 Similar language is found in [temp.explicit]. */
2892 }
2895 }
2897 /* For a type-conversion operator, We might be looking for
2898 `operator int' which will be a specialization of
2899 `operator T'. Grab all the conversion operators, and
2900 then select from them. */
2906 {
2909 }
2910 else
2912 }
2914 /* Figure out what exactly is being specialized at this point.
2915 Note that for an explicit instantiation, even one for a
2916 member function, we cannot tell a priori whether the
2917 instantiation is for a member template, or just a member
2918 function of a template class. Even if a member template is
2919 being instantiated, the member template arguments may be
2920 elided if they can be deduced from the rest of the
2921 declaration. */
2924 member_specialization,
2925 template_count,
2926 tsk);
2929 /* We couldn't figure out what this declaration was
2930 specializing. */
2932 else
2933 {
2936 {
2938 "friend declaration %qD is not visible to "
2942 }
2950 {
2951 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2952 is done by do_decl_instantiation later. */
2958 {
2959 /* If TMPL is not the most general template (for
2960 example, if TMPL is a friend template that is
2961 injected into namespace scope), then there will
2962 be too many levels of TARGS. Remove some of them
2963 here. */
2965 tree new_targs;
2972 }
2975 }
2977 /* If we thought that the DECL was a member function, but it
2978 turns out to be specializing a static member function,
2979 make DECL a static member function as well. */
2985 /* If this is a specialization of a member template of a
2986 template class, we want to return the TEMPLATE_DECL, not
2987 the specialization of it. */
2989 {
2994 {
2995 tree parm;
2999 /* We want to use the argument list specified in the
3000 definition, not in the original declaration. */
3005 }
3008 }
3010 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3016 /* Inherit default function arguments from the template
3017 DECL is specializing. */
3021 /* This specialization has the same protection as the
3022 template it specializes. */
3026 /* 7.1.1-1 [dcl.stc]
3028 A storage-class-specifier shall not be specified in an
3029 explicit specialization...
3031 The parser rejects these, so unless action is taken here,
3032 explicit function specializations will always appear with
3033 global linkage.
3035 The action recommended by the C++ CWG in response to C++
3036 defect report 605 is to make the storage class and linkage
3037 of the explicit specialization match the templated function:
3039 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3040 */
3042 {
3046 /* A concept cannot be specialized. */
3048 {
3050 gen_tmpl);
3052 }
3054 /* This specialization has the same linkage and visibility as
3055 the function template it specializes. */
3058 {
3061 }
3064 {
3067 }
3068 }
3070 /* If DECL is a friend declaration, declared using an
3071 unqualified name, the namespace associated with DECL may
3072 have been set incorrectly. For example, in:
3074 template <typename T> void f(T);
3075 namespace N {
3076 struct S { friend void f<int>(int); }
3077 }
3079 we will have set the DECL_CONTEXT for the friend
3080 declaration to N, rather than to the global namespace. */
3085 /* This is not really a declaration of a specialization.
3086 It's just the name of an instantiation. But, it's not
3087 a request for an instantiation, either. */
3090 /* A specialization is not necessarily COMDAT. */
3096 /* If this is a full specialization, register it so that we can find
3097 it again. Partial specializations will be registered in
3098 process_partial_specialization. */
3103 /* A 'structor should already have clones. */
3109 }
3110 }
3113 }
3115 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3116 parameters. These are represented in the same format used for
3117 DECL_TEMPLATE_PARMS. */
3119 int
3121 {
3122 const_tree p1;
3123 const_tree p2;
3131 {
3143 {
3147 /* If either of the template parameters are invalid, assume
3148 they match for the sake of error recovery. */
3161 }
3162 }
3165 /* One set of parameters has more parameters lists than the
3166 other. */
3170 }
3172 /* Determine whether PARM is a parameter pack. */
3174 bool
3176 {
3177 /* Determine if we have a non-type template parameter pack. */
3184 /* If this is a list of template parameters, we could get a
3185 TYPE_DECL or a TEMPLATE_DECL. */
3189 /* Otherwise it must be a type template parameter. */
3193 }
3195 /* Determine if T is a function parameter pack. */
3197 bool
3199 {
3203 }
3205 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3206 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3208 tree
3210 {
3217 }
3219 /* Return true iff the function parameter PARAM_DECL was expanded
3220 from the function parameter pack PACK. */
3222 bool
3224 {
3229 /* The parameter pack and its pack arguments have the same
3230 DECL_PARM_INDEX. */
3232 }
3234 /* Determine whether ARGS describes a variadic template args list,
3235 i.e., one that is terminated by a template argument pack. */
3237 static bool
3239 {
3241 tree last_parm;
3255 }
3257 /* Generate a new name for the parameter pack name NAME (an
3258 IDENTIFIER_NODE) that incorporates its */
3260 static tree
3262 {
3263 /* Munge the name to include the parameter index. */
3264 #define NUMBUF_LEN 128
3278 }
3280 /* Return true if T is a primary function, class or alias template
3281 instantiation. */
3283 bool
3285 {
3299 }
3301 /* Return true if PARM is a template template parameter. */
3303 bool
3305 {
3307 }
3309 /* Return true iff PARM is a DECL representing a type template
3310 parameter. */
3312 bool
3314 {
3319 }
3321 /* Return the template parameters of T if T is a
3322 primary template instantiation, NULL otherwise. */
3324 tree
3326 {
3331 parms = INNERMOST_TEMPLATE_PARMS
3335 }
3337 /* Return the template parameters of the LEVELth level from the full list
3338 of template parameters PARMS. */
3340 tree
3342 {
3343 tree p;
3354 }
3356 /* Returns the template arguments of T if T is a template instantiation,
3357 NULL otherwise. */
3359 tree
3361 {
3369 }
3371 /* Return the argument pack elements of T if T is a template argument pack,
3372 NULL otherwise. */
3374 tree
3376 {
3382 }
3384 /* True iff FN is a function representing a built-in variadic parameter
3385 pack. */
3387 bool
3389 {
3399 }
3401 /* True iff CALL is a call to a function representing a built-in variadic
3402 parameter pack. */
3404 static bool
3406 {
3410 }
3412 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3414 static tree
3416 tree in_decl)
3417 {
3423 {
3425 {
3428 }
3433 }
3434 else
3435 {
3439 /* Calculate the largest value of len that won't make the size of the vec
3440 overflow an int. The compiler will exceed resource limits long before
3441 this, but it seems a decent place to diagnose. */
3445 {
3450 }
3458 }
3459 }
3461 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3462 CALL. */
3464 static tree
3466 tree in_decl)
3467 {
3477 }
3479 /* Structure used to track the progress of find_parameter_packs_r. */
3480 struct find_parameter_pack_data
3481 {
3482 /* TREE_LIST that will contain all of the parameter packs found by
3483 the traversal. */
3486 /* Set of AST nodes that have been visited by the traversal. */
3489 /* True iff we're making a type pack expansion. */
3491 };
3493 /* Identifies all of the argument packs that occur in a template
3494 argument and appends them to the TREE_LIST inside DATA, which is a
3495 find_parameter_pack_data structure. This is a subroutine of
3496 make_pack_expansion and uses_parameter_packs. */
3497 static tree
3499 {
3505 /* Handle type aliases/typedefs. */
3507 {
3514 }
3516 /* Identify whether this is a parameter pack or not. */
3518 {
3526 /* FALLTHRU */
3528 /* If the placeholder appears in the decl-specifier-seq of a function
3529 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3530 is a pack expansion, the invented template parameter is a template
3531 parameter pack. */
3541 {
3542 /* We don't want to walk into the type of a PARM_DECL,
3543 because we don't want to see the type parameter pack. */
3546 }
3549 /* Look through a lambda capture proxy to the field pack. */
3552 {
3558 }
3560 {
3562 find_parameter_packs_r,
3565 }
3577 /* Not a parameter pack. */
3579 }
3582 {
3583 /* Add this parameter pack to the list. */
3585 }
3591 /* This switch statement will return immediately if we don't find a
3592 parameter pack. */
3594 {
3599 /* Check the template itself. */
3602 /* Check the template arguments. */
3618 /* Fall through. */
3663 {
3664 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3665 type_pack_expansion_p to false so that any placeholders
3666 within the expression don't get marked as parameter packs. */
3674 }
3678 }
3681 }
3683 /* Determines if the expression or type T uses any parameter packs. */
3684 bool
3686 {
3695 }
3697 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3698 representation a base-class initializer into a parameter pack
3699 expansion. If all goes well, the resulting node will be an
3700 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3701 respectively. */
3702 tree
3704 {
3705 tree result;
3714 {
3715 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3716 class initializer. In this case, the TREE_PURPOSE will be a
3717 _TYPE node (representing the base class expansion we're
3718 initializing) and the TREE_VALUE will be a TREE_LIST
3719 containing the initialization arguments.
3721 The resulting expansion looks somewhat different from most
3722 expansions. Rather than returning just one _EXPANSION, we
3723 return a TREE_LIST whose TREE_PURPOSE is a
3724 TYPE_PACK_EXPANSION containing the bases that will be
3725 initialized. The TREE_VALUE will be identical to the
3726 original TREE_VALUE, which is a list of arguments that will
3727 be passed to each base. We do not introduce any new pack
3728 expansion nodes into the TREE_VALUE (although it is possible
3729 that some already exist), because the TREE_PURPOSE and
3730 TREE_VALUE all need to be expanded together with the same
3731 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3732 resulting TREE_PURPOSE will mention the parameter packs in
3733 both the bases and the arguments to the bases. */
3734 tree purpose;
3735 tree value;
3738 /* Determine which parameter packs will be used by the base
3739 class expansion. */
3748 {
3752 }
3755 {
3756 /* Collect the sets of parameter packs used in each of the
3757 initialization arguments. */
3759 {
3760 /* Determine which parameter packs will be expanded in this
3761 argument. */
3764 }
3765 }
3769 /* Create the pack expansion type for the base type. */
3774 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3775 they will rarely be compared to anything. */
3779 }
3784 /* Build the PACK_EXPANSION_* node. */
3785 result = for_types
3790 {
3791 /* Propagate type and const-expression information. */
3794 /* Mark this read now, since the expansion might be length 0. */
3796 }
3797 else
3798 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3799 they will rarely be compared to anything. */
3802 /* Determine which parameter packs will be expanded. */
3809 /* Make sure we found some parameter packs. */
3811 {
3814 else
3817 }
3823 }
3825 /* Checks T for any "bare" parameter packs, which have not yet been
3826 expanded, and issues an error if any are found. This operation can
3827 only be done on full expressions or types (e.g., an expression
3828 statement, "if" condition, etc.), because we could have expressions like:
3830 foo(f(g(h(args)))...)
3832 where "args" is a parameter pack. check_for_bare_parameter_packs
3833 should not be called for the subexpressions args, h(args),
3834 g(h(args)), or f(g(h(args))), because we would produce erroneous
3835 error messages.
3837 Returns TRUE and emits an error if there were bare parameter packs,
3838 returns FALSE otherwise. */
3839 bool
3841 {
3858 {
3862 {
3873 else
3878 else
3882 }
3885 }
3888 }
3890 /* Expand any parameter packs that occur in the template arguments in
3891 ARGS. */
3892 tree
3894 {
3903 /* First, determine if we need to expand anything, and the number of
3904 slots we'll need. */
3906 {
3911 {
3915 else
3917 }
3918 else
3919 {
3921 num_result_args++;
3922 }
3923 }
3925 /* If no expansion is necessary, we're done. */
3929 /* Expand arguments. */
3932 non_default_args_count =
3935 {
3938 {
3945 }
3946 else
3947 {
3950 }
3951 }
3955 }
3957 /* Checks if DECL shadows a template parameter.
3959 [temp.local]: A template-parameter shall not be redeclared within its
3960 scope (including nested scopes).
3962 Emits an error and returns TRUE if the DECL shadows a parameter,
3963 returns FALSE otherwise. */
3965 bool
3967 {
3968 tree olddecl;
3970 /* If we're not in a template, we can't possibly shadow a template
3971 parameter. */
3975 /* Figure out what we're shadowing. */
3979 /* If there's no previous binding for this name, we're not shadowing
3980 anything, let alone a template parameter. */
3984 /* If we're not shadowing a template parameter, we're done. Note
3985 that OLDDECL might be an OVERLOAD (or perhaps even an
3986 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3987 node. */
3991 /* We check for decl != olddecl to avoid bogus errors for using a
3992 name inside a class. We check TPFI to avoid duplicate errors for
3993 inline member templates. */
3999 /* Don't complain about the injected class name, as we've already
4000 complained about the class itself. */
4007 else
4012 }
4014 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4015 ORIG_LEVEL, DECL, and TYPE. */
4017 static tree
4021 tree decl,
4022 tree type)
4023 {
4034 }
4036 /* Find the canonical type parameter for the given template type
4037 parameter. Returns the canonical type parameter, which may be TYPE
4038 if no such parameter existed. */
4040 static tree
4042 {
4043 tree list;
4057 else
4058 {
4062 }
4063 }
4065 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4066 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4067 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4068 new one is created. */
4070 static tree
4072 tsubst_flags_t complain)
4073 {
4078 {
4097 /* Template template parameters need this. */
4099 {
4106 }
4107 }
4110 }
4112 /* Process information from new template parameter PARM and append it
4113 to the LIST being built. This new parameter is a non-type
4114 parameter iff IS_NON_TYPE is true. This new parameter is a
4115 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4116 is in PARM_LOC. */
4118 tree
4121 {
4130 {
4134 {
4138 else
4140 }
4143 }
4146 {
4152 {
4153 /* [temp.param]
4155 The top-level cv-qualifiers on the template-parameter are
4156 ignored when determining its type. */
4161 && !is_parameter_pack
4162 /* If we're in a nested template parameter list, the template
4163 template parameter could be a parameter pack. */
4165 {
4166 /* This template parameter is not a parameter pack, but it
4167 should be. Complain about "bare" parameter packs. */
4170 /* Recover by calling this a parameter pack. */
4172 }
4173 }
4175 /* A template parameter is not modifiable. */
4184 processing_template_decl,
4189 }
4190 else
4191 {
4192 tree t;
4196 {
4198 /* This is for distinguishing between real templates and template
4199 template parameters */
4203 }
4204 else
4205 {
4207 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4210 }
4217 processing_template_decl,
4221 }
4225 /* Build requirements for the type/template parameter.
4226 This must be done after SET_DECL_TEMPLATE_PARM_P or
4227 process_template_parm could fail. */
4232 /* Build the parameter node linking the parameter declaration,
4233 its default argument (if any), and its constraints (if any). */
4238 }
4240 /* The end of a template parameter list has been reached. Process the
4241 tree list into a parameter vector, converting each parameter into a more
4242 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4243 as PARM_DECLs. */
4245 tree
4247 {
4252 /* Pop the dummy parameter level and add the real one. */
4255 current_template_parms
4260 {
4264 }
4269 }
4271 // Explicitly indicate the end of the template parameter list. We assume
4272 // that the current template parameters have been constructed and/or
4273 // managed explicitly, as when creating new template template parameters
4274 // from a shorthand constraint.
4275 void
4277 {
4279 }
4281 /* end_template_decl is called after a template declaration is seen. */
4283 void
4285 {
4291 /* This matches the pushlevel in begin_template_parm_list. */
4296 }
4298 /* Takes a TREE_LIST representing a template parameter and convert it
4299 into an argument suitable to be passed to the type substitution
4300 functions. Note that If the TREE_LIST contains an error_mark
4301 node, the returned argument is error_mark_node. */
4303 tree
4305 {
4318 {
4322 {
4323 /* Turn this argument into a TYPE_ARGUMENT_PACK
4324 with a single element, which expands T. */
4333 }
4334 }
4335 else
4336 {
4340 {
4341 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4342 with a single element, which expands T. */
4352 }
4353 else
4355 }
4357 }
4359 /* Given a single level of template parameters (a TREE_VEC), return it
4360 as a set of template arguments. */
4362 static tree
4364 {
4374 }
4376 /* Given a set of template parameters, return them as a set of template
4377 arguments. The template parameters are represented as a TREE_VEC, in
4378 the form documented in cp-tree.h for template arguments. */
4380 static tree
4382 {
4383 tree header;
4388 /* If there is only one level of template parameters, we do not
4389 create a TREE_VEC of TREE_VECs. Instead, we return a single
4390 TREE_VEC containing the arguments. */
4395 {
4400 else
4402 }
4405 }
4407 /* Within the declaration of a template, return the currently active
4408 template parameters as an argument TREE_VEC. */
4410 static tree
4412 {
4414 }
4416 /* Update the declared TYPE by doing any lookups which were thought to be
4417 dependent, but are not now that we know the SCOPE of the declarator. */
4419 tree
4421 {
4432 /* Don't bother building up the args in this case. */
4434 {
4435 /* tsubst in the args corresponding to the template parameters,
4436 including auto if present. Most things will be unchanged, but
4437 make_typename_type and tsubst_qualified_id will resolve
4438 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4441 tree pushed;
4443 {
4447 }
4452 }
4458 {
4461 else
4463 }
4465 }
4467 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4468 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4469 the new template is a member template. */
4471 tree
4473 {
4481 }
4483 struct template_parm_data
4484 {
4485 /* The level of the template parameters we are currently
4486 processing. */
4489 /* The index of the specialization argument we are currently
4490 processing. */
4493 /* An array whose size is the number of template parameters. The
4494 elements are nonzero if the parameter has been used in any one
4495 of the arguments processed so far. */
4498 /* An array whose size is the number of template arguments. The
4499 elements are nonzero if the argument makes use of template
4500 parameters of this level. */
4502 };
4504 /* Subroutine of push_template_decl used to see if each template
4505 parameter in a partial specialization is used in the explicit
4506 argument list. If T is of the LEVEL given in DATA (which is
4507 treated as a template_parm_data*), then DATA->PARMS is marked
4508 appropriately. */
4510 static int
4512 {
4520 {
4523 }
4525 /* In C++17 the type of a non-type argument is a deduced context. */
4530 data,
4531 NULL,
4534 /* Return zero so that for_each_template_parm will continue the
4535 traversal of the tree; we want to mark *every* template parm. */
4537 }
4539 /* Process the partial specialization DECL. */
4541 static tree
4543 {
4550 tree inner_parms;
4551 tree inst;
4561 /* A concept cannot be specialized. */
4563 {
4566 }
4571 /* We check that each of the template parameters given in the
4572 partial specialization is used in the argument list to the
4573 specialization. For example:
4575 template <class T> struct S;
4576 template <class T> struct S<T*>;
4578 The second declaration is OK because `T*' uses the template
4579 parameter T, whereas
4581 template <class T> struct S<int>;
4583 is no good. Even trickier is:
4585 template <class T>
4586 struct S1
4587 {
4588 template <class U>
4589 struct S2;
4590 template <class U>
4591 struct S2<T>;
4592 };
4594 The S2<T> declaration is actually invalid; it is a
4595 full-specialization. Of course,
4597 template <class U>
4598 struct S2<T (*)(U)>;
4600 or some such would have been OK. */
4608 {
4613 NULL,
4615 }
4618 {
4619 /* One of the template parms was not used in a deduced context in the
4620 specialization. */
4622 {
4626 }
4630 }
4635 /* [temp.class.spec]
4637 The argument list of the specialization shall not be identical to
4638 the implicit argument list of the primary template. */
4639 tree main_args
4642 && (!flag_concepts
4645 {
4649 else
4653 }
4655 /* A partial specialization that replaces multiple parameters of the
4656 primary template with a pack expansion is less specialized for those
4657 parameters. */
4659 {
4661 "primary template because it replaces multiple parameters "
4664 /* Avoid crash in process_partial_specialization. */
4666 }
4668 /* If we aren't in a dependent class, we can actually try deduction. */
4670 /* FIXME we should be able to handle a partial specialization of a
4671 partial instantiation, but currently we can't (c++/41727). */
4674 {
4678 maintmpl);
4679 }
4681 /* [temp.class.spec]
4683 A partially specialized non-type argument expression shall not
4684 involve template parameters of the partial specialization except
4685 when the argument expression is a simple identifier.
4687 The type of a template parameter corresponding to a specialized
4688 non-type argument shall not be dependent on a parameter of the
4689 specialization.
4691 Also, we verify that pack expansions only occur at the
4692 end of the argument list. */
4696 {
4703 {
4704 /* Extract the arguments from the argument pack. We'll be
4705 iterating over these in the following loop. */
4708 }
4711 {
4713 /* Get the Jth argument in the parameter pack. */
4717 {
4718 /* Pack expansions must come at the end of the
4719 argument list. */
4722 {
4726 else
4729 }
4730 }
4733 /* We only care about the pattern. */
4739 /* This next two lines are the `argument expression is not just a
4740 simple identifier' condition and also the `specialized
4741 non-type argument' bit. */
4745 {
4749 arg);
4750 else
4751 {
4752 /* Look at the corresponding template parameter,
4753 marking which template parameters its type depends
4754 upon. */
4758 {
4759 /* We haven't yet initialized TPD2. Do so now. */
4761 /* The number of parameters here is the number in the
4762 main template, which, as checked in the assertion
4763 above, is NARGS. */
4767 }
4769 /* Mark the template parameters. But this time, we're
4770 looking for the template parameters of the main
4771 template, not in the specialization. */
4778 NULL,
4782 {
4783 /* The type depended on some template parameters.
4784 If they are fully specialized in the
4785 specialization, that's OK. */
4794 "type %qT of template argument %qE depends "
4796 "type %qT of template argument %qE depends "
4798 type,
4799 arg);
4800 }
4801 }
4802 }
4803 }
4804 }
4806 /* We should only get here once. */
4810 // Build the template decl.
4819 /* Give template template parms a DECL_CONTEXT of the template
4820 for which they are a parameter. */
4822 {
4826 }
4829 /* We didn't register this in check_explicit_specialization so we could
4830 wait until the constraints were set. */
4832 else
4842 {
4848 {
4856 "declaration of %qD ambiguates earlier template "
4860 "partial specialization of %qD after instantiation "
4862 }
4863 }
4866 }
4868 /* PARM is a template parameter of some form; return the corresponding
4869 TEMPLATE_PARM_INDEX. */
4871 static tree
4873 {
4886 }
4888 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4889 parameter packs used by the template parameter PARM. */
4891 static void
4893 {
4894 /* A type parm can't refer to another parm. */
4898 {
4902 }
4909 }
4911 /* PARM is a template parameter pack. Return any parameter packs used in
4912 its type or the type of any of its template parameters. If there are
4913 any such packs, it will be instantiated into a fixed template parameter
4914 list by partial instantiation rather than be fully deduced. */
4916 tree
4918 {
4919 /* This can only be true in a member template. */
4922 /* This can only be true for a parameter pack. */
4925 /* A type parm can't refer to another parm. */
4939 }
4941 /* Check that a template declaration's use of default arguments and
4942 parameter packs is not invalid. Here, PARMS are the template
4943 parameters. IS_PRIMARY is true if DECL is the thing declared by
4944 a primary template. IS_PARTIAL is true if DECL is a partial
4945 specialization.
4947 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4948 declaration (but not a definition); 1 indicates a declaration, 2
4949 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4950 emitted for extraneous default arguments.
4952 Returns TRUE if there were no errors found, FALSE otherwise. */
4954 bool
4957 {
4960 tree parm_level;
4963 /* [temp.param]
4965 A default template-argument shall not be specified in a
4966 function template declaration or a function template definition, nor
4967 in the template-parameter-list of the definition of a member of a
4968 class template. */
4972 /* You can't have a function template declaration in a local
4973 scope, nor you can you define a member of a class template in a
4974 local scope. */
4982 /* A lambda doesn't have an explicit declaration; don't complain
4983 about the parms of the enclosing class. */
4990 /* If this is either a friend defined in the scope of the class
4991 or a member function. */
4997 /* And, if it was a member function, it really was defined in
4998 the scope of the class. */
5001 /* We already checked these parameters when the template was
5002 declared, so there's no need to do it again now. This function
5003 was defined in class scope, but we're processing its body now
5004 that the class is complete. */
5007 /* Core issue 226 (C++0x only): the following only applies to class
5008 templates. */
5011 {
5012 /* [temp.param]
5014 If a template-parameter has a default template-argument, all
5015 subsequent template-parameters shall have a default
5016 template-argument supplied. */
5018 {
5025 {
5035 {
5037 /* For better subsequent error-recovery, we indicate that
5038 there should have been a default argument. */
5041 }
5043 && !is_friend_decl
5044 /* Don't complain about an enclosing partial
5045 specialization. */
5050 /* A fixed parameter pack will be partially
5051 instantiated into a fixed length list. */
5053 {
5054 /* A primary class template can only have one
5055 parameter pack, at the end of the template
5056 parameter list. */
5064 }
5065 }
5066 }
5067 }
5070 || is_partial
5071 || !is_primary
5073 /* For an ordinary class template, default template arguments are
5074 allowed at the innermost level, e.g.:
5075 template <class T = int>
5076 struct S {};
5077 but, in a partial specialization, they're not allowed even
5078 there, as we have in [temp.class.spec]:
5080 The template parameter list of a specialization shall not
5081 contain default template argument values.
5083 So, for a partial specialization, or for a function template
5084 (in C++98/C++03), we look at all of them. */
5085 ;
5086 else
5087 /* But, for a primary class template that is not a partial
5088 specialization we look at all template parameters except the
5089 innermost ones. */
5092 /* Figure out what error message to issue. */
5107 else
5108 /* Per [temp.param]/9, "A default template-argument shall not be
5109 specified in the template-parameter-lists of the definition of
5110 a member of a class template that appears outside of the member's
5111 class.", thus if we aren't handling a member of a class template
5112 there is no need to examine the parameters. */
5116 /* If we're inside a class definition, there's no need to
5117 examine the parameters to the class itself. On the one
5118 hand, they will be checked when the class is defined, and,
5119 on the other, default arguments are valid in things like:
5120 template <class T = double>
5121 struct S { template <class U> void f(U); };
5122 Here the default argument for `S' has no bearing on the
5123 declaration of `f'. */
5125 else
5126 /* Check everything. */
5132 {
5139 {
5144 {
5146 {
5153 }
5155 /* Clear out the default argument so that we are not
5156 confused later. */
5158 }
5159 }
5161 /* At this point, if we're still interested in issuing messages,
5162 they must apply to classes surrounding the object declared. */
5166 }
5169 }
5171 /* Worker for push_template_decl_real, called via
5172 for_each_template_parm. DATA is really an int, indicating the
5173 level of the parameters we are interested in. If T is a template
5174 parameter of that level, return nonzero. */
5176 static int
5178 {
5184 else
5187 }
5189 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5190 DATA is really an int, indicating the innermost outer level of parameters.
5191 If T is a template parameter of that level or further out, return
5192 nonzero. */
5194 static int
5196 {
5202 else
5205 }
5207 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5208 parameters given by current_template_args, or reuses a
5209 previously existing one, if appropriate. Returns the DECL, or an
5210 equivalent one, if it is replaced via a call to duplicate_decls.
5212 If IS_FRIEND is true, DECL is a friend declaration. */
5214 tree
5216 {
5217 tree tmpl;
5218 tree args;
5219 tree info;
5220 tree ctx;
5224 /* True if the template is a member template, in the sense of
5225 [temp.mem]. */
5231 /* See if this is a partial specialization. */
5244 /* For a friend, we want the context of the friend function, not
5245 the type of which it is a friend. */
5249 /* In the case of a virtual function, we want the class in which
5250 it is defined. */
5252 else
5253 /* Otherwise, if we're currently defining some class, the DECL
5254 is assumed to be a member of the class. */
5263 /* See if this is a primary template. */
5266 /* A friend template that specifies a class context, i.e.
5267 template <typename T> friend void A<T>::f();
5268 is not primary. */
5273 else
5277 {
5284 {
5287 }
5289 {
5291 {
5294 }
5296 {
5297 /* [temp.mem]
5299 A destructor shall not be a member template. */
5302 }
5309 {
5310 /* [basic.stc.dynamic.allocation]
5312 An allocation function can be a function
5313 template. ... Template allocation functions shall
5314 have two or more parameters. */
5317 }
5318 }
5321 {
5322 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5325 {
5331 }
5332 }
5335 /* alias-declaration */
5339 else
5340 {
5343 }
5344 }
5346 /* Check to see that the rules regarding the use of default
5347 arguments are not being violated. */
5351 /* Ensure that there are no parameter packs in the type of this
5352 declaration that have not been expanded. */
5354 {
5355 /* Check each of the arguments individually to see if there are
5356 any bare parameter packs. */
5362 {
5365 {
5366 /* This is a PARM_DECL that contains unexpanded parameter
5367 packs. We have already complained about this in the
5368 check_for_bare_parameter_packs call, so just replace
5369 these types with ERROR_MARK_NODE. */
5372 }
5376 }
5378 /* Check for bare parameter packs in the return type and the
5379 exception specifiers. */
5381 /* Errors were already issued, set return type to int
5382 as the frontend doesn't expect error_mark_node as
5383 the return type. */
5387 }
5392 {
5395 }
5408 {
5413 /* If DECL is a TYPE_DECL for a class-template, then there won't
5414 be DECL_LANG_SPECIFIC. The information equivalent to
5415 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5419 {
5420 /* Since a template declaration already existed for this
5421 class-type, we must be redeclaring it here. Make sure
5422 that the redeclaration is valid. */
5424 current_template_parms,
5426 /* We don't need to create a new TEMPLATE_DECL; just use the
5427 one we already had. */
5429 }
5430 else
5431 {
5433 member_template_p);
5438 {
5439 /* A specialization of a member template of a template
5440 class. */
5444 }
5445 }
5446 }
5447 else
5448 {
5454 {
5457 }
5465 {
5466 tree new_tmpl;
5468 /* The declaration is a specialization of a member
5469 template, declared outside the class. Therefore, the
5470 innermost template arguments will be NULL, so we
5471 replace them with the arguments determined by the
5472 earlier call to check_explicit_specialization. */
5475 new_tmpl
5477 member_template_p);
5487 args,
5490 }
5492 /* Make sure the template headers we got make sense. */
5497 {
5502 }
5503 else
5505 {
5510 {
5514 else
5518 /* Avoid crash in import_export_decl. */
5521 }
5526 /* Can happen in erroneous input. */
5528 else
5530 }
5532 /* Check that the parms are used in the appropriate qualifying scopes
5533 in the declarator. */
5537 {
5543 /* Avoid crash in import_export_decl. */
5546 }
5547 }
5552 /* Push template declarations for global functions and types. Note
5553 that we do not try to push a global template friend declared in a
5554 template class; such a thing may well depend on the template
5555 parameters of the class. */
5558 {
5563 /* Hide template friend classes that haven't been declared yet. */
5565 {
5568 }
5569 }
5572 {
5578 {
5581 /* It is a conversion operator. See if the type converted to
5582 depends on innermost template operands. */
5585 depth))
5587 }
5589 /* Give template template parms a DECL_CONTEXT of the template
5590 for which they are a parameter. */
5593 {
5597 }
5603 }
5605 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5606 back to its most general template. If TMPL is a specialization,
5607 ARGS may only have the innermost set of arguments. Add the missing
5608 argument levels if necessary. */
5616 else
5617 {
5622 }
5625 && !is_friend
5628 /* Set DECL_COMDAT on template instantiations; if we force
5629 them to be emitted by explicit instantiation or -frepo,
5630 mark_needed will tell cgraph to do the right thing. */
5634 }
5636 tree
5638 {
5640 }
5642 /* FN is an inheriting constructor that inherits from the constructor
5643 template INHERITED; turn FN into a constructor template with a matching
5644 template header. */
5646 tree
5648 {
5649 tree inner_parms
5652 tree parms
5663 }
5665 /* Called when a class template TYPE is redeclared with the indicated
5666 template PARMS, e.g.:
5668 template <class T> struct S;
5669 template <class T> struct S {}; */
5671 bool
5673 {
5674 tree tmpl;
5675 tree tmpl_parms;
5679 {
5682 }
5686 /* The type is nested in some template class. Nothing to worry
5687 about here; there are no new template parameters for the nested
5688 type. */
5692 {
5694 tmpl);
5696 }
5702 {
5712 }
5715 {
5716 tree tmpl_parm;
5717 tree parm;
5718 tree tmpl_default;
5719 tree parm_default;
5733 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5734 TEMPLATE_DECL. */
5744 {
5748 }
5751 {
5752 /* We have in [temp.param]:
5754 A template-parameter may not be given default arguments
5755 by two different declarations in the same scope. */
5760 }
5763 /* Update the previous template parameters (which are the ones
5764 that will really count) with the new default value. */
5767 /* Update the new parameters, too; they'll be used as the
5768 parameters for any members. */
5771 /* Give each template template parm in this redeclaration a
5772 DECL_CONTEXT of the template for which they are a parameter. */
5774 {
5777 }
5781 }
5783 // Cannot redeclare a class template with a different set of constraints.
5785 {
5790 }
5793 }
5795 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5796 to be used when the caller has already checked
5797 (processing_template_decl
5798 && !instantiation_dependent_expression_p (expr)
5799 && potential_constant_expression (expr))
5800 and cleared processing_template_decl. */
5802 tree
5804 {
5807 complain,
5811 }
5813 /* Simplify EXPR if it is a non-dependent expression. Returns the
5814 (possibly simplified) expression. */
5816 tree
5818 {
5822 /* If we're in a template, but EXPR isn't value dependent, simplify
5823 it. We're supposed to treat:
5825 template <typename T> void f(T[1 + 1]);
5826 template <typename T> void f(T[2]);
5828 as two declarations of the same function, for example. */
5831 {
5832 processing_template_decl_sentinel s;
5834 }
5836 }
5838 tree
5840 {
5842 }
5844 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
5845 an uninstantiated expression. */
5847 tree
5849 {
5853 {
5856 else
5857 {
5858 processing_template_decl_sentinel s;
5860 }
5861 }
5863 }
5865 /* True iff T is a specialization of a variable template. */
5867 bool
5869 {
5874 }
5876 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5877 template declaration, or a TYPE_DECL for an alias declaration. */
5879 bool
5881 {
5889 }
5891 /* Return TRUE iff T is a specialization of an alias template. */
5893 bool
5895 {
5896 /* It's an alias template specialization if it's an alias and its
5897 TYPE_NAME is a specialization of a primary template. */
5903 }
5905 /* An alias template is complex from a SFINAE perspective if a template-id
5906 using that alias can be ill-formed when the expansion is not, as with
5907 the void_t template. We determine this by checking whether the
5908 expansion for the alias template uses all its template parameters. */
5910 struct uses_all_template_parms_data
5911 {
5914 };
5916 static int
5918 {
5926 }
5928 static bool
5930 {
5945 }
5947 /* Return TRUE iff T is a specialization of a complex alias template with
5948 dependent template-arguments. */
5950 bool
5952 {
5965 }
5967 /* Return the number of innermost template parameters in TMPL. */
5969 static int
5971 {
5974 }
5976 /* Return either TMPL or another template that it is equivalent to under DR
5977 1286: An alias that just changes the name of a template is equivalent to
5978 the other template. */
5980 static tree
5982 {
5985 {
5986 /* Determine if the alias is equivalent to an underlying template. */
5998 tree alias_args = INNERMOST_TEMPLATE_ARGS
6003 /* Alias is equivalent. Strip it and repeat. */
6005 }
6008 }
6010 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6011 must be a reference-to-function or a pointer-to-function type, as specified
6012 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6013 and check that the resulting function has external linkage. */
6015 static tree
6017 tsubst_flags_t complain)
6018 {
6021 linkage_kind linkage;
6036 /* [temp.arg.nontype]/1
6038 A template-argument for a non-type, non-template template-parameter
6039 shall be one of:
6040 [...]
6041 -- the address of an object or function with external [C++11: or
6042 internal] linkage. */
6045 {
6047 {
6053 else
6056 }
6058 }
6062 {
6064 {
6069 else
6073 }
6075 }
6077 accept:
6084 }
6086 /* Subroutine of convert_nontype_argument.
6087 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6088 Emit an error otherwise. */
6090 static bool
6092 tsubst_flags_t complain)
6093 {
6110 {
6115 else
6117 }
6119 }
6121 /* Returns TRUE iff the address of OP is value-dependent.
6123 14.6.2.4 [temp.dep.temp]:
6124 A non-integral non-type template-argument is dependent if its type is
6125 dependent or it has either of the following forms
6126 qualified-id
6127 & qualified-id
6128 and contains a nested-name-specifier which specifies a class-name that
6129 names a dependent type.
6131 We generalize this to just say that the address of a member of a
6132 dependent class is value-dependent; the above doesn't cover the
6133 address of a static data member named with an unqualified-id. */
6135 static bool
6137 {
6138 /* We could use get_inner_reference here, but there's no need;
6139 this is only relevant for template non-type arguments, which
6140 can only be expressed as &id-expression. */
6142 {
6146 }
6149 }
6151 /* The next set of functions are used for providing helpful explanatory
6152 diagnostics for failed overload resolution. Their messages should be
6153 indented by two spaces for consistency with the messages in
6154 call.c */
6156 static int
6158 {
6160 }
6162 /* Other failure functions should call this one, to provide a single function
6163 for setting a breakpoint on. */
6165 static int
6167 {
6169 }
6171 static int
6173 {
6178 }
6180 static int
6182 {
6188 }
6190 static int
6192 {
6196 }
6198 static int
6200 {
6203 " template parameter %qD is not a parameter pack, but "
6207 }
6209 static int
6211 {
6214 " template argument %qE does not match "
6218 }
6220 static int
6222 {
6226 }
6228 static int
6230 {
6236 }
6238 static int
6240 {
6242 {
6247 else
6249 " deduced conflicting values for non-type parameter "
6251 }
6253 }
6255 static int
6257 {
6260 " variable-sized array type %qT is not "
6262 arg);
6264 }
6266 static int
6268 {
6272 arg);
6274 }
6276 static int
6278 {
6280 {
6286 else
6291 }
6293 }
6295 static int
6297 {
6299 }
6301 static int
6304 {
6306 }
6308 static int
6311 {
6317 }
6319 static int
6322 {
6325 {
6333 }
6335 }
6337 static int
6339 {
6342 " template parameters of a template template argument are "
6345 }
6347 static int
6349 {
6355 }
6357 static int
6359 {
6364 }
6366 static int
6368 {
6372 arg);
6374 }
6376 /* Attempt to convert the non-type template parameter EXPR to the
6377 indicated TYPE. If the conversion is successful, return the
6378 converted value. If the conversion is unsuccessful, return
6379 NULL_TREE if we issued an error message, or error_mark_node if we
6380 did not. We issue error messages for out-and-out bad template
6381 parameters, but not simply because the conversion failed, since we
6382 might be just trying to do argument deduction. Both TYPE and EXPR
6383 must be non-dependent.
6385 The conversion follows the special rules described in
6386 [temp.arg.nontype], and it is much more strict than an implicit
6387 conversion.
6389 This function is called twice for each template argument (see
6390 lookup_template_class for a more accurate description of this
6391 problem). This means that we need to handle expressions which
6392 are not valid in a C++ source, but can be created from the
6393 first call (for instance, casts to perform conversions). These
6394 hacks can go away after we fix the double coercion problem. */
6396 static tree
6398 {
6399 tree expr_type;
6403 /* Detect immediately string literals as invalid non-type argument.
6404 This special-case is not needed for correctness (we would easily
6405 catch this later), but only to provide better diagnostic for this
6406 common user mistake. As suggested by DR 100, we do not mention
6407 linkage issues in the diagnostic as this is not the point. */
6408 /* FIXME we're making this OK. */
6410 {
6416 }
6418 /* Add the ADDR_EXPR now for the benefit of
6419 value_dependent_expression_p. */
6422 {
6426 }
6428 /* If we are in a template, EXPR may be non-dependent, but still
6429 have a syntactic, rather than semantic, form. For example, EXPR
6430 might be a SCOPE_REF, rather than the VAR_DECL to which the
6431 SCOPE_REF refers. Preserving the qualifying scope is necessary
6432 so that access checking can be performed when the template is
6433 instantiated -- but here we need the resolved form so that we can
6434 convert the argument. */
6447 else
6450 /* If the argument is non-dependent, perform any conversions in
6451 non-dependent context as well. */
6459 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6460 to a non-type argument of "nullptr". */
6464 /* In C++11, integral or enumeration non-type template arguments can be
6465 arbitrary constant expressions. Pointer and pointer to
6466 member arguments can be general constant expressions that evaluate
6467 to a null value, but otherwise still need to be of a specific form. */
6469 {
6471 /* A PTRMEM_CST is already constant, and a valid template
6472 argument for a parameter of pointer to member type, we just want
6473 to leave it in that form rather than lower it to a
6477 {
6478 /* C++17: A template-argument for a non-type template-parameter shall
6479 be a converted constant expression (8.20) of the type of the
6480 template-parameter. */
6486 }
6488 {
6493 }
6494 }
6496 /* HACK: Due to double coercion, we can get a
6497 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6498 which is the tree that we built on the first call (see
6499 below when coercing to reference to object or to reference to
6500 function). We just strip everything and get to the arg.
6501 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6502 for examples. */
6504 {
6510 {
6511 /* ??? Maybe we could use convert_from_reference here, but we
6512 would need to relax its constraints because the NOP_EXPR
6513 could actually change the type to something more cv-qualified,
6514 and this is not folded by convert_from_reference. */
6519 && (same_type_ignoring_top_level_qualifiers_p
6522 {
6525 }
6526 }
6527 }
6529 /* [temp.arg.nontype]/5, bullet 1
6531 For a non-type template-parameter of integral or enumeration type,
6532 integral promotions (_conv.prom_) and integral conversions
6533 (_conv.integral_) are applied. */
6535 {
6537 {
6542 }
6547 /* Notice that there are constant expressions like '4 % 0' which
6548 do not fold into integer constants. */
6551 {
6553 {
6557 else
6563 /* else cxx_constant_value complained but gave us
6564 a real constant, so go ahead. */
6566 }
6567 else
6569 }
6571 /* Avoid typedef problems. */
6574 }
6575 /* [temp.arg.nontype]/5, bullet 2
6577 For a non-type template-parameter of type pointer to object,
6578 qualification conversions (_conv.qual_) and the array-to-pointer
6579 conversion (_conv.array_) are applied. */
6581 {
6584 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6585 decay_conversion or an explicit cast. If it's a problematic cast,
6586 we'll complain about it below. */
6588 {
6593 {
6596 }
6597 }
6599 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6601 A template-argument for a non-type, non-template template-parameter
6602 shall be one of: [...]
6604 -- the name of a non-type template-parameter;
6605 -- the address of an object or function with external linkage, [...]
6606 expressed as "& id-expression" where the & is optional if the name
6607 refers to a function or array, or if the corresponding
6608 template-parameter is a reference.
6610 Here, we do not care about functions, as they are invalid anyway
6611 for a parameter of type pointer-to-object. */
6614 /* Non-type template parameters are OK. */
6615 ;
6619 {
6621 {
6624 "because %qD is a variable, not the address of "
6627 }
6629 {
6635 }
6636 /* Other values, like integer constants, might be valid
6637 non-type arguments of some other type. */
6639 }
6640 else
6641 {
6645 {
6650 }
6652 {
6658 }
6661 {
6666 }
6667 /* C++17: For a non-type template-parameter of reference or pointer
6668 type, the value of the constant expression shall not refer to (or
6669 for a pointer type, shall not be the address of):
6670 * a subobject (4.5),
6671 * a temporary object (15.2),
6672 * a string literal (5.13.5),
6673 * the result of a typeid expression (8.2.8), or
6674 * a predefined __func__ variable (11.4.1). */
6676 {
6679 decl);
6681 }
6685 {
6690 }
6692 {
6696 decl);
6698 }
6699 }
6706 }
6707 /* [temp.arg.nontype]/5, bullet 3
6709 For a non-type template-parameter of type reference to object, no
6710 conversions apply. The type referred to by the reference may be more
6711 cv-qualified than the (otherwise identical) type of the
6712 template-argument. The template-parameter is bound directly to the
6713 template-argument, which must be an lvalue. */
6715 {
6717 expr_type))
6721 {
6726 }
6729 {
6734 }
6736 /* [temp.arg.nontype]/1
6738 A template-argument for a non-type, non-template template-parameter
6739 shall be one of: [...]
6741 -- the address of an object or function with external linkage. */
6744 {
6747 {
6750 "because a reference variable does not have a constant "
6753 }
6754 }
6758 /* OK, dependent reference. We don't want to ask whether a DECL is
6760 else
6761 {
6763 {
6769 }
6771 /* DR 1155 allows internal linkage in C++11 and up. */
6774 {
6780 }
6783 }
6787 }
6788 /* [temp.arg.nontype]/5, bullet 4
6790 For a non-type template-parameter of type pointer to function, only
6791 the function-to-pointer conversion (_conv.func_) is applied. If the
6792 template-argument represents a set of overloaded functions (or a
6793 pointer to such), the matching function is selected from the set
6794 (_over.over_). */
6796 {
6797 /* If the argument is a template-id, we might not have enough
6798 context information to decay the pointer. */
6800 {
6804 }
6807 /* Null pointer values are OK in C++11. */
6813 }
6814 /* [temp.arg.nontype]/5, bullet 5
6816 For a non-type template-parameter of type reference to function, no
6817 conversions apply. If the template-argument represents a set of
6818 overloaded functions, the matching function is selected from the set
6819 (_over.over_). */
6821 {
6823 {
6825 {
6830 }
6832 }
6837 }
6838 /* [temp.arg.nontype]/5, bullet 6
6840 For a non-type template-parameter of type pointer to member function,
6841 no conversions apply. If the template-argument represents a set of
6842 overloaded member functions, the matching member function is selected
6843 from the set (_over.over_). */
6845 {
6850 /* [temp.arg.nontype] bullet 1 says the pointer to member
6851 expression must be a pointer-to-member constant. */
6856 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
6857 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
6860 }
6861 /* [temp.arg.nontype]/5, bullet 7
6863 For a non-type template-parameter of type pointer to data member,
6864 qualification conversions (_conv.qual_) are applied. */
6866 {
6867 /* [temp.arg.nontype] bullet 1 says the pointer to member
6868 expression must be a pointer-to-member constant. */
6876 }
6878 {
6880 {
6885 }
6887 }
6888 /* A template non-type parameter must be one of the above. */
6889 else
6892 /* Sanity check: did we actually convert the argument to the
6893 right type? */
6897 }
6899 /* Subroutine of coerce_template_template_parms, which returns 1 if
6900 PARM_PARM and ARG_PARM match using the rule for the template
6901 parameters of template template parameters. Both PARM and ARG are
6902 template parameters; the rest of the arguments are the same as for
6903 coerce_template_template_parms.
6904 */
6905 static int
6907 tree arg,
6908 tsubst_flags_t complain,
6909 tree in_decl,
6910 tree outer_args)
6911 {
6920 {
6922 /* We encounter instantiations of templates like
6923 template <template <template <class> class> class TT>
6924 class C; */
6925 {
6932 }
6933 /* Fall through. */
6938 /* Argument is a parameter pack but parameter is not. */
6943 /* The tsubst call is used to handle cases such as
6945 template <int> class C {};
6946 template <class T, template <T> class TT> class D {};
6947 D<int, C> d;
6949 i.e. the parameter list of TT depends on earlier parameters. */
6951 {
6956 }
6960 /* Argument is a parameter pack but parameter is not. */
6967 }
6970 }
6972 /* Coerce template argument list ARGLIST for use with template
6973 template-parameter TEMPL. */
6975 static tree
6977 tsubst_flags_t complain)
6978 {
6979 /* Consider an example where a template template parameter declared as
6981 template <class T, class U = std::allocator<T> > class TT
6983 The template parameter level of T and U are one level larger than
6984 of TT. To proper process the default argument of U, say when an
6985 instantiation `TT<int>' is seen, we need to build the full
6986 arguments containing {int} as the innermost level. Outer levels,
6987 available when not appearing as default template argument, can be
6988 obtained from the arguments of the enclosing template.
6990 Suppose that TT is later substituted with std::vector. The above
6991 instantiation is `TT<int, std::allocator<T> >' with TT at
6992 level 1, and T at level 2, while the template arguments at level 1
6993 becomes {std::vector} and the inner level 2 is {int}. */
6997 {
6999 /* We want arguments for the partial specialization, not arguments for
7000 the primary template. */
7002 else
7004 }
7006 {
7007 /* This is an argument of the current template, so we haven't set
7008 DECL_CONTEXT yet. */
7009 tree relevant_template_parms;
7011 /* Parameter levels that are greater than the level of the given
7012 template template parm are irrelevant. */
7019 }
7026 complain,
7029 }
7031 /* A cache of template template parameters with match-all default
7032 arguments. */
7034 static void
7036 {
7040 }
7041 static tree
7043 {
7048 }
7050 /* T is a bound template template-parameter. Copy its arguments into default
7051 arguments of the template template-parameter's template parameters. */
7053 static tree
7055 {
7078 {
7081 {
7084 }
7085 }
7089 }
7091 /* ARG is a bound potential template template-argument, and PARGS is a list
7092 of arguments for the corresponding template template-parameter. Adjust
7093 PARGS as appropriate for application to ARG's template, and if ARG is a
7094 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7095 arguments to the template template parameter. */
7097 static tree
7099 {
7103 {
7104 /* When comparing two template template-parameters in partial ordering,
7105 rewrite the one currently being used as an argument to have default
7106 arguments for all parameters. */
7112 }
7113 else
7114 {
7115 tree aparms
7120 }
7123 }
7125 /* Subroutine of unify for the case when PARM is a
7126 BOUND_TEMPLATE_TEMPLATE_PARM. */
7128 static int
7131 {
7135 /* The template template parm might be variadic and the argument
7136 not, so flatten both argument lists. */
7141 {
7142 /* In keeping with P0522R0, adjust P's template arguments
7143 to apply to A's template; then flatten it again. */
7152 /* If the P0522 adjustment eliminated a pack expansion, deduce
7153 empty packs. */
7159 }
7160 else
7161 {
7162 /* Deduce arguments T, i from TT<T> or TT<i>.
7163 We check each element of PARMVEC and ARGVEC individually
7164 rather than the whole TREE_VEC since they can have
7165 different number of elements, which is allowed under N2555. */
7169 /* Check if the parameters end in a pack, making them
7170 variadic. */
7177 /* If the template argument list of P contains a pack
7178 expansion that is not the last template argument, the
7179 entire template argument list is a non-deduced
7180 context. */
7198 DEDUCE_EXACT,
7201 }
7204 }
7206 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7207 template template parameters. Both PARM_PARMS and ARG_PARMS are
7208 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7209 or PARM_DECL.
7211 Consider the example:
7212 template <class T> class A;
7213 template<template <class U> class TT> class B;
7215 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7216 the parameters to A, and OUTER_ARGS contains A. */
7218 static int
7220 tree arg_parms,
7221 tsubst_flags_t complain,
7222 tree in_decl,
7223 tree outer_args)
7224 {
7236 {
7237 /* P0522R0: A template template-parameter P is at least as specialized as
7238 a template template-argument A if, given the following rewrite to two
7239 function templates, the function template corresponding to P is at
7240 least as specialized as the function template corresponding to A
7241 according to the partial ordering rules for function templates
7242 ([temp.func.order]). Given an invented class template X with the
7243 template parameter list of A (including default arguments):
7245 * Each of the two function templates has the same template parameters,
7246 respectively, as P or A.
7248 * Each function template has a single function parameter whose type is
7249 a specialization of X with template arguments corresponding to the
7250 template parameters from the respective function template where, for
7251 each template parameter PP in the template parameter list of the
7252 function template, a corresponding template argument AA is formed. If
7253 PP declares a parameter pack, then AA is the pack expansion
7254 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7256 If the rewrite produces an invalid type, then P is not at least as
7257 specialized as A. */
7259 /* So coerce P's args to apply to A's parms, and then deduce between A's
7260 args and the converted args. If that succeeds, A is at least as
7261 specialized as P, so they match.*/
7268 {
7274 }
7275 }
7277 /* Determine whether we have a parameter pack at the end of the
7278 template template parameter's template parameter list. */
7280 {
7287 {
7301 }
7302 }
7308 /* Check all of the template parameters except the parameter pack at
7309 the end (if any). */
7311 {
7320 outer_args))
7323 }
7326 {
7327 /* Check each of the template parameters in the template
7328 argument against the template parameter pack at the end of
7329 the template template parameter. */
7336 {
7343 outer_args))
7345 }
7346 }
7349 }
7351 /* Verifies that the deduced template arguments (in TARGS) for the
7352 template template parameters (in TPARMS) represent valid bindings,
7353 by comparing the template parameter list of each template argument
7354 to the template parameter list of its corresponding template
7355 template parameter, in accordance with DR150. This
7356 routine can only be called after all template arguments have been
7357 deduced. It will return TRUE if all of the template template
7358 parameter bindings are okay, FALSE otherwise. */
7359 bool
7361 {
7365 /* We're dealing with template parms in this process. */
7371 {
7376 {
7381 {
7382 /* Look inside the argument pack. */
7385 }
7388 {
7392 /* Extract the next argument from the argument
7393 pack. */
7397 /* Look at the pattern of the pack expansion. */
7400 /* Extract the template parameters from the template
7401 argument. */
7407 /* Verify that we can coerce the template template
7408 parameters from the template argument to the template
7409 parameter. This requires an exact match. */
7411 && !coerce_template_template_parms
7413 targ_parms,
7414 tf_none,
7415 tparm,
7416 targs))
7417 {
7420 }
7421 }
7422 }
7423 }
7425 out:
7429 }
7431 /* Since type attributes aren't mangled, we need to strip them from
7432 template type arguments. */
7434 static tree
7436 {
7446 }
7448 /* And from inside dependent non-type arguments like sizeof(Type). */
7450 static tree
7452 {
7462 }
7464 // A template declaration can be substituted for a constrained
7465 // template template parameter only when the argument is more
7466 // constrained than the parameter.
7467 static bool
7469 {
7472 /* For now, allow constrained template template arguments
7473 and unconstrained template template parameters. */
7479 // If the template parameter is constrained, we need to rewrite its
7480 // constraints in terms of the ARG's template parameters. This ensures
7481 // that all of the template parameter types will have the same depth.
7482 //
7483 // Note that this is only valid when coerce_template_template_parm is
7484 // true for the innermost template parameters of PARM and ARG. In other
7485 // words, because coercion is successful, this conversion will be valid.
7487 {
7494 }
7497 }
7499 // Convert a placeholder argument into a binding to the original
7500 // parameter. The original parameter is saved as the TREE_TYPE of
7501 // ARG.
7504 {
7507 }
7509 /* Convert the indicated template ARG as necessary to match the
7510 indicated template PARM. Returns the converted ARG, or
7511 error_mark_node if the conversion was unsuccessful. Error and
7512 warning messages are issued under control of COMPLAIN. This
7513 conversion is for the Ith parameter in the parameter list. ARGS is
7514 the full set of template arguments deduced so far. */
7516 static tree
7518 tree arg,
7519 tree args,
7520 tsubst_flags_t complain,
7522 tree in_decl)
7523 {
7524 tree orig_arg;
7525 tree val;
7531 /* Trivially convert placeholders. */
7540 {
7541 /* The template argument was the name of some
7542 member function. That's usually
7543 invalid, but static members are OK. In any
7544 case, grab the underlying fields/functions
7545 and issue an error later if required. */
7548 }
7556 /* When determining whether an argument pack expansion is a template,
7557 look at the pattern. */
7561 /* Deal with an injected-class-name used as a template template arg. */
7563 {
7566 {
7576 }
7577 }
7579 is_tmpl_type =
7595 {
7597 {
7601 }
7604 "to refer to a type member of a template parameter, "
7609 typename_type,
7610 complain);
7613 }
7615 {
7617 {
7619 {
7631 else
7634 }
7635 }
7637 }
7639 {
7641 {
7648 else
7651 }
7653 }
7656 /* We already did the appropriate conversion when packing args. */
7659 {
7661 {
7663 /* The number of argument required is not known yet.
7664 Just accept it for now. */
7666 else
7667 {
7669 tree argparm;
7671 /* Strip alias templates that are equivalent to another
7672 template. */
7678 args))
7679 {
7682 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7683 TEMPLATE_DECL. */
7685 {
7690 }
7691 }
7692 else
7693 {
7695 {
7702 }
7705 }
7707 // Check that the constraints are compatible before allowing the
7708 // substitution.
7711 {
7713 {
7719 }
7721 }
7722 }
7723 }
7724 else
7726 /* We only form one instance of each template specialization.
7727 Therefore, if we use a non-canonical variant (i.e., a
7728 typedef), any future messages referring to the type will use
7729 the typedef, which is confusing if those future uses do not
7730 themselves also use the typedef. */
7733 }
7734 else
7735 {
7739 {
7743 }
7744 else
7752 /* We used to call digest_init here. However, digest_init
7753 will report errors, which we don't want when complain
7754 is zero. More importantly, digest_init will try too
7755 hard to convert things: for example, `0' should not be
7756 converted to pointer type at this point according to
7757 the standard. Accepting this is not merely an
7758 extension, since deciding whether or not these
7759 conversions can occur is part of determining which
7760 function template to call, or whether a given explicit
7761 argument specification is valid. */
7763 else
7773 {
7774 /* Reject template arguments that are references to built-in
7775 functions with no library fallbacks. */
7784 }
7787 {
7788 /* Strip typedefs from the SCOPE_REF. */
7791 complain);
7794 }
7795 }
7798 }
7800 /* Coerces the remaining template arguments in INNER_ARGS (from
7801 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7802 Returns the coerced argument pack. PARM_IDX is the position of this
7803 parameter in the template parameter list. ARGS is the original
7804 template argument list. */
7805 static tree
7808 tree args,
7809 tree inner_args,
7811 tree new_args,
7813 tree in_decl,
7814 tsubst_flags_t complain)
7815 {
7818 tree packed_args;
7819 tree argument_pack;
7826 {
7827 /* When the template parameter is a non-type template parameter pack
7828 or template template parameter pack whose type or template
7829 parameters use parameter packs, we know exactly how many arguments
7830 we are looking for. Build a vector of the instantiated decls for
7831 these template parameters in PACKED_PARMS. */
7832 /* We can't use make_pack_expansion here because it would interpret a
7833 _DECL as a use rather than a declaration. */
7847 /* If we're doing a partial instantiation of a member template,
7848 verify that all of the types used for the non-type
7849 template parameter pack are, in fact, valid for non-type
7850 template parameters. */
7853 {
7856 {
7860 }
7861 /* We don't know how many args we have yet, just
7862 use the unconverted ones for now. */
7864 }
7867 }
7868 /* Check if we have a placeholder pack, which indicates we're
7869 in the context of a introduction list. In that case we want
7870 to match this pack to the single placeholder. */
7874 {
7877 }
7878 else
7881 /* Convert the remaining arguments, which will be a part of the
7882 parameter pack "parm". */
7885 {
7891 {
7892 /* Once we've packed as many args as we have types, stop. */
7896 /* We don't know how many args we have yet, just
7897 use the unconverted ones for now. */
7899 else
7901 }
7904 {
7907 }
7908 else
7911 in_decl);
7915 }
7919 {
7924 }
7929 else
7930 {
7933 }
7940 }
7942 /* Returns the number of pack expansions in the template argument vector
7943 ARGS. */
7945 static int
7947 {
7952 {
7956 }
7958 }
7960 /* Convert all template arguments to their appropriate types, and
7961 return a vector containing the innermost resulting template
7962 arguments. If any error occurs, return error_mark_node. Error and
7963 warning messages are issued under control of COMPLAIN.
7965 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7966 for arguments not specified in ARGS. Otherwise, if
7967 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7968 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7969 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7970 ARGS. */
7972 static tree
7974 tree args,
7975 tree in_decl,
7976 tsubst_flags_t complain,
7979 {
7981 tree orig_inner_args;
7982 tree inner_args;
7983 tree new_args;
7984 tree new_inner_args;
7988 /* When used as a boolean value, indicates whether this is a
7989 variadic template parameter list. Since it's an int, we can also
7990 subtract it from nparms to get the number of non-variadic
7991 parameters. */
7996 /* Likewise for parameters with default arguments. */
8004 /* Determine if there are any parameter packs or default arguments. */
8006 {
8014 }
8017 /* If there are no parameters that follow a parameter pack, we need to
8018 expand any argument packs so that we can deduce a parameter pack from
8019 some non-packed args followed by an argument pack, as in variadic85.C.
8020 If there are such parameters, we need to leave argument packs intact
8021 so the arguments are assigned properly. This can happen when dealing
8022 with a nested class inside a partial specialization of a class
8023 template, as in variadic92.C, or when deducing a template parameter pack
8024 from a sub-declarator, as in variadic114.C. */
8028 /* Count any pack expansion args. */
8034 && require_all_args
8035 && !variadic_args_p
8036 && (!use_default_args
8039 {
8041 {
8043 {
8047 }
8048 else
8055 }
8058 }
8059 /* We can't pass a pack expansion to a non-pack parameter of an alias
8060 template (DR 1430). */
8064 && variadic_args_p
8066 {
8068 {
8070 {
8076 {
8079 "pack expansion argument for non-pack parameter "
8081 else
8083 "pack expansion argument for non-pack parameter "
8087 }
8088 }
8090 found:;
8091 }
8093 }
8095 /* We need to evaluate the template arguments, even though this
8096 template-id may be nested within a "sizeof". */
8105 {
8106 tree arg;
8107 tree parm;
8109 /* Get the Ith template parameter. */
8113 {
8116 }
8118 /* Calculate the next argument. */
8121 else
8126 {
8127 /* Some arguments will be placed in the
8128 template parameter pack PARM. */
8135 {
8136 /* We don't know how many args we have yet, just use the
8137 unconverted (and still packed) ones for now. */
8141 }
8145 /* Store this argument. */
8147 {
8148 lost++;
8149 /* We are done with all of the arguments. */
8151 }
8152 else
8153 {
8156 }
8159 }
8161 {
8163 {
8164 /* "If every valid specialization of a variadic template
8165 requires an empty template parameter pack, the template is
8166 ill-formed, no diagnostic required." So check that the
8167 pattern works with this parameter. */
8172 in_decl);
8174 {
8179 }
8181 /* Recover from missing typename. */
8185 /* We don't know how many args we have yet, just
8186 use the unconverted ones for now. */
8190 }
8191 }
8193 {
8194 /* There must be a default arg in this case. */
8197 /* The position of the first default template argument,
8198 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8199 Record that. */
8203 }
8204 else
8208 {
8211 }
8213 /* This only occurs if there was an error in the template
8214 parameter list itself (which we would already have
8215 reported) that we are trying to recover from, e.g., a class
8216 template with a parameter list such as
8217 template<typename..., typename>. */
8219 else
8225 lost++;
8227 }
8232 {
8234 {
8239 }
8241 }
8251 }
8253 /* Convert all template arguments to their appropriate types, and
8254 return a vector containing the innermost resulting template
8255 arguments. If any error occurs, return error_mark_node. Error and
8256 warning messages are not issued.
8258 Note that no function argument deduction is performed, and default
8259 arguments are used to fill in unspecified arguments. */
8260 tree
8262 {
8264 }
8266 /* Convert all template arguments to their appropriate type, and
8267 instantiate default arguments as needed. This returns a vector
8268 containing the innermost resulting template arguments, or
8269 error_mark_node if unsuccessful. */
8270 tree
8272 tsubst_flags_t complain)
8273 {
8275 }
8277 /* Like coerce_template_parms. If PARMS represents all template
8278 parameters levels, this function returns a vector of vectors
8279 representing all the resulting argument levels. Note that in this
8280 case, only the innermost arguments are coerced because the
8281 outermost ones are supposed to have been coerced already.
8283 Otherwise, if PARMS represents only (the innermost) vector of
8284 parameters, this function returns a vector containing just the
8285 innermost resulting arguments. */
8287 static tree
8289 tree args,
8290 tree in_decl,
8291 tsubst_flags_t complain,
8294 {
8297 tree coerced_args;
8300 {
8302 tree level;
8308 {
8309 tree l;
8313 require_all_args,
8314 use_default_args);
8315 else
8322 }
8323 }
8324 else
8327 require_all_args,
8328 use_default_args);
8330 }
8332 /* Returns 1 if template args OT and NT are equivalent. */
8334 int
8336 {
8345 /* For member templates */
8354 {
8371 }
8375 {
8378 /* Don't treat an alias template specialization with dependent
8379 arguments as equivalent to its underlying type when used as a
8380 template argument; we need them to be distinct so that we
8381 substitute into the specialization arguments at instantiation
8382 time. And aliases can't be equivalent without being ==, so
8383 we don't need to look any deeper.
8385 During partial ordering, however, we need to treat them normally so
8386 that we can order uses of the same alias with different
8387 cv-qualification (79960). */
8391 else
8393 }
8396 else
8397 {
8398 /* Try to treat a template non-type argument that has been converted
8399 to the parameter type as equivalent to one that hasn't yet. */
8412 }
8413 }
8415 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8416 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8417 NEWARG_PTR with the offending arguments if they are non-NULL. */
8419 int
8423 {
8436 {
8441 {
8447 }
8448 }
8450 }
8454 {
8456 }
8458 static void
8460 {
8470 /* We are called both from instantiate_decl, where we've already had a
8471 tinst_level pushed, and instantiate_template, where we haven't.
8472 Compensate. */
8483 else
8492 }
8495 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
8496 ARGLIST. Valid choices for FNS are given in the cp-tree.def
8497 documentation for TEMPLATE_ID_EXPR. */
8499 tree
8501 {
8502 tree type;
8510 {
8513 }
8516 {
8518 unknown_type_node,
8520 arglist);
8522 }
8529 }
8531 /* Within the scope of a template class S<T>, the name S gets bound
8532 (in build_self_reference) to a TYPE_DECL for the class, not a
8533 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
8534 or one of its enclosing classes, and that type is a template,
8535 return the associated TEMPLATE_DECL. Otherwise, the original
8536 DECL is returned.
8538 Also handle the case when DECL is a TREE_LIST of ambiguous
8539 injected-class-names from different bases. */
8541 tree
8543 {
8547 /* DR 176: A lookup that finds an injected-class-name (10.2
8548 [class.member.lookup]) can result in an ambiguity in certain cases
8549 (for example, if it is found in more than one base class). If all of
8550 the injected-class-names that are found refer to specializations of
8551 the same class template, and if the name is followed by a
8552 template-argument-list, the reference refers to the class template
8553 itself and not a specialization thereof, and is not ambiguous. */
8555 {
8558 {
8564 }
8567 else
8569 }
8575 }
8577 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
8578 parameters, find the desired type.
8580 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
8582 IN_DECL, if non-NULL, is the template declaration we are trying to
8583 instantiate.
8585 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
8586 the class we are looking up.
8588 Issue error and warning messages under control of COMPLAIN.
8590 If the template class is really a local class in a template
8591 function, then the FUNCTION_CONTEXT is the function in which it is
8592 being instantiated.
8594 ??? Note that this function is currently called *twice* for each
8595 template-id: the first time from the parser, while creating the
8596 incomplete type (finish_template_type), and the second type during the
8597 real instantiation (instantiate_template_class). This is surely something
8598 that we want to avoid. It also causes some problems with argument
8599 coercion (see convert_nontype_argument for more information on this). */
8601 static tree
8604 {
8606 tree t;
8609 spec_entry elt;
8610 hashval_t hash;
8613 {
8617 else
8618 {
8625 }
8628 }
8630 {
8633 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8634 an implicit typename for the second A. Deal with it. */
8639 {
8642 }
8643 }
8646 {
8649 }
8651 {
8655 }
8657 {
8660 }
8662 /* Issue an error message if we didn't find a template. */
8664 {
8668 }
8671 /* Make sure it's a user visible template, if it was named by
8672 the user. */
8675 {
8677 {
8681 }
8683 }
8687 /* An alias that just changes the name of a template is equivalent to the
8688 other template, so if any of the arguments are pack expansions, strip
8689 the alias to avoid problems with a pack expansion passed to a non-pack
8690 alias template parameter (DR 1430). */
8695 {
8696 tree parm;
8705 }
8706 else
8707 {
8709 tree gen_tmpl;
8710 tree type_decl;
8718 /* An error occurred while building the template TEMPL, and a
8719 diagnostic has most certainly been emitted for that
8720 already. Let's propagate that error. */
8729 {
8730 /* We've been given an incomplete set of template arguments.
8731 For example, given:
8733 template <class T> struct S1 {
8734 template <class U> struct S2 {};
8735 template <class U> struct S2<U*> {};
8736 };
8738 we will be called with an ARGLIST of `U*', but the
8739 TEMPLATE will be `template <class T> template
8740 <class U> struct S1<T>::S2'. We must fill in the missing
8741 arguments. */
8745 }
8747 /* Now we should have enough arguments. */
8750 /* From here on, we're only interested in the most general
8751 template. */
8753 /* Calculate the BOUND_ARGS. These will be the args that are
8754 actually tsubst'd into the definition to create the
8755 instantiation. */
8757 complain,
8762 /* We were unable to bind the arguments. */
8765 /* In the scope of a template class, explicit references to the
8766 template class refer to the type of the template, not any
8767 instantiation of it. For example, in:
8769 template <class T> class C { void f(C<T>); }
8771 the `C<T>' is just the same as `C'. Outside of the
8772 class, however, such a reference is an instantiation. */
8776 {
8781 }
8783 /* If we already have this specialization, return it. */
8793 /* If the the template's constraints are not satisfied,
8794 then we cannot form a valid type.
8796 Note that the check is deferred until after the hash
8797 lookup. This prevents redundant checks on previously
8798 instantiated specializations. */
8800 {
8802 {
8805 }
8807 }
8811 /* If the deduced arguments are invalid, then the binding
8812 failed. */
8816 complain))
8823 {
8828 }
8838 /* Create the type. */
8840 {
8841 /* The user referred to a specialization of an alias
8842 template represented by GEN_TMPL.
8844 [temp.alias]/2 says:
8846 When a template-id refers to the specialization of an
8847 alias template, it is equivalent to the associated
8848 type obtained by substitution of its
8849 template-arguments for the template-parameters in the
8850 type-id of the alias template. */
8853 /* Note that the call above (by indirectly calling
8854 register_specialization in tsubst_decl) registers the
8855 TYPE_DECL representing the specialization of the alias
8856 template. So next time someone substitutes ARGLIST for
8857 the template parms into the alias template (GEN_TMPL),
8858 she'll get that TYPE_DECL back. */
8862 }
8864 {
8866 {
8877 }
8878 else
8879 {
8880 /* We don't want to call start_enum for this type, since
8881 the values for the enumeration constants may involve
8882 template parameters. And, no one should be interested
8883 in the enumeration constants for such a type. */
8886 }
8890 }
8892 {
8898 /* A local class. Make sure the decl gets registered properly. */
8903 /* This instantiation is another name for the primary
8904 template type. Set the TYPE_CANONICAL field
8905 appropriately. */
8908 /* Some of the template arguments require structural
8909 equality testing, so this template class requires
8910 structural equality testing. */
8912 }
8913 else
8916 /* If we called start_enum or pushtag above, this information
8917 will already be set up. */
8919 {
8926 }
8927 else
8931 {
8937 {
8940 }
8941 }
8945 {
8949 {
8950 tree attributes
8958 }
8959 }
8961 /* Let's consider the explicit specialization of a member
8962 of a class template specialization that is implicitly instantiated,
8963 e.g.:
8964 template<class T>
8965 struct S
8966 {
8967 template<class U> struct M {}; //#0
8968 };
8970 template<>
8971 template<>
8972 struct S<int>::M<char> //#1
8973 {
8974 int i;
8975 };
8976 [temp.expl.spec]/4 says this is valid.
8978 In this case, when we write:
8979 S<int>::M<char> m;
8981 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8982 the one of #0.
8984 When we encounter #1, we want to store the partial instantiation
8985 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8987 For all cases other than this "explicit specialization of member of a
8988 class template", we just want to store the most general template into
8989 the CLASSTYPE_TI_TEMPLATE of M.
8991 This case of "explicit specialization of member of a class template"
8992 only happens when:
8993 1/ the enclosing class is an instantiation of, and therefore not
8994 the same as, the context of the most general template, and
8995 2/ we aren't looking at the partial instantiation itself, i.e.
8996 the innermost arguments are not the same as the innermost parms of
8997 the most general template.
8999 So it's only when 1/ and 2/ happens that we want to use the partial
9000 instantiation of the member template in lieu of its most general
9001 template. */
9005 /* the enclosing class must be an instantiation... */
9008 {
9012 tree partial_inst_args =
9019 use_partial_inst_tmpl =
9020 /*...and we must not be looking at the partial instantiation
9021 itself. */
9023 partial_inst_args);
9024 }
9027 /* This case is easy; there are no member templates involved. */
9029 else
9030 {
9031 /* This is a full instantiation of a member template. Find
9032 the partial instantiation of which this is an instance. */
9034 /* Temporarily reduce by one the number of levels in the ARGLIST
9035 so as to avoid comparing the last set of arguments. */
9039 /* FOUND is either a proper class type, or an alias
9040 template specialization. In the later case, it's a
9041 TYPE_DECL, resulting from the substituting of arguments
9042 for parameters in the TYPE_DECL of the alias template
9043 done earlier. So be careful while getting the template
9044 of FOUND. */
9046 ? found
9050 }
9052 // Build template info for the new specialization.
9061 /* Note this use of the partial instantiation so we can check it
9062 later in maybe_process_partial_specialization. */
9069 /* Now that the type has been registered on the instantiations
9070 list, we set up the enumerators. Because the enumeration
9071 constants may involve the enumeration type itself, we make
9072 sure to register the type first, and then create the
9073 constants. That way, doing tsubst_expr for the enumeration
9074 constants won't result in recursive calls here; we'll find
9075 the instantiation and exit above. */
9079 /* If the type makes use of template parameters, the
9080 code that generates debugging information will crash. */
9083 /* Possibly limit visibility based on template args. */
9090 }
9091 }
9093 /* Wrapper for lookup_template_class_1. */
9095 tree
9098 {
9099 tree ret;
9105 }
9107 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9109 tree
9111 {
9112 /* The type of the expression is NULL_TREE since the template-id could refer
9113 to an explicit or partial specialization. */
9116 /* Except that concepts are always bool. */
9119 }
9121 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9123 tree
9125 {
9129 /* We never want to return a VAR_DECL for a variable concept, since they
9130 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9145 {
9147 {
9150 }
9152 }
9154 /* If a template-id refers to a specialization of a variable
9155 concept, then the expression is true if and only if the
9156 concept's constraints are satisfied by the given template
9157 arguments.
9159 NOTE: This is an extension of Concepts Lite TS that
9160 allows constraints to be used in expressions. */
9162 {
9165 }
9168 }
9170 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9171 TARGS template args, and instantiate it if it's not dependent. */
9173 tree
9175 tsubst_flags_t complain)
9176 {
9179 {
9182 }
9185 }
9187 \f
9188 struct pair_fn_data
9189 {
9190 tree_fn_t fn;
9191 tree_fn_t any_fn;
9193 /* True when we should also visit template parameters that occur in
9194 non-deduced contexts. */
9197 };
9199 /* Called from for_each_template_parm via walk_tree. */
9201 static tree
9203 {
9210 #define WALK_SUBTREE(NODE) \
9211 do \
9212 { \
9213 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9214 pfd->include_nondeduced_p, \
9215 pfd->any_fn); \
9216 if (result) goto out; \
9217 } \
9218 while (0)
9228 {
9232 /* Fall through. */
9238 else
9248 /* Since we're not going to walk subtrees, we have to do this
9249 explicitly here. */
9251 /* Fall through. */
9254 /* Check the return type. */
9257 /* Check the parameter types. Since default arguments are not
9258 instantiated until they are needed, the TYPE_ARG_TYPES may
9259 contain expressions that involve template parameters. But,
9260 no-one should be looking at them yet. And, once they're
9261 instantiated, they don't contain template parameters, so
9262 there's no point in looking at them then, either. */
9263 {
9264 tree parm;
9269 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9270 want walk_tree walking into them itself. */
9272 }
9275 {
9279 }
9296 /* Fall through. */
9308 /* Record template parameters such as `T' inside `TT<T>'. */
9310 /* Fall through. */
9322 /* A template template parameter is encountered. */
9326 /* Already substituted template template parameter */
9331 /* A template-id in a TYPENAME_TYPE might be a deduced context after
9332 partial instantiation. */
9344 /* If there's no type, then this thing must be some expression
9345 involving template parameters. */
9367 }
9369 #undef WALK_SUBTREE
9371 /* We didn't find any template parameters we liked. */
9372 out:
9374 }
9376 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
9377 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
9378 call FN with the parameter and the DATA.
9379 If FN returns nonzero, the iteration is terminated, and
9380 for_each_template_parm returns 1. Otherwise, the iteration
9381 continues. If FN never returns a nonzero value, the value
9382 returned by for_each_template_parm is 0. If FN is NULL, it is
9383 considered to be the function which always returns 1.
9385 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
9386 parameters that occur in non-deduced contexts. When false, only
9387 visits those template parameters that can be deduced. */
9389 static tree
9393 tree_fn_t any_fn)
9394 {
9396 tree result;
9398 /* Set up. */
9404 /* Walk the tree. (Conceptually, we would like to walk without
9405 duplicates, but for_each_template_parm_r recursively calls
9406 for_each_template_parm, so we would need to reorganize a fair
9407 bit to use walk_tree_without_duplicates, so we keep our own
9408 visited list.) */
9411 else
9414 for_each_template_parm_r,
9418 /* Clean up. */
9420 {
9423 }
9426 }
9428 /* Returns true if T depends on any template parameter. */
9430 int
9432 {
9462 else
9463 {
9466 }
9471 }
9473 /* Returns true iff current_function_decl is an incompletely instantiated
9474 template. Useful instead of processing_template_decl because the latter
9475 is set to 0 during instantiate_non_dependent_expr. */
9477 bool
9479 {
9488 }
9490 /* Returns true if T depends on any template parameter with level LEVEL. */
9492 bool
9494 {
9497 }
9499 /* Returns true if the signature of DECL depends on any template parameter from
9500 its enclosing class. */
9502 bool
9504 {
9514 template_parm_outer_level,
9524 }
9526 /* Returns TRUE iff INST is an instantiation we don't need to do in an
9527 ill-formed translation unit, i.e. a variable or function that isn't
9528 usable in a constant expression. */
9532 {
9536 }
9538 /* Returns TRUE iff we should refuse to instantiate DECL because it's
9539 neglectable and instantiated from within an erroneous instantiation. */
9541 static bool
9543 {
9554 }
9562 /* We're starting to instantiate D; record the template instantiation context
9563 for diagnostics and to restore it later. */
9565 bool
9567 {
9569 }
9571 /* We're starting to instantiate D; record the template instantiation context
9572 at LOC for diagnostics and to restore it later. */
9574 bool
9576 {
9580 {
9581 /* Tell error.c not to try to instantiate any templates. */
9584 "template instantiation depth exceeds maximum of %d"
9586 max_tinst_depth);
9588 }
9590 /* If the current instantiation caused problems, don't let it instantiate
9591 anything else. Do allow deduction substitution and decls usable in
9592 constant expressions. */
9596 /* When not -quiet, dump template instantiations other than functions, since
9597 announce_function will take care of those. */
9616 }
9618 /* We're done instantiating this template; return to the instantiation
9619 context. */
9621 void
9623 {
9624 /* Restore the filename and line number stashed away when we started
9625 this instantiation. */
9629 }
9631 /* We're instantiating a deferred template; restore the template
9632 instantiation context in which the instantiation was requested, which
9633 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9635 static tree
9637 {
9649 }
9651 /* Returns the TINST_LEVEL which gives the original instantiation
9652 context. */
9656 {
9662 }
9664 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9665 vector of template arguments, as for tsubst.
9667 Returns an appropriate tsubst'd friend declaration. */
9669 static tree
9671 {
9672 tree new_friend;
9677 /* This was a friend declared with an explicit template
9678 argument list, e.g.:
9680 friend void f<>(T);
9682 to indicate that f was a template instantiation, not a new
9683 function declaration. Now, we have to figure out what
9684 instantiation of what template. */
9685 {
9687 tree new_args;
9688 tree tmpl;
9691 /* Friend functions are looked up in the containing namespace scope.
9692 We must enter that scope, to avoid finding member functions of the
9693 current class with same name. */
9708 tsk_none);
9710 }
9714 /* The NEW_FRIEND will look like an instantiation, to the
9715 compiler, but is not an instantiation from the point of view of
9716 the language. For example, we might have had:
9718 template <class T> struct S {
9719 template <class U> friend void f(T, U);
9720 };
9722 Then, in S<int>, template <class U> void f(int, U) is not an
9723 instantiation of anything. */
9729 {
9733 }
9735 /* The mangled name for the NEW_FRIEND is incorrect. The function
9736 is not a template instantiation and should not be mangled like
9737 one. Therefore, we forget the mangling here; we'll recompute it
9738 later if we need it. */
9740 {
9743 }
9746 {
9747 tree old_decl;
9748 tree new_friend_template_info;
9749 tree new_friend_result_template_info;
9750 tree ns;
9753 /* We must save some information from NEW_FRIEND before calling
9754 duplicate decls since that function will free NEW_FRIEND if
9755 possible. */
9757 new_friend_is_defn =
9762 {
9763 /* This declaration is a `primary' template. */
9766 new_friend_result_template_info
9768 }
9769 else
9772 /* Inside pushdecl_namespace_level, we will push into the
9773 current namespace. However, the friend function should go
9774 into the namespace of the template. */
9784 {
9785 /* This new friend declaration matched an existing
9786 declaration. For example, given:
9788 template <class T> void f(T);
9789 template <class U> class C {
9790 template <class T> friend void f(T) {}
9791 };
9793 the friend declaration actually provides the definition
9794 of `f', once C has been instantiated for some type. So,
9795 old_decl will be the out-of-class template declaration,
9796 while new_friend is the in-class definition.
9798 But, if `f' was called before this point, the
9799 instantiation of `f' will have DECL_TI_ARGS corresponding
9800 to `T' but not to `U', references to which might appear
9801 in the definition of `f'. Previously, the most general
9802 template for an instantiation of `f' was the out-of-class
9803 version; now it is the in-class version. Therefore, we
9804 run through all specialization of `f', adding to their
9805 DECL_TI_ARGS appropriately. In particular, they need a
9806 new set of outer arguments, corresponding to the
9807 arguments for this class instantiation.
9809 The same situation can arise with something like this:
9811 friend void f(int);
9812 template <class T> class C {
9813 friend void f(T) {}
9814 };
9816 when `C<int>' is instantiated. Now, `f(int)' is defined
9817 in the class. */
9820 /* On the other hand, if the in-class declaration does
9821 *not* provide a definition, then we don't want to alter
9822 existing definitions. We can just leave everything
9823 alone. */
9824 ;
9825 else
9826 {
9830 /* Overwrite whatever template info was there before, if
9831 any, with the new template information pertaining to
9832 the declaration. */
9836 {
9837 /* We should have called reregister_specialization in
9838 duplicate_decls. */
9843 /* Instantiate it if the global has already been used. */
9847 }
9848 else
9849 {
9850 tree t;
9852 /* Indicate that the old function template is a partial
9853 instantiation. */
9861 /* Reassign any specializations already in the hash table
9862 to the new more general template, and add the
9863 additional template args. */
9867 {
9869 spec_entry elt;
9881 register_specialization
9884 }
9886 }
9887 }
9889 /* The information from NEW_FRIEND has been merged into OLD_DECL
9890 by duplicate_decls. */
9892 }
9893 }
9894 else
9895 {
9899 /* In the code
9900 template <class T> class C {
9901 template <class U> friend void C1<U>::f (); // case 1
9902 friend void C2<T>::f (); // case 2
9903 };
9904 we only need to make sure CONTEXT is a complete type for
9905 case 2. To distinguish between the two cases, we note that
9906 CONTEXT of case 1 remains dependent type after tsubst while
9907 this isn't true for case 2. */
9917 {
9919 /* do_friend adds the TEMPLATE_DECL for any member friend
9920 template even if it isn't a member template, i.e.
9921 template <class T> friend A<T>::f();
9922 Look through it in that case. */
9926 /* Check to see that the declaration is really present, and,
9927 possibly obtain an improved declaration. */
9932 }
9933 }
9936 }
9938 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
9939 template arguments, as for tsubst.
9941 Returns an appropriate tsubst'd friend type or error_mark_node on
9942 failure. */
9944 static tree
9946 {
9947 tree friend_type;
9948 tree tmpl;
9949 tree context;
9952 {
9955 }
9960 {
9963 else
9965 }
9967 /* Look for a class template declaration. We look for hidden names
9968 because two friend declarations of the same template are the
9969 same. For example, in:
9971 struct A {
9972 template <typename> friend class F;
9973 };
9974 template <typename> struct B {
9975 template <typename> friend class F;
9976 };
9978 both F templates are the same. */
9982 /* But, if we don't find one, it might be because we're in a
9983 situation like this:
9985 template <class T>
9986 struct S {
9987 template <class U>
9988 friend struct S;
9989 };
9991 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
9992 for `S<int>', not the TEMPLATE_DECL. */
9994 {
9997 }
10000 {
10001 /* The friend template has already been declared. Just
10002 check to see that the declarations match, and install any new
10003 default parameters. We must tsubst the default parameters,
10004 of course. We only need the innermost template parameters
10005 because that is all that redeclare_class_template will look
10006 at. */
10009 {
10010 tree parms;
10011 location_t saved_input_location;
10021 }
10024 }
10025 else
10026 {
10027 /* The friend template has not already been declared. In this
10028 case, the instantiation of the template class will cause the
10029 injection of this template into the global scope. */
10034 /* The new TMPL is not an instantiation of anything, so we
10035 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
10036 the new type because that is supposed to be the corresponding
10037 template decl, i.e., TMPL. */
10044 /* Inject this template into the global scope. */
10046 }
10049 {
10052 else
10054 }
10057 }
10059 /* Returns zero if TYPE cannot be completed later due to circularity.
10060 Otherwise returns one. */
10062 static int
10064 {
10074 else
10076 }
10081 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10082 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10084 static tree
10087 {
10096 {
10103 clauses
10107 else
10109 }
10110 /* If the first attribute argument is an identifier, don't
10111 pass it through tsubst. Attributes like mode, format,
10112 cleanup and several target specific attributes expect it
10113 unmodified. */
10115 {
10116 tree chain
10121 }
10123 {
10124 /* An attribute pack expansion. */
10133 {
10137 }
10139 }
10140 else
10147 }
10149 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10150 unchanged or a new TREE_LIST chain. */
10152 static tree
10155 {
10160 {
10164 }
10168 {
10171 {
10174 {
10176 do
10181 }
10182 }
10184 }
10187 }
10189 /* Apply any attributes which had to be deferred until instantiation
10190 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10191 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10193 static void
10196 {
10198 tree t;
10205 {
10209 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10210 to our attributes parameter. */
10212 }
10213 else
10214 {
10216 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10217 lookup_template_class_1, and should be preserved. */
10221 }
10225 {
10229 }
10233 {
10238 {
10241 {
10245 do
10248 }
10249 else
10251 }
10254 }
10255 }
10257 /* Perform (or defer) access check for typedefs that were referenced
10258 from within the template TMPL code.
10259 This is a subroutine of instantiate_decl and instantiate_class_template.
10260 TMPL is the template to consider and TARGS is the list of arguments of
10261 that template. */
10263 static void
10265 {
10266 location_t saved_location;
10277 {
10289 /* Make access check error messages point to the location
10290 of the use of the typedef. */
10294 tf_warning_or_error);
10295 }
10297 }
10299 static tree
10301 {
10303 tree typedecl;
10304 tree pbinfo;
10305 tree base_list;
10307 tree fn_context;
10316 /* Figure out which template is being instantiated. */
10320 /* Determine what specialization of the original template to
10321 instantiate. */
10324 {
10327 }
10329 {
10330 /* This TYPE is actually an instantiation of a partial
10331 specialization. We replace the innermost set of ARGS with
10332 the arguments appropriate for substitution. For example,
10333 given:
10335 template <class T> struct S {};
10336 template <class T> struct S<T*> {};
10338 and supposing that we are instantiating S<int*>, ARGS will
10339 presently be {int*} -- but we need {int}. */
10342 }
10343 else
10344 {
10347 }
10349 /* If the template we're instantiating is incomplete, then clearly
10350 there's nothing we can do. */
10354 /* If we've recursively instantiated too many templates, stop. */
10358 /* Now we're really doing the instantiation. Mark the type as in
10359 the process of being defined. */
10362 /* We may be in the middle of deferred access check. Disable
10363 it now. */
10370 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
10375 else
10376 {
10379 }
10380 /* Use #pragma pack from the template context. */
10386 /* Set the input location to the most specialized template definition.
10387 This is needed if tsubsting causes an error. */
10399 {
10402 /* Adjust visibility for template arguments. */
10404 }
10410 /* We should never instantiate a nested class before its enclosing
10411 class; we need to look up the nested class by name before we can
10412 instantiate it, and that lookup should instantiate the enclosing
10413 class. */
10419 {
10420 tree pbase_binfo;
10421 tree pushed_scope;
10424 /* We must enter the scope containing the type, as that is where
10425 the accessibility of types named in dependent bases are
10426 looked up from. */
10429 /* Substitute into each of the bases to determine the actual
10430 basetypes. */
10432 {
10433 tree base;
10439 {
10440 expanded_bases =
10447 }
10450 {
10452 /* Extract the already-expanded base class. */
10454 else
10455 /* Substitute to figure out the base class. */
10457 NULL_TREE);
10465 }
10466 }
10468 /* The list is now in reverse order; correct that. */
10473 }
10474 /* Now call xref_basetypes to set up all the base-class
10475 information. */
10483 /* Now that our base classes are set up, enter the scope of the
10484 class, so that name lookups into base classes, etc. will work
10485 correctly. This is precisely analogous to what we do in
10486 begin_class_definition when defining an ordinary non-template
10487 class, except we also need to push the enclosing classes. */
10490 /* Now members are processed in the order of declaration. */
10493 {
10497 {
10499 {
10500 /* Build new CLASSTYPE_NESTED_UTDS. */
10502 tree newtag;
10508 /* If the member is a class template, then -- even after
10509 substitution -- there may be dependent types in the
10510 template argument list for the class. We increment
10511 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
10512 that function will assume that no types are dependent
10513 when outside of a template. */
10523 {
10527 /* Unfortunately, lookup_template_class sets
10528 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
10529 instantiation (i.e., for the type of a member
10530 template class nested within a template class.)
10531 This behavior is required for
10532 maybe_process_partial_specialization to work
10533 correctly, but is not accurate in this case;
10534 the TAG is not an instantiation of anything.
10535 (The corresponding TEMPLATE_DECL is an
10536 instantiation, but the TYPE is not.) */
10539 /* Now, we call pushtag to put this NEWTAG into the scope of
10540 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
10541 pushtag calling push_template_decl. We don't have to do
10542 this for enums because it will already have been done in
10543 tsubst_enum. */
10547 }
10548 }
10550 {
10551 tree r;
10560 /* Instantiate members marked with attribute used. */
10566 }
10569 /* A closure type for a lambda in a default argument for a
10570 member template. Ignore it; it will be instantiated with
10572 else
10573 {
10574 /* Build new TYPE_FIELDS. */
10576 {
10577 tree condition;
10580 condition =
10590 }
10592 {
10593 tree r;
10597 /* The file and line for this declaration, to
10598 assist in error message reporting. Since we
10599 called push_tinst_level above, we don't need to
10600 restore these. */
10610 {
10611 /* A capture pack became multiple fields. */
10614 }
10617 {
10621 {
10622 /* In [temp.inst]:
10624 [t]he initialization (and any associated
10625 side-effects) of a static data member does
10626 not occur unless the static data member is
10627 itself used in a way that requires the
10628 definition of the static data member to
10629 exist.
10631 Therefore, we do not substitute into the
10632 initialized for the static data member here. */
10633 finish_static_data_member_decl
10639 /* Instantiate members marked with attribute used. */
10642 }
10644 {
10645 /* Determine whether R has a valid type and can be
10646 completed later. If R is invalid, then its type
10647 is replaced by error_mark_node. */
10653 {
10654 /* If R's type couldn't be completed and
10655 it isn't a flexible array member (whose
10656 type is incomplete by definition) give
10657 an error. */
10660 }
10661 }
10663 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
10664 such a thing will already have been added to the field
10665 list by tsubst_enum in finish_member_declaration in the
10666 CLASSTYPE_NESTED_UTDS case above. */
10670 {
10673 }
10674 }
10675 }
10676 }
10677 }
10678 else
10679 {
10682 {
10683 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10689 {
10690 /* template <class T> friend class C; */
10693 }
10695 {
10696 /* template <class T> friend class C::D; */
10702 }
10705 {
10706 /* This could be either
10708 friend class T::C;
10710 when dependent_type_p is false or
10712 template <class U> friend class T::C;
10714 otherwise. */
10715 /* Bump processing_template_decl in case this is something like
10716 template <class T> friend struct A<T>::B. */
10723 }
10727 {
10728 /* friend class C;
10730 where C hasn't been declared yet. Let's lookup name
10731 from namespace scope directly, bypassing any name that
10732 come from dependent base class. */
10735 /* The call to xref_tag_from_type does injection for friend
10736 classes. */
10738 friend_type =
10742 }
10744 /* friend class C<T>; */
10747 /* Otherwise it's
10749 friend class C;
10751 where C is already declared or
10753 friend class C<int>;
10755 We don't have to do anything in these cases. */
10758 /* Trick make_friend_class into realizing that the friend
10759 we're adding is a template, not an ordinary class. It's
10760 important that we use make_friend_class since it will
10761 perform some error-checking and output cross-reference
10762 information. */
10770 }
10771 else
10772 {
10773 /* Build new DECL_FRIENDLIST. */
10774 tree r;
10776 /* The file and line for this declaration, to
10777 assist in error message reporting. Since we
10778 called push_tinst_level above, we don't need to
10779 restore these. */
10783 {
10786 }
10791 {
10794 }
10795 }
10796 }
10797 }
10800 {
10801 /* Restore these before substituting into the lambda capture
10802 initializers. */
10805 }
10808 {
10811 {
10817 {
10818 /* Set function_depth to avoid garbage collection. */
10822 }
10824 /* We need to instantiate the capture list from the template
10825 after we've instantiated the closure members, but before we
10826 consider adding the conversion op. Also keep any captures
10827 that may have been added during instantiation of the op(). */
10829 tree tmpl_cap
10838 }
10839 else
10841 }
10843 /* Set the file and line number information to whatever is given for
10844 the class itself. This puts error messages involving generated
10845 implicit functions at a predictable point, and the same point
10846 that would be used for non-template classes. */
10853 /* We don't instantiate default arguments for member functions. 14.7.1:
10855 The implicit instantiation of a class template specialization causes
10856 the implicit instantiation of the declarations, but not of the
10857 definitions or default arguments, of the class member functions,
10858 member classes, static data members and member templates.... */
10860 /* Some typedefs referenced from within the template code need to be access
10861 checked at template instantiation time, i.e now. These types were
10862 added to the template at parsing time. Let's get those and perform
10863 the access checks then. */
10873 /* The vtable for a template class can be emitted in any translation
10874 unit in which the class is instantiated. When there is no key
10875 method, however, finish_struct_1 will already have added TYPE to
10876 the keyed_classes. */
10881 }
10883 /* Wrapper for instantiate_class_template_1. */
10885 tree
10887 {
10888 tree ret;
10893 }
10895 static tree
10897 {
10898 tree r;
10904 else
10905 {
10912 }
10914 }
10916 /* Given a function parameter pack TMPL_PARM and some function parameters
10917 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10918 and set *SPEC_P to point at the next point in the list. */
10920 tree
10922 {
10923 /* Collect all of the extra "packed" parameters into an
10924 argument pack. */
10925 tree parmvec;
10935 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10941 /* Build the argument packs. */
10946 }
10948 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
10949 NONTYPE_ARGUMENT_PACK. */
10951 static tree
10953 {
10955 }
10957 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
10958 pack expansion with no extra args, 2 if it has extra args, or 0
10959 if it is not a pack expansion. */
10961 static int
10963 {
10969 /* A decl pack is itself an expansion. */
10976 }
10979 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
10981 static tree
10983 {
10990 }
10992 /* This is a subroutine of tsubst_pack_expansion.
10994 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
10995 mechanism to store the (non complete list of) arguments of the
10996 substitution and return a non substituted pack expansion, in order
10997 to wait for when we have enough arguments to really perform the
10998 substitution. */
11000 static bool
11004 {
11005 /* If one pack has an expansion and another pack has a normal
11006 argument or if one pack has an empty argument and an another
11007 one hasn't then tsubst_pack_expansion cannot perform the
11008 substitution and need to fall back on the
11009 PACK_EXPANSION_EXTRA mechanism. */
11017 {
11020 parm_pack;
11022 {
11027 /* We can't substitute a pack expansion with extra args into
11028 our pattern. */
11032 else
11034 }
11038 }
11040 }
11042 /* [temp.variadic]/6 says that:
11044 The instantiation of a pack expansion [...]
11045 produces a list E1,E2, ..., En, where N is the number of elements
11046 in the pack expansion parameters.
11048 This subroutine of tsubst_pack_expansion produces one of these Ei.
11050 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11051 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11052 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11053 INDEX is the index 'i' of the element Ei to produce. ARGS,
11054 COMPLAIN, and IN_DECL are the same parameters as for the
11055 tsubst_pack_expansion function.
11057 The function returns the resulting Ei upon successful completion,
11058 or error_mark_node.
11060 Note that this function possibly modifies the ARGS parameter, so
11061 it's the responsibility of the caller to restore it. */
11063 static tree
11065 tree parm_packs,
11067 tree args /* This parm gets
11069 tsubst_flags_t complain,
11070 tree in_decl)
11071 {
11072 tree t;
11075 /* For each parameter pack, change the substitution of the parameter
11076 pack to the ith argument in its argument pack, then expand the
11077 pattern. */
11079 {
11084 ith_elem_is_expansion |=
11087 /* Select the Ith argument from the pack. */
11090 {
11092 {
11097 }
11098 else
11100 }
11101 else
11102 {
11107 {
11109 /* Update the corresponding argument. */
11111 }
11112 else
11113 /* Re-use the ARGUMENT_PACK_SELECT. */
11115 }
11117 }
11119 /* Substitute into the PATTERN with the (possibly altered)
11120 arguments. */
11122 /* Expanding a fixed parameter pack from
11123 coerce_template_parameter_pack. */
11128 {
11131 else
11134 }
11138 else
11141 /* If the Ith argument pack element is a pack expansion, then
11142 the Ith element resulting from the substituting is going to
11143 be a pack expansion as well. */
11148 }
11150 /* When the unexpanded parameter pack in a fold expression expands to an empty
11151 sequence, the value of the expression is as follows; the program is
11152 ill-formed if the operator is not listed in this table.
11154 && true
11155 || false
11156 , void() */
11158 tree
11160 {
11164 {
11173 }
11179 }
11181 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11182 form an expression that combines the two terms using the
11183 operator of T. */
11185 static tree
11187 {
11191 // Handle compound assignment operators.
11196 {
11206 complain);
11207 }
11208 }
11210 /* Substitute ARGS into the pack of a fold expression T. */
11214 {
11216 }
11218 /* Substitute ARGS into the pack of a fold expression T. */
11222 {
11224 }
11226 /* Expand a PACK of arguments into a grouped as left fold.
11227 Given a pack containing elements A0, A1, ..., An and an
11228 operator @, this builds the expression:
11230 ((A0 @ A1) @ A2) ... @ An
11232 Note that PACK must not be empty.
11234 The operator is defined by the original fold expression T. */
11236 static tree
11238 {
11241 {
11244 }
11246 }
11248 /* Substitute into a unary left fold expression. */
11250 static tree
11252 tree in_decl)
11253 {
11258 {
11262 }
11265 else
11267 }
11269 /* Substitute into a binary left fold expression.
11271 Do ths by building a single (non-empty) vector of argumnts and
11272 building the expression from those elements. */
11274 static tree
11276 tree in_decl)
11277 {
11286 {
11291 }
11299 }
11301 /* Expand a PACK of arguments into a grouped as right fold.
11302 Given a pack containing elementns A0, A1, ..., and an
11303 operator @, this builds the expression:
11305 A0@ ... (An-2 @ (An-1 @ An))
11307 Note that PACK must not be empty.
11309 The operator is defined by the original fold expression T. */
11311 tree
11313 {
11314 // Build the expression.
11318 {
11321 }
11323 }
11325 /* Substitute into a unary right fold expression. */
11327 static tree
11329 tree in_decl)
11330 {
11335 {
11339 }
11342 else
11344 }
11346 /* Substitute into a binary right fold expression.
11348 Do ths by building a single (non-empty) vector of arguments and
11349 building the expression from those elements. */
11351 static tree
11353 tree in_decl)
11354 {
11363 {
11368 }
11377 }
11380 /* Substitute ARGS into T, which is an pack expansion
11381 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
11382 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
11383 (if only a partial substitution could be performed) or
11384 ERROR_MARK_NODE if there was an error. */
11385 tree
11387 tree in_decl)
11388 {
11389 tree pattern;
11393 tree result;
11401 /* Add in any args remembered from an earlier partial instantiation. */
11406 /* Determine the argument packs that will instantiate the parameter
11407 packs used in the expansion expression. While we're at it,
11408 compute the number of arguments to be expanded and make sure it
11409 is consistent. */
11412 {
11419 {
11424 else
11427 }
11429 {
11430 /* ??? Support use in other patterns. */
11434 }
11436 {
11437 /* We know we have correct local_specializations if this
11438 expansion is at function scope, or if we're dealing with a
11439 local parameter in a requires expression; for the latter,
11440 tsubst_requires_expr set it up appropriately. */
11443 else
11444 /* We can't rely on local_specializations for a parameter
11445 name used later in a function declaration (such as in a
11446 late-specified return type). Even if it exists, it might
11447 have the wrong value for a recursive call. */
11451 {
11452 /* This parameter pack was used in an unevaluated context. Just
11453 make a dummy decl, since it's only used for its type. */
11456 /* Partial instantiation of the parm_pack, we can't build
11457 up an argument pack yet. */
11459 else
11461 }
11462 }
11465 else
11466 {
11472 }
11479 /* This can only happen if we forget to expand an argument
11480 pack somewhere else. Just return an error, silently. */
11481 {
11485 }
11488 {
11492 /* Don't bother trying to do a partial substitution with
11493 incomplete packs; we'll try again after deduction. */
11500 {
11505 pattern);
11506 else
11508 pattern);
11510 }
11512 /* Keep track of the parameter packs and their corresponding
11513 argument packs. */
11516 }
11517 else
11518 {
11519 /* We can't substitute for this parameter pack. We use a flag as
11520 well as the missing_level counter because function parameter
11521 packs don't have a level. */
11524 }
11525 }
11527 /* If the expansion is just T..., return the matching argument pack, unless
11528 we need to call convert_from_reference on all the elements. This is an
11529 important optimization; see c++/68422. */
11532 {
11534 /* Types need no adjustment, nor does sizeof..., and if we still have
11535 some pack expansion args we won't do anything yet. */
11540 /* Also optimize expression pack expansions if we can tell that the
11541 elements won't have reference type. */
11547 /* Otherwise use the normal path so we get convert_from_reference. */
11548 }
11550 /* We cannot expand this expansion expression, because we don't have
11551 all of the argument packs we need. */
11553 {
11554 /* We got some full packs, but we can't substitute them in until we
11555 have values for all the packs. So remember these until then. */
11560 }
11562 {
11563 /* There were no real arguments, we're just replacing a parameter
11564 pack with another version of itself. Substitute into the
11565 pattern and return a PACK_EXPANSION_*. The caller will need to
11566 deal with that. */
11570 else
11574 }
11579 {
11580 /* We're in a late-specified return type, so create our own local
11581 specializations map; the current map is either NULL or (in the
11582 case of recursive unification) might have bindings that we don't
11583 want to use or alter. */
11586 }
11588 /* For each argument in each argument pack, substitute into the
11589 pattern. */
11593 {
11595 i,
11597 in_decl);
11600 {
11603 }
11604 }
11606 /* Update ARGS to restore the substitution from parameter packs to
11607 their argument packs. */
11609 {
11615 else
11616 {
11624 /* Update the corresponding argument. */
11628 else
11630 }
11631 }
11634 {
11637 }
11639 /* If the dependent pack arguments were such that we end up with only a
11640 single pack expansion again, there's no need to keep it in a TREE_VEC. */
11646 }
11648 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
11649 TMPL. We do this using DECL_PARM_INDEX, which should work even with
11650 parameter packs; all parms generated from a function parameter pack will
11651 have the same DECL_PARM_INDEX. */
11653 tree
11655 {
11657 tree patparm;
11660 {
11666 }
11667 else
11668 {
11673 }
11676 }
11678 /* Make an argument pack out of the TREE_VEC VEC. */
11680 static tree
11682 {
11683 tree pack;
11687 else
11688 {
11691 }
11694 }
11696 /* Return an exact copy of template args T that can be modified
11697 independently. */
11699 static tree
11701 {
11709 {
11714 }
11720 }
11722 /* Substitute ARGS into the vector or list of template arguments T. */
11724 static tree
11726 {
11738 {
11740 tree new_arg;
11745 {
11746 /* Substitute into an expansion expression. */
11750 /* Add to the expanded length adjustment the number of
11751 expanded arguments. We subtract one from this
11752 measurement, because the argument pack expression
11753 itself is already counted as 1 in
11754 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
11755 the argument pack is empty. */
11757 }
11759 {
11760 /* Substitute into each of the arguments. */
11769 else
11774 }
11775 else
11784 }
11789 /* Make space for the expanded arguments coming from template
11790 argument packs. */
11792 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
11793 arguments for a member template.
11794 In that case each TREE_VEC in ORIG_T represents a level of template
11795 arguments, and ORIG_T won't carry any non defaulted argument count.
11796 It will rather be the nested TREE_VECs that will carry one.
11797 In other words, ORIG_T carries a non defaulted argument count only
11798 if it doesn't contain any nested TREE_VEC. */
11800 {
11804 }
11806 {
11810 {
11813 /* Now expand the template argument pack "in place". */
11816 }
11817 else
11818 {
11820 out++;
11821 }
11822 }
11825 }
11827 /* Substitute ARGS into one level PARMS of template parameters. */
11829 static tree
11831 {
11838 {
11846 }
11849 }
11851 /* Return the result of substituting ARGS into the template parameters
11852 given by PARMS. If there are m levels of ARGS and m + n levels of
11853 PARMS, then the result will contain n levels of PARMS. For
11854 example, if PARMS is `template <class T> template <class U>
11855 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
11856 result will be `template <int*, double, class V>'. */
11858 static tree
11860 {
11864 /* When substituting into a template, we must set
11865 PROCESSING_TEMPLATE_DECL as the template parameters may be
11866 dependent if they are based on one-another, and the dependency
11867 predicates are short-circuit outside of templates. */
11874 {
11881 }
11886 }
11888 /* Return the result of substituting ARGS into one template parameter
11889 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
11890 parameter and which TREE_PURPOSE is the default argument of the
11891 template parameter. */
11893 static tree
11895 {
11916 }
11918 /* Substitute the ARGS into the indicated aggregate (or enumeration)
11919 type T. If T is not an aggregate or enumeration type, it is
11920 handled as if by tsubst. IN_DECL is as for tsubst. If
11921 ENTERING_SCOPE is nonzero, T is the context for a template which
11922 we are presently tsubst'ing. Return the substituted value. */
11924 static tree
11926 tree args,
11927 tsubst_flags_t complain,
11928 tree in_decl,
11930 {
11935 {
11940 /* Fall through. */
11944 {
11945 tree argvec;
11946 tree context;
11947 tree r;
11951 /* In "sizeof(X<I>)" we need to evaluate "I". */
11957 /* First, determine the context for the type we are looking
11958 up. */
11961 {
11964 /* If context is a nested class inside a class template,
11965 it may still need to be instantiated (c++/33959). */
11967 }
11969 /* Then, figure out what arguments are appropriate for the
11970 type we are trying to find. For example, given:
11972 template <class T> struct S;
11973 template <class T, class U> void f(T, U) { S<U> su; }
11975 and supposing that we are instantiating f<int, double>,
11976 then our ARGS will be {int, double}, but, when looking up
11977 S we only want {double}. */
11982 else
11983 {
11987 }
11993 }
11994 else
11995 /* This is not a template type, so there's nothing to do. */
12000 }
12001 }
12005 /* Substitute into the default argument ARG (a default argument for
12006 FN), which has the indicated TYPE. */
12008 tree
12010 tsubst_flags_t complain)
12011 {
12016 /* This can happen in invalid code. */
12031 /* This default argument came from a template. Instantiate the
12032 default argument here, not in tsubst. In the case of
12033 something like:
12035 template <class T>
12036 struct S {
12037 static T t();
12038 void f(T = t());
12039 };
12041 we must be careful to do name lookup in the scope of S<T>,
12042 rather than in the current class. */
12044 /* The "this" pointer is not valid in a default argument. */
12046 {
12051 }
12054 /* The default argument expression may cause implicitly defined
12055 member functions to be synthesized, which will result in garbage
12056 collection. We must treat this situation as if we were within
12057 the body of function so as to avoid collecting live data on the
12058 stack. */
12066 /* Restore the "this" pointer. */
12068 {
12071 }
12078 /* Make sure the default argument is reasonable. */
12084 {
12088 }
12091 }
12093 /* Substitute into all the default arguments for FN. */
12095 static void
12097 {
12098 tree arg;
12099 tree tmpl_args;
12103 /* If this function is not yet instantiated, we certainly don't need
12104 its default arguments. */
12107 /* Don't do this again for clones. */
12113 arg;
12119 complain);
12120 }
12122 /* Substitute the ARGS into the T, which is a _DECL. Return the
12123 result of the substitution. Issue error and warning messages under
12124 control of COMPLAIN. */
12126 static tree
12128 {
12129 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12130 location_t saved_loc;
12135 /* Set the filename and linenumber to improve error-reporting. */
12140 {
12142 {
12143 /* We can get here when processing a member function template,
12144 member class template, or template template parameter. */
12146 tree spec;
12147 tree tmpl_args;
12148 tree full_args;
12151 {
12152 /* Template template parameter is treated here. */
12156 /* If we get a real template back, return it. This can happen in
12157 the context of most_specialized_partial_spec. */
12160 else
12161 /* The new TEMPLATE_DECL was built in
12162 reduce_template_parm_level. */
12165 }
12167 /* We might already have an instance of this template.
12168 The ARGS are for the surrounding class type, so the
12169 full args contain the tsubst'd args for the context,
12170 plus the innermost args from the template decl. */
12174 /* Because this is a template, the arguments will still be
12175 dependent, even after substitution. If
12176 PROCESSING_TEMPLATE_DECL is not set, the dependency
12177 predicates will short-circuit. */
12185 /* If this is a default template template argument,
12186 tsubst might not have changed anything. */
12193 {
12196 }
12198 /* Make a new template decl. It will be similar to the
12199 original, but will record the current template arguments.
12200 We also create a new function declaration, which is just
12201 like the old one, but points to this new template, rather
12202 than the old one. */
12207 // Build new template info linking to the original template decl.
12212 {
12213 tree new_type;
12221 /* For a partial specialization, we need to keep pointing to
12222 the primary template. */
12228 }
12229 else
12230 {
12231 tree new_decl;
12243 }
12249 /* The template parameters for this new template are all the
12250 template parameters for the old template, except the
12251 outermost level of parameters. */
12254 complain);
12260 /* Record this non-type partial instantiation. */
12264 }
12268 {
12271 /* Nobody should be tsubst'ing into non-template functions. */
12275 {
12276 /* If T is not dependent, just return it. */
12280 /* Calculate the most general template of which R is a
12281 specialization, and the complete set of arguments used to
12282 specialize R. */
12285 (DECL_TEMPLATE_RESULT
12291 /* Check to see if we already have this specialization. */
12294 {
12297 }
12299 /* We can see more levels of arguments than parameters if
12300 there was a specialization of a member template, like
12301 this:
12303 template <class T> struct S { template <class U> void f(); }
12304 template <> template <class U> void S<int>::f(U);
12306 Here, we'll be substituting into the specialization,
12307 because that's where we can find the code we actually
12308 want to generate, but we'll have enough arguments for
12309 the most general template.
12311 We also deal with the peculiar case:
12313 template <class T> struct S {
12314 template <class U> friend void f();
12315 };
12316 template <class U> void f() {}
12317 template S<int>;
12318 template void f<double>();
12320 Here, the ARGS for the instantiation of will be {int,
12321 double}. But, we only need as many ARGS as there are
12322 levels of template parameters in CODE_PATTERN. We are
12323 careful not to get fooled into reducing the ARGS in
12324 situations like:
12326 template <class T> struct S { template <class U> void f(U); }
12327 template <class T> template <> void S<T>::f(int) {}
12329 which we can spot because the pattern will be a
12330 specialization in this case. */
12337 }
12338 else
12339 {
12340 /* This special case arises when we have something like this:
12342 template <class T> struct S {
12343 friend void f<int>(int, double);
12344 };
12346 Here, the DECL_TI_TEMPLATE for the friend declaration
12347 will be an IDENTIFIER_NODE. We are being called from
12348 tsubst_friend_function, and we want only to create a
12349 new decl (R) with appropriate types so that we can call
12350 determine_specialization. */
12353 }
12367 /* If we hit excessive deduction depth, the type is bogus even if
12368 it isn't error_mark_node, so don't build a decl. */
12372 /* We do NOT check for matching decls pushed separately at this
12373 point, as they may not represent instantiations of this
12374 template, and in any case are considered separate under the
12375 discrete model. */
12379 /* Clear out the mangled name and RTL for the instantiation. */
12382 /* Leave DECL_INITIAL set on deleted instantiations. */
12387 /* OpenMP UDRs have the only argument a reference to the declared
12388 type. We want to diagnose if the declared type is a reference,
12389 which is invalid, but as references to references are usually
12390 quietly merged, diagnose it here. */
12392 {
12393 tree argtype
12398 "reference type %qT in "
12402 argtype);
12403 }
12406 /* Type-conversion operator. Reconstruct the name, in
12407 case it's the name of one of the template's parameters. */
12417 /* If this is an instantiation of a function with internal
12418 linkage, we already know what object file linkage will be
12419 assigned to the instantiation. */
12428 /* We'll re-clone as appropriate in instantiate_template. */
12431 /* If we aren't complaining now, return on error before we register
12432 the specialization so that we'll complain eventually. */
12438 /* When instantiating a constrained member, substitute
12439 into the constraints to create a new constraint. */
12442 {
12445 }
12447 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
12448 this in the special friend case mentioned above where
12449 GEN_TMPL is NULL. */
12451 {
12456 tree new_r
12459 /* We instantiated this while substituting into
12460 the type earlier (template/friend54.C). */
12463 /* We're not supposed to instantiate default arguments
12464 until they are called, for a template. But, for a
12465 declaration like:
12467 template <class T> void f ()
12468 { extern void g(int i = T()); }
12470 we should do the substitution when the template is
12471 instantiated. We handle the member function case in
12472 instantiate_class_template since the default arguments
12473 might refer to other members of the class. */
12478 }
12479 else
12482 /* Copy the list of befriending classes. */
12486 {
12490 }
12493 {
12497 /* If this is an instantiation of a member template, clone it.
12498 If it isn't, that'll be handled by
12499 clone_constructors_and_destructors. */
12502 }
12513 /* Possibly limit visibility based on template args. */
12516 {
12520 }
12528 }
12532 {
12540 {
12541 /* If there is a local specialization that isn't a
12542 parameter pack, it means that we're doing a "simple"
12543 substitution from inside tsubst_pack_expansion. Just
12544 return the local specialization (which will be a single
12545 parm). */
12552 /* Expand the TYPE_PACK_EXPANSION that provides the types for
12553 the parameters in this function parameter pack. */
12557 {
12560 /* Zero-length parameter packs are boring. Just substitute
12561 into the chain. */
12565 }
12566 else
12567 {
12568 /* All we did was update the type. Make a note of that. */
12571 }
12572 }
12574 /* Loop through all of the parameters we'll build. When T is
12575 a function parameter pack, LEN is the number of expanded
12576 types in EXPANDED_TYPES; otherwise, LEN is 1. */
12579 {
12586 /* We're on the Ith parameter of the function parameter
12587 pack. */
12588 {
12589 /* Get the Ith type. */
12592 /* Rename the parameter to include the index. */
12595 }
12597 /* We're dealing with a normal parameter. */
12605 {
12608 else
12611 }
12621 /* Keep track of the first new parameter we
12622 generate. That's what will be returned to the
12623 caller. */
12627 /* Build a proper chain of parameters when substituting
12628 into a function parameter pack. */
12631 }
12633 /* If cp_unevaluated_operand is set, we're just looking for a
12634 single dummy parameter, so don't keep going. */
12639 /* FIRST_R contains the start of the chain we've built. */
12641 }
12645 {
12652 {
12653 /* This field is a lambda capture pack. Return a TREE_VEC of
12654 the expanded fields to instantiate_class_template_1 and
12655 store them in the specializations hash table as a
12656 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
12660 {
12663 }
12664 else
12665 {
12666 /* All we did was update the type. Make a note of that. */
12669 }
12670 }
12673 {
12676 {
12680 }
12690 /* For bit-fields, DECL_INITIAL gives the number of bits. For
12691 non-bit-fields DECL_INITIAL is a non-static data member
12692 initializer, which gets deferred instantiation. */
12698 {
12699 /* Set up DECL_TEMPLATE_INFO so that we can get at the
12700 NSDMI in perform_member_init. Still set DECL_INITIAL
12701 so that we know there is one. */
12706 }
12707 /* We don't have to set DECL_CONTEXT here; it is set by
12708 finish_member_declaration. */
12716 }
12719 {
12724 }
12725 }
12729 /* We reach here only for member using decls. We also need to check
12730 uses_template_parms because DECL_DEPENDENT_P is not set for a
12731 using-declaration that designates a member of the current
12732 instantiation (c++/53549). */
12735 {
12739 {
12744 {
12748 {
12751 }
12752 else
12753 {
12756 }
12758 }
12759 }
12760 else
12761 {
12767 else
12768 {
12771 }
12772 }
12773 }
12774 else
12775 {
12778 }
12783 {
12786 tree spec;
12788 tree ctx;
12797 {
12798 /* If this is the canonical decl, we don't have to
12799 mess with instantiations, and often we can't (for
12800 typename, template type parms and such). Note that
12801 TYPE_NAME is not correct for the above test if
12802 we've copied the type for a typedef. */
12808 }
12810 /* Check to see if we already have the specialization we
12811 need. */
12814 {
12815 /* T is a static data member or namespace-scope entity.
12816 We have to substitute into namespace-scope variables
12817 (not just variable templates) because of cases like:
12819 template <class T> void f() { extern T t; }
12821 where the entity referenced is not known until
12822 instantiation time. */
12826 {
12828 complain,
12830 /* If CTX is unchanged, then T is in fact the
12831 specialization we want. That situation occurs when
12832 referencing a static data member within in its own
12833 class. We can use pointer equality, rather than
12834 same_type_p, because DECL_CONTEXT is always
12835 canonical... */
12837 /* ... unless T is a member template; in which
12838 case our caller can be willing to create a
12839 specialization of that template represented
12840 by T. */
12844 }
12847 {
12852 argvec = (coerce_innermost_template_parms
12860 }
12861 }
12862 else
12863 {
12864 /* A local variable. */
12866 /* Subsequent calls to pushdecl will fill this in. */
12868 /* Unless this is a reference to a static variable from an
12869 enclosing function, in which case we need to fill it in now. */
12871 {
12875 }
12877 }
12878 /* If we already have the specialization we need, there is
12879 nothing more to do. */
12881 {
12884 }
12886 /* Create a new node for the specialization we need. */
12889 {
12892 else
12901 /* Mask off any template args past the variable's context so we
12902 don't replace the auto with an unrelated argument. */
12907 }
12909 {
12910 /* Even if the original location is out of scope, the
12911 newly substituted one is not. */
12918 {
12919 /* It may seem that this case cannot occur, since:
12921 typedef void f();
12922 void g() { f x; }
12924 declares a function, not a variable. However:
12926 typedef void f();
12927 template <typename T> void g() { T t; }
12928 template void g<f>();
12930 is an attempt to declare a variable with function
12931 type. */
12933 /* R is not yet sufficiently initialized, so we
12934 just use its name. */
12937 }
12939 /* Wait until cp_finish_decl to set this again, to handle
12940 circular dependency (template/instantiate6.C). */
12945 {
12950 {
12953 }
12955 }
12959 }
12965 /* Clear out the mangled name and RTL for the instantiation. */
12969 /* The initializer must not be expanded until it is required;
12970 see [temp.inst]. */
12974 {
12977 /* Possibly limit visibility based on template args. */
12980 {
12984 }
12986 }
12989 {
12990 /* A static data member declaration is always marked
12991 external when it is declared in-class, even if an
12992 initializer is present. We mimic the non-template
12993 processing here. */
13001 }
13002 else
13003 {
13008 }
13016 /* Preserve a typedef that names a type. */
13018 {
13022 /* An alias template specialization can be dependent
13023 even if its underlying type is not. */
13025 }
13028 }
13033 }
13034 #undef RETURN
13036 out:
13037 /* Restore the file and line information. */
13041 }
13043 /* Substitute into the ARG_TYPES of a function type.
13044 If END is a TREE_CHAIN, leave it and any following types
13045 un-substituted. */
13047 static tree
13049 tree args,
13050 tree end,
13051 tsubst_flags_t complain,
13052 tree in_decl)
13053 {
13054 tree remaining_arg_types;
13058 tree default_arg;
13069 {
13070 /* For a pack expansion, perform substitution on the
13071 entire expression. Later on, we'll handle the arguments
13072 one-by-one. */
13077 /* So that we'll spin through the parameters, one by one. */
13079 else
13080 {
13081 /* We only partially substituted into the parameter
13082 pack. Our type is TYPE_PACK_EXPANSION. */
13085 }
13086 }
13099 {
13101 {
13105 }
13107 }
13108 /* DR 657. */
13112 /* Do array-to-pointer, function-to-pointer conversion, and ignore
13113 top-level qualifiers as required. */
13116 /* We do not substitute into default arguments here. The standard
13117 mandates that they be instantiated only when needed, which is
13118 done in build_over_call. */
13122 {
13123 /* We've instantiated a template before its default arguments
13124 have been parsed. This can happen for a nested template
13125 class, and is not an error unless we require the default
13126 argument in a call of this function. */
13127 remaining_arg_types =
13130 }
13131 else
13132 remaining_arg_types =
13134 }
13137 }
13139 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
13140 *not* handle the exception-specification for FNTYPE, because the
13141 initial substitution of explicitly provided template parameters
13142 during argument deduction forbids substitution into the
13143 exception-specification:
13145 [temp.deduct]
13147 All references in the function type of the function template to the
13148 corresponding template parameters are replaced by the specified tem-
13149 plate argument values. If a substitution in a template parameter or
13150 in the function type of the function template results in an invalid
13151 type, type deduction fails. [Note: The equivalent substitution in
13152 exception specifications is done only when the function is instanti-
13153 ated, at which point a program is ill-formed if the substitution
13154 results in an invalid type.] */
13156 static tree
13158 tree args,
13159 tsubst_flags_t complain,
13160 tree in_decl)
13161 {
13162 tree return_type;
13164 tree fntype;
13166 /* The TYPE_CONTEXT is not used for function/method types. */
13169 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
13170 failure. */
13174 {
13175 /* Substitute the argument types. */
13187 {
13188 /* DR 1207: 'this' is in scope in the trailing return type. */
13190 }
13192 /* Substitute the return type. */
13196 {
13199 }
13200 }
13201 else
13202 /* Substitute the return type. */
13207 /* DR 486 clarifies that creation of a function type with an
13208 invalid return type is a deduction failure. */
13211 {
13213 {
13216 else
13218 }
13220 }
13221 /* And DR 657. */
13226 {
13227 /* Substitute the argument types. */
13232 }
13234 /* Construct a new type node and return it. */
13236 {
13241 }
13242 else
13243 {
13245 /* Don't pick up extra function qualifiers from the basetype. */
13248 {
13249 /* [temp.deduct]
13251 Type deduction may fail for any of the following
13252 reasons:
13254 -- Attempting to create "pointer to member of T" when T
13255 is not a class type. */
13258 r);
13260 }
13265 }
13272 }
13274 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
13275 ARGS into that specification, and return the substituted
13276 specification. If there is no specification, return NULL_TREE. */
13278 static tree
13280 tree args,
13281 tsubst_flags_t complain,
13282 tree in_decl,
13284 {
13285 tree specs;
13286 tree new_specs;
13291 {
13292 /* A noexcept-specifier. */
13297 {
13298 /* Defer instantiation of noexcept-specifiers to avoid
13299 excessive instantiations (c++/49107). */
13302 {
13303 /* We already partially instantiated this member template,
13304 so combine the new args with the old. */
13309 }
13310 else
13311 {
13314 }
13315 }
13316 else
13317 new_specs = tsubst_copy_and_build
13321 }
13323 {
13326 else
13328 {
13329 tree spec;
13334 {
13335 /* Expand the pack expansion type. */
13338 in_decl);
13344 else
13345 {
13346 /* We're substituting into a member template, so
13347 we got a TYPE_PACK_EXPANSION back. Add that
13348 expansion and move on. */
13352 expanded_specs,
13353 complain);
13356 }
13357 }
13360 {
13363 else
13368 complain);
13369 }
13372 }
13373 }
13375 }
13377 /* Take the tree structure T and replace template parameters used
13378 therein with the argument vector ARGS. IN_DECL is an associated
13379 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
13380 Issue error and warning messages under control of COMPLAIN. Note
13381 that we must be relatively non-tolerant of extensions here, in
13382 order to preserve conformance; if we allow substitutions that
13383 should not be allowed, we may allow argument deductions that should
13384 not succeed, and therefore report ambiguous overload situations
13385 where there are none. In theory, we could allow the substitution,
13386 but indicate that it should have failed, and allow our caller to
13387 make sure that the right thing happens, but we don't try to do this
13388 yet.
13390 This function is used for dealing with types, decls and the like;
13391 for expressions, use tsubst_expr or tsubst_copy. */
13393 tree
13395 {
13418 else
13423 /* Reuse typedefs. We need to do this to handle dependent attributes,
13424 such as attribute aligned. */
13427 {
13431 {
13432 /* DECL represents an alias template and we want to
13433 instantiate it. */
13437 }
13441 {
13445 }
13450 else
13451 /* The typedef is from a non-template context. */
13455 {
13457 r = cp_build_qualified_type_real
13461 }
13462 else
13463 {
13464 /* We don't have an instantiation yet, so drop the typedef. */
13469 }
13470 }
13487 {
13513 {
13519 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
13520 needed. */
13526 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
13527 with TREE_SIDE_EFFECTS that indicates this is not an integral
13528 constant expression. */
13531 {
13534 }
13537 }
13543 {
13549 /* Early in template argument deduction substitution, we don't
13550 want to reduce the level of 'auto', or it will be confused
13551 with a normal template parm in subsequent deduction. */
13563 {
13567 {
13568 /* See through ARGUMENT_PACK_SELECT arguments. */
13570 /* If the selected argument is an expansion E, that most
13571 likely means we were called from
13572 gen_elem_of_pack_expansion_instantiation during the
13573 substituting of pack an argument pack (which Ith
13574 element is a pack expansion, where I is
13575 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
13576 In this case, the Ith element resulting from this
13577 substituting is going to be a pack expansion, which
13578 pattern is the pattern of E. Let's return the
13579 pattern of E, and
13580 gen_elem_of_pack_expansion_instantiation will
13581 build the resulting pack expansion from it. */
13583 {
13584 /* Make sure we aren't throwing away arg info. */
13587 }
13588 }
13589 }
13594 {
13596 /* If ARG is an argument pack, we don't actually want to
13597 perform a substitution here, because substitutions
13598 for argument packs are only done
13599 element-by-element. We can get to this point when
13600 substituting the type of a non-type template
13601 parameter pack, when that type actually contains
13602 template parameter packs from an outer template, e.g.,
13604 template<typename... Types> struct A {
13605 template<Types... Values> struct B { };
13606 }; */
13610 {
13616 return cp_build_qualified_type_real
13618 }
13620 {
13621 /* We are processing a type constructed from a
13622 template template parameter. */
13633 /* Consider this code:
13635 template <template <class> class Template>
13636 struct Internal {
13637 template <class Arg> using Bind = Template<Arg>;
13638 };
13640 template <template <class> class Template, class Arg>
13641 using Instantiate = Template<Arg>; //#0
13643 template <template <class> class Template,
13644 class Argument>
13645 using Bind =
13646 Instantiate<Internal<Template>::template Bind,
13647 Argument>; //#1
13649 When #1 is parsed, the
13650 BOUND_TEMPLATE_TEMPLATE_PARM representing the
13651 parameter `Template' in #0 matches the
13652 UNBOUND_CLASS_TEMPLATE representing the argument
13653 `Internal<Template>::template Bind'; We then want
13654 to assemble the type `Bind<Argument>' that can't
13655 be fully created right now, because
13656 `Internal<Template>' not being complete, the Bind
13657 template cannot be looked up in that context. So
13658 we need to "store" `Bind<Argument>' for later
13659 when the context of Bind becomes complete. Let's
13660 store that in a TYPENAME_TYPE. */
13664 argvec),
13665 typename_type,
13666 complain);
13668 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
13669 are resolving nested-types in the signature of a
13670 member function templates. Otherwise ARG is a
13671 TEMPLATE_DECL and is the real template to be
13672 instantiated. */
13680 complain);
13681 return cp_build_qualified_type_real
13683 }
13686 else
13687 /* TEMPLATE_PARM_INDEX. */
13689 }
13692 /* This can happen during the attempted tsubst'ing in
13693 unify. This means that we don't yet have any information
13694 about the template parameter in question. */
13697 /* If we get here, we must have been looking at a parm for a
13698 more deeply nested template. Make a new version of this
13699 template parameter, but with a lower level. */
13701 {
13706 {
13708 r = cp_build_qualified_type_real
13712 }
13719 /* Break infinite recursion when substituting the constraints
13721 else
13722 {
13733 {
13734 /* Propagate constraints on placeholders. */
13739 {
13743 }
13744 }
13747 /* We have reduced the level of the template
13748 template parameter, but not the levels of its
13749 template parameters, so canonical_type_parameter
13750 will not be able to find the canonical template
13751 template parameter for this level. Thus, we
13752 require structural equality checking to compare
13753 TEMPLATE_TEMPLATE_PARMs. */
13757 else
13761 {
13763 /* We might need to substitute into the types of non-type
13764 template parameters. */
13776 }
13777 }
13781 /* OK, now substitute the type of the non-type parameter. We
13782 couldn't do it earlier because it might be an auto parameter,
13783 and we wouldn't need to if we had an argument. */
13790 }
13793 }
13796 {
13804 {
13808 }
13811 {
13815 }
13818 {
13822 }
13828 }
13831 /* We should never be tsubsting a binfo. */
13835 /* A vector of template arguments. */
13841 {
13845 /* [temp.deduct]
13847 Type deduction may fail for any of the following
13848 reasons:
13850 -- Attempting to create a pointer to reference type.
13851 -- Attempting to create a reference to a reference type or
13852 a reference to void.
13854 Core issue 106 says that creating a reference to a reference
13855 during instantiation is no longer a cause for failure. We
13856 only enforce this check in strict C++98 mode. */
13860 {
13863 /* We keep track of the last time we issued this error
13864 message to avoid spewing a ton of messages during a
13865 single bad template instantiation. */
13868 {
13873 else
13876 }
13879 }
13883 {
13885 {
13888 type);
13889 else
13891 type);
13892 }
13894 }
13896 {
13900 }
13902 /* In C++0x, during template argument substitution, when there is an
13903 attempt to create a reference to a reference type, reference
13904 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
13906 "If a template-argument for a template-parameter T names a type
13907 that is a reference to a type A, an attempt to create the type
13908 'lvalue reference to cv T' creates the type 'lvalue reference to
13909 A,' while an attempt to create the type type rvalue reference to
13910 cv T' creates the type T"
13911 */
13912 r = cp_build_reference_type
13915 else
13920 /* Will this ever be needed for TYPE_..._TO values? */
13924 }
13926 {
13929 {
13930 /* [temp.deduct]
13932 Type deduction may fail for any of the following
13933 reasons:
13935 -- Attempting to create "pointer to member of T" when T
13936 is not a class type. */
13940 }
13942 {
13946 }
13948 {
13952 }
13955 {
13956 /* The type of the implicit object parameter gets its
13957 cv-qualifiers from the FUNCTION_TYPE. */
13958 tree memptr;
13959 tree method_type
13964 complain);
13965 }
13966 else
13969 complain);
13970 }
13973 {
13974 tree fntype;
13975 tree specs;
13980 /* Substitute the exception specification. */
13988 }
13990 {
13995 /* As an optimization, we avoid regenerating the array type if
13996 it will obviously be the same as T. */
14000 /* These checks should match the ones in create_array_type_for_decl.
14002 [temp.deduct]
14004 The deduction may fail for any of the following reasons:
14006 -- Attempting to create an array with an element type that
14007 is void, a function type, or a reference type, or [DR337]
14008 an abstract class type. */
14014 {
14018 }
14026 {
14029 }
14032 }
14035 {
14047 {
14051 }
14053 {
14054 /* Normally, make_typename_type does not require that the CTX
14055 have complete type in order to allow things like:
14057 template <class T> struct S { typename S<T>::X Y; };
14059 But, such constructs have already been resolved by this
14060 point, so here CTX really should have complete type, unless
14061 it's a partial instantiation. */
14064 {
14068 }
14069 }
14076 {
14079 }
14082 {
14084 {
14088 else
14090 }
14092 {
14096 else
14098 }
14099 }
14101 return cp_build_qualified_type_real
14103 }
14106 {
14118 }
14121 {
14122 tree type;
14138 complain);
14139 }
14142 {
14143 tree type;
14154 {
14156 {
14160 }
14163 }
14174 else
14175 {
14179 /* In a template ~id could be either a complement expression
14180 or an unqualified-id naming a destructor; if instantiating
14181 it produces an expression, it's not an id-expression or
14182 member access. */
14185 }
14190 }
14193 {
14197 }
14201 {
14202 tree r;
14206 else
14214 }
14229 /* We should use one of the expression tsubsts for these codes. */
14235 }
14236 }
14238 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
14239 expression on the left-hand side of the "." or "->" operator. A
14240 baselink indicates a function from a base class. Both the
14241 BASELINK_ACCESS_BINFO and the base class referenced may indicate
14242 bases of the template class, rather than the instantiated class.
14243 In addition, lookups that were not ambiguous before may be
14244 ambiguous now. Therefore, we perform the lookup again. */
14246 static tree
14249 {
14262 {
14269 }
14277 {
14282 }
14284 /* If lookup found a single function, mark it as used at this point.
14285 (If it lookup found multiple functions the one selected later by
14286 overload resolution will be marked as used at that point.) */
14294 {
14295 /* Add back the template arguments, if present. */
14301 /* Update the conversion operator type. */
14303 }
14309 {
14311 qualifying_scope,
14312 object_type);
14314 /* We need to call adjust_result_of_qualified_name_lookup in case the
14315 destructor names a base class, but we unset BASELINK_QUALIFIED_P
14316 so that we still get virtual function binding. */
14318 }
14321 }
14323 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
14324 true if the qualified-id will be a postfix-expression in-and-of
14325 itself; false if more of the postfix-expression follows the
14326 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
14327 of "&". */
14329 static tree
14333 {
14334 tree expr;
14335 tree scope;
14336 tree name;
14338 tree template_args;
14343 /* Figure out what name to look up. */
14346 {
14356 }
14357 else
14358 {
14361 }
14363 /* Substitute into the qualifying scope. When there are no ARGS, we
14364 are just trying to simplify a non-dependent expression. In that
14365 case the qualifying scope may be dependent, and, in any case,
14366 substituting will not help. */
14369 {
14372 }
14373 else
14377 {
14384 }
14387 {
14389 {
14390 /* A BIT_NOT_EXPR is used to represent a destructor. */
14392 {
14396 }
14397 else
14400 }
14401 else
14405 {
14407 {
14411 }
14413 }
14414 }
14417 {
14419 scope);
14420 /* Remember that there was a reference to this entity. */
14423 }
14426 {
14432 }
14435 {
14438 complain);
14439 else
14441 }
14447 {
14448 expr = (adjust_result_of_qualified_name_lookup
14450 expr = (finish_qualified_id_expr
14454 }
14456 /* Expressions do not generally have reference type. */
14458 /* However, if we're about to form a pointer-to-member, we just
14459 want the referenced member referenced. */
14467 }
14469 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
14470 initializer, DECL is the substituted VAR_DECL. Other arguments are as
14471 for tsubst. */
14473 static tree
14476 {
14483 {
14484 /* If we had an initializer but it
14485 instantiated to nothing,
14486 value-initialize the object. This will
14487 only occur when the initializer was a
14488 pack expansion where the parameter packs
14489 used in that expansion were of length
14490 zero. */
14492 complain);
14497 }
14500 }
14502 /* Like tsubst, but deals with expressions. This function just replaces
14503 template parms; to finish processing the resultant expression, use
14504 tsubst_copy_and_build or tsubst_expr. */
14506 static tree
14508 {
14510 tree r;
14518 {
14523 {
14524 /* We get here for a use of 'this' in an NSDMI. */
14528 /* This can happen for a parameter name used later in a function
14529 declaration (such as in a late-specified return type). Just
14530 make a dummy decl, since it's only used for its type. */
14533 /* Give it the template pattern as its context; its true context
14534 hasn't been instantiated yet and this is good enough for
14535 mangling. */
14537 }
14546 {
14547 tree enum_type;
14548 tree v;
14552 /* There is no need to substitute into namespace-scope
14553 enumerators. */
14556 /* If ARGS is NULL, then T is known to be non-dependent. */
14560 /* Unfortunately, we cannot just call lookup_name here.
14561 Consider:
14563 template <int I> int f() {
14564 enum E { a = I };
14565 struct S { void g() { E e = a; } };
14566 };
14568 When we instantiate f<7>::S::g(), say, lookup_name is not
14569 clever enough to find f<7>::a. */
14570 enum_type
14580 /* We didn't find the name. That should never happen; if
14581 name-lookup found it during preliminary parsing, we
14582 should find it again here during instantiation. */
14584 }
14589 {
14590 /* Check for a local specialization set up by
14591 tsubst_pack_expansion. */
14593 {
14597 }
14599 /* When retrieving a capture pack from a generic lambda, remove the
14600 lambda call op's own template argument list from ARGS. Only the
14601 template arguments active for the closure type should be used to
14602 retrieve the pack specialization. */
14608 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
14609 tsubst_decl put in the hash table. */
14611 }
14614 {
14615 tree ctx;
14620 {
14623 {
14627 }
14629 }
14630 }
14640 {
14643 {
14644 /* First try name lookup to find the instantiation. */
14647 {
14648 /* Make sure that the one we found is the one we want. */
14654 }
14658 else
14659 {
14660 /* This can happen for a variable used in a
14661 late-specified return type of a local lambda, or for a
14662 local static or constant. Building a new VAR_DECL
14663 should be OK in all those cases. */
14666 /* Avoid infinite recursion (79640). */
14669 {
14670 /* We can't call cp_finish_decl, so handle the
14671 initializer by hand. */
14686 }
14693 }
14694 /* Remember this for subsequent uses. */
14697 }
14698 }
14699 else
14709 /* An OVERLOAD will always be a non-dependent overload set; an
14710 overload set from function scope will just be represented with an
14711 IDENTIFIER_NODE, and from class scope with a BASELINK. */
14713 /* We must have marked any lookups as persistent. */
14729 {
14730 /* Template template argument like the following example need
14731 special treatment:
14733 template <template <class> class TT> struct C {};
14734 template <class T> struct D {
14735 template <class U> struct E {};
14736 C<E> c; // #1
14737 };
14738 D<int> d; // #2
14740 We are processing the template argument `E' in #1 for
14741 the template instantiation #2. Originally, `E' is a
14742 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
14743 have to substitute this with one having context `D<int>'. */
14747 {
14748 /* When rewriting a constructor into a deduction guide, a
14749 non-dependent name can become dependent, so memtmpl<args>
14750 becomes context::template memtmpl<args>. */
14754 }
14756 }
14757 else
14758 /* Ordinary template template argument. */
14769 {
14773 }
14778 {
14787 /* We only want to compute the number of arguments. */
14790 else
14797 {
14799 /* Set TREE_USED for the benefit of -Wunused. */
14803 }
14811 {
14816 else
14822 else
14825 }
14826 else
14828 }
14830 {
14838 }
14839 /* Fall through */
14855 {
14859 }
14862 {
14863 tree object;
14864 tree name;
14869 {
14873 }
14876 {
14886 }
14891 in_decl);
14892 else
14895 }
14933 {
14937 }
14940 {
14945 }
14948 {
14952 }
14955 {
14963 }
14969 {
14976 }
14979 {
14986 }
14989 {
14996 }
14999 {
15000 /* Substituted template arguments */
15009 }
15012 {
15032 }
15057 /* Fall through. */
15060 {
15063 }
15064 else
15068 /* This is handled by tsubst_copy_and_build. */
15072 {
15076 }
15079 /* We shouldn't have built any of these during initial template
15080 generation. Instead, they should be built during instantiation
15081 in response to the saved STMT_IS_FULL_EXPR_P setting. */
15085 {
15095 }
15113 {
15114 /* Instantiate any typedefs in the type. */
15119 }
15122 /* These can sometimes show up in a partial instantiation, but never
15123 involve template parms. */
15139 /* We shouldn't get here, but keep going if !flag_checking. */
15143 }
15144 }
15146 /* Helper function for tsubst_omp_clauses, used for instantiation of
15147 OMP_CLAUSE_DECL of clauses. */
15149 static tree
15151 tree in_decl)
15152 {
15156 /* Handle an OpenMP array section represented as a TREE_LIST (or
15157 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
15158 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
15159 TREE_LIST. We can handle it exactly the same as an array section
15160 (purpose, value, and a chain), even though the nomenclature
15161 (low_bound, length, etc) is different. */
15163 {
15164 tree low_bound
15170 in_decl);
15179 }
15182 /* Undo convert_from_reference tsubst_expr could have called. */
15188 }
15190 /* Like tsubst_copy, but specifically for OpenMP clauses. */
15192 static tree
15195 {
15200 {
15206 {
15209 {
15215 }
15216 /* FALLTHRU */
15231 in_decl);
15263 {
15266 {
15273 }
15274 else
15276 }
15279 in_decl);
15285 in_decl);
15293 in_decl);
15295 {
15298 }
15303 else
15306 in_decl,
15330 }
15333 {
15343 /* tsubst_expr on SCOPE_REF results in returning
15344 finish_non_static_data_member result. Undo that here. */
15348 {
15353 {
15357 CASE_CONVERT:
15366 /* FALLTHRU */
15370 }
15371 }
15377 {
15380 {
15383 }
15384 }
15388 }
15389 }
15393 {
15398 {
15401 }
15402 }
15404 }
15406 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
15408 static tree
15410 tree in_decl)
15411 {
15412 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
15432 {
15435 else
15436 {
15440 }
15441 }
15446 #undef RECUR
15447 }
15449 /* Used to temporarily communicate the list of #pragma omp parallel
15450 clauses to #pragma omp for instantiation if they are combined
15451 together. */
15455 /* Substitute one OMP_FOR iterator. */
15457 static void
15462 {
15463 #define RECUR(NODE) \
15464 tsubst_expr ((NODE), args, complain, in_decl, \
15465 integral_constant_expression_p)
15472 {
15475 }
15481 {
15482 /* We need to jump through some hoops to handle declarations in the
15483 init-statement, since we might need to handle auto deduction,
15484 but we need to keep control of initialization. */
15488 }
15489 else
15490 {
15492 {
15495 {
15499 {
15503 CASE_CONVERT:
15511 {
15514 }
15515 /* FALLTHRU */
15519 }
15520 }
15521 }
15522 else
15524 }
15535 {
15537 {
15538 /* Declare the variable, but don't let that initialize it. */
15543 }
15548 {
15553 }
15554 else
15561 }
15564 {
15565 /* Declare and initialize the variable. */
15568 }
15570 {
15574 {
15576 {
15582 {
15585 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
15590 }
15593 {
15595 decl);
15597 }
15600 {
15602 decl);
15604 }
15605 else
15607 }
15610 }
15612 {
15617 {
15620 }
15621 }
15622 }
15625 {
15629 }
15630 else
15634 {
15645 {
15653 }
15654 else
15660 {
15666 }
15670 {
15678 }
15679 else
15685 }
15691 #undef RECUR
15692 }
15694 /* Helper function of tsubst_expr, find OMP_TEAMS inside
15695 of OMP_TARGET's body. */
15697 static tree
15699 {
15702 {
15711 }
15713 }
15715 /* Helper function for tsubst_expr. For decomposition declaration
15716 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
15717 also the corresponding decls representing the identifiers
15718 of the decomposition declaration. Return DECL if successful
15719 or error_mark_node otherwise, set *FIRST to the first decl
15720 in the list chained through DECL_CHAIN and *CNT to the number
15721 of such decls. */
15723 static tree
15727 {
15732 decl2
15737 {
15739 {
15742 }
15759 {
15762 }
15763 else
15765 }
15768 }
15770 /* Like tsubst_copy for expressions, etc. but also does semantic
15771 processing. */
15773 tree
15776 {
15777 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
15778 #define RECUR(NODE) \
15779 tsubst_expr ((NODE), args, complain, in_decl, \
15780 integral_constant_expression_p)
15783 tree r;
15784 location_t loc;
15796 {
15798 {
15799 tree_stmt_iterator i;
15803 }
15818 else
15828 {
15830 tree init;
15836 {
15846 else
15848 }
15850 {
15851 /* Don't build up decls for a variadic capture proxy, we'll
15852 instantiate the elements directly as needed. */
15854 }
15855 else
15856 {
15860 {
15861 /* By marking the declaration as instantiated, we avoid
15862 trying to instantiate it. Since instantiate_decl can't
15863 handle local variables, and since we've already done
15864 all that needs to be done, that's the right thing to
15865 do. */
15870 /* Anonymous aggregates are a special case. */
15873 {
15876 {
15880 }
15882 }
15888 {
15893 }
15894 else
15895 {
15900 {
15901 /* For __PRETTY_FUNCTION__ we have to adjust the
15902 initializer. */
15906 }
15907 else
15911 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
15917 {
15919 tree first;
15925 }
15926 }
15927 }
15928 }
15931 }
15946 {
15954 {
15956 tree first;
15961 }
15962 else
15967 }
15993 else
15994 {
16001 }
16007 {
16016 }
16024 else
16032 else
16053 {
16060 }
16064 {
16066 tree label;
16073 }
16079 /* Computed goto's must be tsubst'd into. On the other hand,
16080 non-computed gotos must not be; the identifier in question
16081 will have no binding. */
16083 else
16089 {
16105 }
16110 {
16115 }
16116 else
16117 {
16122 else
16129 else
16135 else
16137 }
16141 {
16145 {
16147 /* Prevent instantiate_decl from trying to instantiate
16148 this variable. We've already done all that needs to be
16149 done. */
16152 }
16157 }
16163 {
16164 /* Local classes are not independent templates; they are
16165 instantiated along with their containing function. And this
16166 way we don't have to deal with pushing out of one local class
16167 to instantiate a member of another local class. */
16168 /* Closures are handled by the LAMBDA_EXPR. */
16178 }
16182 {
16183 tree condition;
16186 condition =
16188 args,
16197 }
16203 in_decl);
16240 {
16255 in_decl);
16257 {
16264 }
16276 integral_constant_expression_p);
16287 else
16288 {
16296 }
16300 }
16305 /* FALLTHRU */
16312 in_decl);
16329 in_decl);
16340 {
16343 {
16344 /* For combined target teams, ensure the num_teams and
16345 thread_limit clause expressions are evaluated on the host,
16346 before entering the target construct. */
16347 tree c;
16353 {
16362 OMP_CLAUSE_FIRSTPRIVATE);
16366 }
16367 }
16368 }
16428 {
16433 {
16436 }
16442 }
16443 else
16444 {
16451 {
16454 }
16457 {
16462 {
16465 }
16471 }
16472 else
16473 {
16477 }
16480 }
16484 {
16490 {
16494 {
16499 }
16503 }
16504 else
16505 {
16510 }
16511 }
16515 {
16519 }
16539 /* If the first operand was a statement, we're done with it. */
16543 complain));
16555 integral_constant_expression_p));
16556 }
16559 out:
16562 #undef RECUR
16563 #undef RETURN
16564 }
16566 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
16567 function. For description of the body see comment above
16568 cp_parser_omp_declare_reduction_exprs. */
16570 static void
16572 {
16578 tree_stmt_iterator tsi;
16589 {
16608 }
16610 {
16630 }
16631 }
16633 /* T is a postfix-expression that is not being used in a function
16634 call. Return the substituted version of T. */
16636 static tree
16638 tsubst_flags_t complain,
16639 tree in_decl)
16640 {
16644 else
16650 }
16652 /* Like tsubst but deals with expressions and performs semantic
16653 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
16655 tree
16657 tree args,
16658 tsubst_flags_t complain,
16659 tree in_decl,
16662 {
16663 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
16664 #define RECUR(NODE) \
16665 tsubst_copy_and_build (NODE, args, complain, in_decl, \
16667 integral_constant_expression_p)
16670 location_t loc;
16679 /* N3276 decltype magic only applies to calls at the top level or on the
16680 right side of a comma. */
16685 {
16688 /* Fall through. */
16690 {
16691 tree decl;
16692 cp_id_kind idk;
16697 {
16700 }
16702 /* Look up the name. */
16705 /* By convention, expressions use ERROR_MARK_NODE to indicate
16706 failure, not NULL_TREE. */
16712 integral_constant_expression_p,
16720 input_location);
16724 {
16728 }
16730 }
16733 {
16734 tree object;
16744 {
16749 }
16755 {
16758 }
16759 else
16766 else
16768 }
16771 {
16775 {
16776 /* A type conversion to reference type will be enclosed in
16777 such an indirect ref, but the substitution of the cast
16778 will have also added such an indirect ref. */
16781 }
16782 else
16790 }
16793 {
16797 }
16800 {
16807 flags));
16808 }
16811 {
16815 }
16822 {
16823 tree type;
16829 {
16834 }
16840 {
16858 }
16861 }
16895 else
16897 in_decl);
16932 {
16939 tree r = build_x_binary_op
16941 op0,
16943 ? ERROR_MARK
16945 op1,
16947 ? ERROR_MARK
16955 }
16958 {
16962 }
16975 {
16984 }
16989 /* Fall through */
16992 {
16993 tree r;
16999 {
17000 /* When there are no ARGS, we are trying to evaluate a
17001 non-dependent expression from the parser. Trying to do
17002 the substitutions may not work. */
17005 }
17006 else
17007 {
17012 else
17015 /*integral_constant_expression_p=*/
17019 }
17023 else
17027 {
17029 {
17031 {
17035 }
17036 else
17040 }
17042 }
17044 }
17047 {
17057 }
17073 {
17077 tree r = build_x_modify_expr
17080 /* TREE_NO_WARNING must be set if either the expression was
17081 parenthesized or it uses an operator such as >>= rather
17082 than plain assignment. In the former case, it was already
17083 set and must be copied. In the latter case,
17084 build_x_modify_expr sets it and it must not be reset
17085 here. */
17090 }
17095 /* Remember that there was a reference to this entity. */
17102 {
17107 tree ret;
17111 else
17112 {
17116 }
17118 /* If there was an initializer in the original tree, but it
17119 instantiated to an empty list, then we should pass a
17120 non-NULL empty vector to tell build_new that it was an
17121 empty initializer() rather than no initializer. This can
17122 only happen when the initializer is a pack expansion whose
17123 parameter packs are of length zero. */
17126 else
17127 {
17131 else
17132 {
17135 }
17136 }
17142 complain);
17150 }
17153 {
17159 complain));
17160 }
17163 {
17167 integral_constant_expression_p);
17169 op0,
17172 }
17175 {
17176 tree function;
17181 tree ret;
17184 /* Internal function with no arguments. */
17188 /* When we parsed the expression, we determined whether or
17189 not Koenig lookup should be performed. */
17192 {
17195 }
17197 {
17202 }
17204 {
17205 /* Do nothing; calling tsubst_copy_and_build on an identifier
17206 would incorrectly perform unqualified lookup again.
17208 Note that we can also have an IDENTIFIER_NODE if the earlier
17209 unqualified lookup found a member function; in that case
17210 koenig_p will be false and we do want to do the lookup
17211 again to find the instantiated member function.
17213 FIXME but doing that causes c++/15272, so we need to stop
17214 using IDENTIFIER_NODE in that situation. */
17216 }
17217 else
17218 {
17220 {
17226 }
17227 else
17232 /* Avoid error about taking the address of a constructor. */
17236 in_decl,
17238 integral_constant_expression_p);
17242 }
17247 {
17252 else
17253 {
17254 /* Expand the pack expansion and push each entry onto
17255 CALL_ARGS. */
17258 {
17263 {
17268 }
17269 }
17270 else
17271 {
17272 /* A partial substitution. Add one entry. */
17274 }
17275 }
17276 }
17278 /* We do not perform argument-dependent lookup if normal
17279 lookup finds a non-function, in accordance with the
17280 expected resolution of DR 218. */
17283 /* If lookup found a member function, the Koenig lookup is
17284 not appropriate, even if an unqualified-name was used
17285 to denote the function. */
17288 /* Only do this when substitution turns a dependent call
17289 into a non-dependent call. */
17297 {
17299 {
17300 /* For backwards compatibility and good diagnostics, try
17301 the unqualified lookup again if we aren't in SFINAE
17302 context. */
17303 tree unq = (tsubst_copy_and_build
17305 integral_constant_expression_p));
17307 {
17310 }
17313 {
17314 /* In a lambda fn, we have to be careful to not
17315 introduce new this captures. Legacy code can't
17316 be using lambdas anyway, so it's ok to be
17317 stricter. */
17322 "and no declarations were found by "
17323 "argument-dependent lookup at the point "
17330 else
17334 {
17345 {
17347 input_location);
17349 "declarations in dependent base %qT are "
17355 else
17359 }
17360 else
17362 "%qD declared here, later in the "
17365 {
17368 }
17369 }
17372 }
17373 }
17375 {
17380 }
17381 }
17383 /* Remember that there was a reference to this entity. */
17387 {
17390 }
17392 /* Put back tf_decltype for the actual call. */
17397 {
17401 {
17403 "wrong number of arguments to "
17406 }
17407 else
17409 input_location),
17414 /* Unsupported internal function with arguments. */
17416 }
17419 complain);
17421 {
17436 complain);
17437 else
17438 ret = (build_new_method_call
17443 complain));
17444 }
17445 else
17448 koenig_p,
17449 complain);
17454 {
17460 {
17466 {
17468 /* The thunk location is not interesting. */
17470 }
17471 }
17472 }
17475 }
17478 {
17484 {
17486 {
17491 }
17492 else
17493 {
17498 }
17500 }
17501 else
17502 {
17505 }
17509 }
17512 {
17517 input_location));
17518 }
17521 {
17529 {
17530 /* We have pack expansions, so expand those and
17531 create a new list out of it. */
17534 tree chain;
17537 /* Expand the argument expressions. */
17545 /* Build the rest of the list. */
17550 /* Determine the number of arguments. */
17552 {
17555 }
17558 else
17559 {
17560 /* Since we only performed a partial substitution into
17561 the argument pack, we only RETURN (a single list
17562 node. */
17569 }
17571 /* Convert the argument vectors into a TREE_LIST */
17574 {
17575 /* Grab the Ith values. */
17576 i--;
17579 value
17583 /* Build the list (backwards). */
17585 }
17588 }
17604 }
17607 {
17608 tree object;
17609 tree object_type;
17610 tree member;
17611 tree r;
17615 /* Remember that there was a reference to this entity. */
17626 else
17632 {
17637 }
17641 {
17643 {
17648 {
17651 }
17653 {
17658 }
17659 }
17660 }
17663 {
17664 /* Lookup the template functions now that we know what the
17665 scope is. */
17673 {
17676 args);
17677 member = (adjust_result_of_qualified_name_lookup
17679 object_type));
17680 }
17681 else
17682 {
17684 input_location);
17686 }
17687 }
17691 {
17693 {
17697 else
17700 }
17702 }
17706 complain);
17710 }
17717 {
17725 tree r;
17730 /* digest_init will do the wrong thing if we let it. */
17734 /* We do not want to process the index of aggregate
17735 initializers as they are identifier nodes which will be
17736 looked up by digest_init. */
17742 {
17744 /* An identifier index is looked up in the type
17745 being initialized, not the current scope. */
17750 {
17751 /* Substitute into the pack expansion. */
17753 in_decl);
17757 ;
17759 /* Just move the argument into place. */
17761 else
17762 {
17763 /* Update the length of the final CONSTRUCTOR
17764 arguments vector, and note that we will need to
17765 copy.*/
17768 }
17769 }
17770 else
17772 }
17775 {
17780 {
17782 {
17787 }
17788 else
17790 }
17791 }
17797 {
17802 }
17806 }
17809 {
17812 {
17815 }
17816 else
17817 {
17820 }
17821 }
17827 {
17828 /* We don't build decls for an instantiation of a
17829 variadic capture proxy, we instantiate the elements
17830 when needed. */
17833 }
17834 /* Fall through */
17837 {
17839 /* ??? We're doing a subset of finish_id_expression here. */
17841 && !processing_template_decl
17842 && !cp_unevaluated_operand
17845 {
17847 /* Replace an evaluated use of the thread_local variable with
17848 a call to its wrapper. */
17850 }
17852 {
17856 }
17859 /* If the original type was a reference, we'll be wrapped in
17860 the appropriate INDIRECT_REF. */
17863 }
17866 {
17870 }
17873 {
17874 tree object_ptr
17881 }
17888 {
17899 }
17902 {
17908 integral_constant_expression_p);
17912 /* If the resulting list of expression statement is empty,
17913 fold it further into void_node. */
17918 }
17921 {
17939 /* For a function or variable scope, we want to use tsubst so that we
17940 don't complain about referring to an auto before deduction. */
17943 {
17944 /* Look up the parameter we want directly, as tsubst_copy
17945 doesn't do what we need. */
17951 /* FIXME Work around the parm not having DECL_CONTEXT set. */
17954 }
17956 /* For a field, use tsubst_copy so that we look up the existing field
17957 rather than build a new one. */
17959 else
17966 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
17968 /* Now that we know visibility, instantiate the type so we have a
17969 declaration of the op() for later calls to lambda_function. */
17980 }
17983 /* We can get here for a constant initializer of non-dependent type.
17984 FIXME stop folding in cp_parser_initializer_clause. */
17985 {
17987 complain);
17989 }
17993 integral_constant_expression_p));
17999 {
18004 complain));
18005 }
18011 /* Handle Objective-C++ constructs, if appropriate. */
18012 {
18013 tree subst
18018 }
18020 }
18022 #undef RECUR
18023 #undef RETURN
18024 out:
18027 }
18029 /* Verify that the instantiated ARGS are valid. For type arguments,
18030 make sure that the type's linkage is ok. For non-type arguments,
18031 make sure they are constants if they are integral or enumerations.
18032 Emit an error under control of COMPLAIN, and return TRUE on error. */
18034 static bool
18036 {
18040 {
18050 }
18052 {
18053 /* [basic.link]: A name with no linkage (notably, the name
18054 of a class or enumeration declared in a local scope)
18055 shall not be used to declare an entity with linkage.
18056 This implies that names with no linkage cannot be used as
18057 template arguments
18059 DR 757 relaxes this restriction for C++0x. */
18064 {
18065 /* DR 488 makes use of a type with no linkage cause
18066 type deduction to fail. */
18068 {
18071 else
18074 }
18076 }
18077 /* In order to avoid all sorts of complications, we do not
18078 allow variably-modified types as template arguments. */
18080 {
18084 }
18085 }
18086 /* Class template and alias template arguments should be OK. */
18088 ;
18089 /* A non-type argument of integral or enumerated type must be a
18090 constant. */
18095 {
18099 }
18101 }
18103 static bool
18105 {
18110 {
18113 }
18117 }
18119 /* We're out of SFINAE context now, so generate diagnostics for the access
18120 errors we saw earlier when instantiating D from TMPL and ARGS. */
18122 static void
18124 {
18136 }
18138 /* Instantiate the indicated variable, function, or alias template TMPL with
18139 the template arguments in TARG_PTR. */
18141 static tree
18143 {
18145 tree fndecl;
18146 tree gen_tmpl;
18147 tree spec;
18155 /* If this function is a clone, handle it specially. */
18157 {
18158 tree spec;
18159 tree clone;
18161 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
18162 DECL_CLONED_FUNCTION. */
18168 /* Look for the clone. */
18172 /* We should always have found the clone by now. */
18175 }
18180 /* Check to see if we already have this specialization. */
18184 /* targ_ptr only has the innermost template args, so add the outer ones
18185 from tmpl, which could be either a partial instantiation or gen_tmpl (in
18186 the case of a non-dependent call within a template definition). */
18187 targ_ptr = (add_outermost_template_args
18189 targ_ptr));
18191 /* It would be nice to avoid hashing here and then again in tsubst_decl,
18192 but it doesn't seem to be on the hot path. */
18201 {
18203 {
18207 }
18209 }
18212 complain))
18215 /* We are building a FUNCTION_DECL, during which the access of its
18216 parameters and return types have to be checked. However this
18217 FUNCTION_DECL which is the desired context for access checking
18218 is not built yet. We solve this chicken-and-egg problem by
18219 deferring all checks until we have the FUNCTION_DECL. */
18222 /* Instantiation of the function happens in the context of the function
18223 template, not the context of the overload resolution we're doing. */
18225 /* If there are dependent arguments, e.g. because we're doing partial
18226 ordering, make sure processing_template_decl stays set. */
18230 {
18234 }
18240 {
18241 /* We need to determine if we're using a partial or explicit
18242 specialization now, because the type of the variable could be
18243 different. */
18249 {
18254 }
18255 }
18257 /* Substitute template parameters to obtain the specialization. */
18265 {
18268 }
18270 /* The DECL_TI_TEMPLATE should always be the immediate parent
18271 template, not the most general template. */
18275 /* Now we know the specialization, compute access previously
18276 deferred. Do no access control for inheriting constructors,
18277 as we already checked access for the inherited constructor. */
18280 {
18285 }
18288 /* If we've just instantiated the main entry point for a function,
18289 instantiate all the alternate entry points as well. We do this
18290 by cloning the instantiation of the main entry point, not by
18291 instantiating the template clones. */
18296 {
18298 {
18299 /* Remember to reinstantiate when we're out of SFINAE so the user
18300 can see the errors. */
18302 }
18304 }
18306 }
18308 /* Wrapper for instantiate_template_1. */
18310 tree
18312 {
18313 tree ret;
18318 }
18320 /* Instantiate the alias template TMPL with ARGS. Also push a template
18321 instantiation level, which instantiate_template doesn't do because
18322 functions and variables have sufficient context established by the
18323 callers. */
18325 static tree
18327 {
18334 {
18337 }
18339 args =
18347 /* We can't free this if a pending_template entry or last_error_tinst_level
18348 is pointing at it. */
18354 }
18356 /* PARM is a template parameter pack for FN. Returns true iff
18357 PARM is used in a deducible way in the argument list of FN. */
18359 static bool
18361 {
18364 {
18366 tree packs;
18372 {
18373 /* The template parameter pack is used in a function parameter
18374 pack. If this is the end of the parameter list, the
18375 template parameter pack is deducible. */
18378 else
18379 /* Otherwise, not. Well, it could be deduced from
18380 a non-pack parameter, but doing so would end up with
18381 a deduction mismatch, so don't bother. */
18383 }
18384 }
18385 /* The template parameter pack isn't used in any function parameter
18386 packs, but it might be used deeper, e.g. tuple<Args...>. */
18388 }
18390 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
18391 NARGS elements of the arguments that are being used when calling
18392 it. TARGS is a vector into which the deduced template arguments
18393 are placed.
18395 Returns either a FUNCTION_DECL for the matching specialization of FN or
18396 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
18397 true, diagnostics will be printed to explain why it failed.
18399 If FN is a conversion operator, or we are trying to produce a specific
18400 specialization, RETURN_TYPE is the return type desired.
18402 The EXPLICIT_TARGS are explicit template arguments provided via a
18403 template-id.
18405 The parameter STRICT is one of:
18407 DEDUCE_CALL:
18408 We are deducing arguments for a function call, as in
18409 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
18410 deducing arguments for a call to the result of a conversion
18411 function template, as in [over.call.object].
18413 DEDUCE_CONV:
18414 We are deducing arguments for a conversion function, as in
18415 [temp.deduct.conv].
18417 DEDUCE_EXACT:
18418 We are deducing arguments when doing an explicit instantiation
18419 as in [temp.explicit], when determining an explicit specialization
18420 as in [temp.expl.spec], or when taking the address of a function
18421 template, as in [temp.deduct.funcaddr]. */
18423 tree
18425 tree explicit_targs,
18426 tree targs,
18429 tree return_type,
18430 unification_kind_t strict,
18434 {
18435 tree parms;
18436 tree fntype;
18449 tree tinst;
18455 full_targs = (add_outermost_template_args
18457 targs));
18462 /* In C++0x, it's possible to have a function template whose type depends
18463 on itself recursively. This is most obvious with decltype, but can also
18464 occur with enumeration scope (c++/48969). So we need to catch infinite
18465 recursion and reject the substitution at deduction time; this function
18466 will return error_mark_node for any repeated substitution.
18468 This also catches excessive recursion such as when f<N> depends on
18469 f<N-1> across all integers, and returns error_mark_node for all the
18470 substitutions back up to the initial one.
18472 This is, of course, not reentrant. */
18482 {
18483 /* [temp.deduct]
18485 The specified template arguments must match the template
18486 parameters in kind (i.e., type, nontype, template), and there
18487 must not be more arguments than there are parameters;
18488 otherwise type deduction fails.
18490 Nontype arguments must match the types of the corresponding
18491 nontype template parameters, or must be convertible to the
18492 types of the corresponding nontype parameters as specified in
18493 _temp.arg.nontype_, otherwise type deduction fails.
18495 All references in the function type of the function template
18496 to the corresponding template parameters are replaced by the
18497 specified template argument values. If a substitution in a
18498 template parameter or in the function type of the function
18499 template results in an invalid type, type deduction fails. */
18510 explicit_targs);
18512 /* Adjust any explicit template arguments before entering the
18513 substitution context. */
18514 explicit_targs
18516 complain,
18522 /* Substitute the explicit args into the function type. This is
18523 necessary so that, for instance, explicitly declared function
18524 arguments can match null pointed constants. If we were given
18525 an incomplete set of explicit args, we must not do semantic
18526 processing during substitution as we could create partial
18527 instantiations. */
18529 {
18534 /* Dig out the actual parm. */
18537 {
18540 }
18542 {
18545 }
18548 /* No explicit argument for this template parameter. */
18552 {
18553 /* Mark the argument pack as "incomplete". We could
18554 still deduce more arguments during unification.
18555 We remove this mark in type_unification_real. */
18557 {
18561 }
18563 /* We have some incomplete argument packs. */
18565 }
18566 }
18570 {
18573 }
18576 /* Ignore any access checks; we'll see them again in
18577 instantiate_template and they might have the wrong
18578 access path at this point. */
18590 /* Place the explicitly specified arguments in TARGS. */
18594 }
18596 /* Never do unification on the 'this' parameter. */
18600 {
18601 /* We're deducing for a call to the result of a template conversion
18602 function. The parms we really want are in return_type. */
18606 }
18608 {
18617 }
18619 /* We allow incomplete unification without an error message here
18620 because the standard doesn't seem to explicitly prohibit it. Our
18621 callers must be ready to deal with unification failures in any
18622 event. */
18625 /* If we aren't explaining yet, push tinst context so we can see where
18626 any errors (e.g. from class instantiations triggered by instantiation
18627 of default template arguments) come from. If we are explaining, this
18628 context is redundant. */
18630 {
18633 }
18635 /* type_unification_real will pass back any access checks from default
18636 template argument substitution. */
18648 /* Now that we have bindings for all of the template arguments,
18649 ensure that the arguments deduced for the template template
18650 parameters have compatible template parameter lists. We cannot
18651 check this property before we have deduced all template
18652 arguments, because the template parameter types of a template
18653 template parameter might depend on prior template parameters
18654 deduced after the template template parameter. The following
18655 ill-formed example illustrates this issue:
18657 template<typename T, template<T> class C> void f(C<5>, T);
18659 template<int N> struct X {};
18661 void g() {
18662 f(X<5>(), 5l); // error: template argument deduction fails
18663 }
18665 The template parameter list of 'C' depends on the template type
18666 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
18667 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
18668 time that we deduce 'C'. */
18671 {
18674 }
18676 /* All is well so far. Now, check:
18678 [temp.deduct]
18680 When all template arguments have been deduced, all uses of
18681 template parameters in nondeduced contexts are replaced with
18682 the corresponding deduced argument values. If the
18683 substitution results in an invalid type, as described above,
18684 type deduction fails. */
18687 {
18690 }
18692 /* Also collect access checks from the instantiation. */
18705 /* Now perform any access checks encountered during substitution. */
18712 /* If we're looking for an exact match, check that what we got
18713 is indeed an exact match. It might not be if some template
18714 parameters are used in non-deduced contexts. But don't check
18715 for an exact match if we have dependent template arguments;
18716 in that case we're doing partial ordering, and we already know
18717 that we have two candidates that will provide the actual type. */
18719 {
18723 tree sarg
18729 {
18733 }
18734 }
18736 /* After doing deduction with the inherited constructor, actually return an
18737 instantiation of the inheriting constructor. */
18743 fail:
18746 {
18748 /* Reset once we're all the way out. */
18750 }
18752 /* We can't free this if a pending_template entry or last_error_tinst_level
18753 is pointing at it. */
18759 }
18761 /* Adjust types before performing type deduction, as described in
18762 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
18763 sections are symmetric. PARM is the type of a function parameter
18764 or the return type of the conversion function. ARG is the type of
18765 the argument passed to the call, or the type of the value
18766 initialized with the result of the conversion function.
18767 ARG_EXPR is the original argument expression, which may be null. */
18769 static int
18773 tree arg_expr)
18774 {
18778 {
18783 /* Swap PARM and ARG throughout the remainder of this
18784 function; the handling is precisely symmetric since PARM
18785 will initialize ARG rather than vice versa. */
18790 /* Core issue #873: Do the DR606 thing (see below) for these cases,
18791 too, but here handle it by stripping the reference from PARM
18792 rather than by adding it to ARG. */
18800 /* Nothing else to do in this case. */
18805 }
18808 {
18809 /* [temp.deduct.call]
18811 If P is not a reference type:
18813 --If A is an array type, the pointer type produced by the
18814 array-to-pointer standard conversion (_conv.array_) is
18815 used in place of A for type deduction; otherwise,
18817 --If A is a function type, the pointer type produced by
18818 the function-to-pointer standard conversion
18819 (_conv.func_) is used in place of A for type deduction;
18820 otherwise,
18822 --If A is a cv-qualified type, the top level
18823 cv-qualifiers of A's type are ignored for type
18824 deduction. */
18829 else
18831 }
18833 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
18834 reference to a cv-unqualified template parameter that does not represent a
18835 template parameter of a class template (during class template argument
18836 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
18837 an lvalue, the type "lvalue reference to A" is used in place of A for type
18838 deduction. */
18845 /* try_one_overload doesn't provide an arg_expr, but
18846 functions are always lvalues. */
18850 /* [temp.deduct.call]
18852 If P is a cv-qualified type, the top level cv-qualifiers
18853 of P's type are ignored for type deduction. If P is a
18854 reference type, the type referred to by P is used for
18855 type deduction. */
18858 {
18861 }
18863 /* DR 322. For conversion deduction, remove a reference type on parm
18864 too (which has been swapped into ARG). */
18869 }
18871 /* Subroutine of unify_one_argument. PARM is a function parameter of a
18872 template which does contain any deducible template parameters; check if
18873 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
18874 unify_one_argument. */
18876 static int
18879 {
18880 tree type;
18884 else
18891 {
18895 }
18897 {
18902 }
18906 else
18908 }
18912 /* Returns true iff the expression EXPR is one from which a template
18913 argument can be deduced. In other words, if it's an undecorated
18914 use of a template non-type parameter. */
18916 static bool
18918 {
18919 /* Strip implicit conversions. */
18923 }
18925 /* Returns true iff the array domain DOMAIN uses a template parameter in a
18926 deducible way; that is, if it has a max value of <PARM> - 1. */
18928 static bool
18930 {
18939 }
18941 /* Returns true iff the template arguments ARGS use a template parameter
18942 in a deducible way. */
18944 static bool
18946 {
18948 {
18953 else
18954 {
18961 else
18963 }
18966 }
18968 }
18970 /* Returns true iff TYPE contains any deducible references to template
18971 parameters, as per 14.8.2.5. */
18973 static bool
18975 {
18979 /* T
18980 cv-list T
18981 TT<T>
18982 TT<i>
18983 TT<> */
18988 /* T*
18989 T&
18990 T&& */
18994 /* T[integer-constant ]
18995 type [i] */
19000 /* T type ::*
19001 type T::*
19002 T T::*
19003 T (type ::*)()
19004 type (T::*)()
19005 type (type ::*)(T)
19006 type (T::*)(T)
19007 T (type ::*)(T)
19008 T (T::*)()
19009 T (T::*)(T) */
19012 || (uses_deducible_template_parms
19015 /* template-name <T> (where template-name refers to a class template)
19016 template-name <i> (where template-name refers to a class template) */
19023 /* type (T)
19024 T()
19025 T(T) */
19028 {
19037 }
19040 }
19042 /* Subroutine of type_unification_real and unify_pack_expansion to
19043 handle unification of a single P/A pair. Parameters are as
19044 for those functions. */
19046 static int
19050 {
19057 /* We can't deduce anything from this, but we might get all the
19058 template args from other function args. */
19061 /* Implicit conversions (Clause 4) will be performed on a function
19062 argument to convert it to the type of the corresponding function
19063 parameter if the parameter type contains no template-parameters that
19064 participate in template argument deduction. */
19067 /* For function parameters with no deducible template parameters,
19068 just return. We'll check non-dependent conversions later. */
19072 {
19074 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
19075 | UNIFY_ALLOW_MORE_CV_QUAL
19089 }
19091 /* We only do these transformations if this is the top-level
19092 parameter_type_list in a call or declaration matching; in other
19093 situations (nested function declarators, template argument lists) we
19094 won't be comparing a type to an expression, and we don't do any type
19095 adjustments. */
19097 {
19099 {
19102 {
19103 /* [temp.deduct.type] A template-argument can be
19104 deduced from a pointer to function or pointer
19105 to member function argument if the set of
19106 overloaded functions does not contain function
19107 templates and at most one of a set of
19108 overloaded functions provides a unique
19109 match. */
19116 }
19122 }
19124 arg_strict |=
19126 }
19127 else
19132 /* For deduction from an init-list we need the actual list. */
19136 }
19138 /* for_each_template_parm callback that always returns 0. */
19140 static int
19142 {
19144 }
19146 /* for_each_template_parm any_fn callback to handle deduction of a template
19147 type argument from the type of an array bound. */
19149 static int
19151 {
19159 {
19165 }
19167 /* Keep walking. */
19169 }
19171 /* Try to deduce any not-yet-deduced template type arguments from the type of
19172 an array bound. This is handled separately from unify because 14.8.2.5 says
19173 "The type of a type parameter is only deduced from an array bound if it is
19174 not otherwise deduced." */
19176 static void
19178 {
19183 }
19185 /* Most parms like fn_type_unification.
19187 If SUBR is 1, we're being called recursively (to unify the
19188 arguments of a function or method parameter of a function
19189 template).
19191 CHECKS is a pointer to a vector of access checks encountered while
19192 substituting default template arguments. */
19194 static int
19196 tree full_targs,
19197 tree xparms,
19201 unification_kind_t strict,
19205 {
19210 tree parms;
19221 /* Reset the number of non-defaulted template arguments contained
19222 in TARGS. */
19225 again:
19233 {
19238 /* For a function parameter pack that occurs at the end of the
19239 parameter-declaration-list, the type A of each remaining
19240 argument of the call is compared with the type P of the
19241 declarator-id of the function parameter pack. */
19247 /* For a function parameter pack that does not occur at the
19248 end of the parameter-declaration-list, the type of the
19249 parameter pack is a non-deduced context. */
19256 explain_p))
19258 }
19263 {
19264 /* Unify the remaining arguments with the pack expansion type. */
19265 tree argvec;
19268 /* Allocate a TREE_VEC and copy in all of the arguments */
19273 /* Copy the parameter into parmvec. */
19279 /* Advance to the end of the list of parameters. */
19281 }
19283 /* Fail if we've reached the end of the parm list, and more args
19284 are present, and the parm list isn't variadic. */
19287 /* Fail if parms are left and they don't have default values and
19288 they aren't all deduced as empty packs (c++/57397). This is
19289 consistent with sufficient_parms_p. */
19292 {
19296 do
19297 {
19300 count++;
19302 }
19306 type_pack_p);
19307 }
19310 {
19311 tsubst_flags_t complain = (explain_p
19312 ? tf_warning_or_error
19317 {
19321 /* Clear the "incomplete" flags on all argument packs now so that
19322 substituting them into later default arguments works. */
19324 {
19327 }
19335 {
19340 }
19342 /* If this is an undeduced nontype parameter that depends on
19343 a type parameter, try another pass; its type may have been
19344 deduced from a later argument than the one from which
19345 this parameter can be deduced. */
19349 {
19352 }
19354 /* Core issue #226 (C++0x) [temp.deduct]:
19356 If a template argument has not been deduced, its
19357 default template argument, if any, is used.
19359 When we are in C++98 mode, TREE_PURPOSE will either
19360 be NULL_TREE or ERROR_MARK_NODE, so we do not need
19361 to explicitly check cxx_dialect here. */
19363 /* OK, there is a default argument. Wait until after the
19364 conversion check to do substitution. */
19367 /* If the type parameter is a parameter pack, then it will
19368 be deduced to an empty parameter pack. */
19370 {
19371 tree arg;
19374 {
19377 }
19378 else
19385 }
19388 }
19390 /* DR 1391: All parameters have args, now check non-dependent parms for
19391 convertibility. */
19395 {
19401 /* For a function parameter pack that occurs at the end of the
19402 parameter-declaration-list, the type A of each remaining
19403 argument of the call is compared with the type P of the
19404 declarator-id of the function parameter pack. */
19410 /* For a function parameter pack that does not occur at the
19411 end of the parameter-declaration-list, the type of the
19412 parameter pack is a non-deduced context. */
19421 explain_p))
19423 }
19425 /* Now substitute into the default template arguments. */
19427 {
19451 else
19459 {
19461 /* The position of the first default template argument,
19462 is also the number of non-defaulted arguments in TARGS.
19463 Record that. */
19466 }
19467 }
19471 }
19477 }
19479 /* Subroutine of type_unification_real. Args are like the variables
19480 at the call site. ARG is an overloaded function (or template-id);
19481 we try deducing template args from each of the overloads, and if
19482 only one succeeds, we go with that. Modifies TARGS and returns
19483 true on success. */
19485 static bool
19487 tree targs,
19488 tree parm,
19489 tree arg,
19490 unification_kind_t strict,
19493 {
19500 {
19503 }
19504 else
19508 /* Handle `&x' where `x' is some static or non-static member
19509 function name. */
19515 /* Strip baselink information. */
19520 {
19521 /* If we got some explicit template args, we need to plug them into
19522 the affected templates before we try to unify, in case the
19523 explicit args will completely resolve the templates in question. */
19530 {
19543 {
19548 {
19551 }
19552 }
19555 }
19556 /* If no templates (or more than one) are fully resolved by the
19557 explicit arguments, this template-id is a non-deduced context; it
19558 could still be OK if we deduce all template arguments for the
19559 enclosing call through other arguments. */
19562 }
19565 /* If ARG is, for example, "(0, &f)" then its type will be unknown
19566 -- but the deduction does not succeed because the expression is
19567 not just the function on its own. */
19569 else
19571 {
19576 {
19579 }
19580 }
19582 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19583 to function or pointer to member function argument if the set of
19584 overloaded functions does not contain function templates and at most
19585 one of a set of overloaded functions provides a unique match.
19587 So if we found multiple possibilities, we return success but don't
19588 deduce anything. */
19591 {
19595 {
19600 /* Don't forget explicit template arguments in a pack. */
19604 }
19605 }
19610 }
19612 /* Core DR 115: In contexts where deduction is done and fails, or in
19613 contexts where deduction is not done, if a template argument list is
19614 specified and it, along with any default template arguments, identifies
19615 a single function template specialization, then the template-id is an
19616 lvalue for the function template specialization. */
19618 tree
19620 {
19633 {
19636 }
19638 {
19641 }
19643 {
19646 }
19649 {
19653 /* If we got some explicit template args, we need to plug them into
19654 the affected templates before we try to unify, in case the
19655 explicit args will completely resolve the templates in question. */
19663 {
19676 {
19679 {
19682 }
19684 {
19687 }
19688 }
19689 }
19691 {
19699 {
19700 tree base
19703 }
19707 }
19709 /* There were no good options and at least one bad one, so let the
19710 user know what the problem is. */
19712 }
19714 }
19716 /* Subroutine of resolve_overloaded_unification; does deduction for a single
19717 overload. Fills TARGS with any deduced arguments, or error_mark_node if
19718 different overloads deduce different arguments for a given parm.
19719 ADDR_P is true if the expression for which deduction is being
19720 performed was of the form "& fn" rather than simply "fn".
19722 Returns 1 on success. */
19724 static int
19726 tree orig_targs,
19727 tree targs,
19728 tree parm,
19729 tree arg,
19730 unification_kind_t strict,
19734 {
19736 tree tempargs;
19742 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19743 to function or pointer to member function argument if the set of
19744 overloaded functions does not contain function templates and at most
19745 one of a set of overloaded functions provides a unique match.
19747 So if this is a template, just return success. */
19759 /* We don't copy orig_targs for this because if we have already deduced
19760 some template args from previous args, unify would complain when we
19761 try to deduce a template parameter for the same argument, even though
19762 there isn't really a conflict. */
19769 /* First make sure we didn't deduce anything that conflicts with
19770 explicitly specified args. */
19772 {
19779 /* Since we're unifying against ourselves, we will fill in
19780 template args used in the function parm list with our own
19781 template parms. Discard them. */
19784 {
19785 /* Check that the argument at each index of the deduced argument pack
19786 is equivalent to the corresponding explicitly specified argument.
19787 We may have deduced more arguments than were explicitly specified,
19788 and that's OK. */
19790 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
19791 that's wrong if we deduce the same argument pack from multiple
19792 function arguments: it's only incomplete the first time. */
19805 }
19808 }
19811 {
19816 }
19819 }
19821 /* PARM is a template class (perhaps with unbound template
19822 parameters). ARG is a fully instantiated type. If ARG can be
19823 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
19824 TARGS are as for unify. */
19826 static tree
19829 {
19830 tree copy_of_targs;
19840 /* We need to make a new template argument vector for the call to
19841 unify. If we used TARGS, we'd clutter it up with the result of
19842 the attempted unification, even if this class didn't work out.
19843 We also don't want to commit ourselves to all the unifications
19844 we've already done, since unification is supposed to be done on
19845 an argument-by-argument basis. In other words, consider the
19846 following pathological case:
19848 template <int I, int J, int K>
19849 struct S {};
19851 template <int I, int J>
19852 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
19854 template <int I, int J, int K>
19855 void f(S<I, J, K>, S<I, I, I>);
19857 void g() {
19858 S<0, 0, 0> s0;
19859 S<0, 1, 2> s2;
19861 f(s0, s2);
19862 }
19864 Now, by the time we consider the unification involving `s2', we
19865 already know that we must have `f<0, 0, 0>'. But, even though
19866 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
19867 because there are two ways to unify base classes of S<0, 1, 2>
19868 with S<I, I, I>. If we kept the already deduced knowledge, we
19869 would reject the possibility I=1. */
19873 {
19877 }
19879 /* If unification failed, we're done. */
19885 }
19887 /* Given a template type PARM and a class type ARG, find the unique
19888 base type in ARG that is an instance of PARM. We do not examine
19889 ARG itself; only its base-classes. If there is not exactly one
19890 appropriate base class, return NULL_TREE. PARM may be the type of
19891 a partial specialization, as well as a plain template type. Used
19892 by unify. */
19894 static enum template_base_result
19897 {
19899 tree binfo;
19905 {
19906 /* The type could not be completed. */
19909 }
19911 /* Walk in inheritance graph order. The search order is not
19912 important, and this avoids multiple walks of virtual bases. */
19914 {
19919 {
19920 /* If there is more than one satisfactory baseclass, then:
19922 [temp.deduct.call]
19924 If they yield more than one possible deduced A, the type
19925 deduction fails.
19927 applies. */
19929 {
19932 }
19935 }
19936 }
19940 }
19942 /* Returns the level of DECL, which declares a template parameter. */
19944 static int
19946 {
19948 {
19958 }
19960 }
19962 /* Decide whether ARG can be unified with PARM, considering only the
19963 cv-qualifiers of each type, given STRICT as documented for unify.
19964 Returns nonzero iff the unification is OK on that basis. */
19966 static int
19968 {
19974 {
19975 /* Although a CVR qualifier is ignored when being applied to a
19976 substituted template parameter ([8.3.2]/1 for example), that
19977 does not allow us to unify "const T" with "int&" because both
19978 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
19979 It is ok when we're allowing additional CV qualifiers
19980 at the outer level [14.8.2.1]/3,1st bullet. */
19990 }
20001 }
20003 /* Determines the LEVEL and INDEX for the template parameter PARM. */
20004 void
20006 {
20010 {
20013 }
20014 else
20015 {
20018 }
20019 }
20021 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
20022 do { \
20023 if (unify (TP, TA, P, A, S, EP)) \
20024 return 1; \
20025 } while (0)
20027 /* Unifies the remaining arguments in PACKED_ARGS with the pack
20028 expansion at the end of PACKED_PARMS. Returns 0 if the type
20029 deduction succeeds, 1 otherwise. STRICT is the same as in
20030 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
20031 function call argument list. We'll need to adjust the arguments to make them
20032 types. SUBR tells us if this is from a recursive call to
20033 type_unification_real, or for comparing two template argument
20034 lists. */
20036 static int
20040 {
20041 tree parm
20047 /* Add in any args remembered from an earlier partial instantiation. */
20054 /* Determine the parameter packs we will be deducing from the
20055 pattern, and record their current deductions. */
20058 {
20062 /* Determine the index and level of this parameter pack. */
20065 /* Keep track of the parameter packs and their corresponding
20066 argument packs. */
20069 }
20071 /* Loop through all of the arguments that have not yet been
20072 unified and unify each with the pattern. */
20074 {
20075 tree parm;
20079 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
20080 or the element of its argument pack at the current index if
20081 this argument was explicitly specified. */
20083 {
20092 {
20095 }
20097 }
20099 /* If we had explicit template arguments, substitute them into the
20100 pattern before deduction. */
20102 {
20103 /* Some arguments might still be unspecified or dependent. */
20111 NULL_TREE);
20116 }
20117 else
20120 /* Unify the pattern with the current argument. */
20122 explain_p))
20125 /* For each parameter pack, collect the deduced value. */
20127 {
20133 }
20134 }
20136 /* Verify that the results of unification with the parameter packs
20137 produce results consistent with what we've seen before, and make
20138 the deduced argument packs available. */
20140 {
20147 /* By default keep the original deduced argument pack.
20148 If necessary, more specific code is going to update the
20149 resulting deduced argument later down in this function. */
20153 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
20154 actually deduce anything. */
20162 {
20163 /* If we had fewer function args than explicit template args,
20164 just use the explicits. */
20169 }
20172 {
20173 tree result;
20174 /* Build the deduced *_ARGUMENT_PACK. */
20176 {
20179 }
20180 else
20185 /* Note the deduced argument packs for this parameter
20186 pack. */
20188 }
20192 {
20193 /* We only had the explicitly-provided arguments before, but
20194 now we have a complete set of arguments. */
20200 }
20201 else
20202 {
20208 /* Inconsistent unification of this parameter pack. */
20210 bad_old_arg,
20211 bad_new_arg);
20212 }
20213 }
20216 }
20218 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
20219 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
20220 parameters and return value are as for unify. */
20222 static int
20226 {
20227 tree parm_max;
20228 tree arg_max;
20232 /* Our representation of array types uses "N - 1" as the
20233 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
20234 not an integer constant. We cannot unify arbitrarily
20235 complex expressions, so we eliminate the MINUS_EXPRs
20236 here. */
20240 {
20243 }
20247 {
20248 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
20249 trying to unify the type of a variable with the type
20250 of a template parameter. For example:
20252 template <unsigned int N>
20253 void f (char (&) [N]);
20254 int g();
20255 void h(int i) {
20256 char a[g(i)];
20257 f(a);
20258 }
20260 Here, the type of the ARG will be "int [g(i)]", and
20261 may be a SAVE_EXPR, etc. */
20265 }
20267 /* If only one of the bounds used a MINUS_EXPR, compensate
20268 by adding one to the other bound. */
20271 integer_type_node,
20272 parm_max,
20273 integer_one_node);
20276 integer_type_node,
20277 arg_max,
20278 integer_one_node);
20282 }
20284 /* Returns whether T, a P or A in unify, is a type, template or expression. */
20288 static pa_kind_t
20290 {
20299 else
20301 }
20303 /* Deduce the value of template parameters. TPARMS is the (innermost)
20304 set of template parameters to a template. TARGS is the bindings
20305 for those template parameters, as determined thus far; TARGS may
20306 include template arguments for outer levels of template parameters
20307 as well. PARM is a parameter to a template function, or a
20308 subcomponent of that parameter; ARG is the corresponding argument.
20309 This function attempts to match PARM with ARG in a manner
20310 consistent with the existing assignments in TARGS. If more values
20311 are deduced, then TARGS is updated.
20313 Returns 0 if the type deduction succeeds, 1 otherwise. The
20314 parameter STRICT is a bitwise or of the following flags:
20316 UNIFY_ALLOW_NONE:
20317 Require an exact match between PARM and ARG.
20318 UNIFY_ALLOW_MORE_CV_QUAL:
20319 Allow the deduced ARG to be more cv-qualified (by qualification
20320 conversion) than ARG.
20321 UNIFY_ALLOW_LESS_CV_QUAL:
20322 Allow the deduced ARG to be less cv-qualified than ARG.
20323 UNIFY_ALLOW_DERIVED:
20324 Allow the deduced ARG to be a template base class of ARG,
20325 or a pointer to a template base class of the type pointed to by
20326 ARG.
20327 UNIFY_ALLOW_INTEGER:
20328 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
20329 case for more information.
20330 UNIFY_ALLOW_OUTER_LEVEL:
20331 This is the outermost level of a deduction. Used to determine validity
20332 of qualification conversions. A valid qualification conversion must
20333 have const qualified pointers leading up to the inner type which
20334 requires additional CV quals, except at the outer level, where const
20335 is not required [conv.qual]. It would be normal to set this flag in
20336 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
20337 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
20338 This is the outermost level of a deduction, and PARM can be more CV
20339 qualified at this point.
20340 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
20341 This is the outermost level of a deduction, and PARM can be less CV
20342 qualified at this point. */
20344 static int
20347 {
20349 tree targ;
20350 tree tparm;
20352 tsubst_flags_t complain = (explain_p
20353 ? tf_warning_or_error
20356 /* I don't think this will do the right thing with respect to types.
20357 But the only case I've seen it in so far has been array bounds, where
20358 signedness is the only information lost, and I think that will be
20359 okay. */
20367 /* We can't deduce anything from this, but we might get all the
20368 template args from other function args. */
20374 /* If PARM uses template parameters, then we can't bail out here,
20375 even if ARG == PARM, since we won't record unifications for the
20376 template parameters. We might need them if we're trying to
20377 figure out which of two things is more specialized. */
20381 /* Handle init lists early, so the rest of the function can assume
20382 we're dealing with a type. */
20384 {
20389 /* Replace T with std::initializer_list<T> for deduction. */
20396 /* We can only deduce from an initializer list argument if the
20397 parameter is std::initializer_list or an array; otherwise this
20398 is a non-deduced context. */
20403 else
20404 {
20406 /* Deduction is defined in terms of a single type, so just punt
20407 on the (bizarre) std::initializer_list<T...>. */
20410 }
20413 {
20420 {
20424 /* It should only be possible to get here for a call. */
20426 elt_strict |= maybe_adjust_types_for_deduction
20429 }
20432 explain_p);
20433 }
20437 {
20438 /* Also deduce from the length of the initializer list. */
20445 }
20447 /* If the std::initializer_list<T> deduction worked, replace the
20448 deduced A with std::initializer_list<A>. */
20450 {
20455 }
20457 }
20459 /* If parm and arg aren't the same kind of thing (template, type, or
20460 expression), fail early. */
20464 /* Immediately reject some pairs that won't unify because of
20465 cv-qualification mismatches. */
20468 /* It is the elements of the array which hold the cv quals of an array
20469 type, and the elements might be template type parms. We'll check
20470 when we recurse. */
20472 /* We check the cv-qualifiers when unifying with template type
20473 parameters below. We want to allow ARG `const T' to unify with
20474 PARM `T' for example, when computing which of two templates
20475 is more specialized, for example. */
20489 {
20493 /* In a type which contains a nested-name-specifier, template
20494 argument values cannot be deduced for template parameters used
20495 within the nested-name-specifier. */
20507 /* The PARM is not one we're trying to unify. Just check
20508 to see if it matches ARG. */
20509 {
20514 else
20516 }
20523 /* Check for mixed types and values. */
20531 {
20534 {
20535 /* First try to match ARG directly. */
20537 explain_p);
20539 {
20540 /* Otherwise, look for a suitable base of ARG, as below. */
20547 }
20548 }
20549 /* ARG must be constructed from a template class or a template
20550 template parameter. */
20555 /* Deduce arguments T, i from TT<T> or TT<i>. */
20561 /* Fall through to deduce template name. */
20562 }
20566 {
20567 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
20569 /* Simple cases: Value already set, does match or doesn't. */
20574 }
20575 else
20576 {
20577 /* If PARM is `const T' and ARG is only `int', we don't have
20578 a match unless we are allowing additional qualification.
20579 If ARG is `const int' and PARM is just `T' that's OK;
20580 that binds `const int' to `T'. */
20585 /* Consider the case where ARG is `const volatile int' and
20586 PARM is `const T'. Then, T should be `volatile int'. */
20587 arg = cp_build_qualified_type_real
20592 /* Simple cases: Value already set, does match or doesn't. */
20598 /* Make sure that ARG is not a variable-sized array. (Note
20599 that were talking about variable-sized arrays (like
20600 `int[n]'), rather than arrays of unknown size (like
20601 `int[]').) We'll get very confused by such a type since
20602 the bound of the array is not constant, and therefore
20603 not mangleable. Besides, such types are not allowed in
20604 ISO C++, so we can do as we please here. We do allow
20605 them for 'auto' deduction, since that isn't ABI-exposed. */
20609 /* Strip typedefs as in convert_template_argument. */
20611 }
20613 /* If ARG is a parameter pack or an expansion, we cannot unify
20614 against it unless PARM is also a parameter pack. */
20619 /* If the argument deduction results is a METHOD_TYPE,
20620 then there is a problem.
20621 METHOD_TYPE doesn't map to any real C++ type the result of
20622 the deduction can not be of that type. */
20636 {
20637 /* The PARM is not one we're trying to unify. Just check
20638 to see if it matches ARG. */
20644 }
20650 {
20655 }
20657 /* [temp.deduct.type] If, in the declaration of a function template
20658 with a non-type template-parameter, the non-type
20659 template-parameter is used in an expression in the function
20660 parameter-list and, if the corresponding template-argument is
20661 deduced, the template-argument type shall match the type of the
20662 template-parameter exactly, except that a template-argument
20663 deduced from an array bound may be of any integral type.
20664 The non-type parameter might use already deduced type parameters. */
20667 {
20671 }
20674 /* Template-parameter dependent expression. Just accept it for now.
20675 It will later be processed in convert_template_argument. */
20676 ;
20682 /* Convert the ARG to the type of PARM; the deduced non-type
20683 template argument must exactly match the types of the
20684 corresponding parameter. */
20687 {
20688 /* We haven't deduced the type of this parameter yet. */
20690 /* We deduce from array bounds in try_array_deduction. */
20692 {
20693 /* Deduce it from the non-type argument. */
20698 }
20699 else
20700 /* Try again later. */
20702 }
20703 else
20706 /* If ARG is a parameter pack or an expansion, we cannot unify
20707 against it unless PARM is also a parameter pack. */
20712 {
20715 }
20720 {
20721 /* A pointer-to-member constant can be unified only with
20722 another constant. */
20726 /* Just unify the class member. It would be useless (and possibly
20727 wrong, depending on the strict flags) to unify also
20728 PTRMEM_CST_CLASS, because we want to be sure that both parm and
20729 arg refer to the same variable, even if through different
20730 classes. For instance:
20732 struct A { int x; };
20733 struct B : A { };
20735 Unification of &A::x and &B::x must succeed. */
20738 }
20741 {
20745 /* [temp.deduct.call]
20747 A can be another pointer or pointer to member type that can
20748 be converted to the deduced A via a qualification
20749 conversion (_conv.qual_).
20751 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
20752 This will allow for additional cv-qualification of the
20753 pointed-to types if appropriate. */
20756 /* The derived-to-base conversion only persists through one
20757 level of pointers. */
20762 }
20794 /* We have already checked cv-qualification at the top of the
20795 function. */
20799 /* As far as unification is concerned, this wins. Later checks
20800 will invalidate it if necessary. */
20803 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
20804 /* Type INTEGER_CST can come from ordinary constant template args. */
20816 {
20826 /* Check for pack expansions in the parameters. */
20828 {
20830 {
20832 /* We can unify against something with a trailing
20833 parameter pack. */
20835 else
20836 /* [temp.deduct.type]/9: If the template argument list of
20837 P contains a pack expansion that is not the last
20838 template argument, the entire template argument list
20839 is a non-deduced context. */
20841 }
20842 }
20844 /* If we don't have enough arguments to satisfy the parameters
20845 (not counting the pack expression at the end), or we have
20846 too many arguments for a parameter list that doesn't end in
20847 a pack expression, we can't unify. */
20853 /* Unify all of the parameters that precede the (optional)
20854 pack expression. */
20856 {
20861 }
20864 DEDUCE_EXACT,
20867 }
20875 {
20883 }
20888 {
20892 {
20893 /* First, we try to unify the PARM and ARG directly. */
20898 {
20899 /* Fallback to the special case allowed in
20900 [temp.deduct.call]:
20902 If P is a class, and P has the form
20903 template-id, then A can be a derived class of
20904 the deduced A. Likewise, if P is a pointer to
20905 a class of the form template-id, A can be a
20906 pointer to a derived class pointed to by the
20907 deduced A. */
20913 {
20914 /* Don't give the derived diagnostic if we're
20915 already dealing with the same template. */
20916 bool same_template
20922 }
20923 }
20924 }
20928 /* Perhaps PARM is something like S<U> and ARG is S<int>.
20929 Then, we should unify `int' and `U'. */
20931 else
20932 /* There's no chance of unification succeeding. */
20937 }
20944 {
20947 tree a;
20953 /* CV qualifications for methods can never be deduced, they must
20954 match exactly. We need to check them explicitly here,
20955 because type_unification_real treats them as any other
20956 cv-qualified parameter. */
20958 && (!check_cv_quals_for_unify
20986 {
20998 }
21001 }
21004 /* Unify a pointer to member with a pointer to member function, which
21005 deduces the type of the member as a function type. */
21007 {
21008 /* Check top-level cv qualifiers */
21016 /* Determine the type of the function we are unifying against. */
21020 }
21039 /* Matched cases are handled by the ARG == PARM test above. */
21043 /* We might get a variable as a non-type template argument in parm if the
21044 corresponding parameter is type-dependent. Make any necessary
21045 adjustments based on whether arg is a reference. */
21049 {
21054 }
21055 /* Now use the normal expression code to check whether they match. */
21066 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
21067 or UNDERLYING_TYPE nodes. */
21071 /* Unification fails if we hit an error node. */
21076 {
21086 }
21087 /* FALLTHRU */
21090 /* An unresolved overload is a nondeduced context. */
21094 expr:
21095 /* We must be looking at an expression. This can happen with
21096 something like:
21098 template <int I>
21099 void foo(S<I>, S<I + 2>);
21101 This is a "nondeduced context":
21103 [deduct.type]
21105 The nondeduced contexts are:
21107 --A type that is a template-id in which one or more of
21108 the template-arguments is an expression that references
21109 a template-parameter.
21111 In these cases, we assume deduction succeeded, but don't
21112 actually infer any unifications. */
21117 else
21119 }
21120 }
21121 #undef RECUR_AND_CHECK_FAILURE
21122 \f
21123 /* Note that DECL can be defined in this translation unit, if
21124 required. */
21126 static void
21128 {
21129 tree clone;
21133 }
21135 /* Called if RESULT is explicitly instantiated, or is a member of an
21136 explicitly instantiated class. */
21138 void
21140 {
21143 /* If this entity has already been written out, it's too late to
21144 make any modifications. */
21148 /* For anonymous namespace we don't need to do anything. */
21150 {
21153 }
21156 /* The TREE_PUBLIC flag for function declarations will have been
21157 set correctly by tsubst. */
21160 /* This might have been set by an earlier implicit instantiation. */
21165 else
21166 {
21169 /* Always make artificials weak. */
21172 /* For WIN32 we also want to put explicit instantiations in
21173 linkonce sections. */
21176 }
21178 /* If EXTERN_P, then this function will not be emitted -- unless
21179 followed by an explicit instantiation, at which point its linkage
21180 will be adjusted. If !EXTERN_P, then this function will be
21181 emitted here. In neither circumstance do we want
21182 import_export_decl to adjust the linkage. */
21184 }
21186 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
21187 important template arguments. If any are missing, we check whether
21188 they're important by using error_mark_node for substituting into any
21189 args that were used for partial ordering (the ones between ARGS and END)
21190 and seeing if it bubbles up. */
21192 static bool
21194 {
21199 {
21202 }
21204 {
21208 }
21210 }
21212 /* Given two function templates PAT1 and PAT2, return:
21214 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
21215 -1 if PAT2 is more specialized than PAT1.
21216 0 if neither is more specialized.
21218 LEN indicates the number of parameters we should consider
21219 (defaulted parameters should not be considered).
21221 The 1998 std underspecified function template partial ordering, and
21222 DR214 addresses the issue. We take pairs of arguments, one from
21223 each of the templates, and deduce them against each other. One of
21224 the templates will be more specialized if all the *other*
21225 template's arguments deduce against its arguments and at least one
21226 of its arguments *does* *not* deduce against the other template's
21227 corresponding argument. Deduction is done as for class templates.
21228 The arguments used in deduction have reference and top level cv
21229 qualifiers removed. Iff both arguments were originally reference
21230 types *and* deduction succeeds in both directions, an lvalue reference
21231 wins against an rvalue reference and otherwise the template
21232 with the more cv-qualified argument wins for that pairing (if
21233 neither is more cv-qualified, they both are equal). Unlike regular
21234 deduction, after all the arguments have been deduced in this way,
21235 we do *not* verify the deduced template argument values can be
21236 substituted into non-deduced contexts.
21238 The logic can be a bit confusing here, because we look at deduce1 and
21239 targs1 to see if pat2 is at least as specialized, and vice versa; if we
21240 can find template arguments for pat1 to make arg1 look like arg2, that
21241 means that arg2 is at least as specialized as arg1. */
21243 int
21245 {
21258 /* Remove the this parameter from non-static member functions. If
21259 one is a non-static member function and the other is not a static
21260 member function, remove the first parameter from that function
21261 also. This situation occurs for operator functions where we
21262 locate both a member function (with this pointer) and non-member
21263 operator (with explicit first operand). */
21265 {
21270 }
21272 {
21275 {
21276 len--;
21278 }
21279 }
21281 /* If only one is a conversion operator, they are unordered. */
21285 /* Consider the return type for a conversion function */
21287 {
21290 len++;
21291 }
21293 processing_template_decl++;
21299 /* Stop when an ellipsis is seen. */
21301 {
21312 {
21313 /* When both arguments are pack expansions, we need only
21314 unify the patterns themselves. */
21318 /* This is the last comparison we need to do. */
21320 }
21322 /* DR 1847: If a particular P contains no template-parameters that
21323 participate in template argument deduction, that P is not used to
21324 determine the ordering. */
21330 {
21334 }
21337 {
21341 }
21347 {
21353 /* Setup the parameter vector, which contains only ARG1. */
21356 /* Setup the argument vector, which contains the remaining
21357 arguments. */
21366 /* We cannot deduce in the other direction, because ARG1 is
21367 a pack expansion but ARG2 is not. */
21369 }
21371 {
21377 /* Setup the parameter vector, which contains only ARG1. */
21380 /* Setup the argument vector, which contains the remaining
21381 arguments. */
21390 /* We cannot deduce in the other direction, because ARG2 is
21391 a pack expansion but ARG1 is not.*/
21393 }
21395 else
21396 {
21397 /* The normal case, where neither argument is a pack
21398 expansion. */
21405 }
21407 /* If we couldn't deduce arguments for tparms1 to make arg1 match
21408 arg2, then arg2 is not as specialized as arg1. */
21414 /* "If, for a given type, deduction succeeds in both directions
21415 (i.e., the types are identical after the transformations above)
21416 and both P and A were reference types (before being replaced with
21417 the type referred to above):
21418 - if the type from the argument template was an lvalue reference and
21419 the type from the parameter template was not, the argument type is
21420 considered to be more specialized than the other; otherwise,
21421 - if the type from the argument template is more cv-qualified
21422 than the type from the parameter template (as described above),
21423 the argument type is considered to be more specialized than the other;
21424 otherwise,
21425 - neither type is more specialized than the other." */
21428 {
21430 {
21433 else
21435 }
21437 {
21442 }
21443 }
21446 /* We've failed to deduce something in either direction.
21447 These must be unordered. */
21450 next:
21454 /* We have already processed all of the arguments in our
21455 handing of the pack expansion type. */
21460 }
21462 /* "In most cases, all template parameters must have values in order for
21463 deduction to succeed, but for partial ordering purposes a template
21464 parameter may remain without a value provided it is not used in the
21465 types being used for partial ordering."
21467 Thus, if we are missing any of the targs1 we need to substitute into
21468 origs1, then pat2 is not as specialized as pat1. This can happen when
21469 there is a nondeduced context. */
21475 processing_template_decl--;
21477 /* If both deductions succeed, the partial ordering selects the more
21478 constrained template. */
21480 {
21485 }
21487 /* All things being equal, if the next argument is a pack expansion
21488 for one function but not for the other, prefer the
21489 non-variadic function. FIXME this is bogus; see c++/41958. */
21493 {
21496 }
21502 else
21504 }
21506 /* Determine which of two partial specializations of TMPL is more
21507 specialized.
21509 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
21510 to the first partial specialization. The TREE_PURPOSE is the
21511 innermost set of template parameters for the partial
21512 specialization. PAT2 is similar, but for the second template.
21514 Return 1 if the first partial specialization is more specialized;
21515 -1 if the second is more specialized; 0 if neither is more
21516 specialized.
21518 See [temp.class.order] for information about determining which of
21519 two templates is more specialized. */
21521 static int
21523 {
21524 tree targs;
21533 /* Just like what happens for functions, if we are ordering between
21534 different template specializations, we may encounter dependent
21535 types in the arguments, and we need our dependency check functions
21536 to behave correctly. */
21540 {
21543 }
21547 {
21550 }
21553 /* If both deductions succeed, the partial ordering selects the more
21554 constrained template. */
21558 /* In the case of a tie where at least one of the templates
21559 has a parameter pack at the end, the template with the most
21560 non-packed parameters wins. */
21562 && any_deductions
21565 {
21571 /* We don't count the pack expansion at the end. */
21581 }
21584 }
21586 /* Return the template arguments that will produce the function signature
21587 DECL from the function template FN, with the explicit template
21588 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
21589 also match. Return NULL_TREE if no satisfactory arguments could be
21590 found. */
21592 static tree
21594 {
21598 tree decl_arg_types;
21601 tree arg;
21605 /* Never do unification on the 'this' parameter. */
21626 }
21628 /* Return the innermost template arguments that, when applied to a partial
21629 specialization SPEC_TMPL of TMPL, yield the ARGS.
21631 For example, suppose we have:
21633 template <class T, class U> struct S {};
21634 template <class T> struct S<T*, int> {};
21636 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
21637 partial specialization and the ARGS will be {double*, int}. The resulting
21638 vector will be {double}, indicating that `T' is bound to `double'. */
21640 static tree
21642 {
21644 tree spec_args
21647 tree deduced_args;
21648 tree innermost_deduced_args;
21652 {
21656 innermost_deduced_args);
21657 }
21658 else
21662 again:
21671 {
21673 {
21679 }
21681 }
21685 {
21688 }
21690 /* Verify that nondeduced template arguments agree with the type
21691 obtained from argument deduction.
21693 For example:
21695 struct A { typedef int X; };
21696 template <class T, class U> struct C {};
21697 template <class T> struct C<T, typename T::X> {};
21699 Then with the instantiation `C<A, int>', we can deduce that
21700 `T' is `A' but unify () does not check whether `typename T::X'
21701 is `int'. */
21712 /* We only need to check the innermost arguments; the other
21713 arguments will always agree. */
21718 /* Now that we have bindings for all of the template arguments,
21719 ensure that the arguments deduced for the template template
21720 parameters have compatible template parameter lists. See the use
21721 of template_template_parm_bindings_ok_p in fn_type_unification
21722 for more information. */
21727 }
21729 // Compare two function templates T1 and T2 by deducing bindings
21730 // from one against the other. If both deductions succeed, compare
21731 // constraints to see which is more constrained.
21732 static int
21734 {
21739 {
21742 }
21745 {
21748 }
21750 // If both deductions succeed, then one may be more constrained.
21755 }
21757 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
21758 Return the TREE_LIST node with the most specialized template, if
21759 any. If there is no most specialized template, the error_mark_node
21760 is returned.
21762 Note that this function does not look at, or modify, the
21763 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
21764 returned is one of the elements of INSTANTIATIONS, callers may
21765 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
21766 and retrieve it from the value returned. */
21768 tree
21770 {
21777 {
21783 {
21784 /* Equally specialized, move to next function. If there
21785 is no next function, nothing's most specialized. */
21790 }
21791 }
21794 /* Now verify that champ is better than everything earlier in the
21795 instantiation list. */
21798 {
21801 }
21802 }
21804 processing_template_decl--;
21810 }
21812 /* If DECL is a specialization of some template, return the most
21813 general such template. Otherwise, returns NULL_TREE.
21815 For example, given:
21817 template <class T> struct S { template <class U> void f(U); };
21819 if TMPL is `template <class U> void S<int>::f(U)' this will return
21820 the full template. This function will not trace past partial
21821 specializations, however. For example, given in addition:
21823 template <class T> struct S<T*> { template <class U> void f(U); };
21825 if TMPL is `template <class U> void S<int*>::f(U)' this will return
21826 `template <class T> template <class U> S<T*>::f(U)'. */
21828 tree
21830 {
21832 {
21835 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
21836 template friend, or a FIELD_DECL for a capture pack. */
21839 }
21841 /* Look for more and more general templates. */
21843 {
21844 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
21845 (See cp-tree.h for details.) */
21854 /* Stop if we run into an explicitly specialized class template. */
21861 }
21864 }
21866 /* Return the most specialized of the template partial specializations
21867 which can produce TARGET, a specialization of some class or variable
21868 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
21869 a TEMPLATE_DECL node corresponding to the partial specialization, while
21870 the TREE_PURPOSE is the set of template arguments that must be
21871 substituted into the template pattern in order to generate TARGET.
21873 If the choice of partial specialization is ambiguous, a diagnostic
21874 is issued, and the error_mark_node is returned. If there are no
21875 partial specializations matching TARGET, then NULL_TREE is
21876 returned, indicating that the primary template should be used. */
21878 static tree
21880 {
21882 tree t;
21883 tree champ;
21890 {
21894 }
21896 {
21899 }
21901 {
21905 }
21906 else
21911 /* For determining which partial specialization to use, only the
21912 innermost args are interesting. */
21914 {
21917 }
21920 {
21921 tree spec_args;
21925 {
21926 /* Substitute in the template args from the enclosing class. */
21930 }
21937 {
21941 /* Keep the candidate only if the constraints are satisfied,
21942 or if we're not compiling with concepts. */
21945 {
21948 }
21949 }
21950 }
21960 {
21963 ;
21964 else
21965 {
21967 {
21970 {
21973 }
21974 }
21976 }
21977 }
21981 {
21984 {
21987 }
21988 }
21991 {
21998 else
22002 {
22007 }
22010 }
22013 }
22015 /* Explicitly instantiate DECL. */
22017 void
22019 {
22024 /* An error occurred, for which grokdeclarator has already issued
22025 an appropriate message. */
22028 {
22031 }
22037 {
22038 /* There is an asymmetry here in the way VAR_DECLs and
22039 FUNCTION_DECLs are handled by grokdeclarator. In the case of
22040 the latter, the DECL we get back will be marked as a
22041 template instantiation, and the appropriate
22042 DECL_TEMPLATE_INFO will be set up. This does not happen for
22043 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
22044 should handle VAR_DECLs as it currently handles
22045 FUNCTION_DECLs. */
22047 {
22050 }
22053 {
22056 }
22058 {
22063 }
22064 }
22066 {
22069 }
22070 else
22073 /* Check for various error cases. Note that if the explicit
22074 instantiation is valid the RESULT will currently be marked as an
22075 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
22076 until we get here. */
22079 {
22080 /* DR 259 [temp.spec].
22082 Both an explicit instantiation and a declaration of an explicit
22083 specialization shall not appear in a program unless the explicit
22084 instantiation follows a declaration of the explicit specialization.
22086 For a given set of template parameters, if an explicit
22087 instantiation of a template appears after a declaration of an
22088 explicit specialization for that template, the explicit
22089 instantiation has no effect. */
22091 }
22093 {
22094 /* [temp.spec]
22096 No program shall explicitly instantiate any template more
22097 than once.
22099 We check DECL_NOT_REALLY_EXTERN so as not to complain when
22100 the first instantiation was `extern' and the second is not,
22101 and EXTERN_P for the opposite case. */
22104 /* If an "extern" explicit instantiation follows an ordinary
22105 explicit instantiation, the template is instantiated. */
22108 }
22110 {
22113 }
22115 {
22118 }
22121 ;
22123 {
22126 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
22129 }
22130 else
22138 }
22140 static void
22142 {
22148 {
22151 }
22152 }
22154 /* Called from do_type_instantiation through binding_table_foreach to
22155 do recursive instantiation for the type bound in ENTRY. */
22156 static void
22158 {
22164 }
22166 /* Perform an explicit instantiation of template class T. STORAGE, if
22167 non-null, is the RID for extern, inline or static. COMPLAIN is
22168 nonzero if this is called from the parser, zero if called recursively,
22169 since the standard is unclear (as detailed below). */
22171 void
22173 {
22183 {
22184 tree tmpl =
22188 else
22191 }
22196 {
22199 t);
22201 }
22204 {
22206 {
22208 {
22211 "ISO C++ 1998 forbids the use of %<extern%> on "
22213 }
22214 else
22216 "ISO C++ forbids the use of %qE"
22218 }
22226 else
22227 {
22229 storage);
22231 }
22232 }
22235 {
22236 /* DR 259 [temp.spec].
22238 Both an explicit instantiation and a declaration of an explicit
22239 specialization shall not appear in a program unless the explicit
22240 instantiation follows a declaration of the explicit specialization.
22242 For a given set of template parameters, if an explicit
22243 instantiation of a template appears after a declaration of an
22244 explicit specialization for that template, the explicit
22245 instantiation has no effect. */
22247 }
22249 {
22250 /* [temp.spec]
22252 No program shall explicitly instantiate any template more
22253 than once.
22255 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
22256 instantiation was `extern'. If EXTERN_P then the second is.
22257 These cases are OK. */
22264 /* If we've already instantiated the template, just return now. */
22267 }
22275 /* In contrast to implicit instantiation, where only the
22276 declarations, and not the definitions, of members are
22277 instantiated, we have here:
22279 [temp.explicit]
22281 The explicit instantiation of a class template specialization
22282 implies the instantiation of all of its members not
22283 previously explicitly specialized in the translation unit
22284 containing the explicit instantiation.
22286 Of course, we can't instantiate member template classes, since we
22287 don't have any arguments for them. Note that the standard is
22288 unclear on whether the instantiation of the members are
22289 *explicit* instantiations or not. However, the most natural
22290 interpretation is that it should be an explicit
22291 instantiation. */
22295 && !static_p
22298 {
22303 }
22308 }
22310 /* Given a function DECL, which is a specialization of TMPL, modify
22311 DECL to be a re-instantiation of TMPL with the same template
22312 arguments. TMPL should be the template into which tsubst'ing
22313 should occur for DECL, not the most general template.
22315 One reason for doing this is a scenario like this:
22317 template <class T>
22318 void f(const T&, int i);
22320 void g() { f(3, 7); }
22322 template <class T>
22323 void f(const T& t, const int i) { }
22325 Note that when the template is first instantiated, with
22326 instantiate_template, the resulting DECL will have no name for the
22327 first parameter, and the wrong type for the second. So, when we go
22328 to instantiate the DECL, we regenerate it. */
22330 static void
22332 {
22333 /* The arguments used to instantiate DECL, from the most general
22334 template. */
22335 tree code_pattern;
22339 /* Make sure that we can see identifiers, and compute access
22340 correctly. */
22344 {
22345 tree decl_parm;
22346 tree pattern_parm;
22347 tree specs;
22361 specs);
22363 /* Merge parameter declarations. */
22366 pattern_parm
22370 {
22371 tree parm_type;
22372 tree attributes;
22377 NULL_TREE);
22383 {
22386 }
22389 }
22390 /* Merge any parameters that match with the function parameter
22391 pack. */
22393 {
22395 tree expanded_types;
22396 /* Expand the TYPE_PACK_EXPANSION that provides the types for
22397 the parameters in this function parameter pack. */
22402 {
22403 tree parm_type;
22404 tree attributes;
22407 /* Rename the parameter to include the index. */
22416 {
22419 }
22421 }
22422 }
22423 /* Merge additional specifiers from the CODE_PATTERN. */
22427 }
22429 {
22437 }
22438 else
22442 }
22444 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
22445 substituted to get DECL. */
22447 tree
22449 {
22452 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
22453 for the instantiation. This is not always the most general
22454 template. Consider, for example:
22456 template <class T>
22457 struct S { template <class U> void f();
22458 template <> void f<int>(); };
22460 and an instantiation of S<double>::f<int>. We want TD to be the
22461 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
22463 more general template. */
22465 /* We must also deal with friend templates. Given:
22467 template <class T> struct S {
22468 template <class U> friend void f() {};
22469 };
22471 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
22472 so far as the language is concerned, but that's still
22473 where we get the pattern for the instantiation from. On
22474 other hand, if the definition comes outside the class, say:
22476 template <class T> struct S {
22477 template <class U> friend void f();
22478 };
22479 template <class U> friend void f() {}
22481 we don't need to look any further. That's what the check for
22482 DECL_INITIAL is for. */
22486 {
22487 /* The present template, TD, should not be a definition. If it
22488 were a definition, we should be using it! Note that we
22489 cannot restructure the loop to just keep going until we find
22490 a template with a definition, since that might go too far if
22491 a specialization was declared, but not defined. */
22493 /* Fetch the more general template. */
22495 }
22498 }
22500 /* Returns true if we need to instantiate this template instance even if we
22501 know we aren't going to emit it. */
22503 bool
22505 {
22506 /* We always instantiate inline functions so that we can inline them. An
22507 explicit instantiation declaration prohibits implicit instantiation of
22508 non-inline functions. With high levels of optimization, we would
22509 normally inline non-inline functions -- but we're not allowed to do
22510 that for "extern template" functions. Therefore, we check
22511 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
22515 /* And we need to instantiate static data members so that
22516 their initializers are available in integral constant
22517 expressions. */
22520 }
22522 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
22523 instantiate it now, modifying TREE_TYPE (fn). Returns false on
22524 error, true otherwise. */
22526 bool
22528 {
22531 /* Don't instantiate a noexcept-specification from template context. */
22546 {
22552 {
22553 /* If hash_set::add returns true, the element was already there. */
22558 fn);
22560 }
22562 {
22577 }
22578 else
22588 }
22591 {
22594 else
22596 }
22599 }
22601 /* Produce the definition of D, a _DECL generated from a template. If
22602 DEFER_OK is true, then we don't have to actually do the
22603 instantiation now; we just have to do it sometime. Normally it is
22604 an error if this is an explicit instantiation but D is undefined.
22605 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
22606 instantiated class template. */
22608 tree
22610 {
22612 tree gen_args;
22613 tree args;
22614 tree td;
22615 tree code_pattern;
22616 tree spec;
22617 tree gen_tmpl;
22625 /* This function should only be used to instantiate templates for
22626 functions and static member variables. */
22629 /* A concept is never instantiated. */
22632 /* Variables are never deferred; if instantiation is required, they
22633 are instantiated right away. That allows for better code in the
22634 case that an expression refers to the value of the variable --
22635 if the variable has a constant value the referring expression can
22636 take advantage of that fact. */
22640 /* Don't instantiate cloned functions. Instead, instantiate the
22641 functions they cloned. */
22649 /* D has already been instantiated or explicitly specialized, so
22650 there's nothing for us to do here.
22652 It might seem reasonable to check whether or not D is an explicit
22653 instantiation, and, if so, stop here. But when an explicit
22654 instantiation is deferred until the end of the compilation,
22655 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
22656 the instantiation. */
22659 /* Check to see whether we know that this template will be
22660 instantiated in some other file, as with "extern template"
22661 extension. */
22664 /* In general, we do not instantiate such templates. */
22672 /* We should already have the extra args. */
22675 /* And what's in the hash table should match D. */
22679 /* This needs to happen before any tsubsting. */
22685 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
22686 for the instantiation. */
22691 {
22692 /* Look up an explicit specialization, if any. */
22696 {
22699 }
22700 }
22704 /* We should never be trying to instantiate a member of a class
22705 template or partial specialization. */
22710 /* In the case of a friend template whose definition is provided
22711 outside the class, we may have too many arguments. Drop the
22712 ones we don't need. The same is true for specializations. */
22713 args = get_innermost_template_args
22717 {
22723 }
22724 else
22725 {
22730 else
22732 }
22734 /* We may be in the middle of deferred access check. Disable it now. */
22737 /* Unless an explicit instantiation directive has already determined
22738 the linkage of D, remember that a definition is available for
22739 this entity. */
22749 /* If D is a member of an explicitly instantiated class template,
22750 and no definition is available, treat it like an implicit
22751 instantiation. */
22754 {
22755 /* Leave linkage flags alone on instantiations with anonymous
22756 visibility. */
22758 {
22761 }
22763 }
22765 /* Defer all other templates, unless we have been explicitly
22766 forbidden from doing so. */
22768 template. */
22769 ! pattern_defined
22770 /* If it's OK to postpone instantiation, do so. */
22771 || defer_ok
22772 /* If this is a static data member that will be defined
22773 elsewhere, we don't want to instantiate the entire data
22774 member, but we do want to instantiate the initializer so that
22775 we can substitute that elsewhere. */
22777 /* Handle here a deleted function too, avoid generating
22778 its body (c++/61080). */
22780 {
22781 /* The definition of the static data member is now required so
22782 we must substitute the initializer. */
22786 {
22787 tree ns;
22788 tree init;
22797 args,
22800 /* If instantiating the initializer involved instantiating this
22801 again, don't call cp_finish_decl twice. */
22803 {
22804 /* Make sure the initializer is still constant, in case of
22805 circular dependency (template/instantiate6.C). */
22806 const_init
22810 LOOKUP_ONLYCONVERTING);
22811 }
22815 }
22817 /* We restore the source position here because it's used by
22818 add_pending_template. */
22824 /* [temp.explicit]
22826 The definition of a non-exported function template, a
22827 non-exported member function template, or a non-exported
22828 member function or static data member of a class template
22829 shall be present in every translation unit in which it is
22830 explicitly instantiated. */
22834 /* If we're in unevaluated context, we just wanted to get the
22835 constant value; this isn't an odr use, so don't queue
22836 a full instantiation. */
22839 /* ??? Historically, we have instantiated inline functions, even
22840 when marked as "extern template". */
22844 }
22845 /* Tell the repository that D is available in this translation unit
22846 -- and see if it is supposed to be instantiated here. */
22848 {
22849 /* In a PCH file, despite the fact that the repository hasn't
22850 requested instantiation in the PCH it is still possible that
22851 an instantiation will be required in a file that includes the
22852 PCH. */
22855 /* Instantiate inline functions so that the inliner can do its
22856 job, even though we'll not be emitting a copy of this
22857 function. */
22860 }
22863 tree fn_context;
22874 else
22875 {
22879 }
22881 /* Mark D as instantiated so that recursive calls to
22882 instantiate_decl do not try to instantiate it again. */
22885 /* Regenerate the declaration in case the template has been modified
22886 by a subsequent redeclaration. */
22889 /* We already set the file and line above. Reset them now in case
22890 they changed as a result of calling regenerate_decl_from_template. */
22894 {
22895 tree init;
22898 /* Clear out DECL_RTL; whatever was there before may not be right
22899 since we've reset the type of the declaration. */
22903 /* The initializer is placed in DECL_INITIAL by
22904 regenerate_decl_from_template so we don't need to
22905 push/pop_access_scope again here. Pull it out so that
22906 cp_finish_decl can process it. */
22911 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
22912 initializer. That function will defer actual emission until
22913 we have a chance to determine linkage. */
22916 /* Enter the scope of D so that access-checking works correctly. */
22929 }
22933 {
22935 tree tmpl_parm;
22936 tree spec_parm;
22940 /* Save away the current list, in case we are instantiating one
22941 template from within the body of another. */
22944 /* Set up the list of local specializations. */
22947 /* Set up context. */
22951 else
22952 {
22954 {
22955 /* When instantiating a lambda's templated function
22956 operator, we need to push the non-lambda class scope
22957 of the lambda itself so that the nested function
22958 stack is sufficiently correct to deal with this
22959 capture. */
22961 do
22966 }
22968 }
22970 /* Some typedefs referenced from within the template code need to be
22971 access checked at template instantiation time, i.e now. These
22972 types were added to the template at parsing time. Let's get those
22973 and perform the access checks then. */
22975 args);
22977 /* Create substitution entries for the parameters. */
22981 {
22985 }
22987 {
22989 {
22992 }
22993 else
22994 {
22995 /* Register the (value) argument pack as a specialization of
22996 TMPL_PARM, then move on. */
22999 }
23000 }
23003 /* Substitute into the body of the function. */
23007 else
23008 {
23013 /* Set the current input_location to the end of the function
23014 so that finish_function knows where we are. */
23015 input_location
23018 /* Remember if we saw an infinite loop in the template. */
23019 current_function_infinite_loop
23021 }
23023 /* We don't need the local specializations any more. */
23027 /* Finish the function. */
23031 else
23032 {
23035 }
23041 }
23043 /* We're not deferring instantiation any more. */
23048 else
23054 out:
23063 }
23065 /* Run through the list of templates that we wish we could
23066 instantiate, and instantiate any we can. RETRIES is the
23067 number of times we retry pending template instantiation. */
23069 void
23071 {
23075 /* Instantiating templates may trigger vtable generation. This in turn
23076 may require further template instantiations. We place a limit here
23077 to avoid infinite loop. */
23079 {
23083 "template instantiation depth exceeds maximum of %d"
23084 " instantiating %q+D, possibly from virtual table generation"
23088 /* Pretend that we defined it. */
23091 }
23093 do
23094 {
23099 {
23104 {
23106 {
23121 }
23124 }
23125 else
23126 {
23129 {
23130 instantiation
23136 }
23140 }
23143 /* If INSTANTIATION has been instantiated, then we don't
23144 need to consider it again in the future. */
23146 else
23147 {
23150 }
23153 }
23155 }
23159 }
23161 /* Substitute ARGVEC into T, which is a list of initializers for
23162 either base class or a non-static data member. The TREE_PURPOSEs
23163 are DECLs, and the TREE_VALUEs are the initializer values. Used by
23164 instantiate_decl. */
23166 static tree
23168 {
23172 {
23173 tree decl;
23174 tree init;
23180 {
23181 tree expr;
23182 tree arg;
23184 /* Expand the base class expansion type into separate base
23185 classes. */
23187 tf_warning_or_error,
23188 NULL_TREE);
23192 /* We'll be building separate TREE_LISTs of arguments for
23193 each base. */
23199 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
23200 expand each argument in the TREE_VALUE of t. */
23207 /* VOID_TYPE_NODE is used to indicate
23208 value-initialization. */
23209 {
23212 }
23213 else
23214 {
23215 /* Substitute parameter packs into each argument in the
23216 TREE_LIST. */
23219 {
23220 tree expanded_exprs;
23222 /* Expand the argument. */
23224 expanded_exprs
23226 tf_warning_or_error,
23227 NULL_TREE);
23231 /* Prepend each of the expanded expressions to the
23232 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
23234 {
23239 }
23240 }
23243 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
23244 since we built them backwards. */
23246 {
23249 }
23250 }
23251 }
23254 {
23256 {
23260 }
23261 else
23262 {
23263 tree tmp;
23278 /* If we had an initializer but it instantiated to nothing,
23279 value-initialize the object. This will only occur when
23280 the initializer was a pack expansion where the parameter
23281 packs used in that expansion were of length zero. */
23284 }
23287 {
23291 }
23292 }
23293 }
23295 }
23297 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
23299 static void
23301 {
23306 else
23308 }
23310 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
23311 is the instantiation (which should have been created with
23312 start_enum) and ARGS are the template arguments to use. */
23314 static void
23316 {
23317 tree e;
23323 {
23324 tree value;
23325 tree decl;
23328 /* Note that in a template enum, the TREE_VALUE is the
23329 CONST_DECL, not the corresponding INTEGER_CST. */
23334 /* Give this enumeration constant the correct access. */
23337 /* Actually build the enumerator itself. Here we're assuming that
23338 enumerators can't have dependent attributes. */
23341 }
23351 }
23353 /* DECL is a FUNCTION_DECL that is a template specialization. Return
23354 its type -- but without substituting the innermost set of template
23355 arguments. So, innermost set of template parameters will appear in
23356 the type. */
23358 tree
23360 {
23361 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
23363 }
23365 /* Return truthvalue if we're processing a template different from
23366 the last one involved in diagnostics. */
23367 bool
23369 {
23371 }
23373 /* Remember current template involved in diagnostics. */
23374 void
23376 {
23378 }
23382 {
23384 }
23386 /* Return TRUE if current_function_decl is being instantiated, false
23387 otherwise. */
23389 bool
23391 {
23394 }
23396 /* [temp.param] Check that template non-type parm TYPE is of an allowable
23397 type. Return zero for ok, nonzero for disallowed. Issue error and
23398 warning messages under control of COMPLAIN. */
23400 static int
23402 {
23417 /* A bound template template parm could later be instantiated to have a valid
23418 nontype parm type via an alias template. */
23424 {
23427 else
23429 type);
23430 }
23432 }
23434 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
23435 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
23437 static bool
23439 {
23440 tree scope;
23442 /* [temp.dep.type]
23444 A type is dependent if it is:
23446 -- a template parameter. Template template parameters are types
23447 for us (since TYPE_P holds true for them) so we handle
23448 them here. */
23452 /* -- a qualified-id with a nested-name-specifier which contains a
23453 class-name that names a dependent type or whose unqualified-id
23454 names a dependent type. */
23458 /* An alias template specialization can be dependent even if the
23459 resulting type is not. */
23463 /* -- a cv-qualified type where the cv-unqualified type is
23464 dependent.
23465 No code is necessary for this bullet; the code below handles
23466 cv-qualified types, and we don't want to strip aliases with
23467 TYPE_MAIN_VARIANT because of DR 1558. */
23468 /* -- a compound type constructed from any dependent type. */
23478 {
23479 tree arg_type;
23484 arg_type;
23489 {
23490 /* A value-dependent noexcept-specifier makes the type dependent. */
23495 }
23497 }
23498 /* -- an array type constructed from any dependent type or whose
23499 size is specified by a constant expression that is
23500 value-dependent.
23502 We checked for type- and value-dependence of the bounds in
23503 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
23505 {
23510 }
23512 /* -- a template-id in which either the template name is a template
23513 parameter ... */
23516 /* ... or any of the template arguments is a dependent type or
23517 an expression that is type-dependent or value-dependent. */
23519 && (any_dependent_template_arguments_p
23523 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
23524 dependent; if the argument of the `typeof' expression is not
23525 type-dependent, then it should already been have resolved. */
23531 /* A template argument pack is dependent if any of its packed
23532 arguments are. */
23534 {
23540 }
23542 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
23543 be template parameters. */
23550 /* The standard does not specifically mention types that are local
23551 to template functions or local classes, but they should be
23552 considered dependent too. For example:
23554 template <int I> void f() {
23555 enum E { a = I };
23556 S<sizeof (E)> s;
23557 }
23559 The size of `E' cannot be known until the value of `I' has been
23560 determined. Therefore, `E' must be considered dependent. */
23564 /* Don't use type_dependent_expression_p here, as it can lead
23565 to infinite recursion trying to determine whether a lambda
23566 nested in a lambda is dependent (c++/47687). */
23570 && (any_dependent_template_arguments_p
23574 /* Other types are non-dependent. */
23576 }
23578 /* Returns TRUE if TYPE is dependent, in the sense of
23579 [temp.dep.type]. Note that a NULL type is considered dependent. */
23581 bool
23583 {
23584 /* If there are no template parameters in scope, then there can't be
23585 any dependent types. */
23587 {
23588 /* If we are not processing a template, then nobody should be
23589 providing us with a dependent type. */
23593 }
23595 /* If the type is NULL, we have not computed a type for the entity
23596 in question; in that case, the type is dependent. */
23600 /* Erroneous types can be considered non-dependent. */
23604 /* Getting here with global_type_node means we improperly called this
23605 function on the TREE_TYPE of an IDENTIFIER_NODE. */
23608 /* If we have not already computed the appropriate value for TYPE,
23609 do so now. */
23611 {
23614 }
23617 }
23619 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
23620 lookup. In other words, a dependent type that is not the current
23621 instantiation. */
23623 bool
23625 {
23628 }
23630 /* T is a SCOPE_REF; return whether we need to consider it
23631 instantiation-dependent so that we can check access at instantiation
23632 time even though we know which member it resolves to. */
23634 static bool
23636 {
23642 else
23644 }
23646 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
23647 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
23648 expression. */
23650 /* Note that this predicate is not appropriate for general expressions;
23651 only constant expressions (that satisfy potential_constant_expression)
23652 can be tested for value dependence. */
23654 bool
23656 {
23660 /* A name declared with a dependent type. */
23665 {
23667 /* A dependent member function of the current instantiation. */
23671 /* A dependent member function of the current instantiation. */
23678 /* A name that has not been looked up -- must be dependent. */
23682 /* A non-type template parm. */
23686 /* A non-type template parm. */
23692 /* A constant with literal type and is initialized
23693 with an expression that is value-dependent.
23695 Note that a non-dependent parenthesized initializer will have
23696 already been replaced with its constant value, so if we see
23697 a TREE_LIST it must be dependent. */
23701 /* cp_finish_decl doesn't fold reference initializers. */
23707 {
23711 }
23719 /* These expressions are value-dependent if the type to which
23720 the cast occurs is dependent or the expression being casted
23721 is value-dependent. */
23722 {
23728 /* A functional cast has a list of operands. */
23731 {
23732 /* If there are no operands, it must be an expression such
23733 as "int()". This should not happen for aggregate types
23734 because it would form non-constant expressions. */
23739 }
23745 }
23750 /* FALLTHRU */
23753 /* A `sizeof' expression is value-dependent if the operand is
23754 type-dependent or is a pack expansion. */
23763 /* An 'encode' expression is value-dependent if the operand is
23764 type-dependent. */
23773 /* All instantiation-dependent expressions should also be considered
23774 value-dependent. */
23782 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
23783 is value-dependent. */
23784 {
23793 }
23796 {
23800 }
23811 {
23815 }
23818 /* Treat all requires-expressions as value-dependent so
23819 we don't try to fold them. */
23826 {
23833 {
23835 /* In a call to a constexpr member function, look through the
23836 implicit ADDR_EXPR on the object argument so that it doesn't
23837 cause the call to be considered value-dependent. We also
23838 look through it in potential_constant_expression. */
23845 }
23847 }
23850 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
23851 type-dependent. */
23856 {
23858 tree val;
23865 }
23868 /* Treat a GNU statement expression as dependent to avoid crashing
23869 under instantiate_non_dependent_expr; it can't be constant. */
23873 /* A constant expression is value-dependent if any subexpression is
23874 value-dependent. */
23876 {
23883 {
23887 {
23890 /* In some cases, some of the operands may be missing.
23891 (For example, in the case of PREDECREMENT_EXPR, the
23892 amount to increment by may be missing.) That doesn't
23893 make the expression dependent. */
23896 }
23897 }
23901 }
23903 }
23905 /* The expression is not value-dependent. */
23907 }
23909 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
23910 [temp.dep.expr]. Note that an expression with no type is
23911 considered dependent. Other parts of the compiler arrange for an
23912 expression with type-dependent subexpressions to have no type, so
23913 this function doesn't have to be fully recursive. */
23915 bool
23917 {
23924 /* An unresolved name is always dependent. */
23930 /* A fold expression is type-dependent. */
23937 /* Some expression forms are never type-dependent. */
23951 /* The types of these expressions depends only on the type to which
23952 the cast occurs. */
23961 /* The types of these expressions depends only on the type created
23962 by the expression. */
23965 {
23966 /* For NEW_EXPR tree nodes created inside a template, either
23967 the object type itself or a TREE_LIST may appear as the
23968 operand 1. */
23971 /* This is an array type. We need to check array dimensions
23972 as well. */
23974 || value_dependent_expression_p
23976 else
23978 }
23981 {
23985 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
23986 contains an identifier associated by name lookup with one or more
23987 declarations declared with a dependent type, or...a
23988 nested-name-specifier or qualified-id that names a member of an
23989 unknown specialization. */
23992 }
24002 {
24003 tree elt;
24007 {
24010 }
24012 }
24014 /* A static data member of the current instantiation with incomplete
24015 array type is type-dependent, as the definition and specializations
24016 can have different bounds. */
24023 /* An array of unknown bound depending on a variadic parameter, eg:
24025 template<typename... Args>
24026 void foo (Args... args)
24027 {
24028 int arr[] = { args... };
24029 }
24031 template<int... vals>
24032 void bar ()
24033 {
24034 int arr[] = { vals... };
24035 }
24037 If the array has no length and has an initializer, it must be that
24038 we couldn't determine its length in cp_complete_array_type because
24039 it is dependent. */
24047 /* A function or variable template-id is type-dependent if it has any
24048 dependent template arguments. */
24052 {
24053 /* Consider the innermost template arguments, since those are the ones
24054 that come from the template-id; the template arguments for the
24055 enclosing class do not make it type-dependent unless they are used in
24056 the type of the decl. */
24058 && (any_dependent_template_arguments_p
24062 /* Otherwise, if the decl isn't from a dependent scope, it can't be
24063 type-dependent. Checking this is important for functions with auto
24064 return type, which looks like a dependent type. */
24071 {
24075 }
24076 }
24078 /* Always dependent, on the number of arguments if nothing else. */
24083 {
24088 {
24094 }
24095 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
24100 {
24105 }
24108 {
24115 }
24125 }
24129 /* Dependent type attributes might not have made it from the decl to
24130 the type yet. */
24136 }
24138 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
24139 type-dependent if the expression refers to a member of the current
24140 instantiation and the type of the referenced member is dependent, or the
24141 class member access expression refers to a member of an unknown
24142 specialization.
24144 This function returns true if the OBJECT in such a class member access
24145 expression is of an unknown specialization. */
24147 bool
24149 {
24150 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
24151 dependent. */
24156 }
24158 /* walk_tree callback function for instantiation_dependent_expression_p,
24159 below. Returns non-zero if a dependent subexpression is found. */
24161 static tree
24164 {
24166 {
24167 /* We don't have to worry about decltype currently because decltype
24168 of an instantiation-dependent expr is a dependent type. This
24169 might change depending on the resolution of DR 1172. */
24172 }
24175 {
24176 /* Don't treat an argument list as dependent just because it has no
24177 TREE_TYPE. */
24185 /* Handle expressions with type operands. */
24190 {
24195 {
24198 else
24199 {
24202 }
24203 }
24205 }
24209 /* In a template, finish_class_member_access_expr creates a
24210 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
24211 type-dependent, so that we can check access control at
24212 instantiation time (PR 42277). See also Core issue 1273. */
24219 else
24222 /* Treat statement-expressions as dependent. */
24226 /* Treat requires-expressions as dependent. */
24231 /* Treat calls to function concepts as dependent. */
24237 /* And variable concepts. */
24244 }
24248 else
24250 }
24252 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
24253 sense defined by the ABI:
24255 "An expression is instantiation-dependent if it is type-dependent
24256 or value-dependent, or it has a subexpression that is type-dependent
24257 or value-dependent."
24259 Except don't actually check value-dependence for unevaluated expressions,
24260 because in sizeof(i) we don't care about the value of i. Checking
24261 type-dependence will in turn check value-dependence of array bounds/template
24262 arguments as needed. */
24264 bool
24266 {
24267 tree result;
24278 }
24280 /* As above, but also check value-dependence of the expression as a whole. */
24282 bool
24284 {
24287 }
24289 /* Like type_dependent_expression_p, but it also works while not processing
24290 a template definition, i.e. during substitution or mangling. */
24292 bool
24294 {
24300 }
24302 /* Returns TRUE if ARGS contains a type-dependent expression. */
24304 bool
24306 {
24308 tree arg;
24311 {
24314 }
24316 }
24318 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24319 expressions) contains any type-dependent expressions. */
24321 bool
24323 {
24329 }
24331 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24332 expressions) contains any value-dependent expressions. */
24334 bool
24336 {
24342 }
24344 /* Returns TRUE if the ARG (a template argument) is dependent. */
24346 bool
24348 {
24352 /* Assume a template argument that was wrongly written by the user
24353 is dependent. This is consistent with what
24354 any_dependent_template_arguments_p [that calls this function]
24355 does. */
24365 {
24368 /* A member template of a dependent class is not necessarily
24369 type-dependent, but it is a dependent template argument because it
24370 will be a member of an unknown specialization to that template. */
24373 }
24375 {
24379 {
24382 }
24385 }
24388 else
24391 }
24393 /* Returns true if ARGS (a collection of template arguments) contains
24394 any types that require structural equality testing. */
24396 bool
24398 {
24408 {
24411 {
24417 {
24418 /* Look inside the argument pack. */
24421 }
24424 {
24437 }
24438 }
24439 }
24442 }
24444 /* Returns true if ARGS (a collection of template arguments) contains
24445 any dependent arguments. */
24447 bool
24449 {
24459 {
24464 }
24467 }
24469 /* Returns TRUE if the template TMPL is type-dependent. */
24471 bool
24473 {
24475 {
24480 }
24482 /* Template template parameters are dependent. */
24486 /* So are names that have not been looked up. */
24490 }
24492 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
24494 bool
24496 {
24499 }
24501 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
24502 are dependent. */
24504 bool
24506 {
24513 {
24535 {
24539 }
24543 {
24547 {
24552 }
24553 }
24554 }
24557 }
24559 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
24560 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
24561 no such TYPE can be found. Note that this function peers inside
24562 uninstantiated templates and therefore should be used only in
24563 extremely limited situations. ONLY_CURRENT_P restricts this
24564 peering to the currently open classes hierarchy (which is required
24565 when comparing types). */
24567 tree
24569 {
24570 tree scope;
24571 tree name;
24572 tree decl;
24574 tree pushed_scope;
24575 tree result;
24580 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
24581 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
24582 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
24583 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
24584 identifier of the TYPENAME_TYPE anymore.
24585 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
24586 TYPENAME_TYPE instead, we avoid messing up with a possible
24587 typedef variant case. */
24590 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
24591 it first before we can figure out what NAME refers to. */
24593 {
24595 /* Given a class template A with a dependent base with nested type C,
24596 typedef typename A::C::C C will land us here, as trying to resolve
24597 the initial A::C leads to the local C typedef, which leads back to
24598 A::C::C. So we break the recursion now. */
24600 else
24602 }
24603 /* If we don't know what SCOPE refers to, then we cannot resolve the
24604 TYPENAME_TYPE. */
24607 /* If this is a typedef, we don't want to look inside (c++/11987). */
24610 /* If SCOPE isn't the template itself, it will not have a valid
24611 TYPE_FIELDS list. */
24613 /* scope is either the template itself or a compatible instantiation
24614 like X<T>, so look up the name in the original template. */
24616 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
24618 /* If scope has no fields, it can't be a current instantiation. Check this
24619 before currently_open_class to avoid infinite recursion (71515). */
24622 /* If the SCOPE is not the current instantiation, there's no reason
24623 to look inside it. */
24626 /* Enter the SCOPE so that name lookup will be resolved as if we
24627 were in the class definition. In particular, SCOPE will no
24628 longer be considered a dependent type. */
24630 /* Look up the declaration. */
24632 tf_warning_or_error);
24636 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
24637 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
24643 {
24647 }
24650 {
24651 /* Obtain the template and the arguments. */
24654 {
24655 /* We get here with a plain identifier because a previous tentative
24656 parse of the nested-name-specifier as part of a ptr-operator saw
24657 ::template X<A>. The use of ::template is necessary in a
24658 ptr-operator, but wrong in a declarator-id.
24660 [temp.names]: In a qualified-id of a declarator-id, the keyword
24661 template shall not appear at the top level. */
24665 }
24667 /* Instantiate the template. */
24673 }
24675 /* Leave the SCOPE. */
24679 /* If we failed to resolve it, return the original typename. */
24683 /* If lookup found a typename type, resolve that too. */
24685 {
24686 /* Ill-formed programs can cause infinite recursion here, so we
24687 must catch that. */
24691 }
24693 /* Qualify the resulting type. */
24699 }
24701 /* EXPR is an expression which is not type-dependent. Return a proxy
24702 for EXPR that can be used to compute the types of larger
24703 expressions containing EXPR. */
24705 tree
24707 {
24708 tree inner_expr;
24710 /* When checking, try to get a constant value for all non-dependent
24711 expressions in order to expose bugs in *_dependent_expression_p
24712 and constexpr. This can affect code generation, see PR70704, so
24713 only do this for -fchecking=2. */
24716 /* Don't do this during nsdmi parsing as it can lead to
24717 unexpected recursive instantiations. */
24719 /* Don't do this during concept expansion either and for
24720 the same reason. */
24724 /* Preserve OVERLOADs; the functions must be available to resolve
24725 types. */
24736 /* There is no need to return a proxy for a variable. */
24739 /* Preserve string constants; conversions from string constants to
24740 "char *" are allowed, even though normally a "const char *"
24741 cannot be used to initialize a "char *". */
24744 /* Preserve void and arithmetic constants, as an optimization -- there is no
24745 reason to create a new node. */
24750 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
24751 There is at least one place where we want to know that a
24752 particular expression is a throw-expression: when checking a ?:
24753 expression, there are special rules if the second or third
24754 argument is a throw-expression. */
24758 /* Don't wrap an initializer list, we need to be able to look inside. */
24762 /* Don't wrap a dummy object, we need to be able to test for it. */
24781 /* If the type is unknown, it can't really be non-dependent */
24784 /* Otherwise, build a NON_DEPENDENT_EXPR. */
24786 }
24788 /* ARGS is a vector of expressions as arguments to a function call.
24789 Replace the arguments with equivalent non-dependent expressions.
24790 This modifies ARGS in place. */
24792 void
24794 {
24796 tree arg;
24799 {
24803 }
24804 }
24806 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
24807 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
24808 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
24810 static tree
24812 {
24826 }
24828 tree
24830 {
24832 }
24834 tree
24836 {
24838 }
24840 /* Return a C++17 deduction placeholder for class template TMPL. */
24842 tree
24844 {
24848 }
24850 /* True iff T is a C++17 class template deduction placeholder. */
24852 bool
24854 {
24856 }
24858 /* Make a "constrained auto" type-specifier. This is an
24859 auto type with constraints that must be associated after
24860 deduction. The constraint is formed from the given
24861 CONC and its optional sequence of arguments, which are
24862 non-null if written as partial-concept-id. */
24864 tree
24866 {
24869 /* Build the constraint. */
24877 /* Our canonical type depends on the constraint. */
24880 /* Attach the constraint to the type declaration. */
24883 }
24885 /* Given type ARG, return std::initializer_list<ARG>. */
24887 static tree
24889 {
24893 {
24897 "deducing from brace-enclosed initializer list"
24901 }
24907 }
24909 /* Replace auto in TYPE with std::initializer_list<auto>. */
24911 static tree
24913 {
24920 }
24922 /* Hash traits for hashing possibly constrained 'auto'
24923 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
24926 {
24929 };
24931 /* Hash the 'auto' T. */
24933 inline hashval_t
24935 {
24937 /* Matching constrained-type-specifiers denote the same template
24938 parameter, so hash the constraint. */
24940 else
24941 /* But unconstrained autos are all separate, so just hash the pointer. */
24943 }
24945 /* Compare two 'auto's. */
24949 {
24956 /* Two unconstrained autos are distinct. */
24961 }
24963 /* for_each_template_parm callback for extract_autos: if t is a (possibly
24964 constrained) auto, add it to the vector. */
24966 static int
24968 {
24971 {
24972 /* All the autos were built with index 0; fix that up now. */
24976 /* If this is a repeated constrained-type-specifier, use the index we
24977 chose before. */
24979 else
24980 {
24981 /* Otherwise this is new, so use the current count. */
24984 }
24986 }
24988 /* Always keep walking. */
24990 }
24992 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
24993 says they can appear anywhere in the type. */
24995 static tree
24997 {
25006 {
25011 }
25014 }
25016 /* The stem for deduction guide names. */
25019 /* Return the name for a deduction guide for class template TMPL. */
25021 tree
25023 {
25034 }
25036 /* True if NAME is the name of a deduction guide. */
25038 bool
25040 {
25044 }
25046 /* True if FN is a deduction guide. */
25048 bool
25050 {
25055 }
25057 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
25059 bool
25061 {
25068 }
25070 /* True if FN is a guide generated from a constructor template. */
25072 bool
25074 {
25079 {
25082 }
25084 }
25086 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
25087 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
25088 template parameter types. Note that the handling of template template
25089 parameters relies on current_template_parms being set appropriately for the
25090 new template. */
25092 static tree
25095 {
25098 tree newtype;
25101 {
25108 }
25109 else
25113 tree newdecl
25118 tree newidx;
25121 {
25131 {
25136 // First create a copy (ttargs) of tsubst_args with an
25137 // additional level for the template template parameter's own
25138 // template parameters (ttparms).
25139 tree ttparms = (INNERMOST_TEMPLATE_PARMS
25147 // Substitute ttargs into ttparms to fix references to
25148 // other template parameters.
25150 complain);
25151 // Now substitute again with args based on tparms, to reduce
25152 // the level of the ttparms.
25155 complain);
25156 // Finally, tack the adjusted parms onto tparms.
25158 current_template_parms);
25160 }
25161 }
25162 else
25163 {
25165 tree newconst
25177 }
25180 }
25182 /* Returns a C++17 class deduction guide template based on the constructor
25183 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
25184 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
25186 static tree
25188 {
25192 location_t loc;
25195 {
25199 {
25202 }
25203 else
25213 }
25214 else
25215 {
25218 tree fn_tmpl
25228 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
25229 fully specialized args for the enclosing class. Strip those off, as
25230 the deduction guide won't have those template parameters. */
25233 /* Discard the 'this' parameter. */
25241 {
25244 /* For a member template constructor, we need to flatten the two
25245 template parameter lists into one, and then adjust the function
25246 signature accordingly. This gets...complicated. */
25249 /* For a member template we should have two levels of parms/args, one
25250 for the class and one for the constructor. We stripped
25251 specialized args for further enclosing classes above. */
25255 /* Template args for translating references to the two-level template
25256 parameters into references to the one-level template parameters we
25257 are creating. */
25262 /* Template parms for the constructor template. */
25265 /* Template parms for the class template. */
25269 /* Template parms for the deduction guide start as a copy of the
25270 template parms for the class. We set current_template_parms for
25271 lookup_template_class_1. */
25277 /* Now we need to rewrite the constructor parms to append them to the
25278 class parms. */
25280 {
25295 }
25297 /* Now we have a final set of template parms to substitute into the
25298 function signature. */
25307 }
25309 }
25312 {
25313 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
25317 }
25321 FUNCTION_DECL,
25338 }
25340 /* Deduce template arguments for the class template placeholder PTYPE for
25341 template TMPL based on the initializer INIT, and return the resulting
25342 type. */
25344 static tree
25346 tsubst_flags_t complain)
25347 {
25349 {
25350 /* We should have handled this in the caller. */
25356 }
25367 {
25370 {
25371 /* As an exception, the first phase in 16.3.1.7 (considering the
25372 initializer list as a single argument) is omitted if the
25373 initializer list consists of a single expression of type cv U,
25374 where U is a specialization of C or a class derived from a
25375 specialization of C. */
25386 }
25389 else
25391 }
25392 else
25403 /* Prune explicit deduction guides in copy-initialization context. */
25405 {
25411 {
25412 /* Found a nonconverting guide, prune the candidates. */
25419 }
25420 }
25425 {
25428 }
25432 // FIXME cache artificial deduction guides
25435 {
25440 else
25444 }
25448 /* If this is list-initialization and the class has a list constructor, first
25449 try deducing from the list as a single argument, as [over.match.list]. */
25453 {
25457 }
25459 {
25465 {
25466 /* That didn't work, now try treating the list as a sequence of
25467 arguments. */
25470 }
25471 }
25473 /* Maybe generate an implicit deduction guide. */
25475 {
25479 /* Generate a copy guide. */
25482 /* Generate a default guide. */
25486 {
25489 }
25490 }
25493 {
25495 " of %qT, as it has no non-explicit deduction guides or "
25498 }
25500 {
25504 }
25507 {
25511 }
25514 {
25524 }
25529 }
25531 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25532 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
25534 tree
25536 {
25538 tf_warning_or_error,
25539 adc_unspecified);
25540 }
25542 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25543 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
25544 The CONTEXT determines the context in which auto deduction is performed
25545 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
25546 OUTER_TARGS are used during template argument deduction
25547 (context == adc_unify) to properly substitute the result, and is ignored
25548 in other contexts.
25550 For partial-concept-ids, extra args may be appended to the list of deduced
25551 template arguments prior to determining constraint satisfaction. */
25553 tree
25557 {
25558 tree targs;
25565 /* Defining a subset of type-dependent expressions that we can deduce
25566 from ahead of time isn't worth the trouble. */
25570 /* C++17 class template argument deduction. */
25574 /* Nothing we can do with this, even in deduction context. */
25577 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
25578 with either a new invented type template parameter U or, if the
25579 initializer is a braced-init-list (8.5.4), with
25580 std::initializer_list<U>. */
25582 {
25587 else
25588 {
25590 {
25594 "for deduction to %<std::initializer_list%>, use copy-"
25596 }
25598 }
25599 }
25610 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
25611 and initializer has array type, deduce cv-qualified array type. */
25613 complain);
25615 {
25624 {
25628 }
25629 }
25630 else
25631 {
25633 tree tparms;
25637 else
25638 {
25642 }
25649 {
25651 /* Try again at instantiation time. */
25655 /* If type is error_mark_node a diagnostic must have been
25656 emitted by now. Also, having a mention to '<type error>'
25657 in the diagnostic is not really useful to the user. */
25658 {
25662 else
25667 }
25669 }
25670 }
25672 /* Check any placeholder constraints against the deduced type. */
25675 {
25676 /* Use the deduced type to check the associated constraints. If we
25677 have a partial-concept-id, rebuild the argument list so that
25678 we check using the extra arguments. */
25682 {
25685 }
25686 else
25689 {
25691 {
25693 {
25711 }
25713 }
25715 }
25716 }
25722 }
25724 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
25725 result. */
25727 tree
25729 {
25731 {
25737 /* In an abbreviated function template we didn't know we were dealing
25738 with a function template when we saw the auto return type, so update
25739 it to have the correct level. */
25741 }
25743 }
25745 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
25746 'decltype(auto)' or a deduced class template. */
25748 bool
25750 {
25756 else
25758 }
25760 /* for_each_template_parm callback for type_uses_auto. */
25762 int
25764 {
25766 }
25768 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
25769 a use of `auto'. Returns NULL_TREE otherwise. */
25771 tree
25773 {
25777 {
25778 /* The Concepts TS allows multiple autos in one type-specifier; just
25779 return the first one we find, do_auto_deduction will collect all of
25780 them. */
25784 else
25786 }
25787 else
25789 }
25791 /* For a given template T, return the vector of typedefs referenced
25792 in T for which access check is needed at T instantiation time.
25793 T is either a FUNCTION_DECL or a RECORD_TYPE.
25794 Those typedefs were added to T by the function
25795 append_type_to_template_for_access_check. */
25799 {
25800 tree ti;
25811 {
25816 }
25819 }
25821 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
25822 tied to T. That list of typedefs will be access checked at
25823 T instantiation time.
25824 T is either a FUNCTION_DECL or a RECORD_TYPE.
25825 TYPE_DECL is a TYPE_DECL node representing a typedef.
25826 SCOPE is the scope through which TYPE_DECL is accessed.
25827 LOCATION is the location of the usage point of TYPE_DECL.
25829 This function is a subroutine of
25830 append_type_to_template_for_access_check. */
25832 static void
25834 tree type_decl,
25835 tree scope,
25836 location_t location)
25837 {
25838 qualified_typedef_usage_t typedef_usage;
25839 tree ti;
25846 && type_decl
25860 }
25862 /* Append TYPE_DECL to the template TEMPL.
25863 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
25864 At TEMPL instanciation time, TYPE_DECL will be checked to see
25865 if it can be accessed through SCOPE.
25866 LOCATION is the location of the usage point of TYPE_DECL.
25868 e.g. consider the following code snippet:
25870 class C
25871 {
25872 typedef int myint;
25873 };
25875 template<class U> struct S
25876 {
25877 C::myint mi; // <-- usage point of the typedef C::myint
25878 };
25880 S<char> s;
25882 At S<char> instantiation time, we need to check the access of C::myint
25883 In other words, we need to check the access of the myint typedef through
25884 the C scope. For that purpose, this function will add the myint typedef
25885 and the scope C through which its being accessed to a list of typedefs
25886 tied to the template S. That list will be walked at template instantiation
25887 time and access check performed on each typedefs it contains.
25888 Note that this particular code snippet should yield an error because
25889 myint is private to C. */
25891 void
25893 tree type_decl,
25894 tree scope,
25895 location_t location)
25896 {
25902 /* Make sure we don't append the type to the template twice. */
25909 }
25911 /* Convert the generic type parameters in PARM that match the types given in the
25912 range [START_IDX, END_IDX) from the current_template_parms into generic type
25913 packs. */
25915 tree
25917 {
25928 {
25929 /* Create a distinct parameter pack type from the current parm and add it
25930 to the replacement args to tsubst below into the generic function
25931 parameter. */
25946 }
25952 /* If there are more levels then build up the replacement with the outer
25953 template parms. */
25957 replacement);
25960 }
25962 /* Entries in the decl_constraint hash table. */
25964 {
25965 tree decl;
25966 tree ci;
25967 };
25969 /* Hashing function and equality for constraint entries. */
25971 {
25973 {
25975 }
25978 {
25980 }
25981 };
25983 /* A mapping from declarations to constraint information. Note that
25984 both templates and their underlying declarations are mapped to the
25985 same constraint information.
25987 FIXME: This is defined in pt.c because garbage collection
25988 code is not being generated for constraint.cc. */
25992 /* Returns the template constraints of declaration T. If T is not
25993 constrained, return NULL_TREE. Note that T must be non-null. */
25995 tree
25997 {
26008 else
26010 }
26012 /* Associate the given constraint information CI with the declaration
26013 T. If T is a template, then the constraints are associated with
26014 its underlying declaration. Don't build associations if CI is
26015 NULL_TREE. */
26017 void
26019 {
26031 }
26033 /* Remove the associated constraints of the declaration T. */
26035 void
26037 {
26046 }
26048 /* Memoized satisfaction results for declarations. This
26049 maps the pair (constraint_info, arguments) to the result computed
26050 by constraints_satisfied_p. */
26053 {
26054 tree ci;
26055 tree args;
26056 tree result;
26057 };
26059 /* Hashing function and equality for constraint entries. */
26062 {
26064 {
26067 }
26070 {
26072 }
26073 };
26075 /* Memoized satisfaction results for concept checks. */
26078 {
26079 tree tmpl;
26080 tree args;
26081 tree result;
26082 };
26084 /* Hashing function and equality for constraint entries. */
26087 {
26089 {
26091 }
26094 {
26099 }
26100 };
26105 /* Search for a memoized satisfaction result. Returns one of the
26106 truth value nodes if previously memoized, or NULL_TREE otherwise. */
26108 tree
26110 {
26115 else
26117 }
26119 /* Memoize the result of a satisfication test. Returns the saved result. */
26121 tree
26123 {
26130 }
26132 /* Search for a memoized satisfaction result for a concept. */
26134 tree
26136 {
26141 else
26143 }
26145 /* Memoize the result of a concept check. Returns the saved result. */
26147 tree
26149 {
26156 }
26160 /* Returns a prior concept specialization. This returns the substituted
26161 and normalized constraints defined by the concept. */
26163 tree
26165 {
26170 else
26172 }
26174 /* Save a concept expansion for later. */
26176 tree
26178 {
26185 }
26187 static hashval_t
26189 {
26198 }
26200 /* Compare the constraints of two subsumption entries. The LEFT1 and
26201 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
26202 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
26204 static bool
26206 {
26214 }
26216 /* Key/value pair for learning and memoizing subsumption results. This
26217 associates a pair of check constraints (including arguments) with
26218 a boolean value indicating the result. */
26221 {
26222 tree t1;
26223 tree t2;
26225 };
26227 /* Hashing function and equality for constraint entries. */
26230 {
26232 {
26234 }
26237 {
26242 }
26243 };
26247 /* Search for a previously cached subsumption result. */
26251 {
26256 else
26258 }
26260 /* Save a subsumption result. */
26262 bool
26264 {
26271 }
26273 /* Set up the hash table for constraint association. */
26275 void
26277 {
26286 }
26288 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
26289 0..N-1. */
26291 void
26293 {
26296 integer_type_node,
26297 NULL_TREE),
26301 }
26303 /* Set up the hash tables for template instantiations. */
26305 void
26307 {
26313 }
26315 /* Print stats about the template hash tables for -fstats. */
26317 void
26319 {
26328 }