| blob | ba52f3b57a62dc6970f5c732939ca0dbe5dcba3e |
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 {
85 else
87 }
90 {
93 }
95 /* True if we've recursed into fn_type_unification too many times. */
99 {
100 tree tmpl;
101 tree args;
102 tree spec;
103 };
106 {
109 };
115 /* Contains canonical template parameter types. The vector is indexed by
116 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
117 TREE_LIST, whose TREE_VALUEs contain the canonical template
118 parameters of various types and levels. */
121 #define UNIFY_ALLOW_NONE 0
122 #define UNIFY_ALLOW_MORE_CV_QUAL 1
123 #define UNIFY_ALLOW_LESS_CV_QUAL 2
124 #define UNIFY_ALLOW_DERIVED 4
125 #define UNIFY_ALLOW_INTEGER 8
126 #define UNIFY_ALLOW_OUTER_LEVEL 16
127 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
128 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
131 tbr_incomplete_type,
132 tbr_ambiguous_baseclass,
133 tbr_success
134 };
157 tree);
214 location_t);
225 /* Make the current scope suitable for access checking when we are
226 processing T. T can be FUNCTION_DECL for instantiated function
227 template, VAR_DECL for static member variable, or TYPE_DECL for
228 alias template (needed by instantiate_decl). */
230 static void
232 {
240 else
244 {
245 saved_access_scope = tree_cons
248 }
249 }
251 /* Restore the scope set up by push_access_scope. T is the node we
252 are processing. */
254 static void
256 {
258 {
261 }
265 else
267 }
269 /* Do any processing required when DECL (a member template
270 declaration) is finished. Returns the TEMPLATE_DECL corresponding
271 to DECL, unless it is a specialization, in which case the DECL
272 itself is returned. */
274 tree
276 {
283 {
284 tree type;
292 {
296 }
298 }
302 {
304 {
307 }
308 else
310 }
311 else
315 }
317 /* Create a template info node. */
319 tree
321 {
326 }
328 /* Return the template info node corresponding to T, whatever T is. */
330 tree
332 {
354 }
356 /* Returns the template nesting level of the indicated class TYPE.
358 For example, in:
359 template <class T>
360 struct A
361 {
362 template <class U>
363 struct B {};
364 };
366 A<T>::B<U> has depth two, while A<T> has depth one.
367 Both A<T>::B<int> and A<int>::B<U> have depth one, if
368 they are instantiations, not specializations.
370 This function is guaranteed to return 0 if passed NULL_TREE so
371 that, for example, `template_class_depth (current_class_type)' is
372 always safe. */
374 int
376 {
380 {
391 else
393 }
396 }
398 /* Subroutine of maybe_begin_member_template_processing.
399 Returns true if processing DECL needs us to push template parms. */
401 static bool
403 {
409 }
411 /* Subroutine of maybe_begin_member_template_processing.
412 Push the template parms in PARMS, starting from LEVELS steps into the
413 chain, and ending at the beginning, since template parms are listed
414 innermost first. */
416 static void
418 {
426 current_template_parms
432 NULL);
434 {
443 {
450 /* Push the CONST_DECL. */
456 }
457 }
458 }
460 /* Restore the template parameter context for a member template, a
461 friend template defined in a class definition, or a non-template
462 member of template class. */
464 void
466 {
467 tree parms;
472 {
475 /* Disregard full specializations (c++/60999). */
478 }
481 {
486 {
489 }
492 }
494 /* Remember how many levels of template parameters we pushed so that
495 we can pop them later. */
497 }
499 /* Undo the effects of maybe_begin_member_template_processing. */
501 void
503 {
512 {
516 }
517 }
519 /* Return a new template argument vector which contains all of ARGS,
520 but has as its innermost set of arguments the EXTRA_ARGS. */
522 static tree
524 {
525 tree new_args;
543 }
545 /* Like add_to_template_args, but only the outermost ARGS are added to
546 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
547 (EXTRA_ARGS) levels are added. This function is used to combine
548 the template arguments from a partial instantiation with the
549 template arguments used to attain the full instantiation from the
550 partial instantiation. */
552 static tree
554 {
555 tree new_args;
557 /* If there are more levels of EXTRA_ARGS than there are ARGS,
558 something very fishy is going on. */
561 /* If *all* the new arguments will be the EXTRA_ARGS, just return
562 them. */
566 /* For the moment, we make ARGS look like it contains fewer levels. */
571 /* Now, we restore ARGS to its full dimensions. */
575 }
577 /* Return the N levels of innermost template arguments from the ARGS. */
579 tree
581 {
582 tree new_args;
588 /* If N is 1, just return the innermost set of template arguments. */
592 /* If we're not removing anything, just return the arguments we were
593 given. */
599 /* Make a new set of arguments, not containing the outer arguments. */
606 }
608 /* The inverse of get_innermost_template_args: Return all but the innermost
609 EXTRA_LEVELS levels of template arguments from the ARGS. */
611 static tree
613 {
614 tree new_args;
620 /* If N is 1, just return the outermost set of template arguments. */
624 /* If we're not removing anything, just return the arguments we were
625 given. */
630 /* Make a new set of arguments, not containing the inner arguments. */
637 }
639 /* We've got a template header coming up; push to a new level for storing
640 the parms. */
642 void
644 {
645 /* We use a non-tag-transparent scope here, which causes pushtag to
646 put tags in this scope, rather than in the enclosing class or
647 namespace scope. This is the right thing, since we want
648 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
649 global template class, push_template_decl handles putting the
650 TEMPLATE_DECL into top-level scope. For a nested template class,
651 e.g.:
653 template <class T> struct S1 {
654 template <class T> struct S2 {};
655 };
657 pushtag contains special code to insert the TEMPLATE_DECL for S2
658 at the right scope. */
664 /* Add a dummy parameter level while we process the parameter list. */
665 current_template_parms
668 current_template_parms);
669 }
671 /* This routine is called when a specialization is declared. If it is
672 invalid to declare a specialization here, an error is reported and
673 false is returned, otherwise this routine will return true. */
675 static bool
677 {
680 /* [temp.expl.spec]
682 An explicit specialization shall be declared in the namespace of
683 which the template is a member, or, for member templates, in the
684 namespace of which the enclosing class or enclosing class
685 template is a member. An explicit specialization of a member
686 function, member class or static data member of a class template
687 shall be declared in the namespace of which the class template
688 is a member. */
690 {
693 }
695 /* [temp.expl.spec]
697 In an explicit specialization declaration for a member of a class
698 template or a member template that appears in namespace scope,
699 the member template and some of its enclosing class templates may
700 remain unspecialized, except that the declaration shall not
701 explicitly specialize a class member template if its enclosing
702 class templates are not explicitly specialized as well. */
704 {
707 }
710 }
712 /* We've just seen template <>. */
714 bool
716 {
720 }
722 /* Called at then end of processing a declaration preceded by
723 template<>. */
725 void
727 {
730 }
732 /* Any template <>'s that we have seen thus far are not referring to a
733 function specialization. */
735 void
737 {
740 }
742 /* We've just seen a template header. If SPECIALIZATION is nonzero,
743 it was of the form template <>. */
745 static void
747 {
749 template_header_count++;
750 }
752 /* We're beginning an explicit instantiation. */
754 void
756 {
759 }
762 void
764 {
767 }
769 /* An explicit specialization or partial specialization of TMPL is being
770 declared. Check that the namespace in which the specialization is
771 occurring is permissible. Returns false iff it is invalid to
772 specialize TMPL in the current namespace. */
774 static bool
776 {
779 /* [tmpl.expl.spec]
781 An explicit specialization shall be declared in a namespace enclosing the
782 specialized template. An explicit specialization whose declarator-id is
783 not qualified shall be declared in the nearest enclosing namespace of the
784 template, or, if the namespace is inline (7.3.1), any namespace from its
785 enclosing namespace set. */
788 {
791 }
794 /* Same or enclosing namespace. */
796 else
797 {
803 }
804 }
806 /* SPEC is an explicit instantiation. Check that it is valid to
807 perform this explicit instantiation in the current namespace. */
809 static void
811 {
812 tree ns;
814 /* DR 275: An explicit instantiation shall appear in an enclosing
815 namespace of its template. */
821 }
823 // Returns the type of a template specialization only if that
824 // specialization needs to be defined. Otherwise (e.g., if the type has
825 // already been defined), the function returns NULL_TREE.
826 static tree
828 {
829 // An implicit instantiation of an incomplete type implies
830 // the definition of a new class template.
831 //
832 // template<typename T>
833 // struct S;
834 //
835 // template<typename T>
836 // struct S<T*>;
837 //
838 // Here, S<T*> is an implicit instantiation of S whose type
839 // is incomplete.
843 // It can also be the case that TYPE is a completed specialization.
844 // Continuing the previous example, suppose we also declare:
845 //
846 // template<typename T>
847 // requires Integral<T>
848 // struct S<T*>;
849 //
850 // Here, S<T*> refers to the specialization S<T*> defined
851 // above. However, we need to differentiate definitions because
852 // we intend to define a new partial specialization. In this case,
853 // we rely on the fact that the constraints are different for
854 // this declaration than that above.
855 //
856 // Note that we also get here for injected class names and
857 // late-parsed template definitions. We must ensure that we
858 // do not create new type declarations for those cases.
860 {
864 // If there are no template parameters, this cannot be a new
865 // partial template specializtion?
869 // The injected-class-name is not a new partial specialization.
873 // If the constraints are not the same as those of the primary
874 // then, we can probably create a new specialization.
878 {
882 }
884 // Also, if there's a pre-existing specialization with matching
885 // constraints, then this also isn't new.
888 {
896 }
898 // Create a new type node (and corresponding type decl)
899 // for the newly declared specialization.
904 /* We only need a separate type node for storing the definition of this
905 partial specialization; uses of S<T*> are unconstrained, so all are
906 equivalent. So keep TYPE_CANONICAL the same. */
909 // Build the corresponding type decl.
915 }
918 }
920 /* The TYPE is being declared. If it is a template type, that means it
921 is a partial specialization. Do appropriate error-checking. */
923 tree
925 {
926 tree context;
931 /* A lambda that appears in specialization context is not itself a
932 specialization. */
937 {
941 }
946 {
952 else
955 }
957 {
958 /* This is for ordinary explicit specialization and partial
959 specialization of a template class such as:
961 template <> class C<int>;
963 or:
965 template <class T> class C<T*>;
967 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
970 {
977 {
982 }
983 }
989 /* Trying to define a specialization either without a template<> header
990 or in an inappropriate place. We've already given an error, so just
991 bail now so we don't actually define the specialization. */
993 }
999 {
1000 /* This is for an explicit specialization of member class
1001 template according to [temp.expl.spec/18]:
1003 template <> template <class U> class C<int>::D;
1005 The context `C<int>' must be an implicit instantiation.
1006 Otherwise this is just a member class template declared
1007 earlier like:
1009 template <> class C<int> { template <class U> class D; };
1010 template <> template <class U> class C<int>::D;
1012 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1013 while in the second case, `C<int>::D' is a primary template
1014 and `C<T>::D' may not exist. */
1018 {
1019 tree t;
1024 {
1029 }
1031 /* Check for invalid specialization after instantiation:
1033 template <> template <> class C<int>::D<int>;
1034 template <> template <class U> class C<int>::D; */
1038 {
1042 {
1043 /* We already have a full specialization of this partial
1044 instantiation, or a full specialization has been
1045 looked up but not instantiated. Reassign it to the
1046 new member specialization template. */
1047 spec_entry elt;
1059 spec_entry **slot
1064 }
1065 else
1066 /* But if we've had an implicit instantiation, that's a
1067 problem ([temp.expl.spec]/6). */
1070 }
1072 /* Mark TYPE as a specialization. And as a result, we only
1073 have one level of template argument for the innermost
1074 class template. */
1079 }
1080 }
1082 {
1083 /* Someday C++0x may allow for enum template specialization. */
1088 else
1089 {
1092 }
1093 }
1096 }
1098 /* Returns nonzero if we can optimize the retrieval of specializations
1099 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1100 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1104 {
1107 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1108 parameter. */
1110 /* The optimized lookup depends on the fact that the
1111 template arguments for the member function template apply
1112 purely to the containing class, which is not true if the
1113 containing class is an explicit or partial
1114 specialization. */
1118 /* It is possible to have a template that is not a member
1119 template and is not a member of a template class:
1121 template <typename T>
1122 struct S { friend A::f(); };
1124 Here, the friend function is a template, but the context does
1125 not have template information. The optimized lookup relies
1126 on having ARGS be the template arguments for both the class
1127 and the function template. */
1129 }
1131 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1132 gone through coerce_template_parms by now. */
1134 static void
1136 {
1139 {
1142 {
1149 /* Allow typedefs on the type of a non-type argument, since a
1151 else
1153 }
1154 }
1156 }
1158 /* Retrieve the specialization (in the sense of [temp.spec] - a
1159 specialization is either an instantiation or an explicit
1160 specialization) of TMPL for the given template ARGS. If there is
1161 no such specialization, return NULL_TREE. The ARGS are a vector of
1162 arguments, or a vector of vectors of arguments, in the case of
1163 templates with more than one level of parameters.
1165 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1166 then we search for a partial specialization matching ARGS. This
1167 parameter is ignored if TMPL is not a class template.
1169 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1170 result is a NONTYPE_ARGUMENT_PACK. */
1172 static tree
1174 {
1184 /* There should be as many levels of arguments as there are
1185 levels of parameters. */
1194 /* Lambda functions in templates aren't instantiated normally, but through
1195 tsubst_lambda_expr. */
1200 {
1201 /* The template arguments actually apply to the containing
1202 class. Find the class specialization with those
1203 arguments. */
1205 tree class_specialization
1210 /* Find the instance of TMPL. */
1213 {
1216 /* using-declarations can add base methods to the method vec,
1217 and we don't want those here. */
1220 }
1222 }
1223 else
1224 {
1226 spec_entry elt;
1235 else
1243 }
1246 }
1248 /* Like retrieve_specialization, but for local declarations. */
1250 tree
1252 {
1258 }
1260 /* Returns nonzero iff DECL is a specialization of TMPL. */
1262 int
1264 {
1265 tree t;
1268 {
1274 }
1275 else
1276 {
1285 }
1288 }
1290 /* Returns nonzero iff DECL is a specialization of friend declaration
1291 FRIEND_DECL according to [temp.friend]. */
1293 bool
1295 {
1302 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1303 of a template class, we want to check if DECL is a specialization
1304 if this. */
1308 {
1309 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1312 }
1317 /* There is nothing to do if this is not a template friend. */
1324 /* [temp.friend/6]
1325 A member of a class template may be declared to be a friend of a
1326 non-template class. In this case, the corresponding member of
1327 every specialization of the class template is a friend of the
1328 class granting friendship.
1330 For example, given a template friend declaration
1332 template <class T> friend void A<T>::f();
1334 the member function below is considered a friend
1336 template <> struct A<int> {
1337 void f();
1338 };
1340 For this type of template friend, TEMPLATE_DEPTH below will be
1341 nonzero. To determine if DECL is a friend of FRIEND, we first
1342 check if the enclosing class is a specialization of another. */
1349 {
1350 /* Next, we check the members themselves. In order to handle
1351 a few tricky cases, such as when FRIEND_DECL's are
1353 template <class T> friend void A<T>::g(T t);
1354 template <class T> template <T t> friend void A<T>::h();
1356 and DECL's are
1358 void A<int>::g(int);
1359 template <int> void A<int>::h();
1361 we need to figure out ARGS, the template arguments from
1362 the context of DECL. This is required for template substitution
1363 of `T' in the function parameter of `g' and template parameter
1364 of `h' in the above examples. Here ARGS corresponds to `int'. */
1371 {
1373 {
1376 else
1378 current_depth++;
1379 }
1381 }
1384 {
1386 tree friend_type;
1387 tree decl_type;
1388 tree friend_args_type;
1389 tree decl_args_type;
1391 /* Make sure that both DECL and FRIEND_DECL are templates or
1392 non-templates. */
1398 {
1399 /* If both are templates, check template parameter list. */
1400 tree friend_parms
1405 friend_parms))
1409 }
1410 else
1418 /* Check if return types match. */
1422 /* Check if function parameter types match, ignoring the
1423 `this' parameter. */
1432 }
1433 else
1434 {
1435 /* DECL is a TYPE_DECL */
1439 /* Make sure that both DECL and FRIEND_DECL are templates or
1440 non-templates. */
1441 is_template
1448 {
1449 tree friend_parms;
1450 /* If both are templates, check the name of the two
1451 TEMPLATE_DECL's first because is_friend didn't. */
1456 /* Now check template parameter list. */
1457 friend_parms
1460 return comp_template_parms
1462 friend_parms);
1463 }
1464 else
1467 }
1468 }
1470 }
1472 /* Register the specialization SPEC as a specialization of TMPL with
1473 the indicated ARGS. IS_FRIEND indicates whether the specialization
1474 is actually just a friend declaration. Returns SPEC, or an
1475 equivalent prior declaration, if available.
1477 We also store instantiations of field packs in the hash table, even
1478 though they are not themselves templates, to make lookup easier. */
1480 static tree
1482 hashval_t hash)
1483 {
1484 tree fn;
1486 spec_entry elt;
1494 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1495 register it; we want the corresponding TEMPLATE_DECL instead.
1496 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1497 the more obvious `uses_template_parms (spec)' to avoid problems
1498 with default function arguments. In particular, given
1499 something like this:
1501 template <class T> void f(T t1, T t = T())
1503 the default argument expression is not substituted for in an
1504 instantiation unless and until it is actually needed. */
1508 /* We don't put these specializations in the hash table, but we might
1509 want to give an error about a mismatch. */
1511 else
1512 {
1520 slot =
1524 else
1526 }
1528 /* We can sometimes try to re-register a specialization that we've
1529 already got. In particular, regenerate_decl_from_template calls
1530 duplicate_decls which will update the specialization list. But,
1531 we'll still get called again here anyhow. It's more convenient
1532 to simply allow this than to try to prevent it. */
1536 {
1538 {
1541 {
1543 fn);
1545 }
1546 else
1547 {
1548 tree clone;
1549 /* This situation should occur only if the first
1550 specialization is an implicit instantiation, the
1551 second is an explicit specialization, and the
1552 implicit instantiation has not yet been used. That
1553 situation can occur if we have implicitly
1554 instantiated a member function and then specialized
1555 it later.
1557 We can also wind up here if a friend declaration that
1558 looked like an instantiation turns out to be a
1559 specialization:
1561 template <class T> void foo(T);
1562 class S { friend void foo<>(int) };
1563 template <> void foo(int);
1565 We transform the existing DECL in place so that any
1566 pointers to it become pointers to the updated
1567 declaration.
1569 If there was a definition for the template, but not
1570 for the specialization, we want this to look as if
1571 there were no definition, and vice versa. */
1574 /* The call to duplicate_decls will have applied
1575 [temp.expl.spec]:
1577 An explicit specialization of a function template
1578 is inline only if it is explicitly declared to be,
1579 and independently of whether its function template
1580 is.
1582 to the primary function; now copy the inline bits to
1583 the various clones. */
1585 {
1592 }
1596 }
1597 }
1599 {
1602 /* We've already complained in duplicate_decls. */
1606 /* Dup decl failed, but this is a new definition. Set the
1607 line number so any errors match this new
1608 definition. */
1612 }
1613 }
1617 /* A specialization must be declared in the same namespace as the
1618 template it is specializing. */
1624 {
1633 /* If TMPL is a forward declaration of a template function, keep a list
1634 of all specializations in case we need to reassign them to a friend
1635 template later in tsubst_friend_function.
1637 Also keep a list of all variable template instantiations so that
1638 process_partial_specialization can check whether a later partial
1639 specialization would have used it. */
1642 }
1645 }
1647 /* Returns true iff two spec_entry nodes are equivalent. */
1651 bool
1653 {
1660 /* tmpl could be a FIELD_DECL for a capture pack. */
1664 {
1665 /* Partial specializations of a variable template can be distinguished by
1666 constraints. */
1670 }
1674 }
1676 /* Returns a hash for a template TMPL and template arguments ARGS. */
1678 static hashval_t
1680 {
1683 }
1685 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1686 ignoring SPEC. */
1688 hashval_t
1690 {
1692 }
1694 /* Recursively calculate a hash value for a template argument ARG, for use
1695 in the hash tables of template specializations. */
1697 hashval_t
1699 {
1719 {
1727 {
1732 }
1754 {
1758 {
1761 }
1763 }
1767 {
1770 }
1781 val = iterative_hash_template_arg
1793 val);
1795 val);
1804 /* A lambda can't appear in a template arg, but don't crash on
1805 erroneous input. */
1817 /* Now hash operands as usual. */
1822 }
1825 {
1828 {
1829 // We want an alias specialization that survived strip_typedefs
1830 // to hash differently from its TYPE_CANONICAL, to avoid hash
1831 // collisions that compare as different in template_args_equal.
1832 // These could be dependent specializations that strip_typedefs
1833 // left alone, or untouched specializations because
1834 // coerce_template_parms returns the unconverted template
1835 // arguments if it sees incomplete argument packs.
1838 }
1841 val);
1844 /* Otherwise just compare the types during lookup. */
1853 {
1858 }
1859 }
1862 }
1864 /* Unregister the specialization SPEC as a specialization of TMPL.
1865 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1866 if the SPEC was listed as a specialization of TMPL.
1868 Note that SPEC has been ggc_freed, so we can't look inside it. */
1870 bool
1872 {
1874 spec_entry elt;
1882 {
1887 }
1890 }
1892 /* Like register_specialization, but for local declarations. We are
1893 registering SPEC, an instantiation of TMPL. */
1895 void
1897 {
1900 }
1902 /* TYPE is a class type. Returns true if TYPE is an explicitly
1903 specialized class. */
1905 bool
1907 {
1911 }
1913 /* Print the list of functions at FNS, going through all the overloads
1914 for each element of the list. Alternatively, FNS can not be a
1915 TREE_LIST, in which case it will be printed together with all the
1916 overloads.
1918 MORE and *STR should respectively be FALSE and NULL when the function
1919 is called from the outside. They are used internally on recursive
1920 calls. print_candidates manages the two parameters and leaves NULL
1921 in *STR when it ends. */
1923 static void
1925 {
1929 else
1931 {
1937 {
1940 else
1943 }
1945 }
1946 }
1948 /* Print the list of candidate FNS in an error message. FNS can also
1949 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1951 void
1953 {
1957 }
1959 /* Get a (possibly) constrained template declaration for the
1960 purpose of ordering candidates. */
1961 static tree
1963 {
1969 }
1971 /* Among candidates having the same signature, return the
1972 most constrained or NULL_TREE if there is no best candidate.
1973 If the signatures of candidates vary (e.g., template
1974 specialization vs. member function), then there can be no
1975 most constrained.
1977 Note that we don't compare constraints on the functions
1978 themselves, but rather those of their templates. */
1979 static tree
1981 {
1982 // Try to find the best candidate in a first pass.
1985 {
1992 }
1994 // Verify that the champ is better than previous candidates.
1999 }
2002 }
2005 /* Returns the template (one of the functions given by TEMPLATE_ID)
2006 which can be specialized to match the indicated DECL with the
2007 explicit template args given in TEMPLATE_ID. The DECL may be
2008 NULL_TREE if none is available. In that case, the functions in
2009 TEMPLATE_ID are non-members.
2011 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2012 specialization of a member template.
2014 The TEMPLATE_COUNT is the number of references to qualifying
2015 template classes that appeared in the name of the function. See
2016 check_explicit_specialization for a more accurate description.
2018 TSK indicates what kind of template declaration (if any) is being
2019 declared. TSK_TEMPLATE indicates that the declaration given by
2020 DECL, though a FUNCTION_DECL, has template parameters, and is
2021 therefore a template function.
2023 The template args (those explicitly specified and those deduced)
2024 are output in a newly created vector *TARGS_OUT.
2026 If it is impossible to determine the result, an error message is
2027 issued. The error_mark_node is returned to indicate failure. */
2029 static tree
2031 tree decl,
2035 tmpl_spec_kind tsk)
2036 {
2037 tree fns;
2038 tree targs;
2039 tree explicit_targs;
2042 /* A TREE_LIST of templates of which DECL may be a specialization.
2043 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2044 corresponding TREE_PURPOSE is the set of template arguments that,
2045 when used to instantiate the template, would produce a function
2046 with the signature of DECL. */
2056 /* We shouldn't be specializing a member template of an
2057 unspecialized class template; we already gave an error in
2058 check_specialization_scope, now avoid crashing. */
2061 {
2064 }
2072 /* Check for baselinks. */
2077 {
2080 }
2082 {
2085 }
2087 /* Count the number of template headers specified for this
2088 specialization. */
2098 {
2101 tf_warning_or_error,
2105 }
2107 {
2111 {
2112 tree decl_arg_types;
2113 tree fn_arg_types;
2114 tree insttype;
2116 /* In case of explicit specialization, we need to check if
2117 the number of template headers appearing in the specialization
2118 is correct. This is usually done in check_explicit_specialization,
2119 but the check done there cannot be exhaustive when specializing
2120 member functions. Consider the following code:
2122 template <> void A<int>::f(int);
2123 template <> template <> void A<int>::f(int);
2125 Assuming that A<int> is not itself an explicit specialization
2126 already, the first line specializes "f" which is a non-template
2127 member function, whilst the second line specializes "f" which
2128 is a template member function. So both lines are syntactically
2129 correct, and check_explicit_specialization does not reject
2130 them.
2132 Here, we can do better, as we are matching the specialization
2133 against the declarations. We count the number of template
2134 headers, and we check if they match TEMPLATE_COUNT + 1
2135 (TEMPLATE_COUNT is the number of qualifying template classes,
2136 plus there must be another header for the member template
2137 itself).
2139 Notice that if header_count is zero, this is not a
2140 specialization but rather a template instantiation, so there
2141 is no check we can perform here. */
2145 /* Check that the number of template arguments at the
2146 innermost level for DECL is the same as for FN. */
2154 /* DECL might be a specialization of FN. */
2158 /* For a non-static member function, we need to make sure
2159 that the const qualification is the same. Since
2160 get_bindings does not try to merge the "this" parameter,
2161 we must do the comparison explicitly. */
2167 /* Skip the "this" parameter and, for constructors of
2168 classes with virtual bases, the VTT parameter. A
2169 full specialization of a constructor will have a VTT
2170 parameter, but a template never will. */
2171 decl_arg_types
2173 fn_arg_types
2176 /* Function templates cannot be specializations; there are
2177 no partial specializations of functions. Therefore, if
2178 the type of DECL does not match FN, there is no
2179 match.
2181 Note that it should never be the case that we have both
2182 candidates added here, and for regular member functions
2183 below. */
2185 {
2189 }
2191 /* See whether this function might be a specialization of this
2192 template. Suppress access control because we might be trying
2193 to make this specialization a friend, and we have already done
2194 access control for the declaration of the specialization. */
2200 /* We cannot deduce template arguments that when used to
2201 specialize TMPL will produce DECL. */
2204 /* Remove, from the set of candidates, all those functions
2205 whose constraints are not satisfied. */
2209 // Then, try to form the new function type.
2213 fn_arg_types
2218 /* Save this template, and the arguments deduced. */
2220 }
2222 /* FN is an ordinary member function, and we need a
2223 specialization of a member template. */
2224 ;
2226 /* We can get IDENTIFIER_NODEs here in certain erroneous
2227 cases. */
2228 ;
2230 /* This is just an ordinary non-member function. Nothing can
2231 be a specialization of that. */
2232 ;
2234 /* Cannot specialize functions that are created implicitly. */
2235 ;
2236 else
2237 {
2238 tree decl_arg_types;
2240 /* This is an ordinary member function. However, since
2241 we're here, we can assume its enclosing class is a
2242 template class. For example,
2244 template <typename T> struct S { void f(); };
2245 template <> void S<int>::f() {}
2247 Here, S<int>::f is a non-template, but S<int> is a
2248 template class. If FN has the same type as DECL, we
2249 might be in business. */
2252 /* Its enclosing class is an explicit specialization
2253 of a template class. This is not a candidate. */
2258 /* The return types differ. */
2261 /* Adjust the type of DECL in case FN is a static member. */
2268 decl_arg_types))
2271 // If the deduced arguments do not satisfy the constraints,
2272 // this is not a candidate.
2276 // Add the candidate.
2278 }
2279 }
2282 {
2283 /* We have:
2285 [temp.expl.spec]
2287 It is possible for a specialization with a given function
2288 signature to be instantiated from more than one function
2289 template. In such cases, explicit specification of the
2290 template arguments must be used to uniquely identify the
2291 function template specialization being specialized.
2293 Note that here, there's no suggestion that we're supposed to
2294 determine which of the candidate templates is most
2295 specialized. However, we, also have:
2297 [temp.func.order]
2299 Partial ordering of overloaded function template
2300 declarations is used in the following contexts to select
2301 the function template to which a function template
2302 specialization refers:
2304 -- when an explicit specialization refers to a function
2305 template.
2307 So, we do use the partial ordering rules, at least for now.
2308 This extension can only serve to make invalid programs valid,
2309 so it's safe. And, there is strong anecdotal evidence that
2310 the committee intended the partial ordering rules to apply;
2311 the EDG front end has that behavior, and John Spicer claims
2312 that the committee simply forgot to delete the wording in
2313 [temp.expl.spec]. */
2316 {
2319 }
2320 }
2322 // Concepts allows multiple declarations of member functions
2323 // with the same signature. Like above, we need to rely on
2324 // on the partial ordering of those candidates to determine which
2325 // is the best.
2327 {
2329 {
2332 }
2333 }
2336 {
2343 else
2346 }
2350 {
2356 }
2358 /* We have one, and exactly one, match. */
2360 {
2364 // Propagate the candidate's constraints to the declaration.
2367 /* DECL is a re-declaration or partial instantiation of a template
2368 function. */
2371 /* It was a specialization of an ordinary member function in a
2372 template class. */
2374 }
2376 /* It was a specialization of a template. */
2379 {
2384 }
2385 else
2388 }
2390 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2391 but with the default argument values filled in from those in the
2392 TMPL_TYPES. */
2394 static tree
2396 tree tmpl_types)
2397 {
2398 tree new_spec_types;
2406 /* Substitute into the rest of the list. */
2407 new_spec_types =
2411 /* Add the default argument for this parameter. */
2414 new_spec_types);
2415 }
2417 /* DECL is an explicit specialization. Replicate default arguments
2418 from the template it specializes. (That way, code like:
2420 template <class T> void f(T = 3);
2421 template <> void f(double);
2422 void g () { f (); }
2424 works, as required.) An alternative approach would be to look up
2425 the correct default arguments at the call-site, but this approach
2426 is consistent with how implicit instantiations are handled. */
2428 static void
2430 {
2431 tree tmpl;
2432 tree spec_types;
2433 tree tmpl_types;
2434 tree new_spec_types;
2435 tree old_type;
2436 tree new_type;
2437 tree t;
2442 /* See if there's anything we need to do. */
2455 {
2456 /* Remove the this pointer, but remember the object's type for
2457 CV quals. */
2463 {
2464 /* DECL may contain more parameters than TMPL due to the extra
2465 in-charge parameter in constructors and destructors. */
2468 }
2470 {
2473 }
2474 }
2476 /* Compute the merged default arguments. */
2477 new_spec_types =
2480 /* Compute the new FUNCTION_TYPE. */
2482 {
2486 new_spec_types);
2489 /* Put the in-charge parameter back. */
2492 new_spec_types);
2496 new_spec_types);
2497 }
2498 else
2500 new_spec_types);
2510 }
2512 /* Return the number of template headers we expect to see for a definition
2513 or specialization of CTYPE or one of its non-template members. */
2515 int
2517 {
2521 {
2522 /* You're supposed to have one `template <...>' for every
2523 template class, but you don't need one for a full
2524 specialization. For example:
2526 template <class T> struct S{};
2527 template <> struct S<int> { void f(); };
2528 void S<int>::f () {}
2530 is correct; there shouldn't be a `template <>' for the
2531 definition of `S<int>::f'. */
2533 /* If CTYPE does not have template information of any
2534 kind, then it is not a template, nor is it nested
2535 within a template. */
2543 }
2546 }
2548 /* Do a simple sanity check on the template headers that precede the
2549 variable declaration DECL. */
2551 void
2553 {
2558 {
2561 "variable templates only available with "
2564 // Namespace-scope variable templates should have a template header.
2566 }
2568 {
2570 "too many template headers for %qD "
2576 "members of an explicitly specialized class are defined "
2578 }
2579 }
2581 /* An explicit specialization whose declarator-id or class-head-name is not
2582 qualified shall be declared in the nearest enclosing namespace of the
2583 template, or, if the namespace is inline (7.3.1), any namespace from its
2584 enclosing namespace set.
2586 If the name declared in the explicit instantiation is an unqualified name,
2587 the explicit instantiation shall appear in the namespace where its template
2588 is declared or, if that namespace is inline (7.3.1), any namespace from its
2589 enclosing namespace set. */
2591 void
2593 {
2598 {
2604 /* This was allowed in C++98, so only pedwarn. */
2606 "outside its namespace must use a nested-name-"
2608 }
2609 }
2611 /* Check to see if the function just declared, as indicated in
2612 DECLARATOR, and in DECL, is a specialization of a function
2613 template. We may also discover that the declaration is an explicit
2614 instantiation at this point.
2616 Returns DECL, or an equivalent declaration that should be used
2617 instead if all goes well. Issues an error message if something is
2618 amiss. Returns error_mark_node if the error is not easily
2619 recoverable.
2621 FLAGS is a bitmask consisting of the following flags:
2623 2: The function has a definition.
2624 4: The function is a friend.
2626 The TEMPLATE_COUNT is the number of references to qualifying
2627 template classes that appeared in the name of the function. For
2628 example, in
2630 template <class T> struct S { void f(); };
2631 void S<int>::f();
2633 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2634 classes are not counted in the TEMPLATE_COUNT, so that in
2636 template <class T> struct S {};
2637 template <> struct S<int> { void f(); }
2638 template <> void S<int>::f();
2640 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2641 invalid; there should be no template <>.)
2643 If the function is a specialization, it is marked as such via
2644 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2645 is set up correctly, and it is added to the list of specializations
2646 for that template. */
2648 tree
2650 tree decl,
2653 {
2662 tmpl_spec_kind tsk;
2665 {
2668 else
2670 }
2671 else
2675 {
2678 {
2681 }
2683 {
2685 /* This could be something like:
2687 template <class T> void f(T);
2688 class S { friend void f<>(int); } */
2690 else
2691 {
2692 /* This case handles bogus declarations like template <>
2693 template <class T> void f<int>(); */
2696 declarator);
2698 }
2699 }
2703 /* The error has already been reported in
2704 check_specialization_scope. */
2710 /* Fall through. */
2723 decl);
2726 else
2730 /* Fall through. */
2736 /* In cases like template<> constexpr bool v = true;
2737 We'll give an error in check_template_variable. */
2743 else
2749 {
2750 /* This case handles bogus declarations like template <>
2751 template <class T> void f<int>(); */
2755 declarator);
2757 {
2758 /* Partial specialization of variable template. */
2762 }
2766 else
2770 ok:;
2771 }
2774 /* This is a specialization of a member template, without
2775 specialization the containing class. Something like:
2777 template <class T> struct S {
2778 template <class U> void f (U);
2779 };
2780 template <> template <class U> void S<int>::f(U) {}
2782 That's a specialization -- but of the entire template. */
2788 }
2791 /* This doesn't apply to variable templates. */
2794 {
2798 {
2802 }
2803 }
2806 {
2811 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2813 {
2814 tree fns;
2819 else
2820 {
2821 /* If there is no class context, the explicit instantiation
2822 must be at namespace scope. */
2825 /* Find the namespace binding, using the declaration
2826 context. */
2830 /* If lookup fails, look for a friend declaration so we can
2831 give a better diagnostic. */
2837 {
2840 }
2841 }
2844 }
2850 {
2852 /* A specialization in class scope. This is invalid,
2853 but the error will already have been flagged by
2854 check_specialization_scope. */
2856 else
2857 {
2858 /* It's not valid to write an explicit instantiation in
2859 class scope, e.g.:
2861 class C { template void f(); }
2863 This case is caught by the parser. However, on
2864 something like:
2866 template class C { void f(); };
2868 (which is invalid) we can get here. The error will be
2869 issued later. */
2870 ;
2871 }
2874 }
2877 {
2878 // We'll match variable templates in start_decl.
2882 /* Find the list of functions in ctype that have the same
2883 name as the declared function. */
2887 {
2891 {
2892 /* From [temp.expl.spec]:
2894 If such an explicit specialization for the member
2895 of a class template names an implicitly-declared
2896 special member function (clause _special_), the
2897 program is ill-formed.
2899 Similar language is found in [temp.explicit]. */
2902 }
2905 }
2907 /* For a type-conversion operator, We might be looking for
2908 `operator int' which will be a specialization of
2909 `operator T'. Grab all the conversion operators, and
2910 then select from them. */
2915 {
2918 }
2919 else
2921 }
2923 /* Figure out what exactly is being specialized at this point.
2924 Note that for an explicit instantiation, even one for a
2925 member function, we cannot tell a priori whether the
2926 instantiation is for a member template, or just a member
2927 function of a template class. Even if a member template is
2928 being instantiated, the member template arguments may be
2929 elided if they can be deduced from the rest of the
2930 declaration. */
2933 member_specialization,
2934 template_count,
2935 tsk);
2938 /* We couldn't figure out what this declaration was
2939 specializing. */
2941 else
2942 {
2945 {
2947 "friend declaration %qD is not visible to "
2951 }
2959 {
2960 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2961 is done by do_decl_instantiation later. */
2967 {
2968 /* If TMPL is not the most general template (for
2969 example, if TMPL is a friend template that is
2970 injected into namespace scope), then there will
2971 be too many levels of TARGS. Remove some of them
2972 here. */
2974 tree new_targs;
2981 }
2984 }
2986 /* If we thought that the DECL was a member function, but it
2987 turns out to be specializing a static member function,
2988 make DECL a static member function as well. */
2994 /* If this is a specialization of a member template of a
2995 template class, we want to return the TEMPLATE_DECL, not
2996 the specialization of it. */
2998 {
3003 {
3004 tree parm;
3008 /* We want to use the argument list specified in the
3009 definition, not in the original declaration. */
3014 }
3017 }
3019 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3025 /* Inherit default function arguments from the template
3026 DECL is specializing. */
3030 /* This specialization has the same protection as the
3031 template it specializes. */
3035 /* 7.1.1-1 [dcl.stc]
3037 A storage-class-specifier shall not be specified in an
3038 explicit specialization...
3040 The parser rejects these, so unless action is taken here,
3041 explicit function specializations will always appear with
3042 global linkage.
3044 The action recommended by the C++ CWG in response to C++
3045 defect report 605 is to make the storage class and linkage
3046 of the explicit specialization match the templated function:
3048 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3049 */
3051 {
3055 /* A concept cannot be specialized. */
3057 {
3059 gen_tmpl);
3061 }
3063 /* This specialization has the same linkage and visibility as
3064 the function template it specializes. */
3067 {
3070 }
3073 {
3076 }
3077 }
3079 /* If DECL is a friend declaration, declared using an
3080 unqualified name, the namespace associated with DECL may
3081 have been set incorrectly. For example, in:
3083 template <typename T> void f(T);
3084 namespace N {
3085 struct S { friend void f<int>(int); }
3086 }
3088 we will have set the DECL_CONTEXT for the friend
3089 declaration to N, rather than to the global namespace. */
3094 /* This is not really a declaration of a specialization.
3095 It's just the name of an instantiation. But, it's not
3096 a request for an instantiation, either. */
3099 /* A specialization is not necessarily COMDAT. */
3105 /* If this is a full specialization, register it so that we can find
3106 it again. Partial specializations will be registered in
3107 process_partial_specialization. */
3112 /* A 'structor should already have clones. */
3118 }
3119 }
3122 }
3124 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3125 parameters. These are represented in the same format used for
3126 DECL_TEMPLATE_PARMS. */
3128 int
3130 {
3131 const_tree p1;
3132 const_tree p2;
3140 {
3152 {
3156 /* If either of the template parameters are invalid, assume
3157 they match for the sake of error recovery. */
3170 }
3171 }
3174 /* One set of parameters has more parameters lists than the
3175 other. */
3179 }
3181 /* Determine whether PARM is a parameter pack. */
3183 bool
3185 {
3186 /* Determine if we have a non-type template parameter pack. */
3193 /* If this is a list of template parameters, we could get a
3194 TYPE_DECL or a TEMPLATE_DECL. */
3198 /* Otherwise it must be a type template parameter. */
3202 }
3204 /* Determine if T is a function parameter pack. */
3206 bool
3208 {
3212 }
3214 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3215 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3217 tree
3219 {
3226 }
3228 /* Return true iff the function parameter PARAM_DECL was expanded
3229 from the function parameter pack PACK. */
3231 bool
3233 {
3238 /* The parameter pack and its pack arguments have the same
3239 DECL_PARM_INDEX. */
3241 }
3243 /* Determine whether ARGS describes a variadic template args list,
3244 i.e., one that is terminated by a template argument pack. */
3246 static bool
3248 {
3250 tree last_parm;
3264 }
3266 /* Generate a new name for the parameter pack name NAME (an
3267 IDENTIFIER_NODE) that incorporates its */
3269 static tree
3271 {
3272 /* Munge the name to include the parameter index. */
3273 #define NUMBUF_LEN 128
3287 }
3289 /* Return true if T is a primary function, class or alias template
3290 instantiation. */
3292 bool
3294 {
3308 }
3310 /* Return true if PARM is a template template parameter. */
3312 bool
3314 {
3316 }
3318 /* Return true iff PARM is a DECL representing a type template
3319 parameter. */
3321 bool
3323 {
3328 }
3330 /* Return the template parameters of T if T is a
3331 primary template instantiation, NULL otherwise. */
3333 tree
3335 {
3340 parms = INNERMOST_TEMPLATE_PARMS
3344 }
3346 /* Return the template parameters of the LEVELth level from the full list
3347 of template parameters PARMS. */
3349 tree
3351 {
3352 tree p;
3363 }
3365 /* Returns the template arguments of T if T is a template instantiation,
3366 NULL otherwise. */
3368 tree
3370 {
3378 }
3380 /* Return the argument pack elements of T if T is a template argument pack,
3381 NULL otherwise. */
3383 tree
3385 {
3391 }
3393 /* True iff FN is a function representing a built-in variadic parameter
3394 pack. */
3396 bool
3398 {
3408 }
3410 /* True iff CALL is a call to a function representing a built-in variadic
3411 parameter pack. */
3413 static bool
3415 {
3419 }
3421 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3423 static tree
3425 tree in_decl)
3426 {
3432 {
3434 {
3437 }
3442 }
3443 else
3444 {
3448 /* Calculate the largest value of len that won't make the size of the vec
3449 overflow an int. The compiler will exceed resource limits long before
3450 this, but it seems a decent place to diagnose. */
3454 {
3459 }
3467 }
3468 }
3470 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3471 CALL. */
3473 static tree
3475 tree in_decl)
3476 {
3486 }
3488 /* Structure used to track the progress of find_parameter_packs_r. */
3489 struct find_parameter_pack_data
3490 {
3491 /* TREE_LIST that will contain all of the parameter packs found by
3492 the traversal. */
3495 /* Set of AST nodes that have been visited by the traversal. */
3498 /* True iff we're making a type pack expansion. */
3500 };
3502 /* Identifies all of the argument packs that occur in a template
3503 argument and appends them to the TREE_LIST inside DATA, which is a
3504 find_parameter_pack_data structure. This is a subroutine of
3505 make_pack_expansion and uses_parameter_packs. */
3506 static tree
3508 {
3514 /* Handle type aliases/typedefs. */
3516 {
3523 }
3525 /* Identify whether this is a parameter pack or not. */
3527 {
3535 /* FALLTHRU */
3537 /* If the placeholder appears in the decl-specifier-seq of a function
3538 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3539 is a pack expansion, the invented template parameter is a template
3540 parameter pack. */
3550 {
3551 /* We don't want to walk into the type of a PARM_DECL,
3552 because we don't want to see the type parameter pack. */
3555 }
3558 /* Look through a lambda capture proxy to the field pack. */
3561 {
3567 }
3569 {
3571 find_parameter_packs_r,
3574 }
3586 /* Not a parameter pack. */
3588 }
3591 {
3592 /* Add this parameter pack to the list. */
3594 }
3600 /* This switch statement will return immediately if we don't find a
3601 parameter pack. */
3603 {
3608 /* Check the template itself. */
3611 /* Check the template arguments. */
3625 /* Ignore the declaration of a capture proxy for a parameter pack. */
3633 /* Fall through. */
3678 {
3684 }
3687 {
3688 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3689 type_pack_expansion_p to false so that any placeholders
3690 within the expression don't get marked as parameter packs. */
3698 }
3702 }
3705 }
3707 /* Determines if the expression or type T uses any parameter packs. */
3708 bool
3710 {
3719 }
3721 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3722 representation a base-class initializer into a parameter pack
3723 expansion. If all goes well, the resulting node will be an
3724 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3725 respectively. */
3726 tree
3728 {
3729 tree result;
3738 {
3739 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3740 class initializer. In this case, the TREE_PURPOSE will be a
3741 _TYPE node (representing the base class expansion we're
3742 initializing) and the TREE_VALUE will be a TREE_LIST
3743 containing the initialization arguments.
3745 The resulting expansion looks somewhat different from most
3746 expansions. Rather than returning just one _EXPANSION, we
3747 return a TREE_LIST whose TREE_PURPOSE is a
3748 TYPE_PACK_EXPANSION containing the bases that will be
3749 initialized. The TREE_VALUE will be identical to the
3750 original TREE_VALUE, which is a list of arguments that will
3751 be passed to each base. We do not introduce any new pack
3752 expansion nodes into the TREE_VALUE (although it is possible
3753 that some already exist), because the TREE_PURPOSE and
3754 TREE_VALUE all need to be expanded together with the same
3755 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3756 resulting TREE_PURPOSE will mention the parameter packs in
3757 both the bases and the arguments to the bases. */
3758 tree purpose;
3759 tree value;
3762 /* Determine which parameter packs will be used by the base
3763 class expansion. */
3772 {
3776 }
3779 {
3780 /* Collect the sets of parameter packs used in each of the
3781 initialization arguments. */
3783 {
3784 /* Determine which parameter packs will be expanded in this
3785 argument. */
3788 }
3789 }
3793 /* Create the pack expansion type for the base type. */
3799 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3800 they will rarely be compared to anything. */
3804 }
3809 /* Build the PACK_EXPANSION_* node. */
3810 result = for_types
3815 {
3816 /* Propagate type and const-expression information. */
3819 /* Mark this read now, since the expansion might be length 0. */
3821 }
3822 else
3823 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3824 they will rarely be compared to anything. */
3827 /* Determine which parameter packs will be expanded. */
3834 /* Make sure we found some parameter packs. */
3836 {
3839 else
3842 }
3848 }
3850 /* Checks T for any "bare" parameter packs, which have not yet been
3851 expanded, and issues an error if any are found. This operation can
3852 only be done on full expressions or types (e.g., an expression
3853 statement, "if" condition, etc.), because we could have expressions like:
3855 foo(f(g(h(args)))...)
3857 where "args" is a parameter pack. check_for_bare_parameter_packs
3858 should not be called for the subexpressions args, h(args),
3859 g(h(args)), or f(g(h(args))), because we would produce erroneous
3860 error messages.
3862 Returns TRUE and emits an error if there were bare parameter packs,
3863 returns FALSE otherwise. */
3864 bool
3866 {
3873 /* A lambda might use a parameter pack from the containing context. */
3887 {
3891 {
3902 else
3907 else
3911 }
3914 }
3917 }
3919 /* Expand any parameter packs that occur in the template arguments in
3920 ARGS. */
3921 tree
3923 {
3932 /* First, determine if we need to expand anything, and the number of
3933 slots we'll need. */
3935 {
3940 {
3944 else
3946 }
3947 else
3948 {
3950 num_result_args++;
3951 }
3952 }
3954 /* If no expansion is necessary, we're done. */
3958 /* Expand arguments. */
3961 non_default_args_count =
3964 {
3967 {
3974 }
3975 else
3976 {
3979 }
3980 }
3984 }
3986 /* Checks if DECL shadows a template parameter.
3988 [temp.local]: A template-parameter shall not be redeclared within its
3989 scope (including nested scopes).
3991 Emits an error and returns TRUE if the DECL shadows a parameter,
3992 returns FALSE otherwise. */
3994 bool
3996 {
3997 tree olddecl;
3999 /* If we're not in a template, we can't possibly shadow a template
4000 parameter. */
4004 /* Figure out what we're shadowing. */
4008 /* If there's no previous binding for this name, we're not shadowing
4009 anything, let alone a template parameter. */
4013 /* If we're not shadowing a template parameter, we're done. Note
4014 that OLDDECL might be an OVERLOAD (or perhaps even an
4015 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4016 node. */
4020 /* We check for decl != olddecl to avoid bogus errors for using a
4021 name inside a class. We check TPFI to avoid duplicate errors for
4022 inline member templates. */
4028 /* Don't complain about the injected class name, as we've already
4029 complained about the class itself. */
4036 else
4041 }
4043 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4044 ORIG_LEVEL, DECL, and TYPE. */
4046 static tree
4050 tree decl,
4051 tree type)
4052 {
4063 }
4065 /* Find the canonical type parameter for the given template type
4066 parameter. Returns the canonical type parameter, which may be TYPE
4067 if no such parameter existed. */
4069 static tree
4071 {
4072 tree list;
4086 else
4087 {
4091 }
4092 }
4094 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4095 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4096 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4097 new one is created. */
4099 static tree
4101 tsubst_flags_t complain)
4102 {
4107 {
4126 /* Template template parameters need this. */
4128 {
4135 }
4136 }
4139 }
4141 /* Process information from new template parameter PARM and append it
4142 to the LIST being built. This new parameter is a non-type
4143 parameter iff IS_NON_TYPE is true. This new parameter is a
4144 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4145 is in PARM_LOC. */
4147 tree
4150 {
4159 {
4163 {
4167 else
4169 }
4172 }
4175 {
4181 {
4182 /* [temp.param]
4184 The top-level cv-qualifiers on the template-parameter are
4185 ignored when determining its type. */
4190 && !is_parameter_pack
4191 /* If we're in a nested template parameter list, the template
4192 template parameter could be a parameter pack. */
4194 {
4195 /* This template parameter is not a parameter pack, but it
4196 should be. Complain about "bare" parameter packs. */
4199 /* Recover by calling this a parameter pack. */
4201 }
4202 }
4204 /* A template parameter is not modifiable. */
4213 processing_template_decl,
4218 }
4219 else
4220 {
4221 tree t;
4225 {
4227 /* This is for distinguishing between real templates and template
4228 template parameters */
4232 }
4233 else
4234 {
4236 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4239 }
4246 processing_template_decl,
4250 }
4254 /* Build requirements for the type/template parameter.
4255 This must be done after SET_DECL_TEMPLATE_PARM_P or
4256 process_template_parm could fail. */
4261 /* Build the parameter node linking the parameter declaration,
4262 its default argument (if any), and its constraints (if any). */
4267 }
4269 /* The end of a template parameter list has been reached. Process the
4270 tree list into a parameter vector, converting each parameter into a more
4271 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4272 as PARM_DECLs. */
4274 tree
4276 {
4281 /* Pop the dummy parameter level and add the real one. */
4284 current_template_parms
4289 {
4293 }
4298 }
4300 // Explicitly indicate the end of the template parameter list. We assume
4301 // that the current template parameters have been constructed and/or
4302 // managed explicitly, as when creating new template template parameters
4303 // from a shorthand constraint.
4304 void
4306 {
4308 }
4310 /* end_template_decl is called after a template declaration is seen. */
4312 void
4314 {
4320 /* This matches the pushlevel in begin_template_parm_list. */
4325 }
4327 /* Takes a TREE_LIST representing a template parameter and convert it
4328 into an argument suitable to be passed to the type substitution
4329 functions. Note that If the TREE_LIST contains an error_mark
4330 node, the returned argument is error_mark_node. */
4332 tree
4334 {
4347 {
4351 {
4352 /* Turn this argument into a TYPE_ARGUMENT_PACK
4353 with a single element, which expands T. */
4362 }
4363 }
4364 else
4365 {
4369 {
4370 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4371 with a single element, which expands T. */
4381 }
4382 else
4384 }
4386 }
4388 /* Given a single level of template parameters (a TREE_VEC), return it
4389 as a set of template arguments. */
4391 static tree
4393 {
4403 }
4405 /* Given a set of template parameters, return them as a set of template
4406 arguments. The template parameters are represented as a TREE_VEC, in
4407 the form documented in cp-tree.h for template arguments. */
4409 static tree
4411 {
4412 tree header;
4417 /* If there is only one level of template parameters, we do not
4418 create a TREE_VEC of TREE_VECs. Instead, we return a single
4419 TREE_VEC containing the arguments. */
4424 {
4429 else
4431 }
4434 }
4436 /* Within the declaration of a template, return the currently active
4437 template parameters as an argument TREE_VEC. */
4439 static tree
4441 {
4443 }
4445 /* Update the declared TYPE by doing any lookups which were thought to be
4446 dependent, but are not now that we know the SCOPE of the declarator. */
4448 tree
4450 {
4461 /* Don't bother building up the args in this case. */
4463 {
4464 /* tsubst in the args corresponding to the template parameters,
4465 including auto if present. Most things will be unchanged, but
4466 make_typename_type and tsubst_qualified_id will resolve
4467 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4470 tree pushed;
4472 {
4476 }
4481 }
4487 {
4490 else
4492 }
4494 }
4496 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4497 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4498 the new template is a member template. */
4500 tree
4502 {
4510 }
4512 struct template_parm_data
4513 {
4514 /* The level of the template parameters we are currently
4515 processing. */
4518 /* The index of the specialization argument we are currently
4519 processing. */
4522 /* An array whose size is the number of template parameters. The
4523 elements are nonzero if the parameter has been used in any one
4524 of the arguments processed so far. */
4527 /* An array whose size is the number of template arguments. The
4528 elements are nonzero if the argument makes use of template
4529 parameters of this level. */
4531 };
4533 /* Subroutine of push_template_decl used to see if each template
4534 parameter in a partial specialization is used in the explicit
4535 argument list. If T is of the LEVEL given in DATA (which is
4536 treated as a template_parm_data*), then DATA->PARMS is marked
4537 appropriately. */
4539 static int
4541 {
4549 {
4552 }
4554 /* In C++17 the type of a non-type argument is a deduced context. */
4559 data,
4560 NULL,
4563 /* Return zero so that for_each_template_parm will continue the
4564 traversal of the tree; we want to mark *every* template parm. */
4566 }
4568 /* Process the partial specialization DECL. */
4570 static tree
4572 {
4579 tree inner_parms;
4580 tree inst;
4590 /* A concept cannot be specialized. */
4592 {
4595 }
4600 /* We check that each of the template parameters given in the
4601 partial specialization is used in the argument list to the
4602 specialization. For example:
4604 template <class T> struct S;
4605 template <class T> struct S<T*>;
4607 The second declaration is OK because `T*' uses the template
4608 parameter T, whereas
4610 template <class T> struct S<int>;
4612 is no good. Even trickier is:
4614 template <class T>
4615 struct S1
4616 {
4617 template <class U>
4618 struct S2;
4619 template <class U>
4620 struct S2<T>;
4621 };
4623 The S2<T> declaration is actually invalid; it is a
4624 full-specialization. Of course,
4626 template <class U>
4627 struct S2<T (*)(U)>;
4629 or some such would have been OK. */
4637 {
4642 NULL,
4644 }
4647 {
4648 /* One of the template parms was not used in a deduced context in the
4649 specialization. */
4651 {
4655 }
4659 }
4664 /* [temp.class.spec]
4666 The argument list of the specialization shall not be identical to
4667 the implicit argument list of the primary template. */
4668 tree main_args
4671 && (!flag_concepts
4674 {
4678 else
4682 }
4684 /* A partial specialization that replaces multiple parameters of the
4685 primary template with a pack expansion is less specialized for those
4686 parameters. */
4688 {
4690 "primary template because it replaces multiple parameters "
4693 /* Avoid crash in process_partial_specialization. */
4695 }
4697 /* If we aren't in a dependent class, we can actually try deduction. */
4699 /* FIXME we should be able to handle a partial specialization of a
4700 partial instantiation, but currently we can't (c++/41727). */
4703 {
4707 maintmpl);
4708 }
4710 /* [temp.class.spec]
4712 A partially specialized non-type argument expression shall not
4713 involve template parameters of the partial specialization except
4714 when the argument expression is a simple identifier.
4716 The type of a template parameter corresponding to a specialized
4717 non-type argument shall not be dependent on a parameter of the
4718 specialization.
4720 Also, we verify that pack expansions only occur at the
4721 end of the argument list. */
4725 {
4732 {
4733 /* Extract the arguments from the argument pack. We'll be
4734 iterating over these in the following loop. */
4737 }
4740 {
4742 /* Get the Jth argument in the parameter pack. */
4746 {
4747 /* Pack expansions must come at the end of the
4748 argument list. */
4751 {
4755 else
4758 }
4759 }
4762 /* We only care about the pattern. */
4768 /* This next two lines are the `argument expression is not just a
4769 simple identifier' condition and also the `specialized
4770 non-type argument' bit. */
4774 {
4778 arg);
4779 else
4780 {
4781 /* Look at the corresponding template parameter,
4782 marking which template parameters its type depends
4783 upon. */
4787 {
4788 /* We haven't yet initialized TPD2. Do so now. */
4790 /* The number of parameters here is the number in the
4791 main template, which, as checked in the assertion
4792 above, is NARGS. */
4796 }
4798 /* Mark the template parameters. But this time, we're
4799 looking for the template parameters of the main
4800 template, not in the specialization. */
4807 NULL,
4811 {
4812 /* The type depended on some template parameters.
4813 If they are fully specialized in the
4814 specialization, that's OK. */
4823 "type %qT of template argument %qE depends "
4825 "type %qT of template argument %qE depends "
4827 type,
4828 arg);
4829 }
4830 }
4831 }
4832 }
4833 }
4835 /* We should only get here once. */
4839 // Build the template decl.
4848 /* Give template template parms a DECL_CONTEXT of the template
4849 for which they are a parameter. */
4851 {
4855 }
4858 /* We didn't register this in check_explicit_specialization so we could
4859 wait until the constraints were set. */
4861 else
4871 {
4877 {
4885 "declaration of %qD ambiguates earlier template "
4889 "partial specialization of %qD after instantiation "
4891 }
4892 }
4895 }
4897 /* PARM is a template parameter of some form; return the corresponding
4898 TEMPLATE_PARM_INDEX. */
4900 static tree
4902 {
4915 }
4917 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4918 parameter packs used by the template parameter PARM. */
4920 static void
4922 {
4923 /* A type parm can't refer to another parm. */
4927 {
4931 }
4938 }
4940 /* PARM is a template parameter pack. Return any parameter packs used in
4941 its type or the type of any of its template parameters. If there are
4942 any such packs, it will be instantiated into a fixed template parameter
4943 list by partial instantiation rather than be fully deduced. */
4945 tree
4947 {
4948 /* This can only be true in a member template. */
4951 /* This can only be true for a parameter pack. */
4954 /* A type parm can't refer to another parm. */
4968 }
4970 /* Check that a template declaration's use of default arguments and
4971 parameter packs is not invalid. Here, PARMS are the template
4972 parameters. IS_PRIMARY is true if DECL is the thing declared by
4973 a primary template. IS_PARTIAL is true if DECL is a partial
4974 specialization.
4976 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4977 declaration (but not a definition); 1 indicates a declaration, 2
4978 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4979 emitted for extraneous default arguments.
4981 Returns TRUE if there were no errors found, FALSE otherwise. */
4983 bool
4986 {
4989 tree parm_level;
4992 /* [temp.param]
4994 A default template-argument shall not be specified in a
4995 function template declaration or a function template definition, nor
4996 in the template-parameter-list of the definition of a member of a
4997 class template. */
5001 /* You can't have a function template declaration in a local
5002 scope, nor you can you define a member of a class template in a
5003 local scope. */
5011 /* A lambda doesn't have an explicit declaration; don't complain
5012 about the parms of the enclosing class. */
5019 /* If this is either a friend defined in the scope of the class
5020 or a member function. */
5026 /* And, if it was a member function, it really was defined in
5027 the scope of the class. */
5030 /* We already checked these parameters when the template was
5031 declared, so there's no need to do it again now. This function
5032 was defined in class scope, but we're processing its body now
5033 that the class is complete. */
5036 /* Core issue 226 (C++0x only): the following only applies to class
5037 templates. */
5040 {
5041 /* [temp.param]
5043 If a template-parameter has a default template-argument, all
5044 subsequent template-parameters shall have a default
5045 template-argument supplied. */
5047 {
5054 {
5064 {
5066 /* For better subsequent error-recovery, we indicate that
5067 there should have been a default argument. */
5070 }
5072 && !is_friend_decl
5073 /* Don't complain about an enclosing partial
5074 specialization. */
5079 /* A fixed parameter pack will be partially
5080 instantiated into a fixed length list. */
5082 {
5083 /* A primary class template can only have one
5084 parameter pack, at the end of the template
5085 parameter list. */
5093 }
5094 }
5095 }
5096 }
5099 || is_partial
5100 || !is_primary
5102 /* For an ordinary class template, default template arguments are
5103 allowed at the innermost level, e.g.:
5104 template <class T = int>
5105 struct S {};
5106 but, in a partial specialization, they're not allowed even
5107 there, as we have in [temp.class.spec]:
5109 The template parameter list of a specialization shall not
5110 contain default template argument values.
5112 So, for a partial specialization, or for a function template
5113 (in C++98/C++03), we look at all of them. */
5114 ;
5115 else
5116 /* But, for a primary class template that is not a partial
5117 specialization we look at all template parameters except the
5118 innermost ones. */
5121 /* Figure out what error message to issue. */
5136 else
5137 /* Per [temp.param]/9, "A default template-argument shall not be
5138 specified in the template-parameter-lists of the definition of
5139 a member of a class template that appears outside of the member's
5140 class.", thus if we aren't handling a member of a class template
5141 there is no need to examine the parameters. */
5145 /* If we're inside a class definition, there's no need to
5146 examine the parameters to the class itself. On the one
5147 hand, they will be checked when the class is defined, and,
5148 on the other, default arguments are valid in things like:
5149 template <class T = double>
5150 struct S { template <class U> void f(U); };
5151 Here the default argument for `S' has no bearing on the
5152 declaration of `f'. */
5154 else
5155 /* Check everything. */
5161 {
5168 {
5173 {
5175 {
5182 }
5184 /* Clear out the default argument so that we are not
5185 confused later. */
5187 }
5188 }
5190 /* At this point, if we're still interested in issuing messages,
5191 they must apply to classes surrounding the object declared. */
5195 }
5198 }
5200 /* Worker for push_template_decl_real, called via
5201 for_each_template_parm. DATA is really an int, indicating the
5202 level of the parameters we are interested in. If T is a template
5203 parameter of that level, return nonzero. */
5205 static int
5207 {
5213 else
5216 }
5218 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5219 DATA is really an int, indicating the innermost outer level of parameters.
5220 If T is a template parameter of that level or further out, return
5221 nonzero. */
5223 static int
5225 {
5231 else
5234 }
5236 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5237 parameters given by current_template_args, or reuses a
5238 previously existing one, if appropriate. Returns the DECL, or an
5239 equivalent one, if it is replaced via a call to duplicate_decls.
5241 If IS_FRIEND is true, DECL is a friend declaration. */
5243 tree
5245 {
5246 tree tmpl;
5247 tree args;
5248 tree info;
5249 tree ctx;
5253 /* True if the template is a member template, in the sense of
5254 [temp.mem]. */
5260 /* See if this is a partial specialization. */
5273 /* For a friend, we want the context of the friend function, not
5274 the type of which it is a friend. */
5278 /* In the case of a virtual function, we want the class in which
5279 it is defined. */
5281 else
5282 /* Otherwise, if we're currently defining some class, the DECL
5283 is assumed to be a member of the class. */
5292 /* See if this is a primary template. */
5295 /* A friend template that specifies a class context, i.e.
5296 template <typename T> friend void A<T>::f();
5297 is not primary. */
5302 else
5306 {
5313 {
5316 }
5318 {
5320 {
5323 }
5325 {
5326 /* [temp.mem]
5328 A destructor shall not be a member template. */
5331 }
5338 {
5339 /* [basic.stc.dynamic.allocation]
5341 An allocation function can be a function
5342 template. ... Template allocation functions shall
5343 have two or more parameters. */
5346 }
5347 }
5350 {
5351 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5354 {
5360 }
5361 }
5364 /* alias-declaration */
5368 else
5369 {
5372 }
5373 }
5375 /* Check to see that the rules regarding the use of default
5376 arguments are not being violated. */
5380 /* Ensure that there are no parameter packs in the type of this
5381 declaration that have not been expanded. */
5383 {
5384 /* Check each of the arguments individually to see if there are
5385 any bare parameter packs. */
5391 {
5394 {
5395 /* This is a PARM_DECL that contains unexpanded parameter
5396 packs. We have already complained about this in the
5397 check_for_bare_parameter_packs call, so just replace
5398 these types with ERROR_MARK_NODE. */
5401 }
5405 }
5407 /* Check for bare parameter packs in the return type and the
5408 exception specifiers. */
5410 /* Errors were already issued, set return type to int
5411 as the frontend doesn't expect error_mark_node as
5412 the return type. */
5416 }
5421 {
5424 }
5437 {
5442 /* If DECL is a TYPE_DECL for a class-template, then there won't
5443 be DECL_LANG_SPECIFIC. The information equivalent to
5444 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5448 {
5449 /* Since a template declaration already existed for this
5450 class-type, we must be redeclaring it here. Make sure
5451 that the redeclaration is valid. */
5453 current_template_parms,
5455 /* We don't need to create a new TEMPLATE_DECL; just use the
5456 one we already had. */
5458 }
5459 else
5460 {
5462 member_template_p);
5467 {
5468 /* A specialization of a member template of a template
5469 class. */
5473 }
5474 }
5475 }
5476 else
5477 {
5483 {
5486 }
5494 {
5495 tree new_tmpl;
5497 /* The declaration is a specialization of a member
5498 template, declared outside the class. Therefore, the
5499 innermost template arguments will be NULL, so we
5500 replace them with the arguments determined by the
5501 earlier call to check_explicit_specialization. */
5504 new_tmpl
5506 member_template_p);
5516 args,
5519 }
5521 /* Make sure the template headers we got make sense. */
5526 {
5531 }
5532 else
5534 {
5539 {
5543 else
5547 /* Avoid crash in import_export_decl. */
5550 }
5555 /* Can happen in erroneous input. */
5557 else
5559 }
5561 /* Check that the parms are used in the appropriate qualifying scopes
5562 in the declarator. */
5566 {
5572 /* Avoid crash in import_export_decl. */
5575 }
5576 }
5581 /* Push template declarations for global functions and types. Note
5582 that we do not try to push a global template friend declared in a
5583 template class; such a thing may well depend on the template
5584 parameters of the class. */
5587 {
5592 /* Hide template friend classes that haven't been declared yet. */
5594 {
5597 }
5598 }
5601 {
5606 /* Give template template parms a DECL_CONTEXT of the template
5607 for which they are a parameter. */
5610 {
5614 }
5620 }
5622 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5623 back to its most general template. If TMPL is a specialization,
5624 ARGS may only have the innermost set of arguments. Add the missing
5625 argument levels if necessary. */
5633 else
5634 {
5639 }
5642 && !is_friend
5645 /* Set DECL_COMDAT on template instantiations; if we force
5646 them to be emitted by explicit instantiation or -frepo,
5647 mark_needed will tell cgraph to do the right thing. */
5651 }
5653 tree
5655 {
5657 }
5659 /* FN is an inheriting constructor that inherits from the constructor
5660 template INHERITED; turn FN into a constructor template with a matching
5661 template header. */
5663 tree
5665 {
5666 tree inner_parms
5669 tree parms
5680 }
5682 /* Called when a class template TYPE is redeclared with the indicated
5683 template PARMS, e.g.:
5685 template <class T> struct S;
5686 template <class T> struct S {}; */
5688 bool
5690 {
5691 tree tmpl;
5692 tree tmpl_parms;
5696 {
5699 }
5703 /* The type is nested in some template class. Nothing to worry
5704 about here; there are no new template parameters for the nested
5705 type. */
5709 {
5711 tmpl);
5713 }
5719 {
5729 }
5732 {
5733 tree tmpl_parm;
5734 tree parm;
5735 tree tmpl_default;
5736 tree parm_default;
5750 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5751 TEMPLATE_DECL. */
5761 {
5765 }
5768 {
5769 /* We have in [temp.param]:
5771 A template-parameter may not be given default arguments
5772 by two different declarations in the same scope. */
5777 }
5780 /* Update the previous template parameters (which are the ones
5781 that will really count) with the new default value. */
5784 /* Update the new parameters, too; they'll be used as the
5785 parameters for any members. */
5788 /* Give each template template parm in this redeclaration a
5789 DECL_CONTEXT of the template for which they are a parameter. */
5791 {
5794 }
5798 }
5800 // Cannot redeclare a class template with a different set of constraints.
5802 {
5807 }
5810 }
5812 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5813 to be used when the caller has already checked
5814 (processing_template_decl
5815 && !instantiation_dependent_expression_p (expr)
5816 && potential_constant_expression (expr))
5817 and cleared processing_template_decl. */
5819 tree
5821 {
5824 complain,
5828 }
5830 /* Simplify EXPR if it is a non-dependent expression. Returns the
5831 (possibly simplified) expression. */
5833 tree
5835 {
5839 /* If we're in a template, but EXPR isn't value dependent, simplify
5840 it. We're supposed to treat:
5842 template <typename T> void f(T[1 + 1]);
5843 template <typename T> void f(T[2]);
5845 as two declarations of the same function, for example. */
5848 {
5849 processing_template_decl_sentinel s;
5851 }
5853 }
5855 tree
5857 {
5859 }
5861 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
5862 an uninstantiated expression. */
5864 tree
5866 {
5870 {
5873 else
5874 {
5875 processing_template_decl_sentinel s;
5877 }
5878 }
5880 }
5882 /* True iff T is a specialization of a variable template. */
5884 bool
5886 {
5891 }
5893 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5894 template declaration, or a TYPE_DECL for an alias declaration. */
5896 bool
5898 {
5906 }
5908 /* Return TRUE iff T is a specialization of an alias template. */
5910 bool
5912 {
5913 /* It's an alias template specialization if it's an alias and its
5914 TYPE_NAME is a specialization of a primary template. */
5920 }
5922 /* An alias template is complex from a SFINAE perspective if a template-id
5923 using that alias can be ill-formed when the expansion is not, as with
5924 the void_t template. We determine this by checking whether the
5925 expansion for the alias template uses all its template parameters. */
5927 struct uses_all_template_parms_data
5928 {
5931 };
5933 static int
5935 {
5943 }
5945 static bool
5947 {
5962 }
5964 /* Return TRUE iff T is a specialization of a complex alias template with
5965 dependent template-arguments. */
5967 bool
5969 {
5982 }
5984 /* Return the number of innermost template parameters in TMPL. */
5986 static int
5988 {
5991 }
5993 /* Return either TMPL or another template that it is equivalent to under DR
5994 1286: An alias that just changes the name of a template is equivalent to
5995 the other template. */
5997 static tree
5999 {
6002 {
6003 /* Determine if the alias is equivalent to an underlying template. */
6015 tree alias_args = INNERMOST_TEMPLATE_ARGS
6020 /* Alias is equivalent. Strip it and repeat. */
6022 }
6025 }
6027 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6028 must be a reference-to-function or a pointer-to-function type, as specified
6029 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6030 and check that the resulting function has external linkage. */
6032 static tree
6034 tsubst_flags_t complain)
6035 {
6038 linkage_kind linkage;
6053 /* [temp.arg.nontype]/1
6055 A template-argument for a non-type, non-template template-parameter
6056 shall be one of:
6057 [...]
6058 -- the address of an object or function with external [C++11: or
6059 internal] linkage. */
6062 {
6064 {
6070 else
6073 }
6075 }
6079 {
6081 {
6086 else
6090 }
6092 }
6094 accept:
6101 }
6103 /* Subroutine of convert_nontype_argument.
6104 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6105 Emit an error otherwise. */
6107 static bool
6109 tsubst_flags_t complain)
6110 {
6127 {
6132 else
6134 }
6136 }
6138 /* Returns TRUE iff the address of OP is value-dependent.
6140 14.6.2.4 [temp.dep.temp]:
6141 A non-integral non-type template-argument is dependent if its type is
6142 dependent or it has either of the following forms
6143 qualified-id
6144 & qualified-id
6145 and contains a nested-name-specifier which specifies a class-name that
6146 names a dependent type.
6148 We generalize this to just say that the address of a member of a
6149 dependent class is value-dependent; the above doesn't cover the
6150 address of a static data member named with an unqualified-id. */
6152 static bool
6154 {
6155 /* We could use get_inner_reference here, but there's no need;
6156 this is only relevant for template non-type arguments, which
6157 can only be expressed as &id-expression. */
6159 {
6163 }
6166 }
6168 /* The next set of functions are used for providing helpful explanatory
6169 diagnostics for failed overload resolution. Their messages should be
6170 indented by two spaces for consistency with the messages in
6171 call.c */
6173 static int
6175 {
6177 }
6179 /* Other failure functions should call this one, to provide a single function
6180 for setting a breakpoint on. */
6182 static int
6184 {
6186 }
6188 static int
6190 {
6195 }
6197 static int
6199 {
6205 }
6207 static int
6209 {
6213 }
6215 static int
6217 {
6220 " template parameter %qD is not a parameter pack, but "
6224 }
6226 static int
6228 {
6231 " template argument %qE does not match "
6235 }
6237 static int
6239 {
6243 }
6245 static int
6247 {
6253 }
6255 static int
6257 {
6259 {
6264 else
6266 " deduced conflicting values for non-type parameter "
6268 }
6270 }
6272 static int
6274 {
6277 " variable-sized array type %qT is not "
6279 arg);
6281 }
6283 static int
6285 {
6289 arg);
6291 }
6293 static int
6295 {
6297 {
6303 else
6308 }
6310 }
6312 static int
6314 {
6316 }
6318 static int
6321 {
6323 }
6325 static int
6328 {
6334 }
6336 static int
6339 {
6342 {
6350 }
6352 }
6354 static int
6356 {
6359 " template parameters of a template template argument are "
6362 }
6364 static int
6366 {
6372 }
6374 static int
6376 {
6381 }
6383 /* Attempt to convert the non-type template parameter EXPR to the
6384 indicated TYPE. If the conversion is successful, return the
6385 converted value. If the conversion is unsuccessful, return
6386 NULL_TREE if we issued an error message, or error_mark_node if we
6387 did not. We issue error messages for out-and-out bad template
6388 parameters, but not simply because the conversion failed, since we
6389 might be just trying to do argument deduction. Both TYPE and EXPR
6390 must be non-dependent.
6392 The conversion follows the special rules described in
6393 [temp.arg.nontype], and it is much more strict than an implicit
6394 conversion.
6396 This function is called twice for each template argument (see
6397 lookup_template_class for a more accurate description of this
6398 problem). This means that we need to handle expressions which
6399 are not valid in a C++ source, but can be created from the
6400 first call (for instance, casts to perform conversions). These
6401 hacks can go away after we fix the double coercion problem. */
6403 static tree
6405 {
6406 tree expr_type;
6410 /* Detect immediately string literals as invalid non-type argument.
6411 This special-case is not needed for correctness (we would easily
6412 catch this later), but only to provide better diagnostic for this
6413 common user mistake. As suggested by DR 100, we do not mention
6414 linkage issues in the diagnostic as this is not the point. */
6415 /* FIXME we're making this OK. */
6417 {
6423 }
6425 /* Add the ADDR_EXPR now for the benefit of
6426 value_dependent_expression_p. */
6429 {
6433 }
6435 /* If we are in a template, EXPR may be non-dependent, but still
6436 have a syntactic, rather than semantic, form. For example, EXPR
6437 might be a SCOPE_REF, rather than the VAR_DECL to which the
6438 SCOPE_REF refers. Preserving the qualifying scope is necessary
6439 so that access checking can be performed when the template is
6440 instantiated -- but here we need the resolved form so that we can
6441 convert the argument. */
6453 /* If the argument is non-dependent, perform any conversions in
6454 non-dependent context as well. */
6462 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6463 to a non-type argument of "nullptr". */
6467 /* In C++11, integral or enumeration non-type template arguments can be
6468 arbitrary constant expressions. Pointer and pointer to
6469 member arguments can be general constant expressions that evaluate
6470 to a null value, but otherwise still need to be of a specific form. */
6472 {
6474 /* A PTRMEM_CST is already constant, and a valid template
6475 argument for a parameter of pointer to member type, we just want
6476 to leave it in that form rather than lower it to a
6480 {
6481 /* C++17: A template-argument for a non-type template-parameter shall
6482 be a converted constant expression (8.20) of the type of the
6483 template-parameter. */
6489 }
6491 {
6496 }
6497 }
6501 else
6504 /* HACK: Due to double coercion, we can get a
6505 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6506 which is the tree that we built on the first call (see
6507 below when coercing to reference to object or to reference to
6508 function). We just strip everything and get to the arg.
6509 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6510 for examples. */
6512 {
6518 {
6519 /* ??? Maybe we could use convert_from_reference here, but we
6520 would need to relax its constraints because the NOP_EXPR
6521 could actually change the type to something more cv-qualified,
6522 and this is not folded by convert_from_reference. */
6527 && (same_type_ignoring_top_level_qualifiers_p
6530 {
6533 }
6534 }
6535 }
6537 /* [temp.arg.nontype]/5, bullet 1
6539 For a non-type template-parameter of integral or enumeration type,
6540 integral promotions (_conv.prom_) and integral conversions
6541 (_conv.integral_) are applied. */
6543 {
6545 {
6550 }
6555 /* Notice that there are constant expressions like '4 % 0' which
6556 do not fold into integer constants. */
6559 {
6561 {
6565 else
6571 /* else cxx_constant_value complained but gave us
6572 a real constant, so go ahead. */
6574 }
6575 else
6577 }
6579 /* Avoid typedef problems. */
6582 }
6583 /* [temp.arg.nontype]/5, bullet 2
6585 For a non-type template-parameter of type pointer to object,
6586 qualification conversions (_conv.qual_) and the array-to-pointer
6587 conversion (_conv.array_) are applied. */
6589 {
6592 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6593 decay_conversion or an explicit cast. If it's a problematic cast,
6594 we'll complain about it below. */
6596 {
6601 {
6604 }
6605 }
6607 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6609 A template-argument for a non-type, non-template template-parameter
6610 shall be one of: [...]
6612 -- the name of a non-type template-parameter;
6613 -- the address of an object or function with external linkage, [...]
6614 expressed as "& id-expression" where the & is optional if the name
6615 refers to a function or array, or if the corresponding
6616 template-parameter is a reference.
6618 Here, we do not care about functions, as they are invalid anyway
6619 for a parameter of type pointer-to-object. */
6622 /* Non-type template parameters are OK. */
6623 ;
6627 {
6629 {
6632 "because %qD is a variable, not the address of "
6635 }
6637 {
6643 }
6644 /* Other values, like integer constants, might be valid
6645 non-type arguments of some other type. */
6647 }
6648 else
6649 {
6653 {
6658 }
6660 {
6666 }
6669 {
6674 }
6675 /* C++17: For a non-type template-parameter of reference or pointer
6676 type, the value of the constant expression shall not refer to (or
6677 for a pointer type, shall not be the address of):
6678 * a subobject (4.5),
6679 * a temporary object (15.2),
6680 * a string literal (5.13.5),
6681 * the result of a typeid expression (8.2.8), or
6682 * a predefined __func__ variable (11.4.1). */
6684 {
6687 decl);
6689 }
6693 {
6698 }
6700 {
6704 decl);
6706 }
6707 }
6714 }
6715 /* [temp.arg.nontype]/5, bullet 3
6717 For a non-type template-parameter of type reference to object, no
6718 conversions apply. The type referred to by the reference may be more
6719 cv-qualified than the (otherwise identical) type of the
6720 template-argument. The template-parameter is bound directly to the
6721 template-argument, which must be an lvalue. */
6723 {
6725 expr_type))
6729 {
6734 }
6737 {
6742 }
6744 /* [temp.arg.nontype]/1
6746 A template-argument for a non-type, non-template template-parameter
6747 shall be one of: [...]
6749 -- the address of an object or function with external linkage. */
6752 {
6755 {
6758 "because a reference variable does not have a constant "
6761 }
6762 }
6766 /* OK, dependent reference. We don't want to ask whether a DECL is
6768 else
6769 {
6771 {
6777 }
6779 /* DR 1155 allows internal linkage in C++11 and up. */
6782 {
6788 }
6791 }
6795 }
6796 /* [temp.arg.nontype]/5, bullet 4
6798 For a non-type template-parameter of type pointer to function, only
6799 the function-to-pointer conversion (_conv.func_) is applied. If the
6800 template-argument represents a set of overloaded functions (or a
6801 pointer to such), the matching function is selected from the set
6802 (_over.over_). */
6804 {
6805 /* If the argument is a template-id, we might not have enough
6806 context information to decay the pointer. */
6808 {
6812 }
6815 /* Null pointer values are OK in C++11. */
6821 }
6822 /* [temp.arg.nontype]/5, bullet 5
6824 For a non-type template-parameter of type reference to function, no
6825 conversions apply. If the template-argument represents a set of
6826 overloaded functions, the matching function is selected from the set
6827 (_over.over_). */
6829 {
6831 {
6833 {
6838 }
6840 }
6845 }
6846 /* [temp.arg.nontype]/5, bullet 6
6848 For a non-type template-parameter of type pointer to member function,
6849 no conversions apply. If the template-argument represents a set of
6850 overloaded member functions, the matching member function is selected
6851 from the set (_over.over_). */
6853 {
6858 /* [temp.arg.nontype] bullet 1 says the pointer to member
6859 expression must be a pointer-to-member constant. */
6864 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
6865 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
6868 }
6869 /* [temp.arg.nontype]/5, bullet 7
6871 For a non-type template-parameter of type pointer to data member,
6872 qualification conversions (_conv.qual_) are applied. */
6874 {
6875 /* [temp.arg.nontype] bullet 1 says the pointer to member
6876 expression must be a pointer-to-member constant. */
6884 }
6886 {
6888 {
6893 }
6895 }
6896 /* A template non-type parameter must be one of the above. */
6897 else
6900 /* Sanity check: did we actually convert the argument to the
6901 right type? */
6905 }
6907 /* Subroutine of coerce_template_template_parms, which returns 1 if
6908 PARM_PARM and ARG_PARM match using the rule for the template
6909 parameters of template template parameters. Both PARM and ARG are
6910 template parameters; the rest of the arguments are the same as for
6911 coerce_template_template_parms.
6912 */
6913 static int
6915 tree arg,
6916 tsubst_flags_t complain,
6917 tree in_decl,
6918 tree outer_args)
6919 {
6928 {
6930 /* We encounter instantiations of templates like
6931 template <template <template <class> class> class TT>
6932 class C; */
6933 {
6940 }
6941 /* Fall through. */
6946 /* Argument is a parameter pack but parameter is not. */
6951 /* The tsubst call is used to handle cases such as
6953 template <int> class C {};
6954 template <class T, template <T> class TT> class D {};
6955 D<int, C> d;
6957 i.e. the parameter list of TT depends on earlier parameters. */
6959 {
6964 }
6968 /* Argument is a parameter pack but parameter is not. */
6975 }
6978 }
6980 /* Coerce template argument list ARGLIST for use with template
6981 template-parameter TEMPL. */
6983 static tree
6985 tsubst_flags_t complain)
6986 {
6987 /* Consider an example where a template template parameter declared as
6989 template <class T, class U = std::allocator<T> > class TT
6991 The template parameter level of T and U are one level larger than
6992 of TT. To proper process the default argument of U, say when an
6993 instantiation `TT<int>' is seen, we need to build the full
6994 arguments containing {int} as the innermost level. Outer levels,
6995 available when not appearing as default template argument, can be
6996 obtained from the arguments of the enclosing template.
6998 Suppose that TT is later substituted with std::vector. The above
6999 instantiation is `TT<int, std::allocator<T> >' with TT at
7000 level 1, and T at level 2, while the template arguments at level 1
7001 becomes {std::vector} and the inner level 2 is {int}. */
7005 {
7007 /* We want arguments for the partial specialization, not arguments for
7008 the primary template. */
7010 else
7012 }
7014 {
7015 /* This is an argument of the current template, so we haven't set
7016 DECL_CONTEXT yet. */
7017 tree relevant_template_parms;
7019 /* Parameter levels that are greater than the level of the given
7020 template template parm are irrelevant. */
7027 }
7034 complain,
7037 }
7039 /* A cache of template template parameters with match-all default
7040 arguments. */
7042 static void
7044 {
7048 }
7049 static tree
7051 {
7056 }
7058 /* T is a bound template template-parameter. Copy its arguments into default
7059 arguments of the template template-parameter's template parameters. */
7061 static tree
7063 {
7086 {
7089 {
7092 }
7093 }
7097 }
7099 /* ARG is a bound potential template template-argument, and PARGS is a list
7100 of arguments for the corresponding template template-parameter. Adjust
7101 PARGS as appropriate for application to ARG's template, and if ARG is a
7102 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7103 arguments to the template template parameter. */
7105 static tree
7107 {
7111 {
7112 /* When comparing two template template-parameters in partial ordering,
7113 rewrite the one currently being used as an argument to have default
7114 arguments for all parameters. */
7120 }
7121 else
7122 {
7123 tree aparms
7128 }
7131 }
7133 /* Subroutine of unify for the case when PARM is a
7134 BOUND_TEMPLATE_TEMPLATE_PARM. */
7136 static int
7139 {
7143 /* The template template parm might be variadic and the argument
7144 not, so flatten both argument lists. */
7149 {
7150 /* In keeping with P0522R0, adjust P's template arguments
7151 to apply to A's template; then flatten it again. */
7160 /* If the P0522 adjustment eliminated a pack expansion, deduce
7161 empty packs. */
7167 }
7168 else
7169 {
7170 /* Deduce arguments T, i from TT<T> or TT<i>.
7171 We check each element of PARMVEC and ARGVEC individually
7172 rather than the whole TREE_VEC since they can have
7173 different number of elements, which is allowed under N2555. */
7177 /* Check if the parameters end in a pack, making them
7178 variadic. */
7185 /* If the template argument list of P contains a pack
7186 expansion that is not the last template argument, the
7187 entire template argument list is a non-deduced
7188 context. */
7206 DEDUCE_EXACT,
7209 }
7212 }
7214 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7215 template template parameters. Both PARM_PARMS and ARG_PARMS are
7216 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7217 or PARM_DECL.
7219 Consider the example:
7220 template <class T> class A;
7221 template<template <class U> class TT> class B;
7223 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7224 the parameters to A, and OUTER_ARGS contains A. */
7226 static int
7228 tree arg_parms,
7229 tsubst_flags_t complain,
7230 tree in_decl,
7231 tree outer_args)
7232 {
7244 {
7245 /* P0522R0: A template template-parameter P is at least as specialized as
7246 a template template-argument A if, given the following rewrite to two
7247 function templates, the function template corresponding to P is at
7248 least as specialized as the function template corresponding to A
7249 according to the partial ordering rules for function templates
7250 ([temp.func.order]). Given an invented class template X with the
7251 template parameter list of A (including default arguments):
7253 * Each of the two function templates has the same template parameters,
7254 respectively, as P or A.
7256 * Each function template has a single function parameter whose type is
7257 a specialization of X with template arguments corresponding to the
7258 template parameters from the respective function template where, for
7259 each template parameter PP in the template parameter list of the
7260 function template, a corresponding template argument AA is formed. If
7261 PP declares a parameter pack, then AA is the pack expansion
7262 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7264 If the rewrite produces an invalid type, then P is not at least as
7265 specialized as A. */
7267 /* So coerce P's args to apply to A's parms, and then deduce between A's
7268 args and the converted args. If that succeeds, A is at least as
7269 specialized as P, so they match.*/
7276 {
7282 }
7283 }
7285 /* Determine whether we have a parameter pack at the end of the
7286 template template parameter's template parameter list. */
7288 {
7295 {
7309 }
7310 }
7316 /* Check all of the template parameters except the parameter pack at
7317 the end (if any). */
7319 {
7328 outer_args))
7331 }
7334 {
7335 /* Check each of the template parameters in the template
7336 argument against the template parameter pack at the end of
7337 the template template parameter. */
7344 {
7351 outer_args))
7353 }
7354 }
7357 }
7359 /* Verifies that the deduced template arguments (in TARGS) for the
7360 template template parameters (in TPARMS) represent valid bindings,
7361 by comparing the template parameter list of each template argument
7362 to the template parameter list of its corresponding template
7363 template parameter, in accordance with DR150. This
7364 routine can only be called after all template arguments have been
7365 deduced. It will return TRUE if all of the template template
7366 parameter bindings are okay, FALSE otherwise. */
7367 bool
7369 {
7373 /* We're dealing with template parms in this process. */
7379 {
7384 {
7389 {
7390 /* Look inside the argument pack. */
7393 }
7396 {
7400 /* Extract the next argument from the argument
7401 pack. */
7405 /* Look at the pattern of the pack expansion. */
7408 /* Extract the template parameters from the template
7409 argument. */
7415 /* Verify that we can coerce the template template
7416 parameters from the template argument to the template
7417 parameter. This requires an exact match. */
7419 && !coerce_template_template_parms
7421 targ_parms,
7422 tf_none,
7423 tparm,
7424 targs))
7425 {
7428 }
7429 }
7430 }
7431 }
7433 out:
7437 }
7439 /* Since type attributes aren't mangled, we need to strip them from
7440 template type arguments. */
7442 static tree
7444 {
7454 }
7456 /* And from inside dependent non-type arguments like sizeof(Type). */
7458 static tree
7460 {
7470 }
7472 // A template declaration can be substituted for a constrained
7473 // template template parameter only when the argument is more
7474 // constrained than the parameter.
7475 static bool
7477 {
7480 /* For now, allow constrained template template arguments
7481 and unconstrained template template parameters. */
7487 // If the template parameter is constrained, we need to rewrite its
7488 // constraints in terms of the ARG's template parameters. This ensures
7489 // that all of the template parameter types will have the same depth.
7490 //
7491 // Note that this is only valid when coerce_template_template_parm is
7492 // true for the innermost template parameters of PARM and ARG. In other
7493 // words, because coercion is successful, this conversion will be valid.
7495 {
7502 }
7505 }
7507 // Convert a placeholder argument into a binding to the original
7508 // parameter. The original parameter is saved as the TREE_TYPE of
7509 // ARG.
7512 {
7515 }
7517 /* Convert the indicated template ARG as necessary to match the
7518 indicated template PARM. Returns the converted ARG, or
7519 error_mark_node if the conversion was unsuccessful. Error and
7520 warning messages are issued under control of COMPLAIN. This
7521 conversion is for the Ith parameter in the parameter list. ARGS is
7522 the full set of template arguments deduced so far. */
7524 static tree
7526 tree arg,
7527 tree args,
7528 tsubst_flags_t complain,
7530 tree in_decl)
7531 {
7532 tree orig_arg;
7533 tree val;
7539 /* Trivially convert placeholders. */
7548 {
7549 /* The template argument was the name of some
7550 member function. That's usually
7551 invalid, but static members are OK. In any
7552 case, grab the underlying fields/functions
7553 and issue an error later if required. */
7556 }
7564 /* When determining whether an argument pack expansion is a template,
7565 look at the pattern. */
7569 /* Deal with an injected-class-name used as a template template arg. */
7571 {
7574 {
7584 }
7585 }
7587 is_tmpl_type =
7603 {
7605 {
7609 }
7612 "to refer to a type member of a template parameter, "
7617 typename_type,
7618 complain);
7621 }
7623 {
7625 {
7627 {
7639 else
7642 }
7643 }
7645 }
7647 {
7649 {
7656 else
7659 }
7661 }
7664 /* We already did the appropriate conversion when packing args. */
7667 {
7669 {
7671 /* The number of argument required is not known yet.
7672 Just accept it for now. */
7674 else
7675 {
7677 tree argparm;
7679 /* Strip alias templates that are equivalent to another
7680 template. */
7686 args))
7687 {
7690 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7691 TEMPLATE_DECL. */
7693 {
7698 }
7699 }
7700 else
7701 {
7703 {
7710 }
7713 }
7715 // Check that the constraints are compatible before allowing the
7716 // substitution.
7719 {
7721 {
7727 }
7729 }
7730 }
7731 }
7732 else
7734 /* We only form one instance of each template specialization.
7735 Therefore, if we use a non-canonical variant (i.e., a
7736 typedef), any future messages referring to the type will use
7737 the typedef, which is confusing if those future uses do not
7738 themselves also use the typedef. */
7741 }
7742 else
7743 {
7747 {
7751 }
7752 else
7760 /* We used to call digest_init here. However, digest_init
7761 will report errors, which we don't want when complain
7762 is zero. More importantly, digest_init will try too
7763 hard to convert things: for example, `0' should not be
7764 converted to pointer type at this point according to
7765 the standard. Accepting this is not merely an
7766 extension, since deciding whether or not these
7767 conversions can occur is part of determining which
7768 function template to call, or whether a given explicit
7769 argument specification is valid. */
7771 else
7781 {
7782 /* Reject template arguments that are references to built-in
7783 functions with no library fallbacks. */
7792 }
7795 {
7796 /* Strip typedefs from the SCOPE_REF. */
7799 complain);
7802 }
7803 }
7806 }
7808 /* Coerces the remaining template arguments in INNER_ARGS (from
7809 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7810 Returns the coerced argument pack. PARM_IDX is the position of this
7811 parameter in the template parameter list. ARGS is the original
7812 template argument list. */
7813 static tree
7816 tree args,
7817 tree inner_args,
7819 tree new_args,
7821 tree in_decl,
7822 tsubst_flags_t complain)
7823 {
7826 tree packed_args;
7827 tree argument_pack;
7834 {
7835 /* When the template parameter is a non-type template parameter pack
7836 or template template parameter pack whose type or template
7837 parameters use parameter packs, we know exactly how many arguments
7838 we are looking for. Build a vector of the instantiated decls for
7839 these template parameters in PACKED_PARMS. */
7840 /* We can't use make_pack_expansion here because it would interpret a
7841 _DECL as a use rather than a declaration. */
7855 /* If we're doing a partial instantiation of a member template,
7856 verify that all of the types used for the non-type
7857 template parameter pack are, in fact, valid for non-type
7858 template parameters. */
7861 {
7864 {
7868 }
7869 /* We don't know how many args we have yet, just
7870 use the unconverted ones for now. */
7872 }
7875 }
7876 /* Check if we have a placeholder pack, which indicates we're
7877 in the context of a introduction list. In that case we want
7878 to match this pack to the single placeholder. */
7882 {
7885 }
7886 else
7889 /* Convert the remaining arguments, which will be a part of the
7890 parameter pack "parm". */
7893 {
7899 {
7900 /* Once we've packed as many args as we have types, stop. */
7904 /* We don't know how many args we have yet, just
7905 use the unconverted ones for now. */
7907 else
7909 }
7912 {
7915 }
7916 else
7919 in_decl);
7923 }
7927 {
7932 }
7937 else
7938 {
7941 }
7948 }
7950 /* Returns the number of pack expansions in the template argument vector
7951 ARGS. */
7953 static int
7955 {
7960 {
7964 }
7966 }
7968 /* Convert all template arguments to their appropriate types, and
7969 return a vector containing the innermost resulting template
7970 arguments. If any error occurs, return error_mark_node. Error and
7971 warning messages are issued under control of COMPLAIN.
7973 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7974 for arguments not specified in ARGS. Otherwise, if
7975 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7976 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7977 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7978 ARGS. */
7980 static tree
7982 tree args,
7983 tree in_decl,
7984 tsubst_flags_t complain,
7987 {
7989 tree orig_inner_args;
7990 tree inner_args;
7991 tree new_args;
7992 tree new_inner_args;
7996 /* When used as a boolean value, indicates whether this is a
7997 variadic template parameter list. Since it's an int, we can also
7998 subtract it from nparms to get the number of non-variadic
7999 parameters. */
8004 /* Likewise for parameters with default arguments. */
8012 /* Determine if there are any parameter packs or default arguments. */
8014 {
8022 }
8025 /* If there are no parameters that follow a parameter pack, we need to
8026 expand any argument packs so that we can deduce a parameter pack from
8027 some non-packed args followed by an argument pack, as in variadic85.C.
8028 If there are such parameters, we need to leave argument packs intact
8029 so the arguments are assigned properly. This can happen when dealing
8030 with a nested class inside a partial specialization of a class
8031 template, as in variadic92.C, or when deducing a template parameter pack
8032 from a sub-declarator, as in variadic114.C. */
8036 /* Count any pack expansion args. */
8042 && require_all_args
8043 && !variadic_args_p
8044 && (!use_default_args
8047 {
8049 {
8051 {
8055 }
8056 else
8063 }
8066 }
8067 /* We can't pass a pack expansion to a non-pack parameter of an alias
8068 template (DR 1430). */
8072 && variadic_args_p
8074 {
8076 {
8078 {
8084 {
8087 "pack expansion argument for non-pack parameter "
8089 else
8091 "pack expansion argument for non-pack parameter "
8095 }
8096 }
8098 found:;
8099 }
8101 }
8103 /* We need to evaluate the template arguments, even though this
8104 template-id may be nested within a "sizeof". */
8113 {
8114 tree arg;
8115 tree parm;
8117 /* Get the Ith template parameter. */
8121 {
8124 }
8126 /* Calculate the next argument. */
8129 else
8134 {
8135 /* Some arguments will be placed in the
8136 template parameter pack PARM. */
8143 {
8144 /* We don't know how many args we have yet, just use the
8145 unconverted (and still packed) ones for now. */
8149 }
8153 /* Store this argument. */
8155 {
8156 lost++;
8157 /* We are done with all of the arguments. */
8159 }
8160 else
8161 {
8164 }
8167 }
8169 {
8171 {
8172 /* "If every valid specialization of a variadic template
8173 requires an empty template parameter pack, the template is
8174 ill-formed, no diagnostic required." So check that the
8175 pattern works with this parameter. */
8180 in_decl);
8182 {
8187 }
8189 /* Recover from missing typename. */
8193 /* We don't know how many args we have yet, just
8194 use the unconverted ones for now. */
8198 }
8199 }
8201 {
8202 /* There must be a default arg in this case. */
8205 /* The position of the first default template argument,
8206 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8207 Record that. */
8211 }
8212 else
8216 {
8219 }
8221 /* This only occurs if there was an error in the template
8222 parameter list itself (which we would already have
8223 reported) that we are trying to recover from, e.g., a class
8224 template with a parameter list such as
8225 template<typename..., typename>. */
8227 else
8233 lost++;
8235 }
8240 {
8242 {
8247 }
8249 }
8259 }
8261 /* Convert all template arguments to their appropriate types, and
8262 return a vector containing the innermost resulting template
8263 arguments. If any error occurs, return error_mark_node. Error and
8264 warning messages are not issued.
8266 Note that no function argument deduction is performed, and default
8267 arguments are used to fill in unspecified arguments. */
8268 tree
8270 {
8272 }
8274 /* Convert all template arguments to their appropriate type, and
8275 instantiate default arguments as needed. This returns a vector
8276 containing the innermost resulting template arguments, or
8277 error_mark_node if unsuccessful. */
8278 tree
8280 tsubst_flags_t complain)
8281 {
8283 }
8285 /* Like coerce_template_parms. If PARMS represents all template
8286 parameters levels, this function returns a vector of vectors
8287 representing all the resulting argument levels. Note that in this
8288 case, only the innermost arguments are coerced because the
8289 outermost ones are supposed to have been coerced already.
8291 Otherwise, if PARMS represents only (the innermost) vector of
8292 parameters, this function returns a vector containing just the
8293 innermost resulting arguments. */
8295 static tree
8297 tree args,
8298 tree in_decl,
8299 tsubst_flags_t complain,
8302 {
8305 tree coerced_args;
8308 {
8310 tree level;
8316 {
8317 tree l;
8321 require_all_args,
8322 use_default_args);
8323 else
8330 }
8331 }
8332 else
8335 require_all_args,
8336 use_default_args);
8338 }
8340 /* Returns 1 if template args OT and NT are equivalent. */
8342 int
8344 {
8353 /* For member templates */
8362 {
8379 }
8383 {
8386 /* Don't treat an alias template specialization with dependent
8387 arguments as equivalent to its underlying type when used as a
8388 template argument; we need them to be distinct so that we
8389 substitute into the specialization arguments at instantiation
8390 time. And aliases can't be equivalent without being ==, so
8391 we don't need to look any deeper.
8393 During partial ordering, however, we need to treat them normally so
8394 that we can order uses of the same alias with different
8395 cv-qualification (79960). */
8399 else
8401 }
8404 else
8405 {
8406 /* Try to treat a template non-type argument that has been converted
8407 to the parameter type as equivalent to one that hasn't yet. */
8420 }
8421 }
8423 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8424 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8425 NEWARG_PTR with the offending arguments if they are non-NULL. */
8427 int
8431 {
8444 {
8449 {
8455 }
8456 }
8458 }
8462 {
8464 }
8466 static void
8468 {
8478 /* We are called both from instantiate_decl, where we've already had a
8479 tinst_level pushed, and instantiate_template, where we haven't.
8480 Compensate. */
8491 else
8500 }
8503 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
8504 ARGLIST. Valid choices for FNS are given in the cp-tree.def
8505 documentation for TEMPLATE_ID_EXPR. */
8507 tree
8509 {
8510 tree type;
8518 {
8521 }
8524 {
8526 unknown_type_node,
8528 arglist);
8530 }
8537 }
8539 /* Within the scope of a template class S<T>, the name S gets bound
8540 (in build_self_reference) to a TYPE_DECL for the class, not a
8541 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
8542 or one of its enclosing classes, and that type is a template,
8543 return the associated TEMPLATE_DECL. Otherwise, the original
8544 DECL is returned.
8546 Also handle the case when DECL is a TREE_LIST of ambiguous
8547 injected-class-names from different bases. */
8549 tree
8551 {
8555 /* DR 176: A lookup that finds an injected-class-name (10.2
8556 [class.member.lookup]) can result in an ambiguity in certain cases
8557 (for example, if it is found in more than one base class). If all of
8558 the injected-class-names that are found refer to specializations of
8559 the same class template, and if the name is followed by a
8560 template-argument-list, the reference refers to the class template
8561 itself and not a specialization thereof, and is not ambiguous. */
8563 {
8566 {
8572 }
8575 else
8577 }
8583 }
8585 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
8586 parameters, find the desired type.
8588 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
8590 IN_DECL, if non-NULL, is the template declaration we are trying to
8591 instantiate.
8593 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
8594 the class we are looking up.
8596 Issue error and warning messages under control of COMPLAIN.
8598 If the template class is really a local class in a template
8599 function, then the FUNCTION_CONTEXT is the function in which it is
8600 being instantiated.
8602 ??? Note that this function is currently called *twice* for each
8603 template-id: the first time from the parser, while creating the
8604 incomplete type (finish_template_type), and the second type during the
8605 real instantiation (instantiate_template_class). This is surely something
8606 that we want to avoid. It also causes some problems with argument
8607 coercion (see convert_nontype_argument for more information on this). */
8609 static tree
8612 {
8614 tree t;
8617 spec_entry elt;
8618 hashval_t hash;
8621 {
8625 else
8626 {
8633 }
8636 }
8638 {
8641 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8642 an implicit typename for the second A. Deal with it. */
8647 {
8650 }
8651 }
8654 {
8657 }
8659 {
8663 }
8665 {
8668 }
8670 /* Issue an error message if we didn't find a template. */
8672 {
8676 }
8679 /* Make sure it's a user visible template, if it was named by
8680 the user. */
8683 {
8685 {
8689 }
8691 }
8695 /* An alias that just changes the name of a template is equivalent to the
8696 other template, so if any of the arguments are pack expansions, strip
8697 the alias to avoid problems with a pack expansion passed to a non-pack
8698 alias template parameter (DR 1430). */
8703 {
8704 tree parm;
8713 }
8714 else
8715 {
8717 tree gen_tmpl;
8718 tree type_decl;
8726 /* An error occurred while building the template TEMPL, and a
8727 diagnostic has most certainly been emitted for that
8728 already. Let's propagate that error. */
8737 {
8738 /* We've been given an incomplete set of template arguments.
8739 For example, given:
8741 template <class T> struct S1 {
8742 template <class U> struct S2 {};
8743 template <class U> struct S2<U*> {};
8744 };
8746 we will be called with an ARGLIST of `U*', but the
8747 TEMPLATE will be `template <class T> template
8748 <class U> struct S1<T>::S2'. We must fill in the missing
8749 arguments. */
8753 }
8755 /* Now we should have enough arguments. */
8758 /* From here on, we're only interested in the most general
8759 template. */
8761 /* Calculate the BOUND_ARGS. These will be the args that are
8762 actually tsubst'd into the definition to create the
8763 instantiation. */
8765 complain,
8770 /* We were unable to bind the arguments. */
8773 /* In the scope of a template class, explicit references to the
8774 template class refer to the type of the template, not any
8775 instantiation of it. For example, in:
8777 template <class T> class C { void f(C<T>); }
8779 the `C<T>' is just the same as `C'. Outside of the
8780 class, however, such a reference is an instantiation. */
8784 {
8789 }
8791 /* If we already have this specialization, return it. */
8801 /* If the the template's constraints are not satisfied,
8802 then we cannot form a valid type.
8804 Note that the check is deferred until after the hash
8805 lookup. This prevents redundant checks on previously
8806 instantiated specializations. */
8808 {
8810 {
8813 }
8815 }
8819 /* If the deduced arguments are invalid, then the binding
8820 failed. */
8824 complain))
8831 {
8836 }
8846 /* Create the type. */
8848 {
8849 /* The user referred to a specialization of an alias
8850 template represented by GEN_TMPL.
8852 [temp.alias]/2 says:
8854 When a template-id refers to the specialization of an
8855 alias template, it is equivalent to the associated
8856 type obtained by substitution of its
8857 template-arguments for the template-parameters in the
8858 type-id of the alias template. */
8861 /* Note that the call above (by indirectly calling
8862 register_specialization in tsubst_decl) registers the
8863 TYPE_DECL representing the specialization of the alias
8864 template. So next time someone substitutes ARGLIST for
8865 the template parms into the alias template (GEN_TMPL),
8866 she'll get that TYPE_DECL back. */
8870 }
8872 {
8874 {
8885 }
8886 else
8887 {
8888 /* We don't want to call start_enum for this type, since
8889 the values for the enumeration constants may involve
8890 template parameters. And, no one should be interested
8891 in the enumeration constants for such a type. */
8894 }
8898 }
8900 {
8906 /* A local class. Make sure the decl gets registered properly. */
8911 /* This instantiation is another name for the primary
8912 template type. Set the TYPE_CANONICAL field
8913 appropriately. */
8916 /* Some of the template arguments require structural
8917 equality testing, so this template class requires
8918 structural equality testing. */
8920 }
8921 else
8924 /* If we called start_enum or pushtag above, this information
8925 will already be set up. */
8927 {
8934 }
8935 else
8939 {
8945 {
8948 }
8949 }
8953 {
8957 {
8958 tree attributes
8966 }
8967 }
8969 /* Let's consider the explicit specialization of a member
8970 of a class template specialization that is implicitly instantiated,
8971 e.g.:
8972 template<class T>
8973 struct S
8974 {
8975 template<class U> struct M {}; //#0
8976 };
8978 template<>
8979 template<>
8980 struct S<int>::M<char> //#1
8981 {
8982 int i;
8983 };
8984 [temp.expl.spec]/4 says this is valid.
8986 In this case, when we write:
8987 S<int>::M<char> m;
8989 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8990 the one of #0.
8992 When we encounter #1, we want to store the partial instantiation
8993 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8995 For all cases other than this "explicit specialization of member of a
8996 class template", we just want to store the most general template into
8997 the CLASSTYPE_TI_TEMPLATE of M.
8999 This case of "explicit specialization of member of a class template"
9000 only happens when:
9001 1/ the enclosing class is an instantiation of, and therefore not
9002 the same as, the context of the most general template, and
9003 2/ we aren't looking at the partial instantiation itself, i.e.
9004 the innermost arguments are not the same as the innermost parms of
9005 the most general template.
9007 So it's only when 1/ and 2/ happens that we want to use the partial
9008 instantiation of the member template in lieu of its most general
9009 template. */
9013 /* the enclosing class must be an instantiation... */
9016 {
9020 tree partial_inst_args =
9027 use_partial_inst_tmpl =
9028 /*...and we must not be looking at the partial instantiation
9029 itself. */
9031 partial_inst_args);
9032 }
9035 /* This case is easy; there are no member templates involved. */
9037 else
9038 {
9039 /* This is a full instantiation of a member template. Find
9040 the partial instantiation of which this is an instance. */
9042 /* Temporarily reduce by one the number of levels in the ARGLIST
9043 so as to avoid comparing the last set of arguments. */
9047 /* FOUND is either a proper class type, or an alias
9048 template specialization. In the later case, it's a
9049 TYPE_DECL, resulting from the substituting of arguments
9050 for parameters in the TYPE_DECL of the alias template
9051 done earlier. So be careful while getting the template
9052 of FOUND. */
9054 ? found
9058 }
9060 // Build template info for the new specialization.
9069 /* Note this use of the partial instantiation so we can check it
9070 later in maybe_process_partial_specialization. */
9077 /* Now that the type has been registered on the instantiations
9078 list, we set up the enumerators. Because the enumeration
9079 constants may involve the enumeration type itself, we make
9080 sure to register the type first, and then create the
9081 constants. That way, doing tsubst_expr for the enumeration
9082 constants won't result in recursive calls here; we'll find
9083 the instantiation and exit above. */
9087 /* If the type makes use of template parameters, the
9088 code that generates debugging information will crash. */
9091 /* Possibly limit visibility based on template args. */
9098 }
9099 }
9101 /* Wrapper for lookup_template_class_1. */
9103 tree
9106 {
9107 tree ret;
9113 }
9115 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9117 tree
9119 {
9120 /* The type of the expression is NULL_TREE since the template-id could refer
9121 to an explicit or partial specialization. */
9124 /* Except that concepts are always bool. */
9127 }
9129 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9131 tree
9133 {
9137 /* We never want to return a VAR_DECL for a variable concept, since they
9138 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9153 {
9155 {
9158 }
9160 }
9162 /* If a template-id refers to a specialization of a variable
9163 concept, then the expression is true if and only if the
9164 concept's constraints are satisfied by the given template
9165 arguments.
9167 NOTE: This is an extension of Concepts Lite TS that
9168 allows constraints to be used in expressions. */
9170 {
9173 }
9176 }
9178 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9179 TARGS template args, and instantiate it if it's not dependent. */
9181 tree
9183 tsubst_flags_t complain)
9184 {
9187 {
9190 }
9193 }
9195 \f
9196 struct pair_fn_data
9197 {
9198 tree_fn_t fn;
9199 tree_fn_t any_fn;
9201 /* True when we should also visit template parameters that occur in
9202 non-deduced contexts. */
9205 };
9207 /* Called from for_each_template_parm via walk_tree. */
9209 static tree
9211 {
9218 #define WALK_SUBTREE(NODE) \
9219 do \
9220 { \
9221 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9222 pfd->include_nondeduced_p, \
9223 pfd->any_fn); \
9224 if (result) goto out; \
9225 } \
9226 while (0)
9236 {
9240 /* Fall through. */
9246 else
9256 /* Since we're not going to walk subtrees, we have to do this
9257 explicitly here. */
9259 /* Fall through. */
9262 /* Check the return type. */
9265 /* Check the parameter types. Since default arguments are not
9266 instantiated until they are needed, the TYPE_ARG_TYPES may
9267 contain expressions that involve template parameters. But,
9268 no-one should be looking at them yet. And, once they're
9269 instantiated, they don't contain template parameters, so
9270 there's no point in looking at them then, either. */
9271 {
9272 tree parm;
9277 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9278 want walk_tree walking into them itself. */
9280 }
9283 {
9287 }
9304 /* Fall through. */
9316 /* Record template parameters such as `T' inside `TT<T>'. */
9318 /* Fall through. */
9330 /* A template template parameter is encountered. */
9334 /* Already substituted template template parameter */
9339 /* A template-id in a TYPENAME_TYPE might be a deduced context after
9340 partial instantiation. */
9352 /* If there's no type, then this thing must be some expression
9353 involving template parameters. */
9375 }
9377 #undef WALK_SUBTREE
9379 /* We didn't find any template parameters we liked. */
9380 out:
9382 }
9384 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
9385 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
9386 call FN with the parameter and the DATA.
9387 If FN returns nonzero, the iteration is terminated, and
9388 for_each_template_parm returns 1. Otherwise, the iteration
9389 continues. If FN never returns a nonzero value, the value
9390 returned by for_each_template_parm is 0. If FN is NULL, it is
9391 considered to be the function which always returns 1.
9393 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
9394 parameters that occur in non-deduced contexts. When false, only
9395 visits those template parameters that can be deduced. */
9397 static tree
9401 tree_fn_t any_fn)
9402 {
9404 tree result;
9406 /* Set up. */
9412 /* Walk the tree. (Conceptually, we would like to walk without
9413 duplicates, but for_each_template_parm_r recursively calls
9414 for_each_template_parm, so we would need to reorganize a fair
9415 bit to use walk_tree_without_duplicates, so we keep our own
9416 visited list.) */
9419 else
9422 for_each_template_parm_r,
9426 /* Clean up. */
9428 {
9431 }
9434 }
9436 /* Returns true if T depends on any template parameter. */
9438 int
9440 {
9470 else
9471 {
9474 }
9479 }
9481 /* Returns true iff current_function_decl is an incompletely instantiated
9482 template. Useful instead of processing_template_decl because the latter
9483 is set to 0 during instantiate_non_dependent_expr. */
9485 bool
9487 {
9496 }
9498 /* Returns true iff we are currently within a template other than a
9499 default-capturing generic lambda, so we don't need to worry about semantic
9500 processing. */
9502 bool
9504 {
9506 }
9508 /* Returns true if T depends on any template parameter with level LEVEL. */
9510 bool
9512 {
9515 }
9517 /* Returns true if the signature of DECL depends on any template parameter from
9518 its enclosing class. */
9520 bool
9522 {
9532 template_parm_outer_level,
9542 }
9544 /* Returns TRUE iff INST is an instantiation we don't need to do in an
9545 ill-formed translation unit, i.e. a variable or function that isn't
9546 usable in a constant expression. */
9550 {
9555 }
9557 /* Returns TRUE iff we should refuse to instantiate DECL because it's
9558 neglectable and instantiated from within an erroneous instantiation. */
9560 static bool
9562 {
9573 }
9581 /* We're starting to instantiate D; record the template instantiation context
9582 for diagnostics and to restore it later. */
9584 bool
9586 {
9588 }
9590 /* We're starting to instantiate D; record the template instantiation context
9591 at LOC for diagnostics and to restore it later. */
9593 bool
9595 {
9599 {
9600 /* Tell error.c not to try to instantiate any templates. */
9603 "template instantiation depth exceeds maximum of %d"
9605 max_tinst_depth);
9607 }
9609 /* If the current instantiation caused problems, don't let it instantiate
9610 anything else. Do allow deduction substitution and decls usable in
9611 constant expressions. */
9615 /* When not -quiet, dump template instantiations other than functions, since
9616 announce_function will take care of those. */
9635 }
9637 /* We're done instantiating this template; return to the instantiation
9638 context. */
9640 void
9642 {
9643 /* Restore the filename and line number stashed away when we started
9644 this instantiation. */
9648 }
9650 /* We're instantiating a deferred template; restore the template
9651 instantiation context in which the instantiation was requested, which
9652 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9654 static tree
9656 {
9668 }
9670 /* Returns the TINST_LEVEL which gives the original instantiation
9671 context. */
9675 {
9681 }
9683 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9684 vector of template arguments, as for tsubst.
9686 Returns an appropriate tsubst'd friend declaration. */
9688 static tree
9690 {
9691 tree new_friend;
9696 /* This was a friend declared with an explicit template
9697 argument list, e.g.:
9699 friend void f<>(T);
9701 to indicate that f was a template instantiation, not a new
9702 function declaration. Now, we have to figure out what
9703 instantiation of what template. */
9704 {
9706 tree new_args;
9707 tree tmpl;
9710 /* Friend functions are looked up in the containing namespace scope.
9711 We must enter that scope, to avoid finding member functions of the
9712 current class with same name. */
9727 tsk_none);
9729 }
9733 /* The NEW_FRIEND will look like an instantiation, to the
9734 compiler, but is not an instantiation from the point of view of
9735 the language. For example, we might have had:
9737 template <class T> struct S {
9738 template <class U> friend void f(T, U);
9739 };
9741 Then, in S<int>, template <class U> void f(int, U) is not an
9742 instantiation of anything. */
9748 {
9752 }
9754 /* The mangled name for the NEW_FRIEND is incorrect. The function
9755 is not a template instantiation and should not be mangled like
9756 one. Therefore, we forget the mangling here; we'll recompute it
9757 later if we need it. */
9759 {
9762 }
9765 {
9766 tree old_decl;
9767 tree new_friend_template_info;
9768 tree new_friend_result_template_info;
9769 tree ns;
9772 /* We must save some information from NEW_FRIEND before calling
9773 duplicate decls since that function will free NEW_FRIEND if
9774 possible. */
9776 new_friend_is_defn =
9781 {
9782 /* This declaration is a `primary' template. */
9785 new_friend_result_template_info
9787 }
9788 else
9791 /* Inside pushdecl_namespace_level, we will push into the
9792 current namespace. However, the friend function should go
9793 into the namespace of the template. */
9803 {
9804 /* This new friend declaration matched an existing
9805 declaration. For example, given:
9807 template <class T> void f(T);
9808 template <class U> class C {
9809 template <class T> friend void f(T) {}
9810 };
9812 the friend declaration actually provides the definition
9813 of `f', once C has been instantiated for some type. So,
9814 old_decl will be the out-of-class template declaration,
9815 while new_friend is the in-class definition.
9817 But, if `f' was called before this point, the
9818 instantiation of `f' will have DECL_TI_ARGS corresponding
9819 to `T' but not to `U', references to which might appear
9820 in the definition of `f'. Previously, the most general
9821 template for an instantiation of `f' was the out-of-class
9822 version; now it is the in-class version. Therefore, we
9823 run through all specialization of `f', adding to their
9824 DECL_TI_ARGS appropriately. In particular, they need a
9825 new set of outer arguments, corresponding to the
9826 arguments for this class instantiation.
9828 The same situation can arise with something like this:
9830 friend void f(int);
9831 template <class T> class C {
9832 friend void f(T) {}
9833 };
9835 when `C<int>' is instantiated. Now, `f(int)' is defined
9836 in the class. */
9839 /* On the other hand, if the in-class declaration does
9840 *not* provide a definition, then we don't want to alter
9841 existing definitions. We can just leave everything
9842 alone. */
9843 ;
9844 else
9845 {
9849 /* Overwrite whatever template info was there before, if
9850 any, with the new template information pertaining to
9851 the declaration. */
9855 {
9856 /* We should have called reregister_specialization in
9857 duplicate_decls. */
9862 /* Instantiate it if the global has already been used. */
9866 }
9867 else
9868 {
9869 tree t;
9871 /* Indicate that the old function template is a partial
9872 instantiation. */
9880 /* Reassign any specializations already in the hash table
9881 to the new more general template, and add the
9882 additional template args. */
9886 {
9888 spec_entry elt;
9900 register_specialization
9903 }
9905 }
9906 }
9908 /* The information from NEW_FRIEND has been merged into OLD_DECL
9909 by duplicate_decls. */
9911 }
9912 }
9913 else
9914 {
9918 /* In the code
9919 template <class T> class C {
9920 template <class U> friend void C1<U>::f (); // case 1
9921 friend void C2<T>::f (); // case 2
9922 };
9923 we only need to make sure CONTEXT is a complete type for
9924 case 2. To distinguish between the two cases, we note that
9925 CONTEXT of case 1 remains dependent type after tsubst while
9926 this isn't true for case 2. */
9936 {
9938 /* do_friend adds the TEMPLATE_DECL for any member friend
9939 template even if it isn't a member template, i.e.
9940 template <class T> friend A<T>::f();
9941 Look through it in that case. */
9945 /* Check to see that the declaration is really present, and,
9946 possibly obtain an improved declaration. */
9951 }
9952 }
9955 }
9957 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
9958 template arguments, as for tsubst.
9960 Returns an appropriate tsubst'd friend type or error_mark_node on
9961 failure. */
9963 static tree
9965 {
9966 tree friend_type;
9967 tree tmpl;
9968 tree context;
9971 {
9974 }
9979 {
9982 else
9984 }
9986 /* Look for a class template declaration. We look for hidden names
9987 because two friend declarations of the same template are the
9988 same. For example, in:
9990 struct A {
9991 template <typename> friend class F;
9992 };
9993 template <typename> struct B {
9994 template <typename> friend class F;
9995 };
9997 both F templates are the same. */
10001 /* But, if we don't find one, it might be because we're in a
10002 situation like this:
10004 template <class T>
10005 struct S {
10006 template <class U>
10007 friend struct S;
10008 };
10010 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
10011 for `S<int>', not the TEMPLATE_DECL. */
10013 {
10016 }
10019 {
10020 /* The friend template has already been declared. Just
10021 check to see that the declarations match, and install any new
10022 default parameters. We must tsubst the default parameters,
10023 of course. We only need the innermost template parameters
10024 because that is all that redeclare_class_template will look
10025 at. */
10028 {
10029 tree parms;
10030 location_t saved_input_location;
10040 }
10043 }
10044 else
10045 {
10046 /* The friend template has not already been declared. In this
10047 case, the instantiation of the template class will cause the
10048 injection of this template into the global scope. */
10053 /* The new TMPL is not an instantiation of anything, so we
10054 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
10055 the new type because that is supposed to be the corresponding
10056 template decl, i.e., TMPL. */
10063 /* Inject this template into the global scope. */
10065 }
10068 {
10071 else
10073 }
10076 }
10078 /* Returns zero if TYPE cannot be completed later due to circularity.
10079 Otherwise returns one. */
10081 static int
10083 {
10093 else
10095 }
10100 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10101 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10103 static tree
10106 {
10115 {
10122 clauses
10126 else
10128 }
10129 /* If the first attribute argument is an identifier, don't
10130 pass it through tsubst. Attributes like mode, format,
10131 cleanup and several target specific attributes expect it
10132 unmodified. */
10134 {
10135 tree chain
10140 }
10142 {
10143 /* An attribute pack expansion. */
10152 {
10156 }
10158 }
10159 else
10166 }
10168 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10169 unchanged or a new TREE_LIST chain. */
10171 static tree
10174 {
10179 {
10183 }
10187 {
10190 {
10193 {
10195 do
10200 }
10201 }
10203 }
10206 }
10208 /* Apply any attributes which had to be deferred until instantiation
10209 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10210 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10212 static void
10215 {
10217 tree t;
10224 {
10228 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10229 to our attributes parameter. */
10231 }
10232 else
10233 {
10235 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10236 lookup_template_class_1, and should be preserved. */
10240 }
10244 {
10248 }
10252 {
10257 {
10260 {
10264 do
10267 }
10268 else
10270 }
10273 }
10274 }
10276 /* Perform (or defer) access check for typedefs that were referenced
10277 from within the template TMPL code.
10278 This is a subroutine of instantiate_decl and instantiate_class_template.
10279 TMPL is the template to consider and TARGS is the list of arguments of
10280 that template. */
10282 static void
10284 {
10285 location_t saved_location;
10296 {
10308 /* Make access check error messages point to the location
10309 of the use of the typedef. */
10313 tf_warning_or_error);
10314 }
10316 }
10318 static tree
10320 {
10322 tree typedecl;
10323 tree pbinfo;
10324 tree base_list;
10326 tree fn_context;
10335 /* Figure out which template is being instantiated. */
10339 /* Determine what specialization of the original template to
10340 instantiate. */
10343 {
10346 }
10348 {
10349 /* This TYPE is actually an instantiation of a partial
10350 specialization. We replace the innermost set of ARGS with
10351 the arguments appropriate for substitution. For example,
10352 given:
10354 template <class T> struct S {};
10355 template <class T> struct S<T*> {};
10357 and supposing that we are instantiating S<int*>, ARGS will
10358 presently be {int*} -- but we need {int}. */
10361 }
10362 else
10363 {
10366 }
10368 /* If the template we're instantiating is incomplete, then clearly
10369 there's nothing we can do. */
10373 /* If we've recursively instantiated too many templates, stop. */
10377 /* Now we're really doing the instantiation. Mark the type as in
10378 the process of being defined. */
10381 /* We may be in the middle of deferred access check. Disable
10382 it now. */
10389 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
10394 else
10395 {
10398 }
10399 /* Use #pragma pack from the template context. */
10405 /* Set the input location to the most specialized template definition.
10406 This is needed if tsubsting causes an error. */
10418 {
10421 /* Adjust visibility for template arguments. */
10423 }
10429 /* We should never instantiate a nested class before its enclosing
10430 class; we need to look up the nested class by name before we can
10431 instantiate it, and that lookup should instantiate the enclosing
10432 class. */
10438 {
10439 tree pbase_binfo;
10440 tree pushed_scope;
10443 /* We must enter the scope containing the type, as that is where
10444 the accessibility of types named in dependent bases are
10445 looked up from. */
10448 /* Substitute into each of the bases to determine the actual
10449 basetypes. */
10451 {
10452 tree base;
10458 {
10459 expanded_bases =
10466 }
10469 {
10471 /* Extract the already-expanded base class. */
10473 else
10474 /* Substitute to figure out the base class. */
10476 NULL_TREE);
10484 }
10485 }
10487 /* The list is now in reverse order; correct that. */
10492 }
10493 /* Now call xref_basetypes to set up all the base-class
10494 information. */
10502 /* Now that our base classes are set up, enter the scope of the
10503 class, so that name lookups into base classes, etc. will work
10504 correctly. This is precisely analogous to what we do in
10505 begin_class_definition when defining an ordinary non-template
10506 class, except we also need to push the enclosing classes. */
10509 /* Now members are processed in the order of declaration. */
10512 {
10516 {
10518 {
10519 /* Build new CLASSTYPE_NESTED_UTDS. */
10521 tree newtag;
10527 /* If the member is a class template, then -- even after
10528 substitution -- there may be dependent types in the
10529 template argument list for the class. We increment
10530 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
10531 that function will assume that no types are dependent
10532 when outside of a template. */
10542 {
10546 /* Unfortunately, lookup_template_class sets
10547 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
10548 instantiation (i.e., for the type of a member
10549 template class nested within a template class.)
10550 This behavior is required for
10551 maybe_process_partial_specialization to work
10552 correctly, but is not accurate in this case;
10553 the TAG is not an instantiation of anything.
10554 (The corresponding TEMPLATE_DECL is an
10555 instantiation, but the TYPE is not.) */
10558 /* Now, we call pushtag to put this NEWTAG into the scope of
10559 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
10560 pushtag calling push_template_decl. We don't have to do
10561 this for enums because it will already have been done in
10562 tsubst_enum. */
10566 }
10567 }
10569 {
10570 tree r;
10579 /* Instantiate members marked with attribute used. */
10585 }
10588 /* A closure type for a lambda in a default argument for a
10589 member template. Ignore it; it will be instantiated with
10591 else
10592 {
10593 /* Build new TYPE_FIELDS. */
10595 {
10596 tree condition;
10599 condition =
10609 }
10611 {
10612 tree r;
10616 /* The file and line for this declaration, to
10617 assist in error message reporting. Since we
10618 called push_tinst_level above, we don't need to
10619 restore these. */
10629 {
10630 /* A capture pack became multiple fields. */
10633 }
10636 {
10640 {
10641 /* In [temp.inst]:
10643 [t]he initialization (and any associated
10644 side-effects) of a static data member does
10645 not occur unless the static data member is
10646 itself used in a way that requires the
10647 definition of the static data member to
10648 exist.
10650 Therefore, we do not substitute into the
10651 initialized for the static data member here. */
10652 finish_static_data_member_decl
10658 /* Instantiate members marked with attribute used. */
10661 }
10663 {
10664 /* Determine whether R has a valid type and can be
10665 completed later. If R is invalid, then its type
10666 is replaced by error_mark_node. */
10672 {
10673 /* If R's type couldn't be completed and
10674 it isn't a flexible array member (whose
10675 type is incomplete by definition) give
10676 an error. */
10679 }
10680 }
10682 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
10683 such a thing will already have been added to the field
10684 list by tsubst_enum in finish_member_declaration in the
10685 CLASSTYPE_NESTED_UTDS case above. */
10689 {
10692 }
10693 }
10694 }
10695 }
10696 }
10697 else
10698 {
10701 {
10702 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10708 {
10709 /* template <class T> friend class C; */
10712 }
10714 {
10715 /* template <class T> friend class C::D; */
10721 }
10724 {
10725 /* This could be either
10727 friend class T::C;
10729 when dependent_type_p is false or
10731 template <class U> friend class T::C;
10733 otherwise. */
10734 /* Bump processing_template_decl in case this is something like
10735 template <class T> friend struct A<T>::B. */
10742 }
10746 {
10747 /* friend class C;
10749 where C hasn't been declared yet. Let's lookup name
10750 from namespace scope directly, bypassing any name that
10751 come from dependent base class. */
10754 /* The call to xref_tag_from_type does injection for friend
10755 classes. */
10757 friend_type =
10761 }
10763 /* friend class C<T>; */
10766 /* Otherwise it's
10768 friend class C;
10770 where C is already declared or
10772 friend class C<int>;
10774 We don't have to do anything in these cases. */
10777 /* Trick make_friend_class into realizing that the friend
10778 we're adding is a template, not an ordinary class. It's
10779 important that we use make_friend_class since it will
10780 perform some error-checking and output cross-reference
10781 information. */
10789 }
10790 else
10791 {
10792 /* Build new DECL_FRIENDLIST. */
10793 tree r;
10795 /* The file and line for this declaration, to
10796 assist in error message reporting. Since we
10797 called push_tinst_level above, we don't need to
10798 restore these. */
10802 {
10805 }
10810 {
10813 }
10814 }
10815 }
10816 }
10819 {
10820 /* Restore these before substituting into the lambda capture
10821 initializers. */
10824 }
10827 {
10830 {
10836 {
10837 /* Set function_depth to avoid garbage collection. */
10841 }
10843 /* We need to instantiate the capture list from the template
10844 after we've instantiated the closure members, but before we
10845 consider adding the conversion op. Also keep any captures
10846 that may have been added during instantiation of the op(). */
10848 tree tmpl_cap
10857 }
10858 else
10860 }
10862 /* Set the file and line number information to whatever is given for
10863 the class itself. This puts error messages involving generated
10864 implicit functions at a predictable point, and the same point
10865 that would be used for non-template classes. */
10872 /* We don't instantiate default arguments for member functions. 14.7.1:
10874 The implicit instantiation of a class template specialization causes
10875 the implicit instantiation of the declarations, but not of the
10876 definitions or default arguments, of the class member functions,
10877 member classes, static data members and member templates.... */
10879 /* Some typedefs referenced from within the template code need to be access
10880 checked at template instantiation time, i.e now. These types were
10881 added to the template at parsing time. Let's get those and perform
10882 the access checks then. */
10892 /* The vtable for a template class can be emitted in any translation
10893 unit in which the class is instantiated. When there is no key
10894 method, however, finish_struct_1 will already have added TYPE to
10895 the keyed_classes. */
10900 }
10902 /* Wrapper for instantiate_class_template_1. */
10904 tree
10906 {
10907 tree ret;
10912 }
10914 static tree
10916 {
10917 tree r;
10923 else
10924 {
10931 }
10933 }
10935 /* Given a function parameter pack TMPL_PARM and some function parameters
10936 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10937 and set *SPEC_P to point at the next point in the list. */
10939 tree
10941 {
10942 /* Collect all of the extra "packed" parameters into an
10943 argument pack. */
10944 tree parmvec;
10954 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10960 /* Build the argument packs. */
10965 }
10967 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
10968 NONTYPE_ARGUMENT_PACK. */
10970 static tree
10972 {
10974 }
10976 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
10977 pack expansion with no extra args, 2 if it has extra args, or 0
10978 if it is not a pack expansion. */
10980 static int
10982 {
10988 /* A decl pack is itself an expansion. */
10995 }
10998 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11000 static tree
11002 {
11009 }
11011 /* This is a subroutine of tsubst_pack_expansion.
11013 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11014 mechanism to store the (non complete list of) arguments of the
11015 substitution and return a non substituted pack expansion, in order
11016 to wait for when we have enough arguments to really perform the
11017 substitution. */
11019 static bool
11023 {
11024 /* If one pack has an expansion and another pack has a normal
11025 argument or if one pack has an empty argument and an another
11026 one hasn't then tsubst_pack_expansion cannot perform the
11027 substitution and need to fall back on the
11028 PACK_EXPANSION_EXTRA mechanism. */
11036 {
11039 parm_pack;
11041 {
11046 /* We can't substitute a pack expansion with extra args into
11047 our pattern. */
11051 else
11053 }
11057 }
11059 }
11061 /* [temp.variadic]/6 says that:
11063 The instantiation of a pack expansion [...]
11064 produces a list E1,E2, ..., En, where N is the number of elements
11065 in the pack expansion parameters.
11067 This subroutine of tsubst_pack_expansion produces one of these Ei.
11069 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11070 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11071 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11072 INDEX is the index 'i' of the element Ei to produce. ARGS,
11073 COMPLAIN, and IN_DECL are the same parameters as for the
11074 tsubst_pack_expansion function.
11076 The function returns the resulting Ei upon successful completion,
11077 or error_mark_node.
11079 Note that this function possibly modifies the ARGS parameter, so
11080 it's the responsibility of the caller to restore it. */
11082 static tree
11084 tree parm_packs,
11086 tree args /* This parm gets
11088 tsubst_flags_t complain,
11089 tree in_decl)
11090 {
11091 tree t;
11094 /* For each parameter pack, change the substitution of the parameter
11095 pack to the ith argument in its argument pack, then expand the
11096 pattern. */
11098 {
11103 ith_elem_is_expansion |=
11106 /* Select the Ith argument from the pack. */
11109 {
11111 {
11116 }
11117 else
11119 }
11120 else
11121 {
11126 {
11128 /* Update the corresponding argument. */
11130 }
11131 else
11132 /* Re-use the ARGUMENT_PACK_SELECT. */
11134 }
11136 }
11138 /* Substitute into the PATTERN with the (possibly altered)
11139 arguments. */
11141 /* Expanding a fixed parameter pack from
11142 coerce_template_parameter_pack. */
11147 {
11150 else
11153 }
11157 else
11160 /* If the Ith argument pack element is a pack expansion, then
11161 the Ith element resulting from the substituting is going to
11162 be a pack expansion as well. */
11167 }
11169 /* When the unexpanded parameter pack in a fold expression expands to an empty
11170 sequence, the value of the expression is as follows; the program is
11171 ill-formed if the operator is not listed in this table.
11173 && true
11174 || false
11175 , void() */
11177 tree
11179 {
11183 {
11192 }
11198 }
11200 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11201 form an expression that combines the two terms using the
11202 operator of T. */
11204 static tree
11206 {
11210 // Handle compound assignment operators.
11215 {
11225 complain);
11226 }
11227 }
11229 /* Substitute ARGS into the pack of a fold expression T. */
11233 {
11235 }
11237 /* Substitute ARGS into the pack of a fold expression T. */
11241 {
11243 }
11245 /* Expand a PACK of arguments into a grouped as left fold.
11246 Given a pack containing elements A0, A1, ..., An and an
11247 operator @, this builds the expression:
11249 ((A0 @ A1) @ A2) ... @ An
11251 Note that PACK must not be empty.
11253 The operator is defined by the original fold expression T. */
11255 static tree
11257 {
11260 {
11263 }
11265 }
11267 /* Substitute into a unary left fold expression. */
11269 static tree
11271 tree in_decl)
11272 {
11277 {
11281 }
11284 else
11286 }
11288 /* Substitute into a binary left fold expression.
11290 Do ths by building a single (non-empty) vector of argumnts and
11291 building the expression from those elements. */
11293 static tree
11295 tree in_decl)
11296 {
11305 {
11310 }
11318 }
11320 /* Expand a PACK of arguments into a grouped as right fold.
11321 Given a pack containing elementns A0, A1, ..., and an
11322 operator @, this builds the expression:
11324 A0@ ... (An-2 @ (An-1 @ An))
11326 Note that PACK must not be empty.
11328 The operator is defined by the original fold expression T. */
11330 tree
11332 {
11333 // Build the expression.
11337 {
11340 }
11342 }
11344 /* Substitute into a unary right fold expression. */
11346 static tree
11348 tree in_decl)
11349 {
11354 {
11358 }
11361 else
11363 }
11365 /* Substitute into a binary right fold expression.
11367 Do ths by building a single (non-empty) vector of arguments and
11368 building the expression from those elements. */
11370 static tree
11372 tree in_decl)
11373 {
11382 {
11387 }
11396 }
11399 /* Substitute ARGS into T, which is an pack expansion
11400 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
11401 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
11402 (if only a partial substitution could be performed) or
11403 ERROR_MARK_NODE if there was an error. */
11404 tree
11406 tree in_decl)
11407 {
11408 tree pattern;
11412 tree result;
11420 /* Add in any args remembered from an earlier partial instantiation. */
11425 /* Determine the argument packs that will instantiate the parameter
11426 packs used in the expansion expression. While we're at it,
11427 compute the number of arguments to be expanded and make sure it
11428 is consistent. */
11431 {
11438 {
11443 else
11446 }
11448 {
11449 /* ??? Support use in other patterns. */
11453 }
11455 {
11456 /* We know we have correct local_specializations if this
11457 expansion is at function scope, or if we're dealing with a
11458 local parameter in a requires expression; for the latter,
11459 tsubst_requires_expr set it up appropriately. */
11462 else
11463 /* We can't rely on local_specializations for a parameter
11464 name used later in a function declaration (such as in a
11465 late-specified return type). Even if it exists, it might
11466 have the wrong value for a recursive call. */
11470 {
11471 /* This parameter pack was used in an unevaluated context. Just
11472 make a dummy decl, since it's only used for its type. */
11475 /* Partial instantiation of the parm_pack, we can't build
11476 up an argument pack yet. */
11478 else
11480 }
11481 }
11484 else
11485 {
11491 }
11498 /* This can only happen if we forget to expand an argument
11499 pack somewhere else. Just return an error, silently. */
11500 {
11504 }
11507 {
11511 /* Don't bother trying to do a partial substitution with
11512 incomplete packs; we'll try again after deduction. */
11519 {
11524 pattern);
11525 else
11527 pattern);
11529 }
11531 /* Keep track of the parameter packs and their corresponding
11532 argument packs. */
11535 }
11536 else
11537 {
11538 /* We can't substitute for this parameter pack. We use a flag as
11539 well as the missing_level counter because function parameter
11540 packs don't have a level. */
11543 }
11544 }
11546 /* If the expansion is just T..., return the matching argument pack, unless
11547 we need to call convert_from_reference on all the elements. This is an
11548 important optimization; see c++/68422. */
11551 {
11553 /* Types need no adjustment, nor does sizeof..., and if we still have
11554 some pack expansion args we won't do anything yet. */
11559 /* Also optimize expression pack expansions if we can tell that the
11560 elements won't have reference type. */
11566 /* Otherwise use the normal path so we get convert_from_reference. */
11567 }
11569 /* We cannot expand this expansion expression, because we don't have
11570 all of the argument packs we need. */
11572 {
11573 /* We got some full packs, but we can't substitute them in until we
11574 have values for all the packs. So remember these until then. */
11579 }
11581 {
11582 /* There were no real arguments, we're just replacing a parameter
11583 pack with another version of itself. Substitute into the
11584 pattern and return a PACK_EXPANSION_*. The caller will need to
11585 deal with that. */
11589 else
11593 }
11598 {
11599 /* We're in a late-specified return type, so create our own local
11600 specializations map; the current map is either NULL or (in the
11601 case of recursive unification) might have bindings that we don't
11602 want to use or alter. */
11605 }
11607 /* For each argument in each argument pack, substitute into the
11608 pattern. */
11612 {
11614 i,
11616 in_decl);
11619 {
11622 }
11623 }
11625 /* Update ARGS to restore the substitution from parameter packs to
11626 their argument packs. */
11628 {
11634 else
11635 {
11643 /* Update the corresponding argument. */
11647 else
11649 }
11650 }
11653 {
11656 }
11658 /* If the dependent pack arguments were such that we end up with only a
11659 single pack expansion again, there's no need to keep it in a TREE_VEC. */
11665 }
11667 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
11668 TMPL. We do this using DECL_PARM_INDEX, which should work even with
11669 parameter packs; all parms generated from a function parameter pack will
11670 have the same DECL_PARM_INDEX. */
11672 tree
11674 {
11676 tree patparm;
11679 {
11685 }
11686 else
11687 {
11692 }
11695 }
11697 /* Make an argument pack out of the TREE_VEC VEC. */
11699 static tree
11701 {
11702 tree pack;
11706 else
11707 {
11710 }
11713 }
11715 /* Return an exact copy of template args T that can be modified
11716 independently. */
11718 static tree
11720 {
11728 {
11733 }
11739 }
11741 /* Substitute ARGS into the vector or list of template arguments T. */
11743 static tree
11745 {
11757 {
11759 tree new_arg;
11764 {
11765 /* Substitute into an expansion expression. */
11769 /* Add to the expanded length adjustment the number of
11770 expanded arguments. We subtract one from this
11771 measurement, because the argument pack expression
11772 itself is already counted as 1 in
11773 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
11774 the argument pack is empty. */
11776 }
11778 {
11779 /* Substitute into each of the arguments. */
11788 else
11793 }
11794 else
11803 }
11808 /* Make space for the expanded arguments coming from template
11809 argument packs. */
11811 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
11812 arguments for a member template.
11813 In that case each TREE_VEC in ORIG_T represents a level of template
11814 arguments, and ORIG_T won't carry any non defaulted argument count.
11815 It will rather be the nested TREE_VECs that will carry one.
11816 In other words, ORIG_T carries a non defaulted argument count only
11817 if it doesn't contain any nested TREE_VEC. */
11819 {
11823 }
11825 {
11829 {
11832 /* Now expand the template argument pack "in place". */
11835 }
11836 else
11837 {
11839 out++;
11840 }
11841 }
11844 }
11846 /* Substitute ARGS into one level PARMS of template parameters. */
11848 static tree
11850 {
11857 {
11865 }
11868 }
11870 /* Return the result of substituting ARGS into the template parameters
11871 given by PARMS. If there are m levels of ARGS and m + n levels of
11872 PARMS, then the result will contain n levels of PARMS. For
11873 example, if PARMS is `template <class T> template <class U>
11874 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
11875 result will be `template <int*, double, class V>'. */
11877 static tree
11879 {
11883 /* When substituting into a template, we must set
11884 PROCESSING_TEMPLATE_DECL as the template parameters may be
11885 dependent if they are based on one-another, and the dependency
11886 predicates are short-circuit outside of templates. */
11893 {
11900 }
11905 }
11907 /* Return the result of substituting ARGS into one template parameter
11908 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
11909 parameter and which TREE_PURPOSE is the default argument of the
11910 template parameter. */
11912 static tree
11914 {
11935 }
11937 /* Substitute the ARGS into the indicated aggregate (or enumeration)
11938 type T. If T is not an aggregate or enumeration type, it is
11939 handled as if by tsubst. IN_DECL is as for tsubst. If
11940 ENTERING_SCOPE is nonzero, T is the context for a template which
11941 we are presently tsubst'ing. Return the substituted value. */
11943 static tree
11945 tree args,
11946 tsubst_flags_t complain,
11947 tree in_decl,
11949 {
11954 {
11959 /* Fall through. */
11963 {
11964 tree argvec;
11965 tree context;
11966 tree r;
11970 /* In "sizeof(X<I>)" we need to evaluate "I". */
11976 /* First, determine the context for the type we are looking
11977 up. */
11980 {
11983 /* If context is a nested class inside a class template,
11984 it may still need to be instantiated (c++/33959). */
11986 }
11988 /* Then, figure out what arguments are appropriate for the
11989 type we are trying to find. For example, given:
11991 template <class T> struct S;
11992 template <class T, class U> void f(T, U) { S<U> su; }
11994 and supposing that we are instantiating f<int, double>,
11995 then our ARGS will be {int, double}, but, when looking up
11996 S we only want {double}. */
12001 else
12002 {
12006 }
12012 }
12013 else
12014 /* This is not a template type, so there's nothing to do. */
12019 }
12020 }
12024 /* Substitute into the default argument ARG (a default argument for
12025 FN), which has the indicated TYPE. */
12027 tree
12029 tsubst_flags_t complain)
12030 {
12035 /* This can happen in invalid code. */
12050 /* This default argument came from a template. Instantiate the
12051 default argument here, not in tsubst. In the case of
12052 something like:
12054 template <class T>
12055 struct S {
12056 static T t();
12057 void f(T = t());
12058 };
12060 we must be careful to do name lookup in the scope of S<T>,
12061 rather than in the current class. */
12063 /* The "this" pointer is not valid in a default argument. */
12065 {
12070 }
12075 /* The default argument expression may cause implicitly defined
12076 member functions to be synthesized, which will result in garbage
12077 collection. We must treat this situation as if we were within
12078 the body of function so as to avoid collecting live data on the
12079 stack. */
12089 /* Restore the "this" pointer. */
12091 {
12094 }
12101 /* Make sure the default argument is reasonable. */
12107 {
12111 }
12114 }
12116 /* Substitute into all the default arguments for FN. */
12118 static void
12120 {
12121 tree arg;
12122 tree tmpl_args;
12126 /* If this function is not yet instantiated, we certainly don't need
12127 its default arguments. */
12130 /* Don't do this again for clones. */
12136 arg;
12142 complain);
12143 }
12145 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12147 static tree
12149 tree lambda_fntype)
12150 {
12155 /* Nobody should be tsubst'ing into non-template functions. */
12159 {
12160 /* If T is not dependent, just return it. */
12164 /* Calculate the most general template of which R is a
12165 specialization, and the complete set of arguments used to
12166 specialize R. */
12169 (DECL_TEMPLATE_RESULT
12175 /* Check to see if we already have this specialization. */
12177 {
12181 }
12183 /* We can see more levels of arguments than parameters if
12184 there was a specialization of a member template, like
12185 this:
12187 template <class T> struct S { template <class U> void f(); }
12188 template <> template <class U> void S<int>::f(U);
12190 Here, we'll be substituting into the specialization,
12191 because that's where we can find the code we actually
12192 want to generate, but we'll have enough arguments for
12193 the most general template.
12195 We also deal with the peculiar case:
12197 template <class T> struct S {
12198 template <class U> friend void f();
12199 };
12200 template <class U> void f() {}
12201 template S<int>;
12202 template void f<double>();
12204 Here, the ARGS for the instantiation of will be {int,
12205 double}. But, we only need as many ARGS as there are
12206 levels of template parameters in CODE_PATTERN. We are
12207 careful not to get fooled into reducing the ARGS in
12208 situations like:
12210 template <class T> struct S { template <class U> void f(U); }
12211 template <class T> template <> void S<T>::f(int) {}
12213 which we can spot because the pattern will be a
12214 specialization in this case. */
12221 }
12222 else
12223 {
12224 /* This special case arises when we have something like this:
12226 template <class T> struct S {
12227 friend void f<int>(int, double);
12228 };
12230 Here, the DECL_TI_TEMPLATE for the friend declaration
12231 will be an IDENTIFIER_NODE. We are being called from
12232 tsubst_friend_function, and we want only to create a
12233 new decl (R) with appropriate types so that we can call
12234 determine_specialization. */
12237 }
12254 /* If we hit excessive deduction depth, the type is bogus even if
12255 it isn't error_mark_node, so don't build a decl. */
12259 /* We do NOT check for matching decls pushed separately at this
12260 point, as they may not represent instantiations of this
12261 template, and in any case are considered separate under the
12262 discrete model. */
12266 /* Clear out the mangled name and RTL for the instantiation. */
12269 /* Leave DECL_INITIAL set on deleted instantiations. */
12274 /* OpenMP UDRs have the only argument a reference to the declared
12275 type. We want to diagnose if the declared type is a reference,
12276 which is invalid, but as references to references are usually
12277 quietly merged, diagnose it here. */
12279 {
12280 tree argtype
12285 "reference type %qT in "
12289 argtype);
12290 }
12293 /* Type-conversion operator. Reconstruct the name, in
12294 case it's the name of one of the template's parameters. */
12304 {
12308 }
12315 /* If this is an instantiation of a function with internal
12316 linkage, we already know what object file linkage will be
12317 assigned to the instantiation. */
12326 /* We'll re-clone as appropriate in instantiate_template. */
12329 /* If we aren't complaining now, return on error before we register
12330 the specialization so that we'll complain eventually. */
12336 /* When instantiating a constrained member, substitute
12337 into the constraints to create a new constraint. */
12340 {
12343 }
12345 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
12346 this in the special friend case mentioned above where
12347 GEN_TMPL is NULL. */
12349 {
12354 tree new_r
12357 /* We instantiated this while substituting into
12358 the type earlier (template/friend54.C). */
12361 /* We're not supposed to instantiate default arguments
12362 until they are called, for a template. But, for a
12363 declaration like:
12365 template <class T> void f ()
12366 { extern void g(int i = T()); }
12368 we should do the substitution when the template is
12369 instantiated. We handle the member function case in
12370 instantiate_class_template since the default arguments
12371 might refer to other members of the class. */
12376 }
12377 else
12380 /* Copy the list of befriending classes. */
12384 {
12388 }
12391 {
12395 /* If this is an instantiation of a member template, clone it.
12396 If it isn't, that'll be handled by
12397 clone_constructors_and_destructors. */
12400 }
12411 /* Possibly limit visibility based on template args. */
12414 {
12418 }
12427 }
12429 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
12431 static tree
12433 tree lambda_fntype)
12434 {
12435 /* We can get here when processing a member function template,
12436 member class template, or template template parameter. */
12439 tree spec;
12440 tree tmpl_args;
12441 tree full_args;
12442 tree r;
12446 {
12447 /* Template template parameter is treated here. */
12451 /* If we get a real template back, return it. This can happen in
12452 the context of most_specialized_partial_spec. */
12455 else
12456 /* The new TEMPLATE_DECL was built in
12457 reduce_template_parm_level. */
12460 }
12463 {
12464 /* We might already have an instance of this template.
12465 The ARGS are for the surrounding class type, so the
12466 full args contain the tsubst'd args for the context,
12467 plus the innermost args from the template decl. */
12471 /* Because this is a template, the arguments will still be
12472 dependent, even after substitution. If
12473 PROCESSING_TEMPLATE_DECL is not set, the dependency
12474 predicates will short-circuit. */
12482 /* If this is a default template template argument,
12483 tsubst might not have changed anything. */
12491 }
12493 /* Make a new template decl. It will be similar to the
12494 original, but will record the current template arguments.
12495 We also create a new function declaration, which is just
12496 like the old one, but points to this new template, rather
12497 than the old one. */
12502 // Build new template info linking to the original template decl.
12504 {
12507 }
12508 else
12511 /* The template parameters for this new template are all the
12512 template parameters for the old template, except the
12513 outermost level of parameters. */
12516 complain);
12520 {
12521 tree new_type;
12529 /* For a partial specialization, we need to keep pointing to
12530 the primary template. */
12536 }
12537 else
12538 {
12539 tree new_decl;
12543 else
12553 {
12556 }
12557 else
12558 {
12561 }
12562 }
12572 /* Record this non-type partial instantiation. */
12578 }
12580 /* True if FN is the op() for a lambda in an uninstantiated template. */
12582 bool
12584 {
12589 }
12591 /* True if FN is the op() for a lambda regenerated from a lambda in an
12592 uninstantiated template. */
12594 bool
12596 {
12599 }
12601 /* We're instantiating a variable from template function TCTX. Return the
12602 corresponding current enclosing scope. This gets complicated because lambda
12603 functions in templates are regenerated rather than instantiated, but generic
12604 lambda functions are subsequently instantiated. */
12606 static tree
12608 {
12616 {
12627 {
12631 }
12633 }
12635 }
12637 /* Substitute the ARGS into the T, which is a _DECL. Return the
12638 result of the substitution. Issue error and warning messages under
12639 control of COMPLAIN. */
12641 static tree
12643 {
12644 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12645 location_t saved_loc;
12650 /* Set the filename and linenumber to improve error-reporting. */
12655 {
12665 {
12673 {
12674 /* If there is a local specialization that isn't a
12675 parameter pack, it means that we're doing a "simple"
12676 substitution from inside tsubst_pack_expansion. Just
12677 return the local specialization (which will be a single
12678 parm). */
12685 /* Expand the TYPE_PACK_EXPANSION that provides the types for
12686 the parameters in this function parameter pack. */
12690 {
12693 /* Zero-length parameter packs are boring. Just substitute
12694 into the chain. */
12698 }
12699 else
12700 {
12701 /* All we did was update the type. Make a note of that. */
12704 }
12705 }
12707 /* Loop through all of the parameters we'll build. When T is
12708 a function parameter pack, LEN is the number of expanded
12709 types in EXPANDED_TYPES; otherwise, LEN is 1. */
12712 {
12719 /* We're on the Ith parameter of the function parameter
12720 pack. */
12721 {
12722 /* Get the Ith type. */
12725 /* Rename the parameter to include the index. */
12728 }
12730 /* We're dealing with a normal parameter. */
12738 {
12741 else
12744 }
12754 /* Keep track of the first new parameter we
12755 generate. That's what will be returned to the
12756 caller. */
12760 /* Build a proper chain of parameters when substituting
12761 into a function parameter pack. */
12764 }
12766 /* If cp_unevaluated_operand is set, we're just looking for a
12767 single dummy parameter, so don't keep going. */
12772 /* FIRST_R contains the start of the chain we've built. */
12774 }
12778 {
12785 {
12786 /* This field is a lambda capture pack. Return a TREE_VEC of
12787 the expanded fields to instantiate_class_template_1 and
12788 store them in the specializations hash table as a
12789 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
12793 {
12796 }
12797 else
12798 {
12799 /* All we did was update the type. Make a note of that. */
12802 }
12803 }
12806 {
12809 {
12813 }
12823 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
12824 number of bits. */
12830 {
12831 /* Set up DECL_TEMPLATE_INFO so that we can get at the
12832 NSDMI in perform_member_init. Still set DECL_INITIAL
12833 so that we know there is one. */
12838 }
12839 /* We don't have to set DECL_CONTEXT here; it is set by
12840 finish_member_declaration. */
12848 }
12851 {
12856 }
12857 }
12861 /* We reach here only for member using decls. We also need to check
12862 uses_template_parms because DECL_DEPENDENT_P is not set for a
12863 using-declaration that designates a member of the current
12864 instantiation (c++/53549). */
12867 {
12871 {
12876 {
12880 {
12883 }
12884 else
12885 {
12888 }
12890 }
12891 }
12892 else
12893 {
12899 else
12900 {
12903 }
12904 }
12905 }
12906 else
12907 {
12910 }
12915 {
12918 tree spec;
12920 tree ctx;
12929 {
12930 /* If this is the canonical decl, we don't have to
12931 mess with instantiations, and often we can't (for
12932 typename, template type parms and such). Note that
12933 TYPE_NAME is not correct for the above test if
12934 we've copied the type for a typedef. */
12940 }
12942 /* Check to see if we already have the specialization we
12943 need. */
12946 {
12947 /* T is a static data member or namespace-scope entity.
12948 We have to substitute into namespace-scope variables
12949 (not just variable templates) because of cases like:
12951 template <class T> void f() { extern T t; }
12953 where the entity referenced is not known until
12954 instantiation time. */
12958 {
12960 complain,
12962 /* If CTX is unchanged, then T is in fact the
12963 specialization we want. That situation occurs when
12964 referencing a static data member within in its own
12965 class. We can use pointer equality, rather than
12966 same_type_p, because DECL_CONTEXT is always
12967 canonical... */
12969 /* ... unless T is a member template; in which
12970 case our caller can be willing to create a
12971 specialization of that template represented
12972 by T. */
12976 }
12979 {
12984 argvec = (coerce_innermost_template_parms
12992 }
12993 }
12994 else
12995 {
12996 /* A local variable. */
12998 /* Subsequent calls to pushdecl will fill this in. */
13000 /* Unless this is a reference to a static variable from an
13001 enclosing function, in which case we need to fill it in now. */
13003 {
13007 }
13009 }
13010 /* If we already have the specialization we need, there is
13011 nothing more to do. */
13013 {
13016 }
13018 /* Create a new node for the specialization we need. */
13021 {
13024 else
13032 {
13033 /* Mask off any template args past the variable's context so we
13034 don't replace the auto with an unrelated argument. */
13038 /* This should never happen with the new lambda instantiation
13039 model, but keep the handling just in case. */
13042 }
13044 }
13046 {
13047 /* Even if the original location is out of scope, the
13048 newly substituted one is not. */
13055 {
13056 /* It may seem that this case cannot occur, since:
13058 typedef void f();
13059 void g() { f x; }
13061 declares a function, not a variable. However:
13063 typedef void f();
13064 template <typename T> void g() { T t; }
13065 template void g<f>();
13067 is an attempt to declare a variable with function
13068 type. */
13070 /* R is not yet sufficiently initialized, so we
13071 just use its name. */
13074 }
13076 /* Wait until cp_finish_decl to set this again, to handle
13077 circular dependency (template/instantiate6.C). */
13082 {
13087 {
13090 }
13092 }
13096 }
13102 /* Clear out the mangled name and RTL for the instantiation. */
13106 /* The initializer must not be expanded until it is required;
13107 see [temp.inst]. */
13111 {
13114 /* Possibly limit visibility based on template args. */
13117 {
13121 }
13123 }
13126 {
13127 /* A static data member declaration is always marked
13128 external when it is declared in-class, even if an
13129 initializer is present. We mimic the non-template
13130 processing here. */
13138 }
13139 else
13140 {
13145 }
13153 /* Preserve a typedef that names a type. */
13155 {
13159 /* An alias template specialization can be dependent
13160 even if its underlying type is not. */
13162 }
13165 }
13170 }
13171 #undef RETURN
13173 out:
13174 /* Restore the file and line information. */
13178 }
13180 /* Substitute into the ARG_TYPES of a function type.
13181 If END is a TREE_CHAIN, leave it and any following types
13182 un-substituted. */
13184 static tree
13186 tree args,
13187 tree end,
13188 tsubst_flags_t complain,
13189 tree in_decl)
13190 {
13191 tree remaining_arg_types;
13195 tree default_arg;
13206 {
13207 /* For a pack expansion, perform substitution on the
13208 entire expression. Later on, we'll handle the arguments
13209 one-by-one. */
13214 /* So that we'll spin through the parameters, one by one. */
13216 else
13217 {
13218 /* We only partially substituted into the parameter
13219 pack. Our type is TYPE_PACK_EXPANSION. */
13222 }
13223 }
13236 {
13238 {
13242 }
13244 }
13245 /* DR 657. */
13249 /* Do array-to-pointer, function-to-pointer conversion, and ignore
13250 top-level qualifiers as required. */
13253 /* We do not substitute into default arguments here. The standard
13254 mandates that they be instantiated only when needed, which is
13255 done in build_over_call. */
13258 /* Except that we do substitute default arguments under tsubst_lambda_expr,
13259 since the new op() won't have any associated template arguments for us
13260 to refer to later. */
13266 {
13267 /* We've instantiated a template before its default arguments
13268 have been parsed. This can happen for a nested template
13269 class, and is not an error unless we require the default
13270 argument in a call of this function. */
13271 remaining_arg_types =
13274 }
13275 else
13276 remaining_arg_types =
13278 }
13281 }
13283 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
13284 *not* handle the exception-specification for FNTYPE, because the
13285 initial substitution of explicitly provided template parameters
13286 during argument deduction forbids substitution into the
13287 exception-specification:
13289 [temp.deduct]
13291 All references in the function type of the function template to the
13292 corresponding template parameters are replaced by the specified tem-
13293 plate argument values. If a substitution in a template parameter or
13294 in the function type of the function template results in an invalid
13295 type, type deduction fails. [Note: The equivalent substitution in
13296 exception specifications is done only when the function is instanti-
13297 ated, at which point a program is ill-formed if the substitution
13298 results in an invalid type.] */
13300 static tree
13302 tree args,
13303 tsubst_flags_t complain,
13304 tree in_decl)
13305 {
13306 tree return_type;
13308 tree fntype;
13310 /* The TYPE_CONTEXT is not used for function/method types. */
13313 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
13314 failure. */
13318 {
13319 /* Substitute the argument types. */
13331 {
13332 /* DR 1207: 'this' is in scope in the trailing return type. */
13334 }
13336 /* Substitute the return type. */
13340 {
13343 }
13344 }
13345 else
13346 /* Substitute the return type. */
13351 /* DR 486 clarifies that creation of a function type with an
13352 invalid return type is a deduction failure. */
13355 {
13357 {
13360 else
13362 }
13364 }
13365 /* And DR 657. */
13370 {
13371 /* Substitute the argument types. */
13376 }
13378 /* Construct a new type node and return it. */
13380 {
13385 }
13386 else
13387 {
13389 /* Don't pick up extra function qualifiers from the basetype. */
13392 {
13393 /* [temp.deduct]
13395 Type deduction may fail for any of the following
13396 reasons:
13398 -- Attempting to create "pointer to member of T" when T
13399 is not a class type. */
13402 r);
13404 }
13409 }
13416 }
13418 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
13419 ARGS into that specification, and return the substituted
13420 specification. If there is no specification, return NULL_TREE. */
13422 static tree
13424 tree args,
13425 tsubst_flags_t complain,
13426 tree in_decl,
13428 {
13429 tree specs;
13430 tree new_specs;
13435 {
13436 /* A noexcept-specifier. */
13441 {
13442 /* Defer instantiation of noexcept-specifiers to avoid
13443 excessive instantiations (c++/49107). */
13446 {
13447 /* We already partially instantiated this member template,
13448 so combine the new args with the old. */
13453 }
13454 else
13455 {
13458 }
13459 }
13460 else
13461 new_specs = tsubst_copy_and_build
13465 }
13467 {
13470 else
13472 {
13473 tree spec;
13478 {
13479 /* Expand the pack expansion type. */
13482 in_decl);
13488 else
13489 {
13490 /* We're substituting into a member template, so
13491 we got a TYPE_PACK_EXPANSION back. Add that
13492 expansion and move on. */
13496 expanded_specs,
13497 complain);
13500 }
13501 }
13504 {
13507 else
13512 complain);
13513 }
13516 }
13517 }
13519 }
13521 /* Take the tree structure T and replace template parameters used
13522 therein with the argument vector ARGS. IN_DECL is an associated
13523 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
13524 Issue error and warning messages under control of COMPLAIN. Note
13525 that we must be relatively non-tolerant of extensions here, in
13526 order to preserve conformance; if we allow substitutions that
13527 should not be allowed, we may allow argument deductions that should
13528 not succeed, and therefore report ambiguous overload situations
13529 where there are none. In theory, we could allow the substitution,
13530 but indicate that it should have failed, and allow our caller to
13531 make sure that the right thing happens, but we don't try to do this
13532 yet.
13534 This function is used for dealing with types, decls and the like;
13535 for expressions, use tsubst_expr or tsubst_copy. */
13537 tree
13539 {
13562 else
13567 /* Reuse typedefs. We need to do this to handle dependent attributes,
13568 such as attribute aligned. */
13571 {
13575 {
13576 /* DECL represents an alias template and we want to
13577 instantiate it. */
13581 }
13585 {
13589 }
13594 else
13595 /* The typedef is from a non-template context. */
13599 {
13601 r = cp_build_qualified_type_real
13605 }
13606 else
13607 {
13608 /* We don't have an instantiation yet, so drop the typedef. */
13613 }
13614 }
13631 {
13657 {
13663 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
13664 needed. */
13670 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
13671 with TREE_SIDE_EFFECTS that indicates this is not an integral
13672 constant expression. */
13675 {
13678 }
13681 }
13687 {
13693 /* Early in template argument deduction substitution, we don't
13694 want to reduce the level of 'auto', or it will be confused
13695 with a normal template parm in subsequent deduction. */
13707 {
13711 {
13712 /* See through ARGUMENT_PACK_SELECT arguments. */
13714 /* If the selected argument is an expansion E, that most
13715 likely means we were called from
13716 gen_elem_of_pack_expansion_instantiation during the
13717 substituting of pack an argument pack (which Ith
13718 element is a pack expansion, where I is
13719 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
13720 In this case, the Ith element resulting from this
13721 substituting is going to be a pack expansion, which
13722 pattern is the pattern of E. Let's return the
13723 pattern of E, and
13724 gen_elem_of_pack_expansion_instantiation will
13725 build the resulting pack expansion from it. */
13727 {
13728 /* Make sure we aren't throwing away arg info. */
13731 }
13732 }
13733 }
13738 {
13740 /* If ARG is an argument pack, we don't actually want to
13741 perform a substitution here, because substitutions
13742 for argument packs are only done
13743 element-by-element. We can get to this point when
13744 substituting the type of a non-type template
13745 parameter pack, when that type actually contains
13746 template parameter packs from an outer template, e.g.,
13748 template<typename... Types> struct A {
13749 template<Types... Values> struct B { };
13750 }; */
13754 {
13760 return cp_build_qualified_type_real
13762 }
13764 {
13765 /* We are processing a type constructed from a
13766 template template parameter. */
13777 /* Consider this code:
13779 template <template <class> class Template>
13780 struct Internal {
13781 template <class Arg> using Bind = Template<Arg>;
13782 };
13784 template <template <class> class Template, class Arg>
13785 using Instantiate = Template<Arg>; //#0
13787 template <template <class> class Template,
13788 class Argument>
13789 using Bind =
13790 Instantiate<Internal<Template>::template Bind,
13791 Argument>; //#1
13793 When #1 is parsed, the
13794 BOUND_TEMPLATE_TEMPLATE_PARM representing the
13795 parameter `Template' in #0 matches the
13796 UNBOUND_CLASS_TEMPLATE representing the argument
13797 `Internal<Template>::template Bind'; We then want
13798 to assemble the type `Bind<Argument>' that can't
13799 be fully created right now, because
13800 `Internal<Template>' not being complete, the Bind
13801 template cannot be looked up in that context. So
13802 we need to "store" `Bind<Argument>' for later
13803 when the context of Bind becomes complete. Let's
13804 store that in a TYPENAME_TYPE. */
13808 argvec),
13809 typename_type,
13810 complain);
13812 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
13813 are resolving nested-types in the signature of a
13814 member function templates. Otherwise ARG is a
13815 TEMPLATE_DECL and is the real template to be
13816 instantiated. */
13824 complain);
13825 return cp_build_qualified_type_real
13827 }
13830 else
13831 /* TEMPLATE_PARM_INDEX. */
13833 }
13836 /* This can happen during the attempted tsubst'ing in
13837 unify. This means that we don't yet have any information
13838 about the template parameter in question. */
13841 /* If we get here, we must have been looking at a parm for a
13842 more deeply nested template. Make a new version of this
13843 template parameter, but with a lower level. */
13845 {
13850 {
13852 r = cp_build_qualified_type_real
13856 }
13863 /* Break infinite recursion when substituting the constraints
13865 else
13866 {
13877 {
13878 /* Propagate constraints on placeholders. */
13883 {
13887 }
13888 }
13891 /* We have reduced the level of the template
13892 template parameter, but not the levels of its
13893 template parameters, so canonical_type_parameter
13894 will not be able to find the canonical template
13895 template parameter for this level. Thus, we
13896 require structural equality checking to compare
13897 TEMPLATE_TEMPLATE_PARMs. */
13901 else
13905 {
13907 /* We might need to substitute into the types of non-type
13908 template parameters. */
13920 }
13921 }
13925 /* OK, now substitute the type of the non-type parameter. We
13926 couldn't do it earlier because it might be an auto parameter,
13927 and we wouldn't need to if we had an argument. */
13936 }
13939 }
13942 {
13950 {
13954 }
13957 {
13961 }
13964 {
13968 }
13974 }
13977 /* We should never be tsubsting a binfo. */
13981 /* A vector of template arguments. */
13987 {
13991 /* [temp.deduct]
13993 Type deduction may fail for any of the following
13994 reasons:
13996 -- Attempting to create a pointer to reference type.
13997 -- Attempting to create a reference to a reference type or
13998 a reference to void.
14000 Core issue 106 says that creating a reference to a reference
14001 during instantiation is no longer a cause for failure. We
14002 only enforce this check in strict C++98 mode. */
14006 {
14009 /* We keep track of the last time we issued this error
14010 message to avoid spewing a ton of messages during a
14011 single bad template instantiation. */
14014 {
14019 else
14022 }
14025 }
14029 {
14031 {
14034 type);
14035 else
14037 type);
14038 }
14040 }
14042 {
14046 }
14048 /* In C++0x, during template argument substitution, when there is an
14049 attempt to create a reference to a reference type, reference
14050 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14052 "If a template-argument for a template-parameter T names a type
14053 that is a reference to a type A, an attempt to create the type
14054 'lvalue reference to cv T' creates the type 'lvalue reference to
14055 A,' while an attempt to create the type type rvalue reference to
14056 cv T' creates the type T"
14057 */
14058 r = cp_build_reference_type
14061 else
14066 /* Will this ever be needed for TYPE_..._TO values? */
14070 }
14072 {
14075 {
14076 /* [temp.deduct]
14078 Type deduction may fail for any of the following
14079 reasons:
14081 -- Attempting to create "pointer to member of T" when T
14082 is not a class type. */
14086 }
14088 {
14092 }
14094 {
14098 }
14101 {
14102 /* The type of the implicit object parameter gets its
14103 cv-qualifiers from the FUNCTION_TYPE. */
14104 tree memptr;
14105 tree method_type
14110 complain);
14111 }
14112 else
14115 complain);
14116 }
14119 {
14120 tree fntype;
14121 tree specs;
14126 /* Substitute the exception specification. */
14134 }
14136 {
14141 /* As an optimization, we avoid regenerating the array type if
14142 it will obviously be the same as T. */
14146 /* These checks should match the ones in create_array_type_for_decl.
14148 [temp.deduct]
14150 The deduction may fail for any of the following reasons:
14152 -- Attempting to create an array with an element type that
14153 is void, a function type, or a reference type, or [DR337]
14154 an abstract class type. */
14160 {
14164 }
14172 {
14175 }
14178 }
14181 {
14193 {
14197 }
14199 {
14200 /* Normally, make_typename_type does not require that the CTX
14201 have complete type in order to allow things like:
14203 template <class T> struct S { typename S<T>::X Y; };
14205 But, such constructs have already been resolved by this
14206 point, so here CTX really should have complete type, unless
14207 it's a partial instantiation. */
14210 {
14214 }
14215 }
14222 {
14225 }
14228 {
14230 {
14234 else
14236 }
14238 {
14242 else
14244 }
14245 }
14247 return cp_build_qualified_type_real
14249 }
14252 {
14264 }
14267 {
14268 tree type;
14284 complain);
14285 }
14288 {
14289 tree type;
14300 {
14302 {
14306 }
14309 }
14320 else
14321 {
14325 /* In a template ~id could be either a complement expression
14326 or an unqualified-id naming a destructor; if instantiating
14327 it produces an expression, it's not an id-expression or
14328 member access. */
14331 }
14336 }
14339 {
14343 }
14347 {
14348 tree r;
14352 else
14360 }
14375 /* We should use one of the expression tsubsts for these codes. */
14381 }
14382 }
14384 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
14385 expression on the left-hand side of the "." or "->" operator. A
14386 baselink indicates a function from a base class. Both the
14387 BASELINK_ACCESS_BINFO and the base class referenced may indicate
14388 bases of the template class, rather than the instantiated class.
14389 In addition, lookups that were not ambiguous before may be
14390 ambiguous now. Therefore, we perform the lookup again. */
14392 static tree
14395 {
14408 {
14415 }
14423 {
14428 }
14430 /* If lookup found a single function, mark it as used at this point.
14431 (If it lookup found multiple functions the one selected later by
14432 overload resolution will be marked as used at that point.) */
14440 {
14441 /* Add back the template arguments, if present. */
14447 /* Update the conversion operator type. */
14449 }
14455 {
14457 qualifying_scope,
14458 object_type);
14460 /* We need to call adjust_result_of_qualified_name_lookup in case the
14461 destructor names a base class, but we unset BASELINK_QUALIFIED_P
14462 so that we still get virtual function binding. */
14464 }
14467 }
14469 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
14470 true if the qualified-id will be a postfix-expression in-and-of
14471 itself; false if more of the postfix-expression follows the
14472 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
14473 of "&". */
14475 static tree
14479 {
14480 tree expr;
14481 tree scope;
14482 tree name;
14484 tree template_args;
14489 /* Figure out what name to look up. */
14492 {
14502 }
14503 else
14504 {
14507 }
14509 /* Substitute into the qualifying scope. When there are no ARGS, we
14510 are just trying to simplify a non-dependent expression. In that
14511 case the qualifying scope may be dependent, and, in any case,
14512 substituting will not help. */
14515 {
14518 }
14519 else
14523 {
14530 }
14533 {
14535 {
14536 /* A BIT_NOT_EXPR is used to represent a destructor. */
14538 {
14542 }
14543 else
14546 }
14547 else
14551 {
14553 {
14557 }
14559 }
14560 }
14563 {
14565 scope);
14566 /* Remember that there was a reference to this entity. */
14569 }
14572 {
14578 }
14581 {
14584 complain);
14585 else
14587 }
14593 {
14594 expr = (adjust_result_of_qualified_name_lookup
14596 expr = (finish_qualified_id_expr
14600 }
14602 /* Expressions do not generally have reference type. */
14604 /* However, if we're about to form a pointer-to-member, we just
14605 want the referenced member referenced. */
14613 }
14615 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
14616 initializer, DECL is the substituted VAR_DECL. Other arguments are as
14617 for tsubst. */
14619 static tree
14622 {
14629 {
14630 /* If we had an initializer but it
14631 instantiated to nothing,
14632 value-initialize the object. This will
14633 only occur when the initializer was a
14634 pack expansion where the parameter packs
14635 used in that expansion were of length
14636 zero. */
14638 complain);
14643 }
14646 }
14648 /* Like tsubst, but deals with expressions. This function just replaces
14649 template parms; to finish processing the resultant expression, use
14650 tsubst_copy_and_build or tsubst_expr. */
14652 static tree
14654 {
14656 tree r;
14664 {
14669 {
14670 /* We get here for a use of 'this' in an NSDMI. */
14674 /* This can happen for a parameter name used later in a function
14675 declaration (such as in a late-specified return type). Just
14676 make a dummy decl, since it's only used for its type. */
14679 /* Give it the template pattern as its context; its true context
14680 hasn't been instantiated yet and this is good enough for
14681 mangling. */
14683 }
14692 {
14693 tree enum_type;
14694 tree v;
14698 /* There is no need to substitute into namespace-scope
14699 enumerators. */
14702 /* If ARGS is NULL, then T is known to be non-dependent. */
14706 /* Unfortunately, we cannot just call lookup_name here.
14707 Consider:
14709 template <int I> int f() {
14710 enum E { a = I };
14711 struct S { void g() { E e = a; } };
14712 };
14714 When we instantiate f<7>::S::g(), say, lookup_name is not
14715 clever enough to find f<7>::a. */
14716 enum_type
14726 /* We didn't find the name. That should never happen; if
14727 name-lookup found it during preliminary parsing, we
14728 should find it again here during instantiation. */
14730 }
14735 {
14736 /* Check for a local specialization set up by
14737 tsubst_pack_expansion. */
14739 {
14743 }
14745 /* When retrieving a capture pack from a generic lambda, remove the
14746 lambda call op's own template argument list from ARGS. Only the
14747 template arguments active for the closure type should be used to
14748 retrieve the pack specialization. */
14754 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
14755 tsubst_decl put in the hash table. */
14757 }
14760 {
14761 tree ctx;
14766 {
14769 {
14773 }
14775 }
14776 }
14786 {
14789 {
14790 /* First try name lookup to find the instantiation. */
14793 {
14794 /* Make sure that the one we found is the one we want. */
14798 }
14802 else
14803 {
14804 /* This can happen for a variable used in a
14805 late-specified return type of a local lambda, or for a
14806 local static or constant. Building a new VAR_DECL
14807 should be OK in all those cases. */
14810 /* Avoid infinite recursion (79640). */
14813 {
14814 /* We can't call cp_finish_decl, so handle the
14815 initializer by hand. */
14830 }
14837 }
14838 /* Remember this for subsequent uses. */
14841 }
14842 }
14843 else
14853 /* An OVERLOAD will always be a non-dependent overload set; an
14854 overload set from function scope will just be represented with an
14855 IDENTIFIER_NODE, and from class scope with a BASELINK. */
14857 /* We must have marked any lookups as persistent. */
14873 {
14874 /* Template template argument like the following example need
14875 special treatment:
14877 template <template <class> class TT> struct C {};
14878 template <class T> struct D {
14879 template <class U> struct E {};
14880 C<E> c; // #1
14881 };
14882 D<int> d; // #2
14884 We are processing the template argument `E' in #1 for
14885 the template instantiation #2. Originally, `E' is a
14886 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
14887 have to substitute this with one having context `D<int>'. */
14891 {
14892 /* When rewriting a constructor into a deduction guide, a
14893 non-dependent name can become dependent, so memtmpl<args>
14894 becomes context::template memtmpl<args>. */
14898 }
14900 }
14901 else
14902 /* Ordinary template template argument. */
14913 {
14917 }
14922 {
14931 /* We only want to compute the number of arguments. */
14934 else
14941 {
14943 /* Set TREE_USED for the benefit of -Wunused. */
14947 }
14955 {
14960 else
14966 else
14969 }
14970 else
14972 }
14974 {
14982 }
14983 /* Fall through */
14999 {
15003 }
15006 {
15007 tree object;
15008 tree name;
15013 {
15017 }
15020 {
15030 }
15035 in_decl);
15036 else
15039 }
15077 {
15081 }
15084 {
15089 }
15092 {
15096 }
15099 {
15107 }
15113 {
15120 }
15123 {
15130 }
15133 {
15140 }
15143 {
15144 /* Substituted template arguments */
15153 }
15156 {
15176 }
15201 /* Fall through. */
15204 {
15207 }
15208 else
15212 /* This is handled by tsubst_copy_and_build. */
15216 {
15220 }
15223 /* We shouldn't have built any of these during initial template
15224 generation. Instead, they should be built during instantiation
15225 in response to the saved STMT_IS_FULL_EXPR_P setting. */
15229 {
15239 }
15257 {
15258 /* Instantiate any typedefs in the type. */
15263 }
15266 /* These can sometimes show up in a partial instantiation, but never
15267 involve template parms. */
15283 /* We shouldn't get here, but keep going if !flag_checking. */
15287 }
15288 }
15290 /* Helper function for tsubst_omp_clauses, used for instantiation of
15291 OMP_CLAUSE_DECL of clauses. */
15293 static tree
15295 tree in_decl)
15296 {
15300 /* Handle an OpenMP array section represented as a TREE_LIST (or
15301 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
15302 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
15303 TREE_LIST. We can handle it exactly the same as an array section
15304 (purpose, value, and a chain), even though the nomenclature
15305 (low_bound, length, etc) is different. */
15307 {
15308 tree low_bound
15314 in_decl);
15323 }
15326 /* Undo convert_from_reference tsubst_expr could have called. */
15332 }
15334 /* Like tsubst_copy, but specifically for OpenMP clauses. */
15336 static tree
15339 {
15344 {
15350 {
15353 {
15359 }
15360 /* FALLTHRU */
15375 in_decl);
15407 {
15410 {
15417 }
15418 else
15420 }
15423 in_decl);
15429 in_decl);
15437 in_decl);
15439 {
15442 }
15447 else
15450 in_decl,
15474 }
15477 {
15487 /* tsubst_expr on SCOPE_REF results in returning
15488 finish_non_static_data_member result. Undo that here. */
15492 {
15497 {
15501 CASE_CONVERT:
15510 /* FALLTHRU */
15514 }
15515 }
15521 {
15524 {
15527 }
15528 }
15532 }
15533 }
15537 {
15542 {
15545 }
15546 }
15548 }
15550 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
15552 static tree
15554 tree in_decl)
15555 {
15556 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
15576 {
15579 else
15580 {
15584 }
15585 }
15590 #undef RECUR
15591 }
15593 /* Used to temporarily communicate the list of #pragma omp parallel
15594 clauses to #pragma omp for instantiation if they are combined
15595 together. */
15599 /* Substitute one OMP_FOR iterator. */
15601 static void
15606 {
15607 #define RECUR(NODE) \
15608 tsubst_expr ((NODE), args, complain, in_decl, \
15609 integral_constant_expression_p)
15616 {
15619 }
15625 {
15626 /* We need to jump through some hoops to handle declarations in the
15627 init-statement, since we might need to handle auto deduction,
15628 but we need to keep control of initialization. */
15632 }
15633 else
15634 {
15636 {
15639 {
15643 {
15647 CASE_CONVERT:
15655 {
15658 }
15659 /* FALLTHRU */
15663 }
15664 }
15665 }
15666 else
15668 }
15679 {
15681 {
15682 /* Declare the variable, but don't let that initialize it. */
15687 }
15692 {
15697 }
15698 else
15705 }
15708 {
15709 /* Declare and initialize the variable. */
15712 }
15714 {
15718 {
15720 {
15726 {
15729 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
15734 }
15737 {
15739 decl);
15741 }
15744 {
15746 decl);
15748 }
15749 else
15751 }
15754 }
15756 {
15761 {
15764 }
15765 }
15766 }
15769 {
15773 }
15774 else
15778 {
15789 {
15797 }
15798 else
15804 {
15810 }
15814 {
15822 }
15823 else
15829 }
15835 #undef RECUR
15836 }
15838 /* Helper function of tsubst_expr, find OMP_TEAMS inside
15839 of OMP_TARGET's body. */
15841 static tree
15843 {
15846 {
15855 }
15857 }
15859 /* Helper function for tsubst_expr. For decomposition declaration
15860 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
15861 also the corresponding decls representing the identifiers
15862 of the decomposition declaration. Return DECL if successful
15863 or error_mark_node otherwise, set *FIRST to the first decl
15864 in the list chained through DECL_CHAIN and *CNT to the number
15865 of such decls. */
15867 static tree
15871 {
15876 decl2
15881 {
15883 {
15886 }
15903 {
15906 }
15907 else
15909 }
15912 }
15914 /* Like tsubst_copy for expressions, etc. but also does semantic
15915 processing. */
15917 tree
15920 {
15921 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
15922 #define RECUR(NODE) \
15923 tsubst_expr ((NODE), args, complain, in_decl, \
15924 integral_constant_expression_p)
15927 tree r;
15928 location_t loc;
15940 {
15942 {
15943 tree_stmt_iterator i;
15947 }
15962 else
15972 {
15974 tree init;
15980 {
15990 else
15992 }
15994 {
15995 /* Don't build up decls for a variadic capture proxy, we'll
15996 instantiate the elements directly as needed. */
15998 }
16001 {
16002 /* We're in tsubst_lambda_expr, we've already inserted a new
16003 capture proxy, so look it up and register it. */
16009 }
16012 /* Don't copy the old closure; we'll create a new one in
16013 tsubst_lambda_expr. */
16015 else
16016 {
16020 {
16021 /* By marking the declaration as instantiated, we avoid
16022 trying to instantiate it. Since instantiate_decl can't
16023 handle local variables, and since we've already done
16024 all that needs to be done, that's the right thing to
16025 do. */
16030 /* Anonymous aggregates are a special case. */
16033 {
16036 {
16040 }
16042 }
16048 {
16053 }
16054 else
16055 {
16060 {
16061 /* For __PRETTY_FUNCTION__ we have to adjust the
16062 initializer. */
16066 }
16067 else
16071 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
16077 {
16079 tree first;
16085 }
16086 }
16087 }
16088 }
16091 }
16106 {
16114 {
16116 tree first;
16121 }
16122 else
16127 }
16153 else
16154 {
16161 }
16167 {
16176 }
16184 else
16192 else
16213 {
16220 }
16224 {
16226 tree label;
16233 }
16239 /* Computed goto's must be tsubst'd into. On the other hand,
16240 non-computed gotos must not be; the identifier in question
16241 will have no binding. */
16243 else
16249 {
16265 }
16270 {
16275 }
16276 else
16277 {
16282 else
16289 else
16295 else
16297 }
16301 {
16305 {
16307 /* Prevent instantiate_decl from trying to instantiate
16308 this variable. We've already done all that needs to be
16309 done. */
16312 }
16317 }
16323 {
16324 /* Local classes are not independent templates; they are
16325 instantiated along with their containing function. And this
16326 way we don't have to deal with pushing out of one local class
16327 to instantiate a member of another local class. */
16328 /* Closures are handled by the LAMBDA_EXPR. */
16338 }
16342 {
16343 tree condition;
16346 condition =
16348 args,
16357 }
16363 in_decl);
16400 {
16415 in_decl);
16417 {
16424 }
16436 integral_constant_expression_p);
16447 else
16448 {
16456 }
16460 }
16465 /* FALLTHRU */
16472 in_decl);
16489 in_decl);
16500 {
16503 {
16504 /* For combined target teams, ensure the num_teams and
16505 thread_limit clause expressions are evaluated on the host,
16506 before entering the target construct. */
16507 tree c;
16513 {
16522 OMP_CLAUSE_FIRSTPRIVATE);
16526 }
16527 }
16528 }
16588 {
16593 {
16596 }
16602 }
16603 else
16604 {
16611 {
16614 }
16617 {
16622 {
16625 }
16631 }
16632 else
16633 {
16637 }
16640 }
16644 {
16650 {
16654 {
16659 }
16663 }
16664 else
16665 {
16670 }
16671 }
16675 {
16679 }
16699 /* If the first operand was a statement, we're done with it. */
16703 complain));
16715 integral_constant_expression_p));
16716 }
16719 out:
16722 #undef RECUR
16723 #undef RETURN
16724 }
16726 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
16727 function. For description of the body see comment above
16728 cp_parser_omp_declare_reduction_exprs. */
16730 static void
16732 {
16738 tree_stmt_iterator tsi;
16749 {
16768 }
16770 {
16790 }
16791 }
16793 /* T is a postfix-expression that is not being used in a function
16794 call. Return the substituted version of T. */
16796 static tree
16798 tsubst_flags_t complain,
16799 tree in_decl)
16800 {
16804 else
16810 }
16812 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
16813 instantiation context. Instantiating a pack expansion containing a lambda
16814 might result in multiple lambdas all based on the same lambda in the
16815 template. */
16817 tree
16819 {
16833 else
16841 {
16853 else
16858 {
16867 }
16868 else
16869 {
16875 }
16876 }
16880 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
16898 else
16899 {
16900 /* Fix the type of 'this'. */
16906 {
16910 }
16911 else
16912 {
16916 }
16918 /* Let finish_function set this. */
16939 /* The capture list was built up in reverse order; fix that now. */
16946 }
16953 }
16955 /* Like tsubst but deals with expressions and performs semantic
16956 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
16958 tree
16960 tree args,
16961 tsubst_flags_t complain,
16962 tree in_decl,
16965 {
16966 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
16967 #define RECUR(NODE) \
16968 tsubst_copy_and_build (NODE, args, complain, in_decl, \
16970 integral_constant_expression_p)
16973 location_t loc;
16982 /* N3276 decltype magic only applies to calls at the top level or on the
16983 right side of a comma. */
16988 {
16991 /* Fall through. */
16993 {
16994 tree decl;
16995 cp_id_kind idk;
17000 {
17003 }
17005 /* Look up the name. */
17008 /* By convention, expressions use ERROR_MARK_NODE to indicate
17009 failure, not NULL_TREE. */
17015 integral_constant_expression_p,
17023 input_location);
17027 {
17031 }
17033 }
17036 {
17037 tree object;
17047 {
17052 }
17058 {
17061 }
17062 else
17069 else
17071 }
17074 {
17078 {
17079 /* A type conversion to reference type will be enclosed in
17080 such an indirect ref, but the substitution of the cast
17081 will have also added such an indirect ref. */
17084 }
17085 else
17093 }
17096 {
17100 }
17103 {
17110 flags));
17111 }
17114 {
17118 }
17125 {
17126 tree type;
17132 {
17137 }
17143 {
17161 }
17164 }
17198 else
17200 in_decl);
17235 {
17242 tree r = build_x_binary_op
17244 op0,
17246 ? ERROR_MARK
17248 op1,
17250 ? ERROR_MARK
17258 }
17261 {
17265 }
17278 {
17287 }
17292 /* Fall through */
17295 {
17296 tree r;
17302 {
17303 /* When there are no ARGS, we are trying to evaluate a
17304 non-dependent expression from the parser. Trying to do
17305 the substitutions may not work. */
17308 }
17309 else
17310 {
17315 else
17318 /*integral_constant_expression_p=*/
17322 }
17326 else
17330 {
17332 {
17334 {
17338 }
17339 else
17343 }
17345 }
17347 }
17350 {
17360 }
17376 {
17380 tree r = build_x_modify_expr
17383 /* TREE_NO_WARNING must be set if either the expression was
17384 parenthesized or it uses an operator such as >>= rather
17385 than plain assignment. In the former case, it was already
17386 set and must be copied. In the latter case,
17387 build_x_modify_expr sets it and it must not be reset
17388 here. */
17393 }
17398 /* Remember that there was a reference to this entity. */
17405 {
17410 tree ret;
17414 else
17415 {
17419 }
17421 /* If there was an initializer in the original tree, but it
17422 instantiated to an empty list, then we should pass a
17423 non-NULL empty vector to tell build_new that it was an
17424 empty initializer() rather than no initializer. This can
17425 only happen when the initializer is a pack expansion whose
17426 parameter packs are of length zero. */
17429 else
17430 {
17434 else
17435 {
17438 }
17439 }
17445 complain);
17453 }
17456 {
17462 complain));
17463 }
17466 {
17470 integral_constant_expression_p);
17472 op0,
17475 }
17478 {
17479 tree function;
17484 tree ret;
17487 /* Internal function with no arguments. */
17491 /* When we parsed the expression, we determined whether or
17492 not Koenig lookup should be performed. */
17495 {
17498 }
17500 {
17505 }
17507 {
17508 /* Do nothing; calling tsubst_copy_and_build on an identifier
17509 would incorrectly perform unqualified lookup again.
17511 Note that we can also have an IDENTIFIER_NODE if the earlier
17512 unqualified lookup found a member function; in that case
17513 koenig_p will be false and we do want to do the lookup
17514 again to find the instantiated member function.
17516 FIXME but doing that causes c++/15272, so we need to stop
17517 using IDENTIFIER_NODE in that situation. */
17519 }
17520 else
17521 {
17523 {
17529 }
17530 else
17535 /* Avoid error about taking the address of a constructor. */
17539 in_decl,
17541 integral_constant_expression_p);
17545 }
17550 {
17555 else
17556 {
17557 /* Expand the pack expansion and push each entry onto
17558 CALL_ARGS. */
17561 {
17566 {
17571 }
17572 }
17573 else
17574 {
17575 /* A partial substitution. Add one entry. */
17577 }
17578 }
17579 }
17581 /* We do not perform argument-dependent lookup if normal
17582 lookup finds a non-function, in accordance with the
17583 expected resolution of DR 218. */
17586 /* If lookup found a member function, the Koenig lookup is
17587 not appropriate, even if an unqualified-name was used
17588 to denote the function. */
17591 /* Only do this when substitution turns a dependent call
17592 into a non-dependent call. */
17600 {
17602 {
17603 /* For backwards compatibility and good diagnostics, try
17604 the unqualified lookup again if we aren't in SFINAE
17605 context. */
17606 tree unq = (tsubst_copy_and_build
17608 integral_constant_expression_p));
17610 {
17613 }
17616 {
17617 /* In a lambda fn, we have to be careful to not
17618 introduce new this captures. Legacy code can't
17619 be using lambdas anyway, so it's ok to be
17620 stricter. */
17625 "and no declarations were found by "
17626 "argument-dependent lookup at the point "
17633 else
17637 {
17648 {
17650 input_location);
17652 "declarations in dependent base %qT are "
17658 else
17662 }
17663 else
17665 "%qD declared here, later in the "
17668 {
17671 }
17672 }
17675 }
17676 }
17678 {
17683 }
17684 }
17686 /* Remember that there was a reference to this entity. */
17690 {
17693 }
17695 /* Put back tf_decltype for the actual call. */
17700 {
17704 {
17706 "wrong number of arguments to "
17709 }
17710 else
17712 input_location),
17717 /* Unsupported internal function with arguments. */
17719 }
17722 complain);
17724 {
17739 complain);
17740 else
17741 ret = (build_new_method_call
17746 complain));
17747 }
17748 else
17751 koenig_p,
17752 complain);
17757 {
17763 {
17769 {
17771 /* The thunk location is not interesting. */
17773 }
17774 }
17775 }
17778 }
17781 {
17787 {
17789 {
17794 }
17795 else
17796 {
17801 }
17803 }
17804 else
17805 {
17808 }
17812 }
17815 {
17820 input_location));
17821 }
17824 {
17832 {
17833 /* We have pack expansions, so expand those and
17834 create a new list out of it. */
17837 tree chain;
17840 /* Expand the argument expressions. */
17848 /* Build the rest of the list. */
17853 /* Determine the number of arguments. */
17855 {
17858 }
17861 else
17862 {
17863 /* Since we only performed a partial substitution into
17864 the argument pack, we only RETURN (a single list
17865 node. */
17872 }
17874 /* Convert the argument vectors into a TREE_LIST */
17877 {
17878 /* Grab the Ith values. */
17879 i--;
17882 value
17886 /* Build the list (backwards). */
17888 }
17891 }
17907 }
17910 {
17911 tree object;
17912 tree object_type;
17913 tree member;
17914 tree r;
17918 /* Remember that there was a reference to this entity. */
17929 else
17935 {
17940 }
17944 {
17946 {
17951 {
17954 }
17956 {
17961 }
17962 }
17963 }
17966 {
17967 /* Lookup the template functions now that we know what the
17968 scope is. */
17976 {
17979 args);
17980 member = (adjust_result_of_qualified_name_lookup
17982 object_type));
17983 }
17984 else
17985 {
17987 input_location);
17989 }
17990 }
17994 {
17996 {
18000 else
18003 }
18005 }
18009 complain);
18013 }
18020 {
18028 tree r;
18033 /* digest_init will do the wrong thing if we let it. */
18037 /* We do not want to process the index of aggregate
18038 initializers as they are identifier nodes which will be
18039 looked up by digest_init. */
18045 {
18047 /* An identifier index is looked up in the type
18048 being initialized, not the current scope. */
18053 {
18054 /* Substitute into the pack expansion. */
18056 in_decl);
18060 ;
18062 /* Just move the argument into place. */
18064 else
18065 {
18066 /* Update the length of the final CONSTRUCTOR
18067 arguments vector, and note that we will need to
18068 copy.*/
18071 }
18072 }
18073 else
18075 }
18078 {
18083 {
18085 {
18090 }
18091 else
18093 }
18094 }
18100 {
18105 }
18109 }
18112 {
18115 {
18118 }
18119 else
18120 {
18123 }
18124 }
18130 {
18131 /* We don't build decls for an instantiation of a
18132 variadic capture proxy, we instantiate the elements
18133 when needed. */
18136 }
18137 /* Fall through */
18140 {
18142 /* ??? We're doing a subset of finish_id_expression here. */
18144 && !processing_template_decl
18145 && !cp_unevaluated_operand
18148 {
18150 /* Replace an evaluated use of the thread_local variable with
18151 a call to its wrapper. */
18153 }
18158 /* If the original type was a reference, we'll be wrapped in
18159 the appropriate INDIRECT_REF. */
18162 }
18165 {
18169 }
18172 {
18173 tree object_ptr
18180 }
18187 {
18198 }
18201 {
18207 integral_constant_expression_p);
18211 /* If the resulting list of expression statement is empty,
18212 fold it further into void_node. */
18217 }
18220 {
18224 }
18227 /* We can get here for a constant initializer of non-dependent type.
18228 FIXME stop folding in cp_parser_initializer_clause. */
18229 {
18231 complain);
18233 }
18237 integral_constant_expression_p));
18243 {
18248 complain));
18249 }
18255 /* Handle Objective-C++ constructs, if appropriate. */
18256 {
18257 tree subst
18262 }
18264 }
18266 #undef RECUR
18267 #undef RETURN
18268 out:
18271 }
18273 /* Verify that the instantiated ARGS are valid. For type arguments,
18274 make sure that the type's linkage is ok. For non-type arguments,
18275 make sure they are constants if they are integral or enumerations.
18276 Emit an error under control of COMPLAIN, and return TRUE on error. */
18278 static bool
18280 {
18284 {
18294 }
18296 {
18297 /* [basic.link]: A name with no linkage (notably, the name
18298 of a class or enumeration declared in a local scope)
18299 shall not be used to declare an entity with linkage.
18300 This implies that names with no linkage cannot be used as
18301 template arguments
18303 DR 757 relaxes this restriction for C++0x. */
18308 {
18309 /* DR 488 makes use of a type with no linkage cause
18310 type deduction to fail. */
18312 {
18315 else
18318 }
18320 }
18321 /* In order to avoid all sorts of complications, we do not
18322 allow variably-modified types as template arguments. */
18324 {
18328 }
18329 }
18330 /* Class template and alias template arguments should be OK. */
18332 ;
18333 /* A non-type argument of integral or enumerated type must be a
18334 constant. */
18339 {
18343 }
18345 }
18347 static bool
18349 {
18354 {
18357 }
18361 }
18363 /* We're out of SFINAE context now, so generate diagnostics for the access
18364 errors we saw earlier when instantiating D from TMPL and ARGS. */
18366 static void
18368 {
18380 }
18382 /* Instantiate the indicated variable, function, or alias template TMPL with
18383 the template arguments in TARG_PTR. */
18385 static tree
18387 {
18389 tree fndecl;
18390 tree gen_tmpl;
18391 tree spec;
18399 /* If this function is a clone, handle it specially. */
18401 {
18402 tree spec;
18403 tree clone;
18405 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
18406 DECL_CLONED_FUNCTION. */
18412 /* Look for the clone. */
18416 /* We should always have found the clone by now. */
18419 }
18424 /* Check to see if we already have this specialization. */
18428 /* targ_ptr only has the innermost template args, so add the outer ones
18429 from tmpl, which could be either a partial instantiation or gen_tmpl (in
18430 the case of a non-dependent call within a template definition). */
18431 targ_ptr = (add_outermost_template_args
18433 targ_ptr));
18435 /* It would be nice to avoid hashing here and then again in tsubst_decl,
18436 but it doesn't seem to be on the hot path. */
18445 {
18447 {
18451 }
18453 }
18456 complain))
18459 /* We are building a FUNCTION_DECL, during which the access of its
18460 parameters and return types have to be checked. However this
18461 FUNCTION_DECL which is the desired context for access checking
18462 is not built yet. We solve this chicken-and-egg problem by
18463 deferring all checks until we have the FUNCTION_DECL. */
18466 /* Instantiation of the function happens in the context of the function
18467 template, not the context of the overload resolution we're doing. */
18469 /* If there are dependent arguments, e.g. because we're doing partial
18470 ordering, make sure processing_template_decl stays set. */
18474 {
18478 }
18484 {
18485 /* We need to determine if we're using a partial or explicit
18486 specialization now, because the type of the variable could be
18487 different. */
18493 {
18498 }
18499 }
18501 /* Substitute template parameters to obtain the specialization. */
18509 {
18512 }
18514 /* The DECL_TI_TEMPLATE should always be the immediate parent
18515 template, not the most general template. */
18519 /* Now we know the specialization, compute access previously
18520 deferred. Do no access control for inheriting constructors,
18521 as we already checked access for the inherited constructor. */
18524 {
18529 }
18532 /* If we've just instantiated the main entry point for a function,
18533 instantiate all the alternate entry points as well. We do this
18534 by cloning the instantiation of the main entry point, not by
18535 instantiating the template clones. */
18540 {
18542 {
18543 /* Remember to reinstantiate when we're out of SFINAE so the user
18544 can see the errors. */
18546 }
18548 }
18550 }
18552 /* Wrapper for instantiate_template_1. */
18554 tree
18556 {
18557 tree ret;
18562 }
18564 /* Instantiate the alias template TMPL with ARGS. Also push a template
18565 instantiation level, which instantiate_template doesn't do because
18566 functions and variables have sufficient context established by the
18567 callers. */
18569 static tree
18571 {
18578 {
18581 }
18583 args =
18591 /* We can't free this if a pending_template entry or last_error_tinst_level
18592 is pointing at it. */
18598 }
18600 /* PARM is a template parameter pack for FN. Returns true iff
18601 PARM is used in a deducible way in the argument list of FN. */
18603 static bool
18605 {
18608 {
18610 tree packs;
18616 {
18617 /* The template parameter pack is used in a function parameter
18618 pack. If this is the end of the parameter list, the
18619 template parameter pack is deducible. */
18622 else
18623 /* Otherwise, not. Well, it could be deduced from
18624 a non-pack parameter, but doing so would end up with
18625 a deduction mismatch, so don't bother. */
18627 }
18628 }
18629 /* The template parameter pack isn't used in any function parameter
18630 packs, but it might be used deeper, e.g. tuple<Args...>. */
18632 }
18634 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
18635 NARGS elements of the arguments that are being used when calling
18636 it. TARGS is a vector into which the deduced template arguments
18637 are placed.
18639 Returns either a FUNCTION_DECL for the matching specialization of FN or
18640 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
18641 true, diagnostics will be printed to explain why it failed.
18643 If FN is a conversion operator, or we are trying to produce a specific
18644 specialization, RETURN_TYPE is the return type desired.
18646 The EXPLICIT_TARGS are explicit template arguments provided via a
18647 template-id.
18649 The parameter STRICT is one of:
18651 DEDUCE_CALL:
18652 We are deducing arguments for a function call, as in
18653 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
18654 deducing arguments for a call to the result of a conversion
18655 function template, as in [over.call.object].
18657 DEDUCE_CONV:
18658 We are deducing arguments for a conversion function, as in
18659 [temp.deduct.conv].
18661 DEDUCE_EXACT:
18662 We are deducing arguments when doing an explicit instantiation
18663 as in [temp.explicit], when determining an explicit specialization
18664 as in [temp.expl.spec], or when taking the address of a function
18665 template, as in [temp.deduct.funcaddr]. */
18667 tree
18669 tree explicit_targs,
18670 tree targs,
18673 tree return_type,
18674 unification_kind_t strict,
18678 {
18679 tree parms;
18680 tree fntype;
18693 tree tinst;
18699 full_targs = (add_outermost_template_args
18701 targs));
18706 /* In C++0x, it's possible to have a function template whose type depends
18707 on itself recursively. This is most obvious with decltype, but can also
18708 occur with enumeration scope (c++/48969). So we need to catch infinite
18709 recursion and reject the substitution at deduction time; this function
18710 will return error_mark_node for any repeated substitution.
18712 This also catches excessive recursion such as when f<N> depends on
18713 f<N-1> across all integers, and returns error_mark_node for all the
18714 substitutions back up to the initial one.
18716 This is, of course, not reentrant. */
18726 {
18727 /* [temp.deduct]
18729 The specified template arguments must match the template
18730 parameters in kind (i.e., type, nontype, template), and there
18731 must not be more arguments than there are parameters;
18732 otherwise type deduction fails.
18734 Nontype arguments must match the types of the corresponding
18735 nontype template parameters, or must be convertible to the
18736 types of the corresponding nontype parameters as specified in
18737 _temp.arg.nontype_, otherwise type deduction fails.
18739 All references in the function type of the function template
18740 to the corresponding template parameters are replaced by the
18741 specified template argument values. If a substitution in a
18742 template parameter or in the function type of the function
18743 template results in an invalid type, type deduction fails. */
18754 explicit_targs);
18756 /* Adjust any explicit template arguments before entering the
18757 substitution context. */
18758 explicit_targs
18760 complain,
18766 /* Substitute the explicit args into the function type. This is
18767 necessary so that, for instance, explicitly declared function
18768 arguments can match null pointed constants. If we were given
18769 an incomplete set of explicit args, we must not do semantic
18770 processing during substitution as we could create partial
18771 instantiations. */
18773 {
18778 /* Dig out the actual parm. */
18781 {
18784 }
18786 {
18789 }
18792 /* No explicit argument for this template parameter. */
18796 {
18797 /* Mark the argument pack as "incomplete". We could
18798 still deduce more arguments during unification.
18799 We remove this mark in type_unification_real. */
18801 {
18805 }
18807 /* We have some incomplete argument packs. */
18809 }
18810 }
18814 {
18817 }
18820 /* Ignore any access checks; we'll see them again in
18821 instantiate_template and they might have the wrong
18822 access path at this point. */
18834 /* Place the explicitly specified arguments in TARGS. */
18838 }
18840 /* Never do unification on the 'this' parameter. */
18844 {
18845 /* We're deducing for a call to the result of a template conversion
18846 function. The parms we really want are in return_type. */
18850 }
18852 {
18861 }
18863 /* We allow incomplete unification without an error message here
18864 because the standard doesn't seem to explicitly prohibit it. Our
18865 callers must be ready to deal with unification failures in any
18866 event. */
18869 /* If we aren't explaining yet, push tinst context so we can see where
18870 any errors (e.g. from class instantiations triggered by instantiation
18871 of default template arguments) come from. If we are explaining, this
18872 context is redundant. */
18874 {
18877 }
18879 /* type_unification_real will pass back any access checks from default
18880 template argument substitution. */
18892 /* Now that we have bindings for all of the template arguments,
18893 ensure that the arguments deduced for the template template
18894 parameters have compatible template parameter lists. We cannot
18895 check this property before we have deduced all template
18896 arguments, because the template parameter types of a template
18897 template parameter might depend on prior template parameters
18898 deduced after the template template parameter. The following
18899 ill-formed example illustrates this issue:
18901 template<typename T, template<T> class C> void f(C<5>, T);
18903 template<int N> struct X {};
18905 void g() {
18906 f(X<5>(), 5l); // error: template argument deduction fails
18907 }
18909 The template parameter list of 'C' depends on the template type
18910 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
18911 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
18912 time that we deduce 'C'. */
18915 {
18918 }
18920 /* All is well so far. Now, check:
18922 [temp.deduct]
18924 When all template arguments have been deduced, all uses of
18925 template parameters in nondeduced contexts are replaced with
18926 the corresponding deduced argument values. If the
18927 substitution results in an invalid type, as described above,
18928 type deduction fails. */
18931 {
18934 }
18936 /* Also collect access checks from the instantiation. */
18949 /* Now perform any access checks encountered during substitution. */
18956 /* If we're looking for an exact match, check that what we got
18957 is indeed an exact match. It might not be if some template
18958 parameters are used in non-deduced contexts. But don't check
18959 for an exact match if we have dependent template arguments;
18960 in that case we're doing partial ordering, and we already know
18961 that we have two candidates that will provide the actual type. */
18963 {
18967 tree sarg
18973 {
18977 }
18978 }
18980 /* After doing deduction with the inherited constructor, actually return an
18981 instantiation of the inheriting constructor. */
18987 fail:
18990 {
18992 /* Reset once we're all the way out. */
18994 }
18996 /* We can't free this if a pending_template entry or last_error_tinst_level
18997 is pointing at it. */
19003 }
19005 /* Adjust types before performing type deduction, as described in
19006 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
19007 sections are symmetric. PARM is the type of a function parameter
19008 or the return type of the conversion function. ARG is the type of
19009 the argument passed to the call, or the type of the value
19010 initialized with the result of the conversion function.
19011 ARG_EXPR is the original argument expression, which may be null. */
19013 static int
19017 tree arg_expr)
19018 {
19022 {
19027 /* Swap PARM and ARG throughout the remainder of this
19028 function; the handling is precisely symmetric since PARM
19029 will initialize ARG rather than vice versa. */
19034 /* Core issue #873: Do the DR606 thing (see below) for these cases,
19035 too, but here handle it by stripping the reference from PARM
19036 rather than by adding it to ARG. */
19044 /* Nothing else to do in this case. */
19049 }
19052 {
19053 /* [temp.deduct.call]
19055 If P is not a reference type:
19057 --If A is an array type, the pointer type produced by the
19058 array-to-pointer standard conversion (_conv.array_) is
19059 used in place of A for type deduction; otherwise,
19061 --If A is a function type, the pointer type produced by
19062 the function-to-pointer standard conversion
19063 (_conv.func_) is used in place of A for type deduction;
19064 otherwise,
19066 --If A is a cv-qualified type, the top level
19067 cv-qualifiers of A's type are ignored for type
19068 deduction. */
19073 else
19075 }
19077 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
19078 reference to a cv-unqualified template parameter that does not represent a
19079 template parameter of a class template (during class template argument
19080 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
19081 an lvalue, the type "lvalue reference to A" is used in place of A for type
19082 deduction. */
19089 /* try_one_overload doesn't provide an arg_expr, but
19090 functions are always lvalues. */
19094 /* [temp.deduct.call]
19096 If P is a cv-qualified type, the top level cv-qualifiers
19097 of P's type are ignored for type deduction. If P is a
19098 reference type, the type referred to by P is used for
19099 type deduction. */
19102 {
19105 }
19107 /* DR 322. For conversion deduction, remove a reference type on parm
19108 too (which has been swapped into ARG). */
19113 }
19115 /* Subroutine of unify_one_argument. PARM is a function parameter of a
19116 template which does contain any deducible template parameters; check if
19117 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
19118 unify_one_argument. */
19120 static int
19123 {
19124 tree type;
19128 else
19135 {
19139 }
19141 {
19146 }
19150 else
19152 }
19156 /* Returns true iff the expression EXPR is one from which a template
19157 argument can be deduced. In other words, if it's an undecorated
19158 use of a template non-type parameter. */
19160 static bool
19162 {
19163 /* Strip implicit conversions. */
19167 }
19169 /* Returns true iff the array domain DOMAIN uses a template parameter in a
19170 deducible way; that is, if it has a max value of <PARM> - 1. */
19172 static bool
19174 {
19183 }
19185 /* Returns true iff the template arguments ARGS use a template parameter
19186 in a deducible way. */
19188 static bool
19190 {
19192 {
19197 else
19198 {
19205 else
19207 }
19210 }
19212 }
19214 /* Returns true iff TYPE contains any deducible references to template
19215 parameters, as per 14.8.2.5. */
19217 static bool
19219 {
19223 /* T
19224 cv-list T
19225 TT<T>
19226 TT<i>
19227 TT<> */
19232 /* T*
19233 T&
19234 T&& */
19238 /* T[integer-constant ]
19239 type [i] */
19244 /* T type ::*
19245 type T::*
19246 T T::*
19247 T (type ::*)()
19248 type (T::*)()
19249 type (type ::*)(T)
19250 type (T::*)(T)
19251 T (type ::*)(T)
19252 T (T::*)()
19253 T (T::*)(T) */
19256 || (uses_deducible_template_parms
19259 /* template-name <T> (where template-name refers to a class template)
19260 template-name <i> (where template-name refers to a class template) */
19267 /* type (T)
19268 T()
19269 T(T) */
19272 {
19281 }
19284 }
19286 /* Subroutine of type_unification_real and unify_pack_expansion to
19287 handle unification of a single P/A pair. Parameters are as
19288 for those functions. */
19290 static int
19294 {
19301 /* We can't deduce anything from this, but we might get all the
19302 template args from other function args. */
19305 /* Implicit conversions (Clause 4) will be performed on a function
19306 argument to convert it to the type of the corresponding function
19307 parameter if the parameter type contains no template-parameters that
19308 participate in template argument deduction. */
19311 /* For function parameters with no deducible template parameters,
19312 just return. We'll check non-dependent conversions later. */
19316 {
19318 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
19319 | UNIFY_ALLOW_MORE_CV_QUAL
19333 }
19335 /* We only do these transformations if this is the top-level
19336 parameter_type_list in a call or declaration matching; in other
19337 situations (nested function declarators, template argument lists) we
19338 won't be comparing a type to an expression, and we don't do any type
19339 adjustments. */
19341 {
19343 {
19346 {
19347 /* [temp.deduct.type] A template-argument can be
19348 deduced from a pointer to function or pointer
19349 to member function argument if the set of
19350 overloaded functions does not contain function
19351 templates and at most one of a set of
19352 overloaded functions provides a unique
19353 match. */
19357 /* If a unique match was not found, this is a
19358 non-deduced context, so we still succeed. */
19360 }
19366 }
19368 arg_strict |=
19370 }
19371 else
19376 /* For deduction from an init-list we need the actual list. */
19380 }
19382 /* for_each_template_parm callback that always returns 0. */
19384 static int
19386 {
19388 }
19390 /* for_each_template_parm any_fn callback to handle deduction of a template
19391 type argument from the type of an array bound. */
19393 static int
19395 {
19403 {
19409 }
19411 /* Keep walking. */
19413 }
19415 /* Try to deduce any not-yet-deduced template type arguments from the type of
19416 an array bound. This is handled separately from unify because 14.8.2.5 says
19417 "The type of a type parameter is only deduced from an array bound if it is
19418 not otherwise deduced." */
19420 static void
19422 {
19427 }
19429 /* Most parms like fn_type_unification.
19431 If SUBR is 1, we're being called recursively (to unify the
19432 arguments of a function or method parameter of a function
19433 template).
19435 CHECKS is a pointer to a vector of access checks encountered while
19436 substituting default template arguments. */
19438 static int
19440 tree full_targs,
19441 tree xparms,
19445 unification_kind_t strict,
19449 {
19454 tree parms;
19465 /* Reset the number of non-defaulted template arguments contained
19466 in TARGS. */
19469 again:
19477 {
19482 /* For a function parameter pack that occurs at the end of the
19483 parameter-declaration-list, the type A of each remaining
19484 argument of the call is compared with the type P of the
19485 declarator-id of the function parameter pack. */
19491 /* For a function parameter pack that does not occur at the
19492 end of the parameter-declaration-list, the type of the
19493 parameter pack is a non-deduced context. */
19500 explain_p))
19502 }
19507 {
19508 /* Unify the remaining arguments with the pack expansion type. */
19509 tree argvec;
19512 /* Allocate a TREE_VEC and copy in all of the arguments */
19517 /* Copy the parameter into parmvec. */
19523 /* Advance to the end of the list of parameters. */
19525 }
19527 /* Fail if we've reached the end of the parm list, and more args
19528 are present, and the parm list isn't variadic. */
19531 /* Fail if parms are left and they don't have default values and
19532 they aren't all deduced as empty packs (c++/57397). This is
19533 consistent with sufficient_parms_p. */
19536 {
19540 do
19541 {
19544 count++;
19546 }
19550 type_pack_p);
19551 }
19554 {
19555 tsubst_flags_t complain = (explain_p
19556 ? tf_warning_or_error
19561 {
19565 /* Clear the "incomplete" flags on all argument packs now so that
19566 substituting them into later default arguments works. */
19568 {
19571 }
19579 {
19584 }
19586 /* If this is an undeduced nontype parameter that depends on
19587 a type parameter, try another pass; its type may have been
19588 deduced from a later argument than the one from which
19589 this parameter can be deduced. */
19593 {
19596 }
19598 /* Core issue #226 (C++0x) [temp.deduct]:
19600 If a template argument has not been deduced, its
19601 default template argument, if any, is used.
19603 When we are in C++98 mode, TREE_PURPOSE will either
19604 be NULL_TREE or ERROR_MARK_NODE, so we do not need
19605 to explicitly check cxx_dialect here. */
19607 /* OK, there is a default argument. Wait until after the
19608 conversion check to do substitution. */
19611 /* If the type parameter is a parameter pack, then it will
19612 be deduced to an empty parameter pack. */
19614 {
19615 tree arg;
19618 {
19621 }
19622 else
19629 }
19632 }
19634 /* DR 1391: All parameters have args, now check non-dependent parms for
19635 convertibility. */
19639 {
19645 /* For a function parameter pack that occurs at the end of the
19646 parameter-declaration-list, the type A of each remaining
19647 argument of the call is compared with the type P of the
19648 declarator-id of the function parameter pack. */
19654 /* For a function parameter pack that does not occur at the
19655 end of the parameter-declaration-list, the type of the
19656 parameter pack is a non-deduced context. */
19665 explain_p))
19667 }
19669 /* Now substitute into the default template arguments. */
19671 {
19695 else
19703 {
19705 /* The position of the first default template argument,
19706 is also the number of non-defaulted arguments in TARGS.
19707 Record that. */
19710 }
19711 }
19715 }
19721 }
19723 /* Subroutine of type_unification_real. Args are like the variables
19724 at the call site. ARG is an overloaded function (or template-id);
19725 we try deducing template args from each of the overloads, and if
19726 only one succeeds, we go with that. Modifies TARGS and returns
19727 true on success. */
19729 static bool
19731 tree targs,
19732 tree parm,
19733 tree arg,
19734 unification_kind_t strict,
19737 {
19744 {
19747 }
19748 else
19752 /* Handle `&x' where `x' is some static or non-static member
19753 function name. */
19759 /* Strip baselink information. */
19764 {
19765 /* If we got some explicit template args, we need to plug them into
19766 the affected templates before we try to unify, in case the
19767 explicit args will completely resolve the templates in question. */
19774 {
19787 {
19792 {
19795 }
19796 }
19799 }
19800 /* If no templates (or more than one) are fully resolved by the
19801 explicit arguments, this template-id is a non-deduced context; it
19802 could still be OK if we deduce all template arguments for the
19803 enclosing call through other arguments. */
19806 }
19809 /* If ARG is, for example, "(0, &f)" then its type will be unknown
19810 -- but the deduction does not succeed because the expression is
19811 not just the function on its own. */
19813 else
19815 {
19820 {
19823 }
19824 }
19826 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19827 to function or pointer to member function argument if the set of
19828 overloaded functions does not contain function templates and at most
19829 one of a set of overloaded functions provides a unique match.
19831 So if we found multiple possibilities, we return success but don't
19832 deduce anything. */
19835 {
19839 {
19844 /* Don't forget explicit template arguments in a pack. */
19848 }
19849 }
19854 }
19856 /* Core DR 115: In contexts where deduction is done and fails, or in
19857 contexts where deduction is not done, if a template argument list is
19858 specified and it, along with any default template arguments, identifies
19859 a single function template specialization, then the template-id is an
19860 lvalue for the function template specialization. */
19862 tree
19864 {
19877 {
19880 }
19882 {
19885 }
19887 {
19890 }
19893 {
19897 /* If we got some explicit template args, we need to plug them into
19898 the affected templates before we try to unify, in case the
19899 explicit args will completely resolve the templates in question. */
19907 {
19920 {
19923 {
19926 }
19928 {
19931 }
19932 }
19933 }
19935 {
19943 {
19944 tree base
19947 }
19951 }
19953 /* There were no good options and at least one bad one, so let the
19954 user know what the problem is. */
19956 }
19958 }
19960 /* Subroutine of resolve_overloaded_unification; does deduction for a single
19961 overload. Fills TARGS with any deduced arguments, or error_mark_node if
19962 different overloads deduce different arguments for a given parm.
19963 ADDR_P is true if the expression for which deduction is being
19964 performed was of the form "& fn" rather than simply "fn".
19966 Returns 1 on success. */
19968 static int
19970 tree orig_targs,
19971 tree targs,
19972 tree parm,
19973 tree arg,
19974 unification_kind_t strict,
19978 {
19980 tree tempargs;
19986 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19987 to function or pointer to member function argument if the set of
19988 overloaded functions does not contain function templates and at most
19989 one of a set of overloaded functions provides a unique match.
19991 So if this is a template, just return success. */
20003 /* We don't copy orig_targs for this because if we have already deduced
20004 some template args from previous args, unify would complain when we
20005 try to deduce a template parameter for the same argument, even though
20006 there isn't really a conflict. */
20013 /* First make sure we didn't deduce anything that conflicts with
20014 explicitly specified args. */
20016 {
20023 /* Since we're unifying against ourselves, we will fill in
20024 template args used in the function parm list with our own
20025 template parms. Discard them. */
20028 {
20029 /* Check that the argument at each index of the deduced argument pack
20030 is equivalent to the corresponding explicitly specified argument.
20031 We may have deduced more arguments than were explicitly specified,
20032 and that's OK. */
20034 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
20035 that's wrong if we deduce the same argument pack from multiple
20036 function arguments: it's only incomplete the first time. */
20049 }
20052 }
20055 {
20060 }
20063 }
20065 /* PARM is a template class (perhaps with unbound template
20066 parameters). ARG is a fully instantiated type. If ARG can be
20067 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
20068 TARGS are as for unify. */
20070 static tree
20073 {
20074 tree copy_of_targs;
20084 /* We need to make a new template argument vector for the call to
20085 unify. If we used TARGS, we'd clutter it up with the result of
20086 the attempted unification, even if this class didn't work out.
20087 We also don't want to commit ourselves to all the unifications
20088 we've already done, since unification is supposed to be done on
20089 an argument-by-argument basis. In other words, consider the
20090 following pathological case:
20092 template <int I, int J, int K>
20093 struct S {};
20095 template <int I, int J>
20096 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
20098 template <int I, int J, int K>
20099 void f(S<I, J, K>, S<I, I, I>);
20101 void g() {
20102 S<0, 0, 0> s0;
20103 S<0, 1, 2> s2;
20105 f(s0, s2);
20106 }
20108 Now, by the time we consider the unification involving `s2', we
20109 already know that we must have `f<0, 0, 0>'. But, even though
20110 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
20111 because there are two ways to unify base classes of S<0, 1, 2>
20112 with S<I, I, I>. If we kept the already deduced knowledge, we
20113 would reject the possibility I=1. */
20117 {
20121 }
20123 /* If unification failed, we're done. */
20129 }
20131 /* Given a template type PARM and a class type ARG, find the unique
20132 base type in ARG that is an instance of PARM. We do not examine
20133 ARG itself; only its base-classes. If there is not exactly one
20134 appropriate base class, return NULL_TREE. PARM may be the type of
20135 a partial specialization, as well as a plain template type. Used
20136 by unify. */
20138 static enum template_base_result
20141 {
20143 tree binfo;
20149 {
20150 /* The type could not be completed. */
20153 }
20155 /* Walk in inheritance graph order. The search order is not
20156 important, and this avoids multiple walks of virtual bases. */
20158 {
20163 {
20164 /* If there is more than one satisfactory baseclass, then:
20166 [temp.deduct.call]
20168 If they yield more than one possible deduced A, the type
20169 deduction fails.
20171 applies. */
20173 {
20176 }
20179 }
20180 }
20184 }
20186 /* Returns the level of DECL, which declares a template parameter. */
20188 static int
20190 {
20192 {
20202 }
20204 }
20206 /* Decide whether ARG can be unified with PARM, considering only the
20207 cv-qualifiers of each type, given STRICT as documented for unify.
20208 Returns nonzero iff the unification is OK on that basis. */
20210 static int
20212 {
20218 {
20219 /* Although a CVR qualifier is ignored when being applied to a
20220 substituted template parameter ([8.3.2]/1 for example), that
20221 does not allow us to unify "const T" with "int&" because both
20222 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
20223 It is ok when we're allowing additional CV qualifiers
20224 at the outer level [14.8.2.1]/3,1st bullet. */
20234 }
20245 }
20247 /* Determines the LEVEL and INDEX for the template parameter PARM. */
20248 void
20250 {
20254 {
20257 }
20258 else
20259 {
20262 }
20263 }
20265 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
20266 do { \
20267 if (unify (TP, TA, P, A, S, EP)) \
20268 return 1; \
20269 } while (0)
20271 /* Unifies the remaining arguments in PACKED_ARGS with the pack
20272 expansion at the end of PACKED_PARMS. Returns 0 if the type
20273 deduction succeeds, 1 otherwise. STRICT is the same as in
20274 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
20275 function call argument list. We'll need to adjust the arguments to make them
20276 types. SUBR tells us if this is from a recursive call to
20277 type_unification_real, or for comparing two template argument
20278 lists. */
20280 static int
20284 {
20285 tree parm
20291 /* Add in any args remembered from an earlier partial instantiation. */
20298 /* Determine the parameter packs we will be deducing from the
20299 pattern, and record their current deductions. */
20302 {
20306 /* Determine the index and level of this parameter pack. */
20309 /* Keep track of the parameter packs and their corresponding
20310 argument packs. */
20313 }
20315 /* Loop through all of the arguments that have not yet been
20316 unified and unify each with the pattern. */
20318 {
20319 tree parm;
20323 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
20324 or the element of its argument pack at the current index if
20325 this argument was explicitly specified. */
20327 {
20336 {
20339 }
20341 }
20343 /* If we had explicit template arguments, substitute them into the
20344 pattern before deduction. */
20346 {
20347 /* Some arguments might still be unspecified or dependent. */
20355 NULL_TREE);
20360 }
20361 else
20364 /* Unify the pattern with the current argument. */
20366 explain_p))
20369 /* For each parameter pack, collect the deduced value. */
20371 {
20377 }
20378 }
20380 /* Verify that the results of unification with the parameter packs
20381 produce results consistent with what we've seen before, and make
20382 the deduced argument packs available. */
20384 {
20391 /* By default keep the original deduced argument pack.
20392 If necessary, more specific code is going to update the
20393 resulting deduced argument later down in this function. */
20397 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
20398 actually deduce anything. */
20406 {
20407 /* If we had fewer function args than explicit template args,
20408 just use the explicits. */
20413 }
20416 {
20417 tree result;
20418 /* Build the deduced *_ARGUMENT_PACK. */
20420 {
20423 }
20424 else
20429 /* Note the deduced argument packs for this parameter
20430 pack. */
20432 }
20436 {
20437 /* We only had the explicitly-provided arguments before, but
20438 now we have a complete set of arguments. */
20444 }
20445 else
20446 {
20452 /* Inconsistent unification of this parameter pack. */
20454 bad_old_arg,
20455 bad_new_arg);
20456 }
20457 }
20460 }
20462 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
20463 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
20464 parameters and return value are as for unify. */
20466 static int
20470 {
20471 tree parm_max;
20472 tree arg_max;
20476 /* Our representation of array types uses "N - 1" as the
20477 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
20478 not an integer constant. We cannot unify arbitrarily
20479 complex expressions, so we eliminate the MINUS_EXPRs
20480 here. */
20484 {
20487 }
20491 {
20492 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
20493 trying to unify the type of a variable with the type
20494 of a template parameter. For example:
20496 template <unsigned int N>
20497 void f (char (&) [N]);
20498 int g();
20499 void h(int i) {
20500 char a[g(i)];
20501 f(a);
20502 }
20504 Here, the type of the ARG will be "int [g(i)]", and
20505 may be a SAVE_EXPR, etc. */
20509 }
20511 /* If only one of the bounds used a MINUS_EXPR, compensate
20512 by adding one to the other bound. */
20515 integer_type_node,
20516 parm_max,
20517 integer_one_node);
20520 integer_type_node,
20521 arg_max,
20522 integer_one_node);
20526 }
20528 /* Returns whether T, a P or A in unify, is a type, template or expression. */
20532 static pa_kind_t
20534 {
20543 else
20545 }
20547 /* Deduce the value of template parameters. TPARMS is the (innermost)
20548 set of template parameters to a template. TARGS is the bindings
20549 for those template parameters, as determined thus far; TARGS may
20550 include template arguments for outer levels of template parameters
20551 as well. PARM is a parameter to a template function, or a
20552 subcomponent of that parameter; ARG is the corresponding argument.
20553 This function attempts to match PARM with ARG in a manner
20554 consistent with the existing assignments in TARGS. If more values
20555 are deduced, then TARGS is updated.
20557 Returns 0 if the type deduction succeeds, 1 otherwise. The
20558 parameter STRICT is a bitwise or of the following flags:
20560 UNIFY_ALLOW_NONE:
20561 Require an exact match between PARM and ARG.
20562 UNIFY_ALLOW_MORE_CV_QUAL:
20563 Allow the deduced ARG to be more cv-qualified (by qualification
20564 conversion) than ARG.
20565 UNIFY_ALLOW_LESS_CV_QUAL:
20566 Allow the deduced ARG to be less cv-qualified than ARG.
20567 UNIFY_ALLOW_DERIVED:
20568 Allow the deduced ARG to be a template base class of ARG,
20569 or a pointer to a template base class of the type pointed to by
20570 ARG.
20571 UNIFY_ALLOW_INTEGER:
20572 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
20573 case for more information.
20574 UNIFY_ALLOW_OUTER_LEVEL:
20575 This is the outermost level of a deduction. Used to determine validity
20576 of qualification conversions. A valid qualification conversion must
20577 have const qualified pointers leading up to the inner type which
20578 requires additional CV quals, except at the outer level, where const
20579 is not required [conv.qual]. It would be normal to set this flag in
20580 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
20581 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
20582 This is the outermost level of a deduction, and PARM can be more CV
20583 qualified at this point.
20584 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
20585 This is the outermost level of a deduction, and PARM can be less CV
20586 qualified at this point. */
20588 static int
20591 {
20593 tree targ;
20594 tree tparm;
20596 tsubst_flags_t complain = (explain_p
20597 ? tf_warning_or_error
20600 /* I don't think this will do the right thing with respect to types.
20601 But the only case I've seen it in so far has been array bounds, where
20602 signedness is the only information lost, and I think that will be
20603 okay. */
20611 /* We can't deduce anything from this, but we might get all the
20612 template args from other function args. */
20618 /* If PARM uses template parameters, then we can't bail out here,
20619 even if ARG == PARM, since we won't record unifications for the
20620 template parameters. We might need them if we're trying to
20621 figure out which of two things is more specialized. */
20625 /* Handle init lists early, so the rest of the function can assume
20626 we're dealing with a type. */
20628 {
20633 /* Replace T with std::initializer_list<T> for deduction. */
20640 /* We can only deduce from an initializer list argument if the
20641 parameter is std::initializer_list or an array; otherwise this
20642 is a non-deduced context. */
20647 else
20648 {
20650 /* Deduction is defined in terms of a single type, so just punt
20651 on the (bizarre) std::initializer_list<T...>. */
20654 }
20657 {
20664 {
20668 /* It should only be possible to get here for a call. */
20670 elt_strict |= maybe_adjust_types_for_deduction
20673 }
20676 explain_p);
20677 }
20681 {
20682 /* Also deduce from the length of the initializer list. */
20689 }
20691 /* If the std::initializer_list<T> deduction worked, replace the
20692 deduced A with std::initializer_list<A>. */
20694 {
20699 }
20701 }
20703 /* If parm and arg aren't the same kind of thing (template, type, or
20704 expression), fail early. */
20708 /* Immediately reject some pairs that won't unify because of
20709 cv-qualification mismatches. */
20712 /* It is the elements of the array which hold the cv quals of an array
20713 type, and the elements might be template type parms. We'll check
20714 when we recurse. */
20716 /* We check the cv-qualifiers when unifying with template type
20717 parameters below. We want to allow ARG `const T' to unify with
20718 PARM `T' for example, when computing which of two templates
20719 is more specialized, for example. */
20733 {
20737 /* In a type which contains a nested-name-specifier, template
20738 argument values cannot be deduced for template parameters used
20739 within the nested-name-specifier. */
20751 /* The PARM is not one we're trying to unify. Just check
20752 to see if it matches ARG. */
20753 {
20758 else
20760 }
20767 /* Check for mixed types and values. */
20775 {
20778 {
20779 /* First try to match ARG directly. */
20781 explain_p);
20783 {
20784 /* Otherwise, look for a suitable base of ARG, as below. */
20791 }
20792 }
20793 /* ARG must be constructed from a template class or a template
20794 template parameter. */
20799 /* Deduce arguments T, i from TT<T> or TT<i>. */
20805 /* Fall through to deduce template name. */
20806 }
20810 {
20811 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
20813 /* Simple cases: Value already set, does match or doesn't. */
20818 }
20819 else
20820 {
20821 /* If PARM is `const T' and ARG is only `int', we don't have
20822 a match unless we are allowing additional qualification.
20823 If ARG is `const int' and PARM is just `T' that's OK;
20824 that binds `const int' to `T'. */
20829 /* Consider the case where ARG is `const volatile int' and
20830 PARM is `const T'. Then, T should be `volatile int'. */
20831 arg = cp_build_qualified_type_real
20836 /* Simple cases: Value already set, does match or doesn't. */
20842 /* Make sure that ARG is not a variable-sized array. (Note
20843 that were talking about variable-sized arrays (like
20844 `int[n]'), rather than arrays of unknown size (like
20845 `int[]').) We'll get very confused by such a type since
20846 the bound of the array is not constant, and therefore
20847 not mangleable. Besides, such types are not allowed in
20848 ISO C++, so we can do as we please here. We do allow
20849 them for 'auto' deduction, since that isn't ABI-exposed. */
20853 /* Strip typedefs as in convert_template_argument. */
20855 }
20857 /* If ARG is a parameter pack or an expansion, we cannot unify
20858 against it unless PARM is also a parameter pack. */
20863 /* If the argument deduction results is a METHOD_TYPE,
20864 then there is a problem.
20865 METHOD_TYPE doesn't map to any real C++ type the result of
20866 the deduction can not be of that type. */
20880 {
20881 /* The PARM is not one we're trying to unify. Just check
20882 to see if it matches ARG. */
20888 }
20894 {
20899 }
20901 /* [temp.deduct.type] If, in the declaration of a function template
20902 with a non-type template-parameter, the non-type
20903 template-parameter is used in an expression in the function
20904 parameter-list and, if the corresponding template-argument is
20905 deduced, the template-argument type shall match the type of the
20906 template-parameter exactly, except that a template-argument
20907 deduced from an array bound may be of any integral type.
20908 The non-type parameter might use already deduced type parameters. */
20911 {
20915 }
20918 /* Template-parameter dependent expression. Just accept it for now.
20919 It will later be processed in convert_template_argument. */
20920 ;
20926 /* Convert the ARG to the type of PARM; the deduced non-type
20927 template argument must exactly match the types of the
20928 corresponding parameter. */
20931 {
20932 /* We haven't deduced the type of this parameter yet. */
20934 /* We deduce from array bounds in try_array_deduction. */
20936 {
20937 /* Deduce it from the non-type argument. */
20942 }
20943 else
20944 /* Try again later. */
20946 }
20947 else
20950 /* If ARG is a parameter pack or an expansion, we cannot unify
20951 against it unless PARM is also a parameter pack. */
20956 {
20959 }
20964 {
20965 /* A pointer-to-member constant can be unified only with
20966 another constant. */
20970 /* Just unify the class member. It would be useless (and possibly
20971 wrong, depending on the strict flags) to unify also
20972 PTRMEM_CST_CLASS, because we want to be sure that both parm and
20973 arg refer to the same variable, even if through different
20974 classes. For instance:
20976 struct A { int x; };
20977 struct B : A { };
20979 Unification of &A::x and &B::x must succeed. */
20982 }
20985 {
20989 /* [temp.deduct.call]
20991 A can be another pointer or pointer to member type that can
20992 be converted to the deduced A via a qualification
20993 conversion (_conv.qual_).
20995 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
20996 This will allow for additional cv-qualification of the
20997 pointed-to types if appropriate. */
21000 /* The derived-to-base conversion only persists through one
21001 level of pointers. */
21006 }
21038 /* We have already checked cv-qualification at the top of the
21039 function. */
21043 /* As far as unification is concerned, this wins. Later checks
21044 will invalidate it if necessary. */
21047 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
21048 /* Type INTEGER_CST can come from ordinary constant template args. */
21060 {
21070 /* Check for pack expansions in the parameters. */
21072 {
21074 {
21076 /* We can unify against something with a trailing
21077 parameter pack. */
21079 else
21080 /* [temp.deduct.type]/9: If the template argument list of
21081 P contains a pack expansion that is not the last
21082 template argument, the entire template argument list
21083 is a non-deduced context. */
21085 }
21086 }
21088 /* If we don't have enough arguments to satisfy the parameters
21089 (not counting the pack expression at the end), or we have
21090 too many arguments for a parameter list that doesn't end in
21091 a pack expression, we can't unify. */
21097 /* Unify all of the parameters that precede the (optional)
21098 pack expression. */
21100 {
21105 }
21108 DEDUCE_EXACT,
21111 }
21119 {
21127 }
21132 {
21136 {
21137 /* First, we try to unify the PARM and ARG directly. */
21142 {
21143 /* Fallback to the special case allowed in
21144 [temp.deduct.call]:
21146 If P is a class, and P has the form
21147 template-id, then A can be a derived class of
21148 the deduced A. Likewise, if P is a pointer to
21149 a class of the form template-id, A can be a
21150 pointer to a derived class pointed to by the
21151 deduced A. */
21157 {
21158 /* Don't give the derived diagnostic if we're
21159 already dealing with the same template. */
21160 bool same_template
21166 }
21167 }
21168 }
21172 /* Perhaps PARM is something like S<U> and ARG is S<int>.
21173 Then, we should unify `int' and `U'. */
21175 else
21176 /* There's no chance of unification succeeding. */
21181 }
21188 {
21191 tree a;
21197 /* CV qualifications for methods can never be deduced, they must
21198 match exactly. We need to check them explicitly here,
21199 because type_unification_real treats them as any other
21200 cv-qualified parameter. */
21202 && (!check_cv_quals_for_unify
21230 {
21242 }
21245 }
21248 /* Unify a pointer to member with a pointer to member function, which
21249 deduces the type of the member as a function type. */
21251 {
21252 /* Check top-level cv qualifiers */
21260 /* Determine the type of the function we are unifying against. */
21264 }
21283 /* Matched cases are handled by the ARG == PARM test above. */
21287 /* We might get a variable as a non-type template argument in parm if the
21288 corresponding parameter is type-dependent. Make any necessary
21289 adjustments based on whether arg is a reference. */
21293 {
21298 }
21299 /* Now use the normal expression code to check whether they match. */
21310 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
21311 or UNDERLYING_TYPE nodes. */
21315 /* Unification fails if we hit an error node. */
21320 {
21330 }
21331 /* FALLTHRU */
21334 /* An unresolved overload is a nondeduced context. */
21338 expr:
21339 /* We must be looking at an expression. This can happen with
21340 something like:
21342 template <int I>
21343 void foo(S<I>, S<I + 2>);
21345 This is a "nondeduced context":
21347 [deduct.type]
21349 The nondeduced contexts are:
21351 --A type that is a template-id in which one or more of
21352 the template-arguments is an expression that references
21353 a template-parameter.
21355 In these cases, we assume deduction succeeded, but don't
21356 actually infer any unifications. */
21361 else
21363 }
21364 }
21365 #undef RECUR_AND_CHECK_FAILURE
21366 \f
21367 /* Note that DECL can be defined in this translation unit, if
21368 required. */
21370 static void
21372 {
21373 tree clone;
21377 }
21379 /* Called if RESULT is explicitly instantiated, or is a member of an
21380 explicitly instantiated class. */
21382 void
21384 {
21387 /* If this entity has already been written out, it's too late to
21388 make any modifications. */
21392 /* For anonymous namespace we don't need to do anything. */
21394 {
21397 }
21400 /* The TREE_PUBLIC flag for function declarations will have been
21401 set correctly by tsubst. */
21404 /* This might have been set by an earlier implicit instantiation. */
21409 else
21410 {
21413 /* Always make artificials weak. */
21416 /* For WIN32 we also want to put explicit instantiations in
21417 linkonce sections. */
21420 }
21422 /* If EXTERN_P, then this function will not be emitted -- unless
21423 followed by an explicit instantiation, at which point its linkage
21424 will be adjusted. If !EXTERN_P, then this function will be
21425 emitted here. In neither circumstance do we want
21426 import_export_decl to adjust the linkage. */
21428 }
21430 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
21431 important template arguments. If any are missing, we check whether
21432 they're important by using error_mark_node for substituting into any
21433 args that were used for partial ordering (the ones between ARGS and END)
21434 and seeing if it bubbles up. */
21436 static bool
21438 {
21443 {
21446 }
21448 {
21452 }
21454 }
21456 /* Given two function templates PAT1 and PAT2, return:
21458 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
21459 -1 if PAT2 is more specialized than PAT1.
21460 0 if neither is more specialized.
21462 LEN indicates the number of parameters we should consider
21463 (defaulted parameters should not be considered).
21465 The 1998 std underspecified function template partial ordering, and
21466 DR214 addresses the issue. We take pairs of arguments, one from
21467 each of the templates, and deduce them against each other. One of
21468 the templates will be more specialized if all the *other*
21469 template's arguments deduce against its arguments and at least one
21470 of its arguments *does* *not* deduce against the other template's
21471 corresponding argument. Deduction is done as for class templates.
21472 The arguments used in deduction have reference and top level cv
21473 qualifiers removed. Iff both arguments were originally reference
21474 types *and* deduction succeeds in both directions, an lvalue reference
21475 wins against an rvalue reference and otherwise the template
21476 with the more cv-qualified argument wins for that pairing (if
21477 neither is more cv-qualified, they both are equal). Unlike regular
21478 deduction, after all the arguments have been deduced in this way,
21479 we do *not* verify the deduced template argument values can be
21480 substituted into non-deduced contexts.
21482 The logic can be a bit confusing here, because we look at deduce1 and
21483 targs1 to see if pat2 is at least as specialized, and vice versa; if we
21484 can find template arguments for pat1 to make arg1 look like arg2, that
21485 means that arg2 is at least as specialized as arg1. */
21487 int
21489 {
21502 /* Remove the this parameter from non-static member functions. If
21503 one is a non-static member function and the other is not a static
21504 member function, remove the first parameter from that function
21505 also. This situation occurs for operator functions where we
21506 locate both a member function (with this pointer) and non-member
21507 operator (with explicit first operand). */
21509 {
21514 }
21516 {
21519 {
21520 len--;
21522 }
21523 }
21525 /* If only one is a conversion operator, they are unordered. */
21529 /* Consider the return type for a conversion function */
21531 {
21534 len++;
21535 }
21537 processing_template_decl++;
21543 /* Stop when an ellipsis is seen. */
21545 {
21556 {
21557 /* When both arguments are pack expansions, we need only
21558 unify the patterns themselves. */
21562 /* This is the last comparison we need to do. */
21564 }
21566 /* DR 1847: If a particular P contains no template-parameters that
21567 participate in template argument deduction, that P is not used to
21568 determine the ordering. */
21574 {
21578 }
21581 {
21585 }
21591 {
21597 /* Setup the parameter vector, which contains only ARG1. */
21600 /* Setup the argument vector, which contains the remaining
21601 arguments. */
21610 /* We cannot deduce in the other direction, because ARG1 is
21611 a pack expansion but ARG2 is not. */
21613 }
21615 {
21621 /* Setup the parameter vector, which contains only ARG1. */
21624 /* Setup the argument vector, which contains the remaining
21625 arguments. */
21634 /* We cannot deduce in the other direction, because ARG2 is
21635 a pack expansion but ARG1 is not.*/
21637 }
21639 else
21640 {
21641 /* The normal case, where neither argument is a pack
21642 expansion. */
21649 }
21651 /* If we couldn't deduce arguments for tparms1 to make arg1 match
21652 arg2, then arg2 is not as specialized as arg1. */
21658 /* "If, for a given type, deduction succeeds in both directions
21659 (i.e., the types are identical after the transformations above)
21660 and both P and A were reference types (before being replaced with
21661 the type referred to above):
21662 - if the type from the argument template was an lvalue reference and
21663 the type from the parameter template was not, the argument type is
21664 considered to be more specialized than the other; otherwise,
21665 - if the type from the argument template is more cv-qualified
21666 than the type from the parameter template (as described above),
21667 the argument type is considered to be more specialized than the other;
21668 otherwise,
21669 - neither type is more specialized than the other." */
21672 {
21674 {
21677 else
21679 }
21681 {
21686 }
21687 }
21690 /* We've failed to deduce something in either direction.
21691 These must be unordered. */
21694 next:
21698 /* We have already processed all of the arguments in our
21699 handing of the pack expansion type. */
21704 }
21706 /* "In most cases, all template parameters must have values in order for
21707 deduction to succeed, but for partial ordering purposes a template
21708 parameter may remain without a value provided it is not used in the
21709 types being used for partial ordering."
21711 Thus, if we are missing any of the targs1 we need to substitute into
21712 origs1, then pat2 is not as specialized as pat1. This can happen when
21713 there is a nondeduced context. */
21719 processing_template_decl--;
21721 /* If both deductions succeed, the partial ordering selects the more
21722 constrained template. */
21724 {
21729 }
21731 /* All things being equal, if the next argument is a pack expansion
21732 for one function but not for the other, prefer the
21733 non-variadic function. FIXME this is bogus; see c++/41958. */
21737 {
21740 }
21746 else
21748 }
21750 /* Determine which of two partial specializations of TMPL is more
21751 specialized.
21753 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
21754 to the first partial specialization. The TREE_PURPOSE is the
21755 innermost set of template parameters for the partial
21756 specialization. PAT2 is similar, but for the second template.
21758 Return 1 if the first partial specialization is more specialized;
21759 -1 if the second is more specialized; 0 if neither is more
21760 specialized.
21762 See [temp.class.order] for information about determining which of
21763 two templates is more specialized. */
21765 static int
21767 {
21768 tree targs;
21777 /* Just like what happens for functions, if we are ordering between
21778 different template specializations, we may encounter dependent
21779 types in the arguments, and we need our dependency check functions
21780 to behave correctly. */
21784 {
21787 }
21791 {
21794 }
21797 /* If both deductions succeed, the partial ordering selects the more
21798 constrained template. */
21802 /* In the case of a tie where at least one of the templates
21803 has a parameter pack at the end, the template with the most
21804 non-packed parameters wins. */
21806 && any_deductions
21809 {
21815 /* We don't count the pack expansion at the end. */
21825 }
21828 }
21830 /* Return the template arguments that will produce the function signature
21831 DECL from the function template FN, with the explicit template
21832 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
21833 also match. Return NULL_TREE if no satisfactory arguments could be
21834 found. */
21836 static tree
21838 {
21842 tree decl_arg_types;
21845 tree arg;
21849 /* Never do unification on the 'this' parameter. */
21870 }
21872 /* Return the innermost template arguments that, when applied to a partial
21873 specialization SPEC_TMPL of TMPL, yield the ARGS.
21875 For example, suppose we have:
21877 template <class T, class U> struct S {};
21878 template <class T> struct S<T*, int> {};
21880 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
21881 partial specialization and the ARGS will be {double*, int}. The resulting
21882 vector will be {double}, indicating that `T' is bound to `double'. */
21884 static tree
21886 {
21888 tree spec_args
21891 tree deduced_args;
21892 tree innermost_deduced_args;
21896 {
21900 innermost_deduced_args);
21901 }
21902 else
21906 again:
21915 {
21917 {
21923 }
21925 }
21929 {
21932 }
21934 /* Verify that nondeduced template arguments agree with the type
21935 obtained from argument deduction.
21937 For example:
21939 struct A { typedef int X; };
21940 template <class T, class U> struct C {};
21941 template <class T> struct C<T, typename T::X> {};
21943 Then with the instantiation `C<A, int>', we can deduce that
21944 `T' is `A' but unify () does not check whether `typename T::X'
21945 is `int'. */
21956 /* We only need to check the innermost arguments; the other
21957 arguments will always agree. */
21962 /* Now that we have bindings for all of the template arguments,
21963 ensure that the arguments deduced for the template template
21964 parameters have compatible template parameter lists. See the use
21965 of template_template_parm_bindings_ok_p in fn_type_unification
21966 for more information. */
21971 }
21973 // Compare two function templates T1 and T2 by deducing bindings
21974 // from one against the other. If both deductions succeed, compare
21975 // constraints to see which is more constrained.
21976 static int
21978 {
21983 {
21986 }
21989 {
21992 }
21994 // If both deductions succeed, then one may be more constrained.
21999 }
22001 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
22002 Return the TREE_LIST node with the most specialized template, if
22003 any. If there is no most specialized template, the error_mark_node
22004 is returned.
22006 Note that this function does not look at, or modify, the
22007 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
22008 returned is one of the elements of INSTANTIATIONS, callers may
22009 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
22010 and retrieve it from the value returned. */
22012 tree
22014 {
22021 {
22027 {
22028 /* Equally specialized, move to next function. If there
22029 is no next function, nothing's most specialized. */
22034 }
22035 }
22038 /* Now verify that champ is better than everything earlier in the
22039 instantiation list. */
22042 {
22045 }
22046 }
22048 processing_template_decl--;
22054 }
22056 /* If DECL is a specialization of some template, return the most
22057 general such template. Otherwise, returns NULL_TREE.
22059 For example, given:
22061 template <class T> struct S { template <class U> void f(U); };
22063 if TMPL is `template <class U> void S<int>::f(U)' this will return
22064 the full template. This function will not trace past partial
22065 specializations, however. For example, given in addition:
22067 template <class T> struct S<T*> { template <class U> void f(U); };
22069 if TMPL is `template <class U> void S<int*>::f(U)' this will return
22070 `template <class T> template <class U> S<T*>::f(U)'. */
22072 tree
22074 {
22076 {
22079 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
22080 template friend, or a FIELD_DECL for a capture pack. */
22083 }
22085 /* Look for more and more general templates. */
22087 {
22088 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
22089 (See cp-tree.h for details.) */
22098 /* Stop if we run into an explicitly specialized class template. */
22105 }
22108 }
22110 /* Return the most specialized of the template partial specializations
22111 which can produce TARGET, a specialization of some class or variable
22112 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
22113 a TEMPLATE_DECL node corresponding to the partial specialization, while
22114 the TREE_PURPOSE is the set of template arguments that must be
22115 substituted into the template pattern in order to generate TARGET.
22117 If the choice of partial specialization is ambiguous, a diagnostic
22118 is issued, and the error_mark_node is returned. If there are no
22119 partial specializations matching TARGET, then NULL_TREE is
22120 returned, indicating that the primary template should be used. */
22122 static tree
22124 {
22126 tree t;
22127 tree champ;
22134 {
22138 }
22140 {
22143 }
22145 {
22149 }
22150 else
22155 /* For determining which partial specialization to use, only the
22156 innermost args are interesting. */
22158 {
22161 }
22164 {
22165 tree spec_args;
22169 {
22170 /* Substitute in the template args from the enclosing class. */
22174 }
22181 {
22185 /* Keep the candidate only if the constraints are satisfied,
22186 or if we're not compiling with concepts. */
22189 {
22192 }
22193 }
22194 }
22204 {
22207 ;
22208 else
22209 {
22211 {
22214 {
22217 }
22218 }
22220 }
22221 }
22225 {
22228 {
22231 }
22232 }
22235 {
22242 else
22246 {
22251 }
22254 }
22257 }
22259 /* Explicitly instantiate DECL. */
22261 void
22263 {
22268 /* An error occurred, for which grokdeclarator has already issued
22269 an appropriate message. */
22272 {
22275 }
22281 {
22282 /* There is an asymmetry here in the way VAR_DECLs and
22283 FUNCTION_DECLs are handled by grokdeclarator. In the case of
22284 the latter, the DECL we get back will be marked as a
22285 template instantiation, and the appropriate
22286 DECL_TEMPLATE_INFO will be set up. This does not happen for
22287 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
22288 should handle VAR_DECLs as it currently handles
22289 FUNCTION_DECLs. */
22291 {
22294 }
22297 {
22300 }
22302 {
22307 }
22308 }
22310 {
22313 }
22314 else
22317 /* Check for various error cases. Note that if the explicit
22318 instantiation is valid the RESULT will currently be marked as an
22319 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
22320 until we get here. */
22323 {
22324 /* DR 259 [temp.spec].
22326 Both an explicit instantiation and a declaration of an explicit
22327 specialization shall not appear in a program unless the explicit
22328 instantiation follows a declaration of the explicit specialization.
22330 For a given set of template parameters, if an explicit
22331 instantiation of a template appears after a declaration of an
22332 explicit specialization for that template, the explicit
22333 instantiation has no effect. */
22335 }
22337 {
22338 /* [temp.spec]
22340 No program shall explicitly instantiate any template more
22341 than once.
22343 We check DECL_NOT_REALLY_EXTERN so as not to complain when
22344 the first instantiation was `extern' and the second is not,
22345 and EXTERN_P for the opposite case. */
22348 /* If an "extern" explicit instantiation follows an ordinary
22349 explicit instantiation, the template is instantiated. */
22352 }
22354 {
22357 }
22359 {
22362 }
22365 ;
22367 {
22370 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
22373 }
22374 else
22382 }
22384 static void
22386 {
22392 {
22395 }
22396 }
22398 /* Called from do_type_instantiation through binding_table_foreach to
22399 do recursive instantiation for the type bound in ENTRY. */
22400 static void
22402 {
22408 }
22410 /* Perform an explicit instantiation of template class T. STORAGE, if
22411 non-null, is the RID for extern, inline or static. COMPLAIN is
22412 nonzero if this is called from the parser, zero if called recursively,
22413 since the standard is unclear (as detailed below). */
22415 void
22417 {
22427 {
22428 tree tmpl =
22432 else
22435 }
22440 {
22443 t);
22445 }
22448 {
22450 {
22452 {
22455 "ISO C++ 1998 forbids the use of %<extern%> on "
22457 }
22458 else
22460 "ISO C++ forbids the use of %qE"
22462 }
22470 else
22471 {
22473 storage);
22475 }
22476 }
22479 {
22480 /* DR 259 [temp.spec].
22482 Both an explicit instantiation and a declaration of an explicit
22483 specialization shall not appear in a program unless the explicit
22484 instantiation follows a declaration of the explicit specialization.
22486 For a given set of template parameters, if an explicit
22487 instantiation of a template appears after a declaration of an
22488 explicit specialization for that template, the explicit
22489 instantiation has no effect. */
22491 }
22493 {
22494 /* [temp.spec]
22496 No program shall explicitly instantiate any template more
22497 than once.
22499 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
22500 instantiation was `extern'. If EXTERN_P then the second is.
22501 These cases are OK. */
22508 /* If we've already instantiated the template, just return now. */
22511 }
22519 /* In contrast to implicit instantiation, where only the
22520 declarations, and not the definitions, of members are
22521 instantiated, we have here:
22523 [temp.explicit]
22525 The explicit instantiation of a class template specialization
22526 implies the instantiation of all of its members not
22527 previously explicitly specialized in the translation unit
22528 containing the explicit instantiation.
22530 Of course, we can't instantiate member template classes, since we
22531 don't have any arguments for them. Note that the standard is
22532 unclear on whether the instantiation of the members are
22533 *explicit* instantiations or not. However, the most natural
22534 interpretation is that it should be an explicit
22535 instantiation. */
22539 && !static_p
22542 {
22547 }
22552 }
22554 /* Given a function DECL, which is a specialization of TMPL, modify
22555 DECL to be a re-instantiation of TMPL with the same template
22556 arguments. TMPL should be the template into which tsubst'ing
22557 should occur for DECL, not the most general template.
22559 One reason for doing this is a scenario like this:
22561 template <class T>
22562 void f(const T&, int i);
22564 void g() { f(3, 7); }
22566 template <class T>
22567 void f(const T& t, const int i) { }
22569 Note that when the template is first instantiated, with
22570 instantiate_template, the resulting DECL will have no name for the
22571 first parameter, and the wrong type for the second. So, when we go
22572 to instantiate the DECL, we regenerate it. */
22574 static void
22576 {
22577 /* The arguments used to instantiate DECL, from the most general
22578 template. */
22579 tree code_pattern;
22583 /* Make sure that we can see identifiers, and compute access
22584 correctly. */
22588 {
22589 tree decl_parm;
22590 tree pattern_parm;
22591 tree specs;
22605 specs);
22607 /* Merge parameter declarations. */
22610 pattern_parm
22614 {
22615 tree parm_type;
22616 tree attributes;
22621 NULL_TREE);
22627 {
22630 }
22633 }
22634 /* Merge any parameters that match with the function parameter
22635 pack. */
22637 {
22639 tree expanded_types;
22640 /* Expand the TYPE_PACK_EXPANSION that provides the types for
22641 the parameters in this function parameter pack. */
22646 {
22647 tree parm_type;
22648 tree attributes;
22651 /* Rename the parameter to include the index. */
22660 {
22663 }
22665 }
22666 }
22667 /* Merge additional specifiers from the CODE_PATTERN. */
22671 }
22673 {
22683 }
22684 else
22688 }
22690 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
22691 substituted to get DECL. */
22693 tree
22695 {
22698 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
22699 for the instantiation. This is not always the most general
22700 template. Consider, for example:
22702 template <class T>
22703 struct S { template <class U> void f();
22704 template <> void f<int>(); };
22706 and an instantiation of S<double>::f<int>. We want TD to be the
22707 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
22709 more general template. */
22711 /* We must also deal with friend templates. Given:
22713 template <class T> struct S {
22714 template <class U> friend void f() {};
22715 };
22717 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
22718 so far as the language is concerned, but that's still
22719 where we get the pattern for the instantiation from. On
22720 other hand, if the definition comes outside the class, say:
22722 template <class T> struct S {
22723 template <class U> friend void f();
22724 };
22725 template <class U> friend void f() {}
22727 we don't need to look any further. That's what the check for
22728 DECL_INITIAL is for. */
22732 {
22733 /* The present template, TD, should not be a definition. If it
22734 were a definition, we should be using it! Note that we
22735 cannot restructure the loop to just keep going until we find
22736 a template with a definition, since that might go too far if
22737 a specialization was declared, but not defined. */
22739 /* Fetch the more general template. */
22741 }
22744 }
22746 /* Returns true if we need to instantiate this template instance even if we
22747 know we aren't going to emit it. */
22749 bool
22751 {
22752 /* We always instantiate inline functions so that we can inline them. An
22753 explicit instantiation declaration prohibits implicit instantiation of
22754 non-inline functions. With high levels of optimization, we would
22755 normally inline non-inline functions -- but we're not allowed to do
22756 that for "extern template" functions. Therefore, we check
22757 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
22761 /* And we need to instantiate static data members so that
22762 their initializers are available in integral constant
22763 expressions. */
22766 }
22768 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
22769 instantiate it now, modifying TREE_TYPE (fn). Returns false on
22770 error, true otherwise. */
22772 bool
22774 {
22777 /* Don't instantiate a noexcept-specification from template context. */
22792 {
22798 {
22799 /* If hash_set::add returns true, the element was already there. */
22804 fn);
22806 }
22808 {
22823 }
22824 else
22834 }
22837 {
22840 else
22842 }
22845 }
22847 /* We're starting to process the function INST, an instantiation of PATTERN;
22848 add their parameters to local_specializations. */
22850 static void
22852 {
22856 {
22860 }
22862 {
22864 {
22867 }
22868 else
22869 {
22870 /* Register the (value) argument pack as a specialization of
22871 TMPL_PARM, then move on. */
22874 }
22875 }
22877 }
22879 /* Produce the definition of D, a _DECL generated from a template. If
22880 DEFER_OK is true, then we don't have to actually do the
22881 instantiation now; we just have to do it sometime. Normally it is
22882 an error if this is an explicit instantiation but D is undefined.
22883 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
22884 instantiated class template. */
22886 tree
22888 {
22890 tree gen_args;
22891 tree args;
22892 tree td;
22893 tree code_pattern;
22894 tree spec;
22895 tree gen_tmpl;
22903 /* This function should only be used to instantiate templates for
22904 functions and static member variables. */
22907 /* A concept is never instantiated. */
22910 /* Variables are never deferred; if instantiation is required, they
22911 are instantiated right away. That allows for better code in the
22912 case that an expression refers to the value of the variable --
22913 if the variable has a constant value the referring expression can
22914 take advantage of that fact. */
22918 /* Don't instantiate cloned functions. Instead, instantiate the
22919 functions they cloned. */
22927 /* D has already been instantiated or explicitly specialized, so
22928 there's nothing for us to do here.
22930 It might seem reasonable to check whether or not D is an explicit
22931 instantiation, and, if so, stop here. But when an explicit
22932 instantiation is deferred until the end of the compilation,
22933 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
22934 the instantiation. */
22937 /* Check to see whether we know that this template will be
22938 instantiated in some other file, as with "extern template"
22939 extension. */
22942 /* In general, we do not instantiate such templates. */
22950 /* We should already have the extra args. */
22953 /* And what's in the hash table should match D. */
22957 /* This needs to happen before any tsubsting. */
22963 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
22964 for the instantiation. */
22969 {
22970 /* Look up an explicit specialization, if any. */
22974 {
22977 }
22978 }
22982 /* We should never be trying to instantiate a member of a class
22983 template or partial specialization. */
22988 /* In the case of a friend template whose definition is provided
22989 outside the class, we may have too many arguments. Drop the
22990 ones we don't need. The same is true for specializations. */
22991 args = get_innermost_template_args
22995 {
23001 }
23002 else
23003 {
23008 else
23010 }
23012 /* We may be in the middle of deferred access check. Disable it now. */
23015 /* Unless an explicit instantiation directive has already determined
23016 the linkage of D, remember that a definition is available for
23017 this entity. */
23027 /* If D is a member of an explicitly instantiated class template,
23028 and no definition is available, treat it like an implicit
23029 instantiation. */
23032 {
23033 /* Leave linkage flags alone on instantiations with anonymous
23034 visibility. */
23036 {
23039 }
23041 }
23043 /* Defer all other templates, unless we have been explicitly
23044 forbidden from doing so. */
23046 template. */
23047 ! pattern_defined
23048 /* If it's OK to postpone instantiation, do so. */
23049 || defer_ok
23050 /* If this is a static data member that will be defined
23051 elsewhere, we don't want to instantiate the entire data
23052 member, but we do want to instantiate the initializer so that
23053 we can substitute that elsewhere. */
23055 /* Handle here a deleted function too, avoid generating
23056 its body (c++/61080). */
23058 {
23059 /* The definition of the static data member is now required so
23060 we must substitute the initializer. */
23064 {
23065 tree ns;
23066 tree init;
23075 args,
23078 /* If instantiating the initializer involved instantiating this
23079 again, don't call cp_finish_decl twice. */
23081 {
23082 /* Make sure the initializer is still constant, in case of
23083 circular dependency (template/instantiate6.C). */
23084 const_init
23088 LOOKUP_ONLYCONVERTING);
23089 }
23093 }
23095 /* We restore the source position here because it's used by
23096 add_pending_template. */
23102 /* [temp.explicit]
23104 The definition of a non-exported function template, a
23105 non-exported member function template, or a non-exported
23106 member function or static data member of a class template
23107 shall be present in every translation unit in which it is
23108 explicitly instantiated. */
23112 /* If we're in unevaluated context, we just wanted to get the
23113 constant value; this isn't an odr use, so don't queue
23114 a full instantiation. */
23117 /* ??? Historically, we have instantiated inline functions, even
23118 when marked as "extern template". */
23122 }
23123 /* Tell the repository that D is available in this translation unit
23124 -- and see if it is supposed to be instantiated here. */
23126 {
23127 /* In a PCH file, despite the fact that the repository hasn't
23128 requested instantiation in the PCH it is still possible that
23129 an instantiation will be required in a file that includes the
23130 PCH. */
23133 /* Instantiate inline functions so that the inliner can do its
23134 job, even though we'll not be emitting a copy of this
23135 function. */
23138 }
23141 tree fn_context;
23152 else
23153 {
23157 }
23159 /* Mark D as instantiated so that recursive calls to
23160 instantiate_decl do not try to instantiate it again. */
23163 /* Regenerate the declaration in case the template has been modified
23164 by a subsequent redeclaration. */
23167 /* We already set the file and line above. Reset them now in case
23168 they changed as a result of calling regenerate_decl_from_template. */
23172 {
23173 tree init;
23176 /* Clear out DECL_RTL; whatever was there before may not be right
23177 since we've reset the type of the declaration. */
23181 /* The initializer is placed in DECL_INITIAL by
23182 regenerate_decl_from_template so we don't need to
23183 push/pop_access_scope again here. Pull it out so that
23184 cp_finish_decl can process it. */
23189 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
23190 initializer. That function will defer actual emission until
23191 we have a chance to determine linkage. */
23194 /* Enter the scope of D so that access-checking works correctly. */
23207 }
23211 {
23212 /* Set up the list of local specializations. */
23216 /* Set up context. */
23220 else
23223 /* Some typedefs referenced from within the template code need to be
23224 access checked at template instantiation time, i.e now. These
23225 types were added to the template at parsing time. Let's get those
23226 and perform the access checks then. */
23228 args);
23230 /* Create substitution entries for the parameters. */
23233 /* Substitute into the body of the function. */
23237 else
23238 {
23243 /* Set the current input_location to the end of the function
23244 so that finish_function knows where we are. */
23245 input_location
23248 /* Remember if we saw an infinite loop in the template. */
23249 current_function_infinite_loop
23251 }
23253 /* Finish the function. */
23257 else
23258 {
23261 }
23265 }
23267 /* We're not deferring instantiation any more. */
23272 else
23278 out:
23287 }
23289 /* Run through the list of templates that we wish we could
23290 instantiate, and instantiate any we can. RETRIES is the
23291 number of times we retry pending template instantiation. */
23293 void
23295 {
23299 /* Instantiating templates may trigger vtable generation. This in turn
23300 may require further template instantiations. We place a limit here
23301 to avoid infinite loop. */
23303 {
23307 "template instantiation depth exceeds maximum of %d"
23308 " instantiating %q+D, possibly from virtual table generation"
23312 /* Pretend that we defined it. */
23315 }
23317 do
23318 {
23323 {
23328 {
23330 {
23345 }
23348 }
23349 else
23350 {
23353 {
23354 instantiation
23360 }
23364 }
23367 /* If INSTANTIATION has been instantiated, then we don't
23368 need to consider it again in the future. */
23370 else
23371 {
23374 }
23377 }
23379 }
23383 }
23385 /* Substitute ARGVEC into T, which is a list of initializers for
23386 either base class or a non-static data member. The TREE_PURPOSEs
23387 are DECLs, and the TREE_VALUEs are the initializer values. Used by
23388 instantiate_decl. */
23390 static tree
23392 {
23396 {
23397 tree decl;
23398 tree init;
23404 {
23405 tree expr;
23406 tree arg;
23408 /* Expand the base class expansion type into separate base
23409 classes. */
23411 tf_warning_or_error,
23412 NULL_TREE);
23416 /* We'll be building separate TREE_LISTs of arguments for
23417 each base. */
23423 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
23424 expand each argument in the TREE_VALUE of t. */
23431 /* VOID_TYPE_NODE is used to indicate
23432 value-initialization. */
23433 {
23436 }
23437 else
23438 {
23439 /* Substitute parameter packs into each argument in the
23440 TREE_LIST. */
23443 {
23444 tree expanded_exprs;
23446 /* Expand the argument. */
23448 expanded_exprs
23450 tf_warning_or_error,
23451 NULL_TREE);
23455 /* Prepend each of the expanded expressions to the
23456 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
23458 {
23463 }
23464 }
23467 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
23468 since we built them backwards. */
23470 {
23473 }
23474 }
23475 }
23478 {
23480 {
23484 }
23485 else
23486 {
23487 tree tmp;
23502 /* If we had an initializer but it instantiated to nothing,
23503 value-initialize the object. This will only occur when
23504 the initializer was a pack expansion where the parameter
23505 packs used in that expansion were of length zero. */
23508 }
23511 {
23515 }
23516 }
23517 }
23519 }
23521 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
23523 static void
23525 {
23530 else
23532 }
23534 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
23535 is the instantiation (which should have been created with
23536 start_enum) and ARGS are the template arguments to use. */
23538 static void
23540 {
23541 tree e;
23547 {
23548 tree value;
23549 tree decl;
23552 /* Note that in a template enum, the TREE_VALUE is the
23553 CONST_DECL, not the corresponding INTEGER_CST. */
23558 /* Give this enumeration constant the correct access. */
23561 /* Actually build the enumerator itself. Here we're assuming that
23562 enumerators can't have dependent attributes. */
23565 }
23575 }
23577 /* DECL is a FUNCTION_DECL that is a template specialization. Return
23578 its type -- but without substituting the innermost set of template
23579 arguments. So, innermost set of template parameters will appear in
23580 the type. */
23582 tree
23584 {
23585 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
23587 }
23589 /* Return truthvalue if we're processing a template different from
23590 the last one involved in diagnostics. */
23591 bool
23593 {
23595 }
23597 /* Remember current template involved in diagnostics. */
23598 void
23600 {
23602 }
23606 {
23608 }
23610 /* Return TRUE if current_function_decl is being instantiated, false
23611 otherwise. */
23613 bool
23615 {
23618 }
23620 /* [temp.param] Check that template non-type parm TYPE is of an allowable
23621 type. Return zero for ok, nonzero for disallowed. Issue error and
23622 warning messages under control of COMPLAIN. */
23624 static int
23626 {
23641 /* A bound template template parm could later be instantiated to have a valid
23642 nontype parm type via an alias template. */
23648 {
23651 else
23653 type);
23654 }
23656 }
23658 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
23659 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
23661 static bool
23663 {
23664 tree scope;
23666 /* [temp.dep.type]
23668 A type is dependent if it is:
23670 -- a template parameter. Template template parameters are types
23671 for us (since TYPE_P holds true for them) so we handle
23672 them here. */
23676 /* -- a qualified-id with a nested-name-specifier which contains a
23677 class-name that names a dependent type or whose unqualified-id
23678 names a dependent type. */
23682 /* An alias template specialization can be dependent even if the
23683 resulting type is not. */
23687 /* -- a cv-qualified type where the cv-unqualified type is
23688 dependent.
23689 No code is necessary for this bullet; the code below handles
23690 cv-qualified types, and we don't want to strip aliases with
23691 TYPE_MAIN_VARIANT because of DR 1558. */
23692 /* -- a compound type constructed from any dependent type. */
23702 {
23703 tree arg_type;
23708 arg_type;
23713 {
23714 /* A value-dependent noexcept-specifier makes the type dependent. */
23719 }
23721 }
23722 /* -- an array type constructed from any dependent type or whose
23723 size is specified by a constant expression that is
23724 value-dependent.
23726 We checked for type- and value-dependence of the bounds in
23727 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
23729 {
23734 }
23736 /* -- a template-id in which either the template name is a template
23737 parameter ... */
23740 /* ... or any of the template arguments is a dependent type or
23741 an expression that is type-dependent or value-dependent. */
23743 && (any_dependent_template_arguments_p
23747 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
23748 dependent; if the argument of the `typeof' expression is not
23749 type-dependent, then it should already been have resolved. */
23755 /* A template argument pack is dependent if any of its packed
23756 arguments are. */
23758 {
23764 }
23766 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
23767 be template parameters. */
23774 /* The standard does not specifically mention types that are local
23775 to template functions or local classes, but they should be
23776 considered dependent too. For example:
23778 template <int I> void f() {
23779 enum E { a = I };
23780 S<sizeof (E)> s;
23781 }
23783 The size of `E' cannot be known until the value of `I' has been
23784 determined. Therefore, `E' must be considered dependent. */
23788 /* Don't use type_dependent_expression_p here, as it can lead
23789 to infinite recursion trying to determine whether a lambda
23790 nested in a lambda is dependent (c++/47687). */
23794 && (any_dependent_template_arguments_p
23798 /* Other types are non-dependent. */
23800 }
23802 /* Returns TRUE if TYPE is dependent, in the sense of
23803 [temp.dep.type]. Note that a NULL type is considered dependent. */
23805 bool
23807 {
23808 /* If there are no template parameters in scope, then there can't be
23809 any dependent types. */
23811 {
23812 /* If we are not processing a template, then nobody should be
23813 providing us with a dependent type. */
23817 }
23819 /* If the type is NULL, we have not computed a type for the entity
23820 in question; in that case, the type is dependent. */
23824 /* Erroneous types can be considered non-dependent. */
23828 /* Getting here with global_type_node means we improperly called this
23829 function on the TREE_TYPE of an IDENTIFIER_NODE. */
23832 /* If we have not already computed the appropriate value for TYPE,
23833 do so now. */
23835 {
23838 }
23841 }
23843 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
23844 lookup. In other words, a dependent type that is not the current
23845 instantiation. */
23847 bool
23849 {
23852 }
23854 /* T is a SCOPE_REF; return whether we need to consider it
23855 instantiation-dependent so that we can check access at instantiation
23856 time even though we know which member it resolves to. */
23858 static bool
23860 {
23866 else
23868 }
23870 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
23871 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
23872 expression. */
23874 /* Note that this predicate is not appropriate for general expressions;
23875 only constant expressions (that satisfy potential_constant_expression)
23876 can be tested for value dependence. */
23878 bool
23880 {
23884 /* A name declared with a dependent type. */
23889 {
23891 /* A dependent member function of the current instantiation. */
23895 /* A dependent member function of the current instantiation. */
23902 /* A name that has not been looked up -- must be dependent. */
23906 /* A non-type template parm. */
23910 /* A non-type template parm. */
23916 /* A constant with literal type and is initialized
23917 with an expression that is value-dependent.
23919 Note that a non-dependent parenthesized initializer will have
23920 already been replaced with its constant value, so if we see
23921 a TREE_LIST it must be dependent. */
23925 /* cp_finish_decl doesn't fold reference initializers. */
23931 {
23935 }
23943 /* These expressions are value-dependent if the type to which
23944 the cast occurs is dependent or the expression being casted
23945 is value-dependent. */
23946 {
23952 /* A functional cast has a list of operands. */
23955 {
23956 /* If there are no operands, it must be an expression such
23957 as "int()". This should not happen for aggregate types
23958 because it would form non-constant expressions. */
23963 }
23969 }
23974 /* FALLTHRU */
23977 /* A `sizeof' expression is value-dependent if the operand is
23978 type-dependent or is a pack expansion. */
23987 /* An 'encode' expression is value-dependent if the operand is
23988 type-dependent. */
23997 /* All instantiation-dependent expressions should also be considered
23998 value-dependent. */
24006 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
24007 is value-dependent. */
24008 {
24017 }
24020 {
24024 }
24035 {
24039 }
24042 /* Treat all requires-expressions as value-dependent so
24043 we don't try to fold them. */
24050 {
24057 {
24059 /* In a call to a constexpr member function, look through the
24060 implicit ADDR_EXPR on the object argument so that it doesn't
24061 cause the call to be considered value-dependent. We also
24062 look through it in potential_constant_expression. */
24069 }
24071 }
24074 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
24075 type-dependent. */
24080 {
24082 tree val;
24089 }
24092 /* Treat a GNU statement expression as dependent to avoid crashing
24093 under instantiate_non_dependent_expr; it can't be constant. */
24097 /* A constant expression is value-dependent if any subexpression is
24098 value-dependent. */
24100 {
24107 {
24111 {
24114 /* In some cases, some of the operands may be missing.
24115 (For example, in the case of PREDECREMENT_EXPR, the
24116 amount to increment by may be missing.) That doesn't
24117 make the expression dependent. */
24120 }
24121 }
24125 }
24127 }
24129 /* The expression is not value-dependent. */
24131 }
24133 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
24134 [temp.dep.expr]. Note that an expression with no type is
24135 considered dependent. Other parts of the compiler arrange for an
24136 expression with type-dependent subexpressions to have no type, so
24137 this function doesn't have to be fully recursive. */
24139 bool
24141 {
24148 /* An unresolved name is always dependent. */
24154 /* A fold expression is type-dependent. */
24161 /* Some expression forms are never type-dependent. */
24175 /* The types of these expressions depends only on the type to which
24176 the cast occurs. */
24185 /* The types of these expressions depends only on the type created
24186 by the expression. */
24189 {
24190 /* For NEW_EXPR tree nodes created inside a template, either
24191 the object type itself or a TREE_LIST may appear as the
24192 operand 1. */
24195 /* This is an array type. We need to check array dimensions
24196 as well. */
24198 || value_dependent_expression_p
24200 else
24202 }
24205 {
24209 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
24210 contains an identifier associated by name lookup with one or more
24211 declarations declared with a dependent type, or...a
24212 nested-name-specifier or qualified-id that names a member of an
24213 unknown specialization. */
24216 }
24226 {
24227 tree elt;
24231 {
24234 }
24236 }
24238 /* A static data member of the current instantiation with incomplete
24239 array type is type-dependent, as the definition and specializations
24240 can have different bounds. */
24247 /* An array of unknown bound depending on a variadic parameter, eg:
24249 template<typename... Args>
24250 void foo (Args... args)
24251 {
24252 int arr[] = { args... };
24253 }
24255 template<int... vals>
24256 void bar ()
24257 {
24258 int arr[] = { vals... };
24259 }
24261 If the array has no length and has an initializer, it must be that
24262 we couldn't determine its length in cp_complete_array_type because
24263 it is dependent. */
24271 /* A function or variable template-id is type-dependent if it has any
24272 dependent template arguments. */
24276 {
24277 /* Consider the innermost template arguments, since those are the ones
24278 that come from the template-id; the template arguments for the
24279 enclosing class do not make it type-dependent unless they are used in
24280 the type of the decl. */
24282 && (any_dependent_template_arguments_p
24285 }
24287 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
24288 type-dependent. Checking this is important for functions with auto return
24289 type, which looks like a dependent type. */
24297 {
24301 }
24303 /* Always dependent, on the number of arguments if nothing else. */
24308 {
24313 {
24319 }
24320 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
24325 {
24330 }
24333 {
24340 }
24350 }
24354 /* Dependent type attributes might not have made it from the decl to
24355 the type yet. */
24361 }
24363 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
24364 type-dependent if the expression refers to a member of the current
24365 instantiation and the type of the referenced member is dependent, or the
24366 class member access expression refers to a member of an unknown
24367 specialization.
24369 This function returns true if the OBJECT in such a class member access
24370 expression is of an unknown specialization. */
24372 bool
24374 {
24375 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
24376 dependent. */
24381 }
24383 /* walk_tree callback function for instantiation_dependent_expression_p,
24384 below. Returns non-zero if a dependent subexpression is found. */
24386 static tree
24389 {
24391 {
24392 /* We don't have to worry about decltype currently because decltype
24393 of an instantiation-dependent expr is a dependent type. This
24394 might change depending on the resolution of DR 1172. */
24397 }
24400 {
24401 /* Don't treat an argument list as dependent just because it has no
24402 TREE_TYPE. */
24410 /* Handle expressions with type operands. */
24415 {
24420 {
24423 else
24424 {
24427 }
24428 }
24430 }
24434 /* In a template, finish_class_member_access_expr creates a
24435 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
24436 type-dependent, so that we can check access control at
24437 instantiation time (PR 42277). See also Core issue 1273. */
24444 else
24447 /* Treat statement-expressions as dependent. */
24451 /* Treat requires-expressions as dependent. */
24456 /* Treat calls to function concepts as dependent. */
24462 /* And variable concepts. */
24469 }
24473 else
24475 }
24477 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
24478 sense defined by the ABI:
24480 "An expression is instantiation-dependent if it is type-dependent
24481 or value-dependent, or it has a subexpression that is type-dependent
24482 or value-dependent."
24484 Except don't actually check value-dependence for unevaluated expressions,
24485 because in sizeof(i) we don't care about the value of i. Checking
24486 type-dependence will in turn check value-dependence of array bounds/template
24487 arguments as needed. */
24489 bool
24491 {
24492 tree result;
24503 }
24505 /* As above, but also check value-dependence of the expression as a whole. */
24507 bool
24509 {
24512 }
24514 /* Like type_dependent_expression_p, but it also works while not processing
24515 a template definition, i.e. during substitution or mangling. */
24517 bool
24519 {
24525 }
24527 /* Returns TRUE if ARGS contains a type-dependent expression. */
24529 bool
24531 {
24533 tree arg;
24536 {
24539 }
24541 }
24543 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24544 expressions) contains any type-dependent expressions. */
24546 bool
24548 {
24554 }
24556 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24557 expressions) contains any value-dependent expressions. */
24559 bool
24561 {
24567 }
24569 /* Returns TRUE if the ARG (a template argument) is dependent. */
24571 bool
24573 {
24577 /* Assume a template argument that was wrongly written by the user
24578 is dependent. This is consistent with what
24579 any_dependent_template_arguments_p [that calls this function]
24580 does. */
24590 {
24593 /* A member template of a dependent class is not necessarily
24594 type-dependent, but it is a dependent template argument because it
24595 will be a member of an unknown specialization to that template. */
24598 }
24600 {
24604 {
24607 }
24610 }
24613 else
24616 }
24618 /* Returns true if ARGS (a collection of template arguments) contains
24619 any types that require structural equality testing. */
24621 bool
24623 {
24633 {
24636 {
24642 {
24643 /* Look inside the argument pack. */
24646 }
24649 {
24662 }
24663 }
24664 }
24667 }
24669 /* Returns true if ARGS (a collection of template arguments) contains
24670 any dependent arguments. */
24672 bool
24674 {
24684 {
24689 }
24692 }
24694 /* Returns TRUE if the template TMPL is type-dependent. */
24696 bool
24698 {
24700 {
24705 }
24707 /* Template template parameters are dependent. */
24711 /* So are names that have not been looked up. */
24715 }
24717 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
24719 bool
24721 {
24724 }
24726 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
24727 are dependent. */
24729 bool
24731 {
24738 {
24760 {
24764 }
24768 {
24772 {
24777 }
24778 }
24779 }
24782 }
24784 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
24785 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
24786 no such TYPE can be found. Note that this function peers inside
24787 uninstantiated templates and therefore should be used only in
24788 extremely limited situations. ONLY_CURRENT_P restricts this
24789 peering to the currently open classes hierarchy (which is required
24790 when comparing types). */
24792 tree
24794 {
24795 tree scope;
24796 tree name;
24797 tree decl;
24799 tree pushed_scope;
24800 tree result;
24805 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
24806 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
24807 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
24808 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
24809 identifier of the TYPENAME_TYPE anymore.
24810 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
24811 TYPENAME_TYPE instead, we avoid messing up with a possible
24812 typedef variant case. */
24815 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
24816 it first before we can figure out what NAME refers to. */
24818 {
24820 /* Given a class template A with a dependent base with nested type C,
24821 typedef typename A::C::C C will land us here, as trying to resolve
24822 the initial A::C leads to the local C typedef, which leads back to
24823 A::C::C. So we break the recursion now. */
24825 else
24827 }
24828 /* If we don't know what SCOPE refers to, then we cannot resolve the
24829 TYPENAME_TYPE. */
24832 /* If this is a typedef, we don't want to look inside (c++/11987). */
24835 /* If SCOPE isn't the template itself, it will not have a valid
24836 TYPE_FIELDS list. */
24838 /* scope is either the template itself or a compatible instantiation
24839 like X<T>, so look up the name in the original template. */
24841 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
24843 /* If scope has no fields, it can't be a current instantiation. Check this
24844 before currently_open_class to avoid infinite recursion (71515). */
24847 /* If the SCOPE is not the current instantiation, there's no reason
24848 to look inside it. */
24851 /* Enter the SCOPE so that name lookup will be resolved as if we
24852 were in the class definition. In particular, SCOPE will no
24853 longer be considered a dependent type. */
24855 /* Look up the declaration. */
24857 tf_warning_or_error);
24861 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
24862 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
24868 {
24872 }
24875 {
24876 /* Obtain the template and the arguments. */
24879 {
24880 /* We get here with a plain identifier because a previous tentative
24881 parse of the nested-name-specifier as part of a ptr-operator saw
24882 ::template X<A>. The use of ::template is necessary in a
24883 ptr-operator, but wrong in a declarator-id.
24885 [temp.names]: In a qualified-id of a declarator-id, the keyword
24886 template shall not appear at the top level. */
24890 }
24892 /* Instantiate the template. */
24898 }
24900 /* Leave the SCOPE. */
24904 /* If we failed to resolve it, return the original typename. */
24908 /* If lookup found a typename type, resolve that too. */
24910 {
24911 /* Ill-formed programs can cause infinite recursion here, so we
24912 must catch that. */
24916 }
24918 /* Qualify the resulting type. */
24924 }
24926 /* EXPR is an expression which is not type-dependent. Return a proxy
24927 for EXPR that can be used to compute the types of larger
24928 expressions containing EXPR. */
24930 tree
24932 {
24933 tree inner_expr;
24935 /* When checking, try to get a constant value for all non-dependent
24936 expressions in order to expose bugs in *_dependent_expression_p
24937 and constexpr. This can affect code generation, see PR70704, so
24938 only do this for -fchecking=2. */
24941 /* Don't do this during nsdmi parsing as it can lead to
24942 unexpected recursive instantiations. */
24944 /* Don't do this during concept expansion either and for
24945 the same reason. */
24949 /* Preserve OVERLOADs; the functions must be available to resolve
24950 types. */
24961 /* There is no need to return a proxy for a variable. */
24964 /* Preserve string constants; conversions from string constants to
24965 "char *" are allowed, even though normally a "const char *"
24966 cannot be used to initialize a "char *". */
24969 /* Preserve void and arithmetic constants, as an optimization -- there is no
24970 reason to create a new node. */
24975 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
24976 There is at least one place where we want to know that a
24977 particular expression is a throw-expression: when checking a ?:
24978 expression, there are special rules if the second or third
24979 argument is a throw-expression. */
24983 /* Don't wrap an initializer list, we need to be able to look inside. */
24987 /* Don't wrap a dummy object, we need to be able to test for it. */
25006 /* If the type is unknown, it can't really be non-dependent */
25009 /* Otherwise, build a NON_DEPENDENT_EXPR. */
25011 }
25013 /* ARGS is a vector of expressions as arguments to a function call.
25014 Replace the arguments with equivalent non-dependent expressions.
25015 This modifies ARGS in place. */
25017 void
25019 {
25021 tree arg;
25024 {
25028 }
25029 }
25031 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
25032 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
25033 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
25035 static tree
25037 {
25051 }
25053 tree
25055 {
25057 }
25059 tree
25061 {
25063 }
25065 /* Return a C++17 deduction placeholder for class template TMPL. */
25067 tree
25069 {
25073 }
25075 /* True iff T is a C++17 class template deduction placeholder. */
25077 bool
25079 {
25081 }
25083 /* Make a "constrained auto" type-specifier. This is an
25084 auto type with constraints that must be associated after
25085 deduction. The constraint is formed from the given
25086 CONC and its optional sequence of arguments, which are
25087 non-null if written as partial-concept-id. */
25089 tree
25091 {
25094 /* Build the constraint. */
25102 /* Our canonical type depends on the constraint. */
25105 /* Attach the constraint to the type declaration. */
25108 }
25110 /* Given type ARG, return std::initializer_list<ARG>. */
25112 static tree
25114 {
25118 {
25122 "deducing from brace-enclosed initializer list"
25126 }
25132 }
25134 /* Replace auto in TYPE with std::initializer_list<auto>. */
25136 static tree
25138 {
25145 }
25147 /* Hash traits for hashing possibly constrained 'auto'
25148 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
25151 {
25154 };
25156 /* Hash the 'auto' T. */
25158 inline hashval_t
25160 {
25162 /* Matching constrained-type-specifiers denote the same template
25163 parameter, so hash the constraint. */
25165 else
25166 /* But unconstrained autos are all separate, so just hash the pointer. */
25168 }
25170 /* Compare two 'auto's. */
25174 {
25181 /* Two unconstrained autos are distinct. */
25186 }
25188 /* for_each_template_parm callback for extract_autos: if t is a (possibly
25189 constrained) auto, add it to the vector. */
25191 static int
25193 {
25196 {
25197 /* All the autos were built with index 0; fix that up now. */
25201 /* If this is a repeated constrained-type-specifier, use the index we
25202 chose before. */
25204 else
25205 {
25206 /* Otherwise this is new, so use the current count. */
25209 }
25211 }
25213 /* Always keep walking. */
25215 }
25217 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
25218 says they can appear anywhere in the type. */
25220 static tree
25222 {
25231 {
25236 }
25239 }
25241 /* The stem for deduction guide names. */
25244 /* Return the name for a deduction guide for class template TMPL. */
25246 tree
25248 {
25259 }
25261 /* True if NAME is the name of a deduction guide. */
25263 bool
25265 {
25269 }
25271 /* True if FN is a deduction guide. */
25273 bool
25275 {
25280 }
25282 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
25284 bool
25286 {
25293 }
25295 /* True if FN is a guide generated from a constructor template. */
25297 bool
25299 {
25307 }
25309 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
25310 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
25311 template parameter types. Note that the handling of template template
25312 parameters relies on current_template_parms being set appropriately for the
25313 new template. */
25315 static tree
25318 {
25321 tree newtype;
25324 {
25331 }
25332 else
25336 tree newdecl
25341 tree newidx;
25344 {
25354 {
25359 // First create a copy (ttargs) of tsubst_args with an
25360 // additional level for the template template parameter's own
25361 // template parameters (ttparms).
25362 tree ttparms = (INNERMOST_TEMPLATE_PARMS
25370 // Substitute ttargs into ttparms to fix references to
25371 // other template parameters.
25373 complain);
25374 // Now substitute again with args based on tparms, to reduce
25375 // the level of the ttparms.
25378 complain);
25379 // Finally, tack the adjusted parms onto tparms.
25381 current_template_parms);
25383 }
25384 }
25385 else
25386 {
25388 tree newconst
25400 }
25403 }
25405 /* Returns a C++17 class deduction guide template based on the constructor
25406 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
25407 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
25409 static tree
25411 {
25415 location_t loc;
25419 {
25423 {
25426 }
25427 else
25437 }
25438 else
25439 {
25442 fn_tmpl
25452 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
25453 fully specialized args for the enclosing class. Strip those off, as
25454 the deduction guide won't have those template parameters. */
25457 /* Discard the 'this' parameter. */
25465 {
25468 /* For a member template constructor, we need to flatten the two
25469 template parameter lists into one, and then adjust the function
25470 signature accordingly. This gets...complicated. */
25473 /* For a member template we should have two levels of parms/args, one
25474 for the class and one for the constructor. We stripped
25475 specialized args for further enclosing classes above. */
25479 /* Template args for translating references to the two-level template
25480 parameters into references to the one-level template parameters we
25481 are creating. */
25486 /* Template parms for the constructor template. */
25489 /* Template parms for the class template. */
25493 /* Template parms for the deduction guide start as a copy of the
25494 template parms for the class. We set current_template_parms for
25495 lookup_template_class_1. */
25501 /* Now we need to rewrite the constructor parms to append them to the
25502 class parms. */
25504 {
25519 }
25521 /* Now we have a final set of template parms to substitute into the
25522 function signature. */
25531 }
25533 }
25536 {
25537 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
25541 }
25545 FUNCTION_DECL,
25562 }
25564 /* Deduce template arguments for the class template placeholder PTYPE for
25565 template TMPL based on the initializer INIT, and return the resulting
25566 type. */
25568 static tree
25570 tsubst_flags_t complain)
25571 {
25573 {
25574 /* We should have handled this in the caller. */
25580 }
25591 {
25594 {
25595 /* As an exception, the first phase in 16.3.1.7 (considering the
25596 initializer list as a single argument) is omitted if the
25597 initializer list consists of a single expression of type cv U,
25598 where U is a specialization of C or a class derived from a
25599 specialization of C. */
25610 }
25613 else
25615 }
25616 else
25627 /* Prune explicit deduction guides in copy-initialization context. */
25629 {
25635 {
25636 /* Found a nonconverting guide, prune the candidates. */
25643 }
25644 }
25649 {
25652 }
25655 // FIXME cache artificial deduction guides
25657 {
25662 else
25666 }
25670 /* If this is list-initialization and the class has a list constructor, first
25671 try deducing from the list as a single argument, as [over.match.list]. */
25675 {
25679 }
25681 {
25687 {
25688 /* That didn't work, now try treating the list as a sequence of
25689 arguments. */
25692 }
25693 }
25695 /* Maybe generate an implicit deduction guide. */
25697 {
25701 /* Generate a copy guide. */
25704 /* Generate a default guide. */
25708 {
25711 }
25712 }
25715 {
25717 " of %qT, as it has no non-explicit deduction guides or "
25720 }
25722 {
25726 }
25729 {
25733 }
25736 {
25746 }
25751 }
25753 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25754 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
25756 tree
25758 {
25760 tf_warning_or_error,
25761 adc_unspecified);
25762 }
25764 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25765 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
25766 The CONTEXT determines the context in which auto deduction is performed
25767 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
25768 OUTER_TARGS are used during template argument deduction
25769 (context == adc_unify) to properly substitute the result, and is ignored
25770 in other contexts.
25772 For partial-concept-ids, extra args may be appended to the list of deduced
25773 template arguments prior to determining constraint satisfaction. */
25775 tree
25779 {
25780 tree targs;
25787 /* Defining a subset of type-dependent expressions that we can deduce
25788 from ahead of time isn't worth the trouble. */
25792 /* C++17 class template argument deduction. */
25796 /* Nothing we can do with this, even in deduction context. */
25799 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
25800 with either a new invented type template parameter U or, if the
25801 initializer is a braced-init-list (8.5.4), with
25802 std::initializer_list<U>. */
25804 {
25809 else
25810 {
25812 {
25816 "for deduction to %<std::initializer_list%>, use copy-"
25818 }
25820 }
25821 }
25832 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
25833 and initializer has array type, deduce cv-qualified array type. */
25835 complain);
25837 {
25846 {
25850 }
25851 }
25852 else
25853 {
25855 tree tparms;
25859 else
25860 {
25864 }
25871 {
25873 /* Try again at instantiation time. */
25877 /* If type is error_mark_node a diagnostic must have been
25878 emitted by now. Also, having a mention to '<type error>'
25879 in the diagnostic is not really useful to the user. */
25880 {
25884 else
25889 }
25891 }
25892 }
25894 /* Check any placeholder constraints against the deduced type. */
25897 {
25898 /* Use the deduced type to check the associated constraints. If we
25899 have a partial-concept-id, rebuild the argument list so that
25900 we check using the extra arguments. */
25904 {
25907 }
25908 else
25911 {
25913 {
25915 {
25933 }
25935 }
25937 }
25938 }
25944 }
25946 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
25947 result. */
25949 tree
25951 {
25953 {
25959 /* In an abbreviated function template we didn't know we were dealing
25960 with a function template when we saw the auto return type, so update
25961 it to have the correct level. */
25963 }
25965 }
25967 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
25968 'decltype(auto)' or a deduced class template. */
25970 bool
25972 {
25978 else
25980 }
25982 /* for_each_template_parm callback for type_uses_auto. */
25984 int
25986 {
25988 }
25990 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
25991 a use of `auto'. Returns NULL_TREE otherwise. */
25993 tree
25995 {
25999 {
26000 /* The Concepts TS allows multiple autos in one type-specifier; just
26001 return the first one we find, do_auto_deduction will collect all of
26002 them. */
26006 else
26008 }
26009 else
26011 }
26013 /* For a given template T, return the vector of typedefs referenced
26014 in T for which access check is needed at T instantiation time.
26015 T is either a FUNCTION_DECL or a RECORD_TYPE.
26016 Those typedefs were added to T by the function
26017 append_type_to_template_for_access_check. */
26021 {
26022 tree ti;
26033 {
26038 }
26041 }
26043 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
26044 tied to T. That list of typedefs will be access checked at
26045 T instantiation time.
26046 T is either a FUNCTION_DECL or a RECORD_TYPE.
26047 TYPE_DECL is a TYPE_DECL node representing a typedef.
26048 SCOPE is the scope through which TYPE_DECL is accessed.
26049 LOCATION is the location of the usage point of TYPE_DECL.
26051 This function is a subroutine of
26052 append_type_to_template_for_access_check. */
26054 static void
26056 tree type_decl,
26057 tree scope,
26058 location_t location)
26059 {
26060 qualified_typedef_usage_t typedef_usage;
26061 tree ti;
26068 && type_decl
26082 }
26084 /* Append TYPE_DECL to the template TEMPL.
26085 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
26086 At TEMPL instanciation time, TYPE_DECL will be checked to see
26087 if it can be accessed through SCOPE.
26088 LOCATION is the location of the usage point of TYPE_DECL.
26090 e.g. consider the following code snippet:
26092 class C
26093 {
26094 typedef int myint;
26095 };
26097 template<class U> struct S
26098 {
26099 C::myint mi; // <-- usage point of the typedef C::myint
26100 };
26102 S<char> s;
26104 At S<char> instantiation time, we need to check the access of C::myint
26105 In other words, we need to check the access of the myint typedef through
26106 the C scope. For that purpose, this function will add the myint typedef
26107 and the scope C through which its being accessed to a list of typedefs
26108 tied to the template S. That list will be walked at template instantiation
26109 time and access check performed on each typedefs it contains.
26110 Note that this particular code snippet should yield an error because
26111 myint is private to C. */
26113 void
26115 tree type_decl,
26116 tree scope,
26117 location_t location)
26118 {
26124 /* Make sure we don't append the type to the template twice. */
26131 }
26133 /* Convert the generic type parameters in PARM that match the types given in the
26134 range [START_IDX, END_IDX) from the current_template_parms into generic type
26135 packs. */
26137 tree
26139 {
26150 {
26151 /* Create a distinct parameter pack type from the current parm and add it
26152 to the replacement args to tsubst below into the generic function
26153 parameter. */
26168 }
26174 /* If there are more levels then build up the replacement with the outer
26175 template parms. */
26179 replacement);
26182 }
26184 /* Entries in the decl_constraint hash table. */
26186 {
26187 tree decl;
26188 tree ci;
26189 };
26191 /* Hashing function and equality for constraint entries. */
26193 {
26195 {
26197 }
26200 {
26202 }
26203 };
26205 /* A mapping from declarations to constraint information. Note that
26206 both templates and their underlying declarations are mapped to the
26207 same constraint information.
26209 FIXME: This is defined in pt.c because garbage collection
26210 code is not being generated for constraint.cc. */
26214 /* Returns the template constraints of declaration T. If T is not
26215 constrained, return NULL_TREE. Note that T must be non-null. */
26217 tree
26219 {
26230 else
26232 }
26234 /* Associate the given constraint information CI with the declaration
26235 T. If T is a template, then the constraints are associated with
26236 its underlying declaration. Don't build associations if CI is
26237 NULL_TREE. */
26239 void
26241 {
26253 }
26255 /* Remove the associated constraints of the declaration T. */
26257 void
26259 {
26268 }
26270 /* Memoized satisfaction results for declarations. This
26271 maps the pair (constraint_info, arguments) to the result computed
26272 by constraints_satisfied_p. */
26275 {
26276 tree ci;
26277 tree args;
26278 tree result;
26279 };
26281 /* Hashing function and equality for constraint entries. */
26284 {
26286 {
26289 }
26292 {
26294 }
26295 };
26297 /* Memoized satisfaction results for concept checks. */
26300 {
26301 tree tmpl;
26302 tree args;
26303 tree result;
26304 };
26306 /* Hashing function and equality for constraint entries. */
26309 {
26311 {
26313 }
26316 {
26321 }
26322 };
26327 /* Search for a memoized satisfaction result. Returns one of the
26328 truth value nodes if previously memoized, or NULL_TREE otherwise. */
26330 tree
26332 {
26337 else
26339 }
26341 /* Memoize the result of a satisfication test. Returns the saved result. */
26343 tree
26345 {
26352 }
26354 /* Search for a memoized satisfaction result for a concept. */
26356 tree
26358 {
26363 else
26365 }
26367 /* Memoize the result of a concept check. Returns the saved result. */
26369 tree
26371 {
26378 }
26382 /* Returns a prior concept specialization. This returns the substituted
26383 and normalized constraints defined by the concept. */
26385 tree
26387 {
26392 else
26394 }
26396 /* Save a concept expansion for later. */
26398 tree
26400 {
26407 }
26409 static hashval_t
26411 {
26420 }
26422 /* Compare the constraints of two subsumption entries. The LEFT1 and
26423 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
26424 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
26426 static bool
26428 {
26436 }
26438 /* Key/value pair for learning and memoizing subsumption results. This
26439 associates a pair of check constraints (including arguments) with
26440 a boolean value indicating the result. */
26443 {
26444 tree t1;
26445 tree t2;
26447 };
26449 /* Hashing function and equality for constraint entries. */
26452 {
26454 {
26456 }
26459 {
26464 }
26465 };
26469 /* Search for a previously cached subsumption result. */
26473 {
26478 else
26480 }
26482 /* Save a subsumption result. */
26484 bool
26486 {
26493 }
26495 /* Set up the hash table for constraint association. */
26497 void
26499 {
26508 }
26510 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
26511 0..N-1. */
26513 void
26515 {
26518 integer_type_node,
26519 NULL_TREE),
26523 }
26525 /* Set up the hash tables for template instantiations. */
26527 void
26529 {
26535 }
26537 /* Print stats about the template hash tables for -fstats. */
26539 void
26541 {
26550 }