| blob | e327da4d0a4c4b03a818f240a77091c1c1159076 |
1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2014 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". */
51 /* The type of functions taking a tree, and some additional data, and
52 returning an int. */
55 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
56 instantiations have been deferred, either because their definitions
57 were not yet available, or because we were putting off doing the work. */
61 };
76 /* Live only within one (recursive) call to tsubst_expr. We use
77 this to pass the statement expression node from the STMT_EXPR
78 to the EXPR_STMT that is its result. */
81 // -------------------------------------------------------------------------- //
82 // Local Specialization Stack
83 //
84 // Implementation of the RAII helper for creating new local
85 // specializations.
88 {
90 }
93 {
96 }
98 /* True if we've recursed into fn_type_unification too many times. */
102 {
103 tree tmpl;
104 tree args;
105 tree spec;
109 htab_t decl_specializations;
112 htab_t type_specializations;
114 /* Contains canonical template parameter types. The vector is indexed by
115 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
116 TREE_LIST, whose TREE_VALUEs contain the canonical template
117 parameters of various types and levels. */
120 #define UNIFY_ALLOW_NONE 0
121 #define UNIFY_ALLOW_MORE_CV_QUAL 1
122 #define UNIFY_ALLOW_LESS_CV_QUAL 2
123 #define UNIFY_ALLOW_DERIVED 4
124 #define UNIFY_ALLOW_INTEGER 8
125 #define UNIFY_ALLOW_OUTER_LEVEL 16
126 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
127 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
130 tbr_incomplete_type,
131 tbr_ambiguous_baseclass,
132 tbr_success
133 };
156 tree);
216 location_t);
222 /* Make the current scope suitable for access checking when we are
223 processing T. T can be FUNCTION_DECL for instantiated function
224 template, VAR_DECL for static member variable, or TYPE_DECL for
225 alias template (needed by instantiate_decl). */
227 static void
229 {
237 else
241 {
242 saved_access_scope = tree_cons
245 }
246 }
248 /* Restore the scope set up by push_access_scope. T is the node we
249 are processing. */
251 static void
253 {
255 {
258 }
262 else
264 }
266 /* Do any processing required when DECL (a member template
267 declaration) is finished. Returns the TEMPLATE_DECL corresponding
268 to DECL, unless it is a specialization, in which case the DECL
269 itself is returned. */
271 tree
273 {
280 {
281 tree type;
289 {
293 }
295 }
299 {
301 {
304 }
305 else
307 }
308 else
312 }
314 /* Create a template info node. */
316 tree
318 {
323 }
325 /* Return the template info node corresponding to T, whatever T is. */
327 tree
329 {
347 }
349 /* Returns the template nesting level of the indicated class TYPE.
351 For example, in:
352 template <class T>
353 struct A
354 {
355 template <class U>
356 struct B {};
357 };
359 A<T>::B<U> has depth two, while A<T> has depth one.
360 Both A<T>::B<int> and A<int>::B<U> have depth one, if
361 they are instantiations, not specializations.
363 This function is guaranteed to return 0 if passed NULL_TREE so
364 that, for example, `template_class_depth (current_class_type)' is
365 always safe. */
367 int
369 {
376 {
382 }
385 }
387 /* Subroutine of maybe_begin_member_template_processing.
388 Returns true if processing DECL needs us to push template parms. */
390 static bool
392 {
398 }
400 /* Subroutine of maybe_begin_member_template_processing.
401 Push the template parms in PARMS, starting from LEVELS steps into the
402 chain, and ending at the beginning, since template parms are listed
403 innermost first. */
405 static void
407 {
415 current_template_parms
421 NULL);
423 {
432 {
439 {
440 /* Make a CONST_DECL as is done in process_template_parm.
441 It is ugly that we recreate this here; the original
442 version built in process_template_parm is no longer
443 available. */
453 }
458 }
459 }
460 }
462 /* Restore the template parameter context for a member template, a
463 friend template defined in a class definition, or a non-template
464 member of template class. */
466 void
468 {
469 tree parms;
479 {
484 {
487 }
490 }
492 /* Remember how many levels of template parameters we pushed so that
493 we can pop them later. */
495 }
497 /* Undo the effects of maybe_begin_member_template_processing. */
499 void
501 {
510 {
514 }
515 }
517 /* Return a new template argument vector which contains all of ARGS,
518 but has as its innermost set of arguments the EXTRA_ARGS. */
520 static tree
522 {
523 tree new_args;
541 }
543 /* Like add_to_template_args, but only the outermost ARGS are added to
544 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
545 (EXTRA_ARGS) levels are added. This function is used to combine
546 the template arguments from a partial instantiation with the
547 template arguments used to attain the full instantiation from the
548 partial instantiation. */
550 static tree
552 {
553 tree new_args;
555 /* If there are more levels of EXTRA_ARGS than there are ARGS,
556 something very fishy is going on. */
559 /* If *all* the new arguments will be the EXTRA_ARGS, just return
560 them. */
564 /* For the moment, we make ARGS look like it contains fewer levels. */
569 /* Now, we restore ARGS to its full dimensions. */
573 }
575 /* Return the N levels of innermost template arguments from the ARGS. */
577 tree
579 {
580 tree new_args;
586 /* If N is 1, just return the innermost set of template arguments. */
590 /* If we're not removing anything, just return the arguments we were
591 given. */
597 /* Make a new set of arguments, not containing the outer arguments. */
604 }
606 /* The inverse of get_innermost_template_args: Return all but the innermost
607 EXTRA_LEVELS levels of template arguments from the ARGS. */
609 static tree
611 {
612 tree new_args;
618 /* If N is 1, just return the outermost set of template arguments. */
622 /* If we're not removing anything, just return the arguments we were
623 given. */
628 /* Make a new set of arguments, not containing the inner arguments. */
635 }
637 /* We've got a template header coming up; push to a new level for storing
638 the parms. */
640 void
642 {
643 /* We use a non-tag-transparent scope here, which causes pushtag to
644 put tags in this scope, rather than in the enclosing class or
645 namespace scope. This is the right thing, since we want
646 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
647 global template class, push_template_decl handles putting the
648 TEMPLATE_DECL into top-level scope. For a nested template class,
649 e.g.:
651 template <class T> struct S1 {
652 template <class T> struct S2 {};
653 };
655 pushtag contains special code to call pushdecl_with_scope on the
656 TEMPLATE_DECL for S2. */
661 }
663 /* This routine is called when a specialization is declared. If it is
664 invalid to declare a specialization here, an error is reported and
665 false is returned, otherwise this routine will return true. */
667 static bool
669 {
672 /* [temp.expl.spec]
674 An explicit specialization shall be declared in the namespace of
675 which the template is a member, or, for member templates, in the
676 namespace of which the enclosing class or enclosing class
677 template is a member. An explicit specialization of a member
678 function, member class or static data member of a class template
679 shall be declared in the namespace of which the class template
680 is a member. */
682 {
685 }
687 /* [temp.expl.spec]
689 In an explicit specialization declaration for a member of a class
690 template or a member template that appears in namespace scope,
691 the member template and some of its enclosing class templates may
692 remain unspecialized, except that the declaration shall not
693 explicitly specialize a class member template if its enclosing
694 class templates are not explicitly specialized as well. */
696 {
699 }
702 }
704 /* We've just seen template <>. */
706 bool
708 {
712 }
714 /* Called at then end of processing a declaration preceded by
715 template<>. */
717 void
719 {
722 }
724 /* Any template <>'s that we have seen thus far are not referring to a
725 function specialization. */
727 void
729 {
732 }
734 /* We've just seen a template header. If SPECIALIZATION is nonzero,
735 it was of the form template <>. */
737 static void
739 {
741 template_header_count++;
742 }
744 /* We're beginning an explicit instantiation. */
746 void
748 {
751 }
754 void
756 {
759 }
761 /* An explicit specialization or partial specialization of TMPL is being
762 declared. Check that the namespace in which the specialization is
763 occurring is permissible. Returns false iff it is invalid to
764 specialize TMPL in the current namespace. */
766 static bool
768 {
771 /* [tmpl.expl.spec]
773 An explicit specialization shall be declared in the namespace of
774 which the template is a member, or, for member templates, in the
775 namespace of which the enclosing class or enclosing class
776 template is a member. An explicit specialization of a member
777 function, member class or static data member of a class template
778 shall be declared in the namespace of which the class template is
779 a member. */
782 {
785 }
787 /* Same or super-using namespace. */
789 else
790 {
794 }
795 }
797 /* SPEC is an explicit instantiation. Check that it is valid to
798 perform this explicit instantiation in the current namespace. */
800 static void
802 {
803 tree ns;
805 /* DR 275: An explicit instantiation shall appear in an enclosing
806 namespace of its template. */
812 }
814 // Returns the TEMPLATE_DECL that defines the partial template specialization
815 // TYPE. If TYPE is not found in the list of partial specializations, then
816 // it must be an explicit specialization.
817 static tree
819 {
824 {
829 }
831 }
833 // Return the template constraints for the template specialization TYPE.
836 {
837 // If TYPE is a partial specialization, return the constraints for
838 // that type. If it is an explicit specialization, return null since
839 // non-templates cannot be constrained.
842 else
844 }
846 // Returns the type of a template specialization only if that
847 // specialization needs to defined. Otherwise (e.g., if the type has
848 // already been defined), the function returns NULL_TREE.
849 static tree
851 {
852 // An implicit instantiation of an incomplete type implies
853 // the definition of a new class template.
854 //
855 // template<typename T>
856 // struct S;
857 //
858 // template<typename T>
859 // struct S<T*>;
860 //
861 // Here, S<T*> is an implicit instantiation of S whose type
862 // is incomplete.
866 // It can also be the case that is a completed specialization.
867 // Continuing the previous example, suppose we also declare:
868 //
869 // template<typename T>
870 // requires Integral<T>
871 // struct S<T*>;
872 //
873 // Here, S<T*> refers to the specialization S<T*> defined
874 // above. However, we need to differentiate definitions because
875 // we intend to define a new partial specialization. In this case,
876 // we rely on the fact that the constraints are different for
877 // this declaration than that above.
878 //
879 // Note that we also get here for injected class names and
880 // late-parsed template definitions. We must ensure that we
881 // do not create new type declarations for those cases.
883 {
886 {
890 // Create a new type node (and corresponding type decl) that
891 // for the newly declared specialization.
899 // Build the corresponding type decl.
905 }
906 }
908 }
910 /* The TYPE is being declared. If it is a template type, that means it
911 is a partial specialization. Do appropriate error-checking. */
913 tree
915 {
916 tree context;
921 /* A lambda that appears in specialization context is not itself a
922 specialization. */
927 {
931 }
936 {
941 else
944 }
946 {
947 /* This is for ordinary explicit specialization and partial
948 specialization of a template class such as:
950 template <> class C<int>;
952 or:
954 template <class T> class C<T*>;
956 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
959 {
964 {
969 }
970 }
976 /* Trying to define a specialization either without a template<> header
977 or in an inappropriate place. We've already given an error, so just
978 bail now so we don't actually define the specialization. */
980 }
986 {
987 /* This is for an explicit specialization of member class
988 template according to [temp.expl.spec/18]:
990 template <> template <class U> class C<int>::D;
992 The context `C<int>' must be an implicit instantiation.
993 Otherwise this is just a member class template declared
994 earlier like:
996 template <> class C<int> { template <class U> class D; };
997 template <> template <class U> class C<int>::D;
999 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1000 while in the second case, `C<int>::D' is a primary template
1001 and `C<T>::D' may not exist. */
1005 {
1006 tree t;
1011 {
1014 }
1016 /* Check for invalid specialization after instantiation:
1018 template <> template <> class C<int>::D<int>;
1019 template <> template <class U> class C<int>::D; */
1023 {
1027 {
1028 /* We already have a full specialization of this partial
1029 instantiation, or a full specialization has been
1030 looked up but not instantiated. Reassign it to the
1031 new member specialization template. */
1032 spec_entry elt;
1049 }
1050 else
1051 /* But if we've had an implicit instantiation, that's a
1052 problem ([temp.expl.spec]/6). */
1055 }
1057 /* Mark TYPE as a specialization. And as a result, we only
1058 have one level of template argument for the innermost
1059 class template. */
1064 }
1065 }
1067 {
1068 /* Someday C++0x may allow for enum template specialization. */
1073 else
1074 {
1077 }
1078 }
1081 }
1083 /* Returns nonzero if we can optimize the retrieval of specializations
1084 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1085 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1089 {
1092 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1093 parameter. */
1095 /* The optimized lookup depends on the fact that the
1096 template arguments for the member function template apply
1097 purely to the containing class, which is not true if the
1098 containing class is an explicit or partial
1099 specialization. */
1103 /* It is possible to have a template that is not a member
1104 template and is not a member of a template class:
1106 template <typename T>
1107 struct S { friend A::f(); };
1109 Here, the friend function is a template, but the context does
1110 not have template information. The optimized lookup relies
1111 on having ARGS be the template arguments for both the class
1112 and the function template. */
1114 }
1116 /* Retrieve the specialization (in the sense of [temp.spec] - a
1117 specialization is either an instantiation or an explicit
1118 specialization) of TMPL for the given template ARGS. If there is
1119 no such specialization, return NULL_TREE. The ARGS are a vector of
1120 arguments, or a vector of vectors of arguments, in the case of
1121 templates with more than one level of parameters.
1123 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1124 then we search for a partial specialization matching ARGS. This
1125 parameter is ignored if TMPL is not a class template.
1127 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1128 result is a NONTYPE_ARGUMENT_PACK. */
1130 static tree
1132 {
1142 /* There should be as many levels of arguments as there are
1143 levels of parameters. */
1150 {
1151 tree class_template;
1152 tree class_specialization;
1154 tree fns;
1157 /* The template arguments actually apply to the containing
1158 class. Find the class specialization with those
1159 arguments. */
1161 class_specialization
1165 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1166 for the specialization. */
1170 /* Iterate through the methods with the indicated name, looking
1171 for the one that has an instance of TMPL. */
1174 {
1177 /* using-declarations can add base methods to the method vec,
1178 and we don't want those here. */
1181 }
1183 }
1184 else
1185 {
1187 spec_entry elt;
1188 htab_t specializations;
1196 else
1204 }
1207 }
1209 /* Like retrieve_specialization, but for local declarations. */
1211 tree
1213 {
1221 }
1223 /* Returns nonzero iff DECL is a specialization of TMPL. */
1225 int
1227 {
1228 tree t;
1231 {
1237 }
1238 else
1239 {
1248 }
1251 }
1253 /* Returns nonzero iff DECL is a specialization of friend declaration
1254 FRIEND_DECL according to [temp.friend]. */
1256 bool
1258 {
1265 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1266 of a template class, we want to check if DECL is a specialization
1267 if this. */
1271 {
1272 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1275 }
1280 /* There is nothing to do if this is not a template friend. */
1287 /* [temp.friend/6]
1288 A member of a class template may be declared to be a friend of a
1289 non-template class. In this case, the corresponding member of
1290 every specialization of the class template is a friend of the
1291 class granting friendship.
1293 For example, given a template friend declaration
1295 template <class T> friend void A<T>::f();
1297 the member function below is considered a friend
1299 template <> struct A<int> {
1300 void f();
1301 };
1303 For this type of template friend, TEMPLATE_DEPTH below will be
1304 nonzero. To determine if DECL is a friend of FRIEND, we first
1305 check if the enclosing class is a specialization of another. */
1312 {
1313 /* Next, we check the members themselves. In order to handle
1314 a few tricky cases, such as when FRIEND_DECL's are
1316 template <class T> friend void A<T>::g(T t);
1317 template <class T> template <T t> friend void A<T>::h();
1319 and DECL's are
1321 void A<int>::g(int);
1322 template <int> void A<int>::h();
1324 we need to figure out ARGS, the template arguments from
1325 the context of DECL. This is required for template substitution
1326 of `T' in the function parameter of `g' and template parameter
1327 of `h' in the above examples. Here ARGS corresponds to `int'. */
1334 {
1336 {
1339 else
1341 current_depth++;
1342 }
1344 }
1347 {
1349 tree friend_type;
1350 tree decl_type;
1351 tree friend_args_type;
1352 tree decl_args_type;
1354 /* Make sure that both DECL and FRIEND_DECL are templates or
1355 non-templates. */
1361 {
1362 /* If both are templates, check template parameter list. */
1363 tree friend_parms
1368 friend_parms))
1372 }
1373 else
1381 /* Check if return types match. */
1385 /* Check if function parameter types match, ignoring the
1386 `this' parameter. */
1395 }
1396 else
1397 {
1398 /* DECL is a TYPE_DECL */
1402 /* Make sure that both DECL and FRIEND_DECL are templates or
1403 non-templates. */
1404 is_template
1411 {
1412 tree friend_parms;
1413 /* If both are templates, check the name of the two
1414 TEMPLATE_DECL's first because is_friend didn't. */
1419 /* Now check template parameter list. */
1420 friend_parms
1423 return comp_template_parms
1425 friend_parms);
1426 }
1427 else
1430 }
1431 }
1433 }
1435 /* Register the specialization SPEC as a specialization of TMPL with
1436 the indicated ARGS. IS_FRIEND indicates whether the specialization
1437 is actually just a friend declaration. Returns SPEC, or an
1438 equivalent prior declaration, if available.
1440 We also store instantiations of field packs in the hash table, even
1441 though they are not themselves templates, to make lookup easier. */
1443 static tree
1445 hashval_t hash)
1446 {
1447 tree fn;
1449 spec_entry elt;
1457 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1458 register it; we want the corresponding TEMPLATE_DECL instead.
1459 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1460 the more obvious `uses_template_parms (spec)' to avoid problems
1461 with default function arguments. In particular, given
1462 something like this:
1464 template <class T> void f(T t1, T t = T())
1466 the default argument expression is not substituted for in an
1467 instantiation unless and until it is actually needed. */
1471 /* We don't put these specializations in the hash table, but we might
1472 want to give an error about a mismatch. */
1474 else
1475 {
1483 slot =
1487 else
1489 }
1491 /* We can sometimes try to re-register a specialization that we've
1492 already got. In particular, regenerate_decl_from_template calls
1493 duplicate_decls which will update the specialization list. But,
1494 we'll still get called again here anyhow. It's more convenient
1495 to simply allow this than to try to prevent it. */
1499 {
1501 {
1504 {
1506 fn);
1508 }
1509 else
1510 {
1511 tree clone;
1512 /* This situation should occur only if the first
1513 specialization is an implicit instantiation, the
1514 second is an explicit specialization, and the
1515 implicit instantiation has not yet been used. That
1516 situation can occur if we have implicitly
1517 instantiated a member function and then specialized
1518 it later.
1520 We can also wind up here if a friend declaration that
1521 looked like an instantiation turns out to be a
1522 specialization:
1524 template <class T> void foo(T);
1525 class S { friend void foo<>(int) };
1526 template <> void foo(int);
1528 We transform the existing DECL in place so that any
1529 pointers to it become pointers to the updated
1530 declaration.
1532 If there was a definition for the template, but not
1533 for the specialization, we want this to look as if
1534 there were no definition, and vice versa. */
1537 /* The call to duplicate_decls will have applied
1538 [temp.expl.spec]:
1540 An explicit specialization of a function template
1541 is inline only if it is explicitly declared to be,
1542 and independently of whether its function template
1543 is.
1545 to the primary function; now copy the inline bits to
1546 the various clones. */
1548 {
1555 }
1559 }
1560 }
1562 {
1564 /* Dup decl failed, but this is a new definition. Set the
1565 line number so any errors match this new
1566 definition. */
1570 }
1571 }
1575 /* A specialization must be declared in the same namespace as the
1576 template it is specializing. */
1582 {
1590 /* TMPL is a forward declaration of a template function; keep a list
1591 of all specializations in case we need to reassign them to a friend
1592 template later in tsubst_friend_function. */
1595 }
1598 }
1600 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1601 TMPL and ARGS members, ignores SPEC. */
1605 static int
1607 {
1618 }
1620 /* Returns a hash for a template TMPL and template arguments ARGS. */
1622 static hashval_t
1624 {
1627 }
1629 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1630 ignoring SPEC. */
1632 static hashval_t
1634 {
1637 }
1639 /* Recursively calculate a hash value for a template argument ARG, for use
1640 in the hash tables of template specializations. */
1642 hashval_t
1644 {
1656 /* We can get one of these when re-hashing a previous entry in the middle
1657 of substituting into a pack expansion. Just look through it. */
1666 {
1674 {
1679 }
1701 {
1704 {
1707 }
1709 }
1713 {
1716 }
1727 val = iterative_hash_template_arg
1739 val);
1741 val);
1750 /* A lambda can't appear in a template arg, but don't crash on
1751 erroneous input. */
1763 /* Now hash operands as usual. */
1768 }
1771 {
1775 val);
1778 /* Otherwise just compare the types during lookup. */
1787 {
1792 }
1793 }
1796 }
1798 /* Unregister the specialization SPEC as a specialization of TMPL.
1799 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1800 if the SPEC was listed as a specialization of TMPL.
1802 Note that SPEC has been ggc_freed, so we can't look inside it. */
1804 bool
1806 {
1808 spec_entry elt;
1816 {
1821 }
1824 }
1826 /* Like register_specialization, but for local declarations. We are
1827 registering SPEC, an instantiation of TMPL. */
1829 void
1831 {
1836 }
1838 /* TYPE is a class type. Returns true if TYPE is an explicitly
1839 specialized class. */
1841 bool
1843 {
1847 }
1849 /* Print the list of functions at FNS, going through all the overloads
1850 for each element of the list. Alternatively, FNS can not be a
1851 TREE_LIST, in which case it will be printed together with all the
1852 overloads.
1854 MORE and *STR should respectively be FALSE and NULL when the function
1855 is called from the outside. They are used internally on recursive
1856 calls. print_candidates manages the two parameters and leaves NULL
1857 in *STR when it ends. */
1859 static void
1861 {
1867 {
1871 }
1872 else
1873 {
1876 {
1877 /* Pick the prefix string. */
1879 {
1883 }
1887 }
1890 }
1893 {
1896 }
1897 }
1899 /* Print the list of candidate FNS in an error message. FNS can also
1900 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1902 void
1904 {
1908 }
1910 /* Returns the template (one of the functions given by TEMPLATE_ID)
1911 which can be specialized to match the indicated DECL with the
1912 explicit template args given in TEMPLATE_ID. The DECL may be
1913 NULL_TREE if none is available. In that case, the functions in
1914 TEMPLATE_ID are non-members.
1916 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1917 specialization of a member template.
1919 The TEMPLATE_COUNT is the number of references to qualifying
1920 template classes that appeared in the name of the function. See
1921 check_explicit_specialization for a more accurate description.
1923 TSK indicates what kind of template declaration (if any) is being
1924 declared. TSK_TEMPLATE indicates that the declaration given by
1925 DECL, though a FUNCTION_DECL, has template parameters, and is
1926 therefore a template function.
1928 The template args (those explicitly specified and those deduced)
1929 are output in a newly created vector *TARGS_OUT.
1931 If it is impossible to determine the result, an error message is
1932 issued. The error_mark_node is returned to indicate failure. */
1934 static tree
1936 tree decl,
1940 tmpl_spec_kind tsk)
1941 {
1942 tree fns;
1943 tree targs;
1944 tree explicit_targs;
1946 /* A TREE_LIST of templates of which DECL may be a specialization.
1947 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1948 corresponding TREE_PURPOSE is the set of template arguments that,
1949 when used to instantiate the template, would produce a function
1950 with the signature of DECL. */
1960 /* We shouldn't be specializing a member template of an
1961 unspecialized class template; we already gave an error in
1962 check_specialization_scope, now avoid crashing. */
1965 {
1968 }
1976 /* Check for baselinks. */
1981 {
1984 }
1986 /* Count the number of template headers specified for this
1987 specialization. */
1995 {
1999 {
2000 tree decl_arg_types;
2001 tree fn_arg_types;
2002 tree insttype;
2004 /* In case of explicit specialization, we need to check if
2005 the number of template headers appearing in the specialization
2006 is correct. This is usually done in check_explicit_specialization,
2007 but the check done there cannot be exhaustive when specializing
2008 member functions. Consider the following code:
2010 template <> void A<int>::f(int);
2011 template <> template <> void A<int>::f(int);
2013 Assuming that A<int> is not itself an explicit specialization
2014 already, the first line specializes "f" which is a non-template
2015 member function, whilst the second line specializes "f" which
2016 is a template member function. So both lines are syntactically
2017 correct, and check_explicit_specialization does not reject
2018 them.
2020 Here, we can do better, as we are matching the specialization
2021 against the declarations. We count the number of template
2022 headers, and we check if they match TEMPLATE_COUNT + 1
2023 (TEMPLATE_COUNT is the number of qualifying template classes,
2024 plus there must be another header for the member template
2025 itself).
2027 Notice that if header_count is zero, this is not a
2028 specialization but rather a template instantiation, so there
2029 is no check we can perform here. */
2033 /* Check that the number of template arguments at the
2034 innermost level for DECL is the same as for FN. */
2042 /* DECL might be a specialization of FN. */
2046 /* For a non-static member function, we need to make sure
2047 that the const qualification is the same. Since
2048 get_bindings does not try to merge the "this" parameter,
2049 we must do the comparison explicitly. */
2055 /* Skip the "this" parameter and, for constructors of
2056 classes with virtual bases, the VTT parameter. A
2057 full specialization of a constructor will have a VTT
2058 parameter, but a template never will. */
2059 decl_arg_types
2061 fn_arg_types
2064 /* Function templates cannot be specializations; there are
2065 no partial specializations of functions. Therefore, if
2066 the type of DECL does not match FN, there is no
2067 match. */
2069 {
2073 }
2075 /* See whether this function might be a specialization of this
2076 template. Suppress access control because we might be trying
2077 to make this specialization a friend, and we have already done
2078 access control for the declaration of the specialization. */
2084 /* We cannot deduce template arguments that when used to
2085 specialize TMPL will produce DECL. */
2088 // Make sure that the deduced arguments actually work. First,
2089 // check that any template constraints are satisfied.
2090 //
2091 // TODO: Make sure that we get reasonable diagnostics for these
2092 // kinds of failures.
2096 // Then, try to form the new function type.
2100 fn_arg_types
2105 /* Save this template, and the arguments deduced. */
2107 }
2109 /* FN is an ordinary member function, and we need a
2110 specialization of a member template. */
2111 ;
2113 /* We can get IDENTIFIER_NODEs here in certain erroneous
2114 cases. */
2115 ;
2117 /* This is just an ordinary non-member function. Nothing can
2118 be a specialization of that. */
2119 ;
2121 /* Cannot specialize functions that are created implicitly. */
2122 ;
2123 else
2124 {
2125 tree decl_arg_types;
2127 /* This is an ordinary member function. However, since
2128 we're here, we can assume its enclosing class is a
2129 template class. For example,
2131 template <typename T> struct S { void f(); };
2132 template <> void S<int>::f() {}
2134 Here, S<int>::f is a non-template, but S<int> is a
2135 template class. If FN has the same type as DECL, we
2136 might be in business. */
2139 /* Its enclosing class is an explicit specialization
2140 of a template class. This is not a candidate. */
2145 /* The return types differ. */
2148 /* Adjust the type of DECL in case FN is a static member. */
2155 decl_arg_types))
2156 /* They match! */
2158 }
2159 }
2162 {
2163 /* We have:
2165 [temp.expl.spec]
2167 It is possible for a specialization with a given function
2168 signature to be instantiated from more than one function
2169 template. In such cases, explicit specification of the
2170 template arguments must be used to uniquely identify the
2171 function template specialization being specialized.
2173 Note that here, there's no suggestion that we're supposed to
2174 determine which of the candidate templates is most
2175 specialized. However, we, also have:
2177 [temp.func.order]
2179 Partial ordering of overloaded function template
2180 declarations is used in the following contexts to select
2181 the function template to which a function template
2182 specialization refers:
2184 -- when an explicit specialization refers to a function
2185 template.
2187 So, we do use the partial ordering rules, at least for now.
2188 This extension can only serve to make invalid programs valid,
2189 so it's safe. And, there is strong anecdotal evidence that
2190 the committee intended the partial ordering rules to apply;
2191 the EDG front end has that behavior, and John Spicer claims
2192 that the committee simply forgot to delete the wording in
2193 [temp.expl.spec]. */
2196 {
2199 }
2200 }
2203 {
2211 }
2215 {
2221 }
2223 /* We have one, and exactly one, match. */
2225 {
2228 /* DECL is a re-declaration or partial instantiation of a template
2229 function. */
2232 /* It was a specialization of an ordinary member function in a
2233 template class. */
2235 }
2237 /* It was a specialization of a template. */
2240 {
2245 }
2246 else
2249 }
2251 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2252 but with the default argument values filled in from those in the
2253 TMPL_TYPES. */
2255 static tree
2257 tree tmpl_types)
2258 {
2259 tree new_spec_types;
2267 /* Substitute into the rest of the list. */
2268 new_spec_types =
2272 /* Add the default argument for this parameter. */
2275 new_spec_types);
2276 }
2278 /* DECL is an explicit specialization. Replicate default arguments
2279 from the template it specializes. (That way, code like:
2281 template <class T> void f(T = 3);
2282 template <> void f(double);
2283 void g () { f (); }
2285 works, as required.) An alternative approach would be to look up
2286 the correct default arguments at the call-site, but this approach
2287 is consistent with how implicit instantiations are handled. */
2289 static void
2291 {
2292 tree tmpl;
2293 tree spec_types;
2294 tree tmpl_types;
2295 tree new_spec_types;
2296 tree old_type;
2297 tree new_type;
2298 tree t;
2303 /* See if there's anything we need to do. */
2316 {
2317 /* Remove the this pointer, but remember the object's type for
2318 CV quals. */
2324 {
2325 /* DECL may contain more parameters than TMPL due to the extra
2326 in-charge parameter in constructors and destructors. */
2329 }
2331 {
2334 }
2335 }
2337 /* Compute the merged default arguments. */
2338 new_spec_types =
2341 /* Compute the new FUNCTION_TYPE. */
2343 {
2347 new_spec_types);
2350 /* Put the in-charge parameter back. */
2353 new_spec_types);
2357 new_spec_types);
2358 }
2359 else
2361 new_spec_types);
2367 }
2369 /* Return the number of template headers we expect to see for a definition
2370 or specialization of CTYPE or one of its non-template members. */
2372 int
2374 {
2378 {
2379 /* You're supposed to have one `template <...>' for every
2380 template class, but you don't need one for a full
2381 specialization. For example:
2383 template <class T> struct S{};
2384 template <> struct S<int> { void f(); };
2385 void S<int>::f () {}
2387 is correct; there shouldn't be a `template <>' for the
2388 definition of `S<int>::f'. */
2390 /* If CTYPE does not have template information of any
2391 kind, then it is not a template, nor is it nested
2392 within a template. */
2400 }
2403 }
2405 /* Do a simple sanity check on the template headers that precede the
2406 variable declaration DECL. */
2408 void
2410 {
2417 {
2423 "members of an explicitly specialized class are defined "
2425 }
2426 }
2428 /* Check to see if the function just declared, as indicated in
2429 DECLARATOR, and in DECL, is a specialization of a function
2430 template. We may also discover that the declaration is an explicit
2431 instantiation at this point.
2433 Returns DECL, or an equivalent declaration that should be used
2434 instead if all goes well. Issues an error message if something is
2435 amiss. Returns error_mark_node if the error is not easily
2436 recoverable.
2438 FLAGS is a bitmask consisting of the following flags:
2440 2: The function has a definition.
2441 4: The function is a friend.
2443 The TEMPLATE_COUNT is the number of references to qualifying
2444 template classes that appeared in the name of the function. For
2445 example, in
2447 template <class T> struct S { void f(); };
2448 void S<int>::f();
2450 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2451 classes are not counted in the TEMPLATE_COUNT, so that in
2453 template <class T> struct S {};
2454 template <> struct S<int> { void f(); }
2455 template <> void S<int>::f();
2457 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2458 invalid; there should be no template <>.)
2460 If the function is a specialization, it is marked as such via
2461 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2462 is set up correctly, and it is added to the list of specializations
2463 for that template. */
2465 tree
2467 tree decl,
2470 {
2479 tmpl_spec_kind tsk;
2482 {
2485 else
2487 }
2488 else
2492 {
2495 {
2498 }
2500 {
2502 /* This could be something like:
2504 template <class T> void f(T);
2505 class S { friend void f<>(int); } */
2507 else
2508 {
2509 /* This case handles bogus declarations like template <>
2510 template <class T> void f<int>(); */
2513 declarator);
2515 }
2516 }
2520 /* The error has already been reported in
2521 check_specialization_scope. */
2527 /* Fall through. */
2540 decl);
2543 else
2547 /* Fall through. */
2551 // if (DECL_DECLARED_CONCEPT_P (decl))
2552 // error ("explicit specialization of concept %qD", decl);
2557 else
2563 {
2564 /* This case handles bogus declarations like template <>
2565 template <class T> void f<int>(); */
2570 else
2572 declarator);
2574 }
2577 /* This is a specialization of a member template, without
2578 specialization the containing class. Something like:
2580 template <class T> struct S {
2581 template <class U> void f (U);
2582 };
2583 template <> template <class U> void S<int>::f(U) {}
2585 That's a specialization -- but of the entire template. */
2591 }
2594 {
2598 {
2602 }
2603 }
2606 {
2610 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2612 {
2613 tree fns;
2618 else
2619 {
2620 /* If there is no class context, the explicit instantiation
2621 must be at namespace scope. */
2624 /* Find the namespace binding, using the declaration
2625 context. */
2629 {
2632 }
2633 else
2634 {
2640 }
2641 }
2644 }
2650 {
2652 /* A specialization in class scope. This is invalid,
2653 but the error will already have been flagged by
2654 check_specialization_scope. */
2656 else
2657 {
2658 /* It's not valid to write an explicit instantiation in
2659 class scope, e.g.:
2661 class C { template void f(); }
2663 This case is caught by the parser. However, on
2664 something like:
2666 template class C { void f(); };
2668 (which is invalid) we can get here. The error will be
2669 issued later. */
2670 ;
2671 }
2674 }
2677 {
2678 /* Find the list of functions in ctype that have the same
2679 name as the declared function. */
2685 {
2690 {
2691 /* From [temp.expl.spec]:
2693 If such an explicit specialization for the member
2694 of a class template names an implicitly-declared
2695 special member function (clause _special_), the
2696 program is ill-formed.
2698 Similar language is found in [temp.explicit]. */
2701 }
2704 }
2707 {
2711 }
2712 else
2713 {
2715 tree ovl;
2717 /* For a type-conversion operator, we cannot do a
2718 name-based lookup. We might be looking for `operator
2719 int' which will be a specialization of `operator T'.
2720 So, we find *all* the conversion operators, and then
2721 select from them. */
2729 {
2731 /* There are no more conversion functions. */
2734 /* Glue all these conversion functions together
2735 with those we already have. */
2738 }
2739 }
2742 {
2745 }
2746 else
2748 }
2750 /* Figure out what exactly is being specialized at this point.
2751 Note that for an explicit instantiation, even one for a
2752 member function, we cannot tell apriori whether the
2753 instantiation is for a member template, or just a member
2754 function of a template class. Even if a member template is
2755 being instantiated, the member template arguments may be
2756 elided if they can be deduced from the rest of the
2757 declaration. */
2760 member_specialization,
2761 template_count,
2762 tsk);
2765 /* We couldn't figure out what this declaration was
2766 specializing. */
2768 else
2769 {
2773 {
2774 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2775 is done by do_decl_instantiation later. */
2781 {
2782 /* If TMPL is not the most general template (for
2783 example, if TMPL is a friend template that is
2784 injected into namespace scope), then there will
2785 be too many levels of TARGS. Remove some of them
2786 here. */
2788 tree new_targs;
2795 }
2798 }
2800 /* If we thought that the DECL was a member function, but it
2801 turns out to be specializing a static member function,
2802 make DECL a static member function as well. */
2807 /* If this is a specialization of a member template of a
2808 template class, we want to return the TEMPLATE_DECL, not
2809 the specialization of it. */
2811 {
2816 {
2817 tree parm;
2821 /* We want to use the argument list specified in the
2822 definition, not in the original declaration. */
2827 }
2830 }
2832 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2835 /* Inherit default function arguments from the template
2836 DECL is specializing. */
2839 /* This specialization has the same protection as the
2840 template it specializes. */
2844 /* 7.1.1-1 [dcl.stc]
2846 A storage-class-specifier shall not be specified in an
2847 explicit specialization...
2849 The parser rejects these, so unless action is taken here,
2850 explicit function specializations will always appear with
2851 global linkage.
2853 The action recommended by the C++ CWG in response to C++
2854 defect report 605 is to make the storage class and linkage
2855 of the explicit specialization match the templated function:
2857 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2858 */
2860 {
2864 // A concept cannot be specialized.
2866 {
2869 }
2871 /* This specialization has the same linkage and visibility as
2872 the function template it specializes. */
2875 {
2878 }
2881 {
2884 }
2885 }
2887 /* If DECL is a friend declaration, declared using an
2888 unqualified name, the namespace associated with DECL may
2889 have been set incorrectly. For example, in:
2891 template <typename T> void f(T);
2892 namespace N {
2893 struct S { friend void f<int>(int); }
2894 }
2896 we will have set the DECL_CONTEXT for the friend
2897 declaration to N, rather than to the global namespace. */
2902 /* This is not really a declaration of a specialization.
2903 It's just the name of an instantiation. But, it's not
2904 a request for an instantiation, either. */
2907 /* Register this specialization so that we can find it
2908 again. */
2911 /* A 'structor should already have clones. */
2916 }
2917 }
2920 }
2922 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2923 parameters. These are represented in the same format used for
2924 DECL_TEMPLATE_PARMS. */
2926 int
2928 {
2929 const_tree p1;
2930 const_tree p2;
2938 {
2950 {
2954 /* If either of the template parameters are invalid, assume
2955 they match for the sake of error recovery. */
2968 }
2969 }
2972 /* One set of parameters has more parameters lists than the
2973 other. */
2977 }
2979 /* Determine whether PARM is a parameter pack. */
2981 bool
2983 {
2984 /* Determine if we have a non-type template parameter pack. */
2991 /* If this is a list of template parameters, we could get a
2992 TYPE_DECL or a TEMPLATE_DECL. */
2996 /* Otherwise it must be a type template parameter. */
3000 }
3002 /* Determine if T is a function parameter pack. */
3004 bool
3006 {
3010 }
3012 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3013 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3015 tree
3017 {
3024 }
3026 /* Return true iff the function parameter PARAM_DECL was expanded
3027 from the function parameter pack PACK. */
3029 bool
3031 {
3036 /* The parameter pack and its pack arguments have the same
3037 DECL_PARM_INDEX. */
3039 }
3041 /* Determine whether ARGS describes a variadic template args list,
3042 i.e., one that is terminated by a template argument pack. */
3044 static bool
3046 {
3048 tree last_parm;
3062 }
3064 /* Generate a new name for the parameter pack name NAME (an
3065 IDENTIFIER_NODE) that incorporates its */
3067 static tree
3069 {
3070 /* Munge the name to include the parameter index. */
3071 #define NUMBUF_LEN 128
3085 }
3087 /* Return true if T is a primary function, class or alias template
3088 instantiation. */
3090 bool
3092 {
3106 }
3108 /* Return true if PARM is a template template parameter. */
3110 bool
3112 {
3114 }
3116 /* Return true iff PARM is a DECL representing a type template
3117 parameter. */
3119 bool
3121 {
3126 }
3128 /* Return the template parameters of T if T is a
3129 primary template instantiation, NULL otherwise. */
3131 tree
3133 {
3138 parms = INNERMOST_TEMPLATE_PARMS
3142 }
3144 /* Return the template parameters of the LEVELth level from the full list
3145 of template parameters PARMS. */
3147 tree
3149 {
3150 tree p;
3161 }
3163 /* Returns the template arguments of T if T is a template instantiation,
3164 NULL otherwise. */
3166 tree
3168 {
3176 }
3178 /* Return the argument pack elements of T if T is a template argument pack,
3179 NULL otherwise. */
3181 tree
3183 {
3189 }
3191 /* Structure used to track the progress of find_parameter_packs_r. */
3192 struct find_parameter_pack_data
3193 {
3194 /* TREE_LIST that will contain all of the parameter packs found by
3195 the traversal. */
3198 /* Set of AST nodes that have been visited by the traversal. */
3200 };
3202 /* Identifies all of the argument packs that occur in a template
3203 argument and appends them to the TREE_LIST inside DATA, which is a
3204 find_parameter_pack_data structure. This is a subroutine of
3205 make_pack_expansion and uses_parameter_packs. */
3206 static tree
3208 {
3214 /* Handle type aliases/typedefs. */
3216 {
3223 }
3225 /* Identify whether this is a parameter pack or not. */
3227 {
3243 {
3244 /* We don't want to walk into the type of a PARM_DECL,
3245 because we don't want to see the type parameter pack. */
3248 }
3251 /* Look through a lambda capture proxy to the field pack. */
3254 {
3260 }
3267 /* Not a parameter pack. */
3269 }
3272 {
3273 /* Add this parameter pack to the list. */
3275 }
3281 /* This switch statement will return immediately if we don't find a
3282 parameter pack. */
3284 {
3289 /* Check the template itself. */
3292 /* Check the template arguments. */
3308 /* Fall through. */
3350 }
3353 }
3355 /* Determines if the expression or type T uses any parameter packs. */
3356 bool
3358 {
3366 }
3368 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3369 representation a base-class initializer into a parameter pack
3370 expansion. If all goes well, the resulting node will be an
3371 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3372 respectively. */
3373 tree
3375 {
3376 tree result;
3385 {
3386 /* The only time we will see a TREE_LIST here is for a base
3387 class initializer. In this case, the TREE_PURPOSE will be a
3388 _TYPE node (representing the base class expansion we're
3389 initializing) and the TREE_VALUE will be a TREE_LIST
3390 containing the initialization arguments.
3392 The resulting expansion looks somewhat different from most
3393 expansions. Rather than returning just one _EXPANSION, we
3394 return a TREE_LIST whose TREE_PURPOSE is a
3395 TYPE_PACK_EXPANSION containing the bases that will be
3396 initialized. The TREE_VALUE will be identical to the
3397 original TREE_VALUE, which is a list of arguments that will
3398 be passed to each base. We do not introduce any new pack
3399 expansion nodes into the TREE_VALUE (although it is possible
3400 that some already exist), because the TREE_PURPOSE and
3401 TREE_VALUE all need to be expanded together with the same
3402 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3403 resulting TREE_PURPOSE will mention the parameter packs in
3404 both the bases and the arguments to the bases. */
3405 tree purpose;
3406 tree value;
3409 /* Determine which parameter packs will be used by the base
3410 class expansion. */
3417 {
3421 }
3424 {
3425 /* Collect the sets of parameter packs used in each of the
3426 initialization arguments. */
3428 {
3429 /* Determine which parameter packs will be expanded in this
3430 argument. */
3433 }
3434 }
3438 /* Create the pack expansion type for the base type. */
3443 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3444 they will rarely be compared to anything. */
3448 }
3453 /* Build the PACK_EXPANSION_* node. */
3454 result = for_types
3459 {
3460 /* Propagate type and const-expression information. */
3463 }
3464 else
3465 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3466 they will rarely be compared to anything. */
3469 /* Determine which parameter packs will be expanded. */
3475 /* Make sure we found some parameter packs. */
3477 {
3480 else
3483 }
3489 }
3491 /* Checks T for any "bare" parameter packs, which have not yet been
3492 expanded, and issues an error if any are found. This operation can
3493 only be done on full expressions or types (e.g., an expression
3494 statement, "if" condition, etc.), because we could have expressions like:
3496 foo(f(g(h(args)))...)
3498 where "args" is a parameter pack. check_for_bare_parameter_packs
3499 should not be called for the subexpressions args, h(args),
3500 g(h(args)), or f(g(h(args))), because we would produce erroneous
3501 error messages.
3503 Returns TRUE and emits an error if there were bare parameter packs,
3504 returns FALSE otherwise. */
3505 bool
3507 {
3523 {
3526 {
3535 else
3540 else
3544 }
3547 }
3550 }
3552 /* Expand any parameter packs that occur in the template arguments in
3553 ARGS. */
3554 tree
3556 {
3562 /* First, determine if we need to expand anything, and the number of
3563 slots we'll need. */
3565 {
3570 {
3574 else
3576 }
3577 else
3578 {
3580 num_result_args++;
3581 }
3582 }
3584 /* If no expansion is necessary, we're done. */
3588 /* Expand arguments. */
3591 non_default_args_count =
3594 {
3597 {
3604 }
3605 else
3606 {
3609 }
3610 }
3614 }
3616 /* Checks if DECL shadows a template parameter.
3618 [temp.local]: A template-parameter shall not be redeclared within its
3619 scope (including nested scopes).
3621 Emits an error and returns TRUE if the DECL shadows a parameter,
3622 returns FALSE otherwise. */
3624 bool
3626 {
3627 tree olddecl;
3629 /* If we're not in a template, we can't possibly shadow a template
3630 parameter. */
3634 /* Figure out what we're shadowing. */
3639 /* If there's no previous binding for this name, we're not shadowing
3640 anything, let alone a template parameter. */
3644 /* If we're not shadowing a template parameter, we're done. Note
3645 that OLDDECL might be an OVERLOAD (or perhaps even an
3646 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3647 node. */
3651 /* We check for decl != olddecl to avoid bogus errors for using a
3652 name inside a class. We check TPFI to avoid duplicate errors for
3653 inline member templates. */
3659 /* Don't complain about the injected class name, as we've already
3660 complained about the class itself. */
3667 }
3669 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3670 ORIG_LEVEL, DECL, and TYPE. */
3672 static tree
3676 tree decl,
3677 tree type)
3678 {
3689 }
3691 /* Find the canonical type parameter for the given template type
3692 parameter. Returns the canonical type parameter, which may be TYPE
3693 if no such parameter existed. */
3695 static tree
3697 {
3698 tree list;
3712 else
3713 {
3718 }
3719 }
3721 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3722 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3723 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3724 new one is created. */
3726 static tree
3728 tsubst_flags_t complain)
3729 {
3734 {
3753 /* Template template parameters need this. */
3758 }
3761 }
3763 /* Process information from new template parameter PARM and append it
3764 to the LIST being built. This new parameter is a non-type
3765 parameter iff IS_NON_TYPE is true. This new parameter is a
3766 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3767 is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template
3768 parameter list PARM belongs to. This is used used to create a
3769 proper canonical type for the type of PARM that is to be created,
3770 iff PARM is a type. If the size is not known, this parameter shall
3771 be set to 0. */
3773 tree
3776 {
3778 tree err_parm_list;
3787 {
3791 {
3795 else
3797 }
3800 }
3801 else
3805 {
3811 {
3815 }
3816 else
3817 {
3818 /* [temp.param]
3820 The top-level cv-qualifiers on the template-parameter are
3821 ignored when determining its type. */
3824 {
3828 }
3831 /* If we're in a nested template parameter list, the template
3832 template parameter could be a parameter pack. */
3834 {
3835 /* This template parameter is not a parameter pack, but it
3836 should be. Complain about "bare" parameter packs. */
3839 /* Recover by calling this a parameter pack. */
3841 }
3842 }
3844 /* A template parameter is not modifiable. */
3853 processing_template_decl,
3859 // Build requirements for the parameter.
3861 }
3862 else
3863 {
3864 tree t;
3868 {
3870 /* This is for distinguishing between real templates and template
3871 template parameters */
3875 }
3876 else
3877 {
3879 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3882 }
3889 processing_template_decl,
3894 // Build requirements for the type/template parameter.
3896 }
3901 // Build the parameter node linking the parameter declaration, its
3902 // default argument (if any), and its constraints (if any).
3907 }
3909 /* The end of a template parameter list has been reached. Process the
3910 tree list into a parameter vector, converting each parameter into a more
3911 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3912 as PARM_DECLs. */
3914 tree
3916 {
3921 current_template_parms
3926 {
3930 }
3935 }
3937 // Explicitly indicate the end of the template parameter list. We assume
3938 // that the current template parameters have been constructed and/or
3939 // managed explicitly, as when creating new template template parameters
3940 // from a shorthand constraint.
3941 void
3943 {
3945 }
3947 /* end_template_decl is called after a template declaration is seen. */
3949 void
3951 {
3957 /* This matches the pushlevel in begin_template_parm_list. */
3962 }
3964 /* Takes a TREE_LIST representing a template parameter and convert it
3965 into an argument suitable to be passed to the type substitution
3966 functions. Note that If the TREE_LIST contains an error_mark
3967 node, the returned argument is error_mark_node. */
3969 tree
3971 {
3984 {
3988 {
3989 /* Turn this argument into a TYPE_ARGUMENT_PACK
3990 with a single element, which expands T. */
3992 #ifdef ENABLE_CHECKING
3993 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3995 #endif
4000 }
4001 }
4002 else
4003 {
4007 {
4008 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4009 with a single element, which expands T. */
4012 #ifdef ENABLE_CHECKING
4013 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
4015 #endif
4022 }
4023 else
4025 }
4027 }
4029 /* Given a set of template parameters, return them as a set of template
4030 arguments. The template parameters are represented as a TREE_VEC, in
4031 the form documented in cp-tree.h for template arguments. */
4033 static tree
4035 {
4036 tree header;
4041 /* If there is only one level of template parameters, we do not
4042 create a TREE_VEC of TREE_VECs. Instead, we return a single
4043 TREE_VEC containing the arguments. */
4048 {
4056 #ifdef ENABLE_CHECKING
4058 #endif
4062 else
4064 }
4067 /* This can happen for template parms of a template template
4068 parameter, e.g:
4070 template<template<class T, class U> class TT> struct S;
4072 Consider the level of the parms of TT; T and U both have
4073 level 2; TT has no template parm of level 1. So in this case
4074 the first element of full_template_args is NULL_TREE. If we
4075 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
4076 of 2. This will make tsubst wrongly consider that T and U
4077 have level 1. Instead, let's create a dummy vector as the
4078 first element of full_template_args so that TMPL_ARGS_DEPTH
4079 returns the correct depth for args. */
4082 }
4084 /* Within the declaration of a template, return the currently active
4085 template parameters as an argument TREE_VEC. */
4087 static tree
4089 {
4091 }
4093 /* Update the declared TYPE by doing any lookups which were thought to be
4094 dependent, but are not now that we know the SCOPE of the declarator. */
4096 tree
4098 {
4109 /* Don't bother building up the args in this case. */
4111 {
4112 /* tsubst in the args corresponding to the template parameters,
4113 including auto if present. Most things will be unchanged, but
4114 make_typename_type and tsubst_qualified_id will resolve
4115 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4118 tree pushed;
4120 {
4124 }
4129 }
4135 {
4138 else
4140 }
4142 }
4144 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4145 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4146 the new template is a member template. */
4148 tree
4150 {
4159 }
4161 struct template_parm_data
4162 {
4163 /* The level of the template parameters we are currently
4164 processing. */
4167 /* The index of the specialization argument we are currently
4168 processing. */
4171 /* An array whose size is the number of template parameters. The
4172 elements are nonzero if the parameter has been used in any one
4173 of the arguments processed so far. */
4176 /* An array whose size is the number of template arguments. The
4177 elements are nonzero if the argument makes use of template
4178 parameters of this level. */
4180 };
4182 /* Subroutine of push_template_decl used to see if each template
4183 parameter in a partial specialization is used in the explicit
4184 argument list. If T is of the LEVEL given in DATA (which is
4185 treated as a template_parm_data*), then DATA->PARMS is marked
4186 appropriately. */
4188 static int
4190 {
4196 {
4199 }
4200 else
4201 {
4204 }
4207 {
4210 }
4212 /* Return zero so that for_each_template_parm will continue the
4213 traversal of the tree; we want to mark *every* template parm. */
4215 }
4217 /* Process the partial specialization DECL. */
4219 static tree
4221 {
4227 tree inner_parms;
4228 tree inst;
4238 // When defining a constrained partial specialization, DECL's type
4239 // will have been assigned to the canonical type of the primary.
4240 // That is:
4241 //
4242 // template<typename T>
4243 // struct S; // Has canonical type S<T>
4244 //
4245 // template<typename T>
4246 // requires C<T>
4247 // struct S<T>; // binds to the primary template.
4248 //
4249 // However, the the constraints differ, so we should be constructing
4250 // a new type. We do this by making the DECL's type its own
4251 // canonical type.
4252 //
4253 // TODO: Do we need to compare the current requirements to make
4254 // sure this isn't a redeclaration?
4261 /* We check that each of the template parameters given in the
4262 partial specialization is used in the argument list to the
4263 specialization. For example:
4265 template <class T> struct S;
4266 template <class T> struct S<T*>;
4268 The second declaration is OK because `T*' uses the template
4269 parameter T, whereas
4271 template <class T> struct S<int>;
4273 is no good. Even trickier is:
4275 template <class T>
4276 struct S1
4277 {
4278 template <class U>
4279 struct S2;
4280 template <class U>
4281 struct S2<T>;
4282 };
4284 The S2<T> declaration is actually invalid; it is a
4285 full-specialization. Of course,
4287 template <class U>
4288 struct S2<T (*)(U)>;
4290 or some such would have been OK. */
4298 {
4303 NULL,
4305 }
4308 {
4309 /* One of the template parms was not used in the
4310 specialization. */
4312 {
4315 }
4318 }
4323 /* [temp.class.spec]
4325 The argument list of the specialization shall not be identical to
4326 the implicit argument list of the primary template.
4328 Note that concepts allow partial specializations with the same list of
4329 arguments but different constraints. */
4338 /* A partial specialization that replaces multiple parameters of the
4339 primary template with a pack expansion is less specialized for those
4340 parameters. */
4342 {
4344 "primary template because it replaces multiple parameters "
4348 }
4350 /* [temp.class.spec]
4352 A partially specialized non-type argument expression shall not
4353 involve template parameters of the partial specialization except
4354 when the argument expression is a simple identifier.
4356 The type of a template parameter corresponding to a specialized
4357 non-type argument shall not be dependent on a parameter of the
4358 specialization.
4360 Also, we verify that pack expansions only occur at the
4361 end of the argument list. */
4365 {
4372 {
4373 /* Extract the arguments from the argument pack. We'll be
4374 iterating over these in the following loop. */
4377 }
4380 {
4382 /* Get the Jth argument in the parameter pack. */
4386 {
4387 /* Pack expansions must come at the end of the
4388 argument list. */
4391 {
4395 else
4398 }
4399 }
4402 /* We only care about the pattern. */
4408 /* This next two lines are the `argument expression is not just a
4409 simple identifier' condition and also the `specialized
4410 non-type argument' bit. */
4414 {
4418 arg);
4419 else
4420 {
4421 /* Look at the corresponding template parameter,
4422 marking which template parameters its type depends
4423 upon. */
4427 {
4428 /* We haven't yet initialized TPD2. Do so now. */
4430 /* The number of parameters here is the number in the
4431 main template, which, as checked in the assertion
4432 above, is NARGS. */
4436 }
4438 /* Mark the template parameters. But this time, we're
4439 looking for the template parameters of the main
4440 template, not in the specialization. */
4447 NULL,
4451 {
4452 /* The type depended on some template parameters.
4453 If they are fully specialized in the
4454 specialization, that's OK. */
4463 "type %qT of template argument %qE depends "
4465 "type %qT of template argument %qE depends "
4467 type,
4468 arg);
4469 }
4470 }
4471 }
4472 }
4473 }
4475 /* We should only get here once. */
4478 // Build the template decl.
4480 current_template_parms,
4481 current_template_reqs,
4496 {
4500 {
4504 "partial specialization of %qT after instantiation "
4506 }
4507 }
4510 }
4512 /* PARM is a template parameter of some form; return the corresponding
4513 TEMPLATE_PARM_INDEX. */
4515 static tree
4517 {
4529 }
4531 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4532 parameter packs used by the template parameter PARM. */
4534 static void
4536 {
4537 /* A type parm can't refer to another parm. */
4541 {
4545 }
4552 }
4554 /* PARM is a template parameter pack. Return any parameter packs used in
4555 its type or the type of any of its template parameters. If there are
4556 any such packs, it will be instantiated into a fixed template parameter
4557 list by partial instantiation rather than be fully deduced. */
4559 tree
4561 {
4562 /* This can only be true in a member template. */
4565 /* This can only be true for a parameter pack. */
4568 /* A type parm can't refer to another parm. */
4581 }
4583 /* Check that a template declaration's use of default arguments and
4584 parameter packs is not invalid. Here, PARMS are the template
4585 parameters. IS_PRIMARY is true if DECL is the thing declared by
4586 a primary template. IS_PARTIAL is true if DECL is a partial
4587 specialization.
4589 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4590 declaration (but not a definition); 1 indicates a declaration, 2
4591 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4592 emitted for extraneous default arguments.
4594 Returns TRUE if there were no errors found, FALSE otherwise. */
4596 bool
4599 {
4602 tree parm_level;
4605 /* [temp.param]
4607 A default template-argument shall not be specified in a
4608 function template declaration or a function template definition, nor
4609 in the template-parameter-list of the definition of a member of a
4610 class template. */
4613 /* You can't have a function template declaration in a local
4614 scope, nor you can you define a member of a class template in a
4615 local scope. */
4621 /* A lambda doesn't have an explicit declaration; don't complain
4622 about the parms of the enclosing class. */
4629 /* If this is either a friend defined in the scope of the class
4630 or a member function. */
4636 /* And, if it was a member function, it really was defined in
4637 the scope of the class. */
4640 /* We already checked these parameters when the template was
4641 declared, so there's no need to do it again now. This function
4642 was defined in class scope, but we're processing its body now
4643 that the class is complete. */
4646 /* Core issue 226 (C++0x only): the following only applies to class
4647 templates. */
4650 {
4651 /* [temp.param]
4653 If a template-parameter has a default template-argument, all
4654 subsequent template-parameters shall have a default
4655 template-argument supplied. */
4657 {
4664 {
4674 {
4676 /* For better subsequent error-recovery, we indicate that
4677 there should have been a default argument. */
4680 }
4682 && !is_friend_decl
4683 /* Don't complain about an enclosing partial
4684 specialization. */
4689 /* A fixed parameter pack will be partially
4690 instantiated into a fixed length list. */
4692 {
4693 /* A primary class template can only have one
4694 parameter pack, at the end of the template
4695 parameter list. */
4700 else
4708 }
4709 }
4710 }
4711 }
4714 || is_partial
4715 || !is_primary
4717 /* For an ordinary class template, default template arguments are
4718 allowed at the innermost level, e.g.:
4719 template <class T = int>
4720 struct S {};
4721 but, in a partial specialization, they're not allowed even
4722 there, as we have in [temp.class.spec]:
4724 The template parameter list of a specialization shall not
4725 contain default template argument values.
4727 So, for a partial specialization, or for a function template
4728 (in C++98/C++03), we look at all of them. */
4729 ;
4730 else
4731 /* But, for a primary class template that is not a partial
4732 specialization we look at all template parameters except the
4733 innermost ones. */
4736 /* Figure out what error message to issue. */
4749 else
4753 /* If we're inside a class definition, there's no need to
4754 examine the parameters to the class itself. On the one
4755 hand, they will be checked when the class is defined, and,
4756 on the other, default arguments are valid in things like:
4757 template <class T = double>
4758 struct S { template <class U> void f(U); };
4759 Here the default argument for `S' has no bearing on the
4760 declaration of `f'. */
4762 else
4763 /* Check everything. */
4769 {
4776 {
4781 {
4783 {
4790 }
4792 /* Clear out the default argument so that we are not
4793 confused later. */
4795 }
4796 }
4798 /* At this point, if we're still interested in issuing messages,
4799 they must apply to classes surrounding the object declared. */
4803 }
4806 }
4808 /* Worker for push_template_decl_real, called via
4809 for_each_template_parm. DATA is really an int, indicating the
4810 level of the parameters we are interested in. If T is a template
4811 parameter of that level, return nonzero. */
4813 static int
4815 {
4821 else
4824 }
4826 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4827 parameters given by current_template_args, or reuses a
4828 previously existing one, if appropriate. Returns the DECL, or an
4829 equivalent one, if it is replaced via a call to duplicate_decls.
4831 If IS_FRIEND is true, DECL is a friend declaration. */
4833 tree
4835 {
4836 tree tmpl;
4837 tree args;
4838 tree info;
4839 tree ctx;
4843 /* True if the template is a member template, in the sense of
4844 [temp.mem]. */
4850 /* See if this is a partial specialization. */
4859 /* For a friend, we want the context of the friend function, not
4860 the type of which it is a friend. */
4864 /* In the case of a virtual function, we want the class in which
4865 it is defined. */
4867 else
4868 /* Otherwise, if we're currently defining some class, the DECL
4869 is assumed to be a member of the class. */
4878 /* See if this is a primary template. */
4881 /* A friend template that specifies a class context, i.e.
4882 template <typename T> friend void A<T>::f();
4883 is not primary. */
4885 else
4889 {
4894 {
4897 }
4899 {
4901 {
4902 /* [temp.mem]
4904 A destructor shall not be a member template. */
4907 }
4914 {
4915 /* [basic.stc.dynamic.allocation]
4917 An allocation function can be a function
4918 template. ... Template allocation functions shall
4919 have two or more parameters. */
4922 }
4923 }
4929 /* alias-declaration */
4931 else
4932 {
4935 }
4936 }
4938 /* Check to see that the rules regarding the use of default
4939 arguments are not being violated. */
4943 /* Ensure that there are no parameter packs in the type of this
4944 declaration that have not been expanded. */
4946 {
4947 /* Check each of the arguments individually to see if there are
4948 any bare parameter packs. */
4954 {
4957 {
4958 /* This is a PARM_DECL that contains unexpanded parameter
4959 packs. We have already complained about this in the
4960 check_for_bare_parameter_packs call, so just replace
4961 these types with ERROR_MARK_NODE. */
4964 }
4968 }
4970 /* Check for bare parameter packs in the return type and the
4971 exception specifiers. */
4973 /* Errors were already issued, set return type to int
4974 as the frontend doesn't expect error_mark_node as
4975 the return type. */
4979 }
4984 {
4987 }
5000 {
5005 /* If DECL is a TYPE_DECL for a class-template, then there won't
5006 be DECL_LANG_SPECIFIC. The information equivalent to
5007 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5011 {
5012 /* Since a template declaration already existed for this
5013 class-type, we must be redeclaring it here. Make sure
5014 that the redeclaration is valid. */
5016 current_template_parms,
5017 current_template_reqs);
5018 /* We don't need to create a new TEMPLATE_DECL; just use the
5019 one we already had. */
5021 }
5022 else
5023 {
5025 current_template_parms,
5026 current_template_reqs,
5027 member_template_p);
5032 {
5033 /* A specialization of a member template of a template
5034 class. */
5038 }
5039 }
5040 }
5041 else
5042 {
5048 {
5051 }
5059 {
5060 tree new_tmpl;
5062 /* The declaration is a specialization of a member
5063 template, declared outside the class. Therefore, the
5064 innermost template arguments will be NULL, so we
5065 replace them with the arguments determined by the
5066 earlier call to check_explicit_specialization. */
5070 current_template_parms,
5071 current_template_reqs,
5072 member_template_p);
5081 args,
5084 }
5086 /* Make sure the template headers we got make sense. */
5091 {
5096 }
5097 else
5099 {
5104 {
5108 else
5112 /* Avoid crash in import_export_decl. */
5115 }
5120 /* Can happen in erroneous input. */
5122 else
5124 }
5126 /* Check that the parms are used in the appropriate qualifying scopes
5127 in the declarator. */
5131 {
5137 /* Avoid crash in import_export_decl. */
5140 }
5141 }
5146 /* Push template declarations for global functions and types. Note
5147 that we do not try to push a global template friend declared in a
5148 template class; such a thing may well depend on the template
5149 parameters of the class. */
5152 {
5157 /* Hide template friend classes that haven't been declared yet. */
5159 {
5162 }
5163 }
5166 {
5172 {
5175 /* It is a conversion operator. See if the type converted to
5176 depends on innermost template operands. */
5179 depth))
5181 }
5183 /* Give template template parms a DECL_CONTEXT of the template
5184 for which they are a parameter. */
5187 {
5191 }
5192 }
5194 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5195 back to its most general template. If TMPL is a specialization,
5196 ARGS may only have the innermost set of arguments. Add the missing
5197 argument levels if necessary. */
5205 else
5206 {
5211 }
5214 }
5216 tree
5218 {
5220 }
5222 /* FN is an inheriting constructor that inherits from the constructor
5223 template INHERITED; turn FN into a constructor template with a matching
5224 template header. */
5226 tree
5228 {
5229 tree inner_parms
5232 tree parms
5238 // If the inherited constructor was constrained, then also
5239 // propagate the constraints to the new declaration by
5240 // rewriting them in terms of the local template parameters.
5243 {
5248 }
5256 }
5258 /* Called when a class template TYPE is redeclared with the indicated
5259 template PARMS, e.g.:
5261 template <class T> struct S;
5262 template <class T> struct S {}; */
5264 bool
5266 {
5267 tree tmpl;
5268 tree tmpl_parms;
5272 {
5275 }
5279 /* The type is nested in some template class. Nothing to worry
5280 about here; there are no new template parameters for the nested
5281 type. */
5285 {
5287 tmpl);
5289 }
5295 {
5305 }
5308 {
5309 tree tmpl_parm;
5310 tree parm;
5311 tree tmpl_default;
5312 tree parm_default;
5326 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5327 TEMPLATE_DECL. */
5337 {
5341 }
5344 {
5345 /* We have in [temp.param]:
5347 A template-parameter may not be given default arguments
5348 by two different declarations in the same scope. */
5353 }
5356 /* Update the previous template parameters (which are the ones
5357 that will really count) with the new default value. */
5360 /* Update the new parameters, too; they'll be used as the
5361 parameters for any members. */
5363 }
5365 // Cannot redeclare a class template with a different set of constraints.
5367 {
5372 }
5375 }
5377 /* Simplify EXPR if it is a non-dependent expression. Returns the
5378 (possibly simplified) expression. */
5380 tree
5382 {
5386 /* If we're in a template, but EXPR isn't value dependent, simplify
5387 it. We're supposed to treat:
5389 template <typename T> void f(T[1 + 1]);
5390 template <typename T> void f(T[2]);
5392 as two declarations of the same function, for example. */
5396 {
5397 HOST_WIDE_INT saved_processing_template_decl;
5403 complain,
5408 }
5410 }
5412 tree
5414 {
5416 }
5418 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5419 template declaration, or a TYPE_DECL for an alias declaration. */
5421 bool
5423 {
5431 }
5433 /* Return TRUE iff is a specialization of an alias template. */
5435 bool
5437 {
5445 }
5447 /* Return the number of innermost template parameters in TMPL. */
5449 static int
5451 {
5454 }
5456 /* Return either TMPL or another template that it is equivalent to under DR
5457 1286: An alias that just changes the name of a template is equivalent to
5458 the other template. */
5460 static tree
5462 {
5465 {
5468 {
5473 {
5474 tree alias_args = INNERMOST_TEMPLATE_ARGS
5478 /* The alias type is equivalent to the pattern of the
5479 underlying template, so strip the alias. */
5482 }
5483 }
5485 }
5487 }
5489 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5490 must be a function or a pointer-to-function type, as specified
5491 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5492 and check that the resulting function has external linkage. */
5494 static tree
5496 {
5499 linkage_kind linkage;
5511 /* [temp.arg.nontype]/1
5513 A template-argument for a non-type, non-template template-parameter
5514 shall be one of:
5515 [...]
5516 -- the address of an object or function with external [C++11: or
5517 internal] linkage. */
5520 {
5524 else
5527 }
5531 {
5536 else
5541 }
5544 }
5546 /* Subroutine of convert_nontype_argument.
5547 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5548 Emit an error otherwise. */
5550 static bool
5552 tsubst_flags_t complain)
5553 {
5560 {
5564 }
5566 }
5568 /* Returns TRUE iff the address of OP is value-dependent.
5570 14.6.2.4 [temp.dep.temp]:
5571 A non-integral non-type template-argument is dependent if its type is
5572 dependent or it has either of the following forms
5573 qualified-id
5574 & qualified-id
5575 and contains a nested-name-specifier which specifies a class-name that
5576 names a dependent type.
5578 We generalize this to just say that the address of a member of a
5579 dependent class is value-dependent; the above doesn't cover the
5580 address of a static data member named with an unqualified-id. */
5582 static bool
5584 {
5585 /* We could use get_inner_reference here, but there's no need;
5586 this is only relevant for template non-type arguments, which
5587 can only be expressed as &id-expression. */
5589 {
5593 }
5596 }
5598 /* The next set of functions are used for providing helpful explanatory
5599 diagnostics for failed overload resolution. Their messages should be
5600 indented by two spaces for consistency with the messages in
5601 call.c */
5603 static int
5605 {
5607 }
5609 static int
5611 {
5616 }
5618 static int
5620 {
5622 }
5624 static int
5626 {
5632 }
5634 static int
5636 {
5640 }
5642 static int
5644 {
5647 " template parameter %qD is not a parameter pack, but "
5651 }
5653 static int
5655 {
5658 " template argument %qE does not match "
5662 }
5664 static int
5666 {
5670 }
5672 static int
5674 {
5680 }
5682 static int
5684 {
5686 {
5691 else
5693 " deduced conflicting values for non-type parameter "
5695 }
5697 }
5699 static int
5701 {
5704 " variable-sized array type %qT is not "
5706 arg);
5708 }
5710 static int
5712 {
5716 arg);
5718 }
5720 static int
5722 {
5729 }
5731 static int
5733 {
5735 }
5737 static int
5739 {
5741 }
5743 static int
5746 {
5752 }
5754 static int
5757 {
5760 {
5768 }
5770 }
5772 static int
5774 {
5777 " template parameters of a template template argument are "
5780 }
5782 static int
5784 {
5790 }
5792 static int
5794 {
5799 }
5801 static int
5803 {
5807 arg);
5809 }
5811 /* Attempt to convert the non-type template parameter EXPR to the
5812 indicated TYPE. If the conversion is successful, return the
5813 converted value. If the conversion is unsuccessful, return
5814 NULL_TREE if we issued an error message, or error_mark_node if we
5815 did not. We issue error messages for out-and-out bad template
5816 parameters, but not simply because the conversion failed, since we
5817 might be just trying to do argument deduction. Both TYPE and EXPR
5818 must be non-dependent.
5820 The conversion follows the special rules described in
5821 [temp.arg.nontype], and it is much more strict than an implicit
5822 conversion.
5824 This function is called twice for each template argument (see
5825 lookup_template_class for a more accurate description of this
5826 problem). This means that we need to handle expressions which
5827 are not valid in a C++ source, but can be created from the
5828 first call (for instance, casts to perform conversions). These
5829 hacks can go away after we fix the double coercion problem. */
5831 static tree
5833 {
5834 tree expr_type;
5836 /* Detect immediately string literals as invalid non-type argument.
5837 This special-case is not needed for correctness (we would easily
5838 catch this later), but only to provide better diagnostic for this
5839 common user mistake. As suggested by DR 100, we do not mention
5840 linkage issues in the diagnostic as this is not the point. */
5841 /* FIXME we're making this OK. */
5843 {
5849 }
5851 /* Add the ADDR_EXPR now for the benefit of
5852 value_dependent_expression_p. */
5855 {
5859 }
5861 /* If we are in a template, EXPR may be non-dependent, but still
5862 have a syntactic, rather than semantic, form. For example, EXPR
5863 might be a SCOPE_REF, rather than the VAR_DECL to which the
5864 SCOPE_REF refers. Preserving the qualifying scope is necessary
5865 so that access checking can be performed when the template is
5866 instantiated -- but here we need the resolved form so that we can
5867 convert the argument. */
5878 else
5881 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5882 to a non-type argument of "nullptr". */
5886 /* In C++11, integral or enumeration non-type template arguments can be
5887 arbitrary constant expressions. Pointer and pointer to
5888 member arguments can be general constant expressions that evaluate
5889 to a null value, but otherwise still need to be of a specific form. */
5891 {
5893 /* A PTRMEM_CST is already constant, and a valid template
5894 argument for a parameter of pointer to member type, we just want
5895 to leave it in that form rather than lower it to a
5900 {
5905 }
5906 }
5908 /* HACK: Due to double coercion, we can get a
5909 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5910 which is the tree that we built on the first call (see
5911 below when coercing to reference to object or to reference to
5912 function). We just strip everything and get to the arg.
5913 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5914 for examples. */
5916 {
5922 {
5923 /* ??? Maybe we could use convert_from_reference here, but we
5924 would need to relax its constraints because the NOP_EXPR
5925 could actually change the type to something more cv-qualified,
5926 and this is not folded by convert_from_reference. */
5931 && (same_type_ignoring_top_level_qualifiers_p
5934 {
5937 }
5938 }
5939 }
5941 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5942 parameter is a pointer to object, through decay and
5943 qualification conversion. Let's strip everything. */
5945 {
5950 {
5951 /* Skip the ADDR_EXPR only if it is part of the decay for
5952 an array. Otherwise, it is part of the original argument
5953 in the source code. */
5958 }
5959 }
5961 /* [temp.arg.nontype]/5, bullet 1
5963 For a non-type template-parameter of integral or enumeration type,
5964 integral promotions (_conv.prom_) and integral conversions
5965 (_conv.integral_) are applied. */
5967 {
5976 /* Notice that there are constant expressions like '4 % 0' which
5977 do not fold into integer constants. */
5979 {
5981 {
5992 /* else cxx_constant_value complained but gave us
5993 a real constant, so go ahead. */
5995 }
5996 else
5998 }
6000 /* Avoid typedef problems. */
6003 }
6004 /* [temp.arg.nontype]/5, bullet 2
6006 For a non-type template-parameter of type pointer to object,
6007 qualification conversions (_conv.qual_) and the array-to-pointer
6008 conversion (_conv.array_) are applied. */
6010 {
6011 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6013 A template-argument for a non-type, non-template template-parameter
6014 shall be one of: [...]
6016 -- the name of a non-type template-parameter;
6017 -- the address of an object or function with external linkage, [...]
6018 expressed as "& id-expression" where the & is optional if the name
6019 refers to a function or array, or if the corresponding
6020 template-parameter is a reference.
6022 Here, we do not care about functions, as they are invalid anyway
6023 for a parameter of type pointer-to-object. */
6026 /* Non-type template parameters are OK. */
6027 ;
6032 {
6034 {
6036 "because %qD is a variable, not the address of "
6040 }
6042 {
6047 }
6048 /* Other values, like integer constants, might be valid
6049 non-type arguments of some other type. */
6051 }
6052 else
6053 {
6054 tree decl;
6059 {
6064 }
6066 {
6071 }
6073 {
6078 }
6079 }
6088 }
6089 /* [temp.arg.nontype]/5, bullet 3
6091 For a non-type template-parameter of type reference to object, no
6092 conversions apply. The type referred to by the reference may be more
6093 cv-qualified than the (otherwise identical) type of the
6094 template-argument. The template-parameter is bound directly to the
6095 template-argument, which must be an lvalue. */
6097 {
6099 expr_type))
6103 {
6107 }
6110 {
6114 }
6116 /* [temp.arg.nontype]/1
6118 A template-argument for a non-type, non-template template-parameter
6119 shall be one of: [...]
6121 -- the address of an object or function with external linkage. */
6124 {
6127 {
6129 "because a reference variable does not have a constant "
6132 }
6133 }
6136 {
6141 }
6144 {
6149 }
6152 }
6153 /* [temp.arg.nontype]/5, bullet 4
6155 For a non-type template-parameter of type pointer to function, only
6156 the function-to-pointer conversion (_conv.func_) is applied. If the
6157 template-argument represents a set of overloaded functions (or a
6158 pointer to such), the matching function is selected from the set
6159 (_over.over_). */
6161 {
6162 /* If the argument is a template-id, we might not have enough
6163 context information to decay the pointer. */
6165 {
6169 }
6172 /* Null pointer values are OK in C++11. */
6178 }
6179 /* [temp.arg.nontype]/5, bullet 5
6181 For a non-type template-parameter of type reference to function, no
6182 conversions apply. If the template-argument represents a set of
6183 overloaded functions, the matching function is selected from the set
6184 (_over.over_). */
6186 {
6188 {
6193 }
6200 }
6201 /* [temp.arg.nontype]/5, bullet 6
6203 For a non-type template-parameter of type pointer to member function,
6204 no conversions apply. If the template-argument represents a set of
6205 overloaded member functions, the matching member function is selected
6206 from the set (_over.over_). */
6208 {
6213 /* [temp.arg.nontype] bullet 1 says the pointer to member
6214 expression must be a pointer-to-member constant. */
6218 /* There is no way to disable standard conversions in
6219 resolve_address_of_overloaded_function (called by
6220 instantiate_type). It is possible that the call succeeded by
6221 converting &B::I to &D::I (where B is a base of D), so we need
6222 to reject this conversion here.
6224 Actually, even if there was a way to disable standard conversions,
6225 it would still be better to reject them here so that we can
6226 provide a superior diagnostic. */
6228 {
6232 /* If we are just one standard conversion off, explain. */
6237 }
6238 }
6239 /* [temp.arg.nontype]/5, bullet 7
6241 For a non-type template-parameter of type pointer to data member,
6242 qualification conversions (_conv.qual_) are applied. */
6244 {
6245 /* [temp.arg.nontype] bullet 1 says the pointer to member
6246 expression must be a pointer-to-member constant. */
6253 }
6255 {
6257 {
6261 }
6263 }
6264 /* A template non-type parameter must be one of the above. */
6265 else
6268 /* Sanity check: did we actually convert the argument to the
6269 right type? */
6273 }
6275 /* Subroutine of coerce_template_template_parms, which returns 1 if
6276 PARM_PARM and ARG_PARM match using the rule for the template
6277 parameters of template template parameters. Both PARM and ARG are
6278 template parameters; the rest of the arguments are the same as for
6279 coerce_template_template_parms.
6280 */
6281 static int
6283 tree arg,
6284 tsubst_flags_t complain,
6285 tree in_decl,
6286 tree outer_args)
6287 {
6296 {
6298 /* We encounter instantiations of templates like
6299 template <template <template <class> class> class TT>
6300 class C; */
6301 {
6308 }
6309 /* Fall through. */
6314 /* Argument is a parameter pack but parameter is not. */
6319 /* The tsubst call is used to handle cases such as
6321 template <int> class C {};
6322 template <class T, template <T> class TT> class D {};
6323 D<int, C> d;
6325 i.e. the parameter list of TT depends on earlier parameters. */
6327 && !same_type_p
6334 /* Argument is a parameter pack but parameter is not. */
6341 }
6344 }
6347 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6348 template template parameters. Both PARM_PARMS and ARG_PARMS are
6349 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6350 or PARM_DECL.
6352 Consider the example:
6353 template <class T> class A;
6354 template<template <class U> class TT> class B;
6356 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6357 the parameters to A, and OUTER_ARGS contains A. */
6359 static int
6361 tree arg_parms,
6362 tsubst_flags_t complain,
6363 tree in_decl,
6364 tree outer_args)
6365 {
6376 /* Determine whether we have a parameter pack at the end of the
6377 template template parameter's template parameter list. */
6379 {
6386 {
6400 }
6401 }
6407 /* Check all of the template parameters except the parameter pack at
6408 the end (if any). */
6410 {
6419 outer_args))
6422 }
6425 {
6426 /* Check each of the template parameters in the template
6427 argument against the template parameter pack at the end of
6428 the template template parameter. */
6435 {
6442 outer_args))
6444 }
6445 }
6448 }
6450 /* Verifies that the deduced template arguments (in TARGS) for the
6451 template template parameters (in TPARMS) represent valid bindings,
6452 by comparing the template parameter list of each template argument
6453 to the template parameter list of its corresponding template
6454 template parameter, in accordance with DR150. This
6455 routine can only be called after all template arguments have been
6456 deduced. It will return TRUE if all of the template template
6457 parameter bindings are okay, FALSE otherwise. */
6458 bool
6460 {
6464 /* We're dealing with template parms in this process. */
6470 {
6475 {
6480 {
6481 /* Look inside the argument pack. */
6484 }
6487 {
6491 /* Extract the next argument from the argument
6492 pack. */
6496 /* Look at the pattern of the pack expansion. */
6499 /* Extract the template parameters from the template
6500 argument. */
6506 /* Verify that we can coerce the template template
6507 parameters from the template argument to the template
6508 parameter. This requires an exact match. */
6510 && !coerce_template_template_parms
6512 targ_parms,
6513 tf_none,
6514 tparm,
6515 targs))
6516 {
6519 }
6520 }
6521 }
6522 }
6524 out:
6528 }
6530 /* Since type attributes aren't mangled, we need to strip them from
6531 template type arguments. */
6533 static tree
6535 {
6536 tree mv;
6543 {
6548 }
6550 }
6552 // A template declaration can be substituted for a constrained
6553 // template template parameter only when the argument is more
6554 // constrained than the parameter.
6555 static bool
6557 {
6558 // TODO: The argument may not have a decl result. This seems to
6559 // happen in some classes with nested template template
6560 // parameters (e.g., a rebind struct in a class taking a template
6561 // template parameter. If this is the case, just return true and
6562 // allow things to happen as they always did.
6564 {
6567 }
6572 // If the template parameter is constrained, we need to rewrite its
6573 // constraints in terms of the ARG's template parameters. This ensures
6574 // that all of the template parameter types will have the same depth.
6575 //
6576 // Note that this is only valid when coerce_template_template_parm is
6577 // true for the innermost template parameters of PARM and ARG. In other
6578 // words, because coercion is successful, this conversion will be valid.
6580 {
6588 }
6591 }
6593 // Convert a placeholder argument into a binding to the original
6594 // parameter. The original parameter is saved as the TREE_TYPE of
6595 // ARG.
6598 {
6601 }
6603 /* Convert the indicated template ARG as necessary to match the
6604 indicated template PARM. Returns the converted ARG, or
6605 error_mark_node if the conversion was unsuccessful. Error and
6606 warning messages are issued under control of COMPLAIN. This
6607 conversion is for the Ith parameter in the parameter list. ARGS is
6608 the full set of template arguments deduced so far. */
6610 static tree
6612 tree arg,
6613 tree args,
6614 tsubst_flags_t complain,
6616 tree in_decl)
6617 {
6618 tree orig_arg;
6619 tree val;
6622 // Trivially convert placeholders.
6628 {
6629 /* The template argument was the name of some
6630 member function. That's usually
6631 invalid, but static members are OK. In any
6632 case, grab the underlying fields/functions
6633 and issue an error later if required. */
6636 }
6644 /* When determining whether an argument pack expansion is a template,
6645 look at the pattern. */
6649 /* Deal with an injected-class-name used as a template template arg. */
6651 {
6654 {
6664 }
6665 }
6667 is_tmpl_type =
6683 {
6685 {
6689 }
6692 "to refer to a type member of a template parameter, "
6697 typename_type,
6698 complain);
6701 }
6703 {
6705 {
6707 {
6717 else
6719 }
6720 }
6722 }
6724 {
6726 {
6732 else
6734 }
6736 }
6739 {
6741 {
6745 /* The number of argument required is not known yet.
6746 Just accept it for now. */
6748 else
6749 {
6753 /* Strip alias templates that are equivalent to another
6754 template. */
6760 args))
6761 {
6764 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6765 TEMPLATE_DECL. */
6767 {
6772 }
6773 }
6774 else
6775 {
6777 {
6783 }
6786 }
6788 // Check that the constraints are compatible before allowing the
6789 // substitution.
6792 {
6794 {
6800 }
6802 }
6803 }
6804 }
6805 else
6807 /* We only form one instance of each template specialization.
6808 Therefore, if we use a non-canonical variant (i.e., a
6809 typedef), any future messages referring to the type will use
6810 the typedef, which is confusing if those future uses do not
6811 themselves also use the typedef. */
6814 }
6815 else
6816 {
6823 {
6826 else
6827 {
6828 /* Not sure if this is reachable, but it doesn't hurt
6829 to be robust. */
6832 }
6833 }
6836 /* We used to call digest_init here. However, digest_init
6837 will report errors, which we don't want when complain
6838 is zero. More importantly, digest_init will try too
6839 hard to convert things: for example, `0' should not be
6840 converted to pointer type at this point according to
6841 the standard. Accepting this is not merely an
6842 extension, since deciding whether or not these
6843 conversions can occur is part of determining which
6844 function template to call, or whether a given explicit
6845 argument specification is valid. */
6847 else
6856 {
6857 /* Strip typedefs from the SCOPE_REF. */
6860 complain);
6863 }
6864 }
6867 }
6869 /* Coerces the remaining template arguments in INNER_ARGS (from
6870 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6871 Returns the coerced argument pack. PARM_IDX is the position of this
6872 parameter in the template parameter list. ARGS is the original
6873 template argument list. */
6874 static tree
6877 tree args,
6878 tree inner_args,
6880 tree new_args,
6882 tree in_decl,
6883 tsubst_flags_t complain)
6884 {
6887 tree packed_args;
6888 tree argument_pack;
6895 {
6896 /* When the template parameter is a non-type template parameter pack
6897 or template template parameter pack whose type or template
6898 parameters use parameter packs, we know exactly how many arguments
6899 we are looking for. Build a vector of the instantiated decls for
6900 these template parameters in PACKED_PARMS. */
6901 /* We can't use make_pack_expansion here because it would interpret a
6902 _DECL as a use rather than a declaration. */
6916 /* If we're doing a partial instantiation of a member template,
6917 verify that all of the types used for the non-type
6918 template parameter pack are, in fact, valid for non-type
6919 template parameters. */
6922 {
6925 {
6929 }
6930 }
6933 }
6934 else
6937 /* Convert the remaining arguments, which will be a part of the
6938 parameter pack "parm". */
6940 {
6946 {
6947 /* Once we've packed as many args as we have types, stop. */
6951 /* We don't know how many args we have yet, just
6952 use the unconverted ones for now. */
6954 else
6956 }
6959 {
6962 }
6963 else
6966 in_decl);
6970 }
6974 {
6978 }
6983 else
6984 {
6989 }
6992 #ifdef ENABLE_CHECKING
6995 #endif
6997 }
6999 /* Returns the number of pack expansions in the template argument vector
7000 ARGS. */
7002 static int
7004 {
7009 {
7013 }
7015 }
7017 /* Convert all template arguments to their appropriate types, and
7018 return a vector containing the innermost resulting template
7019 arguments. If any error occurs, return error_mark_node. Error and
7020 warning messages are issued under control of COMPLAIN.
7022 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7023 for arguments not specified in ARGS. Otherwise, if
7024 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7025 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7026 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7027 ARGS. */
7029 static tree
7031 tree args,
7032 tree in_decl,
7033 tsubst_flags_t complain,
7036 {
7038 tree orig_inner_args;
7039 tree inner_args;
7040 tree new_args;
7041 tree new_inner_args;
7045 /* When used as a boolean value, indicates whether this is a
7046 variadic template parameter list. Since it's an int, we can also
7047 subtract it from nparms to get the number of non-variadic
7048 parameters. */
7058 /* Determine if there are any parameter packs. */
7060 {
7066 }
7069 /* If there are no parameters that follow a parameter pack, we need to
7070 expand any argument packs so that we can deduce a parameter pack from
7071 some non-packed args followed by an argument pack, as in variadic85.C.
7072 If there are such parameters, we need to leave argument packs intact
7073 so the arguments are assigned properly. This can happen when dealing
7074 with a nested class inside a partial specialization of a class
7075 template, as in variadic92.C, or when deducing a template parameter pack
7076 from a sub-declarator, as in variadic114.C. */
7080 /* Count any pack expansion args. */
7086 && require_all_args
7087 && !variadic_args_p
7088 && (!use_default_args
7091 {
7093 {
7095 {
7099 }
7100 else
7106 }
7109 }
7110 /* We can't pass a pack expansion to a non-pack parameter of an alias
7111 template (DR 1430). */
7113 && variadic_args_p
7115 {
7117 {
7119 {
7125 {
7130 }
7131 }
7133 found:;
7134 }
7136 }
7138 /* We need to evaluate the template arguments, even though this
7139 template-id may be nested within a "sizeof". */
7148 {
7149 tree arg;
7150 tree parm;
7152 /* Get the Ith template parameter. */
7156 {
7159 }
7161 /* Calculate the next argument. */
7164 else
7169 {
7170 /* Some arguments will be placed in the
7171 template parameter pack PARM. */
7178 {
7179 /* We don't know how many args we have yet, just use the
7180 unconverted (and still packed) ones for now. */
7184 }
7188 /* Store this argument. */
7190 {
7191 lost++;
7192 /* We are done with all of the arguments. */
7194 }
7195 else
7196 {
7199 }
7202 }
7204 {
7206 {
7207 /* We don't know how many args we have yet, just
7208 use the unconverted ones for now. */
7212 }
7213 }
7215 {
7216 /* There must be a default arg in this case. */
7219 /* The position of the first default template argument,
7220 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7221 Record that. */
7225 }
7226 else
7230 {
7233 }
7235 /* This only occurs if there was an error in the template
7236 parameter list itself (which we would already have
7237 reported) that we are trying to recover from, e.g., a class
7238 template with a parameter list such as
7239 template<typename..., typename>. */
7241 else
7247 lost++;
7249 }
7254 {
7256 {
7261 }
7263 }
7268 #ifdef ENABLE_CHECKING
7272 #endif
7275 }
7277 // Convert all template arguments to their appropriate types, and
7278 // return a vector containing the innermost resulting template
7279 // arguments. If any error occurs, return error_mark_node. Error and
7280 // warning messages are not issued.
7281 //
7282 // Note that no function argument deduction is performed, and default
7283 // arguments are used to fill in unspecified arguments.
7284 tree
7286 {
7288 }
7290 /* Like coerce_template_parms. If PARMS represents all template
7291 parameters levels, this function returns a vector of vectors
7292 representing all the resulting argument levels. Note that in this
7293 case, only the innermost arguments are coerced because the
7294 outermost ones are supposed to have been coerced already.
7296 Otherwise, if PARMS represents only (the innermost) vector of
7297 parameters, this function returns a vector containing just the
7298 innermost resulting arguments. */
7300 static tree
7302 tree args,
7303 tree in_decl,
7304 tsubst_flags_t complain,
7307 {
7310 tree coerced_args;
7313 {
7315 tree level;
7321 {
7322 tree l;
7326 require_all_args,
7327 use_default_args);
7328 else
7335 }
7336 }
7337 else
7340 require_all_args,
7341 use_default_args);
7343 }
7345 /* Returns 1 if template args OT and NT are equivalent. */
7347 static int
7349 {
7356 /* For member templates */
7365 {
7382 }
7384 {
7385 /* We get here probably because we are in the middle of substituting
7386 into the pattern of a pack expansion. In that case the
7387 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7388 interested in. So we want to use the initial pack argument for
7389 the comparison. */
7394 }
7399 else
7401 }
7403 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7404 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7405 NEWARG_PTR with the offending arguments if they are non-NULL. */
7407 static int
7410 {
7423 {
7428 {
7434 }
7435 }
7437 }
7439 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7440 of template arguments. Returns 0 otherwise. */
7442 int
7444 {
7446 }
7448 static void
7450 {
7460 /* We are called both from instantiate_decl, where we've already had a
7461 tinst_level pushed, and instantiate_template, where we haven't.
7462 Compensate. */
7473 else
7482 }
7485 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7486 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7487 documentation for TEMPLATE_ID_EXPR. */
7489 tree
7491 {
7492 tree type;
7500 {
7503 }
7506 {
7508 unknown_type_node,
7510 arglist);
7512 }
7519 }
7521 /* Within the scope of a template class S<T>, the name S gets bound
7522 (in build_self_reference) to a TYPE_DECL for the class, not a
7523 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7524 or one of its enclosing classes, and that type is a template,
7525 return the associated TEMPLATE_DECL. Otherwise, the original
7526 DECL is returned.
7528 Also handle the case when DECL is a TREE_LIST of ambiguous
7529 injected-class-names from different bases. */
7531 tree
7533 {
7537 /* DR 176: A lookup that finds an injected-class-name (10.2
7538 [class.member.lookup]) can result in an ambiguity in certain cases
7539 (for example, if it is found in more than one base class). If all of
7540 the injected-class-names that are found refer to specializations of
7541 the same class template, and if the name is followed by a
7542 template-argument-list, the reference refers to the class template
7543 itself and not a specialization thereof, and is not ambiguous. */
7545 {
7548 {
7554 }
7557 else
7559 }
7565 }
7567 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7568 parameters, find the desired type.
7570 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7572 IN_DECL, if non-NULL, is the template declaration we are trying to
7573 instantiate.
7575 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7576 the class we are looking up.
7578 Issue error and warning messages under control of COMPLAIN.
7580 If the template class is really a local class in a template
7581 function, then the FUNCTION_CONTEXT is the function in which it is
7582 being instantiated.
7584 ??? Note that this function is currently called *twice* for each
7585 template-id: the first time from the parser, while creating the
7586 incomplete type (finish_template_type), and the second type during the
7587 real instantiation (instantiate_template_class). This is surely something
7588 that we want to avoid. It also causes some problems with argument
7589 coercion (see convert_nontype_argument for more information on this). */
7591 static tree
7594 {
7596 tree t;
7599 spec_entry elt;
7600 hashval_t hash;
7603 {
7607 else
7608 {
7615 }
7618 }
7620 {
7623 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7624 an implicit typename for the second A. Deal with it. */
7629 {
7632 }
7633 }
7636 {
7639 }
7643 {
7647 }
7649 {
7652 }
7654 /* Issue an error message if we didn't find a template. */
7656 {
7660 }
7663 /* Make sure it's a user visible template, if it was named by
7664 the user. */
7667 {
7669 {
7673 }
7675 }
7679 /* An alias that just changes the name of a template is equivalent to the
7680 other template, so if any of the arguments are pack expansions, strip
7681 the alias to avoid problems with a pack expansion passed to a non-pack
7682 alias template parameter (DR 1430). */
7687 {
7688 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7689 template arguments */
7691 tree parm;
7692 tree arglist2;
7693 tree outer;
7697 /* Consider an example where a template template parameter declared as
7699 template <class T, class U = std::allocator<T> > class TT
7701 The template parameter level of T and U are one level larger than
7702 of TT. To proper process the default argument of U, say when an
7703 instantiation `TT<int>' is seen, we need to build the full
7704 arguments containing {int} as the innermost level. Outer levels,
7705 available when not appearing as default template argument, can be
7706 obtained from the arguments of the enclosing template.
7708 Suppose that TT is later substituted with std::vector. The above
7709 instantiation is `TT<int, std::allocator<T> >' with TT at
7710 level 1, and T at level 2, while the template arguments at level 1
7711 becomes {std::vector} and the inner level 2 is {int}. */
7717 /* This is an argument of the current template, so we haven't set
7718 DECL_CONTEXT yet. */
7725 complain,
7735 }
7736 else
7737 {
7739 tree gen_tmpl;
7740 tree type_decl;
7748 /* An error occurred while building the template TEMPL, and a
7749 diagnostic has most certainly been emitted for that
7750 already. Let's propagate that error. */
7759 {
7760 /* We've been given an incomplete set of template arguments.
7761 For example, given:
7763 template <class T> struct S1 {
7764 template <class U> struct S2 {};
7765 template <class U> struct S2<U*> {};
7766 };
7768 we will be called with an ARGLIST of `U*', but the
7769 TEMPLATE will be `template <class T> template
7770 <class U> struct S1<T>::S2'. We must fill in the missing
7771 arguments. */
7772 arglist
7774 arglist);
7776 }
7778 /* Now we should have enough arguments. */
7781 /* From here on, we're only interested in the most general
7782 template. */
7784 /* Calculate the BOUND_ARGS. These will be the args that are
7785 actually tsubst'd into the definition to create the
7786 instantiation. */
7788 {
7789 /* We have multiple levels of arguments to coerce, at once. */
7799 {
7800 tree a;
7804 complain,
7807 else
7808 /* Outer levels should have already been coerced. */
7811 /* Don't process further if one of the levels fails. */
7813 {
7814 /* Restore the ARGLIST to its full size. */
7817 }
7821 /* We temporarily reduce the length of the ARGLIST so
7822 that coerce_template_parms will see only the arguments
7823 corresponding to the template parameters it is
7824 examining. */
7826 }
7828 /* Restore the ARGLIST to its full size. */
7832 }
7833 else
7834 arglist
7837 gen_tmpl,
7838 complain,
7843 /* We were unable to bind the arguments. */
7846 /* In the scope of a template class, explicit references to the
7847 template class refer to the type of the template, not any
7848 instantiation of it. For example, in:
7850 template <class T> class C { void f(C<T>); }
7852 the `C<T>' is just the same as `C'. Outside of the
7853 class, however, such a reference is an instantiation. */
7857 /* comp_template_args is expensive, check it last. */
7859 arglist))
7862 /* If we already have this specialization, return it. */
7872 // If the the template's constraints are not satisfied, then we
7873 // cannot form a valid type.
7874 //
7875 // Note that the check is deferred until after the hash-lookup.
7876 // This prevents redundant checks on specializations.
7878 {
7879 // Diagnose constraints here since they are not diagnosed
7880 // anywhere else.
7882 {
7885 }
7887 }
7891 /* If the deduced arguments are invalid, then the binding
7892 failed. */
7896 complain))
7903 {
7908 }
7918 /* Create the type. */
7920 {
7921 /* The user referred to a specialization of an alias
7922 template represented by GEN_TMPL.
7924 [temp.alias]/2 says:
7926 When a template-id refers to the specialization of an
7927 alias template, it is equivalent to the associated
7928 type obtained by substitution of its
7929 template-arguments for the template-parameters in the
7930 type-id of the alias template. */
7933 /* Note that the call above (by indirectly calling
7934 register_specialization in tsubst_decl) registers the
7935 TYPE_DECL representing the specialization of the alias
7936 template. So next time someone substitutes ARGLIST for
7937 the template parms into the alias template (GEN_TMPL),
7938 she'll get that TYPE_DECL back. */
7942 }
7944 {
7946 {
7955 }
7956 else
7957 {
7958 /* We don't want to call start_enum for this type, since
7959 the values for the enumeration constants may involve
7960 template parameters. And, no one should be interested
7961 in the enumeration constants for such a type. */
7964 }
7968 }
7970 {
7977 /* A local class. Make sure the decl gets registered properly. */
7982 /* This instantiation is another name for the primary
7983 template type. Set the TYPE_CANONICAL field
7984 appropriately. */
7987 /* Some of the template arguments require structural
7988 equality testing, so this template class requires
7989 structural equality testing. */
7991 }
7992 else
7995 /* If we called start_enum or pushtag above, this information
7996 will already be set up. */
7998 {
8005 }
8006 else
8010 {
8016 {
8019 }
8020 }
8022 /* Let's consider the explicit specialization of a member
8023 of a class template specialization that is implicitly instantiated,
8024 e.g.:
8025 template<class T>
8026 struct S
8027 {
8028 template<class U> struct M {}; //#0
8029 };
8031 template<>
8032 template<>
8033 struct S<int>::M<char> //#1
8034 {
8035 int i;
8036 };
8037 [temp.expl.spec]/4 says this is valid.
8039 In this case, when we write:
8040 S<int>::M<char> m;
8042 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8043 the one of #0.
8045 When we encounter #1, we want to store the partial instantiation
8046 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8048 For all cases other than this "explicit specialization of member of a
8049 class template", we just want to store the most general template into
8050 the CLASSTYPE_TI_TEMPLATE of M.
8052 This case of "explicit specialization of member of a class template"
8053 only happens when:
8054 1/ the enclosing class is an instantiation of, and therefore not
8055 the same as, the context of the most general template, and
8056 2/ we aren't looking at the partial instantiation itself, i.e.
8057 the innermost arguments are not the same as the innermost parms of
8058 the most general template.
8060 So it's only when 1/ and 2/ happens that we want to use the partial
8061 instantiation of the member template in lieu of its most general
8062 template. */
8066 /* the enclosing class must be an instantiation... */
8069 {
8070 tree partial_inst_args;
8073 partial_inst_args =
8079 use_partial_inst_tmpl =
8080 /*...and we must not be looking at the partial instantiation
8081 itself. */
8083 partial_inst_args);
8084 }
8087 /* This case is easy; there are no member templates involved. */
8089 else
8090 {
8091 /* This is a full instantiation of a member template. Find
8092 the partial instantiation of which this is an instance. */
8094 /* Temporarily reduce by one the number of levels in the ARGLIST
8095 so as to avoid comparing the last set of arguments. */
8099 /* FOUND is either a proper class type, or an alias
8100 template specialization. In the later case, it's a
8101 TYPE_DECL, resulting from the substituting of arguments
8102 for parameters in the TYPE_DECL of the alias template
8103 done earlier. So be careful while getting the template
8104 of FOUND. */
8108 }
8110 // Build template info for the new specialization.
8120 /* Note this use of the partial instantiation so we can check it
8121 later in maybe_process_partial_specialization. */
8128 /* Now that the type has been registered on the instantiations
8129 list, we set up the enumerators. Because the enumeration
8130 constants may involve the enumeration type itself, we make
8131 sure to register the type first, and then create the
8132 constants. That way, doing tsubst_expr for the enumeration
8133 constants won't result in recursive calls here; we'll find
8134 the instantiation and exit above. */
8138 /* If the type makes use of template parameters, the
8139 code that generates debugging information will crash. */
8142 /* Possibly limit visibility based on template args. */
8147 }
8148 }
8150 /* Wrapper for lookup_template_class_1. */
8152 tree
8155 {
8156 tree ret;
8162 }
8163 \f
8164 struct pair_fn_data
8165 {
8166 tree_fn_t fn;
8168 /* True when we should also visit template parameters that occur in
8169 non-deduced contexts. */
8172 };
8174 /* Called from for_each_template_parm via walk_tree. */
8176 static tree
8178 {
8191 {
8195 /* Fall through. */
8218 /* Since we're not going to walk subtrees, we have to do this
8219 explicitly here. */
8223 /* Fall through. */
8226 /* Check the return type. */
8231 /* Check the parameter types. Since default arguments are not
8232 instantiated until they are needed, the TYPE_ARG_TYPES may
8233 contain expressions that involve template parameters. But,
8234 no-one should be looking at them yet. And, once they're
8235 instantiated, they don't contain template parameters, so
8236 there's no point in looking at them then, either. */
8237 {
8238 tree parm;
8245 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8246 want walk_tree walking into them itself. */
8248 }
8266 /* Fall through. */
8282 /* Record template parameters such as `T' inside `TT<T>'. */
8286 /* Fall through. */
8298 /* A template template parameter is encountered. */
8304 /* Already substituted template template parameter */
8327 /* If there's no type, then this thing must be some expression
8328 involving template parameters. */
8350 }
8352 /* We didn't find any template parameters we liked. */
8354 }
8356 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8357 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8358 call FN with the parameter and the DATA.
8359 If FN returns nonzero, the iteration is terminated, and
8360 for_each_template_parm returns 1. Otherwise, the iteration
8361 continues. If FN never returns a nonzero value, the value
8362 returned by for_each_template_parm is 0. If FN is NULL, it is
8363 considered to be the function which always returns 1.
8365 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8366 parameters that occur in non-deduced contexts. When false, only
8367 visits those template parameters that can be deduced. */
8369 static int
8373 {
8377 /* Set up. */
8382 /* Walk the tree. (Conceptually, we would like to walk without
8383 duplicates, but for_each_template_parm_r recursively calls
8384 for_each_template_parm, so we would need to reorganize a fair
8385 bit to use walk_tree_without_duplicates, so we keep our own
8386 visited list.) */
8389 else
8392 for_each_template_parm_r,
8396 /* Clean up. */
8398 {
8401 }
8404 }
8406 /* Returns true if T depends on any template parameter. */
8408 int
8410 {
8437 else
8438 {
8441 }
8446 }
8448 /* Returns true iff current_function_decl is an incompletely instantiated
8449 template. Useful instead of processing_template_decl because the latter
8450 is set to 0 during fold_non_dependent_expr. */
8452 bool
8454 {
8463 }
8465 /* Returns true if T depends on any template parameter with level LEVEL. */
8467 int
8469 {
8472 }
8474 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8475 ill-formed translation unit, i.e. a variable or function that isn't
8476 usable in a constant expression. */
8480 {
8484 }
8486 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8487 neglectable and instantiated from within an erroneous instantiation. */
8489 static bool
8491 {
8502 }
8510 /* We're starting to instantiate D; record the template instantiation context
8511 for diagnostics and to restore it later. */
8513 int
8515 {
8519 {
8525 else
8533 }
8535 /* If the current instantiation caused problems, don't let it instantiate
8536 anything else. Do allow deduction substitution and decls usable in
8537 constant expressions. */
8554 }
8556 /* We're done instantiating this template; return to the instantiation
8557 context. */
8559 void
8561 {
8562 /* Restore the filename and line number stashed away when we started
8563 this instantiation. */
8567 }
8569 /* We're instantiating a deferred template; restore the template
8570 instantiation context in which the instantiation was requested, which
8571 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8573 static tree
8575 {
8587 }
8589 /* Returns the TINST_LEVEL which gives the original instantiation
8590 context. */
8594 {
8600 }
8602 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8603 vector of template arguments, as for tsubst.
8605 Returns an appropriate tsubst'd friend declaration. */
8607 static tree
8609 {
8610 tree new_friend;
8615 /* This was a friend declared with an explicit template
8616 argument list, e.g.:
8618 friend void f<>(T);
8620 to indicate that f was a template instantiation, not a new
8621 function declaration. Now, we have to figure out what
8622 instantiation of what template. */
8623 {
8625 tree new_args;
8626 tree tmpl;
8629 /* Friend functions are looked up in the containing namespace scope.
8630 We must enter that scope, to avoid finding member functions of the
8631 current class with same name. */
8646 tsk_none);
8648 }
8652 /* The NEW_FRIEND will look like an instantiation, to the
8653 compiler, but is not an instantiation from the point of view of
8654 the language. For example, we might have had:
8656 template <class T> struct S {
8657 template <class U> friend void f(T, U);
8658 };
8660 Then, in S<int>, template <class U> void f(int, U) is not an
8661 instantiation of anything. */
8667 {
8671 }
8673 /* The mangled name for the NEW_FRIEND is incorrect. The function
8674 is not a template instantiation and should not be mangled like
8675 one. Therefore, we forget the mangling here; we'll recompute it
8676 later if we need it. */
8678 {
8681 }
8684 {
8685 tree old_decl;
8686 tree new_friend_template_info;
8687 tree new_friend_result_template_info;
8688 tree ns;
8691 /* We must save some information from NEW_FRIEND before calling
8692 duplicate decls since that function will free NEW_FRIEND if
8693 possible. */
8695 new_friend_is_defn =
8700 {
8701 /* This declaration is a `primary' template. */
8704 new_friend_result_template_info
8706 }
8707 else
8710 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8714 /* Inside pushdecl_namespace_level, we will push into the
8715 current namespace. However, the friend function should go
8716 into the namespace of the template. */
8726 {
8727 /* This new friend declaration matched an existing
8728 declaration. For example, given:
8730 template <class T> void f(T);
8731 template <class U> class C {
8732 template <class T> friend void f(T) {}
8733 };
8735 the friend declaration actually provides the definition
8736 of `f', once C has been instantiated for some type. So,
8737 old_decl will be the out-of-class template declaration,
8738 while new_friend is the in-class definition.
8740 But, if `f' was called before this point, the
8741 instantiation of `f' will have DECL_TI_ARGS corresponding
8742 to `T' but not to `U', references to which might appear
8743 in the definition of `f'. Previously, the most general
8744 template for an instantiation of `f' was the out-of-class
8745 version; now it is the in-class version. Therefore, we
8746 run through all specialization of `f', adding to their
8747 DECL_TI_ARGS appropriately. In particular, they need a
8748 new set of outer arguments, corresponding to the
8749 arguments for this class instantiation.
8751 The same situation can arise with something like this:
8753 friend void f(int);
8754 template <class T> class C {
8755 friend void f(T) {}
8756 };
8758 when `C<int>' is instantiated. Now, `f(int)' is defined
8759 in the class. */
8762 /* On the other hand, if the in-class declaration does
8763 *not* provide a definition, then we don't want to alter
8764 existing definitions. We can just leave everything
8765 alone. */
8766 ;
8767 else
8768 {
8772 /* Overwrite whatever template info was there before, if
8773 any, with the new template information pertaining to
8774 the declaration. */
8778 {
8779 /* We should have called reregister_specialization in
8780 duplicate_decls. */
8785 /* Instantiate it if the global has already been used. */
8789 }
8790 else
8791 {
8792 tree t;
8794 /* Indicate that the old function template is a partial
8795 instantiation. */
8803 /* Reassign any specializations already in the hash table
8804 to the new more general template, and add the
8805 additional template args. */
8809 {
8811 spec_entry elt;
8823 register_specialization
8826 }
8828 }
8829 }
8831 /* The information from NEW_FRIEND has been merged into OLD_DECL
8832 by duplicate_decls. */
8834 }
8835 }
8836 else
8837 {
8841 /* In the code
8842 template <class T> class C {
8843 template <class U> friend void C1<U>::f (); // case 1
8844 friend void C2<T>::f (); // case 2
8845 };
8846 we only need to make sure CONTEXT is a complete type for
8847 case 2. To distinguish between the two cases, we note that
8848 CONTEXT of case 1 remains dependent type after tsubst while
8849 this isn't true for case 2. */
8859 {
8861 /* do_friend adds the TEMPLATE_DECL for any member friend
8862 template even if it isn't a member template, i.e.
8863 template <class T> friend A<T>::f();
8864 Look through it in that case. */
8868 /* Check to see that the declaration is really present, and,
8869 possibly obtain an improved declaration. */
8874 }
8875 }
8878 }
8880 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8881 template arguments, as for tsubst.
8883 Returns an appropriate tsubst'd friend type or error_mark_node on
8884 failure. */
8886 static tree
8888 {
8889 tree friend_type;
8890 tree tmpl;
8891 tree context;
8894 {
8897 }
8902 {
8905 else
8907 }
8909 /* Look for a class template declaration. We look for hidden names
8910 because two friend declarations of the same template are the
8911 same. For example, in:
8913 struct A {
8914 template <typename> friend class F;
8915 };
8916 template <typename> struct B {
8917 template <typename> friend class F;
8918 };
8920 both F templates are the same. */
8924 /* But, if we don't find one, it might be because we're in a
8925 situation like this:
8927 template <class T>
8928 struct S {
8929 template <class U>
8930 friend struct S;
8931 };
8933 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8934 for `S<int>', not the TEMPLATE_DECL. */
8936 {
8939 }
8942 {
8943 /* The friend template has already been declared. Just
8944 check to see that the declarations match, and install any new
8945 default parameters. We must tsubst the default parameters,
8946 of course. We only need the innermost template parameters
8947 because that is all that redeclare_class_template will look
8948 at. */
8951 {
8952 tree parms;
8953 location_t saved_input_location;
8963 }
8966 }
8967 else
8968 {
8969 /* The friend template has not already been declared. In this
8970 case, the instantiation of the template class will cause the
8971 injection of this template into the global scope. */
8976 /* The new TMPL is not an instantiation of anything, so we
8977 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8978 the new type because that is supposed to be the corresponding
8979 template decl, i.e., TMPL. */
8986 /* Inject this template into the global scope. */
8988 }
8991 {
8994 else
8996 }
8999 }
9001 /* Returns zero if TYPE cannot be completed later due to circularity.
9002 Otherwise returns one. */
9004 static int
9006 {
9016 else
9018 }
9022 /* Apply any attributes which had to be deferred until instantiation
9023 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
9024 ARGS, COMPLAIN, IN_DECL are as tsubst. */
9026 static void
9029 {
9031 tree t;
9036 {
9040 }
9043 {
9047 }
9048 else
9052 {
9057 {
9060 {
9067 {
9074 clauses
9078 else
9080 }
9081 /* If the first attribute argument is an identifier, don't
9082 pass it through tsubst. Attributes like mode, format,
9083 cleanup and several target specific attributes expect it
9084 unmodified. */
9087 {
9088 tree chain
9090 in_decl,
9095 chain);
9096 }
9097 else
9103 }
9104 else
9106 }
9109 }
9110 }
9112 /* Perform (or defer) access check for typedefs that were referenced
9113 from within the template TMPL code.
9114 This is a subroutine of instantiate_decl and instantiate_class_template.
9115 TMPL is the template to consider and TARGS is the list of arguments of
9116 that template. */
9118 static void
9120 {
9121 location_t saved_location;
9132 {
9144 /* Make access check error messages point to the location
9145 of the use of the typedef. */
9149 tf_warning_or_error);
9150 }
9152 }
9154 static tree
9156 {
9158 tree typedecl;
9159 tree pbinfo;
9160 tree base_list;
9162 tree fn_context;
9171 /* Figure out which template is being instantiated. */
9175 /* Determine what specialization of the original template to
9176 instantiate. */
9179 {
9182 }
9184 {
9185 /* This TYPE is actually an instantiation of a partial
9186 specialization. We replace the innermost set of ARGS with
9187 the arguments appropriate for substitution. For example,
9188 given:
9190 template <class T> struct S {};
9191 template <class T> struct S<T*> {};
9193 and supposing that we are instantiating S<int*>, ARGS will
9194 presently be {int*} -- but we need {int}. */
9197 }
9198 else
9199 {
9202 }
9204 /* If the template we're instantiating is incomplete, then clearly
9205 there's nothing we can do. */
9209 /* If we've recursively instantiated too many templates, stop. */
9213 /* Now we're really doing the instantiation. Mark the type as in
9214 the process of being defined. */
9217 /* We may be in the middle of deferred access check. Disable
9218 it now. */
9224 /* Use #pragma pack from the template context. */
9230 /* Set the input location to the most specialized template definition.
9231 This is needed if tsubsting causes an error. */
9243 {
9246 /* Adjust visibility for template arguments. */
9248 }
9254 /* We should never instantiate a nested class before its enclosing
9255 class; we need to look up the nested class by name before we can
9256 instantiate it, and that lookup should instantiate the enclosing
9257 class. */
9263 {
9264 tree pbase_binfo;
9265 tree pushed_scope;
9268 /* We must enter the scope containing the type, as that is where
9269 the accessibility of types named in dependent bases are
9270 looked up from. */
9273 /* Substitute into each of the bases to determine the actual
9274 basetypes. */
9276 {
9277 tree base;
9283 {
9284 expanded_bases =
9291 }
9294 {
9296 /* Extract the already-expanded base class. */
9298 else
9299 /* Substitute to figure out the base class. */
9301 NULL_TREE);
9309 }
9310 }
9312 /* The list is now in reverse order; correct that. */
9317 }
9318 /* Now call xref_basetypes to set up all the base-class
9319 information. */
9327 /* Now that our base classes are set up, enter the scope of the
9328 class, so that name lookups into base classes, etc. will work
9329 correctly. This is precisely analogous to what we do in
9330 begin_class_definition when defining an ordinary non-template
9331 class, except we also need to push the enclosing classes. */
9334 /* Now members are processed in the order of declaration. */
9337 {
9341 {
9343 {
9344 /* Build new CLASSTYPE_NESTED_UTDS. */
9346 tree newtag;
9352 /* If the member is a class template, then -- even after
9353 substitution -- there may be dependent types in the
9354 template argument list for the class. We increment
9355 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9356 that function will assume that no types are dependent
9357 when outside of a template. */
9367 {
9371 /* Unfortunately, lookup_template_class sets
9372 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9373 instantiation (i.e., for the type of a member
9374 template class nested within a template class.)
9375 This behavior is required for
9376 maybe_process_partial_specialization to work
9377 correctly, but is not accurate in this case;
9378 the TAG is not an instantiation of anything.
9379 (The corresponding TEMPLATE_DECL is an
9380 instantiation, but the TYPE is not.) */
9383 /* Now, we call pushtag to put this NEWTAG into the scope of
9384 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9385 pushtag calling push_template_decl. We don't have to do
9386 this for enums because it will already have been done in
9387 tsubst_enum. */
9391 }
9392 }
9394 {
9395 /* Build new TYPE_METHODS. */
9396 tree r;
9405 /* Instantiate members marked with attribute used. */
9411 }
9412 else
9413 {
9414 /* Build new TYPE_FIELDS. */
9416 {
9417 tree condition;
9420 condition =
9430 }
9432 {
9433 tree r;
9437 /* The file and line for this declaration, to
9438 assist in error message reporting. Since we
9439 called push_tinst_level above, we don't need to
9440 restore these. */
9450 {
9451 /* A capture pack became multiple fields. */
9454 }
9457 {
9461 {
9462 /* In [temp.inst]:
9464 [t]he initialization (and any associated
9465 side-effects) of a static data member does
9466 not occur unless the static data member is
9467 itself used in a way that requires the
9468 definition of the static data member to
9469 exist.
9471 Therefore, we do not substitute into the
9472 initialized for the static data member here. */
9473 finish_static_data_member_decl
9479 /* Instantiate members marked with attribute used. */
9482 }
9484 {
9485 /* Determine whether R has a valid type and can be
9486 completed later. If R is invalid, then its type
9487 is replaced by error_mark_node. */
9493 {
9496 }
9497 }
9499 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9500 such a thing will already have been added to the field
9501 list by tsubst_enum in finish_member_declaration in the
9502 CLASSTYPE_NESTED_UTDS case above. */
9506 {
9509 }
9510 }
9511 }
9512 }
9513 }
9514 else
9515 {
9518 {
9519 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9525 {
9526 /* template <class T> friend class C; */
9529 }
9531 {
9532 /* template <class T> friend class C::D; */
9538 }
9541 {
9542 /* This could be either
9544 friend class T::C;
9546 when dependent_type_p is false or
9548 template <class U> friend class T::C;
9550 otherwise. */
9553 /* Bump processing_template_decl for correct
9554 dependent_type_p calculation. */
9559 }
9562 {
9563 /* friend class C;
9565 where C hasn't been declared yet. Let's lookup name
9566 from namespace scope directly, bypassing any name that
9567 come from dependent base class. */
9570 /* The call to xref_tag_from_type does injection for friend
9571 classes. */
9573 friend_type =
9577 }
9579 /* friend class C<T>; */
9582 /* Otherwise it's
9584 friend class C;
9586 where C is already declared or
9588 friend class C<int>;
9590 We don't have to do anything in these cases. */
9593 /* Trick make_friend_class into realizing that the friend
9594 we're adding is a template, not an ordinary class. It's
9595 important that we use make_friend_class since it will
9596 perform some error-checking and output cross-reference
9597 information. */
9605 }
9606 else
9607 {
9608 /* Build new DECL_FRIENDLIST. */
9609 tree r;
9611 /* The file and line for this declaration, to
9612 assist in error message reporting. Since we
9613 called push_tinst_level above, we don't need to
9614 restore these. */
9618 {
9621 }
9626 {
9629 }
9630 }
9631 }
9632 }
9635 {
9638 {
9643 /* We need to instantiate the capture list from the template
9644 after we've instantiated the closure members, but before we
9645 consider adding the conversion op. Also keep any captures
9646 that may have been added during instantiation of the op(). */
9648 tree tmpl_cap
9657 }
9658 else
9660 }
9662 /* Set the file and line number information to whatever is given for
9663 the class itself. This puts error messages involving generated
9664 implicit functions at a predictable point, and the same point
9665 that would be used for non-template classes. */
9672 /* We don't instantiate default arguments for member functions. 14.7.1:
9674 The implicit instantiation of a class template specialization causes
9675 the implicit instantiation of the declarations, but not of the
9676 definitions or default arguments, of the class member functions,
9677 member classes, static data members and member templates.... */
9679 /* Some typedefs referenced from within the template code need to be access
9680 checked at template instantiation time, i.e now. These types were
9681 added to the template at parsing time. Let's get those and perform
9682 the access checks then. */
9692 /* The vtable for a template class can be emitted in any translation
9693 unit in which the class is instantiated. When there is no key
9694 method, however, finish_struct_1 will already have added TYPE to
9695 the keyed_classes list. */
9700 }
9702 /* Wrapper for instantiate_class_template_1. */
9704 tree
9706 {
9707 tree ret;
9712 }
9714 static tree
9716 {
9717 tree r;
9723 else
9724 {
9731 }
9733 }
9735 /* Given a function parameter pack TMPL_PARM and some function parameters
9736 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9737 and set *SPEC_P to point at the next point in the list. */
9739 tree
9741 {
9742 /* Collect all of the extra "packed" parameters into an
9743 argument pack. */
9744 tree parmvec;
9745 tree parmtypevec;
9756 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9761 {
9764 }
9766 /* Build the argument packs. */
9773 }
9775 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9776 NONTYPE_ARGUMENT_PACK. */
9778 static tree
9780 {
9782 }
9784 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9785 pack expansion. */
9787 static bool
9789 {
9794 }
9797 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9799 static tree
9801 {
9808 }
9810 /* This is a subroutine of tsubst_pack_expansion.
9812 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9813 mechanism to store the (non complete list of) arguments of the
9814 substitution and return a non substituted pack expansion, in order
9815 to wait for when we have enough arguments to really perform the
9816 substitution. */
9818 static bool
9822 {
9823 /* If one pack has an expansion and another pack has a normal
9824 argument or if one pack has an empty argument and an another
9825 one hasn't then tsubst_pack_expansion cannot perform the
9826 substitution and need to fall back on the
9827 PACK_EXPANSION_EXTRA mechanism. */
9835 {
9838 parm_pack;
9840 {
9845 else
9847 }
9851 }
9853 }
9855 /* [temp.variadic]/6 says that:
9857 The instantiation of a pack expansion [...]
9858 produces a list E1,E2, ..., En, where N is the number of elements
9859 in the pack expansion parameters.
9861 This subroutine of tsubst_pack_expansion produces one of these Ei.
9863 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9864 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9865 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9866 INDEX is the index 'i' of the element Ei to produce. ARGS,
9867 COMPLAIN, and IN_DECL are the same parameters as for the
9868 tsubst_pack_expansion function.
9870 The function returns the resulting Ei upon successful completion,
9871 or error_mark_node.
9873 Note that this function possibly modifies the ARGS parameter, so
9874 it's the responsibility of the caller to restore it. */
9876 static tree
9878 tree parm_packs,
9880 tree args /* This parm gets
9882 tsubst_flags_t complain,
9883 tree in_decl)
9884 {
9885 tree t;
9888 /* For each parameter pack, change the substitution of the parameter
9889 pack to the ith argument in its argument pack, then expand the
9890 pattern. */
9892 {
9897 ith_elem_is_expansion |=
9900 /* Select the Ith argument from the pack. */
9903 {
9905 {
9909 }
9910 else
9912 }
9913 else
9914 {
9919 {
9921 /* Update the corresponding argument. */
9923 }
9924 else
9925 /* Re-use the ARGUMENT_PACK_SELECT. */
9927 }
9929 }
9931 /* Substitute into the PATTERN with the (possibly altered)
9932 arguments. */
9934 /* Expanding a fixed parameter pack from
9935 coerce_template_parameter_pack. */
9940 else
9943 /* If the Ith argument pack element is a pack expansion, then
9944 the Ith element resulting from the substituting is going to
9945 be a pack expansion as well. */
9950 }
9952 // Substitute args into the pack expansion T, and rewrite the resulting
9953 // list as a conjuntion of the specified terms. If the result is an empty
9954 // expression, return boolean_true_node.
9955 tree
9957 tree in_decl)
9958 {
9961 // If the resulting expression is type- or value-dependent, then
9962 // return it after setting the result type to bool (so it can be
9963 // expanded as a conjunction).
9964 //
9965 // This happens when instantiating constrained variadic
9966 // member function templates.
9968 {
9971 }
9973 // Conjoin requirements. An empty conjunction is equivalent to ture.
9976 else
9978 }
9981 /* Substitute ARGS into T, which is an pack expansion
9982 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9983 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9984 (if only a partial substitution could be performed) or
9985 ERROR_MARK_NODE if there was an error. */
9986 tree
9988 tree in_decl)
9989 {
9990 tree pattern;
9994 tree result;
10002 /* Add in any args remembered from an earlier partial instantiation. */
10007 /* Determine the argument packs that will instantiate the parameter
10008 packs used in the expansion expression. While we're at it,
10009 compute the number of arguments to be expanded and make sure it
10010 is consistent. */
10013 {
10020 {
10024 else
10027 }
10029 {
10032 else
10033 {
10034 /* We can't rely on local_specializations for a parameter
10035 name used later in a function declaration (such as in a
10036 late-specified return type). Even if it exists, it might
10037 have the wrong value for a recursive call. Just make a
10038 dummy decl, since it's only used for its type. */
10041 /* Partial instantiation of the parm_pack, we can't build
10042 up an argument pack yet. */
10044 else
10047 }
10048 }
10051 else
10052 {
10058 }
10065 /* This can only happen if we forget to expand an argument
10066 pack somewhere else. Just return an error, silently. */
10067 {
10071 }
10074 {
10078 /* Don't bother trying to do a partial substitution with
10079 incomplete packs; we'll try again after deduction. */
10086 {
10092 pattern);
10093 else
10096 pattern);
10098 }
10100 /* Keep track of the parameter packs and their corresponding
10101 argument packs. */
10104 }
10105 else
10106 {
10107 /* We can't substitute for this parameter pack. We use a flag as
10108 well as the missing_level counter because function parameter
10109 packs don't have a level. */
10111 }
10112 }
10114 /* We cannot expand this expansion expression, because we don't have
10115 all of the argument packs we need. */
10117 {
10118 /* We got some full packs, but we can't substitute them in until we
10119 have values for all the packs. So remember these until then. */
10124 }
10126 {
10127 /* There were no real arguments, we're just replacing a parameter
10128 pack with another version of itself. Substitute into the
10129 pattern and return a PACK_EXPANSION_*. The caller will need to
10130 deal with that. */
10134 else
10138 }
10143 {
10144 /* We're in a late-specified return type, so create our own local
10145 specializations map; the current map is either NULL or (in the
10146 case of recursive unification) might have bindings that we don't
10147 want to use or alter. */
10150 }
10152 /* For each argument in each argument pack, substitute into the
10153 pattern. */
10156 {
10158 i,
10160 in_decl);
10163 {
10166 }
10167 }
10169 /* Update ARGS to restore the substitution from parameter packs to
10170 their argument packs. */
10172 {
10178 else
10179 {
10187 /* Update the corresponding argument. */
10191 else
10193 }
10194 }
10197 {
10200 }
10203 }
10205 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10206 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10207 parameter packs; all parms generated from a function parameter pack will
10208 have the same DECL_PARM_INDEX. */
10210 tree
10212 {
10214 tree patparm;
10217 {
10223 }
10224 else
10225 {
10230 }
10233 }
10235 /* Substitute ARGS into the vector or list of template arguments T. */
10237 static tree
10239 {
10251 {
10253 tree new_arg;
10258 {
10259 /* Substitute into an expansion expression. */
10263 /* Add to the expanded length adjustment the number of
10264 expanded arguments. We subtract one from this
10265 measurement, because the argument pack expression
10266 itself is already counted as 1 in
10267 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10268 the argument pack is empty. */
10270 }
10272 {
10273 /* Substitute into each of the arguments. */
10279 new_arg,
10293 }
10294 }
10295 else
10304 }
10309 /* Make space for the expanded arguments coming from template
10310 argument packs. */
10312 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10313 arguments for a member template.
10314 In that case each TREE_VEC in ORIG_T represents a level of template
10315 arguments, and ORIG_T won't carry any non defaulted argument count.
10316 It will rather be the nested TREE_VECs that will carry one.
10317 In other words, ORIG_T carries a non defaulted argument count only
10318 if it doesn't contain any nested TREE_VEC. */
10320 {
10324 }
10326 {
10330 {
10333 /* Now expand the template argument pack "in place". */
10336 }
10337 else
10338 {
10340 out++;
10341 }
10342 }
10345 }
10347 /* Return the result of substituting ARGS into the template parameters
10348 given by PARMS. If there are m levels of ARGS and m + n levels of
10349 PARMS, then the result will contain n levels of PARMS. For
10350 example, if PARMS is `template <class T> template <class U>
10351 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10352 result will be `template <int*, double, class V>'. */
10354 static tree
10356 {
10360 /* When substituting into a template, we must set
10361 PROCESSING_TEMPLATE_DECL as the template parameters may be
10362 dependent if they are based on one-another, and the dependency
10363 predicates are short-circuit outside of templates. */
10370 {
10371 tree new_vec =
10376 {
10377 tree tuple;
10389 }
10395 }
10400 }
10402 /* Return the result of substituting ARGS into one template parameter
10403 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10404 parameter and which TREE_PURPOSE is the default argument of the
10405 template parameter. */
10407 static tree
10409 {
10430 }
10432 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10433 type T. If T is not an aggregate or enumeration type, it is
10434 handled as if by tsubst. IN_DECL is as for tsubst. If
10435 ENTERING_SCOPE is nonzero, T is the context for a template which
10436 we are presently tsubst'ing. Return the substituted value. */
10438 static tree
10440 tree args,
10441 tsubst_flags_t complain,
10442 tree in_decl,
10444 {
10449 {
10454 /* Else fall through. */
10458 {
10459 tree argvec;
10460 tree context;
10461 tree r;
10465 /* In "sizeof(X<I>)" we need to evaluate "I". */
10471 /* First, determine the context for the type we are looking
10472 up. */
10475 {
10478 /* If context is a nested class inside a class template,
10479 it may still need to be instantiated (c++/33959). */
10481 }
10483 /* Then, figure out what arguments are appropriate for the
10484 type we are trying to find. For example, given:
10486 template <class T> struct S;
10487 template <class T, class U> void f(T, U) { S<U> su; }
10489 and supposing that we are instantiating f<int, double>,
10490 then our ARGS will be {int, double}, but, when looking up
10491 S we only want {double}. */
10496 else
10497 {
10501 }
10507 }
10508 else
10509 /* This is not a template type, so there's nothing to do. */
10514 }
10515 }
10517 /* Substitute into the default argument ARG (a default argument for
10518 FN), which has the indicated TYPE. */
10520 tree
10522 {
10527 /* This can happen in invalid code. */
10531 /* This default argument came from a template. Instantiate the
10532 default argument here, not in tsubst. In the case of
10533 something like:
10535 template <class T>
10536 struct S {
10537 static T t();
10538 void f(T = t());
10539 };
10541 we must be careful to do name lookup in the scope of S<T>,
10542 rather than in the current class. */
10544 /* The "this" pointer is not valid in a default argument. */
10546 {
10551 }
10554 /* The default argument expression may cause implicitly defined
10555 member functions to be synthesized, which will result in garbage
10556 collection. We must treat this situation as if we were within
10557 the body of function so as to avoid collecting live data on the
10558 stack. */
10566 /* Restore the "this" pointer. */
10568 {
10571 }
10578 /* Make sure the default argument is reasonable. */
10584 }
10586 /* Substitute into all the default arguments for FN. */
10588 static void
10590 {
10591 tree arg;
10592 tree tmpl_args;
10596 /* If this function is not yet instantiated, we certainly don't need
10597 its default arguments. */
10600 /* Don't do this again for clones. */
10605 arg;
10611 complain);
10612 }
10614 /* Substitute the ARGS into the T, which is a _DECL. Return the
10615 result of the substitution. Issue error and warning messages under
10616 control of COMPLAIN. */
10618 static tree
10620 {
10621 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10622 location_t saved_loc;
10627 /* Set the filename and linenumber to improve error-reporting. */
10632 {
10634 {
10635 /* We can get here when processing a member function template,
10636 member class template, or template template parameter. */
10639 tree spec;
10640 tree tmpl_args;
10641 tree full_args;
10644 {
10645 /* Template template parameter is treated here. */
10649 /* If we get a real template back, return it. This can happen in
10650 the context of most_specialized_class. */
10662 complain);
10665 }
10667 /* We might already have an instance of this template.
10668 The ARGS are for the surrounding class type, so the
10669 full args contain the tsubst'd args for the context,
10670 plus the innermost args from the template decl. */
10674 /* Because this is a template, the arguments will still be
10675 dependent, even after substitution. If
10676 PROCESSING_TEMPLATE_DECL is not set, the dependency
10677 predicates will short-circuit. */
10685 /* If this is a default template template argument,
10686 tsubst might not have changed anything. */
10693 {
10696 }
10698 /* Make a new template decl. It will be similar to the
10699 original, but will record the current template arguments.
10700 We also create a new function declaration, which is just
10701 like the old one, but points to this new template, rather
10702 than the old one. */
10707 // Build new template info linking to the original template decl.
10712 {
10713 tree new_type;
10721 /* For a partial specialization, we need to keep pointing to
10722 the primary template. */
10728 }
10729 else
10730 {
10731 tree new_decl;
10743 }
10749 /* The template parameters for this new template are all the
10750 template parameters for the old template, except the
10751 outermost level of parameters. */
10754 complain);
10756 // If constrained, also instantiate requirements.
10757 // TODO: Instantiate shorthand constraints on parameters also.
10758 // See tsubst_template_parms for that.
10760 {
10763 }
10769 /* Record this non-type partial instantiation. */
10773 }
10777 {
10778 tree ctx;
10781 tree gen_tmpl;
10782 tree type;
10787 /* Nobody should be tsubst'ing into non-template functions. */
10791 {
10792 tree spec;
10795 /* If T is not dependent, just return it. We have to
10796 increment PROCESSING_TEMPLATE_DECL because
10797 value_dependent_expression_p assumes that nothing is
10798 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10805 /* Calculate the most general template of which R is a
10806 specialization, and the complete set of arguments used to
10807 specialize R. */
10810 (DECL_TEMPLATE_RESULT
10816 /* Check to see if we already have this specialization. */
10821 {
10824 }
10826 /* We can see more levels of arguments than parameters if
10827 there was a specialization of a member template, like
10828 this:
10830 template <class T> struct S { template <class U> void f(); }
10831 template <> template <class U> void S<int>::f(U);
10833 Here, we'll be substituting into the specialization,
10834 because that's where we can find the code we actually
10835 want to generate, but we'll have enough arguments for
10836 the most general template.
10838 We also deal with the peculiar case:
10840 template <class T> struct S {
10841 template <class U> friend void f();
10842 };
10843 template <class U> void f() {}
10844 template S<int>;
10845 template void f<double>();
10847 Here, the ARGS for the instantiation of will be {int,
10848 double}. But, we only need as many ARGS as there are
10849 levels of template parameters in CODE_PATTERN. We are
10850 careful not to get fooled into reducing the ARGS in
10851 situations like:
10853 template <class T> struct S { template <class U> void f(U); }
10854 template <class T> template <> void S<T>::f(int) {}
10856 which we can spot because the pattern will be a
10857 specialization in this case. */
10859 parms_depth =
10864 }
10865 else
10866 {
10867 /* This special case arises when we have something like this:
10869 template <class T> struct S {
10870 friend void f<int>(int, double);
10871 };
10873 Here, the DECL_TI_TEMPLATE for the friend declaration
10874 will be an IDENTIFIER_NODE. We are being called from
10875 tsubst_friend_function, and we want only to create a
10876 new decl (R) with appropriate types so that we can call
10877 determine_specialization. */
10879 }
10882 {
10885 else
10889 }
10890 else
10891 {
10894 }
10899 /* If we hit excessive deduction depth, the type is bogus even if
10900 it isn't error_mark_node, so don't build a decl. */
10904 /* We do NOT check for matching decls pushed separately at this
10905 point, as they may not represent instantiations of this
10906 template, and in any case are considered separate under the
10907 discrete model. */
10911 /* Clear out the mangled name and RTL for the instantiation. */
10914 /* Leave DECL_INITIAL set on deleted instantiations. */
10919 /* OpenMP UDRs have the only argument a reference to the declared
10920 type. We want to diagnose if the declared type is a reference,
10921 which is invalid, but as references to references are usually
10922 quietly merged, diagnose it here. */
10924 {
10925 tree argtype
10930 "reference type %qT in "
10934 argtype);
10935 }
10938 /* Type-conversion operator. Reconstruct the name, in
10939 case it's the name of one of the template's parameters. */
10949 /* If this is an instantiation of a function with internal
10950 linkage, we already know what object file linkage will be
10951 assigned to the instantiation. */
10960 /* We'll re-clone as appropriate in instantiate_template. */
10963 /* If we aren't complaining now, return on error before we register
10964 the specialization so that we'll complain eventually. */
10970 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10971 this in the special friend case mentioned above where
10972 GEN_TMPL is NULL. */
10974 {
10978 tree new_r
10981 /* We instantiated this while substituting into
10982 the type earlier (template/friend54.C). */
10985 /* We're not supposed to instantiate default arguments
10986 until they are called, for a template. But, for a
10987 declaration like:
10989 template <class T> void f ()
10990 { extern void g(int i = T()); }
10992 we should do the substitution when the template is
10993 instantiated. We handle the member function case in
10994 instantiate_class_template since the default arguments
10995 might refer to other members of the class. */
11000 }
11001 else
11004 /* Copy the list of befriending classes. */
11008 {
11012 in_decl);
11013 }
11016 {
11022 /* If this is an instantiation of a member template, clone it.
11023 If it isn't, that'll be handled by
11024 clone_constructors_and_destructors. */
11027 }
11038 /* Possibly limit visibility based on template args. */
11041 {
11045 }
11053 }
11057 {
11065 {
11066 /* If there is a local specialization that isn't a
11067 parameter pack, it means that we're doing a "simple"
11068 substitution from inside tsubst_pack_expansion. Just
11069 return the local specialization (which will be a single
11070 parm). */
11077 /* Expand the TYPE_PACK_EXPANSION that provides the types for
11078 the parameters in this function parameter pack. */
11082 {
11085 /* Zero-length parameter packs are boring. Just substitute
11086 into the chain. */
11090 }
11091 else
11092 {
11093 /* All we did was update the type. Make a note of that. */
11096 }
11097 }
11099 /* Loop through all of the parameters we'll build. When T is
11100 a function parameter pack, LEN is the number of expanded
11101 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11104 {
11111 /* We're on the Ith parameter of the function parameter
11112 pack. */
11113 {
11114 /* Get the Ith type. */
11117 // An argument of a function parameter pack is a function
11118 // parameter pack if its type is also a pack. This can
11119 // happen when instantiating templates with other template
11120 // parameters.
11121 // DECL_PACK_P (r) = PACK_EXPANSION_P (type);
11123 /* Rename the parameter to include the index. */
11126 }
11128 /* We're dealing with a normal parameter. */
11136 {
11139 else
11142 }
11152 /* Keep track of the first new parameter we
11153 generate. That's what will be returned to the
11154 caller. */
11158 /* Build a proper chain of parameters when substituting
11159 into a function parameter pack. */
11162 }
11164 /* If cp_unevaluated_operand is set, we're just looking for a
11165 single dummy parameter, so don't keep going. */
11170 /* FIRST_R contains the start of the chain we've built. */
11172 }
11176 {
11183 {
11184 /* This field is a lambda capture pack. Return a TREE_VEC of
11185 the expanded fields to instantiate_class_template_1 and
11186 store them in the specializations hash table as a
11187 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11191 {
11194 }
11195 else
11196 {
11197 /* All we did was update the type. Make a note of that. */
11200 }
11201 }
11204 {
11207 {
11211 }
11221 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11222 non-bit-fields DECL_INITIAL is a non-static data member
11223 initializer, which gets deferred instantiation. */
11229 {
11230 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11231 NSDMI in perform_member_init. Still set DECL_INITIAL
11232 so that we know there is one. */
11237 }
11238 /* We don't have to set DECL_CONTEXT here; it is set by
11239 finish_member_declaration. */
11247 }
11250 {
11258 }
11259 }
11263 /* We reach here only for member using decls. We also need to check
11264 uses_template_parms because DECL_DEPENDENT_P is not set for a
11265 using-declaration that designates a member of the current
11266 instantiation (c++/53549). */
11269 {
11276 else
11277 {
11280 }
11281 }
11282 else
11283 {
11286 }
11291 {
11294 tree spec;
11296 tree ctx;
11305 {
11306 /* If this is the canonical decl, we don't have to
11307 mess with instantiations, and often we can't (for
11308 typename, template type parms and such). Note that
11309 TYPE_NAME is not correct for the above test if
11310 we've copied the type for a typedef. */
11316 }
11318 /* Check to see if we already have the specialization we
11319 need. */
11322 {
11323 /* T is a static data member or namespace-scope entity.
11324 We have to substitute into namespace-scope variables
11325 (even though such entities are never templates) because
11326 of cases like:
11328 template <class T> void f() { extern T t; }
11330 where the entity referenced is not known until
11331 instantiation time. */
11335 {
11337 complain,
11339 /* If CTX is unchanged, then T is in fact the
11340 specialization we want. That situation occurs when
11341 referencing a static data member within in its own
11342 class. We can use pointer equality, rather than
11343 same_type_p, because DECL_CONTEXT is always
11344 canonical... */
11347 /* ... unless T is a member template; in which
11348 case our caller can be willing to create a
11349 specialization of that template represented
11350 by T. */
11354 }
11357 {
11365 }
11366 }
11367 else
11368 {
11369 /* A local variable. */
11371 /* Subsequent calls to pushdecl will fill this in. */
11374 }
11375 /* If we already have the specialization we need, there is
11376 nothing more to do. */
11378 {
11381 }
11383 /* Create a new node for the specialization we need. */
11386 {
11389 else
11396 }
11398 {
11399 /* Even if the original location is out of scope, the
11400 newly substituted one is not. */
11407 {
11408 /* It may seem that this case cannot occur, since:
11410 typedef void f();
11411 void g() { f x; }
11413 declares a function, not a variable. However:
11415 typedef void f();
11416 template <typename T> void g() { T t; }
11417 template void g<f>();
11419 is an attempt to declare a variable with function
11420 type. */
11422 /* R is not yet sufficiently initialized, so we
11423 just use its name. */
11426 }
11428 /* Wait until cp_finish_decl to set this again, to handle
11429 circular dependency (template/instantiate6.C). */
11434 {
11439 {
11442 }
11444 }
11445 }
11451 /* Clear out the mangled name and RTL for the instantiation. */
11455 /* The initializer must not be expanded until it is required;
11456 see [temp.inst]. */
11462 {
11463 /* Possibly limit visibility based on template args. */
11466 {
11470 }
11472 }
11475 {
11476 /* A static data member declaration is always marked
11477 external when it is declared in-class, even if an
11478 initializer is present. We mimic the non-template
11479 processing here. */
11486 }
11496 /* Preserve a typedef that names a type. */
11498 {
11501 }
11504 }
11509 }
11510 #undef RETURN
11512 out:
11513 /* Restore the file and line information. */
11517 }
11519 /* Substitute into the ARG_TYPES of a function type.
11520 If END is a TREE_CHAIN, leave it and any following types
11521 un-substituted. */
11523 static tree
11525 tree args,
11526 tree end,
11527 tsubst_flags_t complain,
11528 tree in_decl)
11529 {
11530 tree remaining_arg_types;
11534 tree default_arg;
11545 {
11546 /* For a pack expansion, perform substitution on the
11547 entire expression. Later on, we'll handle the arguments
11548 one-by-one. */
11553 /* So that we'll spin through the parameters, one by one. */
11555 else
11556 {
11557 /* We only partially substituted into the parameter
11558 pack. Our type is TYPE_PACK_EXPANSION. */
11561 }
11562 }
11575 {
11577 {
11581 }
11583 }
11584 /* DR 657. */
11588 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11589 top-level qualifiers as required. */
11592 /* We do not substitute into default arguments here. The standard
11593 mandates that they be instantiated only when needed, which is
11594 done in build_over_call. */
11598 {
11599 /* We've instantiated a template before its default arguments
11600 have been parsed. This can happen for a nested template
11601 class, and is not an error unless we require the default
11602 argument in a call of this function. */
11603 remaining_arg_types =
11606 }
11607 else
11608 remaining_arg_types =
11610 }
11613 }
11615 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11616 *not* handle the exception-specification for FNTYPE, because the
11617 initial substitution of explicitly provided template parameters
11618 during argument deduction forbids substitution into the
11619 exception-specification:
11621 [temp.deduct]
11623 All references in the function type of the function template to the
11624 corresponding template parameters are replaced by the specified tem-
11625 plate argument values. If a substitution in a template parameter or
11626 in the function type of the function template results in an invalid
11627 type, type deduction fails. [Note: The equivalent substitution in
11628 exception specifications is done only when the function is instanti-
11629 ated, at which point a program is ill-formed if the substitution
11630 results in an invalid type.] */
11632 static tree
11634 tree args,
11635 tsubst_flags_t complain,
11636 tree in_decl)
11637 {
11638 tree return_type;
11639 tree arg_types;
11640 tree fntype;
11642 /* The TYPE_CONTEXT is not used for function/method types. */
11645 /* Substitute the return type. */
11649 /* DR 486 clarifies that creation of a function type with an
11650 invalid return type is a deduction failure. */
11653 {
11655 {
11658 else
11660 }
11662 }
11663 /* And DR 657. */
11667 /* Substitute the argument types. */
11673 /* Construct a new type node and return it. */
11675 {
11680 }
11681 else
11682 {
11684 /* Don't pick up extra function qualifiers from the basetype. */
11687 {
11688 /* [temp.deduct]
11690 Type deduction may fail for any of the following
11691 reasons:
11693 -- Attempting to create "pointer to member of T" when T
11694 is not a class type. */
11697 r);
11699 }
11704 }
11708 }
11710 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11711 ARGS into that specification, and return the substituted
11712 specification. If there is no specification, return NULL_TREE. */
11714 static tree
11716 tree args,
11717 tsubst_flags_t complain,
11718 tree in_decl,
11720 {
11721 tree specs;
11722 tree new_specs;
11727 {
11728 /* A noexcept-specifier. */
11733 {
11734 /* Defer instantiation of noexcept-specifiers to avoid
11735 excessive instantiations (c++/49107). */
11738 {
11739 /* We already partially instantiated this member template,
11740 so combine the new args with the old. */
11745 }
11746 else
11747 {
11750 }
11751 }
11752 else
11753 new_specs = tsubst_copy_and_build
11757 }
11759 {
11762 else
11764 {
11765 tree spec;
11770 {
11771 /* Expand the pack expansion type. */
11774 in_decl);
11780 else
11781 {
11782 /* We're substituting into a member template, so
11783 we got a TYPE_PACK_EXPANSION back. Add that
11784 expansion and move on. */
11788 expanded_specs,
11789 complain);
11792 }
11793 }
11796 {
11799 else
11804 complain);
11805 }
11808 }
11809 }
11811 }
11813 /* Take the tree structure T and replace template parameters used
11814 therein with the argument vector ARGS. IN_DECL is an associated
11815 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11816 Issue error and warning messages under control of COMPLAIN. Note
11817 that we must be relatively non-tolerant of extensions here, in
11818 order to preserve conformance; if we allow substitutions that
11819 should not be allowed, we may allow argument deductions that should
11820 not succeed, and therefore report ambiguous overload situations
11821 where there are none. In theory, we could allow the substitution,
11822 but indicate that it should have failed, and allow our caller to
11823 make sure that the right thing happens, but we don't try to do this
11824 yet.
11826 This function is used for dealing with types, decls and the like;
11827 for expressions, use tsubst_expr or tsubst_copy. */
11829 tree
11831 {
11854 else
11859 /* Reuse typedefs. We need to do this to handle dependent attributes,
11860 such as attribute aligned. */
11863 {
11867 {
11868 /* DECL represents an alias template and we want to
11869 instantiate it. */
11873 }
11877 {
11881 }
11886 else
11887 /* The typedef is from a non-template context. */
11891 {
11893 r = cp_build_qualified_type_real
11897 }
11898 else
11899 {
11900 /* We don't have an instantiation yet, so drop the typedef. */
11905 }
11906 }
11919 {
11945 {
11951 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11952 needed. */
11958 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11959 with TREE_SIDE_EFFECTS that indicates this is not an integral
11960 constant expression. */
11963 {
11966 }
11969 }
11975 {
11988 {
11992 {
11993 /* See through ARGUMENT_PACK_SELECT arguments. */
11995 /* If the selected argument is an expansion E, that most
11996 likely means we were called from
11997 gen_elem_of_pack_expansion_instantiation during the
11998 substituting of pack an argument pack (which Ith
11999 element is a pack expansion, where I is
12000 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12001 In this case, the Ith element resulting from this
12002 substituting is going to be a pack expansion, which
12003 pattern is the pattern of E. Let's return the
12004 pattern of E, and
12005 gen_elem_of_pack_expansion_instantiation will
12006 build the resulting pack expansion from it. */
12009 }
12010 }
12015 {
12017 /* If ARG is an argument pack, we don't actually want to
12018 perform a substitution here, because substitutions
12019 for argument packs are only done
12020 element-by-element. We can get to this point when
12021 substituting the type of a non-type template
12022 parameter pack, when that type actually contains
12023 template parameter packs from an outer template, e.g.,
12025 template<typename... Types> struct A {
12026 template<Types... Values> struct B { };
12027 }; */
12031 {
12037 return cp_build_qualified_type_real
12039 }
12041 {
12042 /* We are processing a type constructed from a
12043 template template parameter. */
12054 /* Consider this code:
12056 template <template <class> class Template>
12057 struct Internal {
12058 template <class Arg> using Bind = Template<Arg>;
12059 };
12061 template <template <class> class Template, class Arg>
12062 using Instantiate = Template<Arg>; //#0
12064 template <template <class> class Template,
12065 class Argument>
12066 using Bind =
12067 Instantiate<Internal<Template>::template Bind,
12068 Argument>; //#1
12070 When #1 is parsed, the
12071 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12072 parameter `Template' in #0 matches the
12073 UNBOUND_CLASS_TEMPLATE representing the argument
12074 `Internal<Template>::template Bind'; We then want
12075 to assemble the type `Bind<Argument>' that can't
12076 be fully created right now, because
12077 `Internal<Template>' not being complete, the Bind
12078 template cannot be looked up in that context. So
12079 we need to "store" `Bind<Argument>' for later
12080 when the context of Bind becomes complete. Let's
12081 store that in a TYPENAME_TYPE. */
12085 argvec),
12086 typename_type,
12087 complain);
12089 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12090 are resolving nested-types in the signature of a
12091 member function templates. Otherwise ARG is a
12092 TEMPLATE_DECL and is the real template to be
12093 instantiated. */
12101 complain);
12102 return cp_build_qualified_type_real
12104 }
12105 else
12106 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12108 }
12111 /* This can happen during the attempted tsubst'ing in
12112 unify. This means that we don't yet have any information
12113 about the template parameter in question. */
12116 /* Early in template argument deduction substitution, we don't
12117 want to reduce the level of 'auto', or it will be confused
12118 with a normal template parm in subsequent deduction. */
12122 /* If we get here, we must have been looking at a parm for a
12123 more deeply nested template. Make a new version of this
12124 template parameter, but with a lower level. */
12126 {
12131 {
12133 r = cp_build_qualified_type_real
12137 }
12138 else
12139 {
12150 /* We have reduced the level of the template
12151 template parameter, but not the levels of its
12152 template parameters, so canonical_type_parameter
12153 will not be able to find the canonical template
12154 template parameter for this level. Thus, we
12155 require structural equality checking to compare
12156 TEMPLATE_TEMPLATE_PARMs. */
12160 else
12164 {
12172 }
12173 }
12182 }
12185 }
12188 {
12196 {
12200 }
12203 {
12207 }
12210 {
12214 }
12220 }
12223 /* We should never be tsubsting a binfo. */
12227 /* A vector of template arguments. */
12233 {
12237 /* [temp.deduct]
12239 Type deduction may fail for any of the following
12240 reasons:
12242 -- Attempting to create a pointer to reference type.
12243 -- Attempting to create a reference to a reference type or
12244 a reference to void.
12246 Core issue 106 says that creating a reference to a reference
12247 during instantiation is no longer a cause for failure. We
12248 only enforce this check in strict C++98 mode. */
12252 {
12255 /* We keep track of the last time we issued this error
12256 message to avoid spewing a ton of messages during a
12257 single bad template instantiation. */
12260 {
12265 else
12268 }
12271 }
12275 {
12277 {
12280 type);
12281 else
12283 type);
12284 }
12286 }
12288 {
12292 }
12294 /* In C++0x, during template argument substitution, when there is an
12295 attempt to create a reference to a reference type, reference
12296 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12298 "If a template-argument for a template-parameter T names a type
12299 that is a reference to a type A, an attempt to create the type
12300 'lvalue reference to cv T' creates the type 'lvalue reference to
12301 A,' while an attempt to create the type type rvalue reference to
12302 cv T' creates the type T"
12303 */
12304 r = cp_build_reference_type
12307 else
12315 {
12317 pedwarn
12319 code == REFERENCE_TYPE
12322 else
12324 }
12327 /* Will this ever be needed for TYPE_..._TO values? */
12331 }
12333 {
12336 {
12337 /* [temp.deduct]
12339 Type deduction may fail for any of the following
12340 reasons:
12342 -- Attempting to create "pointer to member of T" when T
12343 is not a class type. */
12347 }
12349 {
12353 }
12355 {
12359 }
12362 {
12363 /* The type of the implicit object parameter gets its
12364 cv-qualifiers from the FUNCTION_TYPE. */
12365 tree memptr;
12366 tree method_type
12371 complain);
12372 }
12373 else
12376 complain);
12377 }
12380 {
12381 tree fntype;
12382 tree specs;
12387 /* Substitute the exception specification. */
12395 }
12397 {
12402 /* As an optimization, we avoid regenerating the array type if
12403 it will obviously be the same as T. */
12407 /* These checks should match the ones in grokdeclarator.
12409 [temp.deduct]
12411 The deduction may fail for any of the following reasons:
12413 -- Attempting to create an array with an element type that
12414 is void, a function type, or a reference type, or [DR337]
12415 an abstract class type. */
12419 {
12423 }
12431 {
12434 }
12437 }
12440 {
12450 {
12454 }
12456 {
12457 /* Normally, make_typename_type does not require that the CTX
12458 have complete type in order to allow things like:
12460 template <class T> struct S { typename S<T>::X Y; };
12462 But, such constructs have already been resolved by this
12463 point, so here CTX really should have complete type, unless
12464 it's a partial instantiation. */
12467 {
12471 }
12472 }
12479 {
12482 }
12485 {
12487 {
12491 else
12493 }
12495 {
12499 else
12501 }
12502 }
12504 return cp_build_qualified_type_real
12506 }
12509 {
12521 }
12524 {
12525 tree type;
12541 complain);
12542 }
12545 {
12546 tree type;
12564 else
12565 {
12569 /* In a template ~id could be either a complement expression
12570 or an unqualified-id naming a destructor; if instantiating
12571 it produces an expression, it's not an id-expression or
12572 member access. */
12575 }
12579 complain);
12580 }
12583 {
12587 }
12591 {
12593 tree packed_out =
12595 args,
12596 complain,
12597 in_decl);
12600 /* For template nontype argument packs, also substitute into
12601 the type. */
12606 }
12621 /* We should use one of the expression tsubsts for these codes. */
12627 }
12628 }
12630 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12631 type of the expression on the left-hand side of the "." or "->"
12632 operator. */
12634 static tree
12637 {
12638 tree name;
12639 tree qualifying_scope;
12640 tree fns;
12641 tree optype;
12646 /* A baselink indicates a function from a base class. Both the
12647 BASELINK_ACCESS_BINFO and the base class referenced may
12648 indicate bases of the template class, rather than the
12649 instantiated class. In addition, lookups that were not
12650 ambiguous before may be ambiguous now. Therefore, we perform
12651 the lookup again. */
12658 {
12665 }
12673 /* If lookup found a single function, mark it as used at this
12674 point. (If it lookup found multiple functions the one selected
12675 later by overload resolution will be marked as used at that
12676 point.) */
12682 /* Add back the template arguments, if present. */
12687 template_args);
12688 /* Update the conversion operator type. */
12696 qualifying_scope,
12697 object_type);
12699 }
12701 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12702 true if the qualified-id will be a postfix-expression in-and-of
12703 itself; false if more of the postfix-expression follows the
12704 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12705 of "&". */
12707 static tree
12711 {
12712 tree expr;
12713 tree scope;
12714 tree name;
12716 tree template_args;
12721 /* Figure out what name to look up. */
12724 {
12732 }
12733 else
12734 {
12737 }
12739 /* Substitute into the qualifying scope. When there are no ARGS, we
12740 are just trying to simplify a non-dependent expression. In that
12741 case the qualifying scope may be dependent, and, in any case,
12742 substituting will not help. */
12745 {
12748 }
12749 else
12753 {
12758 }
12761 {
12763 {
12764 /* A BIT_NOT_EXPR is used to represent a destructor. */
12766 {
12770 }
12771 else
12774 }
12775 else
12779 {
12781 {
12785 }
12787 }
12788 }
12791 {
12793 scope);
12794 /* Remember that there was a reference to this entity. */
12796 }
12799 {
12805 }
12814 {
12815 expr = (adjust_result_of_qualified_name_lookup
12817 expr = (finish_qualified_id_expr
12821 }
12823 /* Expressions do not generally have reference type. */
12825 /* However, if we're about to form a pointer-to-member, we just
12826 want the referenced member referenced. */
12831 }
12833 /* Like tsubst, but deals with expressions. This function just replaces
12834 template parms; to finish processing the resultant expression, use
12835 tsubst_copy_and_build or tsubst_expr. */
12837 static tree
12839 {
12841 tree r;
12849 {
12854 {
12855 /* We get here for a use of 'this' in an NSDMI. */
12861 /* This can happen for a parameter name used later in a function
12862 declaration (such as in a late-specified return type). Just
12863 make a dummy decl, since it's only used for its type. */
12866 /* Give it the template pattern as its context; its true context
12867 hasn't been instantiated yet and this is good enough for
12868 mangling. */
12870 }
12878 {
12879 tree enum_type;
12880 tree v;
12884 /* There is no need to substitute into namespace-scope
12885 enumerators. */
12888 /* If ARGS is NULL, then T is known to be non-dependent. */
12892 /* Unfortunately, we cannot just call lookup_name here.
12893 Consider:
12895 template <int I> int f() {
12896 enum E { a = I };
12897 struct S { void g() { E e = a; } };
12898 };
12900 When we instantiate f<7>::S::g(), say, lookup_name is not
12901 clever enough to find f<7>::a. */
12902 enum_type
12912 /* We didn't find the name. That should never happen; if
12913 name-lookup found it during preliminary parsing, we
12914 should find it again here during instantiation. */
12916 }
12921 {
12922 /* Check for a local specialization set up by
12923 tsubst_pack_expansion. */
12925 {
12929 }
12931 /* When retrieving a capture pack from a generic lambda, remove the
12932 lambda call op's own template argument list from ARGS. Only the
12933 template arguments active for the closure type should be used to
12934 retrieve the pack specialization. */
12940 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12941 tsubst_decl put in the hash table. */
12943 }
12946 {
12947 tree ctx;
12952 {
12955 {
12959 }
12961 }
12962 }
12971 {
12974 {
12976 {
12977 /* Just use name lookup to find a member alias for an
12978 anonymous union, but then add it to the hash table. */
12982 }
12983 else
12984 {
12985 /* This can happen for a variable used in a late-specified
12986 return type of a local lambda. Just make a dummy decl
12987 since it's only used for its type. */
12992 }
12993 }
12994 }
12995 else
13004 /* An OVERLOAD will always be a non-dependent overload set; an
13005 overload set from function scope will just be represented with an
13006 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13022 {
13023 /* Template template argument like the following example need
13024 special treatment:
13026 template <template <class> class TT> struct C {};
13027 template <class T> struct D {
13028 template <class U> struct E {};
13029 C<E> c; // #1
13030 };
13031 D<int> d; // #2
13033 We are processing the template argument `E' in #1 for
13034 the template instantiation #2. Originally, `E' is a
13035 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13036 have to substitute this with one having context `D<int>'. */
13040 }
13041 else
13042 /* Ordinary template template argument. */
13053 return build1
13059 {
13069 /* We only want to compute the number of arguments. */
13083 {
13090 else
13093 }
13094 else
13096 }
13098 {
13106 }
13107 /* Fall through */
13123 return build1
13128 {
13129 tree object;
13130 tree name;
13135 {
13139 }
13142 {
13152 }
13157 in_decl);
13158 else
13161 }
13199 return build_nt
13212 return build_nt
13219 {
13227 }
13233 {
13234 r = build_nt
13240 }
13243 {
13244 r = build_nt
13250 }
13253 {
13254 r = build_nt
13260 }
13263 {
13264 /* Substituted template arguments */
13273 }
13276 {
13296 }
13323 /* Fall through. */
13326 {
13329 }
13330 else
13334 /* This is handled by tsubst_copy_and_build. */
13340 in_decl),
13344 /* We shouldn't have built any of these during initial template
13345 generation. Instead, they should be built during instantiation
13346 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13350 r = build2
13359 // Expansions of variadic constraints are viable, expanding
13360 // to a conunction of the expanded terms.
13375 {
13376 /* Instantiate any typedefs in the type. */
13381 }
13384 /* These can sometimes show up in a partial instantiation, but never
13385 involve template parms. */
13390 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13393 }
13394 }
13396 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13398 static tree
13401 {
13405 {
13411 {
13414 {
13420 }
13421 /* FALLTHRU */
13449 {
13452 {
13459 }
13460 else
13462 }
13492 }
13493 }
13499 }
13501 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13503 static tree
13505 tree in_decl)
13506 {
13507 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13527 {
13530 else
13531 {
13535 }
13536 }
13541 #undef RECUR
13542 }
13544 /* Substitute one OMP_FOR iterator. */
13546 static void
13551 {
13552 #define RECUR(NODE) \
13553 tsubst_expr ((NODE), args, complain, in_decl, \
13554 integral_constant_expression_p)
13563 {
13564 /* We need to jump through some hoops to handle declarations in the
13565 for-init-statement, since we might need to handle auto deduction,
13566 but we need to keep control of initialization. */
13570 }
13571 else
13583 {
13585 {
13586 /* Declare the variable, but don't let that initialize it. */
13591 }
13599 complain);
13600 else
13607 }
13610 {
13611 /* Declare and initialize the variable. */
13614 }
13616 {
13617 tree c;
13619 {
13630 }
13632 {
13637 {
13640 }
13641 }
13642 }
13648 else
13652 {
13663 {
13670 }
13671 else
13677 {
13683 }
13687 {
13694 }
13695 else
13701 }
13707 #undef RECUR
13708 }
13710 /* Like tsubst_copy for expressions, etc. but also does semantic
13711 processing. */
13713 tree
13716 {
13717 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13718 #define RECUR(NODE) \
13719 tsubst_expr ((NODE), args, complain, in_decl, \
13720 integral_constant_expression_p)
13723 tree r;
13724 location_t loc;
13736 {
13738 {
13739 tree_stmt_iterator i;
13743 }
13758 else
13767 {
13769 tree init;
13775 {
13778 tree decl;
13786 else
13788 }
13790 {
13791 /* Don't build up decls for a variadic capture proxy, we'll
13792 instantiate the elements directly as needed. */
13794 }
13795 else
13796 {
13800 {
13801 /* By marking the declaration as instantiated, we avoid
13802 trying to instantiate it. Since instantiate_decl can't
13803 handle local variables, and since we've already done
13804 all that needs to be done, that's the right thing to
13805 do. */
13810 /* Anonymous aggregates are a special case. */
13813 {
13816 {
13820 }
13822 }
13828 {
13833 }
13834 else
13835 {
13840 {
13841 /* For __PRETTY_FUNCTION__ we have to adjust the
13842 initializer. */
13846 }
13847 else
13848 {
13852 {
13853 /* If we had an initializer but it
13854 instantiated to nothing,
13855 value-initialize the object. This will
13856 only occur when the initializer was a
13857 pack expansion where the parameter packs
13858 used in that expansion were of length
13859 zero. */
13861 complain);
13864 }
13865 else
13867 }
13870 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13873 }
13874 }
13875 }
13878 }
13893 {
13903 }
13930 {
13934 }
13942 else
13950 else
13977 {
13979 tree label;
13984 }
13990 /* Computed goto's must be tsubst'd into. On the other hand,
13991 non-computed gotos must not be; the identifier in question
13992 will have no binding. */
13994 else
14000 tmp = finish_asm_stmt
14007 {
14012 }
14017 {
14022 }
14023 else
14024 {
14029 else
14036 else
14042 else
14044 }
14048 {
14052 {
14054 /* Prevent instantiate_decl from trying to instantiate
14055 this variable. We've already done all that needs to be
14056 done. */
14059 }
14064 }
14070 {
14071 /* Local classes are not independent templates; they are
14072 instantiated along with their containing function. And this
14073 way we don't have to deal with pushing out of one local class
14074 to instantiate a member of another local class. */
14075 tree fn;
14076 /* Closures are handled by the LAMBDA_EXPR. */
14082 }
14086 {
14087 tree condition;
14090 condition =
14092 args,
14101 }
14125 {
14134 {
14139 }
14151 integral_constant_expression_p);
14160 else
14161 {
14169 }
14172 }
14217 {
14222 {
14225 }
14231 }
14232 else
14233 {
14240 {
14243 }
14246 {
14251 {
14254 }
14260 }
14261 else
14262 {
14266 }
14269 }
14273 {
14279 {
14283 {
14288 }
14292 }
14293 else
14294 {
14299 }
14300 }
14308 // Expansions of variadic constraints are viable, expanding
14309 // to a conunction of the expanded terms.
14330 /* If the first operand was a statement, we're done with it. */
14334 complain));
14346 integral_constant_expression_p));
14347 }
14350 out:
14353 #undef RECUR
14354 #undef RETURN
14355 }
14357 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14358 function. For description of the body see comment above
14359 cp_parser_omp_declare_reduction_exprs. */
14361 static void
14363 {
14369 tree_stmt_iterator tsi;
14380 {
14399 }
14401 {
14421 }
14422 }
14424 /* T is a postfix-expression that is not being used in a function
14425 call. Return the substituted version of T. */
14427 static tree
14429 tsubst_flags_t complain,
14430 tree in_decl)
14431 {
14435 else
14441 }
14443 /* Sentinel to disable certain warnings during template substitution. */
14451 };
14453 /* Like tsubst but deals with expressions and performs semantic
14454 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14456 tree
14458 tree args,
14459 tsubst_flags_t complain,
14460 tree in_decl,
14463 {
14464 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14465 #define RECUR(NODE) \
14466 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14468 integral_constant_expression_p)
14471 location_t loc;
14480 /* N3276 decltype magic only applies to calls at the top level or on the
14481 right side of a comma. */
14486 {
14489 /* Fall through. */
14491 {
14492 tree decl;
14493 cp_id_kind idk;
14498 {
14501 }
14503 /* Look up the name. */
14506 /* By convention, expressions use ERROR_MARK_NODE to indicate
14507 failure, not NULL_TREE. */
14513 integral_constant_expression_p,
14521 input_location);
14525 {
14529 }
14531 }
14534 {
14535 tree object;
14543 {
14546 }
14547 else
14554 else
14556 }
14559 {
14563 {
14564 /* A type conversion to reference type will be enclosed in
14565 such an indirect ref, but the substitution of the cast
14566 will have also added such an indirect ref. */
14569 }
14570 else
14574 }
14582 {
14589 flags));
14590 }
14603 {
14604 tree type;
14610 {
14615 }
14621 {
14639 }
14642 }
14676 else
14678 in_decl);
14713 {
14716 tree r = build_x_binary_op
14720 ? ERROR_MARK
14724 ? ERROR_MARK
14732 }
14749 {
14758 }
14762 /* Fall through */
14765 {
14766 tree r;
14772 {
14773 /* When there are no ARGS, we are trying to evaluate a
14774 non-dependent expression from the parser. Trying to do
14775 the substitutions may not work. */
14778 }
14779 else
14780 {
14785 else
14788 /*integral_constant_expression_p=*/
14792 }
14796 else
14800 {
14802 {
14804 {
14808 }
14809 else
14813 }
14815 }
14817 }
14820 {
14830 }
14844 {
14846 tree r = build_x_modify_expr
14852 /* TREE_NO_WARNING must be set if either the expression was
14853 parenthesized or it uses an operator such as >>= rather
14854 than plain assignment. In the former case, it was already
14855 set and must be copied. In the latter case,
14856 build_x_modify_expr sets it and it must not be reset
14857 here. */
14862 }
14867 /* Remember that there was a reference to this entity. */
14873 {
14878 tree ret;
14882 else
14883 {
14887 }
14889 /* If there was an initializer in the original tree, but it
14890 instantiated to an empty list, then we should pass a
14891 non-NULL empty vector to tell build_new that it was an
14892 empty initializer() rather than no initializer. This can
14893 only happen when the initializer is a pack expansion whose
14894 parameter packs are of length zero. */
14897 else
14898 {
14902 else
14903 {
14906 }
14907 }
14914 complain);
14922 }
14930 complain));
14933 {
14937 integral_constant_expression_p);
14939 op0,
14942 }
14945 {
14946 tree function;
14951 tree ret;
14954 /* When we parsed the expression, we determined whether or
14955 not Koenig lookup should be performed. */
14958 {
14963 }
14965 {
14966 /* Do nothing; calling tsubst_copy_and_build on an identifier
14967 would incorrectly perform unqualified lookup again.
14969 Note that we can also have an IDENTIFIER_NODE if the earlier
14970 unqualified lookup found a member function; in that case
14971 koenig_p will be false and we do want to do the lookup
14972 again to find the instantiated member function.
14974 FIXME but doing that causes c++/15272, so we need to stop
14975 using IDENTIFIER_NODE in that situation. */
14977 }
14978 else
14979 {
14981 {
14987 }
14988 else
14993 /* Avoid error about taking the address of a constructor. */
14997 in_decl,
14999 integral_constant_expression_p);
15003 }
15008 {
15013 else
15014 {
15015 /* Expand the pack expansion and push each entry onto
15016 CALL_ARGS. */
15019 {
15024 {
15029 }
15030 }
15031 else
15032 {
15033 /* A partial substitution. Add one entry. */
15035 }
15036 }
15037 }
15039 /* We do not perform argument-dependent lookup if normal
15040 lookup finds a non-function, in accordance with the
15041 expected resolution of DR 218. */
15044 /* If lookup found a member function, the Koenig lookup is
15045 not appropriate, even if an unqualified-name was used
15046 to denote the function. */
15049 /* Only do this when substitution turns a dependent call
15050 into a non-dependent call. */
15057 {
15059 {
15060 /* For backwards compatibility and good diagnostics, try
15061 the unqualified lookup again if we aren't in SFINAE
15062 context. */
15063 tree unq = (tsubst_copy_and_build
15065 integral_constant_expression_p));
15070 {
15079 "%qD was not declared in this scope, "
15080 "and no declarations were found by "
15081 "argument-dependent lookup at the point "
15083 {
15087 {
15089 input_location);
15091 "declarations in dependent base %qT are "
15097 else
15101 }
15102 else
15105 }
15107 }
15108 }
15110 {
15115 }
15116 }
15118 /* Remember that there was a reference to this entity. */
15122 /* Put back tf_decltype for the actual call. */
15127 complain);
15129 {
15144 complain);
15145 else
15146 ret = (build_new_method_call
15151 complain));
15152 }
15153 else
15156 koenig_p,
15157 complain);
15162 }
15165 {
15170 {
15172 {
15177 }
15178 else
15179 {
15184 }
15185 }
15186 else
15187 {
15190 }
15194 }
15201 input_location));
15204 {
15212 {
15213 /* We have pack expansions, so expand those and
15214 create a new list out of it. */
15217 tree chain;
15220 /* Expand the argument expressions. */
15228 /* Build the rest of the list. */
15233 /* Determine the number of arguments. */
15235 {
15238 }
15241 else
15242 {
15243 /* Since we only performed a partial substitution into
15244 the argument pack, we only RETURN (a single list
15245 node. */
15252 }
15254 /* Convert the argument vectors into a TREE_LIST */
15257 {
15258 /* Grab the Ith values. */
15259 i--;
15262 value
15266 /* Build the list (backwards). */
15268 }
15271 }
15287 }
15290 {
15291 tree object;
15292 tree object_type;
15293 tree member;
15294 tree r;
15298 /* Remember that there was a reference to this entity. */
15308 else
15316 {
15318 {
15323 {
15326 }
15328 {
15333 }
15334 }
15335 }
15338 {
15339 /* Lookup the template functions now that we know what the
15340 scope is. */
15348 {
15351 args);
15352 member = (adjust_result_of_qualified_name_lookup
15354 object_type));
15355 }
15356 else
15357 {
15359 input_location);
15361 }
15362 }
15366 {
15368 {
15372 else
15375 }
15377 }
15379 {
15384 }
15388 complain);
15392 }
15399 {
15407 tree r;
15412 /* digest_init will do the wrong thing if we let it. */
15416 /* We do not want to process the index of aggregate
15417 initializers as they are identifier nodes which will be
15418 looked up by digest_init. */
15424 {
15426 /* An identifier index is looked up in the type
15427 being initialized, not the current scope. */
15432 {
15433 /* Substitute into the pack expansion. */
15435 in_decl);
15439 ;
15441 /* Just move the argument into place. */
15443 else
15444 {
15445 /* Update the length of the final CONSTRUCTOR
15446 arguments vector, and note that we will need to
15447 copy.*/
15450 }
15451 }
15452 else
15454 }
15457 {
15462 {
15464 {
15469 }
15470 else
15472 }
15473 }
15483 }
15486 {
15489 {
15492 }
15493 else
15494 {
15497 }
15498 }
15504 {
15505 /* We don't build decls for an instantiation of a
15506 variadic capture proxy, we instantiate the elements
15507 when needed. */
15510 }
15511 /* Fall through */
15514 {
15518 /* If the original type was a reference, we'll be wrapped in
15519 the appropriate INDIRECT_REF. */
15522 // If the type of the argument is a pack expansion, then
15523 // the parameter must also be expanded.
15528 }
15539 {
15548 }
15551 {
15557 integral_constant_expression_p);
15561 /* If the resulting list of expression statement is empty,
15562 fold it further into void_zero_node. */
15567 }
15570 {
15584 /* For a function scope, we want to use tsubst so that we don't
15585 complain about referring to an auto function before its return
15586 type has been deduced. Otherwise, we want to use tsubst_copy so
15587 that we look up the existing field/parameter/variable rather
15588 than build a new one. */
15593 {
15594 /* Look up the parameter we want directly, as tsubst_copy
15595 doesn't do what we need. */
15601 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15604 }
15605 else
15614 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15616 /* Now that we know visibility, instantiate the type so we have a
15617 declaration of the op() for later calls to lambda_function. */
15623 }
15626 /* We can get here for a constant initializer of non-dependent type.
15627 FIXME stop folding in cp_parser_initializer_clause. */
15628 {
15630 complain);
15632 }
15636 integral_constant_expression_p));
15646 complain));
15660 // Normally, *_REQ are reduced out of requiremetns when used
15661 // as constraints. If a concept is checked directly via e.g.,
15662 // a static_assert, however, these appear in the input tree.
15674 /* Handle Objective-C++ constructs, if appropriate. */
15675 {
15676 tree subst
15681 }
15683 }
15685 #undef RECUR
15686 #undef RETURN
15687 out:
15690 }
15692 /* Verify that the instantiated ARGS are valid. For type arguments,
15693 make sure that the type's linkage is ok. For non-type arguments,
15694 make sure they are constants if they are integral or enumerations.
15695 Emit an error under control of COMPLAIN, and return TRUE on error. */
15697 static bool
15699 {
15703 {
15713 }
15715 {
15716 /* [basic.link]: A name with no linkage (notably, the name
15717 of a class or enumeration declared in a local scope)
15718 shall not be used to declare an entity with linkage.
15719 This implies that names with no linkage cannot be used as
15720 template arguments
15722 DR 757 relaxes this restriction for C++0x. */
15727 {
15728 /* DR 488 makes use of a type with no linkage cause
15729 type deduction to fail. */
15731 {
15734 else
15737 }
15739 }
15740 /* In order to avoid all sorts of complications, we do not
15741 allow variably-modified types as template arguments. */
15743 {
15747 }
15748 }
15749 /* Class template and alias template arguments should be OK. */
15751 ;
15752 /* A non-type argument of integral or enumerated type must be a
15753 constant. */
15757 {
15761 }
15763 }
15765 static bool
15767 {
15772 {
15775 }
15779 }
15781 /* We're out of SFINAE context now, so generate diagnostics for the access
15782 errors we saw earlier when instantiating D from TMPL and ARGS. */
15784 static void
15786 {
15798 }
15800 /* Instantiate the indicated variable, function, or alias template TMPL with
15801 the template arguments in TARG_PTR. */
15803 static tree
15805 {
15807 tree fndecl;
15808 tree gen_tmpl;
15809 tree spec;
15817 /* If this function is a clone, handle it specially. */
15819 {
15820 tree spec;
15821 tree clone;
15823 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15824 DECL_CLONED_FUNCTION. */
15830 /* Look for the clone. */
15834 /* We should always have found the clone by now. */
15837 }
15842 /* Check to see if we already have this specialization. */
15845 /* The TMPL is a partial instantiation. To get a full set of
15846 arguments we must add the arguments used to perform the
15847 partial instantiation. */
15849 targ_ptr);
15851 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15852 but it doesn't seem to be on the hot path. */
15861 {
15863 {
15867 }
15869 }
15872 complain))
15875 /* We are building a FUNCTION_DECL, during which the access of its
15876 parameters and return types have to be checked. However this
15877 FUNCTION_DECL which is the desired context for access checking
15878 is not built yet. We solve this chicken-and-egg problem by
15879 deferring all checks until we have the FUNCTION_DECL. */
15882 /* Instantiation of the function happens in the context of the function
15883 template, not the context of the overload resolution we're doing. */
15885 /* If there are dependent arguments, e.g. because we're doing partial
15886 ordering, make sure processing_template_decl stays set. */
15890 {
15894 }
15895 /* Substitute template parameters to obtain the specialization. */
15903 {
15906 }
15908 /* The DECL_TI_TEMPLATE should always be the immediate parent
15909 template, not the most general template. */
15912 /* Now we know the specialization, compute access previously
15913 deferred. */
15920 /* If we've just instantiated the main entry point for a function,
15921 instantiate all the alternate entry points as well. We do this
15922 by cloning the instantiation of the main entry point, not by
15923 instantiating the template clones. */
15928 {
15930 {
15931 /* Remember to reinstantiate when we're out of SFINAE so the user
15932 can see the errors. */
15934 }
15936 }
15938 }
15940 /* Wrapper for instantiate_template_1. */
15942 tree
15944 {
15945 tree ret;
15950 }
15952 /* Instantiate the alias template TMPL with ARGS. Also push a template
15953 instantiation level, which instantiate_template doesn't do because
15954 functions and variables have sufficient context established by the
15955 callers. */
15957 static tree
15959 {
15966 {
15969 }
15971 args =
15979 /* We can't free this if a pending_template entry or last_error_tinst_level
15980 is pointing at it. */
15986 }
15988 /* PARM is a template parameter pack for FN. Returns true iff
15989 PARM is used in a deducible way in the argument list of FN. */
15991 static bool
15993 {
15996 {
15998 tree packs;
16004 {
16005 /* The template parameter pack is used in a function parameter
16006 pack. If this is the end of the parameter list, the
16007 template parameter pack is deducible. */
16010 else
16011 /* Otherwise, not. Well, it could be deduced from
16012 a non-pack parameter, but doing so would end up with
16013 a deduction mismatch, so don't bother. */
16015 }
16016 }
16017 /* The template parameter pack isn't used in any function parameter
16018 packs, but it might be used deeper, e.g. tuple<Args...>. */
16020 }
16022 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16023 NARGS elements of the arguments that are being used when calling
16024 it. TARGS is a vector into which the deduced template arguments
16025 are placed.
16027 Returns either a FUNCTION_DECL for the matching specialization of FN or
16028 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16029 true, diagnostics will be printed to explain why it failed.
16031 If FN is a conversion operator, or we are trying to produce a specific
16032 specialization, RETURN_TYPE is the return type desired.
16034 The EXPLICIT_TARGS are explicit template arguments provided via a
16035 template-id.
16037 The parameter STRICT is one of:
16039 DEDUCE_CALL:
16040 We are deducing arguments for a function call, as in
16041 [temp.deduct.call].
16043 DEDUCE_CONV:
16044 We are deducing arguments for a conversion function, as in
16045 [temp.deduct.conv].
16047 DEDUCE_EXACT:
16048 We are deducing arguments when doing an explicit instantiation
16049 as in [temp.explicit], when determining an explicit specialization
16050 as in [temp.expl.spec], or when taking the address of a function
16051 template, as in [temp.deduct.funcaddr]. */
16053 tree
16055 tree explicit_targs,
16056 tree targs,
16059 tree return_type,
16060 unification_kind_t strict,
16064 {
16065 tree parms;
16066 tree fntype;
16074 tree tinst;
16080 /* In C++0x, it's possible to have a function template whose type depends
16081 on itself recursively. This is most obvious with decltype, but can also
16082 occur with enumeration scope (c++/48969). So we need to catch infinite
16083 recursion and reject the substitution at deduction time; this function
16084 will return error_mark_node for any repeated substitution.
16086 This also catches excessive recursion such as when f<N> depends on
16087 f<N-1> across all integers, and returns error_mark_node for all the
16088 substitutions back up to the initial one.
16090 This is, of course, not reentrant. */
16100 {
16101 /* [temp.deduct]
16103 The specified template arguments must match the template
16104 parameters in kind (i.e., type, nontype, template), and there
16105 must not be more arguments than there are parameters;
16106 otherwise type deduction fails.
16108 Nontype arguments must match the types of the corresponding
16109 nontype template parameters, or must be convertible to the
16110 types of the corresponding nontype parameters as specified in
16111 _temp.arg.nontype_, otherwise type deduction fails.
16113 All references in the function type of the function template
16114 to the corresponding template parameters are replaced by the
16115 specified template argument values. If a substitution in a
16116 template parameter or in the function type of the function
16117 template results in an invalid type, type deduction fails. */
16122 /* Adjust any explicit template arguments before entering the
16123 substitution context. */
16124 explicit_targs
16126 complain,
16132 /* Substitute the explicit args into the function type. This is
16133 necessary so that, for instance, explicitly declared function
16134 arguments can match null pointed constants. If we were given
16135 an incomplete set of explicit args, we must not do semantic
16136 processing during substitution as we could create partial
16137 instantiations. */
16139 {
16144 /* Dig out the actual parm. */
16147 {
16150 }
16152 {
16155 }
16158 /* No explicit argument for this template parameter. */
16162 {
16163 /* Mark the argument pack as "incomplete". We could
16164 still deduce more arguments during unification.
16165 We remove this mark in type_unification_real. */
16167 {
16171 }
16173 /* We have some incomplete argument packs. */
16175 }
16176 }
16180 {
16183 }
16186 /* Ignore any access checks; we'll see them again in
16187 instantiate_template and they might have the wrong
16188 access path at this point. */
16200 /* Place the explicitly specified arguments in TARGS. */
16203 }
16205 /* Never do unification on the 'this' parameter. */
16209 {
16218 }
16220 /* We allow incomplete unification without an error message here
16221 because the standard doesn't seem to explicitly prohibit it. Our
16222 callers must be ready to deal with unification failures in any
16223 event. */
16226 /* If we aren't explaining yet, push tinst context so we can see where
16227 any errors (e.g. from class instantiations triggered by instantiation
16228 of default template arguments) come from. If we are explaining, this
16229 context is redundant. */
16231 {
16234 }
16236 /* type_unification_real will pass back any access checks from default
16237 template argument substitution. */
16249 /* Now that we have bindings for all of the template arguments,
16250 ensure that the arguments deduced for the template template
16251 parameters have compatible template parameter lists. We cannot
16252 check this property before we have deduced all template
16253 arguments, because the template parameter types of a template
16254 template parameter might depend on prior template parameters
16255 deduced after the template template parameter. The following
16256 ill-formed example illustrates this issue:
16258 template<typename T, template<T> class C> void f(C<5>, T);
16260 template<int N> struct X {};
16262 void g() {
16263 f(X<5>(), 5l); // error: template argument deduction fails
16264 }
16266 The template parameter list of 'C' depends on the template type
16267 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16268 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16269 time that we deduce 'C'. */
16272 {
16275 }
16277 // All is well so far. Now, check that the template constraints
16278 // are satisfied.
16280 {
16284 }
16286 /* All is well so far. Now, check:
16288 [temp.deduct]
16290 When all template arguments have been deduced, all uses of
16291 template parameters in nondeduced contexts are replaced with
16292 the corresponding deduced argument values. If the
16293 substitution results in an invalid type, as described above,
16294 type deduction fails. */
16297 {
16300 }
16302 /* Also collect access checks from the instantiation. */
16315 /* Now perform any access checks encountered during substitution. */
16322 /* If we're looking for an exact match, check that what we got
16323 is indeed an exact match. It might not be if some template
16324 parameters are used in non-deduced contexts. But don't check
16325 for an exact match if we have dependent template arguments;
16326 in that case we're doing partial ordering, and we already know
16327 that we have two candidates that will provide the actual type. */
16329 {
16333 tree sarg
16339 {
16343 }
16344 }
16348 fail:
16351 {
16353 /* Reset once we're all the way out. */
16355 }
16357 /* We can't free this if a pending_template entry or last_error_tinst_level
16358 is pointing at it. */
16364 }
16366 /* Adjust types before performing type deduction, as described in
16367 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16368 sections are symmetric. PARM is the type of a function parameter
16369 or the return type of the conversion function. ARG is the type of
16370 the argument passed to the call, or the type of the value
16371 initialized with the result of the conversion function.
16372 ARG_EXPR is the original argument expression, which may be null. */
16374 static int
16378 tree arg_expr)
16379 {
16383 {
16388 {
16389 /* Swap PARM and ARG throughout the remainder of this
16390 function; the handling is precisely symmetric since PARM
16391 will initialize ARG rather than vice versa. */
16396 }
16399 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16400 too, but here handle it by stripping the reference from PARM
16401 rather than by adding it to ARG. */
16409 /* Nothing else to do in this case. */
16414 }
16417 {
16418 /* [temp.deduct.call]
16420 If P is not a reference type:
16422 --If A is an array type, the pointer type produced by the
16423 array-to-pointer standard conversion (_conv.array_) is
16424 used in place of A for type deduction; otherwise,
16426 --If A is a function type, the pointer type produced by
16427 the function-to-pointer standard conversion
16428 (_conv.func_) is used in place of A for type deduction;
16429 otherwise,
16431 --If A is a cv-qualified type, the top level
16432 cv-qualifiers of A's type are ignored for type
16433 deduction. */
16438 else
16440 }
16442 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16443 of the form T&&, where T is a template parameter, and the argument
16444 is an lvalue, T is deduced as A& */
16450 /* try_one_overload doesn't provide an arg_expr, but
16451 functions are always lvalues. */
16455 /* [temp.deduct.call]
16457 If P is a cv-qualified type, the top level cv-qualifiers
16458 of P's type are ignored for type deduction. If P is a
16459 reference type, the type referred to by P is used for
16460 type deduction. */
16463 {
16466 }
16468 /* DR 322. For conversion deduction, remove a reference type on parm
16469 too (which has been swapped into ARG). */
16474 }
16476 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16477 template which does contain any deducible template parameters; check if
16478 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16479 unify_one_argument. */
16481 static int
16484 {
16485 tree type;
16489 else
16496 {
16500 }
16502 {
16507 }
16511 else
16513 }
16517 /* Returns true iff the expression EXPR is one from which a template
16518 argument can be deduced. In other words, if it's an undecorated
16519 use of a template non-type parameter. */
16521 static bool
16523 {
16525 }
16527 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16528 deducible way; that is, if it has a max value of <PARM> - 1. */
16530 static bool
16532 {
16541 }
16543 /* Returns true iff the template arguments ARGS use a template parameter
16544 in a deducible way. */
16546 static bool
16548 {
16550 {
16555 else
16556 {
16563 else
16565 }
16568 }
16570 }
16572 /* Returns true iff TYPE contains any deducible references to template
16573 parameters, as per 14.8.2.5. */
16575 static bool
16577 {
16581 /* T
16582 cv-list T
16583 TT<T>
16584 TT<i>
16585 TT<> */
16590 /* T*
16591 T&
16592 T&& */
16596 /* T[integer-constant ]
16597 type [i] */
16602 /* T type ::*
16603 type T::*
16604 T T::*
16605 T (type ::*)()
16606 type (T::*)()
16607 type (type ::*)(T)
16608 type (T::*)(T)
16609 T (type ::*)(T)
16610 T (T::*)()
16611 T (T::*)(T) */
16614 || (uses_deducible_template_parms
16617 /* template-name <T> (where template-name refers to a class template)
16618 template-name <i> (where template-name refers to a class template) */
16625 /* type (T)
16626 T()
16627 T(T) */
16630 {
16639 }
16642 }
16644 /* Subroutine of type_unification_real and unify_pack_expansion to
16645 handle unification of a single P/A pair. Parameters are as
16646 for those functions. */
16648 static int
16652 {
16659 /* We can't deduce anything from this, but we might get all the
16660 template args from other function args. */
16663 /* Implicit conversions (Clause 4) will be performed on a function
16664 argument to convert it to the type of the corresponding function
16665 parameter if the parameter type contains no template-parameters that
16666 participate in template argument deduction. */
16668 /* For function parameters that contain no template-parameters at all,
16669 we have historically checked for convertibility in order to shortcut
16670 consideration of this candidate. */
16672 explain_p);
16675 /* For function parameters with only non-deducible template parameters,
16676 just return. */
16680 {
16682 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
16683 | UNIFY_ALLOW_MORE_CV_QUAL
16697 }
16699 /* We only do these transformations if this is the top-level
16700 parameter_type_list in a call or declaration matching; in other
16701 situations (nested function declarators, template argument lists) we
16702 won't be comparing a type to an expression, and we don't do any type
16703 adjustments. */
16705 {
16707 {
16710 {
16711 /* [temp.deduct.type] A template-argument can be
16712 deduced from a pointer to function or pointer
16713 to member function argument if the set of
16714 overloaded functions does not contain function
16715 templates and at most one of a set of
16716 overloaded functions provides a unique
16717 match. */
16724 }
16730 }
16732 arg_strict |=
16734 }
16735 else
16739 /* For deduction from an init-list we need the actual list. */
16743 }
16745 /* Most parms like fn_type_unification.
16747 If SUBR is 1, we're being called recursively (to unify the
16748 arguments of a function or method parameter of a function
16749 template).
16751 CHECKS is a pointer to a vector of access checks encountered while
16752 substituting default template arguments. */
16754 static int
16756 tree targs,
16757 tree xparms,
16761 unification_kind_t strict,
16765 {
16770 tree parms;
16779 /* Reset the number of non-defaulted template arguments contained
16780 in TARGS. */
16783 again:
16791 {
16796 /* For a function parameter pack that occurs at the end of the
16797 parameter-declaration-list, the type A of each remaining
16798 argument of the call is compared with the type P of the
16799 declarator-id of the function parameter pack. */
16805 /* For a function parameter pack that does not occur at the
16806 end of the parameter-declaration-list, the type of the
16807 parameter pack is a non-deduced context. */
16816 }
16821 {
16822 /* Unify the remaining arguments with the pack expansion type. */
16823 tree argvec;
16826 /* Allocate a TREE_VEC and copy in all of the arguments */
16831 /* Copy the parameter into parmvec. */
16837 /* Advance to the end of the list of parameters. */
16839 }
16841 /* Fail if we've reached the end of the parm list, and more args
16842 are present, and the parm list isn't variadic. */
16845 /* Fail if parms are left and they don't have default values. */
16848 {
16852 {
16853 count++;
16855 }
16857 }
16860 {
16861 tsubst_flags_t complain = (explain_p
16862 ? tf_warning_or_error
16866 {
16870 /* Clear the "incomplete" flags on all argument packs now so that
16871 substituting them into later default arguments works. */
16873 {
16876 }
16882 /* If this is an undeduced nontype parameter that depends on
16883 a type parameter, try another pass; its type may have been
16884 deduced from a later argument than the one from which
16885 this parameter can be deduced. */
16891 /* Core issue #226 (C++0x) [temp.deduct]:
16893 If a template argument has not been deduced, its
16894 default template argument, if any, is used.
16896 When we are in C++98 mode, TREE_PURPOSE will either
16897 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16898 to explicitly check cxx_dialect here. */
16900 {
16915 else
16916 {
16918 /* The position of the first default template argument,
16919 is also the number of non-defaulted arguments in TARGS.
16920 Record that. */
16924 }
16925 }
16927 /* If the type parameter is a parameter pack, then it will
16928 be deduced to an empty parameter pack. */
16930 {
16931 tree arg;
16934 {
16938 }
16939 else
16946 }
16949 }
16950 }
16951 #ifdef ENABLE_CHECKING
16954 #endif
16957 }
16959 /* Subroutine of type_unification_real. Args are like the variables
16960 at the call site. ARG is an overloaded function (or template-id);
16961 we try deducing template args from each of the overloads, and if
16962 only one succeeds, we go with that. Modifies TARGS and returns
16963 true on success. */
16965 static bool
16967 tree targs,
16968 tree parm,
16969 tree arg,
16970 unification_kind_t strict,
16973 {
16980 {
16983 }
16984 else
16988 /* Handle `&x' where `x' is some static or non-static member
16989 function name. */
16995 /* Strip baselink information. */
17000 {
17001 /* If we got some explicit template args, we need to plug them into
17002 the affected templates before we try to unify, in case the
17003 explicit args will completely resolve the templates in question. */
17010 {
17023 {
17028 {
17031 }
17032 }
17035 }
17036 /* If no templates (or more than one) are fully resolved by the
17037 explicit arguments, this template-id is a non-deduced context; it
17038 could still be OK if we deduce all template arguments for the
17039 enclosing call through other arguments. */
17042 }
17045 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17046 -- but the deduction does not succeed because the expression is
17047 not just the function on its own. */
17049 else
17055 {
17058 }
17060 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17061 to function or pointer to member function argument if the set of
17062 overloaded functions does not contain function templates and at most
17063 one of a set of overloaded functions provides a unique match.
17065 So if we found multiple possibilities, we return success but don't
17066 deduce anything. */
17069 {
17074 }
17079 }
17081 /* Core DR 115: In contexts where deduction is done and fails, or in
17082 contexts where deduction is not done, if a template argument list is
17083 specified and it, along with any default template arguments, identifies
17084 a single function template specialization, then the template-id is an
17085 lvalue for the function template specialization. */
17087 tree
17089 {
17102 {
17105 }
17107 {
17110 }
17112 {
17115 }
17118 {
17122 /* If we got some explicit template args, we need to plug them into
17123 the affected templates before we try to unify, in case the
17124 explicit args will completely resolve the templates in question. */
17132 {
17145 {
17148 {
17151 }
17153 {
17156 }
17157 }
17158 }
17160 {
17168 {
17169 tree base
17172 }
17176 }
17178 /* There were no good options and at least one bad one, so let the
17179 user know what the problem is. */
17181 }
17183 }
17185 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17186 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17187 different overloads deduce different arguments for a given parm.
17188 ADDR_P is true if the expression for which deduction is being
17189 performed was of the form "& fn" rather than simply "fn".
17191 Returns 1 on success. */
17193 static int
17195 tree orig_targs,
17196 tree targs,
17197 tree parm,
17198 tree arg,
17199 unification_kind_t strict,
17203 {
17205 tree tempargs;
17211 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17212 to function or pointer to member function argument if the set of
17213 overloaded functions does not contain function templates and at most
17214 one of a set of overloaded functions provides a unique match.
17216 So if this is a template, just return success. */
17228 /* We don't copy orig_targs for this because if we have already deduced
17229 some template args from previous args, unify would complain when we
17230 try to deduce a template parameter for the same argument, even though
17231 there isn't really a conflict. */
17238 /* First make sure we didn't deduce anything that conflicts with
17239 explicitly specified args. */
17241 {
17248 /* Since we're unifying against ourselves, we will fill in
17249 template args used in the function parm list with our own
17250 template parms. Discard them. */
17254 }
17257 {
17262 }
17265 }
17267 /* PARM is a template class (perhaps with unbound template
17268 parameters). ARG is a fully instantiated type. If ARG can be
17269 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17270 TARGS are as for unify. */
17272 static tree
17275 {
17276 tree copy_of_targs;
17283 /* We need to make a new template argument vector for the call to
17284 unify. If we used TARGS, we'd clutter it up with the result of
17285 the attempted unification, even if this class didn't work out.
17286 We also don't want to commit ourselves to all the unifications
17287 we've already done, since unification is supposed to be done on
17288 an argument-by-argument basis. In other words, consider the
17289 following pathological case:
17291 template <int I, int J, int K>
17292 struct S {};
17294 template <int I, int J>
17295 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17297 template <int I, int J, int K>
17298 void f(S<I, J, K>, S<I, I, I>);
17300 void g() {
17301 S<0, 0, 0> s0;
17302 S<0, 1, 2> s2;
17304 f(s0, s2);
17305 }
17307 Now, by the time we consider the unification involving `s2', we
17308 already know that we must have `f<0, 0, 0>'. But, even though
17309 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17310 because there are two ways to unify base classes of S<0, 1, 2>
17311 with S<I, I, I>. If we kept the already deduced knowledge, we
17312 would reject the possibility I=1. */
17315 /* If unification failed, we're done. */
17321 }
17323 /* Given a template type PARM and a class type ARG, find the unique
17324 base type in ARG that is an instance of PARM. We do not examine
17325 ARG itself; only its base-classes. If there is not exactly one
17326 appropriate base class, return NULL_TREE. PARM may be the type of
17327 a partial specialization, as well as a plain template type. Used
17328 by unify. */
17330 static enum template_base_result
17333 {
17335 tree binfo;
17341 {
17342 /* The type could not be completed. */
17345 }
17347 /* Walk in inheritance graph order. The search order is not
17348 important, and this avoids multiple walks of virtual bases. */
17350 {
17355 {
17356 /* If there is more than one satisfactory baseclass, then:
17358 [temp.deduct.call]
17360 If they yield more than one possible deduced A, the type
17361 deduction fails.
17363 applies. */
17365 {
17368 }
17371 }
17372 }
17376 }
17378 /* Returns the level of DECL, which declares a template parameter. */
17380 static int
17382 {
17384 {
17394 }
17396 }
17398 /* Decide whether ARG can be unified with PARM, considering only the
17399 cv-qualifiers of each type, given STRICT as documented for unify.
17400 Returns nonzero iff the unification is OK on that basis. */
17402 static int
17404 {
17410 {
17411 /* Although a CVR qualifier is ignored when being applied to a
17412 substituted template parameter ([8.3.2]/1 for example), that
17413 does not allow us to unify "const T" with "int&" because both
17414 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17415 It is ok when we're allowing additional CV qualifiers
17416 at the outer level [14.8.2.1]/3,1st bullet. */
17426 }
17437 }
17439 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17440 void
17442 {
17446 {
17449 }
17450 else
17451 {
17454 }
17455 }
17457 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17458 do { \
17459 if (unify (TP, TA, P, A, S, EP)) \
17460 return 1; \
17461 } while (0);
17463 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17464 expansion at the end of PACKED_PARMS. Returns 0 if the type
17465 deduction succeeds, 1 otherwise. STRICT is the same as in
17466 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17467 call argument list. We'll need to adjust the arguments to make them
17468 types. SUBR tells us if this is from a recursive call to
17469 type_unification_real, or for comparing two template argument
17470 lists. */
17472 static int
17476 {
17477 tree parm
17487 /* Determine the parameter packs we will be deducing from the
17488 pattern, and record their current deductions. */
17491 {
17495 /* Determine the index and level of this parameter pack. */
17498 /* Keep track of the parameter packs and their corresponding
17499 argument packs. */
17502 }
17504 /* Loop through all of the arguments that have not yet been
17505 unified and unify each with the pattern. */
17507 {
17508 tree parm;
17512 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17513 or the element of its argument pack at the current index if
17514 this argument was explicitly specified. */
17516 {
17525 {
17528 }
17530 }
17532 /* If we had explicit template arguments, substitute them into the
17533 pattern before deduction. */
17535 {
17536 /* Some arguments might still be unspecified or dependent. */
17544 NULL_TREE);
17549 }
17550 else
17553 /* Unify the pattern with the current argument. */
17558 /* For each parameter pack, collect the deduced value. */
17560 {
17566 }
17567 }
17569 /* Verify that the results of unification with the parameter packs
17570 produce results consistent with what we've seen before, and make
17571 the deduced argument packs available. */
17573 {
17580 /* By default keep the original deduced argument pack.
17581 If necessary, more specific code is going to update the
17582 resulting deduced argument later down in this function. */
17586 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17587 actually deduce anything. */
17595 {
17596 /* If we had fewer function args than explicit template args,
17597 just use the explicits. */
17602 }
17605 {
17606 tree result;
17607 /* Build the deduced *_ARGUMENT_PACK. */
17609 {
17614 }
17615 else
17620 /* Note the deduced argument packs for this parameter
17621 pack. */
17623 }
17627 {
17628 /* We only had the explicitly-provided arguments before, but
17629 now we have a complete set of arguments. */
17635 }
17636 else
17637 {
17643 /* Inconsistent unification of this parameter pack. */
17645 bad_old_arg,
17646 bad_new_arg);
17647 }
17648 }
17651 }
17653 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17654 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17655 parameters and return value are as for unify. */
17657 static int
17661 {
17662 tree parm_max;
17663 tree arg_max;
17667 /* Our representation of array types uses "N - 1" as the
17668 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17669 not an integer constant. We cannot unify arbitrarily
17670 complex expressions, so we eliminate the MINUS_EXPRs
17671 here. */
17675 {
17678 }
17682 {
17683 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17684 trying to unify the type of a variable with the type
17685 of a template parameter. For example:
17687 template <unsigned int N>
17688 void f (char (&) [N]);
17689 int g();
17690 void h(int i) {
17691 char a[g(i)];
17692 f(a);
17693 }
17695 Here, the type of the ARG will be "int [g(i)]", and
17696 may be a SAVE_EXPR, etc. */
17700 }
17702 /* If only one of the bounds used a MINUS_EXPR, compensate
17703 by adding one to the other bound. */
17706 integer_type_node,
17707 parm_max,
17708 integer_one_node);
17711 integer_type_node,
17712 arg_max,
17713 integer_one_node);
17717 }
17719 /* Deduce the value of template parameters. TPARMS is the (innermost)
17720 set of template parameters to a template. TARGS is the bindings
17721 for those template parameters, as determined thus far; TARGS may
17722 include template arguments for outer levels of template parameters
17723 as well. PARM is a parameter to a template function, or a
17724 subcomponent of that parameter; ARG is the corresponding argument.
17725 This function attempts to match PARM with ARG in a manner
17726 consistent with the existing assignments in TARGS. If more values
17727 are deduced, then TARGS is updated.
17729 Returns 0 if the type deduction succeeds, 1 otherwise. The
17730 parameter STRICT is a bitwise or of the following flags:
17732 UNIFY_ALLOW_NONE:
17733 Require an exact match between PARM and ARG.
17734 UNIFY_ALLOW_MORE_CV_QUAL:
17735 Allow the deduced ARG to be more cv-qualified (by qualification
17736 conversion) than ARG.
17737 UNIFY_ALLOW_LESS_CV_QUAL:
17738 Allow the deduced ARG to be less cv-qualified than ARG.
17739 UNIFY_ALLOW_DERIVED:
17740 Allow the deduced ARG to be a template base class of ARG,
17741 or a pointer to a template base class of the type pointed to by
17742 ARG.
17743 UNIFY_ALLOW_INTEGER:
17744 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17745 case for more information.
17746 UNIFY_ALLOW_OUTER_LEVEL:
17747 This is the outermost level of a deduction. Used to determine validity
17748 of qualification conversions. A valid qualification conversion must
17749 have const qualified pointers leading up to the inner type which
17750 requires additional CV quals, except at the outer level, where const
17751 is not required [conv.qual]. It would be normal to set this flag in
17752 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17753 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17754 This is the outermost level of a deduction, and PARM can be more CV
17755 qualified at this point.
17756 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17757 This is the outermost level of a deduction, and PARM can be less CV
17758 qualified at this point. */
17760 static int
17763 {
17765 tree targ;
17766 tree tparm;
17769 /* I don't think this will do the right thing with respect to types.
17770 But the only case I've seen it in so far has been array bounds, where
17771 signedness is the only information lost, and I think that will be
17772 okay. */
17780 /* We can't deduce anything from this, but we might get all the
17781 template args from other function args. */
17784 /* If PARM uses template parameters, then we can't bail out here,
17785 even if ARG == PARM, since we won't record unifications for the
17786 template parameters. We might need them if we're trying to
17787 figure out which of two things is more specialized. */
17791 /* Handle init lists early, so the rest of the function can assume
17792 we're dealing with a type. */
17794 {
17799 /* Replace T with std::initializer_list<T> for deduction. */
17806 /* We can only deduce from an initializer list argument if the
17807 parameter is std::initializer_list or an array; otherwise this
17808 is a non-deduced context. */
17813 else
17817 {
17824 {
17826 /* It should only be possible to get here for a call. */
17828 elt_strict |= maybe_adjust_types_for_deduction
17831 }
17834 explain_p);
17835 }
17839 {
17840 /* Also deduce from the length of the initializer list. */
17847 }
17849 /* If the std::initializer_list<T> deduction worked, replace the
17850 deduced A with std::initializer_list<A>. */
17852 {
17857 }
17859 }
17861 /* Immediately reject some pairs that won't unify because of
17862 cv-qualification mismatches. */
17865 /* It is the elements of the array which hold the cv quals of an array
17866 type, and the elements might be template type parms. We'll check
17867 when we recurse. */
17869 /* We check the cv-qualifiers when unifying with template type
17870 parameters below. We want to allow ARG `const T' to unify with
17871 PARM `T' for example, when computing which of two templates
17872 is more specialized, for example. */
17886 {
17890 /* In a type which contains a nested-name-specifier, template
17891 argument values cannot be deduced for template parameters used
17892 within the nested-name-specifier. */
17904 /* The PARM is not one we're trying to unify. Just check
17905 to see if it matches ARG. */
17906 {
17911 else
17913 }
17920 /* Check for mixed types and values. */
17928 {
17929 /* ARG must be constructed from a template class or a template
17930 template parameter. */
17934 {
17936 /* An alias template name is never deduced. */
17941 tree parm_parms
17942 = DECL_INNERMOST_TEMPLATE_PARMS
17947 /* The resolution to DR150 makes clear that default
17948 arguments for an N-argument may not be used to bind T
17949 to a template template parameter with fewer than N
17950 parameters. It is not safe to permit the binding of
17951 default arguments as an extension, as that may change
17952 the meaning of a conforming program. Consider:
17954 struct Dense { static const unsigned int dim = 1; };
17956 template <template <typename> class View,
17957 typename Block>
17958 void operator+(float, View<Block> const&);
17960 template <typename Block,
17961 unsigned int Dim = Block::dim>
17962 struct Lvalue_proxy { operator float() const; };
17964 void
17965 test_1d (void) {
17966 Lvalue_proxy<Dense> p;
17967 float b;
17968 b + p;
17969 }
17971 Here, if Lvalue_proxy is permitted to bind to View, then
17972 the global operator+ will be used; if they are not, the
17973 Lvalue_proxy will be converted to float. */
17975 full_argvec,
17977 (explain_p
17978 ? tf_warning_or_error
17985 /* Deduce arguments T, i from TT<T> or TT<i>.
17986 We check each element of PARMVEC and ARGVEC individually
17987 rather than the whole TREE_VEC since they can have
17988 different number of elements. */
17995 /* Check if the parameters end in a pack, making them
17996 variadic. */
18002 /* If the template argument list of P contains a pack
18003 expansion that is not the last template argument, the
18004 entire template argument list is a non-deduced
18005 context. */
18014 {
18019 }
18024 DEDUCE_EXACT,
18027 }
18030 /* Fall through to deduce template name. */
18031 }
18035 {
18036 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18038 /* Simple cases: Value already set, does match or doesn't. */
18043 }
18044 else
18045 {
18046 /* If PARM is `const T' and ARG is only `int', we don't have
18047 a match unless we are allowing additional qualification.
18048 If ARG is `const int' and PARM is just `T' that's OK;
18049 that binds `const int' to `T'. */
18054 /* Consider the case where ARG is `const volatile int' and
18055 PARM is `const T'. Then, T should be `volatile int'. */
18056 arg = cp_build_qualified_type_real
18061 /* Simple cases: Value already set, does match or doesn't. */
18067 /* Make sure that ARG is not a variable-sized array. (Note
18068 that were talking about variable-sized arrays (like
18069 `int[n]'), rather than arrays of unknown size (like
18070 `int[]').) We'll get very confused by such a type since
18071 the bound of the array is not constant, and therefore
18072 not mangleable. Besides, such types are not allowed in
18073 ISO C++, so we can do as we please here. We do allow
18074 them for 'auto' deduction, since that isn't ABI-exposed. */
18078 /* Strip typedefs as in convert_template_argument. */
18080 }
18082 /* If ARG is a parameter pack or an expansion, we cannot unify
18083 against it unless PARM is also a parameter pack. */
18088 /* If the argument deduction results is a METHOD_TYPE,
18089 then there is a problem.
18090 METHOD_TYPE doesn't map to any real C++ type the result of
18091 the deduction can not be of that type. */
18105 {
18106 /* The PARM is not one we're trying to unify. Just check
18107 to see if it matches ARG. */
18113 }
18119 {
18124 }
18126 /* [temp.deduct.type] If, in the declaration of a function template
18127 with a non-type template-parameter, the non-type
18128 template-parameter is used in an expression in the function
18129 parameter-list and, if the corresponding template-argument is
18130 deduced, the template-argument type shall match the type of the
18131 template-parameter exactly, except that a template-argument
18132 deduced from an array bound may be of any integral type.
18133 The non-type parameter might use already deduced type parameters. */
18136 /* Template-parameter dependent expression. Just accept it for now.
18137 It will later be processed in convert_template_argument. */
18138 ;
18143 /* Convert the ARG to the type of PARM; the deduced non-type
18144 template argument must exactly match the types of the
18145 corresponding parameter. */
18148 /* We haven't deduced the type of this parameter yet. Try again
18149 later. */
18151 else
18154 /* If ARG is a parameter pack or an expansion, we cannot unify
18155 against it unless PARM is also a parameter pack. */
18165 {
18166 /* A pointer-to-member constant can be unified only with
18167 another constant. */
18171 /* Just unify the class member. It would be useless (and possibly
18172 wrong, depending on the strict flags) to unify also
18173 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18174 arg refer to the same variable, even if through different
18175 classes. For instance:
18177 struct A { int x; };
18178 struct B : A { };
18180 Unification of &A::x and &B::x must succeed. */
18183 }
18186 {
18190 /* [temp.deduct.call]
18192 A can be another pointer or pointer to member type that can
18193 be converted to the deduced A via a qualification
18194 conversion (_conv.qual_).
18196 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18197 This will allow for additional cv-qualification of the
18198 pointed-to types if appropriate. */
18201 /* The derived-to-base conversion only persists through one
18202 level of pointers. */
18207 }
18239 /* We have already checked cv-qualification at the top of the
18240 function. */
18244 /* As far as unification is concerned, this wins. Later checks
18245 will invalidate it if necessary. */
18248 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18249 /* Type INTEGER_CST can come from ordinary constant template args. */
18261 {
18271 /* Check for pack expansions in the parameters. */
18273 {
18275 {
18277 /* We can unify against something with a trailing
18278 parameter pack. */
18280 else
18281 /* [temp.deduct.type]/9: If the template argument list of
18282 P contains a pack expansion that is not the last
18283 template argument, the entire template argument list
18284 is a non-deduced context. */
18286 }
18287 }
18289 /* If we don't have enough arguments to satisfy the parameters
18290 (not counting the pack expression at the end), or we have
18291 too many arguments for a parameter list that doesn't end in
18292 a pack expression, we can't unify. */
18298 /* Unify all of the parameters that precede the (optional)
18299 pack expression. */
18301 {
18306 }
18309 DEDUCE_EXACT,
18312 }
18320 {
18328 }
18331 {
18335 {
18336 /* First, we try to unify the PARM and ARG directly. */
18341 {
18342 /* Fallback to the special case allowed in
18343 [temp.deduct.call]:
18345 If P is a class, and P has the form
18346 template-id, then A can be a derived class of
18347 the deduced A. Likewise, if P is a pointer to
18348 a class of the form template-id, A can be a
18349 pointer to a derived class pointed to by the
18350 deduced A. */
18357 }
18358 }
18362 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18363 Then, we should unify `int' and `U'. */
18365 else
18366 /* There's no chance of unification succeeding. */
18371 }
18378 {
18381 tree a;
18387 /* CV qualifications for methods can never be deduced, they must
18388 match exactly. We need to check them explicitly here,
18389 because type_unification_real treats them as any other
18390 cv-qualified parameter. */
18392 && (!check_cv_quals_for_unify
18412 }
18415 /* Unify a pointer to member with a pointer to member function, which
18416 deduces the type of the member as a function type. */
18418 {
18419 /* Check top-level cv qualifiers */
18427 /* Determine the type of the function we are unifying against. */
18431 }
18450 /* Matched cases are handled by the ARG == PARM test above. */
18454 /* A non-type template parameter that is a variable should be a
18455 an integral constant, in which case, it whould have been
18456 folded into its (constant) value. So we should not be getting
18457 a variable here. */
18468 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18469 or UNDERLYING_TYPE nodes. */
18473 /* Unification fails if we hit an error node. */
18480 /* FALLTHRU */
18483 /* An unresolved overload is a nondeduced context. */
18488 /* We must be looking at an expression. This can happen with
18489 something like:
18491 template <int I>
18492 void foo(S<I>, S<I + 2>);
18494 This is a "nondeduced context":
18496 [deduct.type]
18498 The nondeduced contexts are:
18500 --A type that is a template-id in which one or more of
18501 the template-arguments is an expression that references
18502 a template-parameter.
18504 In these cases, we assume deduction succeeded, but don't
18505 actually infer any unifications. */
18510 else
18512 }
18513 }
18514 #undef RECUR_AND_CHECK_FAILURE
18515 \f
18516 /* Note that DECL can be defined in this translation unit, if
18517 required. */
18519 static void
18521 {
18522 tree clone;
18526 }
18528 /* Called if RESULT is explicitly instantiated, or is a member of an
18529 explicitly instantiated class. */
18531 void
18533 {
18536 /* If this entity has already been written out, it's too late to
18537 make any modifications. */
18541 /* For anonymous namespace we don't need to do anything. */
18543 {
18546 }
18549 /* The TREE_PUBLIC flag for function declarations will have been
18550 set correctly by tsubst. */
18553 /* This might have been set by an earlier implicit instantiation. */
18558 else
18559 {
18562 /* Always make artificials weak. */
18565 /* For WIN32 we also want to put explicit instantiations in
18566 linkonce sections. */
18569 }
18571 /* If EXTERN_P, then this function will not be emitted -- unless
18572 followed by an explicit instantiation, at which point its linkage
18573 will be adjusted. If !EXTERN_P, then this function will be
18574 emitted here. In neither circumstance do we want
18575 import_export_decl to adjust the linkage. */
18577 }
18579 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18580 important template arguments. If any are missing, we check whether
18581 they're important by using error_mark_node for substituting into any
18582 args that were used for partial ordering (the ones between ARGS and END)
18583 and seeing if it bubbles up. */
18585 static bool
18587 {
18592 {
18595 }
18597 {
18601 }
18603 }
18605 /* Given two function templates PAT1 and PAT2, return:
18607 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18608 -1 if PAT2 is more specialized than PAT1.
18609 0 if neither is more specialized.
18611 LEN indicates the number of parameters we should consider
18612 (defaulted parameters should not be considered).
18614 The 1998 std underspecified function template partial ordering, and
18615 DR214 addresses the issue. We take pairs of arguments, one from
18616 each of the templates, and deduce them against each other. One of
18617 the templates will be more specialized if all the *other*
18618 template's arguments deduce against its arguments and at least one
18619 of its arguments *does* *not* deduce against the other template's
18620 corresponding argument. Deduction is done as for class templates.
18621 The arguments used in deduction have reference and top level cv
18622 qualifiers removed. Iff both arguments were originally reference
18623 types *and* deduction succeeds in both directions, an lvalue reference
18624 wins against an rvalue reference and otherwise the template
18625 with the more cv-qualified argument wins for that pairing (if
18626 neither is more cv-qualified, they both are equal). Unlike regular
18627 deduction, after all the arguments have been deduced in this way,
18628 we do *not* verify the deduced template argument values can be
18629 substituted into non-deduced contexts.
18631 The logic can be a bit confusing here, because we look at deduce1 and
18632 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18633 can find template arguments for pat1 to make arg1 look like arg2, that
18634 means that arg2 is at least as specialized as arg1. */
18636 int
18638 {
18651 /* Remove the this parameter from non-static member functions. If
18652 one is a non-static member function and the other is not a static
18653 member function, remove the first parameter from that function
18654 also. This situation occurs for operator functions where we
18655 locate both a member function (with this pointer) and non-member
18656 operator (with explicit first operand). */
18658 {
18663 }
18665 {
18668 {
18669 len--;
18671 }
18672 }
18674 /* If only one is a conversion operator, they are unordered. */
18678 /* Consider the return type for a conversion function */
18680 {
18683 len++;
18684 }
18686 processing_template_decl++;
18692 /* Stop when an ellipsis is seen. */
18694 {
18705 {
18706 /* When both arguments are pack expansions, we need only
18707 unify the patterns themselves. */
18711 /* This is the last comparison we need to do. */
18713 }
18716 {
18720 }
18723 {
18727 }
18733 {
18739 /* Setup the parameter vector, which contains only ARG1. */
18742 /* Setup the argument vector, which contains the remaining
18743 arguments. */
18752 /* We cannot deduce in the other direction, because ARG1 is
18753 a pack expansion but ARG2 is not. */
18755 }
18757 {
18763 /* Setup the parameter vector, which contains only ARG1. */
18766 /* Setup the argument vector, which contains the remaining
18767 arguments. */
18776 /* We cannot deduce in the other direction, because ARG2 is
18777 a pack expansion but ARG1 is not.*/
18779 }
18781 else
18782 {
18783 /* The normal case, where neither argument is a pack
18784 expansion. */
18791 }
18793 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18794 arg2, then arg2 is not as specialized as arg1. */
18800 /* "If, for a given type, deduction succeeds in both directions
18801 (i.e., the types are identical after the transformations above)
18802 and both P and A were reference types (before being replaced with
18803 the type referred to above):
18804 - if the type from the argument template was an lvalue reference and
18805 the type from the parameter template was not, the argument type is
18806 considered to be more specialized than the other; otherwise,
18807 - if the type from the argument template is more cv-qualified
18808 than the type from the parameter template (as described above),
18809 the argument type is considered to be more specialized than the other;
18810 otherwise,
18811 - neither type is more specialized than the other." */
18814 {
18816 {
18819 else
18821 }
18823 {
18828 }
18829 }
18832 /* We've failed to deduce something in either direction.
18833 These must be unordered. */
18838 /* We have already processed all of the arguments in our
18839 handing of the pack expansion type. */
18844 }
18846 /* "In most cases, all template parameters must have values in order for
18847 deduction to succeed, but for partial ordering purposes a template
18848 parameter may remain without a value provided it is not used in the
18849 types being used for partial ordering."
18851 Thus, if we are missing any of the targs1 we need to substitute into
18852 origs1, then pat2 is not as specialized as pat1. This can happen when
18853 there is a nondeduced context. */
18859 processing_template_decl--;
18861 /* All things being equal, if the next argument is a pack expansion
18862 for one function but not for the other, prefer the
18863 non-variadic function. FIXME this is bogus; see c++/41958. */
18867 {
18870 }
18872 // All things still being equal, determine if one is more constrained.
18874 {
18877 }
18883 else
18885 }
18887 /* Determine which of two partial specializations of TMPL is more
18888 specialized.
18890 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18891 to the first partial specialization. The TREE_VALUE is the
18892 innermost set of template parameters for the partial
18893 specialization. PAT2 is similar, but for the second template.
18895 Return 1 if the first partial specialization is more specialized;
18896 -1 if the second is more specialized; 0 if neither is more
18897 specialized.
18899 See [temp.class.order] for information about determining which of
18900 two templates is more specialized. */
18902 static int
18904 {
18905 tree targs;
18914 /* Just like what happens for functions, if we are ordering between
18915 different class template specializations, we may encounter dependent
18916 types in the arguments, and we need our dependency check functions
18917 to behave correctly. */
18923 {
18926 }
18932 {
18935 }
18938 /* In the case of a tie where at least one of the class templates
18939 has a parameter pack at the end, the template with the most
18940 non-packed parameters wins. */
18942 && any_deductions
18945 {
18951 /* We don't count the pack expansion at the end. */
18961 }
18969 }
18971 /* Return the template arguments that will produce the function signature
18972 DECL from the function template FN, with the explicit template
18973 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18974 also match. Return NULL_TREE if no satisfactory arguments could be
18975 found. */
18977 static tree
18979 {
18983 tree decl_arg_types;
18986 tree arg;
18990 /* Never do unification on the 'this' parameter. */
19011 }
19013 /* Return the innermost template arguments that, when applied to a partial
19014 specialization of TMPL whose innermost template parameters are
19015 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19016 ARGS.
19018 For example, suppose we have:
19020 template <class T, class U> struct S {};
19021 template <class T> struct S<T*, int> {};
19023 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19024 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19025 int}. The resulting vector will be {double}, indicating that `T'
19026 is bound to `double'. */
19028 static tree
19031 {
19033 tree deduced_args;
19034 tree innermost_deduced_args;
19038 {
19042 innermost_deduced_args);
19043 }
19044 else
19057 /* Verify that nondeduced template arguments agree with the type
19058 obtained from argument deduction.
19060 For example:
19062 struct A { typedef int X; };
19063 template <class T, class U> struct C {};
19064 template <class T> struct C<T, typename T::X> {};
19066 Then with the instantiation `C<A, int>', we can deduce that
19067 `T' is `A' but unify () does not check whether `typename T::X'
19068 is `int'. */
19074 /* We only need to check the innermost arguments; the other
19075 arguments will always agree. */
19080 /* Now that we have bindings for all of the template arguments,
19081 ensure that the arguments deduced for the template template
19082 parameters have compatible template parameter lists. See the use
19083 of template_template_parm_bindings_ok_p in fn_type_unification
19084 for more information. */
19088 // Having computed and checked the binding, make sure that the
19089 // deduced arguments actually satisfy the template constraints.
19090 // If not, it is equivalent to having failed to compute the binding.
19095 }
19097 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19098 Return the TREE_LIST node with the most specialized template, if
19099 any. If there is no most specialized template, the error_mark_node
19100 is returned.
19102 Note that this function does not look at, or modify, the
19103 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19104 returned is one of the elements of INSTANTIATIONS, callers may
19105 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19106 and retrieve it from the value returned. */
19108 tree
19110 {
19117 {
19123 fate--;
19128 fate++;
19133 {
19134 /* Equally specialized, move to next function. If there
19135 is no next function, nothing's most specialized. */
19140 }
19141 }
19144 /* Now verify that champ is better than everything earlier in the
19145 instantiation list. */
19153 {
19156 }
19158 processing_template_decl--;
19164 }
19166 /* If DECL is a specialization of some template, return the most
19167 general such template. Otherwise, returns NULL_TREE.
19169 For example, given:
19171 template <class T> struct S { template <class U> void f(U); };
19173 if TMPL is `template <class U> void S<int>::f(U)' this will return
19174 the full template. This function will not trace past partial
19175 specializations, however. For example, given in addition:
19177 template <class T> struct S<T*> { template <class U> void f(U); };
19179 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19180 `template <class T> template <class U> S<T*>::f(U)'. */
19182 tree
19184 {
19185 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
19186 an immediate specialization. */
19188 {
19192 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
19193 template friend. */
19198 }
19200 /* Look for more and more general templates. */
19202 {
19203 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19204 (See cp-tree.h for details.) */
19212 /* Stop if we run into an explicitly specialized class template. */
19219 }
19222 }
19224 /* Return the most specialized of the class template partial
19225 specializations which can produce TYPE, a specialization of some class
19226 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
19227 a _TYPE node corresponding to the partial specialization, while the
19228 TREE_PURPOSE is the set of template arguments that must be
19229 substituted into the TREE_TYPE in order to generate TYPE.
19231 If the choice of partial specialization is ambiguous, a diagnostic
19232 is issued, and the error_mark_node is returned. If there are no
19233 partial specializations matching TYPE, then NULL_TREE is
19234 returned, indicating that the primary template should be used. */
19236 static tree
19238 {
19240 tree t;
19241 tree champ;
19250 /* For determining which partial specialization to use, only the
19251 innermost args are interesting. */
19253 {
19256 }
19259 {
19260 tree partial_spec_args;
19261 tree spec_args;
19270 {
19271 /* Discard the outer levels of args, and then substitute in the
19272 template args from the enclosing class. */
19274 partial_spec_args = tsubst_template_args
19277 /* And the same for the partial specialization TEMPLATE_DECL. */
19279 }
19281 partial_spec_args =
19283 partial_spec_args,
19297 partial_spec_args,
19298 args);
19300 {
19305 }
19306 }
19316 {
19319 ;
19320 else
19321 {
19323 {
19326 {
19329 }
19330 }
19332 }
19333 }
19337 {
19340 {
19343 }
19344 }
19347 {
19355 {
19358 }
19361 }
19364 }
19366 /* Explicitly instantiate DECL. */
19368 void
19370 {
19375 /* An error occurred, for which grokdeclarator has already issued
19376 an appropriate message. */
19379 {
19382 }
19384 {
19385 /* There is an asymmetry here in the way VAR_DECLs and
19386 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19387 the latter, the DECL we get back will be marked as a
19388 template instantiation, and the appropriate
19389 DECL_TEMPLATE_INFO will be set up. This does not happen for
19390 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19391 should handle VAR_DECLs as it currently handles
19392 FUNCTION_DECLs. */
19394 {
19397 }
19400 {
19403 }
19405 {
19410 }
19411 }
19413 {
19416 }
19417 else
19420 /* Check for various error cases. Note that if the explicit
19421 instantiation is valid the RESULT will currently be marked as an
19422 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19423 until we get here. */
19426 {
19427 /* DR 259 [temp.spec].
19429 Both an explicit instantiation and a declaration of an explicit
19430 specialization shall not appear in a program unless the explicit
19431 instantiation follows a declaration of the explicit specialization.
19433 For a given set of template parameters, if an explicit
19434 instantiation of a template appears after a declaration of an
19435 explicit specialization for that template, the explicit
19436 instantiation has no effect. */
19438 }
19440 {
19441 /* [temp.spec]
19443 No program shall explicitly instantiate any template more
19444 than once.
19446 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19447 the first instantiation was `extern' and the second is not,
19448 and EXTERN_P for the opposite case. */
19451 /* If an "extern" explicit instantiation follows an ordinary
19452 explicit instantiation, the template is instantiated. */
19455 }
19457 {
19460 }
19462 {
19465 }
19468 ;
19470 {
19473 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19476 }
19477 else
19485 }
19487 static void
19489 {
19495 {
19498 }
19499 }
19501 /* Called from do_type_instantiation through binding_table_foreach to
19502 do recursive instantiation for the type bound in ENTRY. */
19503 static void
19505 {
19511 }
19513 /* Called from do_type_instantiation to instantiate a member
19514 (a member function or a static member variable) of an
19515 explicitly instantiated class template. */
19516 static void
19518 {
19523 }
19525 /* Perform an explicit instantiation of template class T. STORAGE, if
19526 non-null, is the RID for extern, inline or static. COMPLAIN is
19527 nonzero if this is called from the parser, zero if called recursively,
19528 since the standard is unclear (as detailed below). */
19530 void
19532 {
19542 {
19543 tree tmpl =
19547 else
19550 }
19555 {
19558 t);
19560 }
19563 {
19565 {
19567 {
19570 "ISO C++ 1998 forbids the use of %<extern%> on "
19572 }
19573 else
19575 "ISO C++ forbids the use of %qE"
19577 }
19585 else
19586 {
19588 storage);
19590 }
19591 }
19594 {
19595 /* DR 259 [temp.spec].
19597 Both an explicit instantiation and a declaration of an explicit
19598 specialization shall not appear in a program unless the explicit
19599 instantiation follows a declaration of the explicit specialization.
19601 For a given set of template parameters, if an explicit
19602 instantiation of a template appears after a declaration of an
19603 explicit specialization for that template, the explicit
19604 instantiation has no effect. */
19606 }
19608 {
19609 /* [temp.spec]
19611 No program shall explicitly instantiate any template more
19612 than once.
19614 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19615 instantiation was `extern'. If EXTERN_P then the second is.
19616 These cases are OK. */
19623 /* If we've already instantiated the template, just return now. */
19626 }
19634 {
19635 tree tmp;
19637 /* In contrast to implicit instantiation, where only the
19638 declarations, and not the definitions, of members are
19639 instantiated, we have here:
19641 [temp.explicit]
19643 The explicit instantiation of a class template specialization
19644 implies the instantiation of all of its members not
19645 previously explicitly specialized in the translation unit
19646 containing the explicit instantiation.
19648 Of course, we can't instantiate member template classes, since
19649 we don't have any arguments for them. Note that the standard
19650 is unclear on whether the instantiation of the members are
19651 *explicit* instantiations or not. However, the most natural
19652 interpretation is that it should be an explicit instantiation. */
19667 }
19668 }
19670 /* Given a function DECL, which is a specialization of TMPL, modify
19671 DECL to be a re-instantiation of TMPL with the same template
19672 arguments. TMPL should be the template into which tsubst'ing
19673 should occur for DECL, not the most general template.
19675 One reason for doing this is a scenario like this:
19677 template <class T>
19678 void f(const T&, int i);
19680 void g() { f(3, 7); }
19682 template <class T>
19683 void f(const T& t, const int i) { }
19685 Note that when the template is first instantiated, with
19686 instantiate_template, the resulting DECL will have no name for the
19687 first parameter, and the wrong type for the second. So, when we go
19688 to instantiate the DECL, we regenerate it. */
19690 static void
19692 {
19693 /* The arguments used to instantiate DECL, from the most general
19694 template. */
19695 tree args;
19696 tree code_pattern;
19701 /* Make sure that we can see identifiers, and compute access
19702 correctly. */
19706 {
19707 tree decl_parm;
19708 tree pattern_parm;
19709 tree specs;
19723 specs);
19725 /* Merge parameter declarations. */
19728 pattern_parm
19732 {
19733 tree parm_type;
19734 tree attributes;
19739 NULL_TREE);
19745 {
19748 }
19751 }
19752 /* Merge any parameters that match with the function parameter
19753 pack. */
19755 {
19757 tree expanded_types;
19758 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19759 the parameters in this function parameter pack. */
19764 {
19765 tree parm_type;
19766 tree attributes;
19769 /* Rename the parameter to include the index. */
19778 {
19781 }
19783 }
19784 }
19785 /* Merge additional specifiers from the CODE_PATTERN. */
19789 }
19791 {
19799 }
19800 else
19804 }
19806 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19807 substituted to get DECL. */
19809 tree
19811 {
19814 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19815 for the instantiation. This is not always the most general
19816 template. Consider, for example:
19818 template <class T>
19819 struct S { template <class U> void f();
19820 template <> void f<int>(); };
19822 and an instantiation of S<double>::f<int>. We want TD to be the
19823 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19825 more general template. */
19827 /* We must also deal with friend templates. Given:
19829 template <class T> struct S {
19830 template <class U> friend void f() {};
19831 };
19833 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19834 so far as the language is concerned, but that's still
19835 where we get the pattern for the instantiation from. On
19836 other hand, if the definition comes outside the class, say:
19838 template <class T> struct S {
19839 template <class U> friend void f();
19840 };
19841 template <class U> friend void f() {}
19843 we don't need to look any further. That's what the check for
19844 DECL_INITIAL is for. */
19848 {
19849 /* The present template, TD, should not be a definition. If it
19850 were a definition, we should be using it! Note that we
19851 cannot restructure the loop to just keep going until we find
19852 a template with a definition, since that might go too far if
19853 a specialization was declared, but not defined. */
19857 /* Fetch the more general template. */
19859 }
19862 }
19864 /* Returns true if we need to instantiate this template instance even if we
19865 know we aren't going to emit it.. */
19867 bool
19869 {
19870 /* We always instantiate inline functions so that we can inline them. An
19871 explicit instantiation declaration prohibits implicit instantiation of
19872 non-inline functions. With high levels of optimization, we would
19873 normally inline non-inline functions -- but we're not allowed to do
19874 that for "extern template" functions. Therefore, we check
19875 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19879 /* And we need to instantiate static data members so that
19880 their initializers are available in integral constant
19881 expressions. */
19884 }
19886 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19887 instantiate it now, modifying TREE_TYPE (fn). */
19889 void
19891 {
19894 /* Don't instantiate a noexcept-specification from template context. */
19909 {
19911 {
19926 }
19927 else
19929 }
19930 else
19931 {
19932 /* This is an implicitly declared function, so NOEX is a list of
19933 other functions to evaluate and merge. */
19934 tree elt;
19937 {
19939 tree subspec;
19943 }
19944 }
19949 {
19952 else
19954 }
19955 }
19957 /* Produce the definition of D, a _DECL generated from a template. If
19958 DEFER_OK is nonzero, then we don't have to actually do the
19959 instantiation now; we just have to do it sometime. Normally it is
19960 an error if this is an explicit instantiation but D is undefined.
19961 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19962 explicitly instantiated class template. */
19964 tree
19967 {
19969 tree gen_args;
19970 tree args;
19971 tree td;
19972 tree code_pattern;
19973 tree spec;
19974 tree gen_tmpl;
19980 tree fn_context;
19983 /* This function should only be used to instantiate templates for
19984 functions and static member variables. */
19987 /* Variables are never deferred; if instantiation is required, they
19988 are instantiated right away. That allows for better code in the
19989 case that an expression refers to the value of the variable --
19990 if the variable has a constant value the referring expression can
19991 take advantage of that fact. */
19996 /* Don't instantiate cloned functions. Instead, instantiate the
19997 functions they cloned. */
20005 /* D has already been instantiated or explicitly specialized, so
20006 there's nothing for us to do here.
20008 It might seem reasonable to check whether or not D is an explicit
20009 instantiation, and, if so, stop here. But when an explicit
20010 instantiation is deferred until the end of the compilation,
20011 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20012 the instantiation. */
20015 /* Check to see whether we know that this template will be
20016 instantiated in some other file, as with "extern template"
20017 extension. */
20020 /* In general, we do not instantiate such templates. */
20028 /* We should already have the extra args. */
20031 /* And what's in the hash table should match D. */
20035 /* This needs to happen before any tsubsting. */
20041 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20042 for the instantiation. */
20046 /* We should never be trying to instantiate a member of a class
20047 template or partial specialization. */
20052 /* In the case of a friend template whose definition is provided
20053 outside the class, we may have too many arguments. Drop the
20054 ones we don't need. The same is true for specializations. */
20055 args = get_innermost_template_args
20057 else
20063 else
20066 /* We may be in the middle of deferred access check. Disable it now. */
20069 /* Unless an explicit instantiation directive has already determined
20070 the linkage of D, remember that a definition is available for
20071 this entity. */
20081 /* If D is a member of an explicitly instantiated class template,
20082 and no definition is available, treat it like an implicit
20083 instantiation. */
20086 {
20087 /* Leave linkage flags alone on instantiations with anonymous
20088 visibility. */
20090 {
20093 }
20095 }
20100 /* Defer all other templates, unless we have been explicitly
20101 forbidden from doing so. */
20103 template. */
20104 ! pattern_defined
20105 /* If it's OK to postpone instantiation, do so. */
20106 || defer_ok
20107 /* If this is a static data member that will be defined
20108 elsewhere, we don't want to instantiate the entire data
20109 member, but we do want to instantiate the initializer so that
20110 we can substitute that elsewhere. */
20112 {
20113 /* The definition of the static data member is now required so
20114 we must substitute the initializer. */
20118 {
20119 tree ns;
20120 tree init;
20127 args,
20130 /* Make sure the initializer is still constant, in case of
20131 circular dependency (template/instantiate6.C). */
20132 const_init
20136 LOOKUP_ONLYCONVERTING);
20139 }
20141 /* We restore the source position here because it's used by
20142 add_pending_template. */
20148 /* [temp.explicit]
20150 The definition of a non-exported function template, a
20151 non-exported member function template, or a non-exported
20152 member function or static data member of a class template
20153 shall be present in every translation unit in which it is
20154 explicitly instantiated. */
20158 /* If we're in unevaluated context, we just wanted to get the
20159 constant value; this isn't an odr use, so don't queue
20160 a full instantiation. */
20163 /* ??? Historically, we have instantiated inline functions, even
20164 when marked as "extern template". */
20168 }
20169 /* Tell the repository that D is available in this translation unit
20170 -- and see if it is supposed to be instantiated here. */
20172 {
20173 /* In a PCH file, despite the fact that the repository hasn't
20174 requested instantiation in the PCH it is still possible that
20175 an instantiation will be required in a file that includes the
20176 PCH. */
20179 /* Instantiate inline functions so that the inliner can do its
20180 job, even though we'll not be emitting a copy of this
20181 function. */
20184 }
20190 else
20191 {
20196 }
20198 /* Mark D as instantiated so that recursive calls to
20199 instantiate_decl do not try to instantiate it again. */
20202 /* Regenerate the declaration in case the template has been modified
20203 by a subsequent redeclaration. */
20206 /* We already set the file and line above. Reset them now in case
20207 they changed as a result of calling regenerate_decl_from_template. */
20211 {
20212 tree init;
20215 /* Clear out DECL_RTL; whatever was there before may not be right
20216 since we've reset the type of the declaration. */
20220 /* The initializer is placed in DECL_INITIAL by
20221 regenerate_decl_from_template so we don't need to
20222 push/pop_access_scope again here. Pull it out so that
20223 cp_finish_decl can process it. */
20228 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20229 initializer. That function will defer actual emission until
20230 we have a chance to determine linkage. */
20233 /* Enter the scope of D so that access-checking works correctly. */
20238 }
20242 {
20244 tree subst_decl;
20245 tree tmpl_parm;
20246 tree spec_parm;
20249 /* Save away the current list, in case we are instantiating one
20250 template from within the body of another. */
20253 /* Set up the list of local specializations. */
20256 /* Set up context. */
20260 else
20263 /* Some typedefs referenced from within the template code need to be
20264 access checked at template instantiation time, i.e now. These
20265 types were added to the template at parsing time. Let's get those
20266 and perform the access checks then. */
20268 gen_args);
20270 /* Create substitution entries for the parameters. */
20275 {
20279 }
20281 {
20283 {
20286 }
20287 else
20288 {
20289 /* Register the (value) argument pack as a specialization of
20290 TMPL_PARM, then move on. */
20293 }
20294 }
20297 /* Substitute into the body of the function. */
20301 else
20302 {
20307 /* Set the current input_location to the end of the function
20308 so that finish_function knows where we are. */
20309 input_location
20312 /* Remember if we saw an infinite loop in the template. */
20313 current_function_infinite_loop
20315 }
20317 /* We don't need the local specializations any more. */
20321 /* Finish the function. */
20325 else
20326 {
20329 }
20333 }
20335 /* We're not deferring instantiation any more. */
20343 out:
20353 }
20355 /* Run through the list of templates that we wish we could
20356 instantiate, and instantiate any we can. RETRIES is the
20357 number of times we retry pending template instantiation. */
20359 void
20361 {
20365 /* Instantiating templates may trigger vtable generation. This in turn
20366 may require further template instantiations. We place a limit here
20367 to avoid infinite loop. */
20369 {
20373 " instantiating %q+D, possibly from virtual table generation"
20377 /* Pretend that we defined it. */
20380 }
20382 do
20383 {
20388 {
20393 {
20394 tree fn;
20397 {
20401 fn;
20409 }
20412 }
20413 else
20414 {
20417 {
20418 instantiation
20424 }
20428 }
20431 /* If INSTANTIATION has been instantiated, then we don't
20432 need to consider it again in the future. */
20434 else
20435 {
20438 }
20441 }
20443 }
20447 }
20449 /* Substitute ARGVEC into T, which is a list of initializers for
20450 either base class or a non-static data member. The TREE_PURPOSEs
20451 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20452 instantiate_decl. */
20454 static tree
20456 {
20460 {
20461 tree decl;
20462 tree init;
20468 {
20469 tree expr;
20470 tree arg;
20472 /* Expand the base class expansion type into separate base
20473 classes. */
20475 tf_warning_or_error,
20476 NULL_TREE);
20480 /* We'll be building separate TREE_LISTs of arguments for
20481 each base. */
20487 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20488 expand each argument in the TREE_VALUE of t. */
20495 /* VOID_TYPE_NODE is used to indicate
20496 value-initialization. */
20497 {
20500 }
20501 else
20502 {
20503 /* Substitute parameter packs into each argument in the
20504 TREE_LIST. */
20507 {
20508 tree expanded_exprs;
20510 /* Expand the argument. */
20512 expanded_exprs
20514 tf_warning_or_error,
20515 NULL_TREE);
20519 /* Prepend each of the expanded expressions to the
20520 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20522 {
20527 }
20528 }
20531 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20532 since we built them backwards. */
20534 {
20537 }
20538 }
20539 }
20542 {
20544 {
20548 }
20549 else
20550 {
20551 tree tmp;
20566 /* If we had an initializer but it instantiated to nothing,
20567 value-initialize the object. This will only occur when
20568 the initializer was a pack expansion where the parameter
20569 packs used in that expansion were of length zero. */
20572 }
20575 {
20579 }
20580 }
20581 }
20583 }
20585 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20587 static void
20589 {
20594 else
20596 }
20598 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20599 is the instantiation (which should have been created with
20600 start_enum) and ARGS are the template arguments to use. */
20602 static void
20604 {
20605 tree e;
20611 {
20612 tree value;
20613 tree decl;
20616 /* Note that in a template enum, the TREE_VALUE is the
20617 CONST_DECL, not the corresponding INTEGER_CST. */
20622 /* Give this enumeration constant the correct access. */
20625 /* Actually build the enumerator itself. */
20626 build_enumerator
20628 }
20638 }
20640 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20641 its type -- but without substituting the innermost set of template
20642 arguments. So, innermost set of template parameters will appear in
20643 the type. */
20645 tree
20647 {
20648 tree fn_type;
20649 tree tmpl;
20650 tree targs;
20651 tree tparms;
20659 /* There should be as many levels of arguments as there are levels
20660 of parameters. */
20666 /* No substitution is necessary. */
20667 ;
20668 else
20669 {
20671 tree partial_args;
20673 /* Replace the innermost level of the TARGS with NULL_TREEs to
20674 let tsubst know not to substitute for those parameters. */
20683 /* Make sure that we can see identifiers, and compute access
20684 correctly. */
20688 /* Now, do the (partial) substitution to figure out the
20689 appropriate function type. */
20693 /* Substitute into the template parameters to obtain the real
20694 innermost set of parameters. This step is important if the
20695 innermost set of template parameters contains value
20696 parameters whose types depend on outer template parameters. */
20701 }
20704 }
20706 /* Return truthvalue if we're processing a template different from
20707 the last one involved in diagnostics. */
20708 int
20710 {
20712 }
20714 /* Remember current template involved in diagnostics. */
20715 void
20717 {
20719 }
20723 {
20725 }
20727 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20728 type. Return zero for ok, nonzero for disallowed. Issue error and
20729 warning messages under control of COMPLAIN. */
20731 static int
20733 {
20750 {
20753 else
20755 type);
20756 }
20758 }
20760 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20761 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20763 static bool
20765 {
20766 tree scope;
20768 /* [temp.dep.type]
20770 A type is dependent if it is:
20772 -- a template parameter. Template template parameters are types
20773 for us (since TYPE_P holds true for them) so we handle
20774 them here. */
20778 /* -- a qualified-id with a nested-name-specifier which contains a
20779 class-name that names a dependent type or whose unqualified-id
20780 names a dependent type. */
20783 /* -- a cv-qualified type where the cv-unqualified type is
20784 dependent. */
20786 /* -- a compound type constructed from any dependent type. */
20796 {
20797 tree arg_type;
20802 arg_type;
20807 }
20808 /* -- an array type constructed from any dependent type or whose
20809 size is specified by a constant expression that is
20810 value-dependent.
20812 We checked for type- and value-dependence of the bounds in
20813 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20815 {
20820 }
20822 /* -- a template-id in which either the template name is a template
20823 parameter ... */
20826 /* ... or any of the template arguments is a dependent type or
20827 an expression that is type-dependent or value-dependent. */
20829 && (any_dependent_template_arguments_p
20833 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20834 dependent; if the argument of the `typeof' expression is not
20835 type-dependent, then it should already been have resolved. */
20841 /* A template argument pack is dependent if any of its packed
20842 arguments are. */
20844 {
20850 }
20852 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20853 be template parameters. */
20857 /* The standard does not specifically mention types that are local
20858 to template functions or local classes, but they should be
20859 considered dependent too. For example:
20861 template <int I> void f() {
20862 enum E { a = I };
20863 S<sizeof (E)> s;
20864 }
20866 The size of `E' cannot be known until the value of `I' has been
20867 determined. Therefore, `E' must be considered dependent. */
20871 /* Don't use type_dependent_expression_p here, as it can lead
20872 to infinite recursion trying to determine whether a lambda
20873 nested in a lambda is dependent (c++/47687). */
20877 && (any_dependent_template_arguments_p
20881 /* Other types are non-dependent. */
20883 }
20885 /* Returns TRUE if TYPE is dependent, in the sense of
20886 [temp.dep.type]. Note that a NULL type is considered dependent. */
20888 bool
20890 {
20891 /* If there are no template parameters in scope, then there can't be
20892 any dependent types. */
20894 {
20895 /* If we are not processing a template, then nobody should be
20896 providing us with a dependent type. */
20900 }
20902 /* If the type is NULL, we have not computed a type for the entity
20903 in question; in that case, the type is dependent. */
20907 /* Erroneous types can be considered non-dependent. */
20911 /* If we have not already computed the appropriate value for TYPE,
20912 do so now. */
20914 {
20917 }
20920 }
20922 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20923 lookup. In other words, a dependent type that is not the current
20924 instantiation. */
20926 bool
20928 {
20931 }
20933 /* T is a SCOPE_REF; return whether we need to consider it
20934 instantiation-dependent so that we can check access at instantiation
20935 time even though we know which member it resolves to. */
20937 static bool
20939 {
20945 else
20947 }
20949 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20950 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20951 expression. */
20953 /* Note that this predicate is not appropriate for general expressions;
20954 only constant expressions (that satisfy potential_constant_expression)
20955 can be tested for value dependence. */
20957 bool
20959 {
20963 /* A name declared with a dependent type. */
20968 {
20970 /* A name that has not been looked up -- must be dependent. */
20974 /* A non-type template parm. */
20978 /* A non-type template parm. */
20984 /* A constant with literal type and is initialized
20985 with an expression that is value-dependent.
20987 Note that a non-dependent parenthesized initializer will have
20988 already been replaced with its constant value, so if we see
20989 a TREE_LIST it must be dependent. */
21002 /* These expressions are value-dependent if the type to which
21003 the cast occurs is dependent or the expression being casted
21004 is value-dependent. */
21005 {
21011 /* A functional cast has a list of operands. */
21014 {
21015 /* If there are no operands, it must be an expression such
21016 as "int()". This should not happen for aggregate types
21017 because it would form non-constant expressions. */
21022 }
21028 }
21033 /* FALLTHRU */
21036 /* A `sizeof' expression is value-dependent if the operand is
21037 type-dependent or is a pack expansion. */
21046 /* An 'encode' expression is value-dependent if the operand is
21047 type-dependent. */
21056 /* All instantiation-dependent expressions should also be considered
21057 value-dependent. */
21065 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21066 is value-dependent. */
21067 {
21076 }
21079 {
21083 }
21094 {
21098 }
21101 {
21108 {
21110 /* In a call to a constexpr member function, look through the
21111 implicit ADDR_EXPR on the object argument so that it doesn't
21112 cause the call to be considered value-dependent. We also
21113 look through it in potential_constant_expression. */
21120 }
21122 }
21125 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21126 type-dependent. */
21130 {
21132 tree val;
21137 }
21140 /* Treat a GNU statement expression as dependent to avoid crashing
21141 under fold_non_dependent_expr; it can't be constant. */
21145 /* A constant expression is value-dependent if any subexpression is
21146 value-dependent. */
21148 {
21155 {
21159 {
21162 /* In some cases, some of the operands may be missing.l
21163 (For example, in the case of PREDECREMENT_EXPR, the
21164 amount to increment by may be missing.) That doesn't
21165 make the expression dependent. */
21168 }
21169 }
21173 }
21175 }
21177 /* The expression is not value-dependent. */
21179 }
21181 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21182 [temp.dep.expr]. Note that an expression with no type is
21183 considered dependent. Other parts of the compiler arrange for an
21184 expression with type-dependent subexpressions to have no type, so
21185 this function doesn't have to be fully recursive. */
21187 bool
21189 {
21196 /* An unresolved name is always dependent. */
21202 /* Some expression forms are never type-dependent. */
21215 /* The types of these expressions depends only on the type to which
21216 the cast occurs. */
21225 /* The types of these expressions depends only on the type created
21226 by the expression. */
21229 {
21230 /* For NEW_EXPR tree nodes created inside a template, either
21231 the object type itself or a TREE_LIST may appear as the
21232 operand 1. */
21235 /* This is an array type. We need to check array dimensions
21236 as well. */
21238 || value_dependent_expression_p
21240 else
21242 }
21245 {
21249 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21250 contains an identifier associated by name lookup with one or more
21251 declarations declared with a dependent type, or...a
21252 nested-name-specifier or qualified-id that names a member of an
21253 unknown specialization. */
21256 }
21261 && (any_dependent_template_arguments_p
21273 {
21274 tree elt;
21278 {
21281 }
21283 }
21285 /* A static data member of the current instantiation with incomplete
21286 array type is type-dependent, as the definition and specializations
21287 can have different bounds. */
21294 /* An array of unknown bound depending on a variadic parameter, eg:
21296 template<typename... Args>
21297 void foo (Args... args)
21298 {
21299 int arr[] = { args... };
21300 }
21302 template<int... vals>
21303 void bar ()
21304 {
21305 int arr[] = { vals... };
21306 }
21308 If the array has no length and has an initializer, it must be that
21309 we couldn't determine its length in cp_complete_array_type because
21310 it is dependent. */
21318 {
21323 {
21329 }
21330 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21334 /* Always dependent, on the number of arguments if nothing else. */
21342 {
21347 }
21352 {
21356 }
21358 }
21363 }
21365 /* walk_tree callback function for instantiation_dependent_expression_p,
21366 below. Returns non-zero if a dependent subexpression is found. */
21368 static tree
21371 {
21373 {
21374 /* We don't have to worry about decltype currently because decltype
21375 of an instantiation-dependent expr is a dependent type. This
21376 might change depending on the resolution of DR 1172. */
21379 }
21382 {
21383 /* Don't treat an argument list as dependent just because it has no
21384 TREE_TYPE. */
21391 /* A constant with a dependent initializer is dependent. */
21399 /* Handle expressions with type operands. */
21404 {
21409 {
21412 else
21413 {
21416 }
21417 }
21419 }
21422 {
21430 }
21434 /* In a template, finish_class_member_access_expr creates a
21435 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21436 type-dependent, so that we can check access control at
21437 instantiation time (PR 42277). See also Core issue 1273. */
21444 else
21447 /* Treat statement-expressions as dependent. */
21453 }
21457 else
21459 }
21461 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21462 sense defined by the ABI:
21464 "An expression is instantiation-dependent if it is type-dependent
21465 or value-dependent, or it has a subexpression that is type-dependent
21466 or value-dependent." */
21468 bool
21470 {
21471 tree result;
21482 }
21484 /* Like type_dependent_expression_p, but it also works while not processing
21485 a template definition, i.e. during substitution or mangling. */
21487 bool
21489 {
21495 }
21497 /* Returns TRUE if ARGS contains a type-dependent expression. */
21499 bool
21501 {
21503 tree arg;
21506 {
21509 }
21511 }
21513 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21514 expressions) contains any type-dependent expressions. */
21516 bool
21518 {
21524 }
21526 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21527 expressions) contains any value-dependent expressions. */
21529 bool
21531 {
21537 }
21539 /* Returns TRUE if the ARG (a template argument) is dependent. */
21541 bool
21543 {
21547 /* Assume a template argument that was wrongly written by the user
21548 is dependent. This is consistent with what
21549 any_dependent_template_arguments_p [that calls this function]
21550 does. */
21561 {
21565 {
21568 }
21571 }
21574 else
21577 }
21579 /* Returns true if ARGS (a collection of template arguments) contains
21580 any types that require structural equality testing. */
21582 bool
21584 {
21594 {
21597 {
21603 {
21604 /* Look inside the argument pack. */
21607 }
21610 {
21623 }
21624 }
21625 }
21628 }
21630 /* Returns true if ARGS (a collection of template arguments) contains
21631 any dependent arguments. */
21633 bool
21635 {
21645 {
21650 }
21653 }
21655 /* Returns TRUE if the template TMPL is dependent. */
21657 bool
21659 {
21661 {
21663 {
21667 }
21669 }
21671 /* Template template parameters are dependent. */
21675 /* So are names that have not been looked up. */
21678 /* So are member templates of dependent classes. */
21682 }
21684 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21686 bool
21688 {
21691 }
21693 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21694 is dependent. */
21696 bool
21698 {
21705 {
21726 {
21730 }
21734 {
21738 {
21743 }
21744 }
21745 }
21748 }
21750 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21751 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21752 no such TYPE can be found. Note that this function peers inside
21753 uninstantiated templates and therefore should be used only in
21754 extremely limited situations. ONLY_CURRENT_P restricts this
21755 peering to the currently open classes hierarchy (which is required
21756 when comparing types). */
21758 tree
21760 {
21761 tree scope;
21762 tree name;
21763 tree decl;
21765 tree pushed_scope;
21766 tree result;
21771 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21772 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21773 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21774 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21775 identifier of the TYPENAME_TYPE anymore.
21776 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21777 TYPENAME_TYPE instead, we avoid messing up with a possible
21778 typedef variant case. */
21781 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21782 it first before we can figure out what NAME refers to. */
21784 {
21786 /* Given a class template A with a dependent base with nested type C,
21787 typedef typename A::C::C C will land us here, as trying to resolve
21788 the initial A::C leads to the local C typedef, which leads back to
21789 A::C::C. So we break the recursion now. */
21791 else
21793 }
21794 /* If we don't know what SCOPE refers to, then we cannot resolve the
21795 TYPENAME_TYPE. */
21798 /* If the SCOPE is a template type parameter, we have no way of
21799 resolving the name. */
21802 /* If the SCOPE is not the current instantiation, there's no reason
21803 to look inside it. */
21806 /* If this is a typedef, we don't want to look inside (c++/11987). */
21809 /* If SCOPE isn't the template itself, it will not have a valid
21810 TYPE_FIELDS list. */
21812 /* scope is either the template itself or a compatible instantiation
21813 like X<T>, so look up the name in the original template. */
21815 else
21816 /* scope is a partial instantiation, so we can't do the lookup or we
21817 will lose the template arguments. */
21819 /* Enter the SCOPE so that name lookup will be resolved as if we
21820 were in the class definition. In particular, SCOPE will no
21821 longer be considered a dependent type. */
21823 /* Look up the declaration. */
21825 tf_warning_or_error);
21829 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21830 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21835 {
21839 }
21842 {
21843 tree tmpl;
21844 tree args;
21845 /* Obtain the template and the arguments. */
21848 /* Instantiate the template. */
21854 }
21856 /* Leave the SCOPE. */
21860 /* If we failed to resolve it, return the original typename. */
21864 /* If lookup found a typename type, resolve that too. */
21866 {
21867 /* Ill-formed programs can cause infinite recursion here, so we
21868 must catch that. */
21872 }
21874 /* Qualify the resulting type. */
21880 }
21882 /* EXPR is an expression which is not type-dependent. Return a proxy
21883 for EXPR that can be used to compute the types of larger
21884 expressions containing EXPR. */
21886 tree
21888 {
21889 tree inner_expr;
21891 #ifdef ENABLE_CHECKING
21892 /* Try to get a constant value for all non-dependent expressions in
21893 order to expose bugs in *_dependent_expression_p and constexpr. */
21896 #endif
21898 /* Preserve OVERLOADs; the functions must be available to resolve
21899 types. */
21910 /* There is no need to return a proxy for a variable. */
21913 /* Preserve string constants; conversions from string constants to
21914 "char *" are allowed, even though normally a "const char *"
21915 cannot be used to initialize a "char *". */
21918 /* Preserve arithmetic constants, as an optimization -- there is no
21919 reason to create a new node. */
21922 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21923 There is at least one place where we want to know that a
21924 particular expression is a throw-expression: when checking a ?:
21925 expression, there are special rules if the second or third
21926 argument is a throw-expression. */
21930 /* Don't wrap an initializer list, we need to be able to look inside. */
21934 /* Don't wrap a dummy object, we need to be able to test for it. */
21953 /* If the type is unknown, it can't really be non-dependent */
21956 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21958 }
21960 /* ARGS is a vector of expressions as arguments to a function call.
21961 Replace the arguments with equivalent non-dependent expressions.
21962 This modifies ARGS in place. */
21964 void
21966 {
21968 tree arg;
21971 {
21975 }
21976 }
21978 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21979 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21980 parms. */
21982 static tree
21984 {
21997 }
21999 tree
22001 {
22003 }
22005 tree
22007 {
22009 }
22011 /* Given type ARG, return std::initializer_list<ARG>. */
22013 static tree
22015 {
22016 tree std_init_list = namespace_binding
22018 tree argvec;
22020 {
22024 }
22029 }
22031 /* Replace auto in TYPE with std::initializer_list<auto>. */
22033 static tree
22035 {
22042 }
22044 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22045 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22047 tree
22049 {
22050 tree targs;
22056 /* Defining a subset of type-dependent expressions that we can deduce
22057 from ahead of time isn't worth the trouble. */
22060 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22061 with either a new invented type template parameter U or, if the
22062 initializer is a braced-init-list (8.5.4), with
22063 std::initializer_list<U>. */
22071 {
22077 {
22080 }
22081 }
22082 else
22083 {
22094 {
22096 /* Try again at instantiation time. */
22099 /* If type is error_mark_node a diagnostic must have been
22100 emitted by now. Also, having a mention to '<type error>'
22101 in the diagnostic is not really useful to the user. */
22102 {
22106 else
22108 }
22110 }
22111 }
22113 /* If the list of declarators contains more than one declarator, the type
22114 of each declared variable is determined as described above. If the
22115 type deduced for the template parameter U is not the same in each
22116 deduction, the program is ill-formed. */
22119 {
22125 else
22129 }
22135 }
22137 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22138 result. */
22140 tree
22142 {
22143 tree argvec;
22150 /* For a late-specified return type in a template type-parameter, we
22151 need to add a dummy argument level for its parmlist. */
22152 argvec = add_to_template_args
22157 }
22159 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22160 'decltype(auto)'. */
22162 bool
22164 {
22169 else
22171 }
22173 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22174 a use of `auto'. Returns NULL_TREE otherwise. */
22176 tree
22178 {
22180 }
22182 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22183 'decltype(auto)' or a concept. */
22185 bool
22187 {
22189 }
22191 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22192 a concept identifier) iff TYPE contains a use of a generic type. Returns
22193 NULL_TREE otherwise. */
22195 tree
22197 {
22199 }
22202 /* For a given template T, return the vector of typedefs referenced
22203 in T for which access check is needed at T instantiation time.
22204 T is either a FUNCTION_DECL or a RECORD_TYPE.
22205 Those typedefs were added to T by the function
22206 append_type_to_template_for_access_check. */
22210 {
22211 tree ti;
22222 {
22227 }
22230 }
22232 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22233 tied to T. That list of typedefs will be access checked at
22234 T instantiation time.
22235 T is either a FUNCTION_DECL or a RECORD_TYPE.
22236 TYPE_DECL is a TYPE_DECL node representing a typedef.
22237 SCOPE is the scope through which TYPE_DECL is accessed.
22238 LOCATION is the location of the usage point of TYPE_DECL.
22240 This function is a subroutine of
22241 append_type_to_template_for_access_check. */
22243 static void
22245 tree type_decl,
22246 tree scope,
22247 location_t location)
22248 {
22249 qualified_typedef_usage_t typedef_usage;
22250 tree ti;
22257 && type_decl
22271 }
22273 /* Append TYPE_DECL to the template TEMPL.
22274 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22275 At TEMPL instanciation time, TYPE_DECL will be checked to see
22276 if it can be accessed through SCOPE.
22277 LOCATION is the location of the usage point of TYPE_DECL.
22279 e.g. consider the following code snippet:
22281 class C
22282 {
22283 typedef int myint;
22284 };
22286 template<class U> struct S
22287 {
22288 C::myint mi; // <-- usage point of the typedef C::myint
22289 };
22291 S<char> s;
22293 At S<char> instantiation time, we need to check the access of C::myint
22294 In other words, we need to check the access of the myint typedef through
22295 the C scope. For that purpose, this function will add the myint typedef
22296 and the scope C through which its being accessed to a list of typedefs
22297 tied to the template S. That list will be walked at template instantiation
22298 time and access check performed on each typedefs it contains.
22299 Note that this particular code snippet should yield an error because
22300 myint is private to C. */
22302 void
22304 tree type_decl,
22305 tree scope,
22306 location_t location)
22307 {
22313 /* Make sure we don't append the type to the template twice. */
22320 }
22322 /* Convert the generic type parameters in PARM that match the types given in the
22323 range [START_IDX, END_IDX) from the current_template_parms into generic type
22324 packs. */
22326 tree
22328 {
22339 {
22340 /* Create a distinct parameter pack type from the current parm and add it
22341 to the replacement args to tsubst below into the generic function
22342 parameter. */
22357 }
22363 /* If there are more levels then build up the replacement with the outer
22364 template parms. */
22368 replacement);
22371 }
22374 /* Set up the hash tables for template instantiations. */
22376 void
22378 {
22380 hash_specialization,
22381 eq_specializations,
22382 ggc_free);
22384 hash_specialization,
22385 eq_specializations,
22386 ggc_free);
22387 }
22389 /* Print stats about the template hash tables for -fstats. */
22391 void
22393 {
22402 }