| blob | 5547a6c049939e262ea519ddb543642b252e24de |
1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2015 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". */
61 /* The type of functions taking a tree, and some additional data, and
62 returning an int. */
65 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
66 instantiations have been deferred, either because their definitions
67 were not yet available, or because we were putting off doing the work. */
71 };
86 /* Live only within one (recursive) call to tsubst_expr. We use
87 this to pass the statement expression node from the STMT_EXPR
88 to the EXPR_STMT that is its result. */
91 // -------------------------------------------------------------------------- //
92 // Local Specialization Stack
93 //
94 // Implementation of the RAII helper for creating new local
95 // specializations.
98 {
100 }
103 {
106 }
108 /* True if we've recursed into fn_type_unification too many times. */
112 {
113 tree tmpl;
114 tree args;
115 tree spec;
116 };
119 {
122 };
128 /* Contains canonical template parameter types. The vector is indexed by
129 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
130 TREE_LIST, whose TREE_VALUEs contain the canonical template
131 parameters of various types and levels. */
134 #define UNIFY_ALLOW_NONE 0
135 #define UNIFY_ALLOW_MORE_CV_QUAL 1
136 #define UNIFY_ALLOW_LESS_CV_QUAL 2
137 #define UNIFY_ALLOW_DERIVED 4
138 #define UNIFY_ALLOW_INTEGER 8
139 #define UNIFY_ALLOW_OUTER_LEVEL 16
140 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
141 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
144 tbr_incomplete_type,
145 tbr_ambiguous_baseclass,
146 tbr_success
147 };
170 tree);
228 location_t);
234 /* Make the current scope suitable for access checking when we are
235 processing T. T can be FUNCTION_DECL for instantiated function
236 template, VAR_DECL for static member variable, or TYPE_DECL for
237 alias template (needed by instantiate_decl). */
239 static void
241 {
249 else
253 {
254 saved_access_scope = tree_cons
257 }
258 }
260 /* Restore the scope set up by push_access_scope. T is the node we
261 are processing. */
263 static void
265 {
267 {
270 }
274 else
276 }
278 /* Do any processing required when DECL (a member template
279 declaration) is finished. Returns the TEMPLATE_DECL corresponding
280 to DECL, unless it is a specialization, in which case the DECL
281 itself is returned. */
283 tree
285 {
292 {
293 tree type;
301 {
305 }
307 }
311 {
313 {
316 }
317 else
319 }
320 else
324 }
326 /* Create a template info node. */
328 tree
330 {
335 }
337 /* Return the template info node corresponding to T, whatever T is. */
339 tree
341 {
362 }
364 /* Returns the template nesting level of the indicated class TYPE.
366 For example, in:
367 template <class T>
368 struct A
369 {
370 template <class U>
371 struct B {};
372 };
374 A<T>::B<U> has depth two, while A<T> has depth one.
375 Both A<T>::B<int> and A<int>::B<U> have depth one, if
376 they are instantiations, not specializations.
378 This function is guaranteed to return 0 if passed NULL_TREE so
379 that, for example, `template_class_depth (current_class_type)' is
380 always safe. */
382 int
384 {
391 {
397 }
400 }
402 /* Subroutine of maybe_begin_member_template_processing.
403 Returns true if processing DECL needs us to push template parms. */
405 static bool
407 {
413 }
415 /* Subroutine of maybe_begin_member_template_processing.
416 Push the template parms in PARMS, starting from LEVELS steps into the
417 chain, and ending at the beginning, since template parms are listed
418 innermost first. */
420 static void
422 {
430 current_template_parms
436 NULL);
438 {
447 {
454 {
455 /* Make a CONST_DECL as is done in process_template_parm.
456 It is ugly that we recreate this here; the original
457 version built in process_template_parm is no longer
458 available. */
468 }
473 }
474 }
475 }
477 /* Restore the template parameter context for a member template, a
478 friend template defined in a class definition, or a non-template
479 member of template class. */
481 void
483 {
484 tree parms;
489 {
492 /* Disregard full specializations (c++/60999). */
495 }
498 {
503 {
506 }
509 }
511 /* Remember how many levels of template parameters we pushed so that
512 we can pop them later. */
514 }
516 /* Undo the effects of maybe_begin_member_template_processing. */
518 void
520 {
529 {
533 }
534 }
536 /* Return a new template argument vector which contains all of ARGS,
537 but has as its innermost set of arguments the EXTRA_ARGS. */
539 static tree
541 {
542 tree new_args;
560 }
562 /* Like add_to_template_args, but only the outermost ARGS are added to
563 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
564 (EXTRA_ARGS) levels are added. This function is used to combine
565 the template arguments from a partial instantiation with the
566 template arguments used to attain the full instantiation from the
567 partial instantiation. */
569 static tree
571 {
572 tree new_args;
574 /* If there are more levels of EXTRA_ARGS than there are ARGS,
575 something very fishy is going on. */
578 /* If *all* the new arguments will be the EXTRA_ARGS, just return
579 them. */
583 /* For the moment, we make ARGS look like it contains fewer levels. */
588 /* Now, we restore ARGS to its full dimensions. */
592 }
594 /* Return the N levels of innermost template arguments from the ARGS. */
596 tree
598 {
599 tree new_args;
605 /* If N is 1, just return the innermost set of template arguments. */
609 /* If we're not removing anything, just return the arguments we were
610 given. */
616 /* Make a new set of arguments, not containing the outer arguments. */
623 }
625 /* The inverse of get_innermost_template_args: Return all but the innermost
626 EXTRA_LEVELS levels of template arguments from the ARGS. */
628 static tree
630 {
631 tree new_args;
637 /* If N is 1, just return the outermost set of template arguments. */
641 /* If we're not removing anything, just return the arguments we were
642 given. */
647 /* Make a new set of arguments, not containing the inner arguments. */
654 }
656 /* We've got a template header coming up; push to a new level for storing
657 the parms. */
659 void
661 {
662 /* We use a non-tag-transparent scope here, which causes pushtag to
663 put tags in this scope, rather than in the enclosing class or
664 namespace scope. This is the right thing, since we want
665 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
666 global template class, push_template_decl handles putting the
667 TEMPLATE_DECL into top-level scope. For a nested template class,
668 e.g.:
670 template <class T> struct S1 {
671 template <class T> struct S2 {};
672 };
674 pushtag contains special code to call pushdecl_with_scope on the
675 TEMPLATE_DECL for S2. */
680 }
682 /* This routine is called when a specialization is declared. If it is
683 invalid to declare a specialization here, an error is reported and
684 false is returned, otherwise this routine will return true. */
686 static bool
688 {
691 /* [temp.expl.spec]
693 An explicit specialization shall be declared in the namespace of
694 which the template is a member, or, for member templates, in the
695 namespace of which the enclosing class or enclosing class
696 template is a member. An explicit specialization of a member
697 function, member class or static data member of a class template
698 shall be declared in the namespace of which the class template
699 is a member. */
701 {
704 }
706 /* [temp.expl.spec]
708 In an explicit specialization declaration for a member of a class
709 template or a member template that appears in namespace scope,
710 the member template and some of its enclosing class templates may
711 remain unspecialized, except that the declaration shall not
712 explicitly specialize a class member template if its enclosing
713 class templates are not explicitly specialized as well. */
715 {
718 }
721 }
723 /* We've just seen template <>. */
725 bool
727 {
731 }
733 /* Called at then end of processing a declaration preceded by
734 template<>. */
736 void
738 {
741 }
743 /* Any template <>'s that we have seen thus far are not referring to a
744 function specialization. */
746 void
748 {
751 }
753 /* We've just seen a template header. If SPECIALIZATION is nonzero,
754 it was of the form template <>. */
756 static void
758 {
760 template_header_count++;
761 }
763 /* We're beginning an explicit instantiation. */
765 void
767 {
770 }
773 void
775 {
778 }
780 /* An explicit specialization or partial specialization of TMPL is being
781 declared. Check that the namespace in which the specialization is
782 occurring is permissible. Returns false iff it is invalid to
783 specialize TMPL in the current namespace. */
785 static bool
787 {
790 /* [tmpl.expl.spec]
792 An explicit specialization shall be declared in the namespace of
793 which the template is a member, or, for member templates, in the
794 namespace of which the enclosing class or enclosing class
795 template is a member. An explicit specialization of a member
796 function, member class or static data member of a class template
797 shall be declared in the namespace of which the class template is
798 a member. */
801 {
804 }
806 /* Same or super-using namespace. */
808 else
809 {
813 }
814 }
816 /* SPEC is an explicit instantiation. Check that it is valid to
817 perform this explicit instantiation in the current namespace. */
819 static void
821 {
822 tree ns;
824 /* DR 275: An explicit instantiation shall appear in an enclosing
825 namespace of its template. */
831 }
833 // Returns the TEMPLATE_DECL that defines the partial template specialization
834 // TYPE. If TYPE is not found in the list of partial specializations, then
835 // it must be an explicit specialization.
836 static tree
838 {
843 {
848 }
850 }
852 // Return the template constraints for the template specialization TYPE.
855 {
856 // If TYPE is a partial specialization, return the constraints for
857 // that type. If it is an explicit specialization, return null since
858 // non-templates cannot be constrained.
861 else
863 }
865 // Returns the type of a template specialization only if that
866 // specialization needs to defined. Otherwise (e.g., if the type has
867 // already been defined), the function returns NULL_TREE.
868 static tree
870 {
871 // An implicit instantiation of an incomplete type implies
872 // the definition of a new class template.
873 //
874 // template<typename T>
875 // struct S;
876 //
877 // template<typename T>
878 // struct S<T*>;
879 //
880 // Here, S<T*> is an implicit instantiation of S whose type
881 // is incomplete.
885 // It can also be the case that TYPE is a completed specialization.
886 // Continuing the previous example, suppose we also declare:
887 //
888 // template<typename T>
889 // requires Integral<T>
890 // struct S<T*>;
891 //
892 // Here, S<T*> refers to the specialization S<T*> defined
893 // above. However, we need to differentiate definitions because
894 // we intend to define a new partial specialization. In this case,
895 // we rely on the fact that the constraints are different for
896 // this declaration than that above.
897 //
898 // Note that we also get here for injected class names and
899 // late-parsed template definitions. We must ensure that we
900 // do not create new type declarations for those cases.
901 //
902 // FIXME: This may allow multiple partial specializations to have
903 // equivalent constraints. We need to check this against all
904 // partial specializations with euqivalent type. For exmaple:
905 //
906 // template<typename T> struct S;
907 // template<typename T> struct S<T*>; // #1
908 // template<C T> struct S<T*>; // #2
909 // template<C T> struct S<T*>; // differs from #1 but not #2
911 {
915 // If TYPE is the same as the template's type, this is clearly
916 // not a specialization. This happens when you define a member
917 // template outside of its enclosing class.
921 // If there are no template parameters, this cannot be a new
922 // partial template specializtion?
926 // If the constraints are not the same as those of the primary
927 // then, we can probably create a new specialization.
934 // Also, if there's a pre-existing specialization with matching
935 // constraints, then this also isn't new.
938 {
944 }
946 // Create a new type node (and corresponding type decl)
947 // for the newly declared specialization.
954 // Build the corresponding type decl.
960 }
963 }
965 /* The TYPE is being declared. If it is a template type, that means it
966 is a partial specialization. Do appropriate error-checking. */
968 tree
970 {
971 tree context;
975 /* A lambda that appears in specialization context is not itself a
976 specialization. */
981 {
985 }
990 {
995 else
998 }
1000 {
1001 /* This is for ordinary explicit specialization and partial
1002 specialization of a template class such as:
1004 template <> class C<int>;
1006 or:
1008 template <class T> class C<T*>;
1010 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
1013 {
1020 {
1025 }
1026 }
1032 /* Trying to define a specialization either without a template<> header
1033 or in an inappropriate place. We've already given an error, so just
1034 bail now so we don't actually define the specialization. */
1036 }
1042 {
1043 /* This is for an explicit specialization of member class
1044 template according to [temp.expl.spec/18]:
1046 template <> template <class U> class C<int>::D;
1048 The context `C<int>' must be an implicit instantiation.
1049 Otherwise this is just a member class template declared
1050 earlier like:
1052 template <> class C<int> { template <class U> class D; };
1053 template <> template <class U> class C<int>::D;
1055 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1056 while in the second case, `C<int>::D' is a primary template
1057 and `C<T>::D' may not exist. */
1061 {
1062 tree t;
1067 {
1070 }
1072 /* Check for invalid specialization after instantiation:
1074 template <> template <> class C<int>::D<int>;
1075 template <> template <class U> class C<int>::D; */
1079 {
1083 {
1084 /* We already have a full specialization of this partial
1085 instantiation, or a full specialization has been
1086 looked up but not instantiated. Reassign it to the
1087 new member specialization template. */
1088 spec_entry elt;
1100 spec_entry **slot
1105 }
1106 else
1107 /* But if we've had an implicit instantiation, that's a
1108 problem ([temp.expl.spec]/6). */
1111 }
1113 /* Mark TYPE as a specialization. And as a result, we only
1114 have one level of template argument for the innermost
1115 class template. */
1120 }
1121 }
1123 {
1124 /* Someday C++0x may allow for enum template specialization. */
1129 else
1130 {
1133 }
1134 }
1137 }
1139 /* Returns nonzero if we can optimize the retrieval of specializations
1140 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1141 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1145 {
1148 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1149 parameter. */
1151 /* The optimized lookup depends on the fact that the
1152 template arguments for the member function template apply
1153 purely to the containing class, which is not true if the
1154 containing class is an explicit or partial
1155 specialization. */
1159 /* It is possible to have a template that is not a member
1160 template and is not a member of a template class:
1162 template <typename T>
1163 struct S { friend A::f(); };
1165 Here, the friend function is a template, but the context does
1166 not have template information. The optimized lookup relies
1167 on having ARGS be the template arguments for both the class
1168 and the function template. */
1170 }
1172 /* Retrieve the specialization (in the sense of [temp.spec] - a
1173 specialization is either an instantiation or an explicit
1174 specialization) of TMPL for the given template ARGS. If there is
1175 no such specialization, return NULL_TREE. The ARGS are a vector of
1176 arguments, or a vector of vectors of arguments, in the case of
1177 templates with more than one level of parameters.
1179 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1180 then we search for a partial specialization matching ARGS. This
1181 parameter is ignored if TMPL is not a class template.
1183 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1184 result is a NONTYPE_ARGUMENT_PACK. */
1186 static tree
1188 {
1198 /* There should be as many levels of arguments as there are
1199 levels of parameters. */
1206 {
1207 tree class_template;
1208 tree class_specialization;
1210 tree fns;
1213 /* The template arguments actually apply to the containing
1214 class. Find the class specialization with those
1215 arguments. */
1217 class_specialization
1221 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1222 for the specialization. */
1226 /* Iterate through the methods with the indicated name, looking
1227 for the one that has an instance of TMPL. */
1230 {
1233 /* using-declarations can add base methods to the method vec,
1234 and we don't want those here. */
1237 }
1239 }
1240 else
1241 {
1243 spec_entry elt;
1252 else
1260 }
1263 }
1265 /* Like retrieve_specialization, but for local declarations. */
1267 tree
1269 {
1275 }
1277 /* Returns nonzero iff DECL is a specialization of TMPL. */
1279 int
1281 {
1282 tree t;
1285 {
1291 }
1292 else
1293 {
1302 }
1305 }
1307 /* Returns nonzero iff DECL is a specialization of friend declaration
1308 FRIEND_DECL according to [temp.friend]. */
1310 bool
1312 {
1319 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1320 of a template class, we want to check if DECL is a specialization
1321 if this. */
1325 {
1326 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1329 }
1334 /* There is nothing to do if this is not a template friend. */
1341 /* [temp.friend/6]
1342 A member of a class template may be declared to be a friend of a
1343 non-template class. In this case, the corresponding member of
1344 every specialization of the class template is a friend of the
1345 class granting friendship.
1347 For example, given a template friend declaration
1349 template <class T> friend void A<T>::f();
1351 the member function below is considered a friend
1353 template <> struct A<int> {
1354 void f();
1355 };
1357 For this type of template friend, TEMPLATE_DEPTH below will be
1358 nonzero. To determine if DECL is a friend of FRIEND, we first
1359 check if the enclosing class is a specialization of another. */
1366 {
1367 /* Next, we check the members themselves. In order to handle
1368 a few tricky cases, such as when FRIEND_DECL's are
1370 template <class T> friend void A<T>::g(T t);
1371 template <class T> template <T t> friend void A<T>::h();
1373 and DECL's are
1375 void A<int>::g(int);
1376 template <int> void A<int>::h();
1378 we need to figure out ARGS, the template arguments from
1379 the context of DECL. This is required for template substitution
1380 of `T' in the function parameter of `g' and template parameter
1381 of `h' in the above examples. Here ARGS corresponds to `int'. */
1388 {
1390 {
1393 else
1395 current_depth++;
1396 }
1398 }
1401 {
1403 tree friend_type;
1404 tree decl_type;
1405 tree friend_args_type;
1406 tree decl_args_type;
1408 /* Make sure that both DECL and FRIEND_DECL are templates or
1409 non-templates. */
1415 {
1416 /* If both are templates, check template parameter list. */
1417 tree friend_parms
1422 friend_parms))
1426 }
1427 else
1435 /* Check if return types match. */
1439 /* Check if function parameter types match, ignoring the
1440 `this' parameter. */
1449 }
1450 else
1451 {
1452 /* DECL is a TYPE_DECL */
1456 /* Make sure that both DECL and FRIEND_DECL are templates or
1457 non-templates. */
1458 is_template
1465 {
1466 tree friend_parms;
1467 /* If both are templates, check the name of the two
1468 TEMPLATE_DECL's first because is_friend didn't. */
1473 /* Now check template parameter list. */
1474 friend_parms
1477 return comp_template_parms
1479 friend_parms);
1480 }
1481 else
1484 }
1485 }
1487 }
1489 /* Register the specialization SPEC as a specialization of TMPL with
1490 the indicated ARGS. IS_FRIEND indicates whether the specialization
1491 is actually just a friend declaration. Returns SPEC, or an
1492 equivalent prior declaration, if available.
1494 We also store instantiations of field packs in the hash table, even
1495 though they are not themselves templates, to make lookup easier. */
1497 static tree
1499 hashval_t hash)
1500 {
1501 tree fn;
1503 spec_entry elt;
1511 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1512 register it; we want the corresponding TEMPLATE_DECL instead.
1513 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1514 the more obvious `uses_template_parms (spec)' to avoid problems
1515 with default function arguments. In particular, given
1516 something like this:
1518 template <class T> void f(T t1, T t = T())
1520 the default argument expression is not substituted for in an
1521 instantiation unless and until it is actually needed. */
1525 /* We don't put these specializations in the hash table, but we might
1526 want to give an error about a mismatch. */
1528 else
1529 {
1537 slot =
1541 else
1543 }
1545 /* We can sometimes try to re-register a specialization that we've
1546 already got. In particular, regenerate_decl_from_template calls
1547 duplicate_decls which will update the specialization list. But,
1548 we'll still get called again here anyhow. It's more convenient
1549 to simply allow this than to try to prevent it. */
1553 {
1555 {
1558 {
1560 fn);
1562 }
1563 else
1564 {
1565 tree clone;
1566 /* This situation should occur only if the first
1567 specialization is an implicit instantiation, the
1568 second is an explicit specialization, and the
1569 implicit instantiation has not yet been used. That
1570 situation can occur if we have implicitly
1571 instantiated a member function and then specialized
1572 it later.
1574 We can also wind up here if a friend declaration that
1575 looked like an instantiation turns out to be a
1576 specialization:
1578 template <class T> void foo(T);
1579 class S { friend void foo<>(int) };
1580 template <> void foo(int);
1582 We transform the existing DECL in place so that any
1583 pointers to it become pointers to the updated
1584 declaration.
1586 If there was a definition for the template, but not
1587 for the specialization, we want this to look as if
1588 there were no definition, and vice versa. */
1592 /* The call to duplicate_decls will have applied
1593 [temp.expl.spec]:
1595 An explicit specialization of a function template
1596 is inline only if it is explicitly declared to be,
1597 and independently of whether its function template
1598 is.
1600 to the primary function; now copy the inline bits to
1601 the various clones. */
1603 {
1610 }
1614 }
1615 }
1617 {
1619 /* Dup decl failed, but this is a new definition. Set the
1620 line number so any errors match this new
1621 definition. */
1625 }
1626 }
1630 /* A specialization must be declared in the same namespace as the
1631 template it is specializing. */
1637 {
1646 /* If TMPL is a forward declaration of a template function, keep a list
1647 of all specializations in case we need to reassign them to a friend
1648 template later in tsubst_friend_function.
1650 Also keep a list of all variable template instantiations so that
1651 process_partial_specialization can check whether a later partial
1652 specialization would have used it. */
1655 }
1658 }
1661 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1662 TMPL and ARGS members, ignores SPEC. */
1666 bool
1668 {
1677 }
1679 /* Returns a hash for a template TMPL and template arguments ARGS. */
1681 static hashval_t
1683 {
1686 }
1688 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1689 ignoring SPEC. */
1691 hashval_t
1693 {
1695 }
1697 /* Recursively calculate a hash value for a template argument ARG, for use
1698 in the hash tables of template specializations. */
1700 hashval_t
1702 {
1714 /* We can get one of these when re-hashing a previous entry in the middle
1715 of substituting into a pack expansion. Just look through it. */
1724 {
1732 {
1737 }
1759 {
1763 {
1766 }
1768 }
1772 {
1775 }
1786 val = iterative_hash_template_arg
1798 val);
1800 val);
1809 /* A lambda can't appear in a template arg, but don't crash on
1810 erroneous input. */
1822 /* Now hash operands as usual. */
1827 }
1830 {
1833 {
1834 // We want an alias specialization that survived strip_typedefs
1835 // to hash differently from its TYPE_CANONICAL, to avoid hash
1836 // collisions that compare as different in template_args_equal.
1837 // These could be dependent specializations that strip_typedefs
1838 // left alone, or untouched specializations because
1839 // coerce_template_parms returns the unconverted template
1840 // arguments if it sees incomplete argument packs.
1843 }
1846 val);
1849 /* Otherwise just compare the types during lookup. */
1858 {
1863 }
1864 }
1867 }
1869 /* Unregister the specialization SPEC as a specialization of TMPL.
1870 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1871 if the SPEC was listed as a specialization of TMPL.
1873 Note that SPEC has been ggc_freed, so we can't look inside it. */
1875 bool
1877 {
1879 spec_entry elt;
1887 {
1892 }
1895 }
1897 /* Like register_specialization, but for local declarations. We are
1898 registering SPEC, an instantiation of TMPL. */
1900 void
1902 {
1904 }
1906 /* TYPE is a class type. Returns true if TYPE is an explicitly
1907 specialized class. */
1909 bool
1911 {
1915 }
1917 /* Print the list of functions at FNS, going through all the overloads
1918 for each element of the list. Alternatively, FNS can not be a
1919 TREE_LIST, in which case it will be printed together with all the
1920 overloads.
1922 MORE and *STR should respectively be FALSE and NULL when the function
1923 is called from the outside. They are used internally on recursive
1924 calls. print_candidates manages the two parameters and leaves NULL
1925 in *STR when it ends. */
1927 static void
1929 {
1935 {
1939 }
1940 else
1941 {
1944 {
1945 /* Pick the prefix string. */
1947 {
1951 }
1955 }
1958 }
1961 {
1964 }
1965 }
1967 /* Print the list of candidate FNS in an error message. FNS can also
1968 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1970 void
1972 {
1976 }
1978 /* Get a (possibly) constrained template declaration for the
1979 purpose of ordering candidates. */
1980 static tree
1982 {
1988 }
1990 /* Among candidates having the same signature, return the
1991 most constrained or NULL_TREE if there is no best candidate.
1992 If the signatures of candidates vary (e.g., template
1993 specialization vs. member function), then there can be no
1994 most constrained.
1996 Note that we don't compare constraints on the functions
1997 themselves, but rather those of their templates. */
1998 static tree
2000 {
2001 // Try to find the best candidate in a first pass.
2004 {
2011 }
2013 // Verify that the champ is better than previous candidates.
2018 }
2021 }
2024 /* Returns the template (one of the functions given by TEMPLATE_ID)
2025 which can be specialized to match the indicated DECL with the
2026 explicit template args given in TEMPLATE_ID. The DECL may be
2027 NULL_TREE if none is available. In that case, the functions in
2028 TEMPLATE_ID are non-members.
2030 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2031 specialization of a member template.
2033 The TEMPLATE_COUNT is the number of references to qualifying
2034 template classes that appeared in the name of the function. See
2035 check_explicit_specialization for a more accurate description.
2037 TSK indicates what kind of template declaration (if any) is being
2038 declared. TSK_TEMPLATE indicates that the declaration given by
2039 DECL, though a FUNCTION_DECL, has template parameters, and is
2040 therefore a template function.
2042 The template args (those explicitly specified and those deduced)
2043 are output in a newly created vector *TARGS_OUT.
2045 If it is impossible to determine the result, an error message is
2046 issued. The error_mark_node is returned to indicate failure. */
2048 static tree
2050 tree decl,
2054 tmpl_spec_kind tsk)
2055 {
2056 tree fns;
2057 tree targs;
2058 tree explicit_targs;
2062 /* A TREE_LIST of templates of which DECL may be a specialization.
2063 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2064 corresponding TREE_PURPOSE is the set of template arguments that,
2065 when used to instantiate the template, would produce a function
2066 with the signature of DECL. */
2076 /* We shouldn't be specializing a member template of an
2077 unspecialized class template; we already gave an error in
2078 check_specialization_scope, now avoid crashing. */
2081 {
2084 }
2092 /* Check for baselinks. */
2097 {
2100 }
2102 {
2105 }
2107 /* Count the number of template headers specified for this
2108 specialization. */
2118 {
2122 {
2123 tree decl_arg_types;
2124 tree fn_arg_types;
2125 tree insttype;
2127 /* In case of explicit specialization, we need to check if
2128 the number of template headers appearing in the specialization
2129 is correct. This is usually done in check_explicit_specialization,
2130 but the check done there cannot be exhaustive when specializing
2131 member functions. Consider the following code:
2133 template <> void A<int>::f(int);
2134 template <> template <> void A<int>::f(int);
2136 Assuming that A<int> is not itself an explicit specialization
2137 already, the first line specializes "f" which is a non-template
2138 member function, whilst the second line specializes "f" which
2139 is a template member function. So both lines are syntactically
2140 correct, and check_explicit_specialization does not reject
2141 them.
2143 Here, we can do better, as we are matching the specialization
2144 against the declarations. We count the number of template
2145 headers, and we check if they match TEMPLATE_COUNT + 1
2146 (TEMPLATE_COUNT is the number of qualifying template classes,
2147 plus there must be another header for the member template
2148 itself).
2150 Notice that if header_count is zero, this is not a
2151 specialization but rather a template instantiation, so there
2152 is no check we can perform here. */
2157 /* Check that the number of template arguments at the
2158 innermost level for DECL is the same as for FN. */
2166 /* DECL might be a specialization of FN. */
2170 /* For a non-static member function, we need to make sure
2171 that the const qualification is the same. Since
2172 get_bindings does not try to merge the "this" parameter,
2173 we must do the comparison explicitly. */
2179 /* Skip the "this" parameter and, for constructors of
2180 classes with virtual bases, the VTT parameter. A
2181 full specialization of a constructor will have a VTT
2182 parameter, but a template never will. */
2183 decl_arg_types
2185 fn_arg_types
2188 /* Function templates cannot be specializations; there are
2189 no partial specializations of functions. Therefore, if
2190 the type of DECL does not match FN, there is no
2191 match.
2193 Note that it should never be the case that we have both
2194 candidates added here, and for regular member functions
2195 below. */
2197 {
2201 }
2203 /* See whether this function might be a specialization of this
2204 template. Suppress access control because we might be trying
2205 to make this specialization a friend, and we have already done
2206 access control for the declaration of the specialization. */
2212 /* We cannot deduce template arguments that when used to
2213 specialize TMPL will produce DECL. */
2216 /* Remove, from the set of candidates, all those functions
2217 whose constraints are not satisfied. */
2221 // Then, try to form the new function type.
2225 fn_arg_types
2230 /* Save this template, and the arguments deduced. */
2232 }
2234 /* FN is an ordinary member function, and we need a
2235 specialization of a member template. */
2236 ;
2238 /* We can get IDENTIFIER_NODEs here in certain erroneous
2239 cases. */
2240 ;
2242 /* This is just an ordinary non-member function. Nothing can
2243 be a specialization of that. */
2244 ;
2246 /* Cannot specialize functions that are created implicitly. */
2247 ;
2248 else
2249 {
2250 tree decl_arg_types;
2252 /* This is an ordinary member function. However, since
2253 we're here, we can assume its enclosing class is a
2254 template class. For example,
2256 template <typename T> struct S { void f(); };
2257 template <> void S<int>::f() {}
2259 Here, S<int>::f is a non-template, but S<int> is a
2260 template class. If FN has the same type as DECL, we
2261 might be in business. */
2264 /* Its enclosing class is an explicit specialization
2265 of a template class. This is not a candidate. */
2271 /* The return types differ. */
2274 /* Adjust the type of DECL in case FN is a static member. */
2281 decl_arg_types))
2284 // If the deduced arguments do not satisfy the constraints,
2285 // this is not a candidate. If it fails, record the
2286 // rejected candidate.
2288 {
2291 }
2293 // Add the candidate.
2295 }
2296 }
2299 {
2300 /* We have:
2302 [temp.expl.spec]
2304 It is possible for a specialization with a given function
2305 signature to be instantiated from more than one function
2306 template. In such cases, explicit specification of the
2307 template arguments must be used to uniquely identify the
2308 function template specialization being specialized.
2310 Note that here, there's no suggestion that we're supposed to
2311 determine which of the candidate templates is most
2312 specialized. However, we, also have:
2314 [temp.func.order]
2316 Partial ordering of overloaded function template
2317 declarations is used in the following contexts to select
2318 the function template to which a function template
2319 specialization refers:
2321 -- when an explicit specialization refers to a function
2322 template.
2324 So, we do use the partial ordering rules, at least for now.
2325 This extension can only serve to make invalid programs valid,
2326 so it's safe. And, there is strong anecdotal evidence that
2327 the committee intended the partial ordering rules to apply;
2328 the EDG front end has that behavior, and John Spicer claims
2329 that the committee simply forgot to delete the wording in
2330 [temp.expl.spec]. */
2333 {
2336 }
2337 }
2339 // Concepts allows multiple declarations of member functions
2340 // with the same signature. Like above, we need to rely on
2341 // on the partial ordering of those candidates to determine which
2342 // is the best.
2344 {
2346 {
2349 }
2350 }
2353 {
2363 }
2367 {
2373 }
2375 /* We have one, and exactly one, match. */
2377 {
2381 // Propagate the candidate's constraints to the declaration.
2384 /* DECL is a re-declaration or partial instantiation of a template
2385 function. */
2389 /* It was a specialization of an ordinary member function in a
2390 template class. */
2392 }
2394 /* It was a specialization of a template. */
2397 {
2402 }
2403 else
2407 }
2409 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2410 but with the default argument values filled in from those in the
2411 TMPL_TYPES. */
2413 static tree
2415 tree tmpl_types)
2416 {
2417 tree new_spec_types;
2425 /* Substitute into the rest of the list. */
2426 new_spec_types =
2430 /* Add the default argument for this parameter. */
2433 new_spec_types);
2434 }
2436 /* DECL is an explicit specialization. Replicate default arguments
2437 from the template it specializes. (That way, code like:
2439 template <class T> void f(T = 3);
2440 template <> void f(double);
2441 void g () { f (); }
2443 works, as required.) An alternative approach would be to look up
2444 the correct default arguments at the call-site, but this approach
2445 is consistent with how implicit instantiations are handled. */
2447 static void
2449 {
2450 tree tmpl;
2451 tree spec_types;
2452 tree tmpl_types;
2453 tree new_spec_types;
2454 tree old_type;
2455 tree new_type;
2456 tree t;
2461 /* See if there's anything we need to do. */
2474 {
2475 /* Remove the this pointer, but remember the object's type for
2476 CV quals. */
2482 {
2483 /* DECL may contain more parameters than TMPL due to the extra
2484 in-charge parameter in constructors and destructors. */
2487 }
2489 {
2492 }
2493 }
2495 /* Compute the merged default arguments. */
2496 new_spec_types =
2499 /* Compute the new FUNCTION_TYPE. */
2501 {
2505 new_spec_types);
2508 /* Put the in-charge parameter back. */
2511 new_spec_types);
2515 new_spec_types);
2516 }
2517 else
2519 new_spec_types);
2529 }
2531 /* Return the number of template headers we expect to see for a definition
2532 or specialization of CTYPE or one of its non-template members. */
2534 int
2536 {
2540 {
2541 /* You're supposed to have one `template <...>' for every
2542 template class, but you don't need one for a full
2543 specialization. For example:
2545 template <class T> struct S{};
2546 template <> struct S<int> { void f(); };
2547 void S<int>::f () {}
2549 is correct; there shouldn't be a `template <>' for the
2550 definition of `S<int>::f'. */
2552 /* If CTYPE does not have template information of any
2553 kind, then it is not a template, nor is it nested
2554 within a template. */
2562 }
2565 }
2567 /* Do a simple sanity check on the template headers that precede the
2568 variable declaration DECL. */
2570 void
2572 {
2577 {
2580 "variable templates only available with "
2583 // Namespace-scope variable templates should have a template header.
2585 }
2587 {
2594 "members of an explicitly specialized class are defined "
2596 }
2597 }
2599 /* Check to see if the function just declared, as indicated in
2600 DECLARATOR, and in DECL, is a specialization of a function
2601 template. We may also discover that the declaration is an explicit
2602 instantiation at this point.
2604 Returns DECL, or an equivalent declaration that should be used
2605 instead if all goes well. Issues an error message if something is
2606 amiss. Returns error_mark_node if the error is not easily
2607 recoverable.
2609 FLAGS is a bitmask consisting of the following flags:
2611 2: The function has a definition.
2612 4: The function is a friend.
2614 The TEMPLATE_COUNT is the number of references to qualifying
2615 template classes that appeared in the name of the function. For
2616 example, in
2618 template <class T> struct S { void f(); };
2619 void S<int>::f();
2621 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2622 classes are not counted in the TEMPLATE_COUNT, so that in
2624 template <class T> struct S {};
2625 template <> struct S<int> { void f(); }
2626 template <> void S<int>::f();
2628 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2629 invalid; there should be no template <>.)
2631 If the function is a specialization, it is marked as such via
2632 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2633 is set up correctly, and it is added to the list of specializations
2634 for that template. */
2636 tree
2638 tree decl,
2641 {
2650 tmpl_spec_kind tsk;
2653 {
2656 else
2658 }
2659 else
2663 {
2666 {
2669 }
2671 {
2673 /* This could be something like:
2675 template <class T> void f(T);
2676 class S { friend void f<>(int); } */
2678 else
2679 {
2680 /* This case handles bogus declarations like template <>
2681 template <class T> void f<int>(); */
2684 declarator);
2686 }
2687 }
2691 /* The error has already been reported in
2692 check_specialization_scope. */
2698 /* Fall through. */
2711 decl);
2714 else
2718 /* Fall through. */
2724 /* In cases like template<> constexpr bool v = true;
2725 We'll give an error in check_template_variable. */
2731 else
2737 {
2738 /* This case handles bogus declarations like template <>
2739 template <class T> void f<int>(); */
2743 declarator);
2745 {
2746 /* Partial specialization of variable template. */
2750 }
2754 else
2758 ok:;
2759 }
2762 /* This is a specialization of a member template, without
2763 specialization the containing class. Something like:
2765 template <class T> struct S {
2766 template <class U> void f (U);
2767 };
2768 template <> template <class U> void S<int>::f(U) {}
2770 That's a specialization -- but of the entire template. */
2776 }
2779 /* This doesn't apply to variable templates. */
2782 {
2786 {
2790 }
2791 }
2794 {
2799 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2801 {
2802 tree fns;
2807 else
2808 {
2809 /* If there is no class context, the explicit instantiation
2810 must be at namespace scope. */
2813 /* Find the namespace binding, using the declaration
2814 context. */
2818 {
2821 }
2822 else
2823 {
2829 }
2830 }
2833 }
2839 {
2841 /* A specialization in class scope. This is invalid,
2842 but the error will already have been flagged by
2843 check_specialization_scope. */
2845 else
2846 {
2847 /* It's not valid to write an explicit instantiation in
2848 class scope, e.g.:
2850 class C { template void f(); }
2852 This case is caught by the parser. However, on
2853 something like:
2855 template class C { void f(); };
2857 (which is invalid) we can get here. The error will be
2858 issued later. */
2859 ;
2860 }
2863 }
2866 {
2867 // We'll match variable templates in start_decl.
2871 /* Find the list of functions in ctype that have the same
2872 name as the declared function. */
2878 {
2883 {
2884 /* From [temp.expl.spec]:
2886 If such an explicit specialization for the member
2887 of a class template names an implicitly-declared
2888 special member function (clause _special_), the
2889 program is ill-formed.
2891 Similar language is found in [temp.explicit]. */
2894 }
2897 }
2900 {
2904 }
2905 else
2906 {
2908 tree ovl;
2910 /* For a type-conversion operator, we cannot do a
2911 name-based lookup. We might be looking for `operator
2912 int' which will be a specialization of `operator T'.
2913 So, we find *all* the conversion operators, and then
2914 select from them. */
2922 {
2924 /* There are no more conversion functions. */
2927 /* Glue all these conversion functions together
2928 with those we already have. */
2931 }
2932 }
2935 {
2938 }
2939 else
2941 }
2943 /* Figure out what exactly is being specialized at this point.
2944 Note that for an explicit instantiation, even one for a
2945 member function, we cannot tell apriori whether the
2946 instantiation is for a member template, or just a member
2947 function of a template class. Even if a member template is
2948 being instantiated, the member template arguments may be
2949 elided if they can be deduced from the rest of the
2950 declaration. */
2953 member_specialization,
2954 template_count,
2955 tsk);
2958 /* We couldn't figure out what this declaration was
2959 specializing. */
2961 else
2962 {
2966 {
2967 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2968 is done by do_decl_instantiation later. */
2974 {
2975 /* If TMPL is not the most general template (for
2976 example, if TMPL is a friend template that is
2977 injected into namespace scope), then there will
2978 be too many levels of TARGS. Remove some of them
2979 here. */
2981 tree new_targs;
2988 }
2991 }
2993 /* If we thought that the DECL was a member function, but it
2994 turns out to be specializing a static member function,
2995 make DECL a static member function as well. */
3001 /* If this is a specialization of a member template of a
3002 template class, we want to return the TEMPLATE_DECL, not
3003 the specialization of it. */
3005 {
3010 {
3011 tree parm;
3015 /* We want to use the argument list specified in the
3016 definition, not in the original declaration. */
3021 }
3024 }
3026 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3032 /* Inherit default function arguments from the template
3033 DECL is specializing. */
3037 /* This specialization has the same protection as the
3038 template it specializes. */
3042 /* 7.1.1-1 [dcl.stc]
3044 A storage-class-specifier shall not be specified in an
3045 explicit specialization...
3047 The parser rejects these, so unless action is taken here,
3048 explicit function specializations will always appear with
3049 global linkage.
3051 The action recommended by the C++ CWG in response to C++
3052 defect report 605 is to make the storage class and linkage
3053 of the explicit specialization match the templated function:
3055 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3056 */
3058 {
3062 // A concept cannot be specialized.
3064 {
3067 }
3069 /* This specialization has the same linkage and visibility as
3070 the function template it specializes. */
3073 {
3076 }
3079 {
3082 }
3083 }
3085 /* If DECL is a friend declaration, declared using an
3086 unqualified name, the namespace associated with DECL may
3087 have been set incorrectly. For example, in:
3089 template <typename T> void f(T);
3090 namespace N {
3091 struct S { friend void f<int>(int); }
3092 }
3094 we will have set the DECL_CONTEXT for the friend
3095 declaration to N, rather than to the global namespace. */
3100 /* This is not really a declaration of a specialization.
3101 It's just the name of an instantiation. But, it's not
3102 a request for an instantiation, either. */
3105 /* A specialization is not necessarily COMDAT. */
3111 /* Register this specialization so that we can find it
3112 again. */
3115 /* A 'structor should already have clones. */
3121 }
3122 }
3125 }
3127 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3128 parameters. These are represented in the same format used for
3129 DECL_TEMPLATE_PARMS. */
3131 int
3133 {
3134 const_tree p1;
3135 const_tree p2;
3143 {
3155 {
3159 /* If either of the template parameters are invalid, assume
3160 they match for the sake of error recovery. */
3173 }
3174 }
3177 /* One set of parameters has more parameters lists than the
3178 other. */
3182 }
3184 /* Determine whether PARM is a parameter pack. */
3186 bool
3188 {
3189 /* Determine if we have a non-type template parameter pack. */
3196 /* If this is a list of template parameters, we could get a
3197 TYPE_DECL or a TEMPLATE_DECL. */
3201 /* Otherwise it must be a type template parameter. */
3205 }
3207 /* Determine if T is a function parameter pack. */
3209 bool
3211 {
3215 }
3217 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3218 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3220 tree
3222 {
3229 }
3231 /* Return true iff the function parameter PARAM_DECL was expanded
3232 from the function parameter pack PACK. */
3234 bool
3236 {
3241 /* The parameter pack and its pack arguments have the same
3242 DECL_PARM_INDEX. */
3244 }
3246 /* Determine whether ARGS describes a variadic template args list,
3247 i.e., one that is terminated by a template argument pack. */
3249 static bool
3251 {
3253 tree last_parm;
3267 }
3269 /* Generate a new name for the parameter pack name NAME (an
3270 IDENTIFIER_NODE) that incorporates its */
3272 static tree
3274 {
3275 /* Munge the name to include the parameter index. */
3276 #define NUMBUF_LEN 128
3290 }
3292 /* Return true if T is a primary function, class or alias template
3293 instantiation. */
3295 bool
3297 {
3311 }
3313 /* Return true if PARM is a template template parameter. */
3315 bool
3317 {
3319 }
3321 /* Return true iff PARM is a DECL representing a type template
3322 parameter. */
3324 bool
3326 {
3331 }
3333 /* Return the template parameters of T if T is a
3334 primary template instantiation, NULL otherwise. */
3336 tree
3338 {
3343 parms = INNERMOST_TEMPLATE_PARMS
3347 }
3349 /* Return the template parameters of the LEVELth level from the full list
3350 of template parameters PARMS. */
3352 tree
3354 {
3355 tree p;
3366 }
3368 /* Returns the template arguments of T if T is a template instantiation,
3369 NULL otherwise. */
3371 tree
3373 {
3381 }
3383 /* Return the argument pack elements of T if T is a template argument pack,
3384 NULL otherwise. */
3386 tree
3388 {
3394 }
3396 /* Structure used to track the progress of find_parameter_packs_r. */
3397 struct find_parameter_pack_data
3398 {
3399 /* TREE_LIST that will contain all of the parameter packs found by
3400 the traversal. */
3403 /* Set of AST nodes that have been visited by the traversal. */
3405 };
3407 /* Identifies all of the argument packs that occur in a template
3408 argument and appends them to the TREE_LIST inside DATA, which is a
3409 find_parameter_pack_data structure. This is a subroutine of
3410 make_pack_expansion and uses_parameter_packs. */
3411 static tree
3413 {
3419 /* Handle type aliases/typedefs. */
3421 {
3428 }
3430 /* Identify whether this is a parameter pack or not. */
3432 {
3448 {
3449 /* We don't want to walk into the type of a PARM_DECL,
3450 because we don't want to see the type parameter pack. */
3453 }
3456 /* Look through a lambda capture proxy to the field pack. */
3459 {
3465 }
3472 /* Not a parameter pack. */
3474 }
3477 {
3478 /* Add this parameter pack to the list. */
3480 }
3486 /* This switch statement will return immediately if we don't find a
3487 parameter pack. */
3489 {
3494 /* Check the template itself. */
3497 /* Check the template arguments. */
3513 /* Fall through. */
3555 }
3558 }
3560 /* Determines if the expression or type T uses any parameter packs. */
3561 bool
3563 {
3571 }
3573 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3574 representation a base-class initializer into a parameter pack
3575 expansion. If all goes well, the resulting node will be an
3576 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3577 respectively. */
3578 tree
3580 {
3581 tree result;
3590 {
3591 /* The only time we will see a TREE_LIST here is for a base
3592 class initializer. In this case, the TREE_PURPOSE will be a
3593 _TYPE node (representing the base class expansion we're
3594 initializing) and the TREE_VALUE will be a TREE_LIST
3595 containing the initialization arguments.
3597 The resulting expansion looks somewhat different from most
3598 expansions. Rather than returning just one _EXPANSION, we
3599 return a TREE_LIST whose TREE_PURPOSE is a
3600 TYPE_PACK_EXPANSION containing the bases that will be
3601 initialized. The TREE_VALUE will be identical to the
3602 original TREE_VALUE, which is a list of arguments that will
3603 be passed to each base. We do not introduce any new pack
3604 expansion nodes into the TREE_VALUE (although it is possible
3605 that some already exist), because the TREE_PURPOSE and
3606 TREE_VALUE all need to be expanded together with the same
3607 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3608 resulting TREE_PURPOSE will mention the parameter packs in
3609 both the bases and the arguments to the bases. */
3610 tree purpose;
3611 tree value;
3614 /* Determine which parameter packs will be used by the base
3615 class expansion. */
3622 {
3626 }
3629 {
3630 /* Collect the sets of parameter packs used in each of the
3631 initialization arguments. */
3633 {
3634 /* Determine which parameter packs will be expanded in this
3635 argument. */
3638 }
3639 }
3643 /* Create the pack expansion type for the base type. */
3648 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3649 they will rarely be compared to anything. */
3653 }
3658 /* Build the PACK_EXPANSION_* node. */
3659 result = for_types
3664 {
3665 /* Propagate type and const-expression information. */
3668 }
3669 else
3670 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3671 they will rarely be compared to anything. */
3674 /* Determine which parameter packs will be expanded. */
3680 /* Make sure we found some parameter packs. */
3682 {
3685 else
3688 }
3694 }
3696 /* Checks T for any "bare" parameter packs, which have not yet been
3697 expanded, and issues an error if any are found. This operation can
3698 only be done on full expressions or types (e.g., an expression
3699 statement, "if" condition, etc.), because we could have expressions like:
3701 foo(f(g(h(args)))...)
3703 where "args" is a parameter pack. check_for_bare_parameter_packs
3704 should not be called for the subexpressions args, h(args),
3705 g(h(args)), or f(g(h(args))), because we would produce erroneous
3706 error messages.
3708 Returns TRUE and emits an error if there were bare parameter packs,
3709 returns FALSE otherwise. */
3710 bool
3712 {
3728 {
3731 {
3740 else
3745 else
3749 }
3752 }
3755 }
3757 /* Expand any parameter packs that occur in the template arguments in
3758 ARGS. */
3759 tree
3761 {
3767 /* First, determine if we need to expand anything, and the number of
3768 slots we'll need. */
3770 {
3775 {
3779 else
3781 }
3782 else
3783 {
3785 num_result_args++;
3786 }
3787 }
3789 /* If no expansion is necessary, we're done. */
3793 /* Expand arguments. */
3796 non_default_args_count =
3799 {
3802 {
3809 }
3810 else
3811 {
3814 }
3815 }
3819 }
3821 /* Checks if DECL shadows a template parameter.
3823 [temp.local]: A template-parameter shall not be redeclared within its
3824 scope (including nested scopes).
3826 Emits an error and returns TRUE if the DECL shadows a parameter,
3827 returns FALSE otherwise. */
3829 bool
3831 {
3832 tree olddecl;
3834 /* If we're not in a template, we can't possibly shadow a template
3835 parameter. */
3839 /* Figure out what we're shadowing. */
3844 /* If there's no previous binding for this name, we're not shadowing
3845 anything, let alone a template parameter. */
3849 /* If we're not shadowing a template parameter, we're done. Note
3850 that OLDDECL might be an OVERLOAD (or perhaps even an
3851 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3852 node. */
3856 /* We check for decl != olddecl to avoid bogus errors for using a
3857 name inside a class. We check TPFI to avoid duplicate errors for
3858 inline member templates. */
3864 /* Don't complain about the injected class name, as we've already
3865 complained about the class itself. */
3872 }
3874 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3875 ORIG_LEVEL, DECL, and TYPE. */
3877 static tree
3881 tree decl,
3882 tree type)
3883 {
3894 }
3896 /* Find the canonical type parameter for the given template type
3897 parameter. Returns the canonical type parameter, which may be TYPE
3898 if no such parameter existed. */
3900 static tree
3902 {
3903 tree list;
3917 else
3918 {
3923 }
3924 }
3926 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3927 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3928 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3929 new one is created. */
3931 static tree
3933 tsubst_flags_t complain)
3934 {
3939 {
3958 /* Template template parameters need this. */
3963 }
3966 }
3968 /* Process information from new template parameter PARM and append it
3969 to the LIST being built. This new parameter is a non-type
3970 parameter iff IS_NON_TYPE is true. This new parameter is a
3971 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3972 is in PARM_LOC. */
3974 tree
3977 {
3987 {
3991 {
3995 else
3997 }
4000 }
4003 {
4009 {
4010 /* [temp.param]
4012 The top-level cv-qualifiers on the template-parameter are
4013 ignored when determining its type. */
4018 && !is_parameter_pack
4019 /* If we're in a nested template parameter list, the template
4020 template parameter could be a parameter pack. */
4022 {
4023 /* This template parameter is not a parameter pack, but it
4024 should be. Complain about "bare" parameter packs. */
4027 /* Recover by calling this a parameter pack. */
4029 }
4030 }
4032 /* A template parameter is not modifiable. */
4041 processing_template_decl,
4046 }
4047 else
4048 {
4049 tree t;
4053 {
4055 /* This is for distinguishing between real templates and template
4056 template parameters */
4060 }
4061 else
4062 {
4064 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4067 }
4074 processing_template_decl,
4078 }
4082 // Build requirements for the type/template parameter. This must be done
4083 // after SET_DECL_TEMPLATE_PARM_P or process_template_parm could fail.
4088 // Build the parameter node linking the parameter declaration, its
4089 // default argument (if any), and its constraints (if any).
4094 }
4096 /* The end of a template parameter list has been reached. Process the
4097 tree list into a parameter vector, converting each parameter into a more
4098 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4099 as PARM_DECLs. */
4101 tree
4103 {
4108 current_template_parms
4113 {
4117 }
4122 }
4124 // Explicitly indicate the end of the template parameter list. We assume
4125 // that the current template parameters have been constructed and/or
4126 // managed explicitly, as when creating new template template parameters
4127 // from a shorthand constraint.
4128 void
4130 {
4132 }
4134 /* end_template_decl is called after a template declaration is seen. */
4136 void
4138 {
4144 /* This matches the pushlevel in begin_template_parm_list. */
4149 }
4151 /* Takes a TREE_LIST representing a template parameter and convert it
4152 into an argument suitable to be passed to the type substitution
4153 functions. Note that If the TREE_LIST contains an error_mark
4154 node, the returned argument is error_mark_node. */
4156 tree
4158 {
4171 {
4175 {
4176 /* Turn this argument into a TYPE_ARGUMENT_PACK
4177 with a single element, which expands T. */
4179 #ifdef ENABLE_CHECKING
4180 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
4182 #endif
4187 }
4188 }
4189 else
4190 {
4194 {
4195 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4196 with a single element, which expands T. */
4199 #ifdef ENABLE_CHECKING
4200 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
4202 #endif
4209 }
4210 else
4212 }
4214 }
4216 /* Given a set of template parameters, return them as a set of template
4217 arguments. The template parameters are represented as a TREE_VEC, in
4218 the form documented in cp-tree.h for template arguments. */
4220 static tree
4222 {
4223 tree header;
4228 /* If there is only one level of template parameters, we do not
4229 create a TREE_VEC of TREE_VECs. Instead, we return a single
4230 TREE_VEC containing the arguments. */
4235 {
4243 #ifdef ENABLE_CHECKING
4245 #endif
4249 else
4251 }
4254 /* This can happen for template parms of a template template
4255 parameter, e.g:
4257 template<template<class T, class U> class TT> struct S;
4259 Consider the level of the parms of TT; T and U both have
4260 level 2; TT has no template parm of level 1. So in this case
4261 the first element of full_template_args is NULL_TREE. If we
4262 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
4263 of 2. This will make tsubst wrongly consider that T and U
4264 have level 1. Instead, let's create a dummy vector as the
4265 first element of full_template_args so that TMPL_ARGS_DEPTH
4266 returns the correct depth for args. */
4269 }
4271 /* Within the declaration of a template, return the currently active
4272 template parameters as an argument TREE_VEC. */
4274 static tree
4276 {
4278 }
4280 /* Update the declared TYPE by doing any lookups which were thought to be
4281 dependent, but are not now that we know the SCOPE of the declarator. */
4283 tree
4285 {
4296 /* Don't bother building up the args in this case. */
4298 {
4299 /* tsubst in the args corresponding to the template parameters,
4300 including auto if present. Most things will be unchanged, but
4301 make_typename_type and tsubst_qualified_id will resolve
4302 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4305 tree pushed;
4307 {
4311 }
4316 }
4322 {
4325 else
4327 }
4329 }
4331 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4332 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4333 the new template is a member template. */
4335 tree
4337 {
4345 }
4347 struct template_parm_data
4348 {
4349 /* The level of the template parameters we are currently
4350 processing. */
4353 /* The index of the specialization argument we are currently
4354 processing. */
4357 /* An array whose size is the number of template parameters. The
4358 elements are nonzero if the parameter has been used in any one
4359 of the arguments processed so far. */
4362 /* An array whose size is the number of template arguments. The
4363 elements are nonzero if the argument makes use of template
4364 parameters of this level. */
4366 };
4368 /* Subroutine of push_template_decl used to see if each template
4369 parameter in a partial specialization is used in the explicit
4370 argument list. If T is of the LEVEL given in DATA (which is
4371 treated as a template_parm_data*), then DATA->PARMS is marked
4372 appropriately. */
4374 static int
4376 {
4384 {
4387 }
4389 /* Return zero so that for_each_template_parm will continue the
4390 traversal of the tree; we want to mark *every* template parm. */
4392 }
4394 /* Process the partial specialization DECL. */
4396 static tree
4398 {
4405 tree inner_parms;
4406 tree inst;
4416 /* A concept cannot be specialized. */
4418 {
4421 }
4423 /* When defining a constrained partial specialization, DECL's type
4424 will have been assigned to the canonical type of the primary.
4425 That is:
4427 template<typename T>
4428 struct S; // Has canonical type S<T>
4430 template<C T>
4431 struct S<T>; // Binds to the primary template.
4433 However, the constraints differ, so we should be constructing
4434 a new type instead of simply referring to the old one. We
4435 do this by erasing the canonical type of the partial
4436 specialization and always comparing these types structurally.
4438 TODO: Do we need to compare the current requirements to make
4439 sure this isn't a redeclaration? */
4446 /* We check that each of the template parameters given in the
4447 partial specialization is used in the argument list to the
4448 specialization. For example:
4450 template <class T> struct S;
4451 template <class T> struct S<T*>;
4453 The second declaration is OK because `T*' uses the template
4454 parameter T, whereas
4456 template <class T> struct S<int>;
4458 is no good. Even trickier is:
4460 template <class T>
4461 struct S1
4462 {
4463 template <class U>
4464 struct S2;
4465 template <class U>
4466 struct S2<T>;
4467 };
4469 The S2<T> declaration is actually invalid; it is a
4470 full-specialization. Of course,
4472 template <class U>
4473 struct S2<T (*)(U)>;
4475 or some such would have been OK. */
4483 {
4488 NULL,
4490 }
4493 {
4494 /* One of the template parms was not used in a deduced context in the
4495 specialization. */
4497 {
4501 }
4505 }
4510 /* Build the associated constraints now so we can compare
4511 and assign them below. */
4512 tree tmpl_constr;
4514 {
4517 }
4518 else
4521 /* [temp.class.spec]
4523 The argument list of the specialization shall not be identical to
4524 the implicit argument list of the primary template. */
4525 tree main_args
4528 {
4532 else
4533 {
4534 /* If the arguments compare equal but are not not more
4535 constrained, then this will not be more specialized. */
4537 {
4542 }
4543 }
4544 }
4546 /* A partial specialization that replaces multiple parameters of the
4547 primary template with a pack expansion is less specialized for those
4548 parameters. */
4550 {
4552 "primary template because it replaces multiple parameters "
4556 }
4558 /* [temp.class.spec]
4560 A partially specialized non-type argument expression shall not
4561 involve template parameters of the partial specialization except
4562 when the argument expression is a simple identifier.
4564 The type of a template parameter corresponding to a specialized
4565 non-type argument shall not be dependent on a parameter of the
4566 specialization.
4568 Also, we verify that pack expansions only occur at the
4569 end of the argument list. */
4573 {
4580 {
4581 /* Extract the arguments from the argument pack. We'll be
4582 iterating over these in the following loop. */
4585 }
4588 {
4590 /* Get the Jth argument in the parameter pack. */
4594 {
4595 /* Pack expansions must come at the end of the
4596 argument list. */
4599 {
4603 else
4606 }
4607 }
4610 /* We only care about the pattern. */
4616 /* This next two lines are the `argument expression is not just a
4617 simple identifier' condition and also the `specialized
4618 non-type argument' bit. */
4622 {
4626 arg);
4627 else
4628 {
4629 /* Look at the corresponding template parameter,
4630 marking which template parameters its type depends
4631 upon. */
4635 {
4636 /* We haven't yet initialized TPD2. Do so now. */
4638 /* The number of parameters here is the number in the
4639 main template, which, as checked in the assertion
4640 above, is NARGS. */
4644 }
4646 /* Mark the template parameters. But this time, we're
4647 looking for the template parameters of the main
4648 template, not in the specialization. */
4655 NULL,
4659 {
4660 /* The type depended on some template parameters.
4661 If they are fully specialized in the
4662 specialization, that's OK. */
4671 "type %qT of template argument %qE depends "
4673 "type %qT of template argument %qE depends "
4675 type,
4676 arg);
4677 }
4678 }
4679 }
4680 }
4681 }
4683 /* We should only get here once. */
4687 // Build the template decl.
4689 current_template_parms,
4705 {
4711 {
4714 {
4718 "partial specialization of %qD after instantiation "
4720 }
4721 }
4722 }
4725 }
4727 /* PARM is a template parameter of some form; return the corresponding
4728 TEMPLATE_PARM_INDEX. */
4730 static tree
4732 {
4744 }
4746 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4747 parameter packs used by the template parameter PARM. */
4749 static void
4751 {
4752 /* A type parm can't refer to another parm. */
4756 {
4760 }
4767 }
4769 /* PARM is a template parameter pack. Return any parameter packs used in
4770 its type or the type of any of its template parameters. If there are
4771 any such packs, it will be instantiated into a fixed template parameter
4772 list by partial instantiation rather than be fully deduced. */
4774 tree
4776 {
4777 /* This can only be true in a member template. */
4780 /* This can only be true for a parameter pack. */
4783 /* A type parm can't refer to another parm. */
4796 }
4798 /* Check that a template declaration's use of default arguments and
4799 parameter packs is not invalid. Here, PARMS are the template
4800 parameters. IS_PRIMARY is true if DECL is the thing declared by
4801 a primary template. IS_PARTIAL is true if DECL is a partial
4802 specialization.
4804 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4805 declaration (but not a definition); 1 indicates a declaration, 2
4806 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4807 emitted for extraneous default arguments.
4809 Returns TRUE if there were no errors found, FALSE otherwise. */
4811 bool
4814 {
4817 tree parm_level;
4820 /* [temp.param]
4822 A default template-argument shall not be specified in a
4823 function template declaration or a function template definition, nor
4824 in the template-parameter-list of the definition of a member of a
4825 class template. */
4829 /* You can't have a function template declaration in a local
4830 scope, nor you can you define a member of a class template in a
4831 local scope. */
4839 /* A lambda doesn't have an explicit declaration; don't complain
4840 about the parms of the enclosing class. */
4847 /* If this is either a friend defined in the scope of the class
4848 or a member function. */
4854 /* And, if it was a member function, it really was defined in
4855 the scope of the class. */
4858 /* We already checked these parameters when the template was
4859 declared, so there's no need to do it again now. This function
4860 was defined in class scope, but we're processing its body now
4861 that the class is complete. */
4864 /* Core issue 226 (C++0x only): the following only applies to class
4865 templates. */
4868 {
4869 /* [temp.param]
4871 If a template-parameter has a default template-argument, all
4872 subsequent template-parameters shall have a default
4873 template-argument supplied. */
4875 {
4882 {
4892 {
4894 /* For better subsequent error-recovery, we indicate that
4895 there should have been a default argument. */
4898 }
4900 && !is_friend_decl
4901 /* Don't complain about an enclosing partial
4902 specialization. */
4907 /* A fixed parameter pack will be partially
4908 instantiated into a fixed length list. */
4910 {
4911 /* A primary class template can only have one
4912 parameter pack, at the end of the template
4913 parameter list. */
4921 }
4922 }
4923 }
4924 }
4927 || is_partial
4928 || !is_primary
4930 /* For an ordinary class template, default template arguments are
4931 allowed at the innermost level, e.g.:
4932 template <class T = int>
4933 struct S {};
4934 but, in a partial specialization, they're not allowed even
4935 there, as we have in [temp.class.spec]:
4937 The template parameter list of a specialization shall not
4938 contain default template argument values.
4940 So, for a partial specialization, or for a function template
4941 (in C++98/C++03), we look at all of them. */
4942 ;
4943 else
4944 /* But, for a primary class template that is not a partial
4945 specialization we look at all template parameters except the
4946 innermost ones. */
4949 /* Figure out what error message to issue. */
4962 else
4966 /* If we're inside a class definition, there's no need to
4967 examine the parameters to the class itself. On the one
4968 hand, they will be checked when the class is defined, and,
4969 on the other, default arguments are valid in things like:
4970 template <class T = double>
4971 struct S { template <class U> void f(U); };
4972 Here the default argument for `S' has no bearing on the
4973 declaration of `f'. */
4975 else
4976 /* Check everything. */
4982 {
4989 {
4994 {
4996 {
5003 }
5005 /* Clear out the default argument so that we are not
5006 confused later. */
5008 }
5009 }
5011 /* At this point, if we're still interested in issuing messages,
5012 they must apply to classes surrounding the object declared. */
5016 }
5019 }
5021 /* Worker for push_template_decl_real, called via
5022 for_each_template_parm. DATA is really an int, indicating the
5023 level of the parameters we are interested in. If T is a template
5024 parameter of that level, return nonzero. */
5026 static int
5028 {
5034 else
5037 }
5039 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5040 parameters given by current_template_args, or reuses a
5041 previously existing one, if appropriate. Returns the DECL, or an
5042 equivalent one, if it is replaced via a call to duplicate_decls.
5044 If IS_FRIEND is true, DECL is a friend declaration. */
5046 tree
5048 {
5049 tree tmpl;
5050 tree args;
5051 tree info;
5052 tree ctx;
5056 /* True if the template is a member template, in the sense of
5057 [temp.mem]. */
5063 /* See if this is a partial specialization. */
5076 /* For a friend, we want the context of the friend function, not
5077 the type of which it is a friend. */
5081 /* In the case of a virtual function, we want the class in which
5082 it is defined. */
5084 else
5085 /* Otherwise, if we're currently defining some class, the DECL
5086 is assumed to be a member of the class. */
5095 /* See if this is a primary template. */
5098 /* A friend template that specifies a class context, i.e.
5099 template <typename T> friend void A<T>::f();
5100 is not primary. */
5105 else
5109 {
5114 {
5117 }
5119 {
5121 {
5124 }
5126 {
5127 /* [temp.mem]
5129 A destructor shall not be a member template. */
5132 }
5139 {
5140 /* [basic.stc.dynamic.allocation]
5142 An allocation function can be a function
5143 template. ... Template allocation functions shall
5144 have two or more parameters. */
5147 }
5148 }
5154 /* alias-declaration */
5158 else
5159 {
5162 }
5163 }
5165 /* Check to see that the rules regarding the use of default
5166 arguments are not being violated. */
5170 /* Ensure that there are no parameter packs in the type of this
5171 declaration that have not been expanded. */
5173 {
5174 /* Check each of the arguments individually to see if there are
5175 any bare parameter packs. */
5181 {
5184 {
5185 /* This is a PARM_DECL that contains unexpanded parameter
5186 packs. We have already complained about this in the
5187 check_for_bare_parameter_packs call, so just replace
5188 these types with ERROR_MARK_NODE. */
5191 }
5195 }
5197 /* Check for bare parameter packs in the return type and the
5198 exception specifiers. */
5200 /* Errors were already issued, set return type to int
5201 as the frontend doesn't expect error_mark_node as
5202 the return type. */
5206 }
5211 {
5214 }
5227 {
5232 /* If DECL is a TYPE_DECL for a class-template, then there won't
5233 be DECL_LANG_SPECIFIC. The information equivalent to
5234 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5238 {
5239 /* Since a template declaration already existed for this
5240 class-type, we must be redeclaring it here. Make sure
5241 that the redeclaration is valid. */
5245 current_template_parms,
5246 constr);
5247 /* We don't need to create a new TEMPLATE_DECL; just use the
5248 one we already had. */
5250 }
5251 else
5252 {
5254 current_template_parms,
5255 member_template_p);
5260 {
5261 /* A specialization of a member template of a template
5262 class. */
5266 }
5267 }
5268 }
5269 else
5270 {
5276 {
5279 }
5287 {
5288 tree new_tmpl;
5290 /* The declaration is a specialization of a member
5291 template, declared outside the class. Therefore, the
5292 innermost template arguments will be NULL, so we
5293 replace them with the arguments determined by the
5294 earlier call to check_explicit_specialization. */
5298 current_template_parms,
5299 member_template_p);
5308 args,
5311 }
5313 /* Make sure the template headers we got make sense. */
5318 {
5323 }
5324 else
5326 {
5331 {
5335 else
5339 /* Avoid crash in import_export_decl. */
5342 }
5347 /* Can happen in erroneous input. */
5349 else
5351 }
5353 /* Check that the parms are used in the appropriate qualifying scopes
5354 in the declarator. */
5358 {
5364 /* Avoid crash in import_export_decl. */
5367 }
5368 }
5373 /* Push template declarations for global functions and types. Note
5374 that we do not try to push a global template friend declared in a
5375 template class; such a thing may well depend on the template
5376 parameters of the class. */
5379 {
5384 /* Hide template friend classes that haven't been declared yet. */
5386 {
5389 }
5390 }
5393 {
5399 {
5402 /* It is a conversion operator. See if the type converted to
5403 depends on innermost template operands. */
5406 depth))
5408 }
5410 /* Give template template parms a DECL_CONTEXT of the template
5411 for which they are a parameter. */
5414 {
5418 }
5419 }
5421 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5422 back to its most general template. If TMPL is a specialization,
5423 ARGS may only have the innermost set of arguments. Add the missing
5424 argument levels if necessary. */
5432 else
5433 {
5438 }
5441 && !is_friend
5444 /* Set DECL_COMDAT on template instantiations; if we force
5445 them to be emitted by explicit instantiation or -frepo,
5446 mark_needed will tell cgraph to do the right thing. */
5450 }
5452 tree
5454 {
5456 }
5458 /* FN is an inheriting constructor that inherits from the constructor
5459 template INHERITED; turn FN into a constructor template with a matching
5460 template header. */
5462 tree
5464 {
5465 tree inner_parms
5468 tree parms
5481 }
5483 /* Called when a class template TYPE is redeclared with the indicated
5484 template PARMS, e.g.:
5486 template <class T> struct S;
5487 template <class T> struct S {}; */
5489 bool
5491 {
5492 tree tmpl;
5493 tree tmpl_parms;
5497 {
5500 }
5504 /* The type is nested in some template class. Nothing to worry
5505 about here; there are no new template parameters for the nested
5506 type. */
5510 {
5512 tmpl);
5514 }
5520 {
5530 }
5533 {
5534 tree tmpl_parm;
5535 tree parm;
5536 tree tmpl_default;
5537 tree parm_default;
5551 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5552 TEMPLATE_DECL. */
5562 {
5566 }
5569 {
5570 /* We have in [temp.param]:
5572 A template-parameter may not be given default arguments
5573 by two different declarations in the same scope. */
5578 }
5581 /* Update the previous template parameters (which are the ones
5582 that will really count) with the new default value. */
5585 /* Update the new parameters, too; they'll be used as the
5586 parameters for any members. */
5588 }
5590 // Cannot redeclare a class template with a different set of constraints.
5592 {
5597 }
5600 }
5602 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5603 to be used when the caller has already checked
5604 (processing_template_decl
5605 && !instantiation_dependent_expression_p (expr)
5606 && potential_constant_expression (expr))
5607 and cleared processing_template_decl. */
5609 tree
5611 {
5614 complain,
5618 }
5620 /* Simplify EXPR if it is a non-dependent expression. Returns the
5621 (possibly simplified) expression. */
5623 tree
5625 {
5629 /* If we're in a template, but EXPR isn't value dependent, simplify
5630 it. We're supposed to treat:
5632 template <typename T> void f(T[1 + 1]);
5633 template <typename T> void f(T[2]);
5635 as two declarations of the same function, for example. */
5639 {
5640 processing_template_decl_sentinel s;
5642 }
5644 }
5646 tree
5648 {
5650 }
5652 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5653 template declaration, or a TYPE_DECL for an alias declaration. */
5655 bool
5657 {
5665 }
5667 /* Return TRUE iff T is a specialization of an alias template. */
5669 bool
5671 {
5672 /* It's an alias template specialization if it's an alias and its
5673 TYPE_NAME is a specialization of a primary template. */
5675 {
5679 {
5682 }
5683 }
5685 }
5687 /* Return TRUE iff T is a specialization of an alias template with
5688 dependent template-arguments. */
5690 bool
5692 {
5694 && (any_dependent_template_arguments_p
5696 }
5698 /* Return the number of innermost template parameters in TMPL. */
5700 static int
5702 {
5705 }
5707 /* Return either TMPL or another template that it is equivalent to under DR
5708 1286: An alias that just changes the name of a template is equivalent to
5709 the other template. */
5711 static tree
5713 {
5716 {
5719 {
5724 {
5725 tree alias_args = INNERMOST_TEMPLATE_ARGS
5729 /* The alias type is equivalent to the pattern of the
5730 underlying template, so strip the alias. */
5733 }
5734 }
5736 }
5738 }
5740 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5741 must be a function or a pointer-to-function type, as specified
5742 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5743 and check that the resulting function has external linkage. */
5745 static tree
5747 tsubst_flags_t complain)
5748 {
5751 linkage_kind linkage;
5763 /* [temp.arg.nontype]/1
5765 A template-argument for a non-type, non-template template-parameter
5766 shall be one of:
5767 [...]
5768 -- the address of an object or function with external [C++11: or
5769 internal] linkage. */
5772 {
5774 {
5780 else
5783 }
5785 }
5789 {
5791 {
5796 else
5800 }
5802 }
5805 }
5807 /* Subroutine of convert_nontype_argument.
5808 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5809 Emit an error otherwise. */
5811 static bool
5813 tsubst_flags_t complain)
5814 {
5825 {
5829 }
5831 }
5833 /* Returns TRUE iff the address of OP is value-dependent.
5835 14.6.2.4 [temp.dep.temp]:
5836 A non-integral non-type template-argument is dependent if its type is
5837 dependent or it has either of the following forms
5838 qualified-id
5839 & qualified-id
5840 and contains a nested-name-specifier which specifies a class-name that
5841 names a dependent type.
5843 We generalize this to just say that the address of a member of a
5844 dependent class is value-dependent; the above doesn't cover the
5845 address of a static data member named with an unqualified-id. */
5847 static bool
5849 {
5850 /* We could use get_inner_reference here, but there's no need;
5851 this is only relevant for template non-type arguments, which
5852 can only be expressed as &id-expression. */
5854 {
5858 }
5861 }
5863 /* The next set of functions are used for providing helpful explanatory
5864 diagnostics for failed overload resolution. Their messages should be
5865 indented by two spaces for consistency with the messages in
5866 call.c */
5868 static int
5870 {
5872 }
5874 static int
5876 {
5881 }
5883 static int
5885 {
5887 }
5889 static int
5891 {
5897 }
5899 static int
5901 {
5905 }
5907 static int
5909 {
5912 " template parameter %qD is not a parameter pack, but "
5916 }
5918 static int
5920 {
5923 " template argument %qE does not match "
5927 }
5929 static int
5931 {
5935 }
5937 static int
5939 {
5945 }
5947 static int
5949 {
5951 {
5956 else
5958 " deduced conflicting values for non-type parameter "
5960 }
5962 }
5964 static int
5966 {
5969 " variable-sized array type %qT is not "
5971 arg);
5973 }
5975 static int
5977 {
5981 arg);
5983 }
5985 static int
5987 {
5989 {
5995 else
6000 }
6002 }
6004 static int
6006 {
6008 }
6010 static int
6013 {
6015 }
6017 static int
6020 {
6026 }
6028 static int
6031 {
6034 {
6042 }
6044 }
6046 static int
6048 {
6051 " template parameters of a template template argument are "
6054 }
6056 static int
6058 {
6064 }
6066 static int
6068 {
6073 }
6075 static int
6077 {
6081 arg);
6083 }
6085 /* Attempt to convert the non-type template parameter EXPR to the
6086 indicated TYPE. If the conversion is successful, return the
6087 converted value. If the conversion is unsuccessful, return
6088 NULL_TREE if we issued an error message, or error_mark_node if we
6089 did not. We issue error messages for out-and-out bad template
6090 parameters, but not simply because the conversion failed, since we
6091 might be just trying to do argument deduction. Both TYPE and EXPR
6092 must be non-dependent.
6094 The conversion follows the special rules described in
6095 [temp.arg.nontype], and it is much more strict than an implicit
6096 conversion.
6098 This function is called twice for each template argument (see
6099 lookup_template_class for a more accurate description of this
6100 problem). This means that we need to handle expressions which
6101 are not valid in a C++ source, but can be created from the
6102 first call (for instance, casts to perform conversions). These
6103 hacks can go away after we fix the double coercion problem. */
6105 static tree
6107 {
6108 tree expr_type;
6110 /* Detect immediately string literals as invalid non-type argument.
6111 This special-case is not needed for correctness (we would easily
6112 catch this later), but only to provide better diagnostic for this
6113 common user mistake. As suggested by DR 100, we do not mention
6114 linkage issues in the diagnostic as this is not the point. */
6115 /* FIXME we're making this OK. */
6117 {
6123 }
6125 /* Add the ADDR_EXPR now for the benefit of
6126 value_dependent_expression_p. */
6129 {
6133 }
6135 /* If we are in a template, EXPR may be non-dependent, but still
6136 have a syntactic, rather than semantic, form. For example, EXPR
6137 might be a SCOPE_REF, rather than the VAR_DECL to which the
6138 SCOPE_REF refers. Preserving the qualifying scope is necessary
6139 so that access checking can be performed when the template is
6140 instantiated -- but here we need the resolved form so that we can
6141 convert the argument. */
6147 && processing_template_decl
6156 else
6159 /* If the argument is non-dependent, perform any conversions in
6160 non-dependent context as well. */
6165 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6166 to a non-type argument of "nullptr". */
6170 /* In C++11, integral or enumeration non-type template arguments can be
6171 arbitrary constant expressions. Pointer and pointer to
6172 member arguments can be general constant expressions that evaluate
6173 to a null value, but otherwise still need to be of a specific form. */
6175 {
6177 /* A PTRMEM_CST is already constant, and a valid template
6178 argument for a parameter of pointer to member type, we just want
6179 to leave it in that form rather than lower it to a
6184 {
6189 }
6190 }
6192 /* HACK: Due to double coercion, we can get a
6193 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6194 which is the tree that we built on the first call (see
6195 below when coercing to reference to object or to reference to
6196 function). We just strip everything and get to the arg.
6197 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6198 for examples. */
6200 {
6206 {
6207 /* ??? Maybe we could use convert_from_reference here, but we
6208 would need to relax its constraints because the NOP_EXPR
6209 could actually change the type to something more cv-qualified,
6210 and this is not folded by convert_from_reference. */
6215 && (same_type_ignoring_top_level_qualifiers_p
6218 {
6221 }
6222 }
6223 }
6225 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
6226 parameter is a pointer to object, through decay and
6227 qualification conversion. Let's strip everything. */
6229 {
6234 {
6235 /* Skip the ADDR_EXPR only if it is part of the decay for
6236 an array. Otherwise, it is part of the original argument
6237 in the source code. */
6242 }
6243 }
6245 /* [temp.arg.nontype]/5, bullet 1
6247 For a non-type template-parameter of integral or enumeration type,
6248 integral promotions (_conv.prom_) and integral conversions
6249 (_conv.integral_) are applied. */
6251 {
6260 /* Notice that there are constant expressions like '4 % 0' which
6261 do not fold into integer constants. */
6263 {
6265 {
6276 /* else cxx_constant_value complained but gave us
6277 a real constant, so go ahead. */
6279 }
6280 else
6282 }
6284 /* Avoid typedef problems. */
6287 }
6288 /* [temp.arg.nontype]/5, bullet 2
6290 For a non-type template-parameter of type pointer to object,
6291 qualification conversions (_conv.qual_) and the array-to-pointer
6292 conversion (_conv.array_) are applied. */
6294 {
6295 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6297 A template-argument for a non-type, non-template template-parameter
6298 shall be one of: [...]
6300 -- the name of a non-type template-parameter;
6301 -- the address of an object or function with external linkage, [...]
6302 expressed as "& id-expression" where the & is optional if the name
6303 refers to a function or array, or if the corresponding
6304 template-parameter is a reference.
6306 Here, we do not care about functions, as they are invalid anyway
6307 for a parameter of type pointer-to-object. */
6310 /* Non-type template parameters are OK. */
6311 ;
6316 {
6318 {
6321 "because %qD is a variable, not the address of "
6324 }
6326 {
6332 }
6333 /* Other values, like integer constants, might be valid
6334 non-type arguments of some other type. */
6336 }
6337 else
6338 {
6339 tree decl;
6344 {
6349 }
6351 {
6357 }
6359 {
6364 }
6365 }
6374 }
6375 /* [temp.arg.nontype]/5, bullet 3
6377 For a non-type template-parameter of type reference to object, no
6378 conversions apply. The type referred to by the reference may be more
6379 cv-qualified than the (otherwise identical) type of the
6380 template-argument. The template-parameter is bound directly to the
6381 template-argument, which must be an lvalue. */
6383 {
6385 expr_type))
6389 {
6394 }
6397 {
6402 }
6404 /* [temp.arg.nontype]/1
6406 A template-argument for a non-type, non-template template-parameter
6407 shall be one of: [...]
6409 -- the address of an object or function with external linkage. */
6412 {
6415 {
6418 "because a reference variable does not have a constant "
6421 }
6422 }
6425 {
6431 }
6434 {
6440 }
6443 }
6444 /* [temp.arg.nontype]/5, bullet 4
6446 For a non-type template-parameter of type pointer to function, only
6447 the function-to-pointer conversion (_conv.func_) is applied. If the
6448 template-argument represents a set of overloaded functions (or a
6449 pointer to such), the matching function is selected from the set
6450 (_over.over_). */
6452 {
6453 /* If the argument is a template-id, we might not have enough
6454 context information to decay the pointer. */
6456 {
6460 }
6463 /* Null pointer values are OK in C++11. */
6469 }
6470 /* [temp.arg.nontype]/5, bullet 5
6472 For a non-type template-parameter of type reference to function, no
6473 conversions apply. If the template-argument represents a set of
6474 overloaded functions, the matching function is selected from the set
6475 (_over.over_). */
6477 {
6479 {
6481 {
6486 }
6488 }
6495 }
6496 /* [temp.arg.nontype]/5, bullet 6
6498 For a non-type template-parameter of type pointer to member function,
6499 no conversions apply. If the template-argument represents a set of
6500 overloaded member functions, the matching member function is selected
6501 from the set (_over.over_). */
6503 {
6508 /* [temp.arg.nontype] bullet 1 says the pointer to member
6509 expression must be a pointer-to-member constant. */
6513 /* There is no way to disable standard conversions in
6514 resolve_address_of_overloaded_function (called by
6515 instantiate_type). It is possible that the call succeeded by
6516 converting &B::I to &D::I (where B is a base of D), so we need
6517 to reject this conversion here.
6519 Actually, even if there was a way to disable standard conversions,
6520 it would still be better to reject them here so that we can
6521 provide a superior diagnostic. */
6523 {
6525 {
6529 /* If we are just one standard conversion off, explain. */
6533 }
6535 }
6536 }
6537 /* [temp.arg.nontype]/5, bullet 7
6539 For a non-type template-parameter of type pointer to data member,
6540 qualification conversions (_conv.qual_) are applied. */
6542 {
6543 /* [temp.arg.nontype] bullet 1 says the pointer to member
6544 expression must be a pointer-to-member constant. */
6551 }
6553 {
6555 {
6560 }
6562 }
6563 /* A template non-type parameter must be one of the above. */
6564 else
6567 /* Sanity check: did we actually convert the argument to the
6568 right type? */
6572 }
6574 /* Subroutine of coerce_template_template_parms, which returns 1 if
6575 PARM_PARM and ARG_PARM match using the rule for the template
6576 parameters of template template parameters. Both PARM and ARG are
6577 template parameters; the rest of the arguments are the same as for
6578 coerce_template_template_parms.
6579 */
6580 static int
6582 tree arg,
6583 tsubst_flags_t complain,
6584 tree in_decl,
6585 tree outer_args)
6586 {
6595 {
6597 /* We encounter instantiations of templates like
6598 template <template <template <class> class> class TT>
6599 class C; */
6600 {
6607 }
6608 /* Fall through. */
6613 /* Argument is a parameter pack but parameter is not. */
6618 /* The tsubst call is used to handle cases such as
6620 template <int> class C {};
6621 template <class T, template <T> class TT> class D {};
6622 D<int, C> d;
6624 i.e. the parameter list of TT depends on earlier parameters. */
6626 && !same_type_p
6633 /* Argument is a parameter pack but parameter is not. */
6640 }
6643 }
6646 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6647 template template parameters. Both PARM_PARMS and ARG_PARMS are
6648 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6649 or PARM_DECL.
6651 Consider the example:
6652 template <class T> class A;
6653 template<template <class U> class TT> class B;
6655 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6656 the parameters to A, and OUTER_ARGS contains A. */
6658 static int
6660 tree arg_parms,
6661 tsubst_flags_t complain,
6662 tree in_decl,
6663 tree outer_args)
6664 {
6675 /* Determine whether we have a parameter pack at the end of the
6676 template template parameter's template parameter list. */
6678 {
6685 {
6699 }
6700 }
6706 /* Check all of the template parameters except the parameter pack at
6707 the end (if any). */
6709 {
6718 outer_args))
6721 }
6724 {
6725 /* Check each of the template parameters in the template
6726 argument against the template parameter pack at the end of
6727 the template template parameter. */
6734 {
6741 outer_args))
6743 }
6744 }
6747 }
6749 /* Verifies that the deduced template arguments (in TARGS) for the
6750 template template parameters (in TPARMS) represent valid bindings,
6751 by comparing the template parameter list of each template argument
6752 to the template parameter list of its corresponding template
6753 template parameter, in accordance with DR150. This
6754 routine can only be called after all template arguments have been
6755 deduced. It will return TRUE if all of the template template
6756 parameter bindings are okay, FALSE otherwise. */
6757 bool
6759 {
6763 /* We're dealing with template parms in this process. */
6769 {
6774 {
6779 {
6780 /* Look inside the argument pack. */
6783 }
6786 {
6790 /* Extract the next argument from the argument
6791 pack. */
6795 /* Look at the pattern of the pack expansion. */
6798 /* Extract the template parameters from the template
6799 argument. */
6805 /* Verify that we can coerce the template template
6806 parameters from the template argument to the template
6807 parameter. This requires an exact match. */
6809 && !coerce_template_template_parms
6811 targ_parms,
6812 tf_none,
6813 tparm,
6814 targs))
6815 {
6818 }
6819 }
6820 }
6821 }
6823 out:
6827 }
6829 /* Since type attributes aren't mangled, we need to strip them from
6830 template type arguments. */
6832 static tree
6834 {
6835 tree mv;
6842 {
6847 }
6849 }
6851 // A template declaration can be substituted for a constrained
6852 // template template parameter only when the argument is more
6853 // constrained than the parameter.
6854 static bool
6856 {
6857 // TODO: The argument may not have a decl result. This seems to
6858 // happen in some classes with nested template template
6859 // parameters (e.g., a rebind struct in a class taking a template
6860 // template parameter. If this is the case, just return true and
6861 // allow things to happen as they always did.
6863 {
6866 }
6871 // If the template parameter is constrained, we need to rewrite its
6872 // constraints in terms of the ARG's template parameters. This ensures
6873 // that all of the template parameter types will have the same depth.
6874 //
6875 // Note that this is only valid when coerce_template_template_parm is
6876 // true for the innermost template parameters of PARM and ARG. In other
6877 // words, because coercion is successful, this conversion will be valid.
6879 {
6884 }
6887 }
6889 // Convert a placeholder argument into a binding to the original
6890 // parameter. The original parameter is saved as the TREE_TYPE of
6891 // ARG.
6894 {
6897 }
6899 /* Convert the indicated template ARG as necessary to match the
6900 indicated template PARM. Returns the converted ARG, or
6901 error_mark_node if the conversion was unsuccessful. Error and
6902 warning messages are issued under control of COMPLAIN. This
6903 conversion is for the Ith parameter in the parameter list. ARGS is
6904 the full set of template arguments deduced so far. */
6906 static tree
6908 tree arg,
6909 tree args,
6910 tsubst_flags_t complain,
6912 tree in_decl)
6913 {
6914 tree orig_arg;
6915 tree val;
6921 /* Trivially convert placeholders. */
6927 {
6928 /* The template argument was the name of some
6929 member function. That's usually
6930 invalid, but static members are OK. In any
6931 case, grab the underlying fields/functions
6932 and issue an error later if required. */
6935 }
6943 /* When determining whether an argument pack expansion is a template,
6944 look at the pattern. */
6948 /* Deal with an injected-class-name used as a template template arg. */
6950 {
6953 {
6963 }
6964 }
6966 is_tmpl_type =
6982 {
6984 {
6988 }
6991 "to refer to a type member of a template parameter, "
6996 typename_type,
6997 complain);
7000 }
7002 {
7004 {
7006 {
7018 else
7021 }
7022 }
7024 }
7026 {
7028 {
7035 else
7038 }
7040 }
7043 {
7045 {
7049 /* The number of argument required is not known yet.
7050 Just accept it for now. */
7052 else
7053 {
7057 /* Strip alias templates that are equivalent to another
7058 template. */
7064 args))
7065 {
7068 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7069 TEMPLATE_DECL. */
7071 {
7076 }
7077 }
7078 else
7079 {
7081 {
7088 }
7091 }
7093 // Check that the constraints are compatible before allowing the
7094 // substitution.
7097 {
7099 {
7105 }
7107 }
7108 }
7109 }
7110 else
7112 /* We only form one instance of each template specialization.
7113 Therefore, if we use a non-canonical variant (i.e., a
7114 typedef), any future messages referring to the type will use
7115 the typedef, which is confusing if those future uses do not
7116 themselves also use the typedef. */
7119 }
7120 else
7121 {
7128 {
7131 else
7132 {
7133 /* Not sure if this is reachable, but it doesn't hurt
7134 to be robust. */
7137 }
7138 }
7141 /* We used to call digest_init here. However, digest_init
7142 will report errors, which we don't want when complain
7143 is zero. More importantly, digest_init will try too
7144 hard to convert things: for example, `0' should not be
7145 converted to pointer type at this point according to
7146 the standard. Accepting this is not merely an
7147 extension, since deciding whether or not these
7148 conversions can occur is part of determining which
7149 function template to call, or whether a given explicit
7150 argument specification is valid. */
7152 else
7161 {
7162 /* Strip typedefs from the SCOPE_REF. */
7165 complain);
7168 }
7169 }
7172 }
7174 /* Coerces the remaining template arguments in INNER_ARGS (from
7175 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7176 Returns the coerced argument pack. PARM_IDX is the position of this
7177 parameter in the template parameter list. ARGS is the original
7178 template argument list. */
7179 static tree
7182 tree args,
7183 tree inner_args,
7185 tree new_args,
7187 tree in_decl,
7188 tsubst_flags_t complain)
7189 {
7192 tree packed_args;
7193 tree argument_pack;
7200 {
7201 /* When the template parameter is a non-type template parameter pack
7202 or template template parameter pack whose type or template
7203 parameters use parameter packs, we know exactly how many arguments
7204 we are looking for. Build a vector of the instantiated decls for
7205 these template parameters in PACKED_PARMS. */
7206 /* We can't use make_pack_expansion here because it would interpret a
7207 _DECL as a use rather than a declaration. */
7221 /* If we're doing a partial instantiation of a member template,
7222 verify that all of the types used for the non-type
7223 template parameter pack are, in fact, valid for non-type
7224 template parameters. */
7227 {
7230 {
7234 }
7235 /* We don't know how many args we have yet, just
7236 use the unconverted ones for now. */
7238 }
7241 }
7242 /* Check if we have a placeholder pack, which indicates we're in the context
7243 of a introduction list. In that case we want to simply match this pack to
7244 the single placeholder. */
7247 {
7250 }
7251 else
7254 /* Convert the remaining arguments, which will be a part of the
7255 parameter pack "parm". */
7257 {
7263 {
7264 /* Once we've packed as many args as we have types, stop. */
7268 /* We don't know how many args we have yet, just
7269 use the unconverted ones for now. */
7271 else
7273 }
7276 {
7279 }
7280 else
7283 in_decl);
7287 }
7291 {
7296 }
7301 else
7302 {
7307 }
7310 #ifdef ENABLE_CHECKING
7313 #endif
7315 }
7317 /* Returns the number of pack expansions in the template argument vector
7318 ARGS. */
7320 static int
7322 {
7327 {
7331 }
7333 }
7335 /* Convert all template arguments to their appropriate types, and
7336 return a vector containing the innermost resulting template
7337 arguments. If any error occurs, return error_mark_node. Error and
7338 warning messages are issued under control of COMPLAIN.
7340 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7341 for arguments not specified in ARGS. Otherwise, if
7342 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7343 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7344 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7345 ARGS. */
7347 static tree
7349 tree args,
7350 tree in_decl,
7351 tsubst_flags_t complain,
7354 {
7356 tree orig_inner_args;
7357 tree inner_args;
7358 tree new_args;
7359 tree new_inner_args;
7363 /* When used as a boolean value, indicates whether this is a
7364 variadic template parameter list. Since it's an int, we can also
7365 subtract it from nparms to get the number of non-variadic
7366 parameters. */
7371 /* Likewise for parameters with default arguments. */
7379 /* Determine if there are any parameter packs or default arguments. */
7381 {
7389 }
7392 /* If there are no parameters that follow a parameter pack, we need to
7393 expand any argument packs so that we can deduce a parameter pack from
7394 some non-packed args followed by an argument pack, as in variadic85.C.
7395 If there are such parameters, we need to leave argument packs intact
7396 so the arguments are assigned properly. This can happen when dealing
7397 with a nested class inside a partial specialization of a class
7398 template, as in variadic92.C, or when deducing a template parameter pack
7399 from a sub-declarator, as in variadic114.C. */
7403 /* Count any pack expansion args. */
7409 && require_all_args
7410 && !variadic_args_p
7411 && (!use_default_args
7414 {
7416 {
7418 {
7422 }
7423 else
7429 }
7432 }
7433 /* We can't pass a pack expansion to a non-pack parameter of an alias
7434 template (DR 1430). */
7436 && variadic_args_p
7438 {
7440 {
7442 {
7448 {
7453 }
7454 }
7456 found:;
7457 }
7459 }
7461 /* We need to evaluate the template arguments, even though this
7462 template-id may be nested within a "sizeof". */
7471 {
7472 tree arg;
7473 tree parm;
7475 /* Get the Ith template parameter. */
7479 {
7482 }
7484 /* Calculate the next argument. */
7487 else
7492 {
7493 /* Some arguments will be placed in the
7494 template parameter pack PARM. */
7501 {
7502 /* We don't know how many args we have yet, just use the
7503 unconverted (and still packed) ones for now. */
7507 }
7511 /* Store this argument. */
7513 {
7514 lost++;
7515 /* We are done with all of the arguments. */
7517 }
7518 else
7519 {
7522 }
7525 }
7527 {
7529 {
7530 /* "If every valid specialization of a variadic template
7531 requires an empty template parameter pack, the template is
7532 ill-formed, no diagnostic required." So check that the
7533 pattern works with this parameter. */
7538 in_decl);
7540 {
7544 }
7546 /* Recover from missing typename. */
7550 /* We don't know how many args we have yet, just
7551 use the unconverted ones for now. */
7555 }
7556 }
7558 {
7559 /* There must be a default arg in this case. */
7562 /* The position of the first default template argument,
7563 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7564 Record that. */
7568 }
7569 else
7573 {
7576 }
7578 /* This only occurs if there was an error in the template
7579 parameter list itself (which we would already have
7580 reported) that we are trying to recover from, e.g., a class
7581 template with a parameter list such as
7582 template<typename..., typename>. */
7584 else
7590 lost++;
7592 }
7597 {
7599 {
7604 }
7606 }
7611 #ifdef ENABLE_CHECKING
7615 #endif
7618 }
7620 /* Convert all template arguments to their appropriate types, and
7621 return a vector containing the innermost resulting template
7622 arguments. If any error occurs, return error_mark_node. Error and
7623 warning messages are not issued.
7625 Note that no function argument deduction is performed, and default
7626 arguments are used to fill in unspecified arguments. */
7627 tree
7629 {
7631 }
7633 /* Convert all template arguments to their appropriate type, and
7634 instantiate default arguments as needed. This returns a vector
7635 containing the innermost resulting template arguments, or
7636 error_mark_node if unsuccessful. */
7637 tree
7639 tsubst_flags_t complain)
7640 {
7642 }
7644 /* Like coerce_template_parms. If PARMS represents all template
7645 parameters levels, this function returns a vector of vectors
7646 representing all the resulting argument levels. Note that in this
7647 case, only the innermost arguments are coerced because the
7648 outermost ones are supposed to have been coerced already.
7650 Otherwise, if PARMS represents only (the innermost) vector of
7651 parameters, this function returns a vector containing just the
7652 innermost resulting arguments. */
7654 static tree
7656 tree args,
7657 tree in_decl,
7658 tsubst_flags_t complain,
7661 {
7664 tree coerced_args;
7667 {
7669 tree level;
7675 {
7676 tree l;
7680 require_all_args,
7681 use_default_args);
7682 else
7689 }
7690 }
7691 else
7694 require_all_args,
7695 use_default_args);
7697 }
7699 /* Returns 1 if template args OT and NT are equivalent. */
7701 static int
7703 {
7710 /* For member templates */
7719 {
7736 }
7738 {
7739 /* We get here probably because we are in the middle of substituting
7740 into the pattern of a pack expansion. In that case the
7741 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7742 interested in. So we want to use the initial pack argument for
7743 the comparison. */
7748 }
7750 {
7753 /* Don't treat an alias template specialization with dependent
7754 arguments as equivalent to its underlying type when used as a
7755 template argument; we need them to be distinct so that we
7756 substitute into the specialization arguments at instantiation
7757 time. And aliases can't be equivalent without being ==, so
7758 we don't need to look any deeper. */
7761 else
7763 }
7766 else
7767 {
7768 /* Try to treat a template non-type argument that has been converted
7769 to the parameter type as equivalent to one that hasn't yet. */
7782 }
7783 }
7785 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7786 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7787 NEWARG_PTR with the offending arguments if they are non-NULL. */
7789 static int
7792 {
7805 {
7810 {
7816 }
7817 }
7819 }
7821 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7822 of template arguments. Returns 0 otherwise. */
7824 int
7826 {
7828 }
7830 static void
7832 {
7842 /* We are called both from instantiate_decl, where we've already had a
7843 tinst_level pushed, and instantiate_template, where we haven't.
7844 Compensate. */
7855 else
7864 }
7867 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7868 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7869 documentation for TEMPLATE_ID_EXPR. */
7871 tree
7873 {
7874 tree type;
7882 {
7885 }
7888 {
7890 unknown_type_node,
7892 arglist);
7894 }
7901 }
7903 /* Within the scope of a template class S<T>, the name S gets bound
7904 (in build_self_reference) to a TYPE_DECL for the class, not a
7905 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7906 or one of its enclosing classes, and that type is a template,
7907 return the associated TEMPLATE_DECL. Otherwise, the original
7908 DECL is returned.
7910 Also handle the case when DECL is a TREE_LIST of ambiguous
7911 injected-class-names from different bases. */
7913 tree
7915 {
7919 /* DR 176: A lookup that finds an injected-class-name (10.2
7920 [class.member.lookup]) can result in an ambiguity in certain cases
7921 (for example, if it is found in more than one base class). If all of
7922 the injected-class-names that are found refer to specializations of
7923 the same class template, and if the name is followed by a
7924 template-argument-list, the reference refers to the class template
7925 itself and not a specialization thereof, and is not ambiguous. */
7927 {
7930 {
7936 }
7939 else
7941 }
7947 }
7949 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7950 parameters, find the desired type.
7952 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7954 IN_DECL, if non-NULL, is the template declaration we are trying to
7955 instantiate.
7957 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7958 the class we are looking up.
7960 Issue error and warning messages under control of COMPLAIN.
7962 If the template class is really a local class in a template
7963 function, then the FUNCTION_CONTEXT is the function in which it is
7964 being instantiated.
7966 ??? Note that this function is currently called *twice* for each
7967 template-id: the first time from the parser, while creating the
7968 incomplete type (finish_template_type), and the second type during the
7969 real instantiation (instantiate_template_class). This is surely something
7970 that we want to avoid. It also causes some problems with argument
7971 coercion (see convert_nontype_argument for more information on this). */
7973 static tree
7976 {
7978 tree t;
7981 spec_entry elt;
7982 hashval_t hash;
7985 {
7989 else
7990 {
7997 }
8000 }
8002 {
8005 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8006 an implicit typename for the second A. Deal with it. */
8011 {
8014 }
8015 }
8018 {
8021 }
8023 {
8027 }
8029 {
8032 }
8034 /* Issue an error message if we didn't find a template. */
8036 {
8040 }
8043 /* Make sure it's a user visible template, if it was named by
8044 the user. */
8047 {
8049 {
8053 }
8055 }
8059 /* An alias that just changes the name of a template is equivalent to the
8060 other template, so if any of the arguments are pack expansions, strip
8061 the alias to avoid problems with a pack expansion passed to a non-pack
8062 alias template parameter (DR 1430). */
8067 {
8068 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
8069 template arguments */
8071 tree parm;
8072 tree arglist2;
8073 tree outer;
8077 /* Consider an example where a template template parameter declared as
8079 template <class T, class U = std::allocator<T> > class TT
8081 The template parameter level of T and U are one level larger than
8082 of TT. To proper process the default argument of U, say when an
8083 instantiation `TT<int>' is seen, we need to build the full
8084 arguments containing {int} as the innermost level. Outer levels,
8085 available when not appearing as default template argument, can be
8086 obtained from the arguments of the enclosing template.
8088 Suppose that TT is later substituted with std::vector. The above
8089 instantiation is `TT<int, std::allocator<T> >' with TT at
8090 level 1, and T at level 2, while the template arguments at level 1
8091 becomes {std::vector} and the inner level 2 is {int}. */
8097 /* This is an argument of the current template, so we haven't set
8098 DECL_CONTEXT yet. */
8105 complain,
8115 }
8116 else
8117 {
8119 tree gen_tmpl;
8120 tree type_decl;
8128 /* An error occurred while building the template TEMPL, and a
8129 diagnostic has most certainly been emitted for that
8130 already. Let's propagate that error. */
8139 {
8140 /* We've been given an incomplete set of template arguments.
8141 For example, given:
8143 template <class T> struct S1 {
8144 template <class U> struct S2 {};
8145 template <class U> struct S2<U*> {};
8146 };
8148 we will be called with an ARGLIST of `U*', but the
8149 TEMPLATE will be `template <class T> template
8150 <class U> struct S1<T>::S2'. We must fill in the missing
8151 arguments. */
8152 arglist
8154 arglist);
8156 }
8158 /* Now we should have enough arguments. */
8161 /* From here on, we're only interested in the most general
8162 template. */
8164 /* Calculate the BOUND_ARGS. These will be the args that are
8165 actually tsubst'd into the definition to create the
8166 instantiation. */
8168 {
8169 /* We have multiple levels of arguments to coerce, at once. */
8179 {
8180 tree a;
8184 complain,
8187 else
8188 /* Outer levels should have already been coerced. */
8191 /* Don't process further if one of the levels fails. */
8193 {
8194 /* Restore the ARGLIST to its full size. */
8197 }
8201 /* We temporarily reduce the length of the ARGLIST so
8202 that coerce_template_parms will see only the arguments
8203 corresponding to the template parameters it is
8204 examining. */
8206 }
8208 /* Restore the ARGLIST to its full size. */
8212 }
8213 else
8214 arglist
8217 gen_tmpl,
8218 complain,
8223 /* We were unable to bind the arguments. */
8226 /* In the scope of a template class, explicit references to the
8227 template class refer to the type of the template, not any
8228 instantiation of it. For example, in:
8230 template <class T> class C { void f(C<T>); }
8232 the `C<T>' is just the same as `C'. Outside of the
8233 class, however, such a reference is an instantiation. */
8237 /* comp_template_args is expensive, check it last. */
8239 arglist))
8242 /* If we already have this specialization, return it. */
8251 /* If the the template's constraints are not satisfied,
8252 then we cannot form a valid type.
8254 Note that the check is deferred until after the hash
8255 lookup. This prevents redundant checks on previously
8256 instantiated specializations. */
8258 {
8260 {
8263 }
8265 }
8269 /* If the deduced arguments are invalid, then the binding
8270 failed. */
8274 complain))
8281 {
8286 }
8296 /* Create the type. */
8298 {
8299 /* The user referred to a specialization of an alias
8300 template represented by GEN_TMPL.
8302 [temp.alias]/2 says:
8304 When a template-id refers to the specialization of an
8305 alias template, it is equivalent to the associated
8306 type obtained by substitution of its
8307 template-arguments for the template-parameters in the
8308 type-id of the alias template. */
8311 /* Note that the call above (by indirectly calling
8312 register_specialization in tsubst_decl) registers the
8313 TYPE_DECL representing the specialization of the alias
8314 template. So next time someone substitutes ARGLIST for
8315 the template parms into the alias template (GEN_TMPL),
8316 she'll get that TYPE_DECL back. */
8320 }
8322 {
8324 {
8333 }
8334 else
8335 {
8336 /* We don't want to call start_enum for this type, since
8337 the values for the enumeration constants may involve
8338 template parameters. And, no one should be interested
8339 in the enumeration constants for such a type. */
8342 }
8346 }
8348 {
8355 /* A local class. Make sure the decl gets registered properly. */
8360 /* This instantiation is another name for the primary
8361 template type. Set the TYPE_CANONICAL field
8362 appropriately. */
8365 /* Some of the template arguments require structural
8366 equality testing, so this template class requires
8367 structural equality testing. */
8369 }
8370 else
8373 /* If we called start_enum or pushtag above, this information
8374 will already be set up. */
8376 {
8383 }
8384 else
8388 {
8394 {
8397 }
8398 }
8402 {
8405 {
8408 else
8412 }
8413 }
8415 /* Let's consider the explicit specialization of a member
8416 of a class template specialization that is implicitly instantiated,
8417 e.g.:
8418 template<class T>
8419 struct S
8420 {
8421 template<class U> struct M {}; //#0
8422 };
8424 template<>
8425 template<>
8426 struct S<int>::M<char> //#1
8427 {
8428 int i;
8429 };
8430 [temp.expl.spec]/4 says this is valid.
8432 In this case, when we write:
8433 S<int>::M<char> m;
8435 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8436 the one of #0.
8438 When we encounter #1, we want to store the partial instantiation
8439 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8441 For all cases other than this "explicit specialization of member of a
8442 class template", we just want to store the most general template into
8443 the CLASSTYPE_TI_TEMPLATE of M.
8445 This case of "explicit specialization of member of a class template"
8446 only happens when:
8447 1/ the enclosing class is an instantiation of, and therefore not
8448 the same as, the context of the most general template, and
8449 2/ we aren't looking at the partial instantiation itself, i.e.
8450 the innermost arguments are not the same as the innermost parms of
8451 the most general template.
8453 So it's only when 1/ and 2/ happens that we want to use the partial
8454 instantiation of the member template in lieu of its most general
8455 template. */
8459 /* the enclosing class must be an instantiation... */
8462 {
8463 tree partial_inst_args;
8466 partial_inst_args =
8472 use_partial_inst_tmpl =
8473 /*...and we must not be looking at the partial instantiation
8474 itself. */
8476 partial_inst_args);
8477 }
8480 /* This case is easy; there are no member templates involved. */
8482 else
8483 {
8484 /* This is a full instantiation of a member template. Find
8485 the partial instantiation of which this is an instance. */
8487 /* Temporarily reduce by one the number of levels in the ARGLIST
8488 so as to avoid comparing the last set of arguments. */
8492 /* FOUND is either a proper class type, or an alias
8493 template specialization. In the later case, it's a
8494 TYPE_DECL, resulting from the substituting of arguments
8495 for parameters in the TYPE_DECL of the alias template
8496 done earlier. So be careful while getting the template
8497 of FOUND. */
8501 }
8503 // Build template info for the new specialization.
8512 /* Note this use of the partial instantiation so we can check it
8513 later in maybe_process_partial_specialization. */
8520 /* Now that the type has been registered on the instantiations
8521 list, we set up the enumerators. Because the enumeration
8522 constants may involve the enumeration type itself, we make
8523 sure to register the type first, and then create the
8524 constants. That way, doing tsubst_expr for the enumeration
8525 constants won't result in recursive calls here; we'll find
8526 the instantiation and exit above. */
8530 /* If the type makes use of template parameters, the
8531 code that generates debugging information will crash. */
8534 /* Possibly limit visibility based on template args. */
8541 }
8542 }
8544 /* Wrapper for lookup_template_class_1. */
8546 tree
8549 {
8550 tree ret;
8556 }
8558 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8559 The type of the expression is the unknown_type_node since the
8560 template-id could refer to an explicit or partial specialization. */
8562 tree
8564 {
8567 }
8569 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8571 tree
8573 {
8586 /* If a template-id refers to a specialization of a variable
8587 concept, then the expression is true if and only if the
8588 concept's constraints are satisfied by the given template
8589 arguments.
8591 NOTE: This is an extension of Concepts Lite TS that
8592 allows constraints to be used in expressions. */
8595 {
8598 }
8601 }
8602 \f
8603 struct pair_fn_data
8604 {
8605 tree_fn_t fn;
8607 /* True when we should also visit template parameters that occur in
8608 non-deduced contexts. */
8611 };
8613 /* Called from for_each_template_parm via walk_tree. */
8615 static tree
8617 {
8630 {
8634 /* Fall through. */
8657 /* Since we're not going to walk subtrees, we have to do this
8658 explicitly here. */
8662 /* Fall through. */
8665 /* Check the return type. */
8670 /* Check the parameter types. Since default arguments are not
8671 instantiated until they are needed, the TYPE_ARG_TYPES may
8672 contain expressions that involve template parameters. But,
8673 no-one should be looking at them yet. And, once they're
8674 instantiated, they don't contain template parameters, so
8675 there's no point in looking at them then, either. */
8676 {
8677 tree parm;
8684 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8685 want walk_tree walking into them itself. */
8687 }
8705 /* Fall through. */
8721 /* Record template parameters such as `T' inside `TT<T>'. */
8725 /* Fall through. */
8737 /* A template template parameter is encountered. */
8743 /* Already substituted template template parameter */
8766 /* If there's no type, then this thing must be some expression
8767 involving template parameters. */
8789 }
8791 /* We didn't find any template parameters we liked. */
8793 }
8795 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8796 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8797 call FN with the parameter and the DATA.
8798 If FN returns nonzero, the iteration is terminated, and
8799 for_each_template_parm returns 1. Otherwise, the iteration
8800 continues. If FN never returns a nonzero value, the value
8801 returned by for_each_template_parm is 0. If FN is NULL, it is
8802 considered to be the function which always returns 1.
8804 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8805 parameters that occur in non-deduced contexts. When false, only
8806 visits those template parameters that can be deduced. */
8808 static int
8812 {
8816 /* Set up. */
8821 /* Walk the tree. (Conceptually, we would like to walk without
8822 duplicates, but for_each_template_parm_r recursively calls
8823 for_each_template_parm, so we would need to reorganize a fair
8824 bit to use walk_tree_without_duplicates, so we keep our own
8825 visited list.) */
8828 else
8831 for_each_template_parm_r,
8835 /* Clean up. */
8837 {
8840 }
8843 }
8845 /* Returns true if T depends on any template parameter. */
8847 int
8849 {
8879 else
8880 {
8883 }
8888 }
8890 /* Returns true iff current_function_decl is an incompletely instantiated
8891 template. Useful instead of processing_template_decl because the latter
8892 is set to 0 during instantiate_non_dependent_expr. */
8894 bool
8896 {
8905 }
8907 /* Returns true if T depends on any template parameter with level LEVEL. */
8909 int
8911 {
8914 }
8916 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8917 ill-formed translation unit, i.e. a variable or function that isn't
8918 usable in a constant expression. */
8922 {
8926 }
8928 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8929 neglectable and instantiated from within an erroneous instantiation. */
8931 static bool
8933 {
8944 }
8952 /* We're starting to instantiate D; record the template instantiation context
8953 for diagnostics and to restore it later. */
8955 bool
8957 {
8959 }
8961 /* We're starting to instantiate D; record the template instantiation context
8962 at LOC for diagnostics and to restore it later. */
8964 bool
8966 {
8970 {
8972 "template instantiation depth exceeds maximum of %d"
8974 max_tinst_depth);
8976 }
8978 /* If the current instantiation caused problems, don't let it instantiate
8979 anything else. Do allow deduction substitution and decls usable in
8980 constant expressions. */
8997 }
8999 /* We're done instantiating this template; return to the instantiation
9000 context. */
9002 void
9004 {
9005 /* Restore the filename and line number stashed away when we started
9006 this instantiation. */
9010 }
9012 /* We're instantiating a deferred template; restore the template
9013 instantiation context in which the instantiation was requested, which
9014 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9016 static tree
9018 {
9030 }
9032 /* Returns the TINST_LEVEL which gives the original instantiation
9033 context. */
9037 {
9043 }
9045 /* Returns TRUE if the t is a parameter that will be
9046 expanded into a sequence of arguments, when an argument
9047 pack is substituted into it.
9049 These arise from requires-expressions, where substitution
9050 during normalization produces unexpanded parameters.
9051 For example:
9053 template<typename T, typename... Args>
9054 concept bool C() {
9055 return requires (T t, Args... args) {
9056 t(args...);
9057 }
9058 }
9060 tempate<typename X, typename... As>
9061 requires C<X, As...>
9062 struct S { };
9064 When S's constraint is normalized the parameterized expression
9065 is a parameter args whose type is the type pack expansion
9066 As... When we instantiate S and provide a concrete argument
9067 pack, we need to make sure that references to args... are
9068 expanded correctly. */
9072 {
9075 }
9077 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9078 vector of template arguments, as for tsubst.
9080 Returns an appropriate tsubst'd friend declaration. */
9082 static tree
9084 {
9085 tree new_friend;
9090 /* This was a friend declared with an explicit template
9091 argument list, e.g.:
9093 friend void f<>(T);
9095 to indicate that f was a template instantiation, not a new
9096 function declaration. Now, we have to figure out what
9097 instantiation of what template. */
9098 {
9100 tree new_args;
9101 tree tmpl;
9104 /* Friend functions are looked up in the containing namespace scope.
9105 We must enter that scope, to avoid finding member functions of the
9106 current class with same name. */
9121 tsk_none);
9123 }
9127 /* The NEW_FRIEND will look like an instantiation, to the
9128 compiler, but is not an instantiation from the point of view of
9129 the language. For example, we might have had:
9131 template <class T> struct S {
9132 template <class U> friend void f(T, U);
9133 };
9135 Then, in S<int>, template <class U> void f(int, U) is not an
9136 instantiation of anything. */
9142 {
9146 }
9148 /* The mangled name for the NEW_FRIEND is incorrect. The function
9149 is not a template instantiation and should not be mangled like
9150 one. Therefore, we forget the mangling here; we'll recompute it
9151 later if we need it. */
9153 {
9156 }
9159 {
9160 tree old_decl;
9161 tree new_friend_template_info;
9162 tree new_friend_result_template_info;
9163 tree ns;
9166 /* We must save some information from NEW_FRIEND before calling
9167 duplicate decls since that function will free NEW_FRIEND if
9168 possible. */
9170 new_friend_is_defn =
9175 {
9176 /* This declaration is a `primary' template. */
9179 new_friend_result_template_info
9181 }
9182 else
9185 /* Make the init_value nonzero so pushdecl knows this is a defn. */
9189 /* Inside pushdecl_namespace_level, we will push into the
9190 current namespace. However, the friend function should go
9191 into the namespace of the template. */
9201 {
9202 /* This new friend declaration matched an existing
9203 declaration. For example, given:
9205 template <class T> void f(T);
9206 template <class U> class C {
9207 template <class T> friend void f(T) {}
9208 };
9210 the friend declaration actually provides the definition
9211 of `f', once C has been instantiated for some type. So,
9212 old_decl will be the out-of-class template declaration,
9213 while new_friend is the in-class definition.
9215 But, if `f' was called before this point, the
9216 instantiation of `f' will have DECL_TI_ARGS corresponding
9217 to `T' but not to `U', references to which might appear
9218 in the definition of `f'. Previously, the most general
9219 template for an instantiation of `f' was the out-of-class
9220 version; now it is the in-class version. Therefore, we
9221 run through all specialization of `f', adding to their
9222 DECL_TI_ARGS appropriately. In particular, they need a
9223 new set of outer arguments, corresponding to the
9224 arguments for this class instantiation.
9226 The same situation can arise with something like this:
9228 friend void f(int);
9229 template <class T> class C {
9230 friend void f(T) {}
9231 };
9233 when `C<int>' is instantiated. Now, `f(int)' is defined
9234 in the class. */
9237 /* On the other hand, if the in-class declaration does
9238 *not* provide a definition, then we don't want to alter
9239 existing definitions. We can just leave everything
9240 alone. */
9241 ;
9242 else
9243 {
9247 /* Overwrite whatever template info was there before, if
9248 any, with the new template information pertaining to
9249 the declaration. */
9253 {
9254 /* We should have called reregister_specialization in
9255 duplicate_decls. */
9260 /* Instantiate it if the global has already been used. */
9264 }
9265 else
9266 {
9267 tree t;
9269 /* Indicate that the old function template is a partial
9270 instantiation. */
9278 /* Reassign any specializations already in the hash table
9279 to the new more general template, and add the
9280 additional template args. */
9284 {
9286 spec_entry elt;
9298 register_specialization
9301 }
9303 }
9304 }
9306 /* The information from NEW_FRIEND has been merged into OLD_DECL
9307 by duplicate_decls. */
9309 }
9310 }
9311 else
9312 {
9316 /* In the code
9317 template <class T> class C {
9318 template <class U> friend void C1<U>::f (); // case 1
9319 friend void C2<T>::f (); // case 2
9320 };
9321 we only need to make sure CONTEXT is a complete type for
9322 case 2. To distinguish between the two cases, we note that
9323 CONTEXT of case 1 remains dependent type after tsubst while
9324 this isn't true for case 2. */
9334 {
9336 /* do_friend adds the TEMPLATE_DECL for any member friend
9337 template even if it isn't a member template, i.e.
9338 template <class T> friend A<T>::f();
9339 Look through it in that case. */
9343 /* Check to see that the declaration is really present, and,
9344 possibly obtain an improved declaration. */
9349 }
9350 }
9353 }
9355 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
9356 template arguments, as for tsubst.
9358 Returns an appropriate tsubst'd friend type or error_mark_node on
9359 failure. */
9361 static tree
9363 {
9364 tree friend_type;
9365 tree tmpl;
9366 tree context;
9369 {
9372 }
9377 {
9380 else
9382 }
9384 /* Look for a class template declaration. We look for hidden names
9385 because two friend declarations of the same template are the
9386 same. For example, in:
9388 struct A {
9389 template <typename> friend class F;
9390 };
9391 template <typename> struct B {
9392 template <typename> friend class F;
9393 };
9395 both F templates are the same. */
9399 /* But, if we don't find one, it might be because we're in a
9400 situation like this:
9402 template <class T>
9403 struct S {
9404 template <class U>
9405 friend struct S;
9406 };
9408 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
9409 for `S<int>', not the TEMPLATE_DECL. */
9411 {
9414 }
9417 {
9418 /* The friend template has already been declared. Just
9419 check to see that the declarations match, and install any new
9420 default parameters. We must tsubst the default parameters,
9421 of course. We only need the innermost template parameters
9422 because that is all that redeclare_class_template will look
9423 at. */
9426 {
9427 tree parms;
9428 location_t saved_input_location;
9438 }
9441 }
9442 else
9443 {
9444 /* The friend template has not already been declared. In this
9445 case, the instantiation of the template class will cause the
9446 injection of this template into the global scope. */
9451 /* The new TMPL is not an instantiation of anything, so we
9452 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
9453 the new type because that is supposed to be the corresponding
9454 template decl, i.e., TMPL. */
9461 /* Inject this template into the global scope. */
9463 }
9466 {
9469 else
9471 }
9474 }
9476 /* Returns zero if TYPE cannot be completed later due to circularity.
9477 Otherwise returns one. */
9479 static int
9481 {
9491 else
9493 }
9497 /* Apply any attributes which had to be deferred until instantiation
9498 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
9499 ARGS, COMPLAIN, IN_DECL are as tsubst. */
9501 static void
9504 {
9506 tree t;
9511 {
9515 }
9518 {
9522 }
9523 else
9527 {
9532 {
9535 {
9542 {
9549 clauses
9553 else
9555 }
9556 /* If the first attribute argument is an identifier, don't
9557 pass it through tsubst. Attributes like mode, format,
9558 cleanup and several target specific attributes expect it
9559 unmodified. */
9562 {
9563 tree chain
9565 in_decl,
9570 chain);
9571 }
9572 else
9578 }
9579 else
9581 }
9584 }
9585 }
9587 /* Perform (or defer) access check for typedefs that were referenced
9588 from within the template TMPL code.
9589 This is a subroutine of instantiate_decl and instantiate_class_template.
9590 TMPL is the template to consider and TARGS is the list of arguments of
9591 that template. */
9593 static void
9595 {
9596 location_t saved_location;
9607 {
9619 /* Make access check error messages point to the location
9620 of the use of the typedef. */
9624 tf_warning_or_error);
9625 }
9627 }
9629 static tree
9631 {
9633 tree typedecl;
9634 tree pbinfo;
9635 tree base_list;
9637 tree fn_context;
9646 /* Figure out which template is being instantiated. */
9650 /* Determine what specialization of the original template to
9651 instantiate. */
9654 {
9657 }
9659 {
9660 /* This TYPE is actually an instantiation of a partial
9661 specialization. We replace the innermost set of ARGS with
9662 the arguments appropriate for substitution. For example,
9663 given:
9665 template <class T> struct S {};
9666 template <class T> struct S<T*> {};
9668 and supposing that we are instantiating S<int*>, ARGS will
9669 presently be {int*} -- but we need {int}. */
9672 }
9673 else
9674 {
9677 }
9679 /* If the template we're instantiating is incomplete, then clearly
9680 there's nothing we can do. */
9684 /* If we've recursively instantiated too many templates, stop. */
9688 /* Now we're really doing the instantiation. Mark the type as in
9689 the process of being defined. */
9692 /* We may be in the middle of deferred access check. Disable
9693 it now. */
9697 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9702 /* Use #pragma pack from the template context. */
9708 /* Set the input location to the most specialized template definition.
9709 This is needed if tsubsting causes an error. */
9721 {
9724 /* Adjust visibility for template arguments. */
9726 }
9732 /* We should never instantiate a nested class before its enclosing
9733 class; we need to look up the nested class by name before we can
9734 instantiate it, and that lookup should instantiate the enclosing
9735 class. */
9741 {
9742 tree pbase_binfo;
9743 tree pushed_scope;
9746 /* We must enter the scope containing the type, as that is where
9747 the accessibility of types named in dependent bases are
9748 looked up from. */
9751 /* Substitute into each of the bases to determine the actual
9752 basetypes. */
9754 {
9755 tree base;
9761 {
9762 expanded_bases =
9769 }
9772 {
9774 /* Extract the already-expanded base class. */
9776 else
9777 /* Substitute to figure out the base class. */
9779 NULL_TREE);
9787 }
9788 }
9790 /* The list is now in reverse order; correct that. */
9795 }
9796 /* Now call xref_basetypes to set up all the base-class
9797 information. */
9805 /* Now that our base classes are set up, enter the scope of the
9806 class, so that name lookups into base classes, etc. will work
9807 correctly. This is precisely analogous to what we do in
9808 begin_class_definition when defining an ordinary non-template
9809 class, except we also need to push the enclosing classes. */
9812 /* Now members are processed in the order of declaration. */
9815 {
9819 {
9821 {
9822 /* Build new CLASSTYPE_NESTED_UTDS. */
9824 tree newtag;
9830 /* If the member is a class template, then -- even after
9831 substitution -- there may be dependent types in the
9832 template argument list for the class. We increment
9833 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9834 that function will assume that no types are dependent
9835 when outside of a template. */
9845 {
9849 /* Unfortunately, lookup_template_class sets
9850 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9851 instantiation (i.e., for the type of a member
9852 template class nested within a template class.)
9853 This behavior is required for
9854 maybe_process_partial_specialization to work
9855 correctly, but is not accurate in this case;
9856 the TAG is not an instantiation of anything.
9857 (The corresponding TEMPLATE_DECL is an
9858 instantiation, but the TYPE is not.) */
9861 /* Now, we call pushtag to put this NEWTAG into the scope of
9862 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9863 pushtag calling push_template_decl. We don't have to do
9864 this for enums because it will already have been done in
9865 tsubst_enum. */
9869 }
9870 }
9872 {
9873 /* Build new TYPE_METHODS. */
9874 tree r;
9883 /* Instantiate members marked with attribute used. */
9889 }
9892 /* A closure type for a lambda in a default argument for a
9893 member template. Ignore it; it will be instantiated with
9895 else
9896 {
9897 /* Build new TYPE_FIELDS. */
9899 {
9900 tree condition;
9903 condition =
9913 }
9915 {
9916 tree r;
9920 /* The file and line for this declaration, to
9921 assist in error message reporting. Since we
9922 called push_tinst_level above, we don't need to
9923 restore these. */
9933 {
9934 /* A capture pack became multiple fields. */
9937 }
9940 {
9944 {
9945 /* In [temp.inst]:
9947 [t]he initialization (and any associated
9948 side-effects) of a static data member does
9949 not occur unless the static data member is
9950 itself used in a way that requires the
9951 definition of the static data member to
9952 exist.
9954 Therefore, we do not substitute into the
9955 initialized for the static data member here. */
9956 finish_static_data_member_decl
9962 /* Instantiate members marked with attribute used. */
9965 }
9967 {
9968 /* Determine whether R has a valid type and can be
9969 completed later. If R is invalid, then its type
9970 is replaced by error_mark_node. */
9976 {
9979 }
9980 }
9982 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9983 such a thing will already have been added to the field
9984 list by tsubst_enum in finish_member_declaration in the
9985 CLASSTYPE_NESTED_UTDS case above. */
9989 {
9992 }
9993 }
9994 }
9995 }
9996 }
9997 else
9998 {
10001 {
10002 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10008 {
10009 /* template <class T> friend class C; */
10012 }
10014 {
10015 /* template <class T> friend class C::D; */
10021 }
10024 {
10025 /* This could be either
10027 friend class T::C;
10029 when dependent_type_p is false or
10031 template <class U> friend class T::C;
10033 otherwise. */
10036 /* Bump processing_template_decl for correct
10037 dependent_type_p calculation. */
10042 }
10045 {
10046 /* friend class C;
10048 where C hasn't been declared yet. Let's lookup name
10049 from namespace scope directly, bypassing any name that
10050 come from dependent base class. */
10053 /* The call to xref_tag_from_type does injection for friend
10054 classes. */
10056 friend_type =
10060 }
10062 /* friend class C<T>; */
10065 /* Otherwise it's
10067 friend class C;
10069 where C is already declared or
10071 friend class C<int>;
10073 We don't have to do anything in these cases. */
10076 /* Trick make_friend_class into realizing that the friend
10077 we're adding is a template, not an ordinary class. It's
10078 important that we use make_friend_class since it will
10079 perform some error-checking and output cross-reference
10080 information. */
10088 }
10089 else
10090 {
10091 /* Build new DECL_FRIENDLIST. */
10092 tree r;
10094 /* The file and line for this declaration, to
10095 assist in error message reporting. Since we
10096 called push_tinst_level above, we don't need to
10097 restore these. */
10101 {
10104 }
10109 {
10112 }
10113 }
10114 }
10115 }
10118 {
10121 {
10126 /* We need to instantiate the capture list from the template
10127 after we've instantiated the closure members, but before we
10128 consider adding the conversion op. Also keep any captures
10129 that may have been added during instantiation of the op(). */
10131 tree tmpl_cap
10140 }
10141 else
10143 }
10145 /* Set the file and line number information to whatever is given for
10146 the class itself. This puts error messages involving generated
10147 implicit functions at a predictable point, and the same point
10148 that would be used for non-template classes. */
10155 /* We don't instantiate default arguments for member functions. 14.7.1:
10157 The implicit instantiation of a class template specialization causes
10158 the implicit instantiation of the declarations, but not of the
10159 definitions or default arguments, of the class member functions,
10160 member classes, static data members and member templates.... */
10162 /* Some typedefs referenced from within the template code need to be access
10163 checked at template instantiation time, i.e now. These types were
10164 added to the template at parsing time. Let's get those and perform
10165 the access checks then. */
10175 /* The vtable for a template class can be emitted in any translation
10176 unit in which the class is instantiated. When there is no key
10177 method, however, finish_struct_1 will already have added TYPE to
10178 the keyed_classes list. */
10183 }
10185 /* Wrapper for instantiate_class_template_1. */
10187 tree
10189 {
10190 tree ret;
10195 }
10197 static tree
10199 {
10200 tree r;
10206 else
10207 {
10214 }
10216 }
10218 /* Given a function parameter pack TMPL_PARM and some function parameters
10219 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10220 and set *SPEC_P to point at the next point in the list. */
10222 tree
10224 {
10225 /* Collect all of the extra "packed" parameters into an
10226 argument pack. */
10227 tree parmvec;
10228 tree parmtypevec;
10239 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10244 {
10247 }
10249 /* Build the argument packs. */
10256 }
10258 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
10259 NONTYPE_ARGUMENT_PACK. */
10261 static tree
10263 {
10265 }
10267 /* Return true iff the Ith element of the argument pack ARG_PACK is a
10268 pack expansion. */
10270 static bool
10272 {
10277 }
10280 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
10282 static tree
10284 {
10291 }
10293 /* This is a subroutine of tsubst_pack_expansion.
10295 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
10296 mechanism to store the (non complete list of) arguments of the
10297 substitution and return a non substituted pack expansion, in order
10298 to wait for when we have enough arguments to really perform the
10299 substitution. */
10301 static bool
10305 {
10306 /* If one pack has an expansion and another pack has a normal
10307 argument or if one pack has an empty argument and an another
10308 one hasn't then tsubst_pack_expansion cannot perform the
10309 substitution and need to fall back on the
10310 PACK_EXPANSION_EXTRA mechanism. */
10318 {
10321 parm_pack;
10323 {
10328 else
10330 }
10334 }
10336 }
10338 /* [temp.variadic]/6 says that:
10340 The instantiation of a pack expansion [...]
10341 produces a list E1,E2, ..., En, where N is the number of elements
10342 in the pack expansion parameters.
10344 This subroutine of tsubst_pack_expansion produces one of these Ei.
10346 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
10347 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
10348 PATTERN, and each TREE_VALUE is its corresponding argument pack.
10349 INDEX is the index 'i' of the element Ei to produce. ARGS,
10350 COMPLAIN, and IN_DECL are the same parameters as for the
10351 tsubst_pack_expansion function.
10353 The function returns the resulting Ei upon successful completion,
10354 or error_mark_node.
10356 Note that this function possibly modifies the ARGS parameter, so
10357 it's the responsibility of the caller to restore it. */
10359 static tree
10361 tree parm_packs,
10363 tree args /* This parm gets
10365 tsubst_flags_t complain,
10366 tree in_decl)
10367 {
10368 tree t;
10371 /* For each parameter pack, change the substitution of the parameter
10372 pack to the ith argument in its argument pack, then expand the
10373 pattern. */
10375 {
10380 ith_elem_is_expansion |=
10383 /* Select the Ith argument from the pack. */
10386 {
10388 {
10392 }
10393 else
10395 }
10396 else
10397 {
10402 {
10404 /* Update the corresponding argument. */
10406 }
10407 else
10408 /* Re-use the ARGUMENT_PACK_SELECT. */
10410 }
10412 }
10414 /* Substitute into the PATTERN with the (possibly altered)
10415 arguments. */
10417 /* Expanding a fixed parameter pack from
10418 coerce_template_parameter_pack. */
10423 else
10426 /* If the Ith argument pack element is a pack expansion, then
10427 the Ith element resulting from the substituting is going to
10428 be a pack expansion as well. */
10433 }
10435 /* Substitute args into the pack expansion T, and rewrite the resulting
10436 list as a conjunction of the specified terms. If the result is an empty
10437 expression, return boolean_true_node.
10439 FIXME: This goes away with fold expressions. */
10440 tree
10442 tree in_decl)
10443 {
10446 /* If the resulting expression is type- or value-dependent, then
10447 return it after setting the result type to bool (so it can be
10448 expanded as a conjunction). This happens when instantiating
10449 constrained variadic member function templates. Just rebuild
10450 the dependent pack expansion. */
10452 {
10456 }
10458 /* Empty expansions are equivalent to 'true'. */
10462 /* Otherwise, and the terms together. These are transformed
10463 into constraints later. */
10468 }
10470 }
10473 /* Substitute ARGS into T, which is an pack expansion
10474 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
10475 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
10476 (if only a partial substitution could be performed) or
10477 ERROR_MARK_NODE if there was an error. */
10478 tree
10480 tree in_decl)
10481 {
10482 tree pattern;
10486 tree result;
10491 /* If T is a parameter declaration pending expansion by
10492 ARGS, substitute through and form an argument pack
10493 for the resulting expression. The sequence of
10494 expressions is contained in the argument pack. */
10496 {
10502 }
10507 /* Add in any args remembered from an earlier partial instantiation. */
10512 /* Determine the argument packs that will instantiate the parameter
10513 packs used in the expansion expression. While we're at it,
10514 compute the number of arguments to be expanded and make sure it
10515 is consistent. */
10518 {
10525 {
10529 else
10532 }
10534 {
10537 else
10538 {
10539 /* We can't rely on local_specializations for a parameter
10540 name used later in a function declaration (such as in a
10541 late-specified return type). Even if it exists, it might
10542 have the wrong value for a recursive call. Just make a
10543 dummy decl, since it's only used for its type. */
10546 /* Partial instantiation of the parm_pack, we can't build
10547 up an argument pack yet. */
10549 else
10552 }
10553 }
10556 else
10557 {
10563 }
10570 /* This can only happen if we forget to expand an argument
10571 pack somewhere else. Just return an error, silently. */
10572 {
10576 }
10579 {
10583 /* Don't bother trying to do a partial substitution with
10584 incomplete packs; we'll try again after deduction. */
10591 {
10597 pattern);
10598 else
10601 pattern);
10603 }
10605 /* Keep track of the parameter packs and their corresponding
10606 argument packs. */
10609 }
10610 else
10611 {
10612 /* We can't substitute for this parameter pack. We use a flag as
10613 well as the missing_level counter because function parameter
10614 packs don't have a level. */
10616 }
10617 }
10619 /* If the expansion is just T..., return the matching argument pack. */
10622 {
10627 /* Otherwise use the normal path so we get convert_from_reference. */
10628 }
10630 /* We cannot expand this expansion expression, because we don't have
10631 all of the argument packs we need. */
10633 {
10634 /* We got some full packs, but we can't substitute them in until we
10635 have values for all the packs. So remember these until then. */
10640 }
10642 {
10643 /* There were no real arguments, we're just replacing a parameter
10644 pack with another version of itself. Substitute into the
10645 pattern and return a PACK_EXPANSION_*. The caller will need to
10646 deal with that. */
10650 else
10654 }
10659 {
10660 /* We're in a late-specified return type, so create our own local
10661 specializations map; the current map is either NULL or (in the
10662 case of recursive unification) might have bindings that we don't
10663 want to use or alter. */
10666 }
10668 /* For each argument in each argument pack, substitute into the
10669 pattern. */
10672 {
10674 i,
10676 in_decl);
10679 {
10682 }
10683 }
10685 /* Update ARGS to restore the substitution from parameter packs to
10686 their argument packs. */
10688 {
10694 else
10695 {
10703 /* Update the corresponding argument. */
10707 else
10709 }
10710 }
10713 {
10716 }
10719 }
10721 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10722 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10723 parameter packs; all parms generated from a function parameter pack will
10724 have the same DECL_PARM_INDEX. */
10726 tree
10728 {
10730 tree patparm;
10733 {
10739 }
10740 else
10741 {
10746 }
10749 }
10751 /* Substitute ARGS into the vector or list of template arguments T. */
10753 static tree
10755 {
10767 {
10769 tree new_arg;
10774 {
10775 /* Substitute into an expansion expression. */
10779 /* Add to the expanded length adjustment the number of
10780 expanded arguments. We subtract one from this
10781 measurement, because the argument pack expression
10782 itself is already counted as 1 in
10783 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10784 the argument pack is empty. */
10786 }
10788 {
10789 /* Substitute into each of the arguments. */
10795 new_arg,
10809 }
10810 }
10811 else
10820 }
10825 /* Make space for the expanded arguments coming from template
10826 argument packs. */
10828 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10829 arguments for a member template.
10830 In that case each TREE_VEC in ORIG_T represents a level of template
10831 arguments, and ORIG_T won't carry any non defaulted argument count.
10832 It will rather be the nested TREE_VECs that will carry one.
10833 In other words, ORIG_T carries a non defaulted argument count only
10834 if it doesn't contain any nested TREE_VEC. */
10836 {
10840 }
10842 {
10846 {
10849 /* Now expand the template argument pack "in place". */
10852 }
10853 else
10854 {
10856 out++;
10857 }
10858 }
10861 }
10863 /* Return the result of substituting ARGS into the template parameters
10864 given by PARMS. If there are m levels of ARGS and m + n levels of
10865 PARMS, then the result will contain n levels of PARMS. For
10866 example, if PARMS is `template <class T> template <class U>
10867 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10868 result will be `template <int*, double, class V>'. */
10870 static tree
10872 {
10876 /* When substituting into a template, we must set
10877 PROCESSING_TEMPLATE_DECL as the template parameters may be
10878 dependent if they are based on one-another, and the dependency
10879 predicates are short-circuit outside of templates. */
10886 {
10887 tree new_vec =
10892 {
10893 tree tuple;
10905 }
10911 }
10916 }
10918 /* Return the result of substituting ARGS into one template parameter
10919 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10920 parameter and which TREE_PURPOSE is the default argument of the
10921 template parameter. */
10923 static tree
10925 {
10946 }
10948 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10949 type T. If T is not an aggregate or enumeration type, it is
10950 handled as if by tsubst. IN_DECL is as for tsubst. If
10951 ENTERING_SCOPE is nonzero, T is the context for a template which
10952 we are presently tsubst'ing. Return the substituted value. */
10954 static tree
10956 tree args,
10957 tsubst_flags_t complain,
10958 tree in_decl,
10960 {
10965 {
10970 /* Else fall through. */
10974 {
10975 tree argvec;
10976 tree context;
10977 tree r;
10981 /* In "sizeof(X<I>)" we need to evaluate "I". */
10987 /* First, determine the context for the type we are looking
10988 up. */
10991 {
10994 /* If context is a nested class inside a class template,
10995 it may still need to be instantiated (c++/33959). */
10997 }
10999 /* Then, figure out what arguments are appropriate for the
11000 type we are trying to find. For example, given:
11002 template <class T> struct S;
11003 template <class T, class U> void f(T, U) { S<U> su; }
11005 and supposing that we are instantiating f<int, double>,
11006 then our ARGS will be {int, double}, but, when looking up
11007 S we only want {double}. */
11012 else
11013 {
11017 }
11023 }
11024 else
11025 /* This is not a template type, so there's nothing to do. */
11030 }
11031 }
11033 /* Substitute into the default argument ARG (a default argument for
11034 FN), which has the indicated TYPE. */
11036 tree
11038 {
11043 /* This can happen in invalid code. */
11047 /* This default argument came from a template. Instantiate the
11048 default argument here, not in tsubst. In the case of
11049 something like:
11051 template <class T>
11052 struct S {
11053 static T t();
11054 void f(T = t());
11055 };
11057 we must be careful to do name lookup in the scope of S<T>,
11058 rather than in the current class. */
11060 /* The "this" pointer is not valid in a default argument. */
11062 {
11067 }
11070 /* The default argument expression may cause implicitly defined
11071 member functions to be synthesized, which will result in garbage
11072 collection. We must treat this situation as if we were within
11073 the body of function so as to avoid collecting live data on the
11074 stack. */
11082 /* Restore the "this" pointer. */
11084 {
11087 }
11094 /* Make sure the default argument is reasonable. */
11100 }
11102 /* Substitute into all the default arguments for FN. */
11104 static void
11106 {
11107 tree arg;
11108 tree tmpl_args;
11112 /* If this function is not yet instantiated, we certainly don't need
11113 its default arguments. */
11116 /* Don't do this again for clones. */
11121 arg;
11127 complain);
11128 }
11130 /* Substitute the ARGS into the T, which is a _DECL. Return the
11131 result of the substitution. Issue error and warning messages under
11132 control of COMPLAIN. */
11134 static tree
11136 {
11137 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
11138 location_t saved_loc;
11143 /* Set the filename and linenumber to improve error-reporting. */
11148 {
11150 {
11151 /* We can get here when processing a member function template,
11152 member class template, or template template parameter. */
11155 tree spec;
11156 tree tmpl_args;
11157 tree full_args;
11160 {
11161 /* Template template parameter is treated here. */
11165 /* If we get a real template back, return it. This can happen in
11166 the context of most_specialized_partial_spec. */
11178 complain);
11181 }
11183 /* We might already have an instance of this template.
11184 The ARGS are for the surrounding class type, so the
11185 full args contain the tsubst'd args for the context,
11186 plus the innermost args from the template decl. */
11190 /* Because this is a template, the arguments will still be
11191 dependent, even after substitution. If
11192 PROCESSING_TEMPLATE_DECL is not set, the dependency
11193 predicates will short-circuit. */
11201 /* If this is a default template template argument,
11202 tsubst might not have changed anything. */
11209 {
11212 }
11214 /* Make a new template decl. It will be similar to the
11215 original, but will record the current template arguments.
11216 We also create a new function declaration, which is just
11217 like the old one, but points to this new template, rather
11218 than the old one. */
11223 // Build new template info linking to the original template decl.
11228 {
11229 tree new_type;
11237 /* For a partial specialization, we need to keep pointing to
11238 the primary template. */
11244 }
11245 else
11246 {
11247 tree new_decl;
11259 }
11265 /* The template parameters for this new template are all the
11266 template parameters for the old template, except the
11267 outermost level of parameters. */
11270 complain);
11276 /* Record this non-type partial instantiation. */
11280 }
11284 {
11285 tree ctx;
11288 tree gen_tmpl;
11289 tree type;
11294 /* Nobody should be tsubst'ing into non-template functions. */
11298 {
11299 tree spec;
11302 /* If T is not dependent, just return it. We have to
11303 increment PROCESSING_TEMPLATE_DECL because
11304 value_dependent_expression_p assumes that nothing is
11305 dependent when PROCESSING_TEMPLATE_DECL is zero. */
11312 /* Calculate the most general template of which R is a
11313 specialization, and the complete set of arguments used to
11314 specialize R. */
11317 (DECL_TEMPLATE_RESULT
11323 /* Check to see if we already have this specialization. */
11328 {
11331 }
11333 /* We can see more levels of arguments than parameters if
11334 there was a specialization of a member template, like
11335 this:
11337 template <class T> struct S { template <class U> void f(); }
11338 template <> template <class U> void S<int>::f(U);
11340 Here, we'll be substituting into the specialization,
11341 because that's where we can find the code we actually
11342 want to generate, but we'll have enough arguments for
11343 the most general template.
11345 We also deal with the peculiar case:
11347 template <class T> struct S {
11348 template <class U> friend void f();
11349 };
11350 template <class U> void f() {}
11351 template S<int>;
11352 template void f<double>();
11354 Here, the ARGS for the instantiation of will be {int,
11355 double}. But, we only need as many ARGS as there are
11356 levels of template parameters in CODE_PATTERN. We are
11357 careful not to get fooled into reducing the ARGS in
11358 situations like:
11360 template <class T> struct S { template <class U> void f(U); }
11361 template <class T> template <> void S<T>::f(int) {}
11363 which we can spot because the pattern will be a
11364 specialization in this case. */
11366 parms_depth =
11371 }
11372 else
11373 {
11374 /* This special case arises when we have something like this:
11376 template <class T> struct S {
11377 friend void f<int>(int, double);
11378 };
11380 Here, the DECL_TI_TEMPLATE for the friend declaration
11381 will be an IDENTIFIER_NODE. We are being called from
11382 tsubst_friend_function, and we want only to create a
11383 new decl (R) with appropriate types so that we can call
11384 determine_specialization. */
11386 }
11389 {
11392 else
11396 }
11397 else
11398 {
11401 }
11406 /* If we hit excessive deduction depth, the type is bogus even if
11407 it isn't error_mark_node, so don't build a decl. */
11411 /* We do NOT check for matching decls pushed separately at this
11412 point, as they may not represent instantiations of this
11413 template, and in any case are considered separate under the
11414 discrete model. */
11418 /* Clear out the mangled name and RTL for the instantiation. */
11421 /* Leave DECL_INITIAL set on deleted instantiations. */
11426 /* OpenMP UDRs have the only argument a reference to the declared
11427 type. We want to diagnose if the declared type is a reference,
11428 which is invalid, but as references to references are usually
11429 quietly merged, diagnose it here. */
11431 {
11432 tree argtype
11437 "reference type %qT in "
11441 argtype);
11442 }
11445 /* Type-conversion operator. Reconstruct the name, in
11446 case it's the name of one of the template's parameters. */
11456 /* If this is an instantiation of a function with internal
11457 linkage, we already know what object file linkage will be
11458 assigned to the instantiation. */
11467 /* We'll re-clone as appropriate in instantiate_template. */
11470 /* If we aren't complaining now, return on error before we register
11471 the specialization so that we'll complain eventually. */
11477 /* When instantiating a constrained member, substitute
11478 into the constraints to create a new constraint into
11479 the */
11482 {
11485 }
11486 }
11488 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
11489 this in the special friend case mentioned above where
11490 GEN_TMPL is NULL. */
11492 {
11496 tree new_r
11499 /* We instantiated this while substituting into
11500 the type earlier (template/friend54.C). */
11503 /* We're not supposed to instantiate default arguments
11504 until they are called, for a template. But, for a
11505 declaration like:
11507 template <class T> void f ()
11508 { extern void g(int i = T()); }
11510 we should do the substitution when the template is
11511 instantiated. We handle the member function case in
11512 instantiate_class_template since the default arguments
11513 might refer to other members of the class. */
11518 }
11519 else
11522 /* Copy the list of befriending classes. */
11526 {
11530 in_decl);
11531 }
11534 {
11542 /* If this is an instantiation of a member template, clone it.
11543 If it isn't, that'll be handled by
11544 clone_constructors_and_destructors. */
11547 }
11558 /* Possibly limit visibility based on template args. */
11561 {
11565 }
11573 }
11577 {
11585 {
11586 /* If there is a local specialization that isn't a
11587 parameter pack, it means that we're doing a "simple"
11588 substitution from inside tsubst_pack_expansion. Just
11589 return the local specialization (which will be a single
11590 parm). */
11597 /* Expand the TYPE_PACK_EXPANSION that provides the types for
11598 the parameters in this function parameter pack. */
11602 {
11605 /* Zero-length parameter packs are boring. Just substitute
11606 into the chain. */
11610 }
11611 else
11612 {
11613 /* All we did was update the type. Make a note of that. */
11616 }
11617 }
11619 /* Loop through all of the parameters we'll build. When T is
11620 a function parameter pack, LEN is the number of expanded
11621 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11624 {
11631 /* We're on the Ith parameter of the function parameter
11632 pack. */
11633 {
11634 /* Get the Ith type. */
11637 /* Rename the parameter to include the index. */
11640 }
11642 /* We're dealing with a normal parameter. */
11650 {
11653 else
11656 }
11666 /* Keep track of the first new parameter we
11667 generate. That's what will be returned to the
11668 caller. */
11672 /* Build a proper chain of parameters when substituting
11673 into a function parameter pack. */
11676 }
11678 /* If cp_unevaluated_operand is set, we're just looking for a
11679 single dummy parameter, so don't keep going. */
11684 /* FIRST_R contains the start of the chain we've built. */
11686 }
11690 {
11697 {
11698 /* This field is a lambda capture pack. Return a TREE_VEC of
11699 the expanded fields to instantiate_class_template_1 and
11700 store them in the specializations hash table as a
11701 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11705 {
11708 }
11709 else
11710 {
11711 /* All we did was update the type. Make a note of that. */
11714 }
11715 }
11718 {
11721 {
11725 }
11735 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11736 non-bit-fields DECL_INITIAL is a non-static data member
11737 initializer, which gets deferred instantiation. */
11743 {
11744 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11745 NSDMI in perform_member_init. Still set DECL_INITIAL
11746 so that we know there is one. */
11751 }
11752 /* We don't have to set DECL_CONTEXT here; it is set by
11753 finish_member_declaration. */
11761 }
11764 {
11772 }
11773 }
11777 /* We reach here only for member using decls. We also need to check
11778 uses_template_parms because DECL_DEPENDENT_P is not set for a
11779 using-declaration that designates a member of the current
11780 instantiation (c++/53549). */
11783 {
11790 else
11791 {
11794 }
11795 }
11796 else
11797 {
11800 }
11805 {
11808 tree spec;
11810 tree ctx;
11819 {
11820 /* If this is the canonical decl, we don't have to
11821 mess with instantiations, and often we can't (for
11822 typename, template type parms and such). Note that
11823 TYPE_NAME is not correct for the above test if
11824 we've copied the type for a typedef. */
11830 }
11832 /* Check to see if we already have the specialization we
11833 need. */
11836 {
11837 /* T is a static data member or namespace-scope entity.
11838 We have to substitute into namespace-scope variables
11839 (even though such entities are never templates) because
11840 of cases like:
11842 template <class T> void f() { extern T t; }
11844 where the entity referenced is not known until
11845 instantiation time. */
11849 {
11851 complain,
11853 /* If CTX is unchanged, then T is in fact the
11854 specialization we want. That situation occurs when
11855 referencing a static data member within in its own
11856 class. We can use pointer equality, rather than
11857 same_type_p, because DECL_CONTEXT is always
11858 canonical... */
11860 /* ... unless T is a member template; in which
11861 case our caller can be willing to create a
11862 specialization of that template represented
11863 by T.
11865 NOTE: The extra check for DECL_TEMPLATE_INFO
11866 is apparenly needed when checking constraints
11867 for associated type names when the requirement
11868 is satisfied by an alias declaration. */
11873 }
11876 {
11884 }
11885 }
11886 else
11887 {
11888 /* A local variable. */
11890 /* Subsequent calls to pushdecl will fill this in. */
11893 }
11894 /* If we already have the specialization we need, there is
11895 nothing more to do. */
11897 {
11900 }
11902 /* Create a new node for the specialization we need. */
11905 {
11908 else
11915 }
11917 {
11918 /* Even if the original location is out of scope, the
11919 newly substituted one is not. */
11926 {
11927 /* It may seem that this case cannot occur, since:
11929 typedef void f();
11930 void g() { f x; }
11932 declares a function, not a variable. However:
11934 typedef void f();
11935 template <typename T> void g() { T t; }
11936 template void g<f>();
11938 is an attempt to declare a variable with function
11939 type. */
11941 /* R is not yet sufficiently initialized, so we
11942 just use its name. */
11945 }
11947 /* Wait until cp_finish_decl to set this again, to handle
11948 circular dependency (template/instantiate6.C). */
11953 {
11958 {
11961 }
11963 }
11966 }
11972 /* Clear out the mangled name and RTL for the instantiation. */
11976 /* The initializer must not be expanded until it is required;
11977 see [temp.inst]. */
11983 {
11984 /* Possibly limit visibility based on template args. */
11987 {
11991 }
11993 }
11996 {
11997 /* A static data member declaration is always marked
11998 external when it is declared in-class, even if an
11999 initializer is present. We mimic the non-template
12000 processing here. */
12007 }
12017 /* Preserve a typedef that names a type. */
12019 {
12022 }
12025 }
12030 }
12031 #undef RETURN
12033 out:
12034 /* Restore the file and line information. */
12038 }
12040 /* Substitute into the ARG_TYPES of a function type.
12041 If END is a TREE_CHAIN, leave it and any following types
12042 un-substituted. */
12044 static tree
12046 tree args,
12047 tree end,
12048 tsubst_flags_t complain,
12049 tree in_decl)
12050 {
12051 tree remaining_arg_types;
12055 tree default_arg;
12066 {
12067 /* For a pack expansion, perform substitution on the
12068 entire expression. Later on, we'll handle the arguments
12069 one-by-one. */
12074 /* So that we'll spin through the parameters, one by one. */
12076 else
12077 {
12078 /* We only partially substituted into the parameter
12079 pack. Our type is TYPE_PACK_EXPANSION. */
12082 }
12083 }
12096 {
12098 {
12102 }
12104 }
12105 /* DR 657. */
12109 /* Do array-to-pointer, function-to-pointer conversion, and ignore
12110 top-level qualifiers as required. */
12113 /* We do not substitute into default arguments here. The standard
12114 mandates that they be instantiated only when needed, which is
12115 done in build_over_call. */
12119 {
12120 /* We've instantiated a template before its default arguments
12121 have been parsed. This can happen for a nested template
12122 class, and is not an error unless we require the default
12123 argument in a call of this function. */
12124 remaining_arg_types =
12127 }
12128 else
12129 remaining_arg_types =
12131 }
12134 }
12136 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
12137 *not* handle the exception-specification for FNTYPE, because the
12138 initial substitution of explicitly provided template parameters
12139 during argument deduction forbids substitution into the
12140 exception-specification:
12142 [temp.deduct]
12144 All references in the function type of the function template to the
12145 corresponding template parameters are replaced by the specified tem-
12146 plate argument values. If a substitution in a template parameter or
12147 in the function type of the function template results in an invalid
12148 type, type deduction fails. [Note: The equivalent substitution in
12149 exception specifications is done only when the function is instanti-
12150 ated, at which point a program is ill-formed if the substitution
12151 results in an invalid type.] */
12153 static tree
12155 tree args,
12156 tsubst_flags_t complain,
12157 tree in_decl)
12158 {
12159 tree return_type;
12161 tree fntype;
12163 /* The TYPE_CONTEXT is not used for function/method types. */
12166 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
12167 failure. */
12171 {
12172 /* Substitute the argument types. */
12184 {
12185 /* DR 1207: 'this' is in scope in the trailing return type. */
12187 }
12189 /* Substitute the return type. */
12193 {
12196 }
12197 }
12198 else
12199 /* Substitute the return type. */
12204 /* DR 486 clarifies that creation of a function type with an
12205 invalid return type is a deduction failure. */
12208 {
12210 {
12213 else
12215 }
12217 }
12218 /* And DR 657. */
12223 {
12224 /* Substitute the argument types. */
12229 }
12231 /* Construct a new type node and return it. */
12233 {
12238 }
12239 else
12240 {
12242 /* Don't pick up extra function qualifiers from the basetype. */
12245 {
12246 /* [temp.deduct]
12248 Type deduction may fail for any of the following
12249 reasons:
12251 -- Attempting to create "pointer to member of T" when T
12252 is not a class type. */
12255 r);
12257 }
12262 }
12269 }
12271 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
12272 ARGS into that specification, and return the substituted
12273 specification. If there is no specification, return NULL_TREE. */
12275 static tree
12277 tree args,
12278 tsubst_flags_t complain,
12279 tree in_decl,
12281 {
12282 tree specs;
12283 tree new_specs;
12288 {
12289 /* A noexcept-specifier. */
12294 {
12295 /* Defer instantiation of noexcept-specifiers to avoid
12296 excessive instantiations (c++/49107). */
12299 {
12300 /* We already partially instantiated this member template,
12301 so combine the new args with the old. */
12306 }
12307 else
12308 {
12311 }
12312 }
12313 else
12314 new_specs = tsubst_copy_and_build
12318 }
12320 {
12323 else
12325 {
12326 tree spec;
12331 {
12332 /* Expand the pack expansion type. */
12335 in_decl);
12341 else
12342 {
12343 /* We're substituting into a member template, so
12344 we got a TYPE_PACK_EXPANSION back. Add that
12345 expansion and move on. */
12349 expanded_specs,
12350 complain);
12353 }
12354 }
12357 {
12360 else
12365 complain);
12366 }
12369 }
12370 }
12372 }
12374 /* Take the tree structure T and replace template parameters used
12375 therein with the argument vector ARGS. IN_DECL is an associated
12376 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
12377 Issue error and warning messages under control of COMPLAIN. Note
12378 that we must be relatively non-tolerant of extensions here, in
12379 order to preserve conformance; if we allow substitutions that
12380 should not be allowed, we may allow argument deductions that should
12381 not succeed, and therefore report ambiguous overload situations
12382 where there are none. In theory, we could allow the substitution,
12383 but indicate that it should have failed, and allow our caller to
12384 make sure that the right thing happens, but we don't try to do this
12385 yet.
12387 This function is used for dealing with types, decls and the like;
12388 for expressions, use tsubst_expr or tsubst_copy. */
12390 tree
12392 {
12415 else
12420 /* Reuse typedefs. We need to do this to handle dependent attributes,
12421 such as attribute aligned. */
12424 {
12428 {
12429 /* DECL represents an alias template and we want to
12430 instantiate it. */
12434 }
12438 {
12442 }
12447 else
12448 /* The typedef is from a non-template context. */
12452 {
12454 r = cp_build_qualified_type_real
12458 }
12459 else
12460 {
12461 /* We don't have an instantiation yet, so drop the typedef. */
12466 }
12467 }
12480 {
12506 {
12512 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
12513 needed. */
12519 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
12520 with TREE_SIDE_EFFECTS that indicates this is not an integral
12521 constant expression. */
12524 {
12527 }
12530 }
12536 {
12552 {
12555 {
12556 /* See through ARGUMENT_PACK_SELECT arguments. */
12558 /* If the selected argument is an expansion E, that most
12559 likely means we were called from
12560 gen_elem_of_pack_expansion_instantiation during the
12561 substituting of pack an argument pack (which Ith
12562 element is a pack expansion, where I is
12563 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12564 In this case, the Ith element resulting from this
12565 substituting is going to be a pack expansion, which
12566 pattern is the pattern of E. Let's return the
12567 pattern of E, and
12568 gen_elem_of_pack_expansion_instantiation will
12569 build the resulting pack expansion from it. */
12571 {
12572 /* Make sure we aren't throwing away arg info. */
12575 }
12576 }
12577 }
12582 {
12584 /* If ARG is an argument pack, we don't actually want to
12585 perform a substitution here, because substitutions
12586 for argument packs are only done
12587 element-by-element. We can get to this point when
12588 substituting the type of a non-type template
12589 parameter pack, when that type actually contains
12590 template parameter packs from an outer template, e.g.,
12592 template<typename... Types> struct A {
12593 template<Types... Values> struct B { };
12594 }; */
12598 {
12604 return cp_build_qualified_type_real
12606 }
12608 {
12609 /* We are processing a type constructed from a
12610 template template parameter. */
12621 /* Consider this code:
12623 template <template <class> class Template>
12624 struct Internal {
12625 template <class Arg> using Bind = Template<Arg>;
12626 };
12628 template <template <class> class Template, class Arg>
12629 using Instantiate = Template<Arg>; //#0
12631 template <template <class> class Template,
12632 class Argument>
12633 using Bind =
12634 Instantiate<Internal<Template>::template Bind,
12635 Argument>; //#1
12637 When #1 is parsed, the
12638 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12639 parameter `Template' in #0 matches the
12640 UNBOUND_CLASS_TEMPLATE representing the argument
12641 `Internal<Template>::template Bind'; We then want
12642 to assemble the type `Bind<Argument>' that can't
12643 be fully created right now, because
12644 `Internal<Template>' not being complete, the Bind
12645 template cannot be looked up in that context. So
12646 we need to "store" `Bind<Argument>' for later
12647 when the context of Bind becomes complete. Let's
12648 store that in a TYPENAME_TYPE. */
12652 argvec),
12653 typename_type,
12654 complain);
12656 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12657 are resolving nested-types in the signature of a
12658 member function templates. Otherwise ARG is a
12659 TEMPLATE_DECL and is the real template to be
12660 instantiated. */
12668 complain);
12669 return cp_build_qualified_type_real
12671 }
12672 else
12673 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12675 }
12678 /* This can happen during the attempted tsubst'ing in
12679 unify. This means that we don't yet have any information
12680 about the template parameter in question. */
12683 /* Early in template argument deduction substitution, we don't
12684 want to reduce the level of 'auto', or it will be confused
12685 with a normal template parm in subsequent deduction. */
12689 /* If we get here, we must have been looking at a parm for a
12690 more deeply nested template. Make a new version of this
12691 template parameter, but with a lower level. */
12693 {
12698 {
12700 r = cp_build_qualified_type_real
12704 }
12705 else
12706 {
12717 /* We have reduced the level of the template
12718 template parameter, but not the levels of its
12719 template parameters, so canonical_type_parameter
12720 will not be able to find the canonical template
12721 template parameter for this level. Thus, we
12722 require structural equality checking to compare
12723 TEMPLATE_TEMPLATE_PARMs. */
12727 else
12731 {
12739 }
12740 }
12749 }
12752 }
12755 {
12763 {
12767 }
12770 {
12774 }
12777 {
12781 }
12787 }
12790 /* We should never be tsubsting a binfo. */
12794 /* A vector of template arguments. */
12800 {
12804 /* [temp.deduct]
12806 Type deduction may fail for any of the following
12807 reasons:
12809 -- Attempting to create a pointer to reference type.
12810 -- Attempting to create a reference to a reference type or
12811 a reference to void.
12813 Core issue 106 says that creating a reference to a reference
12814 during instantiation is no longer a cause for failure. We
12815 only enforce this check in strict C++98 mode. */
12819 {
12822 /* We keep track of the last time we issued this error
12823 message to avoid spewing a ton of messages during a
12824 single bad template instantiation. */
12827 {
12832 else
12835 }
12838 }
12842 {
12844 {
12847 type);
12848 else
12850 type);
12851 }
12853 }
12855 {
12859 }
12861 /* In C++0x, during template argument substitution, when there is an
12862 attempt to create a reference to a reference type, reference
12863 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12865 "If a template-argument for a template-parameter T names a type
12866 that is a reference to a type A, an attempt to create the type
12867 'lvalue reference to cv T' creates the type 'lvalue reference to
12868 A,' while an attempt to create the type type rvalue reference to
12869 cv T' creates the type T"
12870 */
12871 r = cp_build_reference_type
12874 else
12879 /* Will this ever be needed for TYPE_..._TO values? */
12883 }
12885 {
12888 {
12889 /* [temp.deduct]
12891 Type deduction may fail for any of the following
12892 reasons:
12894 -- Attempting to create "pointer to member of T" when T
12895 is not a class type. */
12899 }
12901 {
12905 }
12907 {
12911 }
12914 {
12915 /* The type of the implicit object parameter gets its
12916 cv-qualifiers from the FUNCTION_TYPE. */
12917 tree memptr;
12918 tree method_type
12923 complain);
12924 }
12925 else
12928 complain);
12929 }
12932 {
12933 tree fntype;
12934 tree specs;
12939 /* Substitute the exception specification. */
12947 }
12949 {
12954 /* As an optimization, we avoid regenerating the array type if
12955 it will obviously be the same as T. */
12959 /* These checks should match the ones in create_array_type_for_decl.
12961 [temp.deduct]
12963 The deduction may fail for any of the following reasons:
12965 -- Attempting to create an array with an element type that
12966 is void, a function type, or a reference type, or [DR337]
12967 an abstract class type. */
12973 {
12977 }
12985 {
12988 }
12991 }
12994 {
13004 {
13008 }
13010 {
13011 /* Normally, make_typename_type does not require that the CTX
13012 have complete type in order to allow things like:
13014 template <class T> struct S { typename S<T>::X Y; };
13016 But, such constructs have already been resolved by this
13017 point, so here CTX really should have complete type, unless
13018 it's a partial instantiation. */
13021 {
13025 }
13026 }
13033 {
13036 }
13039 {
13041 {
13045 else
13047 }
13049 {
13053 else
13055 }
13056 }
13058 return cp_build_qualified_type_real
13060 }
13063 {
13075 }
13078 {
13079 tree type;
13095 complain);
13096 }
13099 {
13100 tree type;
13118 else
13119 {
13123 /* In a template ~id could be either a complement expression
13124 or an unqualified-id naming a destructor; if instantiating
13125 it produces an expression, it's not an id-expression or
13126 member access. */
13129 }
13134 }
13137 {
13141 }
13145 {
13147 tree packed_out =
13149 args,
13150 complain,
13151 in_decl);
13154 /* For template nontype argument packs, also substitute into
13155 the type. */
13160 }
13176 /* We should use one of the expression tsubsts for these codes. */
13182 }
13183 }
13185 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
13186 type of the expression on the left-hand side of the "." or "->"
13187 operator. */
13189 static tree
13192 {
13193 tree name;
13194 tree qualifying_scope;
13195 tree fns;
13196 tree optype;
13201 /* A baselink indicates a function from a base class. Both the
13202 BASELINK_ACCESS_BINFO and the base class referenced may
13203 indicate bases of the template class, rather than the
13204 instantiated class. In addition, lookups that were not
13205 ambiguous before may be ambiguous now. Therefore, we perform
13206 the lookup again. */
13213 {
13220 }
13228 /* If lookup found a single function, mark it as used at this
13229 point. (If it lookup found multiple functions the one selected
13230 later by overload resolution will be marked as used at that
13231 point.) */
13237 /* Add back the template arguments, if present. */
13242 template_args);
13243 /* Update the conversion operator type. */
13251 qualifying_scope,
13252 object_type);
13254 }
13256 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
13257 true if the qualified-id will be a postfix-expression in-and-of
13258 itself; false if more of the postfix-expression follows the
13259 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
13260 of "&". */
13262 static tree
13266 {
13267 tree expr;
13268 tree scope;
13269 tree name;
13271 tree template_args;
13276 /* Figure out what name to look up. */
13279 {
13287 }
13288 else
13289 {
13292 }
13294 /* Substitute into the qualifying scope. When there are no ARGS, we
13295 are just trying to simplify a non-dependent expression. In that
13296 case the qualifying scope may be dependent, and, in any case,
13297 substituting will not help. */
13300 {
13303 }
13304 else
13308 {
13313 }
13316 {
13318 {
13319 /* A BIT_NOT_EXPR is used to represent a destructor. */
13321 {
13325 }
13326 else
13329 }
13330 else
13334 {
13336 {
13340 }
13342 }
13343 }
13346 {
13348 scope);
13349 /* Remember that there was a reference to this entity. */
13351 }
13354 {
13360 }
13369 {
13370 expr = (adjust_result_of_qualified_name_lookup
13372 expr = (finish_qualified_id_expr
13376 }
13378 /* Expressions do not generally have reference type. */
13380 /* However, if we're about to form a pointer-to-member, we just
13381 want the referenced member referenced. */
13386 }
13388 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
13389 initializer, DECL is the substituted VAR_DECL. Other arguments are as
13390 for tsubst. */
13392 static tree
13395 {
13402 {
13403 /* If we had an initializer but it
13404 instantiated to nothing,
13405 value-initialize the object. This will
13406 only occur when the initializer was a
13407 pack expansion where the parameter packs
13408 used in that expansion were of length
13409 zero. */
13411 complain);
13414 }
13417 }
13419 /* Like tsubst, but deals with expressions. This function just replaces
13420 template parms; to finish processing the resultant expression, use
13421 tsubst_copy_and_build or tsubst_expr. */
13423 static tree
13425 {
13427 tree r;
13435 {
13440 {
13441 /* We get here for a use of 'this' in an NSDMI. */
13443 && current_function_decl
13447 /* This can happen for a parameter name used later in a function
13448 declaration (such as in a late-specified return type). Just
13449 make a dummy decl, since it's only used for its type. */
13452 /* Give it the template pattern as its context; its true context
13453 hasn't been instantiated yet and this is good enough for
13454 mangling. */
13456 }
13464 {
13465 tree enum_type;
13466 tree v;
13470 /* There is no need to substitute into namespace-scope
13471 enumerators. */
13474 /* If ARGS is NULL, then T is known to be non-dependent. */
13478 /* Unfortunately, we cannot just call lookup_name here.
13479 Consider:
13481 template <int I> int f() {
13482 enum E { a = I };
13483 struct S { void g() { E e = a; } };
13484 };
13486 When we instantiate f<7>::S::g(), say, lookup_name is not
13487 clever enough to find f<7>::a. */
13488 enum_type
13498 /* We didn't find the name. That should never happen; if
13499 name-lookup found it during preliminary parsing, we
13500 should find it again here during instantiation. */
13502 }
13507 {
13508 /* Check for a local specialization set up by
13509 tsubst_pack_expansion. */
13511 {
13515 }
13517 /* When retrieving a capture pack from a generic lambda, remove the
13518 lambda call op's own template argument list from ARGS. Only the
13519 template arguments active for the closure type should be used to
13520 retrieve the pack specialization. */
13526 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
13527 tsubst_decl put in the hash table. */
13529 }
13532 {
13533 tree ctx;
13538 {
13541 {
13545 }
13547 }
13548 }
13557 {
13560 {
13561 /* First try name lookup to find the instantiation. */
13564 {
13565 /* Make sure that the one we found is the one we want. */
13570 }
13574 else
13575 {
13576 /* This can happen for a variable used in a
13577 late-specified return type of a local lambda, or for a
13578 local static or constant. Building a new VAR_DECL
13579 should be OK in all those cases. */
13582 {
13583 /* We can't call cp_finish_decl, so handle the
13584 initializer by hand. */
13595 }
13600 {
13603 at_eof);
13605 /* A use of a local constant decays to its value.
13606 FIXME update for core DR 696. */
13608 }
13609 }
13610 /* Remember this for subsequent uses. */
13613 }
13614 }
13615 else
13624 /* An OVERLOAD will always be a non-dependent overload set; an
13625 overload set from function scope will just be represented with an
13626 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13642 {
13643 /* Template template argument like the following example need
13644 special treatment:
13646 template <template <class> class TT> struct C {};
13647 template <class T> struct D {
13648 template <class U> struct E {};
13649 C<E> c; // #1
13650 };
13651 D<int> d; // #2
13653 We are processing the template argument `E' in #1 for
13654 the template instantiation #2. Originally, `E' is a
13655 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13656 have to substitute this with one having context `D<int>'. */
13660 }
13661 else
13662 /* Ordinary template template argument. */
13673 {
13677 }
13681 {
13691 /* We only want to compute the number of arguments. */
13705 {
13712 else
13715 }
13716 else
13718 }
13720 {
13728 }
13729 /* Fall through */
13745 {
13749 }
13752 {
13753 tree object;
13754 tree name;
13759 {
13763 }
13766 {
13776 }
13781 in_decl);
13782 else
13785 }
13823 {
13827 }
13830 {
13835 }
13838 {
13842 }
13845 {
13853 }
13859 {
13866 }
13869 {
13876 }
13879 {
13886 }
13889 {
13890 /* Substituted template arguments */
13899 }
13902 {
13922 }
13949 /* Fall through. */
13952 {
13955 }
13956 else
13960 /* This is handled by tsubst_copy_and_build. */
13964 {
13968 }
13971 /* We shouldn't have built any of these during initial template
13972 generation. Instead, they should be built during instantiation
13973 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13977 {
13985 }
13988 // Expansions of variadic constraints are viable, expanding
13989 // to a conunction of the expanded terms.
14008 {
14009 /* Instantiate any typedefs in the type. */
14014 }
14017 /* These can sometimes show up in a partial instantiation, but never
14018 involve template parms. */
14023 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
14026 }
14027 }
14029 /* Like tsubst_copy, but specifically for OpenMP clauses. */
14031 static tree
14034 {
14038 {
14044 {
14047 {
14053 }
14054 /* FALLTHRU */
14082 {
14085 {
14092 }
14093 else
14095 }
14125 }
14126 }
14132 }
14134 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
14136 static tree
14138 tree in_decl)
14139 {
14140 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
14160 {
14163 else
14164 {
14168 }
14169 }
14174 #undef RECUR
14175 }
14177 /* Substitute one OMP_FOR iterator. */
14179 static void
14184 {
14185 #define RECUR(NODE) \
14186 tsubst_expr ((NODE), args, complain, in_decl, \
14187 integral_constant_expression_p)
14196 {
14197 /* We need to jump through some hoops to handle declarations in the
14198 for-init-statement, since we might need to handle auto deduction,
14199 but we need to keep control of initialization. */
14203 }
14204 else
14216 {
14218 {
14219 /* Declare the variable, but don't let that initialize it. */
14224 }
14229 {
14234 }
14235 else
14242 }
14245 {
14246 /* Declare and initialize the variable. */
14249 }
14251 {
14252 tree c;
14254 {
14265 }
14267 {
14272 {
14275 }
14276 }
14277 }
14280 {
14284 }
14285 else
14289 {
14300 {
14308 }
14309 else
14315 {
14321 }
14325 {
14333 }
14334 else
14340 }
14346 #undef RECUR
14347 }
14349 /* Like tsubst_copy for expressions, etc. but also does semantic
14350 processing. */
14352 tree
14355 {
14356 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
14357 #define RECUR(NODE) \
14358 tsubst_expr ((NODE), args, complain, in_decl, \
14359 integral_constant_expression_p)
14362 tree r;
14363 location_t loc;
14375 {
14377 {
14378 tree_stmt_iterator i;
14382 }
14397 else
14406 {
14408 tree init;
14414 {
14417 tree decl;
14425 else
14427 }
14429 {
14430 /* Don't build up decls for a variadic capture proxy, we'll
14431 instantiate the elements directly as needed. */
14433 }
14434 else
14435 {
14439 {
14440 /* By marking the declaration as instantiated, we avoid
14441 trying to instantiate it. Since instantiate_decl can't
14442 handle local variables, and since we've already done
14443 all that needs to be done, that's the right thing to
14444 do. */
14449 /* Anonymous aggregates are a special case. */
14452 {
14455 {
14459 }
14461 }
14467 {
14472 }
14473 else
14474 {
14479 {
14480 /* For __PRETTY_FUNCTION__ we have to adjust the
14481 initializer. */
14485 }
14486 else
14490 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
14493 }
14494 }
14495 }
14498 }
14513 {
14523 }
14550 {
14554 }
14562 else
14570 else
14591 {
14595 }
14599 {
14601 tree label;
14606 }
14612 /* Computed goto's must be tsubst'd into. On the other hand,
14613 non-computed gotos must not be; the identifier in question
14614 will have no binding. */
14616 else
14622 {
14638 }
14643 {
14648 }
14649 else
14650 {
14655 else
14662 else
14668 else
14670 }
14674 {
14678 {
14680 /* Prevent instantiate_decl from trying to instantiate
14681 this variable. We've already done all that needs to be
14682 done. */
14685 }
14690 }
14696 {
14697 /* Local classes are not independent templates; they are
14698 instantiated along with their containing function. And this
14699 way we don't have to deal with pushing out of one local class
14700 to instantiate a member of another local class. */
14701 tree fn;
14702 /* Closures are handled by the LAMBDA_EXPR. */
14708 }
14712 {
14713 tree condition;
14716 condition =
14718 args,
14727 }
14752 {
14761 {
14766 }
14778 integral_constant_expression_p);
14787 else
14788 {
14796 }
14799 }
14858 {
14863 {
14866 }
14872 }
14873 else
14874 {
14881 {
14884 }
14887 {
14892 {
14895 }
14901 }
14902 else
14903 {
14907 }
14910 }
14914 {
14920 {
14924 {
14929 }
14933 }
14934 else
14935 {
14940 }
14941 }
14945 {
14949 }
14952 // Expansions of variadic constraints are viable, expanding
14953 // to a conunction of the expanded terms.
14974 /* If the first operand was a statement, we're done with it. */
14978 complain));
14990 integral_constant_expression_p));
14991 }
14994 out:
14997 #undef RECUR
14998 #undef RETURN
14999 }
15001 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
15002 function. For description of the body see comment above
15003 cp_parser_omp_declare_reduction_exprs. */
15005 static void
15007 {
15013 tree_stmt_iterator tsi;
15024 {
15043 }
15045 {
15065 }
15066 }
15068 /* T is a postfix-expression that is not being used in a function
15069 call. Return the substituted version of T. */
15071 static tree
15073 tsubst_flags_t complain,
15074 tree in_decl)
15075 {
15079 else
15085 }
15087 /* Like tsubst but deals with expressions and performs semantic
15088 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
15090 tree
15092 tree args,
15093 tsubst_flags_t complain,
15094 tree in_decl,
15097 {
15098 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
15099 #define RECUR(NODE) \
15100 tsubst_copy_and_build (NODE, args, complain, in_decl, \
15102 integral_constant_expression_p)
15105 location_t loc;
15114 /* N3276 decltype magic only applies to calls at the top level or on the
15115 right side of a comma. */
15120 {
15123 /* Fall through. */
15125 {
15126 tree decl;
15127 cp_id_kind idk;
15132 {
15135 }
15137 /* Look up the name. */
15140 /* By convention, expressions use ERROR_MARK_NODE to indicate
15141 failure, not NULL_TREE. */
15147 integral_constant_expression_p,
15155 input_location);
15159 {
15163 }
15165 }
15168 {
15169 tree object;
15177 {
15180 }
15181 else
15184 {
15187 }
15188 else
15194 else
15196 }
15199 {
15203 {
15204 /* A type conversion to reference type will be enclosed in
15205 such an indirect ref, but the substitution of the cast
15206 will have also added such an indirect ref. */
15209 }
15210 else
15214 }
15217 {
15221 }
15224 {
15231 flags));
15232 }
15235 {
15239 }
15246 {
15247 tree type;
15253 {
15258 }
15264 {
15282 }
15285 }
15319 else
15321 in_decl);
15356 {
15361 tree r = build_x_binary_op
15363 op0,
15365 ? ERROR_MARK
15367 op1,
15369 ? ERROR_MARK
15377 }
15380 {
15384 }
15397 {
15406 }
15410 /* Fall through */
15413 {
15414 tree r;
15420 {
15421 /* When there are no ARGS, we are trying to evaluate a
15422 non-dependent expression from the parser. Trying to do
15423 the substitutions may not work. */
15426 }
15427 else
15428 {
15433 else
15436 /*integral_constant_expression_p=*/
15440 }
15444 else
15448 {
15450 {
15452 {
15456 }
15457 else
15461 }
15463 }
15465 }
15468 {
15478 }
15494 {
15498 tree r = build_x_modify_expr
15501 /* TREE_NO_WARNING must be set if either the expression was
15502 parenthesized or it uses an operator such as >>= rather
15503 than plain assignment. In the former case, it was already
15504 set and must be copied. In the latter case,
15505 build_x_modify_expr sets it and it must not be reset
15506 here. */
15511 }
15516 /* Remember that there was a reference to this entity. */
15522 {
15527 tree ret;
15531 else
15532 {
15536 }
15538 /* If there was an initializer in the original tree, but it
15539 instantiated to an empty list, then we should pass a
15540 non-NULL empty vector to tell build_new that it was an
15541 empty initializer() rather than no initializer. This can
15542 only happen when the initializer is a pack expansion whose
15543 parameter packs are of length zero. */
15546 else
15547 {
15551 else
15552 {
15555 }
15556 }
15562 complain);
15570 }
15573 {
15579 complain));
15580 }
15583 {
15587 integral_constant_expression_p);
15589 op0,
15592 }
15595 {
15596 tree function;
15601 tree ret;
15604 /* When we parsed the expression, we determined whether or
15605 not Koenig lookup should be performed. */
15608 {
15613 }
15615 {
15616 /* Do nothing; calling tsubst_copy_and_build on an identifier
15617 would incorrectly perform unqualified lookup again.
15619 Note that we can also have an IDENTIFIER_NODE if the earlier
15620 unqualified lookup found a member function; in that case
15621 koenig_p will be false and we do want to do the lookup
15622 again to find the instantiated member function.
15624 FIXME but doing that causes c++/15272, so we need to stop
15625 using IDENTIFIER_NODE in that situation. */
15627 }
15628 else
15629 {
15631 {
15637 }
15638 else
15643 /* Avoid error about taking the address of a constructor. */
15647 in_decl,
15649 integral_constant_expression_p);
15653 }
15658 {
15663 else
15664 {
15665 /* Expand the pack expansion and push each entry onto
15666 CALL_ARGS. */
15669 {
15674 {
15679 }
15680 }
15681 else
15682 {
15683 /* A partial substitution. Add one entry. */
15685 }
15686 }
15687 }
15689 /* We do not perform argument-dependent lookup if normal
15690 lookup finds a non-function, in accordance with the
15691 expected resolution of DR 218. */
15694 /* If lookup found a member function, the Koenig lookup is
15695 not appropriate, even if an unqualified-name was used
15696 to denote the function. */
15699 /* Only do this when substitution turns a dependent call
15700 into a non-dependent call. */
15707 {
15709 {
15710 /* For backwards compatibility and good diagnostics, try
15711 the unqualified lookup again if we aren't in SFINAE
15712 context. */
15713 tree unq = (tsubst_copy_and_build
15715 integral_constant_expression_p));
15720 {
15729 "%qD was not declared in this scope, "
15730 "and no declarations were found by "
15731 "argument-dependent lookup at the point "
15733 {
15737 {
15739 input_location);
15741 "declarations in dependent base %qT are "
15747 else
15751 }
15752 else
15755 }
15757 }
15758 }
15760 {
15765 }
15766 }
15768 /* Remember that there was a reference to this entity. */
15772 /* Put back tf_decltype for the actual call. */
15777 complain);
15779 {
15794 complain);
15795 else
15796 ret = (build_new_method_call
15801 complain));
15802 }
15803 else
15806 koenig_p,
15807 complain);
15812 }
15815 {
15821 {
15823 {
15828 }
15829 else
15830 {
15835 }
15837 }
15838 else
15839 {
15842 }
15846 }
15849 {
15854 input_location));
15855 }
15858 {
15866 {
15867 /* We have pack expansions, so expand those and
15868 create a new list out of it. */
15871 tree chain;
15874 /* Expand the argument expressions. */
15882 /* Build the rest of the list. */
15887 /* Determine the number of arguments. */
15889 {
15892 }
15895 else
15896 {
15897 /* Since we only performed a partial substitution into
15898 the argument pack, we only RETURN (a single list
15899 node. */
15906 }
15908 /* Convert the argument vectors into a TREE_LIST */
15911 {
15912 /* Grab the Ith values. */
15913 i--;
15916 value
15920 /* Build the list (backwards). */
15922 }
15925 }
15941 }
15944 {
15945 tree object;
15946 tree object_type;
15947 tree member;
15948 tree r;
15952 /* Remember that there was a reference to this entity. */
15962 else
15970 {
15972 {
15977 {
15980 }
15982 {
15987 }
15988 }
15989 }
15992 {
15993 /* Lookup the template functions now that we know what the
15994 scope is. */
16002 {
16005 args);
16006 member = (adjust_result_of_qualified_name_lookup
16008 object_type));
16009 }
16010 else
16011 {
16013 input_location);
16015 }
16016 }
16020 {
16022 {
16026 else
16029 }
16031 }
16033 {
16038 }
16042 complain);
16046 }
16053 {
16061 tree r;
16066 /* digest_init will do the wrong thing if we let it. */
16070 /* We do not want to process the index of aggregate
16071 initializers as they are identifier nodes which will be
16072 looked up by digest_init. */
16078 {
16080 /* An identifier index is looked up in the type
16081 being initialized, not the current scope. */
16086 {
16087 /* Substitute into the pack expansion. */
16089 in_decl);
16093 ;
16095 /* Just move the argument into place. */
16097 else
16098 {
16099 /* Update the length of the final CONSTRUCTOR
16100 arguments vector, and note that we will need to
16101 copy.*/
16104 }
16105 }
16106 else
16108 }
16111 {
16116 {
16118 {
16123 }
16124 else
16126 }
16127 }
16137 }
16140 {
16143 {
16146 }
16147 else
16148 {
16151 }
16152 }
16158 {
16159 /* We don't build decls for an instantiation of a
16160 variadic capture proxy, we instantiate the elements
16161 when needed. */
16164 }
16165 /* Fall through */
16168 {
16170 /* ??? We're doing a subset of finish_id_expression here. */
16172 && !processing_template_decl
16173 && !cp_unevaluated_operand
16176 {
16178 /* Replace an evaluated use of the thread_local variable with
16179 a call to its wrapper. */
16181 }
16186 /* If the original type was a reference, we'll be wrapped in
16187 the appropriate INDIRECT_REF. */
16191 }
16194 {
16198 }
16205 {
16216 }
16219 {
16225 integral_constant_expression_p);
16229 /* If the resulting list of expression statement is empty,
16230 fold it further into void_node. */
16235 }
16238 {
16252 /* For a function scope, we want to use tsubst so that we don't
16253 complain about referring to an auto function before its return
16254 type has been deduced. Otherwise, we want to use tsubst_copy so
16255 that we look up the existing field/parameter/variable rather
16256 than build a new one. */
16261 {
16262 /* Look up the parameter we want directly, as tsubst_copy
16263 doesn't do what we need. */
16269 /* FIXME Work around the parm not having DECL_CONTEXT set. */
16272 }
16273 else
16282 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
16284 /* Now that we know visibility, instantiate the type so we have a
16285 declaration of the op() for later calls to lambda_function. */
16291 }
16294 /* We can get here for a constant initializer of non-dependent type.
16295 FIXME stop folding in cp_parser_initializer_clause. */
16296 {
16298 complain);
16300 }
16304 integral_constant_expression_p));
16310 {
16315 complain));
16316 }
16322 /* Handle Objective-C++ constructs, if appropriate. */
16323 {
16324 tree subst
16329 }
16331 }
16333 #undef RECUR
16334 #undef RETURN
16335 out:
16338 }
16340 /* Verify that the instantiated ARGS are valid. For type arguments,
16341 make sure that the type's linkage is ok. For non-type arguments,
16342 make sure they are constants if they are integral or enumerations.
16343 Emit an error under control of COMPLAIN, and return TRUE on error. */
16345 static bool
16347 {
16351 {
16361 }
16363 {
16364 /* [basic.link]: A name with no linkage (notably, the name
16365 of a class or enumeration declared in a local scope)
16366 shall not be used to declare an entity with linkage.
16367 This implies that names with no linkage cannot be used as
16368 template arguments
16370 DR 757 relaxes this restriction for C++0x. */
16375 {
16376 /* DR 488 makes use of a type with no linkage cause
16377 type deduction to fail. */
16379 {
16382 else
16385 }
16387 }
16388 /* In order to avoid all sorts of complications, we do not
16389 allow variably-modified types as template arguments. */
16391 {
16395 }
16396 }
16397 /* Class template and alias template arguments should be OK. */
16399 ;
16400 /* A non-type argument of integral or enumerated type must be a
16401 constant. */
16406 {
16410 }
16412 }
16414 static bool
16416 {
16421 {
16424 }
16428 }
16430 /* We're out of SFINAE context now, so generate diagnostics for the access
16431 errors we saw earlier when instantiating D from TMPL and ARGS. */
16433 static void
16435 {
16447 }
16449 /* Instantiate the indicated variable, function, or alias template TMPL with
16450 the template arguments in TARG_PTR. */
16452 static tree
16454 {
16456 tree fndecl;
16457 tree gen_tmpl;
16458 tree spec;
16466 /* If this function is a clone, handle it specially. */
16468 {
16469 tree spec;
16470 tree clone;
16472 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
16473 DECL_CLONED_FUNCTION. */
16479 /* Look for the clone. */
16483 /* We should always have found the clone by now. */
16486 }
16491 /* Check to see if we already have this specialization. */
16494 /* The TMPL is a partial instantiation. To get a full set of
16495 arguments we must add the arguments used to perform the
16496 partial instantiation. */
16498 targ_ptr);
16500 /* It would be nice to avoid hashing here and then again in tsubst_decl,
16501 but it doesn't seem to be on the hot path. */
16510 {
16512 {
16516 }
16518 }
16521 complain))
16524 /* We are building a FUNCTION_DECL, during which the access of its
16525 parameters and return types have to be checked. However this
16526 FUNCTION_DECL which is the desired context for access checking
16527 is not built yet. We solve this chicken-and-egg problem by
16528 deferring all checks until we have the FUNCTION_DECL. */
16531 /* Instantiation of the function happens in the context of the function
16532 template, not the context of the overload resolution we're doing. */
16534 /* If there are dependent arguments, e.g. because we're doing partial
16535 ordering, make sure processing_template_decl stays set. */
16539 {
16543 }
16548 {
16549 /* We need to determine if we're using a partial or explicit
16550 specialization now, because the type of the variable could be
16551 different. */
16557 {
16561 }
16562 }
16564 /* Substitute template parameters to obtain the specialization. */
16571 {
16574 }
16576 /* The DECL_TI_TEMPLATE should always be the immediate parent
16577 template, not the most general template. */
16580 /* Now we know the specialization, compute access previously
16581 deferred. */
16588 /* If we've just instantiated the main entry point for a function,
16589 instantiate all the alternate entry points as well. We do this
16590 by cloning the instantiation of the main entry point, not by
16591 instantiating the template clones. */
16596 {
16598 {
16599 /* Remember to reinstantiate when we're out of SFINAE so the user
16600 can see the errors. */
16602 }
16604 }
16606 }
16608 /* Wrapper for instantiate_template_1. */
16610 tree
16612 {
16613 tree ret;
16618 }
16620 /* Instantiate the alias template TMPL with ARGS. Also push a template
16621 instantiation level, which instantiate_template doesn't do because
16622 functions and variables have sufficient context established by the
16623 callers. */
16625 static tree
16627 {
16634 {
16637 }
16639 args =
16647 /* We can't free this if a pending_template entry or last_error_tinst_level
16648 is pointing at it. */
16652 }
16655 }
16657 /* PARM is a template parameter pack for FN. Returns true iff
16658 PARM is used in a deducible way in the argument list of FN. */
16660 static bool
16662 {
16665 {
16667 tree packs;
16673 {
16674 /* The template parameter pack is used in a function parameter
16675 pack. If this is the end of the parameter list, the
16676 template parameter pack is deducible. */
16679 else
16680 /* Otherwise, not. Well, it could be deduced from
16681 a non-pack parameter, but doing so would end up with
16682 a deduction mismatch, so don't bother. */
16684 }
16685 }
16686 /* The template parameter pack isn't used in any function parameter
16687 packs, but it might be used deeper, e.g. tuple<Args...>. */
16689 }
16691 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16692 NARGS elements of the arguments that are being used when calling
16693 it. TARGS is a vector into which the deduced template arguments
16694 are placed.
16696 Returns either a FUNCTION_DECL for the matching specialization of FN or
16697 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16698 true, diagnostics will be printed to explain why it failed.
16700 If FN is a conversion operator, or we are trying to produce a specific
16701 specialization, RETURN_TYPE is the return type desired.
16703 The EXPLICIT_TARGS are explicit template arguments provided via a
16704 template-id.
16706 The parameter STRICT is one of:
16708 DEDUCE_CALL:
16709 We are deducing arguments for a function call, as in
16710 [temp.deduct.call].
16712 DEDUCE_CONV:
16713 We are deducing arguments for a conversion function, as in
16714 [temp.deduct.conv].
16716 DEDUCE_EXACT:
16717 We are deducing arguments when doing an explicit instantiation
16718 as in [temp.explicit], when determining an explicit specialization
16719 as in [temp.expl.spec], or when taking the address of a function
16720 template, as in [temp.deduct.funcaddr]. */
16722 tree
16724 tree explicit_targs,
16725 tree targs,
16728 tree return_type,
16729 unification_kind_t strict,
16733 {
16734 tree parms;
16735 tree fntype;
16743 tree tinst;
16749 /* In C++0x, it's possible to have a function template whose type depends
16750 on itself recursively. This is most obvious with decltype, but can also
16751 occur with enumeration scope (c++/48969). So we need to catch infinite
16752 recursion and reject the substitution at deduction time; this function
16753 will return error_mark_node for any repeated substitution.
16755 This also catches excessive recursion such as when f<N> depends on
16756 f<N-1> across all integers, and returns error_mark_node for all the
16757 substitutions back up to the initial one.
16759 This is, of course, not reentrant. */
16769 {
16770 /* [temp.deduct]
16772 The specified template arguments must match the template
16773 parameters in kind (i.e., type, nontype, template), and there
16774 must not be more arguments than there are parameters;
16775 otherwise type deduction fails.
16777 Nontype arguments must match the types of the corresponding
16778 nontype template parameters, or must be convertible to the
16779 types of the corresponding nontype parameters as specified in
16780 _temp.arg.nontype_, otherwise type deduction fails.
16782 All references in the function type of the function template
16783 to the corresponding template parameters are replaced by the
16784 specified template argument values. If a substitution in a
16785 template parameter or in the function type of the function
16786 template results in an invalid type, type deduction fails. */
16791 /* Adjust any explicit template arguments before entering the
16792 substitution context. */
16793 explicit_targs
16795 complain,
16801 /* Substitute the explicit args into the function type. This is
16802 necessary so that, for instance, explicitly declared function
16803 arguments can match null pointed constants. If we were given
16804 an incomplete set of explicit args, we must not do semantic
16805 processing during substitution as we could create partial
16806 instantiations. */
16808 {
16813 /* Dig out the actual parm. */
16816 {
16819 }
16821 {
16824 }
16827 /* No explicit argument for this template parameter. */
16831 {
16832 /* Mark the argument pack as "incomplete". We could
16833 still deduce more arguments during unification.
16834 We remove this mark in type_unification_real. */
16836 {
16840 }
16842 /* We have some incomplete argument packs. */
16844 }
16845 }
16849 {
16852 }
16855 /* Ignore any access checks; we'll see them again in
16856 instantiate_template and they might have the wrong
16857 access path at this point. */
16869 /* Place the explicitly specified arguments in TARGS. */
16872 }
16874 /* Never do unification on the 'this' parameter. */
16878 {
16887 }
16889 /* We allow incomplete unification without an error message here
16890 because the standard doesn't seem to explicitly prohibit it. Our
16891 callers must be ready to deal with unification failures in any
16892 event. */
16895 /* If we aren't explaining yet, push tinst context so we can see where
16896 any errors (e.g. from class instantiations triggered by instantiation
16897 of default template arguments) come from. If we are explaining, this
16898 context is redundant. */
16900 {
16903 }
16905 /* type_unification_real will pass back any access checks from default
16906 template argument substitution. */
16918 /* Now that we have bindings for all of the template arguments,
16919 ensure that the arguments deduced for the template template
16920 parameters have compatible template parameter lists. We cannot
16921 check this property before we have deduced all template
16922 arguments, because the template parameter types of a template
16923 template parameter might depend on prior template parameters
16924 deduced after the template template parameter. The following
16925 ill-formed example illustrates this issue:
16927 template<typename T, template<T> class C> void f(C<5>, T);
16929 template<int N> struct X {};
16931 void g() {
16932 f(X<5>(), 5l); // error: template argument deduction fails
16933 }
16935 The template parameter list of 'C' depends on the template type
16936 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16937 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16938 time that we deduce 'C'. */
16941 {
16944 }
16946 /* All is well so far. Now, check:
16948 [temp.deduct]
16950 When all template arguments have been deduced, all uses of
16951 template parameters in nondeduced contexts are replaced with
16952 the corresponding deduced argument values. If the
16953 substitution results in an invalid type, as described above,
16954 type deduction fails. */
16957 {
16960 }
16962 /* Also collect access checks from the instantiation. */
16975 /* Now perform any access checks encountered during substitution. */
16982 /* If we're looking for an exact match, check that what we got
16983 is indeed an exact match. It might not be if some template
16984 parameters are used in non-deduced contexts. But don't check
16985 for an exact match if we have dependent template arguments;
16986 in that case we're doing partial ordering, and we already know
16987 that we have two candidates that will provide the actual type. */
16989 {
16993 tree sarg
16999 {
17003 }
17004 }
17008 fail:
17011 {
17013 /* Reset once we're all the way out. */
17015 }
17017 /* We can't free this if a pending_template entry or last_error_tinst_level
17018 is pointing at it. */
17022 }
17025 }
17027 /* Adjust types before performing type deduction, as described in
17028 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
17029 sections are symmetric. PARM is the type of a function parameter
17030 or the return type of the conversion function. ARG is the type of
17031 the argument passed to the call, or the type of the value
17032 initialized with the result of the conversion function.
17033 ARG_EXPR is the original argument expression, which may be null. */
17035 static int
17039 tree arg_expr)
17040 {
17044 {
17049 {
17050 /* Swap PARM and ARG throughout the remainder of this
17051 function; the handling is precisely symmetric since PARM
17052 will initialize ARG rather than vice versa. */
17057 }
17060 /* Core issue #873: Do the DR606 thing (see below) for these cases,
17061 too, but here handle it by stripping the reference from PARM
17062 rather than by adding it to ARG. */
17070 /* Nothing else to do in this case. */
17075 }
17078 {
17079 /* [temp.deduct.call]
17081 If P is not a reference type:
17083 --If A is an array type, the pointer type produced by the
17084 array-to-pointer standard conversion (_conv.array_) is
17085 used in place of A for type deduction; otherwise,
17087 --If A is a function type, the pointer type produced by
17088 the function-to-pointer standard conversion
17089 (_conv.func_) is used in place of A for type deduction;
17090 otherwise,
17092 --If A is a cv-qualified type, the top level
17093 cv-qualifiers of A's type are ignored for type
17094 deduction. */
17099 else
17101 }
17103 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
17104 of the form T&&, where T is a template parameter, and the argument
17105 is an lvalue, T is deduced as A& */
17111 /* try_one_overload doesn't provide an arg_expr, but
17112 functions are always lvalues. */
17116 /* [temp.deduct.call]
17118 If P is a cv-qualified type, the top level cv-qualifiers
17119 of P's type are ignored for type deduction. If P is a
17120 reference type, the type referred to by P is used for
17121 type deduction. */
17124 {
17127 }
17129 /* DR 322. For conversion deduction, remove a reference type on parm
17130 too (which has been swapped into ARG). */
17135 }
17137 /* Subroutine of unify_one_argument. PARM is a function parameter of a
17138 template which does contain any deducible template parameters; check if
17139 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
17140 unify_one_argument. */
17142 static int
17145 {
17146 tree type;
17150 else
17157 {
17161 }
17163 {
17168 }
17172 else
17174 }
17178 /* Returns true iff the expression EXPR is one from which a template
17179 argument can be deduced. In other words, if it's an undecorated
17180 use of a template non-type parameter. */
17182 static bool
17184 {
17186 }
17188 /* Returns true iff the array domain DOMAIN uses a template parameter in a
17189 deducible way; that is, if it has a max value of <PARM> - 1. */
17191 static bool
17193 {
17202 }
17204 /* Returns true iff the template arguments ARGS use a template parameter
17205 in a deducible way. */
17207 static bool
17209 {
17211 {
17216 else
17217 {
17224 else
17226 }
17229 }
17231 }
17233 /* Returns true iff TYPE contains any deducible references to template
17234 parameters, as per 14.8.2.5. */
17236 static bool
17238 {
17242 /* T
17243 cv-list T
17244 TT<T>
17245 TT<i>
17246 TT<> */
17251 /* T*
17252 T&
17253 T&& */
17257 /* T[integer-constant ]
17258 type [i] */
17263 /* T type ::*
17264 type T::*
17265 T T::*
17266 T (type ::*)()
17267 type (T::*)()
17268 type (type ::*)(T)
17269 type (T::*)(T)
17270 T (type ::*)(T)
17271 T (T::*)()
17272 T (T::*)(T) */
17275 || (uses_deducible_template_parms
17278 /* template-name <T> (where template-name refers to a class template)
17279 template-name <i> (where template-name refers to a class template) */
17286 /* type (T)
17287 T()
17288 T(T) */
17291 {
17300 }
17303 }
17305 /* Subroutine of type_unification_real and unify_pack_expansion to
17306 handle unification of a single P/A pair. Parameters are as
17307 for those functions. */
17309 static int
17313 {
17320 /* We can't deduce anything from this, but we might get all the
17321 template args from other function args. */
17324 /* Implicit conversions (Clause 4) will be performed on a function
17325 argument to convert it to the type of the corresponding function
17326 parameter if the parameter type contains no template-parameters that
17327 participate in template argument deduction. */
17329 /* For function parameters that contain no template-parameters at all,
17330 we have historically checked for convertibility in order to shortcut
17331 consideration of this candidate. */
17333 explain_p);
17336 /* For function parameters with only non-deducible template parameters,
17337 just return. */
17341 {
17343 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
17344 | UNIFY_ALLOW_MORE_CV_QUAL
17358 }
17360 /* We only do these transformations if this is the top-level
17361 parameter_type_list in a call or declaration matching; in other
17362 situations (nested function declarators, template argument lists) we
17363 won't be comparing a type to an expression, and we don't do any type
17364 adjustments. */
17366 {
17368 {
17371 {
17372 /* [temp.deduct.type] A template-argument can be
17373 deduced from a pointer to function or pointer
17374 to member function argument if the set of
17375 overloaded functions does not contain function
17376 templates and at most one of a set of
17377 overloaded functions provides a unique
17378 match. */
17385 }
17391 }
17393 arg_strict |=
17395 }
17396 else
17401 /* For deduction from an init-list we need the actual list. */
17405 }
17407 /* Most parms like fn_type_unification.
17409 If SUBR is 1, we're being called recursively (to unify the
17410 arguments of a function or method parameter of a function
17411 template).
17413 CHECKS is a pointer to a vector of access checks encountered while
17414 substituting default template arguments. */
17416 static int
17418 tree targs,
17419 tree xparms,
17423 unification_kind_t strict,
17427 {
17432 tree parms;
17441 /* Reset the number of non-defaulted template arguments contained
17442 in TARGS. */
17445 again:
17453 {
17458 /* For a function parameter pack that occurs at the end of the
17459 parameter-declaration-list, the type A of each remaining
17460 argument of the call is compared with the type P of the
17461 declarator-id of the function parameter pack. */
17467 /* For a function parameter pack that does not occur at the
17468 end of the parameter-declaration-list, the type of the
17469 parameter pack is a non-deduced context. */
17478 }
17483 {
17484 /* Unify the remaining arguments with the pack expansion type. */
17485 tree argvec;
17488 /* Allocate a TREE_VEC and copy in all of the arguments */
17493 /* Copy the parameter into parmvec. */
17499 /* Advance to the end of the list of parameters. */
17501 }
17503 /* Fail if we've reached the end of the parm list, and more args
17504 are present, and the parm list isn't variadic. */
17507 /* Fail if parms are left and they don't have default values and
17508 they aren't all deduced as empty packs (c++/57397). This is
17509 consistent with sufficient_parms_p. */
17512 {
17516 do
17517 {
17520 count++;
17522 }
17526 type_pack_p);
17527 }
17530 {
17531 tsubst_flags_t complain = (explain_p
17532 ? tf_warning_or_error
17536 {
17540 /* Clear the "incomplete" flags on all argument packs now so that
17541 substituting them into later default arguments works. */
17543 {
17546 }
17552 /* If this is an undeduced nontype parameter that depends on
17553 a type parameter, try another pass; its type may have been
17554 deduced from a later argument than the one from which
17555 this parameter can be deduced. */
17561 /* Core issue #226 (C++0x) [temp.deduct]:
17563 If a template argument has not been deduced, its
17564 default template argument, if any, is used.
17566 When we are in C++98 mode, TREE_PURPOSE will either
17567 be NULL_TREE or ERROR_MARK_NODE, so we do not need
17568 to explicitly check cxx_dialect here. */
17570 {
17585 else
17586 {
17588 /* The position of the first default template argument,
17589 is also the number of non-defaulted arguments in TARGS.
17590 Record that. */
17594 }
17595 }
17597 /* If the type parameter is a parameter pack, then it will
17598 be deduced to an empty parameter pack. */
17600 {
17601 tree arg;
17604 {
17608 }
17609 else
17616 }
17619 }
17620 }
17621 #ifdef ENABLE_CHECKING
17624 #endif
17627 }
17629 /* Subroutine of type_unification_real. Args are like the variables
17630 at the call site. ARG is an overloaded function (or template-id);
17631 we try deducing template args from each of the overloads, and if
17632 only one succeeds, we go with that. Modifies TARGS and returns
17633 true on success. */
17635 static bool
17637 tree targs,
17638 tree parm,
17639 tree arg,
17640 unification_kind_t strict,
17643 {
17650 {
17653 }
17654 else
17658 /* Handle `&x' where `x' is some static or non-static member
17659 function name. */
17665 /* Strip baselink information. */
17670 {
17671 /* If we got some explicit template args, we need to plug them into
17672 the affected templates before we try to unify, in case the
17673 explicit args will completely resolve the templates in question. */
17680 {
17693 {
17698 {
17701 }
17702 }
17705 }
17706 /* If no templates (or more than one) are fully resolved by the
17707 explicit arguments, this template-id is a non-deduced context; it
17708 could still be OK if we deduce all template arguments for the
17709 enclosing call through other arguments. */
17712 }
17715 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17716 -- but the deduction does not succeed because the expression is
17717 not just the function on its own. */
17719 else
17725 {
17728 }
17730 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17731 to function or pointer to member function argument if the set of
17732 overloaded functions does not contain function templates and at most
17733 one of a set of overloaded functions provides a unique match.
17735 So if we found multiple possibilities, we return success but don't
17736 deduce anything. */
17739 {
17743 {
17748 /* Don't forget explicit template arguments in a pack. */
17752 }
17753 }
17758 }
17760 /* Core DR 115: In contexts where deduction is done and fails, or in
17761 contexts where deduction is not done, if a template argument list is
17762 specified and it, along with any default template arguments, identifies
17763 a single function template specialization, then the template-id is an
17764 lvalue for the function template specialization. */
17766 tree
17768 {
17781 {
17784 }
17786 {
17789 }
17791 {
17794 }
17797 {
17801 /* If we got some explicit template args, we need to plug them into
17802 the affected templates before we try to unify, in case the
17803 explicit args will completely resolve the templates in question. */
17811 {
17824 {
17827 {
17830 }
17832 {
17835 }
17836 }
17837 }
17839 {
17847 {
17848 tree base
17851 }
17855 }
17857 /* There were no good options and at least one bad one, so let the
17858 user know what the problem is. */
17860 }
17862 }
17864 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17865 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17866 different overloads deduce different arguments for a given parm.
17867 ADDR_P is true if the expression for which deduction is being
17868 performed was of the form "& fn" rather than simply "fn".
17870 Returns 1 on success. */
17872 static int
17874 tree orig_targs,
17875 tree targs,
17876 tree parm,
17877 tree arg,
17878 unification_kind_t strict,
17882 {
17884 tree tempargs;
17890 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17891 to function or pointer to member function argument if the set of
17892 overloaded functions does not contain function templates and at most
17893 one of a set of overloaded functions provides a unique match.
17895 So if this is a template, just return success. */
17907 /* We don't copy orig_targs for this because if we have already deduced
17908 some template args from previous args, unify would complain when we
17909 try to deduce a template parameter for the same argument, even though
17910 there isn't really a conflict. */
17917 /* First make sure we didn't deduce anything that conflicts with
17918 explicitly specified args. */
17920 {
17927 /* Since we're unifying against ourselves, we will fill in
17928 template args used in the function parm list with our own
17929 template parms. Discard them. */
17933 }
17936 {
17941 }
17944 }
17946 /* PARM is a template class (perhaps with unbound template
17947 parameters). ARG is a fully instantiated type. If ARG can be
17948 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17949 TARGS are as for unify. */
17951 static tree
17954 {
17955 tree copy_of_targs;
17962 /* We need to make a new template argument vector for the call to
17963 unify. If we used TARGS, we'd clutter it up with the result of
17964 the attempted unification, even if this class didn't work out.
17965 We also don't want to commit ourselves to all the unifications
17966 we've already done, since unification is supposed to be done on
17967 an argument-by-argument basis. In other words, consider the
17968 following pathological case:
17970 template <int I, int J, int K>
17971 struct S {};
17973 template <int I, int J>
17974 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17976 template <int I, int J, int K>
17977 void f(S<I, J, K>, S<I, I, I>);
17979 void g() {
17980 S<0, 0, 0> s0;
17981 S<0, 1, 2> s2;
17983 f(s0, s2);
17984 }
17986 Now, by the time we consider the unification involving `s2', we
17987 already know that we must have `f<0, 0, 0>'. But, even though
17988 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17989 because there are two ways to unify base classes of S<0, 1, 2>
17990 with S<I, I, I>. If we kept the already deduced knowledge, we
17991 would reject the possibility I=1. */
17994 /* If unification failed, we're done. */
18000 }
18002 /* Given a template type PARM and a class type ARG, find the unique
18003 base type in ARG that is an instance of PARM. We do not examine
18004 ARG itself; only its base-classes. If there is not exactly one
18005 appropriate base class, return NULL_TREE. PARM may be the type of
18006 a partial specialization, as well as a plain template type. Used
18007 by unify. */
18009 static enum template_base_result
18012 {
18014 tree binfo;
18020 {
18021 /* The type could not be completed. */
18024 }
18026 /* Walk in inheritance graph order. The search order is not
18027 important, and this avoids multiple walks of virtual bases. */
18029 {
18034 {
18035 /* If there is more than one satisfactory baseclass, then:
18037 [temp.deduct.call]
18039 If they yield more than one possible deduced A, the type
18040 deduction fails.
18042 applies. */
18044 {
18047 }
18050 }
18051 }
18055 }
18057 /* Returns the level of DECL, which declares a template parameter. */
18059 static int
18061 {
18063 {
18073 }
18075 }
18077 /* Decide whether ARG can be unified with PARM, considering only the
18078 cv-qualifiers of each type, given STRICT as documented for unify.
18079 Returns nonzero iff the unification is OK on that basis. */
18081 static int
18083 {
18089 {
18090 /* Although a CVR qualifier is ignored when being applied to a
18091 substituted template parameter ([8.3.2]/1 for example), that
18092 does not allow us to unify "const T" with "int&" because both
18093 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
18094 It is ok when we're allowing additional CV qualifiers
18095 at the outer level [14.8.2.1]/3,1st bullet. */
18105 }
18116 }
18118 /* Determines the LEVEL and INDEX for the template parameter PARM. */
18119 void
18121 {
18125 {
18128 }
18129 else
18130 {
18133 }
18134 }
18136 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
18137 do { \
18138 if (unify (TP, TA, P, A, S, EP)) \
18139 return 1; \
18140 } while (0);
18142 /* Unifies the remaining arguments in PACKED_ARGS with the pack
18143 expansion at the end of PACKED_PARMS. Returns 0 if the type
18144 deduction succeeds, 1 otherwise. STRICT is the same as in
18145 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
18146 call argument list. We'll need to adjust the arguments to make them
18147 types. SUBR tells us if this is from a recursive call to
18148 type_unification_real, or for comparing two template argument
18149 lists. */
18151 static int
18155 {
18156 tree parm
18166 /* Determine the parameter packs we will be deducing from the
18167 pattern, and record their current deductions. */
18170 {
18174 /* Determine the index and level of this parameter pack. */
18177 /* Keep track of the parameter packs and their corresponding
18178 argument packs. */
18181 }
18183 /* Loop through all of the arguments that have not yet been
18184 unified and unify each with the pattern. */
18186 {
18187 tree parm;
18191 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
18192 or the element of its argument pack at the current index if
18193 this argument was explicitly specified. */
18195 {
18204 {
18207 }
18209 }
18211 /* If we had explicit template arguments, substitute them into the
18212 pattern before deduction. */
18214 {
18215 /* Some arguments might still be unspecified or dependent. */
18223 NULL_TREE);
18228 }
18229 else
18232 /* Unify the pattern with the current argument. */
18237 /* For each parameter pack, collect the deduced value. */
18239 {
18245 }
18246 }
18248 /* Verify that the results of unification with the parameter packs
18249 produce results consistent with what we've seen before, and make
18250 the deduced argument packs available. */
18252 {
18259 /* By default keep the original deduced argument pack.
18260 If necessary, more specific code is going to update the
18261 resulting deduced argument later down in this function. */
18265 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
18266 actually deduce anything. */
18274 {
18275 /* If we had fewer function args than explicit template args,
18276 just use the explicits. */
18281 }
18284 {
18285 tree result;
18286 /* Build the deduced *_ARGUMENT_PACK. */
18288 {
18293 }
18294 else
18299 /* Note the deduced argument packs for this parameter
18300 pack. */
18302 }
18306 {
18307 /* We only had the explicitly-provided arguments before, but
18308 now we have a complete set of arguments. */
18314 }
18315 else
18316 {
18322 /* Inconsistent unification of this parameter pack. */
18324 bad_old_arg,
18325 bad_new_arg);
18326 }
18327 }
18330 }
18332 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
18333 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
18334 parameters and return value are as for unify. */
18336 static int
18340 {
18341 tree parm_max;
18342 tree arg_max;
18346 /* Our representation of array types uses "N - 1" as the
18347 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
18348 not an integer constant. We cannot unify arbitrarily
18349 complex expressions, so we eliminate the MINUS_EXPRs
18350 here. */
18354 {
18357 }
18361 {
18362 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
18363 trying to unify the type of a variable with the type
18364 of a template parameter. For example:
18366 template <unsigned int N>
18367 void f (char (&) [N]);
18368 int g();
18369 void h(int i) {
18370 char a[g(i)];
18371 f(a);
18372 }
18374 Here, the type of the ARG will be "int [g(i)]", and
18375 may be a SAVE_EXPR, etc. */
18379 }
18381 /* If only one of the bounds used a MINUS_EXPR, compensate
18382 by adding one to the other bound. */
18385 integer_type_node,
18386 parm_max,
18387 integer_one_node);
18390 integer_type_node,
18391 arg_max,
18392 integer_one_node);
18396 }
18398 /* Deduce the value of template parameters. TPARMS is the (innermost)
18399 set of template parameters to a template. TARGS is the bindings
18400 for those template parameters, as determined thus far; TARGS may
18401 include template arguments for outer levels of template parameters
18402 as well. PARM is a parameter to a template function, or a
18403 subcomponent of that parameter; ARG is the corresponding argument.
18404 This function attempts to match PARM with ARG in a manner
18405 consistent with the existing assignments in TARGS. If more values
18406 are deduced, then TARGS is updated.
18408 Returns 0 if the type deduction succeeds, 1 otherwise. The
18409 parameter STRICT is a bitwise or of the following flags:
18411 UNIFY_ALLOW_NONE:
18412 Require an exact match between PARM and ARG.
18413 UNIFY_ALLOW_MORE_CV_QUAL:
18414 Allow the deduced ARG to be more cv-qualified (by qualification
18415 conversion) than ARG.
18416 UNIFY_ALLOW_LESS_CV_QUAL:
18417 Allow the deduced ARG to be less cv-qualified than ARG.
18418 UNIFY_ALLOW_DERIVED:
18419 Allow the deduced ARG to be a template base class of ARG,
18420 or a pointer to a template base class of the type pointed to by
18421 ARG.
18422 UNIFY_ALLOW_INTEGER:
18423 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
18424 case for more information.
18425 UNIFY_ALLOW_OUTER_LEVEL:
18426 This is the outermost level of a deduction. Used to determine validity
18427 of qualification conversions. A valid qualification conversion must
18428 have const qualified pointers leading up to the inner type which
18429 requires additional CV quals, except at the outer level, where const
18430 is not required [conv.qual]. It would be normal to set this flag in
18431 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
18432 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
18433 This is the outermost level of a deduction, and PARM can be more CV
18434 qualified at this point.
18435 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
18436 This is the outermost level of a deduction, and PARM can be less CV
18437 qualified at this point. */
18439 static int
18442 {
18444 tree targ;
18445 tree tparm;
18448 /* I don't think this will do the right thing with respect to types.
18449 But the only case I've seen it in so far has been array bounds, where
18450 signedness is the only information lost, and I think that will be
18451 okay. */
18459 /* We can't deduce anything from this, but we might get all the
18460 template args from other function args. */
18463 /* If PARM uses template parameters, then we can't bail out here,
18464 even if ARG == PARM, since we won't record unifications for the
18465 template parameters. We might need them if we're trying to
18466 figure out which of two things is more specialized. */
18470 /* Handle init lists early, so the rest of the function can assume
18471 we're dealing with a type. */
18473 {
18478 /* Replace T with std::initializer_list<T> for deduction. */
18485 /* We can only deduce from an initializer list argument if the
18486 parameter is std::initializer_list or an array; otherwise this
18487 is a non-deduced context. */
18492 else
18493 {
18495 /* Deduction is defined in terms of a single type, so just punt
18496 on the (bizarre) std::initializer_list<T...>. */
18499 }
18502 {
18509 {
18513 /* It should only be possible to get here for a call. */
18515 elt_strict |= maybe_adjust_types_for_deduction
18518 }
18521 explain_p);
18522 }
18526 {
18527 /* Also deduce from the length of the initializer list. */
18534 }
18536 /* If the std::initializer_list<T> deduction worked, replace the
18537 deduced A with std::initializer_list<A>. */
18539 {
18544 }
18546 }
18548 /* Immediately reject some pairs that won't unify because of
18549 cv-qualification mismatches. */
18552 /* It is the elements of the array which hold the cv quals of an array
18553 type, and the elements might be template type parms. We'll check
18554 when we recurse. */
18556 /* We check the cv-qualifiers when unifying with template type
18557 parameters below. We want to allow ARG `const T' to unify with
18558 PARM `T' for example, when computing which of two templates
18559 is more specialized, for example. */
18573 {
18577 /* In a type which contains a nested-name-specifier, template
18578 argument values cannot be deduced for template parameters used
18579 within the nested-name-specifier. */
18591 /* The PARM is not one we're trying to unify. Just check
18592 to see if it matches ARG. */
18593 {
18598 else
18600 }
18607 /* Check for mixed types and values. */
18615 {
18616 /* ARG must be constructed from a template class or a template
18617 template parameter. */
18621 {
18623 /* An alias template name is never deduced. */
18628 tree parm_parms
18629 = DECL_INNERMOST_TEMPLATE_PARMS
18634 /* The resolution to DR150 makes clear that default
18635 arguments for an N-argument may not be used to bind T
18636 to a template template parameter with fewer than N
18637 parameters. It is not safe to permit the binding of
18638 default arguments as an extension, as that may change
18639 the meaning of a conforming program. Consider:
18641 struct Dense { static const unsigned int dim = 1; };
18643 template <template <typename> class View,
18644 typename Block>
18645 void operator+(float, View<Block> const&);
18647 template <typename Block,
18648 unsigned int Dim = Block::dim>
18649 struct Lvalue_proxy { operator float() const; };
18651 void
18652 test_1d (void) {
18653 Lvalue_proxy<Dense> p;
18654 float b;
18655 b + p;
18656 }
18658 Here, if Lvalue_proxy is permitted to bind to View, then
18659 the global operator+ will be used; if they are not, the
18660 Lvalue_proxy will be converted to float. */
18662 full_argvec,
18664 (explain_p
18665 ? tf_warning_or_error
18672 /* Deduce arguments T, i from TT<T> or TT<i>.
18673 We check each element of PARMVEC and ARGVEC individually
18674 rather than the whole TREE_VEC since they can have
18675 different number of elements. */
18682 /* Check if the parameters end in a pack, making them
18683 variadic. */
18689 /* If the template argument list of P contains a pack
18690 expansion that is not the last template argument, the
18691 entire template argument list is a non-deduced
18692 context. */
18701 {
18706 }
18711 DEDUCE_EXACT,
18714 }
18717 /* Fall through to deduce template name. */
18718 }
18722 {
18723 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18725 /* Simple cases: Value already set, does match or doesn't. */
18730 }
18731 else
18732 {
18733 /* If PARM is `const T' and ARG is only `int', we don't have
18734 a match unless we are allowing additional qualification.
18735 If ARG is `const int' and PARM is just `T' that's OK;
18736 that binds `const int' to `T'. */
18741 /* Consider the case where ARG is `const volatile int' and
18742 PARM is `const T'. Then, T should be `volatile int'. */
18743 arg = cp_build_qualified_type_real
18748 /* Simple cases: Value already set, does match or doesn't. */
18754 /* Make sure that ARG is not a variable-sized array. (Note
18755 that were talking about variable-sized arrays (like
18756 `int[n]'), rather than arrays of unknown size (like
18757 `int[]').) We'll get very confused by such a type since
18758 the bound of the array is not constant, and therefore
18759 not mangleable. Besides, such types are not allowed in
18760 ISO C++, so we can do as we please here. We do allow
18761 them for 'auto' deduction, since that isn't ABI-exposed. */
18765 /* Strip typedefs as in convert_template_argument. */
18767 }
18769 /* If ARG is a parameter pack or an expansion, we cannot unify
18770 against it unless PARM is also a parameter pack. */
18775 /* If the argument deduction results is a METHOD_TYPE,
18776 then there is a problem.
18777 METHOD_TYPE doesn't map to any real C++ type the result of
18778 the deduction can not be of that type. */
18792 {
18793 /* The PARM is not one we're trying to unify. Just check
18794 to see if it matches ARG. */
18800 }
18806 {
18811 }
18813 /* [temp.deduct.type] If, in the declaration of a function template
18814 with a non-type template-parameter, the non-type
18815 template-parameter is used in an expression in the function
18816 parameter-list and, if the corresponding template-argument is
18817 deduced, the template-argument type shall match the type of the
18818 template-parameter exactly, except that a template-argument
18819 deduced from an array bound may be of any integral type.
18820 The non-type parameter might use already deduced type parameters. */
18823 /* Template-parameter dependent expression. Just accept it for now.
18824 It will later be processed in convert_template_argument. */
18825 ;
18830 /* Convert the ARG to the type of PARM; the deduced non-type
18831 template argument must exactly match the types of the
18832 corresponding parameter. */
18835 /* We haven't deduced the type of this parameter yet. Try again
18836 later. */
18838 else
18841 /* If ARG is a parameter pack or an expansion, we cannot unify
18842 against it unless PARM is also a parameter pack. */
18852 {
18853 /* A pointer-to-member constant can be unified only with
18854 another constant. */
18858 /* Just unify the class member. It would be useless (and possibly
18859 wrong, depending on the strict flags) to unify also
18860 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18861 arg refer to the same variable, even if through different
18862 classes. For instance:
18864 struct A { int x; };
18865 struct B : A { };
18867 Unification of &A::x and &B::x must succeed. */
18870 }
18873 {
18877 /* [temp.deduct.call]
18879 A can be another pointer or pointer to member type that can
18880 be converted to the deduced A via a qualification
18881 conversion (_conv.qual_).
18883 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18884 This will allow for additional cv-qualification of the
18885 pointed-to types if appropriate. */
18888 /* The derived-to-base conversion only persists through one
18889 level of pointers. */
18894 }
18926 /* We have already checked cv-qualification at the top of the
18927 function. */
18931 /* As far as unification is concerned, this wins. Later checks
18932 will invalidate it if necessary. */
18935 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18936 /* Type INTEGER_CST can come from ordinary constant template args. */
18948 {
18958 /* Check for pack expansions in the parameters. */
18960 {
18962 {
18964 /* We can unify against something with a trailing
18965 parameter pack. */
18967 else
18968 /* [temp.deduct.type]/9: If the template argument list of
18969 P contains a pack expansion that is not the last
18970 template argument, the entire template argument list
18971 is a non-deduced context. */
18973 }
18974 }
18976 /* If we don't have enough arguments to satisfy the parameters
18977 (not counting the pack expression at the end), or we have
18978 too many arguments for a parameter list that doesn't end in
18979 a pack expression, we can't unify. */
18985 /* Unify all of the parameters that precede the (optional)
18986 pack expression. */
18988 {
18993 }
18996 DEDUCE_EXACT,
18999 }
19007 {
19015 }
19020 {
19024 {
19025 /* First, we try to unify the PARM and ARG directly. */
19030 {
19031 /* Fallback to the special case allowed in
19032 [temp.deduct.call]:
19034 If P is a class, and P has the form
19035 template-id, then A can be a derived class of
19036 the deduced A. Likewise, if P is a pointer to
19037 a class of the form template-id, A can be a
19038 pointer to a derived class pointed to by the
19039 deduced A. */
19046 }
19047 }
19051 /* Perhaps PARM is something like S<U> and ARG is S<int>.
19052 Then, we should unify `int' and `U'. */
19054 else
19055 /* There's no chance of unification succeeding. */
19060 }
19067 {
19070 tree a;
19076 /* CV qualifications for methods can never be deduced, they must
19077 match exactly. We need to check them explicitly here,
19078 because type_unification_real treats them as any other
19079 cv-qualified parameter. */
19081 && (!check_cv_quals_for_unify
19101 }
19104 /* Unify a pointer to member with a pointer to member function, which
19105 deduces the type of the member as a function type. */
19107 {
19108 /* Check top-level cv qualifiers */
19116 /* Determine the type of the function we are unifying against. */
19120 }
19139 /* Matched cases are handled by the ARG == PARM test above. */
19143 /* A non-type template parameter that is a variable should be a
19144 an integral constant, in which case, it whould have been
19145 folded into its (constant) value. So we should not be getting
19146 a variable here. */
19157 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
19158 or UNDERLYING_TYPE nodes. */
19162 /* Unification fails if we hit an error node. */
19167 {
19172 }
19173 /* FALLTHRU */
19176 /* An unresolved overload is a nondeduced context. */
19181 /* We must be looking at an expression. This can happen with
19182 something like:
19184 template <int I>
19185 void foo(S<I>, S<I + 2>);
19187 This is a "nondeduced context":
19189 [deduct.type]
19191 The nondeduced contexts are:
19193 --A type that is a template-id in which one or more of
19194 the template-arguments is an expression that references
19195 a template-parameter.
19197 In these cases, we assume deduction succeeded, but don't
19198 actually infer any unifications. */
19203 else
19205 }
19206 }
19207 #undef RECUR_AND_CHECK_FAILURE
19208 \f
19209 /* Note that DECL can be defined in this translation unit, if
19210 required. */
19212 static void
19214 {
19215 tree clone;
19219 }
19221 /* Called if RESULT is explicitly instantiated, or is a member of an
19222 explicitly instantiated class. */
19224 void
19226 {
19229 /* If this entity has already been written out, it's too late to
19230 make any modifications. */
19234 /* For anonymous namespace we don't need to do anything. */
19236 {
19239 }
19242 /* The TREE_PUBLIC flag for function declarations will have been
19243 set correctly by tsubst. */
19246 /* This might have been set by an earlier implicit instantiation. */
19251 else
19252 {
19255 /* Always make artificials weak. */
19258 /* For WIN32 we also want to put explicit instantiations in
19259 linkonce sections. */
19262 }
19264 /* If EXTERN_P, then this function will not be emitted -- unless
19265 followed by an explicit instantiation, at which point its linkage
19266 will be adjusted. If !EXTERN_P, then this function will be
19267 emitted here. In neither circumstance do we want
19268 import_export_decl to adjust the linkage. */
19270 }
19272 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
19273 important template arguments. If any are missing, we check whether
19274 they're important by using error_mark_node for substituting into any
19275 args that were used for partial ordering (the ones between ARGS and END)
19276 and seeing if it bubbles up. */
19278 static bool
19280 {
19285 {
19288 }
19290 {
19294 }
19296 }
19298 /* Given two function templates PAT1 and PAT2, return:
19300 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
19301 -1 if PAT2 is more specialized than PAT1.
19302 0 if neither is more specialized.
19304 LEN indicates the number of parameters we should consider
19305 (defaulted parameters should not be considered).
19307 The 1998 std underspecified function template partial ordering, and
19308 DR214 addresses the issue. We take pairs of arguments, one from
19309 each of the templates, and deduce them against each other. One of
19310 the templates will be more specialized if all the *other*
19311 template's arguments deduce against its arguments and at least one
19312 of its arguments *does* *not* deduce against the other template's
19313 corresponding argument. Deduction is done as for class templates.
19314 The arguments used in deduction have reference and top level cv
19315 qualifiers removed. Iff both arguments were originally reference
19316 types *and* deduction succeeds in both directions, an lvalue reference
19317 wins against an rvalue reference and otherwise the template
19318 with the more cv-qualified argument wins for that pairing (if
19319 neither is more cv-qualified, they both are equal). Unlike regular
19320 deduction, after all the arguments have been deduced in this way,
19321 we do *not* verify the deduced template argument values can be
19322 substituted into non-deduced contexts.
19324 The logic can be a bit confusing here, because we look at deduce1 and
19325 targs1 to see if pat2 is at least as specialized, and vice versa; if we
19326 can find template arguments for pat1 to make arg1 look like arg2, that
19327 means that arg2 is at least as specialized as arg1. */
19329 int
19331 {
19344 /* Remove the this parameter from non-static member functions. If
19345 one is a non-static member function and the other is not a static
19346 member function, remove the first parameter from that function
19347 also. This situation occurs for operator functions where we
19348 locate both a member function (with this pointer) and non-member
19349 operator (with explicit first operand). */
19351 {
19356 }
19358 {
19361 {
19362 len--;
19364 }
19365 }
19367 /* If only one is a conversion operator, they are unordered. */
19371 /* Consider the return type for a conversion function */
19373 {
19376 len++;
19377 }
19379 processing_template_decl++;
19385 /* Stop when an ellipsis is seen. */
19387 {
19398 {
19399 /* When both arguments are pack expansions, we need only
19400 unify the patterns themselves. */
19404 /* This is the last comparison we need to do. */
19406 }
19409 {
19413 }
19416 {
19420 }
19426 {
19432 /* Setup the parameter vector, which contains only ARG1. */
19435 /* Setup the argument vector, which contains the remaining
19436 arguments. */
19445 /* We cannot deduce in the other direction, because ARG1 is
19446 a pack expansion but ARG2 is not. */
19448 }
19450 {
19456 /* Setup the parameter vector, which contains only ARG1. */
19459 /* Setup the argument vector, which contains the remaining
19460 arguments. */
19469 /* We cannot deduce in the other direction, because ARG2 is
19470 a pack expansion but ARG1 is not.*/
19472 }
19474 else
19475 {
19476 /* The normal case, where neither argument is a pack
19477 expansion. */
19484 }
19486 /* If we couldn't deduce arguments for tparms1 to make arg1 match
19487 arg2, then arg2 is not as specialized as arg1. */
19493 /* "If, for a given type, deduction succeeds in both directions
19494 (i.e., the types are identical after the transformations above)
19495 and both P and A were reference types (before being replaced with
19496 the type referred to above):
19497 - if the type from the argument template was an lvalue reference and
19498 the type from the parameter template was not, the argument type is
19499 considered to be more specialized than the other; otherwise,
19500 - if the type from the argument template is more cv-qualified
19501 than the type from the parameter template (as described above),
19502 the argument type is considered to be more specialized than the other;
19503 otherwise,
19504 - neither type is more specialized than the other." */
19507 {
19509 {
19512 else
19514 }
19516 {
19521 }
19522 }
19525 /* We've failed to deduce something in either direction.
19526 These must be unordered. */
19531 /* We have already processed all of the arguments in our
19532 handing of the pack expansion type. */
19537 }
19539 /* "In most cases, all template parameters must have values in order for
19540 deduction to succeed, but for partial ordering purposes a template
19541 parameter may remain without a value provided it is not used in the
19542 types being used for partial ordering."
19544 Thus, if we are missing any of the targs1 we need to substitute into
19545 origs1, then pat2 is not as specialized as pat1. This can happen when
19546 there is a nondeduced context. */
19552 processing_template_decl--;
19554 /* All things being equal, if the next argument is a pack expansion
19555 for one function but not for the other, prefer the
19556 non-variadic function. FIXME this is bogus; see c++/41958. */
19560 {
19563 }
19565 // All things still being equal, determine if one is more constrained.
19567 {
19572 }
19578 else
19580 }
19582 /* Determine which of two partial specializations of TMPL is more
19583 specialized.
19585 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
19586 to the first partial specialization. The TREE_PURPOSE is the
19587 innermost set of template parameters for the partial
19588 specialization. PAT2 is similar, but for the second template.
19590 Return 1 if the first partial specialization is more specialized;
19591 -1 if the second is more specialized; 0 if neither is more
19592 specialized.
19594 See [temp.class.order] for information about determining which of
19595 two templates is more specialized. */
19597 static int
19599 {
19600 tree targs;
19611 /* Just like what happens for functions, if we are ordering between
19612 different template specializations, we may encounter dependent
19613 types in the arguments, and we need our dependency check functions
19614 to behave correctly. */
19618 {
19621 }
19625 {
19628 }
19631 /* In the case of a tie where at least one of the templates
19632 has a parameter pack at the end, the template with the most
19633 non-packed parameters wins. */
19635 && any_deductions
19638 {
19644 /* We don't count the pack expansion at the end. */
19654 }
19657 // If still tied at this point, the most specialized is also
19658 // the most constrained.
19663 }
19665 /* Return the template arguments that will produce the function signature
19666 DECL from the function template FN, with the explicit template
19667 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19668 also match. Return NULL_TREE if no satisfactory arguments could be
19669 found. */
19671 static tree
19673 {
19677 tree decl_arg_types;
19680 tree arg;
19684 /* Never do unification on the 'this' parameter. */
19705 }
19707 /* Return the innermost template arguments that, when applied to a partial
19708 specialization of TMPL whose innermost template parameters are
19709 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19710 ARGS.
19712 For example, suppose we have:
19714 template <class T, class U> struct S {};
19715 template <class T> struct S<T*, int> {};
19717 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19718 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19719 int}. The resulting vector will be {double}, indicating that `T'
19720 is bound to `double'. */
19722 static tree
19724 {
19726 tree deduced_args;
19727 tree innermost_deduced_args;
19731 {
19735 innermost_deduced_args);
19736 }
19737 else
19750 /* Verify that nondeduced template arguments agree with the type
19751 obtained from argument deduction.
19753 For example:
19755 struct A { typedef int X; };
19756 template <class T, class U> struct C {};
19757 template <class T> struct C<T, typename T::X> {};
19759 Then with the instantiation `C<A, int>', we can deduce that
19760 `T' is `A' but unify () does not check whether `typename T::X'
19761 is `int'. */
19767 /* We only need to check the innermost arguments; the other
19768 arguments will always agree. */
19773 /* Now that we have bindings for all of the template arguments,
19774 ensure that the arguments deduced for the template template
19775 parameters have compatible template parameter lists. See the use
19776 of template_template_parm_bindings_ok_p in fn_type_unification
19777 for more information. */
19782 }
19784 // Compare two function templates T1 and T2 by deducing bindings
19785 // from one against the other. If both deductions succeed, compare
19786 // constraints to see which is more constrained.
19787 static int
19789 {
19794 {
19797 }
19800 {
19803 }
19805 // If both deductions succeed, then one may be more constrained.
19810 }
19812 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19813 Return the TREE_LIST node with the most specialized template, if
19814 any. If there is no most specialized template, the error_mark_node
19815 is returned.
19817 Note that this function does not look at, or modify, the
19818 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19819 returned is one of the elements of INSTANTIATIONS, callers may
19820 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19821 and retrieve it from the value returned. */
19823 tree
19825 {
19832 {
19837 {
19838 /* Equally specialized, move to next function. If there
19839 is no next function, nothing's most specialized. */
19844 }
19845 }
19848 /* Now verify that champ is better than everything earlier in the
19849 instantiation list. */
19852 {
19855 }
19856 }
19858 processing_template_decl--;
19864 }
19866 /* If DECL is a specialization of some template, return the most
19867 general such template. Otherwise, returns NULL_TREE.
19869 For example, given:
19871 template <class T> struct S { template <class U> void f(U); };
19873 if TMPL is `template <class U> void S<int>::f(U)' this will return
19874 the full template. This function will not trace past partial
19875 specializations, however. For example, given in addition:
19877 template <class T> struct S<T*> { template <class U> void f(U); };
19879 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19880 `template <class T> template <class U> S<T*>::f(U)'. */
19882 tree
19884 {
19886 {
19889 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19890 template friend, or a FIELD_DECL for a capture pack. */
19893 }
19895 /* Look for more and more general templates. */
19897 {
19898 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19899 (See cp-tree.h for details.) */
19908 /* Stop if we run into an explicitly specialized class template. */
19915 }
19918 }
19920 /* Return the most specialized of the template partial specializations
19921 which can produce TARGET, a specialization of some class or variable
19922 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19923 a TEMPLATE_DECL node corresponding to the partial specialization, while
19924 the TREE_PURPOSE is the set of template arguments that must be
19925 substituted into the template pattern in order to generate TARGET.
19927 If the choice of partial specialization is ambiguous, a diagnostic
19928 is issued, and the error_mark_node is returned. If there are no
19929 partial specializations matching TARGET, then NULL_TREE is
19930 returned, indicating that the primary template should be used. */
19932 static tree
19934 {
19936 tree t;
19937 tree champ;
19944 {
19948 }
19950 {
19953 }
19955 {
19959 }
19960 else
19965 /* For determining which partial specialization to use, only the
19966 innermost args are interesting. */
19968 {
19971 }
19974 {
19975 tree partial_spec_args;
19976 tree spec_args;
19984 {
19985 /* Discard the outer levels of args, and then substitute in the
19986 template args from the enclosing class. */
19988 partial_spec_args = tsubst_template_args
19991 /* And the same for the partial specialization TEMPLATE_DECL. */
19993 }
19995 partial_spec_args =
19997 partial_spec_args,
20011 partial_spec_args,
20012 args);
20014 {
20018 /* Keep the candidate only if the constraints are satisfied,
20019 or if we're not compiling with concepts. */
20021 {
20024 }
20025 }
20026 }
20036 {
20039 ;
20040 else
20041 {
20043 {
20046 {
20049 }
20050 }
20052 }
20053 }
20057 {
20060 {
20063 }
20064 }
20067 {
20074 else
20078 {
20083 }
20086 }
20089 }
20091 /* Explicitly instantiate DECL. */
20093 void
20095 {
20100 /* An error occurred, for which grokdeclarator has already issued
20101 an appropriate message. */
20104 {
20107 }
20113 {
20114 /* There is an asymmetry here in the way VAR_DECLs and
20115 FUNCTION_DECLs are handled by grokdeclarator. In the case of
20116 the latter, the DECL we get back will be marked as a
20117 template instantiation, and the appropriate
20118 DECL_TEMPLATE_INFO will be set up. This does not happen for
20119 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
20120 should handle VAR_DECLs as it currently handles
20121 FUNCTION_DECLs. */
20123 {
20126 }
20129 {
20132 }
20134 {
20139 }
20140 }
20142 {
20145 }
20146 else
20149 /* Check for various error cases. Note that if the explicit
20150 instantiation is valid the RESULT will currently be marked as an
20151 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
20152 until we get here. */
20155 {
20156 /* DR 259 [temp.spec].
20158 Both an explicit instantiation and a declaration of an explicit
20159 specialization shall not appear in a program unless the explicit
20160 instantiation follows a declaration of the explicit specialization.
20162 For a given set of template parameters, if an explicit
20163 instantiation of a template appears after a declaration of an
20164 explicit specialization for that template, the explicit
20165 instantiation has no effect. */
20167 }
20169 {
20170 /* [temp.spec]
20172 No program shall explicitly instantiate any template more
20173 than once.
20175 We check DECL_NOT_REALLY_EXTERN so as not to complain when
20176 the first instantiation was `extern' and the second is not,
20177 and EXTERN_P for the opposite case. */
20180 /* If an "extern" explicit instantiation follows an ordinary
20181 explicit instantiation, the template is instantiated. */
20184 }
20186 {
20189 }
20191 {
20194 }
20197 ;
20199 {
20202 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
20205 }
20206 else
20214 }
20216 static void
20218 {
20224 {
20227 }
20228 }
20230 /* Called from do_type_instantiation through binding_table_foreach to
20231 do recursive instantiation for the type bound in ENTRY. */
20232 static void
20234 {
20240 }
20242 /* Called from do_type_instantiation to instantiate a member
20243 (a member function or a static member variable) of an
20244 explicitly instantiated class template. */
20245 static void
20247 {
20252 }
20254 /* Perform an explicit instantiation of template class T. STORAGE, if
20255 non-null, is the RID for extern, inline or static. COMPLAIN is
20256 nonzero if this is called from the parser, zero if called recursively,
20257 since the standard is unclear (as detailed below). */
20259 void
20261 {
20271 {
20272 tree tmpl =
20276 else
20279 }
20284 {
20287 t);
20289 }
20292 {
20294 {
20296 {
20299 "ISO C++ 1998 forbids the use of %<extern%> on "
20301 }
20302 else
20304 "ISO C++ forbids the use of %qE"
20306 }
20314 else
20315 {
20317 storage);
20319 }
20320 }
20323 {
20324 /* DR 259 [temp.spec].
20326 Both an explicit instantiation and a declaration of an explicit
20327 specialization shall not appear in a program unless the explicit
20328 instantiation follows a declaration of the explicit specialization.
20330 For a given set of template parameters, if an explicit
20331 instantiation of a template appears after a declaration of an
20332 explicit specialization for that template, the explicit
20333 instantiation has no effect. */
20335 }
20337 {
20338 /* [temp.spec]
20340 No program shall explicitly instantiate any template more
20341 than once.
20343 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
20344 instantiation was `extern'. If EXTERN_P then the second is.
20345 These cases are OK. */
20352 /* If we've already instantiated the template, just return now. */
20355 }
20363 {
20364 tree tmp;
20366 /* In contrast to implicit instantiation, where only the
20367 declarations, and not the definitions, of members are
20368 instantiated, we have here:
20370 [temp.explicit]
20372 The explicit instantiation of a class template specialization
20373 implies the instantiation of all of its members not
20374 previously explicitly specialized in the translation unit
20375 containing the explicit instantiation.
20377 Of course, we can't instantiate member template classes, since
20378 we don't have any arguments for them. Note that the standard
20379 is unclear on whether the instantiation of the members are
20380 *explicit* instantiations or not. However, the most natural
20381 interpretation is that it should be an explicit instantiation. */
20396 }
20397 }
20399 /* Given a function DECL, which is a specialization of TMPL, modify
20400 DECL to be a re-instantiation of TMPL with the same template
20401 arguments. TMPL should be the template into which tsubst'ing
20402 should occur for DECL, not the most general template.
20404 One reason for doing this is a scenario like this:
20406 template <class T>
20407 void f(const T&, int i);
20409 void g() { f(3, 7); }
20411 template <class T>
20412 void f(const T& t, const int i) { }
20414 Note that when the template is first instantiated, with
20415 instantiate_template, the resulting DECL will have no name for the
20416 first parameter, and the wrong type for the second. So, when we go
20417 to instantiate the DECL, we regenerate it. */
20419 static void
20421 {
20422 /* The arguments used to instantiate DECL, from the most general
20423 template. */
20424 tree args;
20425 tree code_pattern;
20430 /* Make sure that we can see identifiers, and compute access
20431 correctly. */
20435 {
20436 tree decl_parm;
20437 tree pattern_parm;
20438 tree specs;
20452 specs);
20454 /* Merge parameter declarations. */
20457 pattern_parm
20461 {
20462 tree parm_type;
20463 tree attributes;
20468 NULL_TREE);
20474 {
20477 }
20480 }
20481 /* Merge any parameters that match with the function parameter
20482 pack. */
20484 {
20486 tree expanded_types;
20487 /* Expand the TYPE_PACK_EXPANSION that provides the types for
20488 the parameters in this function parameter pack. */
20493 {
20494 tree parm_type;
20495 tree attributes;
20498 /* Rename the parameter to include the index. */
20507 {
20510 }
20512 }
20513 }
20514 /* Merge additional specifiers from the CODE_PATTERN. */
20518 }
20520 {
20528 }
20529 else
20533 }
20535 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
20536 substituted to get DECL. */
20538 tree
20540 {
20543 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
20544 for the instantiation. This is not always the most general
20545 template. Consider, for example:
20547 template <class T>
20548 struct S { template <class U> void f();
20549 template <> void f<int>(); };
20551 and an instantiation of S<double>::f<int>. We want TD to be the
20552 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
20554 more general template. */
20556 /* We must also deal with friend templates. Given:
20558 template <class T> struct S {
20559 template <class U> friend void f() {};
20560 };
20562 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
20563 so far as the language is concerned, but that's still
20564 where we get the pattern for the instantiation from. On
20565 other hand, if the definition comes outside the class, say:
20567 template <class T> struct S {
20568 template <class U> friend void f();
20569 };
20570 template <class U> friend void f() {}
20572 we don't need to look any further. That's what the check for
20573 DECL_INITIAL is for. */
20577 {
20578 /* The present template, TD, should not be a definition. If it
20579 were a definition, we should be using it! Note that we
20580 cannot restructure the loop to just keep going until we find
20581 a template with a definition, since that might go too far if
20582 a specialization was declared, but not defined. */
20584 /* Fetch the more general template. */
20586 }
20589 }
20591 /* Returns true if we need to instantiate this template instance even if we
20592 know we aren't going to emit it. */
20594 bool
20596 {
20597 /* We always instantiate inline functions so that we can inline them. An
20598 explicit instantiation declaration prohibits implicit instantiation of
20599 non-inline functions. With high levels of optimization, we would
20600 normally inline non-inline functions -- but we're not allowed to do
20601 that for "extern template" functions. Therefore, we check
20602 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
20606 /* And we need to instantiate static data members so that
20607 their initializers are available in integral constant
20608 expressions. */
20611 }
20613 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
20614 instantiate it now, modifying TREE_TYPE (fn). */
20616 void
20618 {
20621 /* Don't instantiate a noexcept-specification from template context. */
20636 {
20640 {
20655 }
20656 else
20660 }
20663 {
20666 else
20668 }
20669 }
20671 /* Produce the definition of D, a _DECL generated from a template. If
20672 DEFER_OK is nonzero, then we don't have to actually do the
20673 instantiation now; we just have to do it sometime. Normally it is
20674 an error if this is an explicit instantiation but D is undefined.
20675 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20676 explicitly instantiated class template. */
20678 tree
20681 {
20683 tree gen_args;
20684 tree args;
20685 tree td;
20686 tree code_pattern;
20687 tree spec;
20688 tree gen_tmpl;
20695 tree fn_context;
20698 /* This function should only be used to instantiate templates for
20699 functions and static member variables. */
20702 /* A concept is never instantiated. */
20705 /* Variables are never deferred; if instantiation is required, they
20706 are instantiated right away. That allows for better code in the
20707 case that an expression refers to the value of the variable --
20708 if the variable has a constant value the referring expression can
20709 take advantage of that fact. */
20714 /* Don't instantiate cloned functions. Instead, instantiate the
20715 functions they cloned. */
20723 /* D has already been instantiated or explicitly specialized, so
20724 there's nothing for us to do here.
20726 It might seem reasonable to check whether or not D is an explicit
20727 instantiation, and, if so, stop here. But when an explicit
20728 instantiation is deferred until the end of the compilation,
20729 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20730 the instantiation. */
20733 /* Check to see whether we know that this template will be
20734 instantiated in some other file, as with "extern template"
20735 extension. */
20738 /* In general, we do not instantiate such templates. */
20746 /* We should already have the extra args. */
20749 /* And what's in the hash table should match D. */
20753 /* This needs to happen before any tsubsting. */
20759 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20760 for the instantiation. */
20764 /* We should never be trying to instantiate a member of a class
20765 template or partial specialization. */
20770 /* In the case of a friend template whose definition is provided
20771 outside the class, we may have too many arguments. Drop the
20772 ones we don't need. The same is true for specializations. */
20773 args = get_innermost_template_args
20775 else
20779 {
20784 }
20785 else
20786 {
20789 }
20791 /* We may be in the middle of deferred access check. Disable it now. */
20794 /* Unless an explicit instantiation directive has already determined
20795 the linkage of D, remember that a definition is available for
20796 this entity. */
20806 /* If D is a member of an explicitly instantiated class template,
20807 and no definition is available, treat it like an implicit
20808 instantiation. */
20811 {
20812 /* Leave linkage flags alone on instantiations with anonymous
20813 visibility. */
20815 {
20818 }
20820 }
20822 /* Defer all other templates, unless we have been explicitly
20823 forbidden from doing so. */
20825 template. */
20826 ! pattern_defined
20827 /* If it's OK to postpone instantiation, do so. */
20828 || defer_ok
20829 /* If this is a static data member that will be defined
20830 elsewhere, we don't want to instantiate the entire data
20831 member, but we do want to instantiate the initializer so that
20832 we can substitute that elsewhere. */
20834 /* Handle here a deleted function too, avoid generating
20835 its body (c++/61080). */
20837 {
20838 /* The definition of the static data member is now required so
20839 we must substitute the initializer. */
20843 {
20844 tree ns;
20845 tree init;
20854 args,
20857 /* If instantiating the initializer involved instantiating this
20858 again, don't call cp_finish_decl twice. */
20860 {
20861 /* Make sure the initializer is still constant, in case of
20862 circular dependency (template/instantiate6.C). */
20863 const_init
20867 LOOKUP_ONLYCONVERTING);
20868 }
20872 }
20874 /* We restore the source position here because it's used by
20875 add_pending_template. */
20881 /* [temp.explicit]
20883 The definition of a non-exported function template, a
20884 non-exported member function template, or a non-exported
20885 member function or static data member of a class template
20886 shall be present in every translation unit in which it is
20887 explicitly instantiated. */
20891 /* If we're in unevaluated context, we just wanted to get the
20892 constant value; this isn't an odr use, so don't queue
20893 a full instantiation. */
20896 /* ??? Historically, we have instantiated inline functions, even
20897 when marked as "extern template". */
20901 }
20902 /* Tell the repository that D is available in this translation unit
20903 -- and see if it is supposed to be instantiated here. */
20905 {
20906 /* In a PCH file, despite the fact that the repository hasn't
20907 requested instantiation in the PCH it is still possible that
20908 an instantiation will be required in a file that includes the
20909 PCH. */
20912 /* Instantiate inline functions so that the inliner can do its
20913 job, even though we'll not be emitting a copy of this
20914 function. */
20917 }
20923 else
20924 {
20929 }
20931 /* Mark D as instantiated so that recursive calls to
20932 instantiate_decl do not try to instantiate it again. */
20935 /* Regenerate the declaration in case the template has been modified
20936 by a subsequent redeclaration. */
20939 /* We already set the file and line above. Reset them now in case
20940 they changed as a result of calling regenerate_decl_from_template. */
20944 {
20945 tree init;
20948 /* Clear out DECL_RTL; whatever was there before may not be right
20949 since we've reset the type of the declaration. */
20953 /* The initializer is placed in DECL_INITIAL by
20954 regenerate_decl_from_template so we don't need to
20955 push/pop_access_scope again here. Pull it out so that
20956 cp_finish_decl can process it. */
20961 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20962 initializer. That function will defer actual emission until
20963 we have a chance to determine linkage. */
20966 /* Enter the scope of D so that access-checking works correctly. */
20979 }
20983 {
20985 tree subst_decl;
20986 tree tmpl_parm;
20987 tree spec_parm;
20990 /* Save away the current list, in case we are instantiating one
20991 template from within the body of another. */
20994 /* Set up the list of local specializations. */
20997 /* Set up context. */
21001 else
21004 /* Some typedefs referenced from within the template code need to be
21005 access checked at template instantiation time, i.e now. These
21006 types were added to the template at parsing time. Let's get those
21007 and perform the access checks then. */
21009 gen_args);
21011 /* Create substitution entries for the parameters. */
21016 {
21020 }
21022 {
21024 {
21027 }
21028 else
21029 {
21030 /* Register the (value) argument pack as a specialization of
21031 TMPL_PARM, then move on. */
21034 }
21035 }
21038 /* Substitute into the body of the function. */
21042 else
21043 {
21048 /* Set the current input_location to the end of the function
21049 so that finish_function knows where we are. */
21050 input_location
21053 /* Remember if we saw an infinite loop in the template. */
21054 current_function_infinite_loop
21056 }
21058 /* We don't need the local specializations any more. */
21062 /* Finish the function. */
21066 else
21067 {
21070 }
21074 }
21076 /* We're not deferring instantiation any more. */
21084 out:
21094 }
21096 /* Run through the list of templates that we wish we could
21097 instantiate, and instantiate any we can. RETRIES is the
21098 number of times we retry pending template instantiation. */
21100 void
21102 {
21106 /* Instantiating templates may trigger vtable generation. This in turn
21107 may require further template instantiations. We place a limit here
21108 to avoid infinite loop. */
21110 {
21114 "template instantiation depth exceeds maximum of %d"
21115 " instantiating %q+D, possibly from virtual table generation"
21119 /* Pretend that we defined it. */
21122 }
21124 do
21125 {
21130 {
21135 {
21136 tree fn;
21139 {
21143 fn;
21151 }
21154 }
21155 else
21156 {
21159 {
21160 instantiation
21166 }
21170 }
21173 /* If INSTANTIATION has been instantiated, then we don't
21174 need to consider it again in the future. */
21176 else
21177 {
21180 }
21183 }
21185 }
21189 }
21191 /* Substitute ARGVEC into T, which is a list of initializers for
21192 either base class or a non-static data member. The TREE_PURPOSEs
21193 are DECLs, and the TREE_VALUEs are the initializer values. Used by
21194 instantiate_decl. */
21196 static tree
21198 {
21202 {
21203 tree decl;
21204 tree init;
21210 {
21211 tree expr;
21212 tree arg;
21214 /* Expand the base class expansion type into separate base
21215 classes. */
21217 tf_warning_or_error,
21218 NULL_TREE);
21222 /* We'll be building separate TREE_LISTs of arguments for
21223 each base. */
21229 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
21230 expand each argument in the TREE_VALUE of t. */
21237 /* VOID_TYPE_NODE is used to indicate
21238 value-initialization. */
21239 {
21242 }
21243 else
21244 {
21245 /* Substitute parameter packs into each argument in the
21246 TREE_LIST. */
21249 {
21250 tree expanded_exprs;
21252 /* Expand the argument. */
21254 expanded_exprs
21256 tf_warning_or_error,
21257 NULL_TREE);
21261 /* Prepend each of the expanded expressions to the
21262 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
21264 {
21269 }
21270 }
21273 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
21274 since we built them backwards. */
21276 {
21279 }
21280 }
21281 }
21284 {
21286 {
21290 }
21291 else
21292 {
21293 tree tmp;
21308 /* If we had an initializer but it instantiated to nothing,
21309 value-initialize the object. This will only occur when
21310 the initializer was a pack expansion where the parameter
21311 packs used in that expansion were of length zero. */
21314 }
21317 {
21321 }
21322 }
21323 }
21325 }
21327 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
21329 static void
21331 {
21336 else
21338 }
21340 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
21341 is the instantiation (which should have been created with
21342 start_enum) and ARGS are the template arguments to use. */
21344 static void
21346 {
21347 tree e;
21353 {
21354 tree value;
21355 tree decl;
21358 /* Note that in a template enum, the TREE_VALUE is the
21359 CONST_DECL, not the corresponding INTEGER_CST. */
21364 /* Give this enumeration constant the correct access. */
21367 /* Actually build the enumerator itself. */
21368 build_enumerator
21370 }
21380 }
21382 /* DECL is a FUNCTION_DECL that is a template specialization. Return
21383 its type -- but without substituting the innermost set of template
21384 arguments. So, innermost set of template parameters will appear in
21385 the type. */
21387 tree
21389 {
21390 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
21392 }
21394 /* Return truthvalue if we're processing a template different from
21395 the last one involved in diagnostics. */
21396 bool
21398 {
21400 }
21402 /* Remember current template involved in diagnostics. */
21403 void
21405 {
21407 }
21411 {
21413 }
21415 /* Return TRUE if current_function_decl is being instantiated, false
21416 otherwise. */
21418 bool
21420 {
21423 }
21425 /* [temp.param] Check that template non-type parm TYPE is of an allowable
21426 type. Return zero for ok, nonzero for disallowed. Issue error and
21427 warning messages under control of COMPLAIN. */
21429 static int
21431 {
21448 {
21451 else
21453 type);
21454 }
21456 }
21458 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
21459 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
21461 static bool
21463 {
21464 tree scope;
21466 /* [temp.dep.type]
21468 A type is dependent if it is:
21470 -- a template parameter. Template template parameters are types
21471 for us (since TYPE_P holds true for them) so we handle
21472 them here. */
21476 /* -- a qualified-id with a nested-name-specifier which contains a
21477 class-name that names a dependent type or whose unqualified-id
21478 names a dependent type. */
21481 /* -- a cv-qualified type where the cv-unqualified type is
21482 dependent.
21483 No code is necessary for this bullet; the code below handles
21484 cv-qualified types, and we don't want to strip aliases with
21485 TYPE_MAIN_VARIANT because of DR 1558. */
21486 /* -- a compound type constructed from any dependent type. */
21496 {
21497 tree arg_type;
21502 arg_type;
21507 }
21508 /* -- an array type constructed from any dependent type or whose
21509 size is specified by a constant expression that is
21510 value-dependent.
21512 We checked for type- and value-dependence of the bounds in
21513 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
21515 {
21520 }
21522 /* -- a template-id in which either the template name is a template
21523 parameter ... */
21526 /* ... or any of the template arguments is a dependent type or
21527 an expression that is type-dependent or value-dependent. */
21529 && (any_dependent_template_arguments_p
21532 /* For an alias template specialization, check the arguments both to the
21533 class template and the alias template. */
21535 && (any_dependent_template_arguments_p
21539 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
21540 dependent; if the argument of the `typeof' expression is not
21541 type-dependent, then it should already been have resolved. */
21547 /* A template argument pack is dependent if any of its packed
21548 arguments are. */
21550 {
21556 }
21558 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
21559 be template parameters. */
21563 /* The standard does not specifically mention types that are local
21564 to template functions or local classes, but they should be
21565 considered dependent too. For example:
21567 template <int I> void f() {
21568 enum E { a = I };
21569 S<sizeof (E)> s;
21570 }
21572 The size of `E' cannot be known until the value of `I' has been
21573 determined. Therefore, `E' must be considered dependent. */
21577 /* Don't use type_dependent_expression_p here, as it can lead
21578 to infinite recursion trying to determine whether a lambda
21579 nested in a lambda is dependent (c++/47687). */
21583 && (any_dependent_template_arguments_p
21587 /* Other types are non-dependent. */
21589 }
21591 /* Returns TRUE if TYPE is dependent, in the sense of
21592 [temp.dep.type]. Note that a NULL type is considered dependent. */
21594 bool
21596 {
21597 /* If there are no template parameters in scope, then there can't be
21598 any dependent types. */
21600 {
21601 /* If we are not processing a template, then nobody should be
21602 providing us with a dependent type. */
21606 }
21608 /* If the type is NULL, we have not computed a type for the entity
21609 in question; in that case, the type is dependent. */
21613 /* Erroneous types can be considered non-dependent. */
21617 /* If we have not already computed the appropriate value for TYPE,
21618 do so now. */
21620 {
21623 }
21626 }
21628 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
21629 lookup. In other words, a dependent type that is not the current
21630 instantiation. */
21632 bool
21634 {
21637 }
21639 /* T is a SCOPE_REF; return whether we need to consider it
21640 instantiation-dependent so that we can check access at instantiation
21641 time even though we know which member it resolves to. */
21643 static bool
21645 {
21651 else
21653 }
21655 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
21656 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
21657 expression. */
21659 /* Note that this predicate is not appropriate for general expressions;
21660 only constant expressions (that satisfy potential_constant_expression)
21661 can be tested for value dependence. */
21663 bool
21665 {
21669 /* A name declared with a dependent type. */
21674 {
21676 /* A name that has not been looked up -- must be dependent. */
21680 /* A non-type template parm. */
21684 /* A non-type template parm. */
21690 /* A constant with literal type and is initialized
21691 with an expression that is value-dependent.
21693 Note that a non-dependent parenthesized initializer will have
21694 already been replaced with its constant value, so if we see
21695 a TREE_LIST it must be dependent. */
21699 /* cp_finish_decl doesn't fold reference initializers. */
21710 /* These expressions are value-dependent if the type to which
21711 the cast occurs is dependent or the expression being casted
21712 is value-dependent. */
21713 {
21719 /* A functional cast has a list of operands. */
21722 {
21723 /* If there are no operands, it must be an expression such
21724 as "int()". This should not happen for aggregate types
21725 because it would form non-constant expressions. */
21730 }
21736 }
21741 /* FALLTHRU */
21744 /* A `sizeof' expression is value-dependent if the operand is
21745 type-dependent or is a pack expansion. */
21754 /* An 'encode' expression is value-dependent if the operand is
21755 type-dependent. */
21764 /* All instantiation-dependent expressions should also be considered
21765 value-dependent. */
21773 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21774 is value-dependent. */
21775 {
21784 }
21787 {
21791 }
21802 {
21806 }
21809 /* Treat all requires-expressions as value-dependent so
21810 we don't try to fold them. */
21819 {
21826 {
21828 /* In a call to a constexpr member function, look through the
21829 implicit ADDR_EXPR on the object argument so that it doesn't
21830 cause the call to be considered value-dependent. We also
21831 look through it in potential_constant_expression. */
21838 }
21840 }
21843 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21844 type-dependent. */
21848 {
21850 tree val;
21857 }
21860 /* Treat a GNU statement expression as dependent to avoid crashing
21861 under instantiate_non_dependent_expr; it can't be constant. */
21865 /* A constant expression is value-dependent if any subexpression is
21866 value-dependent. */
21868 {
21875 {
21879 {
21882 /* In some cases, some of the operands may be missing.l
21883 (For example, in the case of PREDECREMENT_EXPR, the
21884 amount to increment by may be missing.) That doesn't
21885 make the expression dependent. */
21888 }
21889 }
21893 }
21895 }
21897 /* The expression is not value-dependent. */
21899 }
21901 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21902 [temp.dep.expr]. Note that an expression with no type is
21903 considered dependent. Other parts of the compiler arrange for an
21904 expression with type-dependent subexpressions to have no type, so
21905 this function doesn't have to be fully recursive. */
21907 bool
21909 {
21916 /* An unresolved name is always dependent. */
21922 /* Some expression forms are never type-dependent. */
21936 /* The types of these expressions depends only on the type to which
21937 the cast occurs. */
21946 /* The types of these expressions depends only on the type created
21947 by the expression. */
21950 {
21951 /* For NEW_EXPR tree nodes created inside a template, either
21952 the object type itself or a TREE_LIST may appear as the
21953 operand 1. */
21956 /* This is an array type. We need to check array dimensions
21957 as well. */
21959 || value_dependent_expression_p
21961 else
21963 }
21966 {
21970 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21971 contains an identifier associated by name lookup with one or more
21972 declarations declared with a dependent type, or...a
21973 nested-name-specifier or qualified-id that names a member of an
21974 unknown specialization. */
21977 }
21982 && (any_dependent_template_arguments_p
21994 {
21995 tree elt;
21999 {
22002 }
22004 }
22006 /* A static data member of the current instantiation with incomplete
22007 array type is type-dependent, as the definition and specializations
22008 can have different bounds. */
22015 /* An array of unknown bound depending on a variadic parameter, eg:
22017 template<typename... Args>
22018 void foo (Args... args)
22019 {
22020 int arr[] = { args... };
22021 }
22023 template<int... vals>
22024 void bar ()
22025 {
22026 int arr[] = { vals... };
22027 }
22029 If the array has no length and has an initializer, it must be that
22030 we couldn't determine its length in cp_complete_array_type because
22031 it is dependent. */
22038 /* A variable template specialization is type-dependent if it has any
22039 dependent template arguments. */
22047 {
22052 {
22058 }
22059 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
22063 /* Always dependent, on the number of arguments if nothing else. */
22068 {
22073 }
22076 {
22081 }
22086 {
22090 }
22092 }
22097 }
22099 /* walk_tree callback function for instantiation_dependent_expression_p,
22100 below. Returns non-zero if a dependent subexpression is found. */
22102 static tree
22105 {
22107 {
22108 /* We don't have to worry about decltype currently because decltype
22109 of an instantiation-dependent expr is a dependent type. This
22110 might change depending on the resolution of DR 1172. */
22113 }
22116 {
22117 /* Don't treat an argument list as dependent just because it has no
22118 TREE_TYPE. */
22125 /* A constant with a dependent initializer is dependent. */
22133 /* Handle expressions with type operands. */
22138 {
22143 {
22146 else
22147 {
22150 }
22151 }
22153 }
22156 {
22164 }
22168 /* In a template, finish_class_member_access_expr creates a
22169 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
22170 type-dependent, so that we can check access control at
22171 instantiation time (PR 42277). See also Core issue 1273. */
22178 else
22181 /* Treat statement-expressions as dependent. */
22186 /* Treat requires-expressions as dependent. */
22191 }
22195 else
22197 }
22199 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
22200 sense defined by the ABI:
22202 "An expression is instantiation-dependent if it is type-dependent
22203 or value-dependent, or it has a subexpression that is type-dependent
22204 or value-dependent." */
22206 bool
22208 {
22209 tree result;
22220 }
22222 /* Like type_dependent_expression_p, but it also works while not processing
22223 a template definition, i.e. during substitution or mangling. */
22225 bool
22227 {
22233 }
22235 /* Returns TRUE if ARGS contains a type-dependent expression. */
22237 bool
22239 {
22241 tree arg;
22244 {
22247 }
22249 }
22251 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
22252 expressions) contains any type-dependent expressions. */
22254 bool
22256 {
22262 }
22264 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
22265 expressions) contains any value-dependent expressions. */
22267 bool
22269 {
22275 }
22277 /* Returns TRUE if the ARG (a template argument) is dependent. */
22279 bool
22281 {
22285 /* Assume a template argument that was wrongly written by the user
22286 is dependent. This is consistent with what
22287 any_dependent_template_arguments_p [that calls this function]
22288 does. */
22299 {
22303 {
22306 }
22309 }
22312 else
22315 }
22317 /* Returns true if ARGS (a collection of template arguments) contains
22318 any types that require structural equality testing. */
22320 bool
22322 {
22332 {
22335 {
22341 {
22342 /* Look inside the argument pack. */
22345 }
22348 {
22361 }
22362 }
22363 }
22366 }
22368 /* Returns true if ARGS (a collection of template arguments) contains
22369 any dependent arguments. */
22371 bool
22373 {
22383 {
22388 }
22391 }
22393 /* Returns TRUE if the template TMPL is dependent. */
22395 bool
22397 {
22399 {
22401 {
22405 }
22407 }
22409 /* Template template parameters are dependent. */
22413 /* So are names that have not been looked up. */
22416 /* So are member templates of dependent classes. */
22420 }
22422 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
22424 bool
22426 {
22429 }
22431 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
22432 is dependent. */
22434 bool
22436 {
22443 {
22464 {
22468 }
22472 {
22476 {
22481 }
22482 }
22483 }
22486 }
22488 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
22489 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
22490 no such TYPE can be found. Note that this function peers inside
22491 uninstantiated templates and therefore should be used only in
22492 extremely limited situations. ONLY_CURRENT_P restricts this
22493 peering to the currently open classes hierarchy (which is required
22494 when comparing types). */
22496 tree
22498 {
22499 tree scope;
22500 tree name;
22501 tree decl;
22503 tree pushed_scope;
22504 tree result;
22509 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
22510 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
22511 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
22512 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
22513 identifier of the TYPENAME_TYPE anymore.
22514 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
22515 TYPENAME_TYPE instead, we avoid messing up with a possible
22516 typedef variant case. */
22519 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
22520 it first before we can figure out what NAME refers to. */
22522 {
22524 /* Given a class template A with a dependent base with nested type C,
22525 typedef typename A::C::C C will land us here, as trying to resolve
22526 the initial A::C leads to the local C typedef, which leads back to
22527 A::C::C. So we break the recursion now. */
22529 else
22531 }
22532 /* If we don't know what SCOPE refers to, then we cannot resolve the
22533 TYPENAME_TYPE. */
22536 /* If the SCOPE is a template type parameter, we have no way of
22537 resolving the name. */
22540 /* If the SCOPE is not the current instantiation, there's no reason
22541 to look inside it. */
22544 /* If this is a typedef, we don't want to look inside (c++/11987). */
22547 /* If SCOPE isn't the template itself, it will not have a valid
22548 TYPE_FIELDS list. */
22550 /* scope is either the template itself or a compatible instantiation
22551 like X<T>, so look up the name in the original template. */
22553 else
22554 /* scope is a partial instantiation, so we can't do the lookup or we
22555 will lose the template arguments. */
22557 /* Enter the SCOPE so that name lookup will be resolved as if we
22558 were in the class definition. In particular, SCOPE will no
22559 longer be considered a dependent type. */
22561 /* Look up the declaration. */
22563 tf_warning_or_error);
22567 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
22568 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
22573 {
22577 }
22580 {
22581 tree tmpl;
22582 tree args;
22583 /* Obtain the template and the arguments. */
22586 /* Instantiate the template. */
22592 }
22594 /* Leave the SCOPE. */
22598 /* If we failed to resolve it, return the original typename. */
22602 /* If lookup found a typename type, resolve that too. */
22604 {
22605 /* Ill-formed programs can cause infinite recursion here, so we
22606 must catch that. */
22610 }
22612 /* Qualify the resulting type. */
22618 }
22620 /* EXPR is an expression which is not type-dependent. Return a proxy
22621 for EXPR that can be used to compute the types of larger
22622 expressions containing EXPR. */
22624 tree
22626 {
22627 tree inner_expr;
22629 #ifdef ENABLE_CHECKING
22630 /* Try to get a constant value for all non-dependent expressions in
22631 order to expose bugs in *_dependent_expression_p and constexpr. */
22634 #endif
22636 /* Preserve OVERLOADs; the functions must be available to resolve
22637 types. */
22648 /* There is no need to return a proxy for a variable. */
22651 /* Preserve string constants; conversions from string constants to
22652 "char *" are allowed, even though normally a "const char *"
22653 cannot be used to initialize a "char *". */
22656 /* Preserve void and arithmetic constants, as an optimization -- there is no
22657 reason to create a new node. */
22662 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22663 There is at least one place where we want to know that a
22664 particular expression is a throw-expression: when checking a ?:
22665 expression, there are special rules if the second or third
22666 argument is a throw-expression. */
22670 /* Don't wrap an initializer list, we need to be able to look inside. */
22674 /* Don't wrap a dummy object, we need to be able to test for it. */
22693 /* If the type is unknown, it can't really be non-dependent */
22696 /* Otherwise, build a NON_DEPENDENT_EXPR. */
22698 }
22700 /* ARGS is a vector of expressions as arguments to a function call.
22701 Replace the arguments with equivalent non-dependent expressions.
22702 This modifies ARGS in place. */
22704 void
22706 {
22708 tree arg;
22711 {
22715 }
22716 }
22718 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22719 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22720 parms. */
22722 static tree
22724 {
22737 }
22739 tree
22741 {
22743 }
22745 tree
22747 {
22749 }
22751 /* Given type ARG, return std::initializer_list<ARG>. */
22753 static tree
22755 {
22756 tree std_init_list = namespace_binding
22758 tree argvec;
22760 {
22764 }
22769 }
22771 /* Replace auto in TYPE with std::initializer_list<auto>. */
22773 static tree
22775 {
22782 }
22784 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22785 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22787 tree
22789 {
22790 tree targs;
22796 /* Defining a subset of type-dependent expressions that we can deduce
22797 from ahead of time isn't worth the trouble. */
22800 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22801 with either a new invented type template parameter U or, if the
22802 initializer is a braced-init-list (8.5.4), with
22803 std::initializer_list<U>. */
22805 {
22810 else
22811 {
22815 "for deduction to %<std::initializer_list%>, use copy-"
22818 }
22819 }
22825 {
22831 {
22834 }
22835 }
22836 else
22837 {
22848 {
22850 /* Try again at instantiation time. */
22853 /* If type is error_mark_node a diagnostic must have been
22854 emitted by now. Also, having a mention to '<type error>'
22855 in the diagnostic is not really useful to the user. */
22856 {
22860 else
22862 }
22864 }
22865 }
22867 /* If the list of declarators contains more than one declarator, the type
22868 of each declared variable is determined as described above. If the
22869 type deduced for the template parameter U is not the same in each
22870 deduction, the program is ill-formed. */
22873 {
22879 else
22883 }
22889 }
22891 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22892 result. */
22894 tree
22896 {
22897 tree argvec;
22904 /* For a late-specified return type in a template type-parameter, we
22905 need to add a dummy argument level for its parmlist. */
22906 argvec = add_to_template_args
22911 }
22913 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22914 'decltype(auto)'. */
22916 bool
22918 {
22923 else
22925 }
22927 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22928 a use of `auto'. Returns NULL_TREE otherwise. */
22930 tree
22932 {
22934 }
22936 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22937 'decltype(auto)' or a concept. */
22939 bool
22941 {
22943 }
22945 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22946 a concept identifier) iff TYPE contains a use of a generic type. Returns
22947 NULL_TREE otherwise. */
22949 tree
22951 {
22953 }
22956 /* For a given template T, return the vector of typedefs referenced
22957 in T for which access check is needed at T instantiation time.
22958 T is either a FUNCTION_DECL or a RECORD_TYPE.
22959 Those typedefs were added to T by the function
22960 append_type_to_template_for_access_check. */
22964 {
22965 tree ti;
22976 {
22981 }
22984 }
22986 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22987 tied to T. That list of typedefs will be access checked at
22988 T instantiation time.
22989 T is either a FUNCTION_DECL or a RECORD_TYPE.
22990 TYPE_DECL is a TYPE_DECL node representing a typedef.
22991 SCOPE is the scope through which TYPE_DECL is accessed.
22992 LOCATION is the location of the usage point of TYPE_DECL.
22994 This function is a subroutine of
22995 append_type_to_template_for_access_check. */
22997 static void
22999 tree type_decl,
23000 tree scope,
23001 location_t location)
23002 {
23003 qualified_typedef_usage_t typedef_usage;
23004 tree ti;
23011 && type_decl
23025 }
23027 /* Append TYPE_DECL to the template TEMPL.
23028 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
23029 At TEMPL instanciation time, TYPE_DECL will be checked to see
23030 if it can be accessed through SCOPE.
23031 LOCATION is the location of the usage point of TYPE_DECL.
23033 e.g. consider the following code snippet:
23035 class C
23036 {
23037 typedef int myint;
23038 };
23040 template<class U> struct S
23041 {
23042 C::myint mi; // <-- usage point of the typedef C::myint
23043 };
23045 S<char> s;
23047 At S<char> instantiation time, we need to check the access of C::myint
23048 In other words, we need to check the access of the myint typedef through
23049 the C scope. For that purpose, this function will add the myint typedef
23050 and the scope C through which its being accessed to a list of typedefs
23051 tied to the template S. That list will be walked at template instantiation
23052 time and access check performed on each typedefs it contains.
23053 Note that this particular code snippet should yield an error because
23054 myint is private to C. */
23056 void
23058 tree type_decl,
23059 tree scope,
23060 location_t location)
23061 {
23067 /* Make sure we don't append the type to the template twice. */
23074 }
23076 /* Convert the generic type parameters in PARM that match the types given in the
23077 range [START_IDX, END_IDX) from the current_template_parms into generic type
23078 packs. */
23080 tree
23082 {
23093 {
23094 /* Create a distinct parameter pack type from the current parm and add it
23095 to the replacement args to tsubst below into the generic function
23096 parameter. */
23111 }
23117 /* If there are more levels then build up the replacement with the outer
23118 template parms. */
23122 replacement);
23125 }
23127 /* Entries in the decl_constraint hash table. */
23129 {
23130 tree decl;
23131 tree ci;
23132 };
23134 /* Hashing function and equality fo constraint entries.. */
23136 {
23138 {
23140 }
23143 {
23145 }
23146 };
23149 /* A mapping from declarations to constraint information. Note that
23150 both templates and their underlying declarations are mapped to the
23151 same constraint information.
23153 FIXME: This is defined in pt.c because it's garbage collection
23154 code is not being generated for constraint.cc. */
23157 /* Returns true iff cinfo contains a valid set of constraints.
23158 This is the case when the associated requirements have been
23159 successfully decomposed into lists of atomic constraints.
23160 That is, when the saved assumptions are not error_mark_node. */
23161 bool
23163 {
23166 }
23168 /* Returns the template constraints of declaration T. If T is not
23169 constrained, return NULL_TREE. Note that T must be non-null. */
23170 tree
23172 {
23180 else
23182 }
23184 /* Associate the given constraint information CI with the declaration
23185 T. If T is a template, then the constraints are associated with
23186 its underlying declaration. Don't build associations if CI is
23187 NULL_TREE. */
23188 void
23190 {
23202 }
23204 /* Remove the associated constraints of the declaration T.
23205 If there are no constraints associated with T, then
23206 return NULL_TREE. */
23207 void
23209 {
23218 }
23220 /* Set up the hash table for constraint association. */
23222 void
23224 {
23226 }
23228 /* Set up the hash tables for template instantiations. */
23230 void
23232 {
23235 }
23237 /* Print stats about the template hash tables for -fstats. */
23239 void
23241 {
23250 }