| blob | 7561d3fc9246bfbdc4fe1f79b443b02181feab2c |
1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
6 Rewritten by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 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 /* A map from local variable declarations in the body of the template
82 presently being instantiated to the corresponding instantiated
83 local variables. */
87 {
88 tree tmpl;
89 tree args;
90 tree spec;
94 htab_t decl_specializations;
97 htab_t type_specializations;
99 /* Contains canonical template parameter types. The vector is indexed by
100 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
101 TREE_LIST, whose TREE_VALUEs contain the canonical template
102 parameters of various types and levels. */
105 #define UNIFY_ALLOW_NONE 0
106 #define UNIFY_ALLOW_MORE_CV_QUAL 1
107 #define UNIFY_ALLOW_LESS_CV_QUAL 2
108 #define UNIFY_ALLOW_DERIVED 4
109 #define UNIFY_ALLOW_INTEGER 8
110 #define UNIFY_ALLOW_OUTER_LEVEL 16
111 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
112 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
132 tree);
192 location_t);
197 /* Make the current scope suitable for access checking when we are
198 processing T. T can be FUNCTION_DECL for instantiated function
199 template, or VAR_DECL for static member variable (need by
200 instantiate_decl). */
202 static void
204 {
212 else
216 {
217 saved_access_scope = tree_cons
220 }
221 }
223 /* Restore the scope set up by push_access_scope. T is the node we
224 are processing. */
226 static void
228 {
230 {
233 }
237 else
239 }
241 /* Do any processing required when DECL (a member template
242 declaration) is finished. Returns the TEMPLATE_DECL corresponding
243 to DECL, unless it is a specialization, in which case the DECL
244 itself is returned. */
246 tree
248 {
255 {
256 tree type;
264 {
268 }
270 }
274 {
276 {
279 }
280 else
282 }
283 else
287 }
289 /* Create a template info node. */
291 tree
293 {
298 }
300 /* Return the template info node corresponding to T, whatever T is. */
302 tree
304 {
322 }
324 /* Returns the template nesting level of the indicated class TYPE.
326 For example, in:
327 template <class T>
328 struct A
329 {
330 template <class U>
331 struct B {};
332 };
334 A<T>::B<U> has depth two, while A<T> has depth one.
335 Both A<T>::B<int> and A<int>::B<U> have depth one, if
336 they are instantiations, not specializations.
338 This function is guaranteed to return 0 if passed NULL_TREE so
339 that, for example, `template_class_depth (current_class_type)' is
340 always safe. */
342 int
344 {
351 {
357 }
360 }
362 /* Subroutine of maybe_begin_member_template_processing.
363 Returns true if processing DECL needs us to push template parms. */
365 static bool
367 {
373 }
375 /* Subroutine of maybe_begin_member_template_processing.
376 Push the template parms in PARMS, starting from LEVELS steps into the
377 chain, and ending at the beginning, since template parms are listed
378 innermost first. */
380 static void
382 {
390 current_template_parms
396 NULL);
398 {
407 {
414 {
415 /* Make a CONST_DECL as is done in process_template_parm.
416 It is ugly that we recreate this here; the original
417 version built in process_template_parm is no longer
418 available. */
428 }
433 }
434 }
435 }
437 /* Restore the template parameter context for a member template or
438 a friend template defined in a class definition. */
440 void
442 {
443 tree parms;
447 {
452 {
455 }
458 }
460 /* Remember how many levels of template parameters we pushed so that
461 we can pop them later. */
463 }
465 /* Undo the effects of maybe_begin_member_template_processing. */
467 void
469 {
478 {
482 }
483 }
485 /* Return a new template argument vector which contains all of ARGS,
486 but has as its innermost set of arguments the EXTRA_ARGS. */
488 static tree
490 {
491 tree new_args;
509 }
511 /* Like add_to_template_args, but only the outermost ARGS are added to
512 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
513 (EXTRA_ARGS) levels are added. This function is used to combine
514 the template arguments from a partial instantiation with the
515 template arguments used to attain the full instantiation from the
516 partial instantiation. */
518 static tree
520 {
521 tree new_args;
523 /* If there are more levels of EXTRA_ARGS than there are ARGS,
524 something very fishy is going on. */
527 /* If *all* the new arguments will be the EXTRA_ARGS, just return
528 them. */
532 /* For the moment, we make ARGS look like it contains fewer levels. */
537 /* Now, we restore ARGS to its full dimensions. */
541 }
543 /* Return the N levels of innermost template arguments from the ARGS. */
545 tree
547 {
548 tree new_args;
554 /* If N is 1, just return the innermost set of template arguments. */
558 /* If we're not removing anything, just return the arguments we were
559 given. */
565 /* Make a new set of arguments, not containing the outer arguments. */
572 }
574 /* The inverse of get_innermost_template_args: Return all but the innermost
575 EXTRA_LEVELS levels of template arguments from the ARGS. */
577 static tree
579 {
580 tree new_args;
586 /* If N is 1, just return the outermost set of template arguments. */
590 /* If we're not removing anything, just return the arguments we were
591 given. */
596 /* Make a new set of arguments, not containing the inner arguments. */
603 }
605 /* We've got a template header coming up; push to a new level for storing
606 the parms. */
608 void
610 {
611 /* We use a non-tag-transparent scope here, which causes pushtag to
612 put tags in this scope, rather than in the enclosing class or
613 namespace scope. This is the right thing, since we want
614 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
615 global template class, push_template_decl handles putting the
616 TEMPLATE_DECL into top-level scope. For a nested template class,
617 e.g.:
619 template <class T> struct S1 {
620 template <class T> struct S2 {};
621 };
623 pushtag contains special code to call pushdecl_with_scope on the
624 TEMPLATE_DECL for S2. */
629 }
631 /* This routine is called when a specialization is declared. If it is
632 invalid to declare a specialization here, an error is reported and
633 false is returned, otherwise this routine will return true. */
635 static bool
637 {
640 /* [temp.expl.spec]
642 An explicit specialization shall be declared in the namespace of
643 which the template is a member, or, for member templates, in the
644 namespace of which the enclosing class or enclosing class
645 template is a member. An explicit specialization of a member
646 function, member class or static data member of a class template
647 shall be declared in the namespace of which the class template
648 is a member. */
650 {
653 }
655 /* [temp.expl.spec]
657 In an explicit specialization declaration for a member of a class
658 template or a member template that appears in namespace scope,
659 the member template and some of its enclosing class templates may
660 remain unspecialized, except that the declaration shall not
661 explicitly specialize a class member template if its enclosing
662 class templates are not explicitly specialized as well. */
664 {
667 }
670 }
672 /* We've just seen template <>. */
674 bool
676 {
680 }
682 /* Called at then end of processing a declaration preceded by
683 template<>. */
685 void
687 {
690 }
692 /* Any template <>'s that we have seen thus far are not referring to a
693 function specialization. */
695 void
697 {
700 }
702 /* We've just seen a template header. If SPECIALIZATION is nonzero,
703 it was of the form template <>. */
705 static void
707 {
709 template_header_count++;
710 }
712 /* We're beginning an explicit instantiation. */
714 void
716 {
719 }
722 void
724 {
727 }
729 /* An explicit specialization or partial specialization TMPL is being
730 declared. Check that the namespace in which the specialization is
731 occurring is permissible. Returns false iff it is invalid to
732 specialize TMPL in the current namespace. */
734 static bool
736 {
739 /* [tmpl.expl.spec]
741 An explicit specialization shall be declared in the namespace of
742 which the template is a member, or, for member templates, in the
743 namespace of which the enclosing class or enclosing class
744 template is a member. An explicit specialization of a member
745 function, member class or static data member of a class template
746 shall be declared in the namespace of which the class template is
747 a member. */
750 {
753 }
755 /* Same or super-using namespace. */
757 else
758 {
762 }
763 }
765 /* SPEC is an explicit instantiation. Check that it is valid to
766 perform this explicit instantiation in the current namespace. */
768 static void
770 {
771 tree ns;
773 /* DR 275: An explicit instantiation shall appear in an enclosing
774 namespace of its template. */
780 }
782 /* The TYPE is being declared. If it is a template type, that means it
783 is a partial specialization. Do appropriate error-checking. */
785 tree
787 {
788 tree context;
794 {
798 }
803 {
804 /* This is for ordinary explicit specialization and partial
805 specialization of a template class such as:
807 template <> class C<int>;
809 or:
811 template <class T> class C<T*>;
813 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
817 {
821 {
825 }
826 }
829 }
835 {
836 /* This is for an explicit specialization of member class
837 template according to [temp.expl.spec/18]:
839 template <> template <class U> class C<int>::D;
841 The context `C<int>' must be an implicit instantiation.
842 Otherwise this is just a member class template declared
843 earlier like:
845 template <> class C<int> { template <class U> class D; };
846 template <> template <class U> class C<int>::D;
848 In the first case, `C<int>::D' is a specialization of `C<T>::D'
849 while in the second case, `C<int>::D' is a primary template
850 and `C<T>::D' may not exist. */
854 {
855 tree t;
860 {
863 }
865 /* Check for invalid specialization after instantiation:
867 template <> template <> class C<int>::D<int>;
868 template <> template <class U> class C<int>::D; */
872 {
875 {
876 /* We already have a full specialization of this partial
877 instantiation. Reassign it to the new member
878 specialization template. */
879 spec_entry elt;
895 }
897 /* But if we've had an implicit instantiation, that's a
898 problem ([temp.expl.spec]/6). */
901 }
903 /* Mark TYPE as a specialization. And as a result, we only
904 have one level of template argument for the innermost
905 class template. */
909 }
910 }
912 {
915 }
918 }
920 /* Returns nonzero if we can optimize the retrieval of specializations
921 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
922 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
926 {
929 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
930 parameter. */
932 /* The optimized lookup depends on the fact that the
933 template arguments for the member function template apply
934 purely to the containing class, which is not true if the
935 containing class is an explicit or partial
936 specialization. */
940 /* It is possible to have a template that is not a member
941 template and is not a member of a template class:
943 template <typename T>
944 struct S { friend A::f(); };
946 Here, the friend function is a template, but the context does
947 not have template information. The optimized lookup relies
948 on having ARGS be the template arguments for both the class
949 and the function template. */
951 }
953 /* Retrieve the specialization (in the sense of [temp.spec] - a
954 specialization is either an instantiation or an explicit
955 specialization) of TMPL for the given template ARGS. If there is
956 no such specialization, return NULL_TREE. The ARGS are a vector of
957 arguments, or a vector of vectors of arguments, in the case of
958 templates with more than one level of parameters.
960 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
961 then we search for a partial specialization matching ARGS. This
962 parameter is ignored if TMPL is not a class template. */
964 static tree
966 {
972 /* There should be as many levels of arguments as there are
973 levels of parameters. */
978 {
979 tree class_template;
980 tree class_specialization;
982 tree fns;
985 /* The template arguments actually apply to the containing
986 class. Find the class specialization with those
987 arguments. */
989 class_specialization
993 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
994 for the specialization. */
998 /* Iterate through the methods with the indicated name, looking
999 for the one that has an instance of TMPL. */
1002 {
1005 /* using-declarations can add base methods to the method vec,
1006 and we don't want those here. */
1009 }
1011 }
1012 else
1013 {
1015 spec_entry elt;
1016 htab_t specializations;
1024 else
1032 }
1035 }
1037 /* Like retrieve_specialization, but for local declarations. */
1039 static tree
1041 {
1042 tree spec;
1050 }
1052 /* Returns nonzero iff DECL is a specialization of TMPL. */
1054 int
1056 {
1057 tree t;
1060 {
1066 }
1067 else
1068 {
1077 }
1080 }
1082 /* Returns nonzero iff DECL is a specialization of friend declaration
1083 FRIEND_DECL according to [temp.friend]. */
1085 bool
1087 {
1094 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1095 of a template class, we want to check if DECL is a specialization
1096 if this. */
1100 {
1101 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1104 }
1109 /* There is nothing to do if this is not a template friend. */
1116 /* [temp.friend/6]
1117 A member of a class template may be declared to be a friend of a
1118 non-template class. In this case, the corresponding member of
1119 every specialization of the class template is a friend of the
1120 class granting friendship.
1122 For example, given a template friend declaration
1124 template <class T> friend void A<T>::f();
1126 the member function below is considered a friend
1128 template <> struct A<int> {
1129 void f();
1130 };
1132 For this type of template friend, TEMPLATE_DEPTH below will be
1133 nonzero. To determine if DECL is a friend of FRIEND, we first
1134 check if the enclosing class is a specialization of another. */
1141 {
1142 /* Next, we check the members themselves. In order to handle
1143 a few tricky cases, such as when FRIEND_DECL's are
1145 template <class T> friend void A<T>::g(T t);
1146 template <class T> template <T t> friend void A<T>::h();
1148 and DECL's are
1150 void A<int>::g(int);
1151 template <int> void A<int>::h();
1153 we need to figure out ARGS, the template arguments from
1154 the context of DECL. This is required for template substitution
1155 of `T' in the function parameter of `g' and template parameter
1156 of `h' in the above examples. Here ARGS corresponds to `int'. */
1163 {
1165 {
1168 else
1170 current_depth++;
1171 }
1173 }
1176 {
1178 tree friend_type;
1179 tree decl_type;
1180 tree friend_args_type;
1181 tree decl_args_type;
1183 /* Make sure that both DECL and FRIEND_DECL are templates or
1184 non-templates. */
1190 {
1191 /* If both are templates, check template parameter list. */
1192 tree friend_parms
1197 friend_parms))
1201 }
1202 else
1210 /* Check if return types match. */
1214 /* Check if function parameter types match, ignoring the
1215 `this' parameter. */
1224 }
1225 else
1226 {
1227 /* DECL is a TYPE_DECL */
1231 /* Make sure that both DECL and FRIEND_DECL are templates or
1232 non-templates. */
1233 is_template
1240 {
1241 tree friend_parms;
1242 /* If both are templates, check the name of the two
1243 TEMPLATE_DECL's first because is_friend didn't. */
1248 /* Now check template parameter list. */
1249 friend_parms
1252 return comp_template_parms
1254 friend_parms);
1255 }
1256 else
1259 }
1260 }
1262 }
1264 /* Register the specialization SPEC as a specialization of TMPL with
1265 the indicated ARGS. IS_FRIEND indicates whether the specialization
1266 is actually just a friend declaration. Returns SPEC, or an
1267 equivalent prior declaration, if available. */
1269 static tree
1271 hashval_t hash)
1272 {
1273 tree fn;
1275 spec_entry elt;
1281 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1282 register it; we want the corresponding TEMPLATE_DECL instead.
1283 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1284 the more obvious `uses_template_parms (spec)' to avoid problems
1285 with default function arguments. In particular, given
1286 something like this:
1288 template <class T> void f(T t1, T t = T())
1290 the default argument expression is not substituted for in an
1291 instantiation unless and until it is actually needed. */
1295 /* We don't put these specializations in the hash table, but we might
1296 want to give an error about a mismatch. */
1298 else
1299 {
1311 else
1313 }
1315 /* We can sometimes try to re-register a specialization that we've
1316 already got. In particular, regenerate_decl_from_template calls
1317 duplicate_decls which will update the specialization list. But,
1318 we'll still get called again here anyhow. It's more convenient
1319 to simply allow this than to try to prevent it. */
1323 {
1325 {
1328 {
1330 fn);
1332 }
1333 else
1334 {
1335 tree clone;
1336 /* This situation should occur only if the first
1337 specialization is an implicit instantiation, the
1338 second is an explicit specialization, and the
1339 implicit instantiation has not yet been used. That
1340 situation can occur if we have implicitly
1341 instantiated a member function and then specialized
1342 it later.
1344 We can also wind up here if a friend declaration that
1345 looked like an instantiation turns out to be a
1346 specialization:
1348 template <class T> void foo(T);
1349 class S { friend void foo<>(int) };
1350 template <> void foo(int);
1352 We transform the existing DECL in place so that any
1353 pointers to it become pointers to the updated
1354 declaration.
1356 If there was a definition for the template, but not
1357 for the specialization, we want this to look as if
1358 there were no definition, and vice versa. */
1361 /* The call to duplicate_decls will have applied
1362 [temp.expl.spec]:
1364 An explicit specialization of a function template
1365 is inline only if it is explicitly declared to be,
1366 and independently of whether its function template
1367 is.
1369 to the primary function; now copy the inline bits to
1370 the various clones. */
1372 {
1377 }
1381 }
1382 }
1384 {
1386 /* Dup decl failed, but this is a new definition. Set the
1387 line number so any errors match this new
1388 definition. */
1392 }
1393 }
1397 /* A specialization must be declared in the same namespace as the
1398 template it is specializing. */
1404 {
1411 /* TMPL is a forward declaration of a template function; keep a list
1412 of all specializations in case we need to reassign them to a friend
1413 template later in tsubst_friend_function. */
1416 }
1419 }
1421 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1422 TMPL and ARGS members, ignores SPEC. */
1424 static int
1426 {
1432 }
1434 /* Returns a hash for a template TMPL and template arguments ARGS. */
1436 static hashval_t
1438 {
1441 }
1443 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1444 ignoring SPEC. */
1446 static hashval_t
1448 {
1451 }
1453 /* Recursively calculate a hash value for a template argument ARG, for use
1454 in the hash tables of template specializations. */
1456 static hashval_t
1458 {
1470 /* We can get one of these when re-hashing a previous entry in the middle
1471 of substituting into a pack expansion. Just look through it. */
1480 {
1488 {
1493 }
1514 {
1517 {
1520 }
1522 }
1537 val = iterative_hash_template_arg
1549 val);
1551 val);
1560 /* layout_type sets structural equality for arrays of
1561 incomplete type, so we can't rely on the canonical type
1562 for hashing. */
1567 /* A lambda can't appear in a template arg, but don't crash on
1568 erroneous input. */
1574 {
1578 val);
1581 /* Otherwise just compare the types during lookup. */
1590 {
1595 }
1596 }
1597 }
1600 }
1602 /* Unregister the specialization SPEC as a specialization of TMPL.
1603 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1604 if the SPEC was listed as a specialization of TMPL.
1606 Note that SPEC has been ggc_freed, so we can't look inside it. */
1608 bool
1610 {
1612 spec_entry elt;
1620 {
1625 }
1628 }
1630 /* Compare an entry in the local specializations hash table P1 (which
1631 is really a pointer to a TREE_LIST) with P2 (which is really a
1632 DECL). */
1634 static int
1636 {
1638 }
1640 /* Hash P1, an entry in the local specializations table. */
1642 static hashval_t
1644 {
1646 }
1648 /* Like register_specialization, but for local declarations. We are
1649 registering SPEC, an instantiation of TMPL. */
1651 static void
1653 {
1659 }
1661 /* TYPE is a class type. Returns true if TYPE is an explicitly
1662 specialized class. */
1664 bool
1666 {
1670 }
1672 /* Print the list of functions at FNS, going through all the overloads
1673 for each element of the list. Alternatively, FNS can not be a
1674 TREE_LIST, in which case it will be printed together with all the
1675 overloads.
1677 MORE and *STR should respectively be FALSE and NULL when the function
1678 is called from the outside. They are used internally on recursive
1679 calls. print_candidates manages the two parameters and leaves NULL
1680 in *STR when it ends. */
1682 static void
1684 {
1690 {
1695 }
1696 else
1697 {
1699 {
1700 /* Pick the prefix string. */
1702 {
1705 }
1709 }
1712 }
1715 {
1718 }
1719 }
1721 /* Print the list of candidate FNS in an error message. */
1723 void
1725 {
1729 }
1731 /* Returns the template (one of the functions given by TEMPLATE_ID)
1732 which can be specialized to match the indicated DECL with the
1733 explicit template args given in TEMPLATE_ID. The DECL may be
1734 NULL_TREE if none is available. In that case, the functions in
1735 TEMPLATE_ID are non-members.
1737 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1738 specialization of a member template.
1740 The TEMPLATE_COUNT is the number of references to qualifying
1741 template classes that appeared in the name of the function. See
1742 check_explicit_specialization for a more accurate description.
1744 TSK indicates what kind of template declaration (if any) is being
1745 declared. TSK_TEMPLATE indicates that the declaration given by
1746 DECL, though a FUNCTION_DECL, has template parameters, and is
1747 therefore a template function.
1749 The template args (those explicitly specified and those deduced)
1750 are output in a newly created vector *TARGS_OUT.
1752 If it is impossible to determine the result, an error message is
1753 issued. The error_mark_node is returned to indicate failure. */
1755 static tree
1757 tree decl,
1761 tmpl_spec_kind tsk)
1762 {
1763 tree fns;
1764 tree targs;
1765 tree explicit_targs;
1767 /* A TREE_LIST of templates of which DECL may be a specialization.
1768 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1769 corresponding TREE_PURPOSE is the set of template arguments that,
1770 when used to instantiate the template, would produce a function
1771 with the signature of DECL. */
1787 /* Check for baselinks. */
1792 {
1795 }
1797 /* Count the number of template headers specified for this
1798 specialization. */
1806 {
1810 {
1811 tree decl_arg_types;
1812 tree fn_arg_types;
1814 /* In case of explicit specialization, we need to check if
1815 the number of template headers appearing in the specialization
1816 is correct. This is usually done in check_explicit_specialization,
1817 but the check done there cannot be exhaustive when specializing
1818 member functions. Consider the following code:
1820 template <> void A<int>::f(int);
1821 template <> template <> void A<int>::f(int);
1823 Assuming that A<int> is not itself an explicit specialization
1824 already, the first line specializes "f" which is a non-template
1825 member function, whilst the second line specializes "f" which
1826 is a template member function. So both lines are syntactically
1827 correct, and check_explicit_specialization does not reject
1828 them.
1830 Here, we can do better, as we are matching the specialization
1831 against the declarations. We count the number of template
1832 headers, and we check if they match TEMPLATE_COUNT + 1
1833 (TEMPLATE_COUNT is the number of qualifying template classes,
1834 plus there must be another header for the member template
1835 itself).
1837 Notice that if header_count is zero, this is not a
1838 specialization but rather a template instantiation, so there
1839 is no check we can perform here. */
1843 /* Check that the number of template arguments at the
1844 innermost level for DECL is the same as for FN. */
1852 /* DECL might be a specialization of FN. */
1856 /* For a non-static member function, we need to make sure
1857 that the const qualification is the same. Since
1858 get_bindings does not try to merge the "this" parameter,
1859 we must do the comparison explicitly. */
1865 /* Skip the "this" parameter and, for constructors of
1866 classes with virtual bases, the VTT parameter. A
1867 full specialization of a constructor will have a VTT
1868 parameter, but a template never will. */
1869 decl_arg_types
1871 fn_arg_types
1874 /* Check that the number of function parameters matches.
1875 For example,
1876 template <class T> void f(int i = 0);
1877 template <> void f<int>();
1878 The specialization f<int> is invalid but is not caught
1879 by get_bindings below. */
1883 /* Function templates cannot be specializations; there are
1884 no partial specializations of functions. Therefore, if
1885 the type of DECL does not match FN, there is no
1886 match. */
1888 {
1892 }
1894 /* See whether this function might be a specialization of this
1895 template. */
1899 /* We cannot deduce template arguments that when used to
1900 specialize TMPL will produce DECL. */
1903 /* Save this template, and the arguments deduced. */
1905 }
1907 /* FN is an ordinary member function, and we need a
1908 specialization of a member template. */
1909 ;
1911 /* We can get IDENTIFIER_NODEs here in certain erroneous
1912 cases. */
1913 ;
1915 /* This is just an ordinary non-member function. Nothing can
1916 be a specialization of that. */
1917 ;
1919 /* Cannot specialize functions that are created implicitly. */
1920 ;
1921 else
1922 {
1923 tree decl_arg_types;
1925 /* This is an ordinary member function. However, since
1926 we're here, we can assume it's enclosing class is a
1927 template class. For example,
1929 template <typename T> struct S { void f(); };
1930 template <> void S<int>::f() {}
1932 Here, S<int>::f is a non-template, but S<int> is a
1933 template class. If FN has the same type as DECL, we
1934 might be in business. */
1937 /* Its enclosing class is an explicit specialization
1938 of a template class. This is not a candidate. */
1943 /* The return types differ. */
1946 /* Adjust the type of DECL in case FN is a static member. */
1953 decl_arg_types))
1954 /* They match! */
1956 }
1957 }
1960 {
1961 /* We have:
1963 [temp.expl.spec]
1965 It is possible for a specialization with a given function
1966 signature to be instantiated from more than one function
1967 template. In such cases, explicit specification of the
1968 template arguments must be used to uniquely identify the
1969 function template specialization being specialized.
1971 Note that here, there's no suggestion that we're supposed to
1972 determine which of the candidate templates is most
1973 specialized. However, we, also have:
1975 [temp.func.order]
1977 Partial ordering of overloaded function template
1978 declarations is used in the following contexts to select
1979 the function template to which a function template
1980 specialization refers:
1982 -- when an explicit specialization refers to a function
1983 template.
1985 So, we do use the partial ordering rules, at least for now.
1986 This extension can only serve to make invalid programs valid,
1987 so it's safe. And, there is strong anecdotal evidence that
1988 the committee intended the partial ordering rules to apply;
1989 the EDG front end has that behavior, and John Spicer claims
1990 that the committee simply forgot to delete the wording in
1991 [temp.expl.spec]. */
1994 {
1997 }
1998 }
2001 {
2009 }
2013 {
2019 }
2021 /* We have one, and exactly one, match. */
2023 {
2026 /* DECL is a re-declaration or partial instantiation of a template
2027 function. */
2030 /* It was a specialization of an ordinary member function in a
2031 template class. */
2033 }
2035 /* It was a specialization of a template. */
2038 {
2043 }
2044 else
2047 }
2049 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2050 but with the default argument values filled in from those in the
2051 TMPL_TYPES. */
2053 static tree
2055 tree tmpl_types)
2056 {
2057 tree new_spec_types;
2065 /* Substitute into the rest of the list. */
2066 new_spec_types =
2070 /* Add the default argument for this parameter. */
2073 new_spec_types);
2074 }
2076 /* DECL is an explicit specialization. Replicate default arguments
2077 from the template it specializes. (That way, code like:
2079 template <class T> void f(T = 3);
2080 template <> void f(double);
2081 void g () { f (); }
2083 works, as required.) An alternative approach would be to look up
2084 the correct default arguments at the call-site, but this approach
2085 is consistent with how implicit instantiations are handled. */
2087 static void
2089 {
2090 tree tmpl;
2091 tree spec_types;
2092 tree tmpl_types;
2093 tree new_spec_types;
2094 tree old_type;
2095 tree new_type;
2096 tree t;
2101 /* See if there's anything we need to do. */
2114 {
2115 /* Remove the this pointer, but remember the object's type for
2116 CV quals. */
2122 {
2123 /* DECL may contain more parameters than TMPL due to the extra
2124 in-charge parameter in constructors and destructors. */
2127 }
2129 {
2132 }
2133 }
2135 /* Compute the merged default arguments. */
2136 new_spec_types =
2139 /* Compute the new FUNCTION_TYPE. */
2141 {
2145 new_spec_types);
2148 /* Put the in-charge parameter back. */
2151 new_spec_types);
2155 new_spec_types);
2156 }
2157 else
2159 new_spec_types);
2165 }
2167 /* Check to see if the function just declared, as indicated in
2168 DECLARATOR, and in DECL, is a specialization of a function
2169 template. We may also discover that the declaration is an explicit
2170 instantiation at this point.
2172 Returns DECL, or an equivalent declaration that should be used
2173 instead if all goes well. Issues an error message if something is
2174 amiss. Returns error_mark_node if the error is not easily
2175 recoverable.
2177 FLAGS is a bitmask consisting of the following flags:
2179 2: The function has a definition.
2180 4: The function is a friend.
2182 The TEMPLATE_COUNT is the number of references to qualifying
2183 template classes that appeared in the name of the function. For
2184 example, in
2186 template <class T> struct S { void f(); };
2187 void S<int>::f();
2189 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2190 classes are not counted in the TEMPLATE_COUNT, so that in
2192 template <class T> struct S {};
2193 template <> struct S<int> { void f(); }
2194 template <> void S<int>::f();
2196 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2197 invalid; there should be no template <>.)
2199 If the function is a specialization, it is marked as such via
2200 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2201 is set up correctly, and it is added to the list of specializations
2202 for that template. */
2204 tree
2206 tree decl,
2209 {
2217 tmpl_spec_kind tsk;
2220 {
2223 else
2225 }
2226 else
2230 {
2233 {
2236 }
2238 {
2240 /* This could be something like:
2242 template <class T> void f(T);
2243 class S { friend void f<>(int); } */
2245 else
2246 {
2247 /* This case handles bogus declarations like template <>
2248 template <class T> void f<int>(); */
2251 declarator);
2253 }
2254 }
2258 /* The error has already been reported in
2259 check_specialization_scope. */
2265 /* Fall through. */
2278 decl);
2281 else
2285 /* Fall through. */
2290 else
2296 {
2297 /* This case handles bogus declarations like template <>
2298 template <class T> void f<int>(); */
2303 else
2305 declarator);
2307 }
2310 /* This is a specialization of a member template, without
2311 specialization the containing class. Something like:
2313 template <class T> struct S {
2314 template <class U> void f (U);
2315 };
2316 template <> template <class U> void S<int>::f(U) {}
2318 That's a specialization -- but of the entire template. */
2324 }
2327 {
2331 {
2335 }
2336 }
2339 {
2343 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2345 {
2346 tree fns;
2351 else
2352 {
2353 /* If there is no class context, the explicit instantiation
2354 must be at namespace scope. */
2357 /* Find the namespace binding, using the declaration
2358 context. */
2362 {
2365 }
2366 else
2367 {
2373 }
2374 }
2377 }
2383 {
2385 /* A specialization in class scope. This is invalid,
2386 but the error will already have been flagged by
2387 check_specialization_scope. */
2389 else
2390 {
2391 /* It's not valid to write an explicit instantiation in
2392 class scope, e.g.:
2394 class C { template void f(); }
2396 This case is caught by the parser. However, on
2397 something like:
2399 template class C { void f(); };
2401 (which is invalid) we can get here. The error will be
2402 issued later. */
2403 ;
2404 }
2407 }
2410 IDENTIFIER_NODE))
2411 {
2412 /* Find the list of functions in ctype that have the same
2413 name as the declared function. */
2419 {
2424 {
2425 /* From [temp.expl.spec]:
2427 If such an explicit specialization for the member
2428 of a class template names an implicitly-declared
2429 special member function (clause _special_), the
2430 program is ill-formed.
2432 Similar language is found in [temp.explicit]. */
2435 }
2438 }
2441 {
2445 }
2446 else
2447 {
2449 tree ovl;
2451 /* For a type-conversion operator, we cannot do a
2452 name-based lookup. We might be looking for `operator
2453 int' which will be a specialization of `operator T'.
2454 So, we find *all* the conversion operators, and then
2455 select from them. */
2463 {
2465 /* There are no more conversion functions. */
2468 /* Glue all these conversion functions together
2469 with those we already have. */
2472 }
2473 }
2476 {
2479 }
2480 else
2482 }
2484 /* Figure out what exactly is being specialized at this point.
2485 Note that for an explicit instantiation, even one for a
2486 member function, we cannot tell apriori whether the
2487 instantiation is for a member template, or just a member
2488 function of a template class. Even if a member template is
2489 being instantiated, the member template arguments may be
2490 elided if they can be deduced from the rest of the
2491 declaration. */
2494 member_specialization,
2495 template_count,
2496 tsk);
2499 /* We couldn't figure out what this declaration was
2500 specializing. */
2502 else
2503 {
2507 {
2508 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2509 is done by do_decl_instantiation later. */
2515 {
2516 /* If TMPL is not the most general template (for
2517 example, if TMPL is a friend template that is
2518 injected into namespace scope), then there will
2519 be too many levels of TARGS. Remove some of them
2520 here. */
2522 tree new_targs;
2529 }
2532 }
2534 /* If we thought that the DECL was a member function, but it
2535 turns out to be specializing a static member function,
2536 make DECL a static member function as well. */
2541 /* If this is a specialization of a member template of a
2542 template class, we want to return the TEMPLATE_DECL, not
2543 the specialization of it. */
2545 {
2550 {
2551 tree parm;
2555 /* We want to use the argument list specified in the
2556 definition, not in the original declaration. */
2561 }
2564 }
2566 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2569 /* Inherit default function arguments from the template
2570 DECL is specializing. */
2573 /* This specialization has the same protection as the
2574 template it specializes. */
2578 /* 7.1.1-1 [dcl.stc]
2580 A storage-class-specifier shall not be specified in an
2581 explicit specialization...
2583 The parser rejects these, so unless action is taken here,
2584 explicit function specializations will always appear with
2585 global linkage.
2587 The action recommended by the C++ CWG in response to C++
2588 defect report 605 is to make the storage class and linkage
2589 of the explicit specialization match the templated function:
2591 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2592 */
2594 {
2598 /* This specialization has the same linkage and visibility as
2599 the function template it specializes. */
2602 {
2605 }
2608 {
2611 }
2612 }
2614 /* If DECL is a friend declaration, declared using an
2615 unqualified name, the namespace associated with DECL may
2616 have been set incorrectly. For example, in:
2618 template <typename T> void f(T);
2619 namespace N {
2620 struct S { friend void f<int>(int); }
2621 }
2623 we will have set the DECL_CONTEXT for the friend
2624 declaration to N, rather than to the global namespace. */
2629 /* This is not really a declaration of a specialization.
2630 It's just the name of an instantiation. But, it's not
2631 a request for an instantiation, either. */
2634 /* This is indeed a specialization. In case of constructors
2635 and destructors, we need in-charge and not-in-charge
2636 versions in V3 ABI. */
2639 /* Register this specialization so that we can find it
2640 again. */
2642 }
2643 }
2646 }
2648 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2649 parameters. These are represented in the same format used for
2650 DECL_TEMPLATE_PARMS. */
2652 int
2654 {
2655 const_tree p1;
2656 const_tree p2;
2664 {
2676 {
2680 /* If either of the template parameters are invalid, assume
2681 they match for the sake of error recovery. */
2694 }
2695 }
2698 /* One set of parameters has more parameters lists than the
2699 other. */
2703 }
2705 /* Determine whether PARM is a parameter pack. */
2707 bool
2709 {
2710 /* Determine if we have a non-type template parameter pack. */
2715 /* If this is a list of template parameters, we could get a
2716 TYPE_DECL or a TEMPLATE_DECL. */
2723 }
2725 /* Determine if T is a function parameter pack. */
2727 bool
2729 {
2733 }
2735 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2736 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2738 tree
2740 {
2747 }
2749 /* Return true iff the function parameter PARAM_DECL was expanded
2750 from the function parameter pack PACK. */
2752 bool
2754 {
2759 /* The parameter pack and its pack arguments have the same
2760 DECL_PARM_INDEX. */
2762 }
2764 /* Determine whether ARGS describes a variadic template args list,
2765 i.e., one that is terminated by a template argument pack. */
2767 static bool
2769 {
2771 tree last_parm;
2785 }
2787 /* Generate a new name for the parameter pack name NAME (an
2788 IDENTIFIER_NODE) that incorporates its */
2790 static tree
2792 {
2793 /* Munge the name to include the parameter index. */
2794 #define NUMBUF_LEN 128
2806 }
2808 /* Return true if T is a primary function
2809 or class template instantiation. */
2811 bool
2813 {
2825 }
2827 /* Return true if PARM is a template template parameter. */
2829 bool
2831 {
2833 }
2835 /* Return the template parameters of T if T is a
2836 primary template instantiation, NULL otherwise. */
2838 tree
2840 {
2845 parms = INNERMOST_TEMPLATE_PARMS
2849 }
2851 /* Return the template parameters of the LEVELth level from the full list
2852 of template parameters PARMS. */
2854 tree
2856 {
2857 tree p;
2868 }
2870 /* Returns the template arguments of T if T is a template instantiation,
2871 NULL otherwise. */
2873 tree
2875 {
2883 }
2885 /* Return the argument pack elements of T if T is a template argument pack,
2886 NULL otherwise. */
2888 tree
2890 {
2896 }
2898 /* Structure used to track the progress of find_parameter_packs_r. */
2899 struct find_parameter_pack_data
2900 {
2901 /* TREE_LIST that will contain all of the parameter packs found by
2902 the traversal. */
2905 /* Set of AST nodes that have been visited by the traversal. */
2907 };
2909 /* Identifies all of the argument packs that occur in a template
2910 argument and appends them to the TREE_LIST inside DATA, which is a
2911 find_parameter_pack_data structure. This is a subroutine of
2912 make_pack_expansion and uses_parameter_packs. */
2913 static tree
2915 {
2921 /* Identify whether this is a parameter pack or not. */
2923 {
2937 {
2938 /* We don't want to walk into the type of a PARM_DECL,
2939 because we don't want to see the type parameter pack. */
2942 }
2946 /* Not a parameter pack. */
2948 }
2951 {
2952 /* Add this parameter pack to the list. */
2954 }
2960 /* This switch statement will return immediately if we don't find a
2961 parameter pack. */
2963 {
2968 /* Check the template itself. */
2971 /* Check the template arguments. */
2987 /* Fall through. */
3028 }
3031 }
3033 /* Determines if the expression or type T uses any parameter packs. */
3034 bool
3036 {
3044 }
3046 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3047 representation a base-class initializer into a parameter pack
3048 expansion. If all goes well, the resulting node will be an
3049 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3050 respectively. */
3051 tree
3053 {
3054 tree result;
3063 {
3064 /* The only time we will see a TREE_LIST here is for a base
3065 class initializer. In this case, the TREE_PURPOSE will be a
3066 _TYPE node (representing the base class expansion we're
3067 initializing) and the TREE_VALUE will be a TREE_LIST
3068 containing the initialization arguments.
3070 The resulting expansion looks somewhat different from most
3071 expansions. Rather than returning just one _EXPANSION, we
3072 return a TREE_LIST whose TREE_PURPOSE is a
3073 TYPE_PACK_EXPANSION containing the bases that will be
3074 initialized. The TREE_VALUE will be identical to the
3075 original TREE_VALUE, which is a list of arguments that will
3076 be passed to each base. We do not introduce any new pack
3077 expansion nodes into the TREE_VALUE (although it is possible
3078 that some already exist), because the TREE_PURPOSE and
3079 TREE_VALUE all need to be expanded together with the same
3080 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3081 resulting TREE_PURPOSE will mention the parameter packs in
3082 both the bases and the arguments to the bases. */
3083 tree purpose;
3084 tree value;
3087 /* Determine which parameter packs will be used by the base
3088 class expansion. */
3095 {
3099 }
3102 {
3103 /* Collect the sets of parameter packs used in each of the
3104 initialization arguments. */
3106 {
3107 /* Determine which parameter packs will be expanded in this
3108 argument. */
3111 }
3112 }
3116 /* Create the pack expansion type for the base type. */
3121 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3122 they will rarely be compared to anything. */
3126 }
3131 /* Build the PACK_EXPANSION_* node. */
3132 result = for_types
3137 {
3138 /* Propagate type and const-expression information. */
3141 }
3142 else
3143 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3144 they will rarely be compared to anything. */
3147 /* Determine which parameter packs will be expanded. */
3153 /* Make sure we found some parameter packs. */
3155 {
3158 else
3161 }
3165 }
3167 /* Checks T for any "bare" parameter packs, which have not yet been
3168 expanded, and issues an error if any are found. This operation can
3169 only be done on full expressions or types (e.g., an expression
3170 statement, "if" condition, etc.), because we could have expressions like:
3172 foo(f(g(h(args)))...)
3174 where "args" is a parameter pack. check_for_bare_parameter_packs
3175 should not be called for the subexpressions args, h(args),
3176 g(h(args)), or f(g(h(args))), because we would produce erroneous
3177 error messages.
3179 Returns TRUE and emits an error if there were bare parameter packs,
3180 returns FALSE otherwise. */
3181 bool
3183 {
3199 {
3202 {
3211 else
3216 else
3220 }
3223 }
3226 }
3228 /* Expand any parameter packs that occur in the template arguments in
3229 ARGS. */
3230 tree
3232 {
3238 /* First, determine if we need to expand anything, and the number of
3239 slots we'll need. */
3241 {
3246 {
3250 else
3252 }
3253 else
3254 {
3256 num_result_args++;
3257 }
3258 }
3260 /* If no expansion is necessary, we're done. */
3264 /* Expand arguments. */
3267 non_default_args_count =
3270 {
3273 {
3280 }
3281 else
3282 {
3285 }
3286 }
3290 }
3292 /* Checks if DECL shadows a template parameter.
3294 [temp.local]: A template-parameter shall not be redeclared within its
3295 scope (including nested scopes).
3297 Emits an error and returns TRUE if the DECL shadows a parameter,
3298 returns FALSE otherwise. */
3300 bool
3302 {
3303 tree olddecl;
3305 /* If we're not in a template, we can't possibly shadow a template
3306 parameter. */
3310 /* Figure out what we're shadowing. */
3315 /* If there's no previous binding for this name, we're not shadowing
3316 anything, let alone a template parameter. */
3320 /* If we're not shadowing a template parameter, we're done. Note
3321 that OLDDECL might be an OVERLOAD (or perhaps even an
3322 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3323 node. */
3327 /* We check for decl != olddecl to avoid bogus errors for using a
3328 name inside a class. We check TPFI to avoid duplicate errors for
3329 inline member templates. */
3337 }
3339 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3340 ORIG_LEVEL, DECL, and TYPE. */
3342 static tree
3346 tree decl,
3347 tree type)
3348 {
3359 }
3361 /* Find the canonical type parameter for the given template type
3362 parameter. Returns the canonical type parameter, which may be TYPE
3363 if no such parameter existed. */
3364 static tree
3366 {
3367 tree list;
3381 else
3382 {
3387 }
3388 }
3390 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3391 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3392 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3393 new one is created. */
3395 static tree
3397 tsubst_flags_t complain)
3398 {
3403 {
3422 /* Template template parameters need this. */
3427 }
3430 }
3432 /* Process information from new template parameter PARM and append it to the
3433 LIST being built. This new parameter is a non-type parameter iff
3434 IS_NON_TYPE is true. This new parameter is a parameter
3435 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3436 PARM_LOC. */
3438 tree
3441 {
3443 tree defval;
3444 tree err_parm_list;
3451 {
3455 {
3459 else
3461 }
3464 }
3465 else
3469 {
3475 {
3479 }
3480 else
3481 {
3482 /* [temp.param]
3484 The top-level cv-qualifiers on the template-parameter are
3485 ignored when determining its type. */
3488 {
3492 }
3495 {
3496 /* This template parameter is not a parameter pack, but it
3497 should be. Complain about "bare" parameter packs. */
3500 /* Recover by calling this a parameter pack. */
3502 }
3503 }
3505 /* A template parameter is not modifiable. */
3514 processing_template_decl,
3519 }
3520 else
3521 {
3522 tree t;
3526 {
3528 /* This is for distinguishing between real templates and template
3529 template parameters */
3533 }
3534 else
3535 {
3537 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3540 }
3547 processing_template_decl,
3551 }
3557 }
3559 /* The end of a template parameter list has been reached. Process the
3560 tree list into a parameter vector, converting each parameter into a more
3561 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3562 as PARM_DECLs. */
3564 tree
3566 {
3571 current_template_parms
3576 {
3582 current_template_parms;
3583 }
3588 }
3590 /* end_template_decl is called after a template declaration is seen. */
3592 void
3594 {
3600 /* This matches the pushlevel in begin_template_parm_list. */
3605 }
3607 /* Within the declaration of a template, return all levels of template
3608 parameters that apply. The template parameters are represented as
3609 a TREE_VEC, in the form documented in cp-tree.h for template
3610 arguments. */
3612 static tree
3614 {
3615 tree header;
3620 /* If there is only one level of template parameters, we do not
3621 create a TREE_VEC of TREE_VECs. Instead, we return a single
3622 TREE_VEC containing the arguments. */
3627 {
3633 {
3636 /* T will be a list if we are called from within a
3637 begin/end_template_parm_list pair, but a vector directly
3638 if within a begin/end_member_template_processing pair. */
3640 {
3644 {
3647 {
3651 {
3652 /* Turn this argument into a TYPE_ARGUMENT_PACK
3653 with a single element, which expands T. */
3655 #ifdef ENABLE_CHECKING
3656 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3658 #endif
3663 }
3664 }
3665 else
3666 {
3670 {
3671 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3672 with a single element, which expands T. */
3675 #ifdef ENABLE_CHECKING
3676 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3678 #endif
3684 }
3685 }
3687 }
3688 }
3689 }
3691 #ifdef ENABLE_CHECKING
3693 #endif
3697 else
3699 }
3702 }
3704 /* Update the declared TYPE by doing any lookups which were thought to be
3705 dependent, but are not now that we know the SCOPE of the declarator. */
3707 tree
3709 {
3720 /* Don't bother building up the args in this case. */
3722 {
3723 /* tsubst in the args corresponding to the template parameters,
3724 including auto if present. Most things will be unchanged, but
3725 make_typename_type and tsubst_qualified_id will resolve
3726 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3729 tree pushed;
3731 {
3735 }
3740 }
3746 {
3749 else
3751 }
3753 }
3755 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3756 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3757 a member template. Used by push_template_decl below. */
3759 static tree
3761 {
3768 }
3770 struct template_parm_data
3771 {
3772 /* The level of the template parameters we are currently
3773 processing. */
3776 /* The index of the specialization argument we are currently
3777 processing. */
3780 /* An array whose size is the number of template parameters. The
3781 elements are nonzero if the parameter has been used in any one
3782 of the arguments processed so far. */
3785 /* An array whose size is the number of template arguments. The
3786 elements are nonzero if the argument makes use of template
3787 parameters of this level. */
3789 };
3791 /* Subroutine of push_template_decl used to see if each template
3792 parameter in a partial specialization is used in the explicit
3793 argument list. If T is of the LEVEL given in DATA (which is
3794 treated as a template_parm_data*), then DATA->PARMS is marked
3795 appropriately. */
3797 static int
3799 {
3805 {
3808 }
3809 else
3810 {
3813 }
3816 {
3819 }
3821 /* Return zero so that for_each_template_parm will continue the
3822 traversal of the tree; we want to mark *every* template parm. */
3824 }
3826 /* Process the partial specialization DECL. */
3828 static tree
3830 {
3836 tree inner_parms;
3849 /* We check that each of the template parameters given in the
3850 partial specialization is used in the argument list to the
3851 specialization. For example:
3853 template <class T> struct S;
3854 template <class T> struct S<T*>;
3856 The second declaration is OK because `T*' uses the template
3857 parameter T, whereas
3859 template <class T> struct S<int>;
3861 is no good. Even trickier is:
3863 template <class T>
3864 struct S1
3865 {
3866 template <class U>
3867 struct S2;
3868 template <class U>
3869 struct S2<T>;
3870 };
3872 The S2<T> declaration is actually invalid; it is a
3873 full-specialization. Of course,
3875 template <class U>
3876 struct S2<T (*)(U)>;
3878 or some such would have been OK. */
3886 {
3891 NULL,
3893 }
3896 {
3897 /* One of the template parms was not used in the
3898 specialization. */
3900 {
3903 }
3906 }
3908 /* [temp.class.spec]
3910 The argument list of the specialization shall not be identical to
3911 the implicit argument list of the primary template. */
3918 /* [temp.class.spec]
3920 A partially specialized non-type argument expression shall not
3921 involve template parameters of the partial specialization except
3922 when the argument expression is a simple identifier.
3924 The type of a template parameter corresponding to a specialized
3925 non-type argument shall not be dependent on a parameter of the
3926 specialization.
3928 Also, we verify that pack expansions only occur at the
3929 end of the argument list. */
3933 {
3940 {
3941 /* Extract the arguments from the argument pack. We'll be
3942 iterating over these in the following loop. */
3945 }
3948 {
3950 /* Get the Jth argument in the parameter pack. */
3954 {
3955 /* Pack expansions must come at the end of the
3956 argument list. */
3959 {
3963 else
3966 }
3967 }
3970 /* We only care about the pattern. */
3976 /* This next line is the `argument expression is not just a
3977 simple identifier' condition and also the `specialized
3978 non-type argument' bit. */
3980 {
3984 arg);
3985 else
3986 {
3987 /* Look at the corresponding template parameter,
3988 marking which template parameters its type depends
3989 upon. */
3993 {
3994 /* We haven't yet initialized TPD2. Do so now. */
3995 tpd2.arg_uses_template_parms
3997 /* The number of parameters here is the number in the
3998 main template, which, as checked in the assertion
3999 above, is NARGS. */
4003 }
4005 /* Mark the template parameters. But this time, we're
4006 looking for the template parameters of the main
4007 template, not in the specialization. */
4014 NULL,
4018 {
4019 /* The type depended on some template parameters.
4020 If they are fully specialized in the
4021 specialization, that's OK. */
4030 "type %qT of template argument %qE depends "
4032 "type %qT of template argument %qE depends "
4034 type,
4035 arg);
4036 }
4037 }
4038 }
4039 }
4040 }
4042 /* We should only get here once. */
4050 }
4052 /* Check that a template declaration's use of default arguments and
4053 parameter packs is not invalid. Here, PARMS are the template
4054 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
4055 a primary template. IS_PARTIAL is nonzero if DECL is a partial
4056 specialization.
4059 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4060 declaration (but not a definition); 1 indicates a declaration, 2
4061 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4062 emitted for extraneous default arguments.
4064 Returns TRUE if there were no errors found, FALSE otherwise. */
4066 bool
4069 {
4072 tree parm_level;
4075 /* [temp.param]
4077 A default template-argument shall not be specified in a
4078 function template declaration or a function template definition, nor
4079 in the template-parameter-list of the definition of a member of a
4080 class template. */
4083 /* You can't have a function template declaration in a local
4084 scope, nor you can you define a member of a class template in a
4085 local scope. */
4092 /* If this is either a friend defined in the scope of the class
4093 or a member function. */
4099 /* And, if it was a member function, it really was defined in
4100 the scope of the class. */
4103 /* We already checked these parameters when the template was
4104 declared, so there's no need to do it again now. This function
4105 was defined in class scope, but we're processing it's body now
4106 that the class is complete. */
4109 /* Core issue 226 (C++0x only): the following only applies to class
4110 templates. */
4112 {
4113 /* [temp.param]
4115 If a template-parameter has a default template-argument, all
4116 subsequent template-parameters shall have a default
4117 template-argument supplied. */
4119 {
4126 {
4136 {
4138 /* For better subsequent error-recovery, we indicate that
4139 there should have been a default argument. */
4142 }
4144 && !is_partial
4145 && !is_friend_decl
4146 /* Don't complain about an enclosing partial
4147 specialization. */
4152 {
4153 /* A primary class template can only have one
4154 parameter pack, at the end of the template
4155 parameter list. */
4160 else
4168 }
4169 }
4170 }
4171 }
4174 || is_partial
4175 || !is_primary
4177 /* For an ordinary class template, default template arguments are
4178 allowed at the innermost level, e.g.:
4179 template <class T = int>
4180 struct S {};
4181 but, in a partial specialization, they're not allowed even
4182 there, as we have in [temp.class.spec]:
4184 The template parameter list of a specialization shall not
4185 contain default template argument values.
4187 So, for a partial specialization, or for a function template
4188 (in C++98/C++03), we look at all of them. */
4189 ;
4190 else
4191 /* But, for a primary class template that is not a partial
4192 specialization we look at all template parameters except the
4193 innermost ones. */
4196 /* Figure out what error message to issue. */
4209 else
4213 /* If we're inside a class definition, there's no need to
4214 examine the parameters to the class itself. On the one
4215 hand, they will be checked when the class is defined, and,
4216 on the other, default arguments are valid in things like:
4217 template <class T = double>
4218 struct S { template <class U> void f(U); };
4219 Here the default argument for `S' has no bearing on the
4220 declaration of `f'. */
4222 else
4223 /* Check everything. */
4229 {
4236 {
4241 {
4243 {
4250 }
4252 /* Clear out the default argument so that we are not
4253 confused later. */
4255 }
4256 }
4258 /* At this point, if we're still interested in issuing messages,
4259 they must apply to classes surrounding the object declared. */
4263 }
4266 }
4268 /* Worker for push_template_decl_real, called via
4269 for_each_template_parm. DATA is really an int, indicating the
4270 level of the parameters we are interested in. If T is a template
4271 parameter of that level, return nonzero. */
4273 static int
4275 {
4281 else
4284 }
4286 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4287 parameters given by current_template_args, or reuses a
4288 previously existing one, if appropriate. Returns the DECL, or an
4289 equivalent one, if it is replaced via a call to duplicate_decls.
4291 If IS_FRIEND is true, DECL is a friend declaration. */
4293 tree
4295 {
4296 tree tmpl;
4297 tree args;
4298 tree info;
4299 tree ctx;
4303 /* True if the template is a member template, in the sense of
4304 [temp.mem]. */
4310 /* See if this is a partial specialization. */
4319 /* For a friend, we want the context of the friend function, not
4320 the type of which it is a friend. */
4324 /* In the case of a virtual function, we want the class in which
4325 it is defined. */
4327 else
4328 /* Otherwise, if we're currently defining some class, the DECL
4329 is assumed to be a member of the class. */
4338 /* See if this is a primary template. */
4340 /* A friend template that specifies a class context, i.e.
4341 template <typename T> friend void A<T>::f();
4342 is not primary. */
4344 else
4348 {
4353 {
4356 }
4358 {
4360 {
4361 /* [temp.mem]
4363 A destructor shall not be a member template. */
4366 }
4373 {
4374 /* [basic.stc.dynamic.allocation]
4376 An allocation function can be a function
4377 template. ... Template allocation functions shall
4378 have two or more parameters. */
4381 }
4382 }
4386 else
4387 {
4390 }
4391 }
4393 /* Check to see that the rules regarding the use of default
4394 arguments are not being violated. */
4398 /* Ensure that there are no parameter packs in the type of this
4399 declaration that have not been expanded. */
4401 {
4402 /* Check each of the arguments individually to see if there are
4403 any bare parameter packs. */
4409 {
4412 {
4413 /* This is a PARM_DECL that contains unexpanded parameter
4414 packs. We have already complained about this in the
4415 check_for_bare_parameter_packs call, so just replace
4416 these types with ERROR_MARK_NODE. */
4419 }
4423 }
4425 /* Check for bare parameter packs in the return type and the
4426 exception specifiers. */
4428 /* Errors were already issued, set return type to int
4429 as the frontend doesn't expect error_mark_node as
4430 the return type. */
4434 }
4436 {
4439 }
4450 {
4455 /* If DECL is a TYPE_DECL for a class-template, then there won't
4456 be DECL_LANG_SPECIFIC. The information equivalent to
4457 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4461 {
4462 /* Since a template declaration already existed for this
4463 class-type, we must be redeclaring it here. Make sure
4464 that the redeclaration is valid. */
4466 current_template_parms);
4467 /* We don't need to create a new TEMPLATE_DECL; just use the
4468 one we already had. */
4470 }
4471 else
4472 {
4474 member_template_p);
4479 {
4480 /* A specialization of a member template of a template
4481 class. */
4485 }
4486 }
4487 }
4488 else
4489 {
4495 {
4498 }
4506 {
4507 tree new_tmpl;
4509 /* The declaration is a specialization of a member
4510 template, declared outside the class. Therefore, the
4511 innermost template arguments will be NULL, so we
4512 replace them with the arguments determined by the
4513 earlier call to check_explicit_specialization. */
4516 new_tmpl
4518 member_template_p);
4528 args,
4531 }
4533 /* Make sure the template headers we got make sense. */
4538 {
4541 }
4542 else
4544 {
4549 {
4553 else
4558 }
4563 /* Can happen in erroneous input. */
4565 else
4569 }
4571 /* Check that the parms are used in the appropriate qualifying scopes
4572 in the declarator. */
4576 {
4582 /* Avoid crash in import_export_decl. */
4585 }
4586 }
4591 /* Push template declarations for global functions and types. Note
4592 that we do not try to push a global template friend declared in a
4593 template class; such a thing may well depend on the template
4594 parameters of the class. */
4597 {
4602 /* Hide template friend classes that haven't been declared yet. */
4604 {
4607 }
4608 }
4611 {
4617 {
4620 /* It is a conversion operator. See if the type converted to
4621 depends on innermost template operands. */
4624 depth))
4626 }
4628 /* Give template template parms a DECL_CONTEXT of the template
4629 for which they are a parameter. */
4632 {
4636 }
4637 }
4639 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4640 back to its most general template. If TMPL is a specialization,
4641 ARGS may only have the innermost set of arguments. Add the missing
4642 argument levels if necessary. */
4654 }
4656 tree
4658 {
4660 }
4662 /* Called when a class template TYPE is redeclared with the indicated
4663 template PARMS, e.g.:
4665 template <class T> struct S;
4666 template <class T> struct S {}; */
4668 bool
4670 {
4671 tree tmpl;
4672 tree tmpl_parms;
4676 {
4679 }
4683 /* The type is nested in some template class. Nothing to worry
4684 about here; there are no new template parameters for the nested
4685 type. */
4689 {
4691 tmpl);
4693 }
4699 {
4709 }
4712 {
4713 tree tmpl_parm;
4714 tree parm;
4715 tree tmpl_default;
4716 tree parm_default;
4730 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4731 TEMPLATE_DECL. */
4741 {
4745 }
4748 {
4749 /* We have in [temp.param]:
4751 A template-parameter may not be given default arguments
4752 by two different declarations in the same scope. */
4757 }
4760 /* Update the previous template parameters (which are the ones
4761 that will really count) with the new default value. */
4764 /* Update the new parameters, too; they'll be used as the
4765 parameters for any members. */
4767 }
4770 }
4772 /* Simplify EXPR if it is a non-dependent expression. Returns the
4773 (possibly simplified) expression. */
4775 tree
4777 {
4781 /* If we're in a template, but EXPR isn't value dependent, simplify
4782 it. We're supposed to treat:
4784 template <typename T> void f(T[1 + 1]);
4785 template <typename T> void f(T[2]);
4787 as two declarations of the same function, for example. */
4791 {
4792 HOST_WIDE_INT saved_processing_template_decl;
4798 tf_error,
4803 }
4805 }
4807 /* EXPR is an expression which is used in a constant-expression context.
4808 For instance, it could be a VAR_DECL with a constant initializer.
4809 Extract the innermost constant expression.
4811 This is basically a more powerful version of
4812 integral_constant_value, which can be used also in templates where
4813 initializers can maintain a syntactic rather than semantic form
4814 (even if they are non-dependent, for access-checking purposes). */
4816 static tree
4818 {
4820 do
4821 {
4824 }
4828 }
4830 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4831 must be a function or a pointer-to-function type, as specified
4832 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4833 and check that the resulting function has external linkage. */
4835 static tree
4837 {
4851 /* [temp.arg.nontype]/1
4853 A template-argument for a non-type, non-template template-parameter
4854 shall be one of:
4855 [...]
4856 -- the address of an object or function with external linkage. */
4858 {
4863 }
4866 }
4868 /* Subroutine of convert_nontype_argument.
4869 Check if EXPR of type TYPE is a valid pointer-to-member constant.
4870 Emit an error otherwise. */
4872 static bool
4874 {
4882 }
4884 /* Attempt to convert the non-type template parameter EXPR to the
4885 indicated TYPE. If the conversion is successful, return the
4886 converted value. If the conversion is unsuccessful, return
4887 NULL_TREE if we issued an error message, or error_mark_node if we
4888 did not. We issue error messages for out-and-out bad template
4889 parameters, but not simply because the conversion failed, since we
4890 might be just trying to do argument deduction. Both TYPE and EXPR
4891 must be non-dependent.
4893 The conversion follows the special rules described in
4894 [temp.arg.nontype], and it is much more strict than an implicit
4895 conversion.
4897 This function is called twice for each template argument (see
4898 lookup_template_class for a more accurate description of this
4899 problem). This means that we need to handle expressions which
4900 are not valid in a C++ source, but can be created from the
4901 first call (for instance, casts to perform conversions). These
4902 hacks can go away after we fix the double coercion problem. */
4904 static tree
4906 {
4907 tree expr_type;
4909 /* Detect immediately string literals as invalid non-type argument.
4910 This special-case is not needed for correctness (we would easily
4911 catch this later), but only to provide better diagnostic for this
4912 common user mistake. As suggested by DR 100, we do not mention
4913 linkage issues in the diagnostic as this is not the point. */
4915 {
4920 }
4922 /* If we are in a template, EXPR may be non-dependent, but still
4923 have a syntactic, rather than semantic, form. For example, EXPR
4924 might be a SCOPE_REF, rather than the VAR_DECL to which the
4925 SCOPE_REF refers. Preserving the qualifying scope is necessary
4926 so that access checking can be performed when the template is
4927 instantiated -- but here we need the resolved form so that we can
4928 convert the argument. */
4934 /* HACK: Due to double coercion, we can get a
4935 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4936 which is the tree that we built on the first call (see
4937 below when coercing to reference to object or to reference to
4938 function). We just strip everything and get to the arg.
4939 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4940 for examples. */
4942 {
4944 {
4945 /* ??? Maybe we could use convert_from_reference here, but we
4946 would need to relax its constraints because the NOP_EXPR
4947 could actually change the type to something more cv-qualified,
4948 and this is not folded by convert_from_reference. */
4959 }
4961 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4962 parameter is a pointer to object, through decay and
4963 qualification conversion. Let's strip everything. */
4965 {
4969 /* Skip the ADDR_EXPR only if it is part of the decay for
4970 an array. Otherwise, it is part of the original argument
4971 in the source code. */
4975 }
4976 }
4978 /* [temp.arg.nontype]/5, bullet 1
4980 For a non-type template-parameter of integral or enumeration type,
4981 integral promotions (_conv.prom_) and integral conversions
4982 (_conv.integral_) are applied. */
4984 {
4989 /* Notice that there are constant expressions like '4 % 0' which
4990 do not fold into integer constants. */
4992 {
4996 }
4998 /* At this point, an implicit conversion does what we want,
4999 because we already know that the expression is of integral
5000 type. */
5005 /* Conversion was allowed: fold it to a bare integer constant. */
5007 }
5008 /* [temp.arg.nontype]/5, bullet 2
5010 For a non-type template-parameter of type pointer to object,
5011 qualification conversions (_conv.qual_) and the array-to-pointer
5012 conversion (_conv.array_) are applied. */
5014 {
5015 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5017 A template-argument for a non-type, non-template template-parameter
5018 shall be one of: [...]
5020 -- the name of a non-type template-parameter;
5021 -- the address of an object or function with external linkage, [...]
5022 expressed as "& id-expression" where the & is optional if the name
5023 refers to a function or array, or if the corresponding
5024 template-parameter is a reference.
5026 Here, we do not care about functions, as they are invalid anyway
5027 for a parameter of type pointer-to-object. */
5030 /* Non-type template parameters are OK. */
5031 ;
5034 {
5036 {
5038 "because %qD is a variable, not the address of "
5042 }
5043 /* Other values, like integer constants, might be valid
5044 non-type arguments of some other type. */
5046 }
5047 else
5048 {
5049 tree decl;
5054 {
5059 }
5061 {
5066 }
5067 }
5076 }
5077 /* [temp.arg.nontype]/5, bullet 3
5079 For a non-type template-parameter of type reference to object, no
5080 conversions apply. The type referred to by the reference may be more
5081 cv-qualified than the (otherwise identical) type of the
5082 template-argument. The template-parameter is bound directly to the
5083 template-argument, which must be an lvalue. */
5085 {
5087 expr_type))
5091 {
5095 }
5098 {
5102 }
5104 /* [temp.arg.nontype]/1
5106 A template-argument for a non-type, non-template template-parameter
5107 shall be one of: [...]
5109 -- the address of an object or function with external linkage. */
5112 {
5115 {
5117 "because a reference variable does not have a constant "
5120 }
5121 }
5124 {
5129 }
5132 {
5137 }
5140 }
5141 /* [temp.arg.nontype]/5, bullet 4
5143 For a non-type template-parameter of type pointer to function, only
5144 the function-to-pointer conversion (_conv.func_) is applied. If the
5145 template-argument represents a set of overloaded functions (or a
5146 pointer to such), the matching function is selected from the set
5147 (_over.over_). */
5149 {
5150 /* If the argument is a template-id, we might not have enough
5151 context information to decay the pointer. */
5153 {
5157 }
5164 {
5168 }
5169 }
5170 /* [temp.arg.nontype]/5, bullet 5
5172 For a non-type template-parameter of type reference to function, no
5173 conversions apply. If the template-argument represents a set of
5174 overloaded functions, the matching function is selected from the set
5175 (_over.over_). */
5177 {
5179 {
5184 }
5191 }
5192 /* [temp.arg.nontype]/5, bullet 6
5194 For a non-type template-parameter of type pointer to member function,
5195 no conversions apply. If the template-argument represents a set of
5196 overloaded member functions, the matching member function is selected
5197 from the set (_over.over_). */
5199 {
5204 /* [temp.arg.nontype] bullet 1 says the pointer to member
5205 expression must be a pointer-to-member constant. */
5209 /* There is no way to disable standard conversions in
5210 resolve_address_of_overloaded_function (called by
5211 instantiate_type). It is possible that the call succeeded by
5212 converting &B::I to &D::I (where B is a base of D), so we need
5213 to reject this conversion here.
5215 Actually, even if there was a way to disable standard conversions,
5216 it would still be better to reject them here so that we can
5217 provide a superior diagnostic. */
5219 {
5223 /* If we are just one standard conversion off, explain. */
5228 }
5229 }
5230 /* [temp.arg.nontype]/5, bullet 7
5232 For a non-type template-parameter of type pointer to data member,
5233 qualification conversions (_conv.qual_) are applied. */
5235 {
5236 /* [temp.arg.nontype] bullet 1 says the pointer to member
5237 expression must be a pointer-to-member constant. */
5244 }
5245 /* A template non-type parameter must be one of the above. */
5246 else
5249 /* Sanity check: did we actually convert the argument to the
5250 right type? */
5253 }
5255 /* Subroutine of coerce_template_template_parms, which returns 1 if
5256 PARM_PARM and ARG_PARM match using the rule for the template
5257 parameters of template template parameters. Both PARM and ARG are
5258 template parameters; the rest of the arguments are the same as for
5259 coerce_template_template_parms.
5260 */
5261 static int
5263 tree arg,
5264 tsubst_flags_t complain,
5265 tree in_decl,
5266 tree outer_args)
5267 {
5276 {
5278 /* We encounter instantiations of templates like
5279 template <template <template <class> class> class TT>
5280 class C; */
5281 {
5288 }
5289 /* Fall through. */
5294 /* Argument is a parameter pack but parameter is not. */
5299 /* The tsubst call is used to handle cases such as
5301 template <int> class C {};
5302 template <class T, template <T> class TT> class D {};
5303 D<int, C> d;
5305 i.e. the parameter list of TT depends on earlier parameters. */
5307 && !same_type_p
5314 /* Argument is a parameter pack but parameter is not. */
5321 }
5324 }
5327 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5328 template template parameters. Both PARM_PARMS and ARG_PARMS are
5329 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5330 or PARM_DECL.
5332 Consider the example:
5333 template <class T> class A;
5334 template<template <class U> class TT> class B;
5336 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5337 the parameters to A, and OUTER_ARGS contains A. */
5339 static int
5341 tree arg_parms,
5342 tsubst_flags_t complain,
5343 tree in_decl,
5344 tree outer_args)
5345 {
5356 /* Determine whether we have a parameter pack at the end of the
5357 template template parameter's template parameter list. */
5359 {
5366 {
5380 }
5381 }
5387 /* Check all of the template parameters except the parameter pack at
5388 the end (if any). */
5390 {
5399 outer_args))
5402 }
5405 {
5406 /* Check each of the template parameters in the template
5407 argument against the template parameter pack at the end of
5408 the template template parameter. */
5415 {
5422 outer_args))
5424 }
5425 }
5428 }
5430 /* Verifies that the deduced template arguments (in TARGS) for the
5431 template template parameters (in TPARMS) represent valid bindings,
5432 by comparing the template parameter list of each template argument
5433 to the template parameter list of its corresponding template
5434 template parameter, in accordance with DR150. This
5435 routine can only be called after all template arguments have been
5436 deduced. It will return TRUE if all of the template template
5437 parameter bindings are okay, FALSE otherwise. */
5438 bool
5440 {
5444 /* We're dealing with template parms in this process. */
5450 {
5455 {
5460 {
5461 /* Look inside the argument pack. */
5464 }
5467 {
5471 /* Extract the next argument from the argument
5472 pack. */
5476 /* Look at the pattern of the pack expansion. */
5479 /* Extract the template parameters from the template
5480 argument. */
5486 /* Verify that we can coerce the template template
5487 parameters from the template argument to the template
5488 parameter. This requires an exact match. */
5490 && !coerce_template_template_parms
5492 targ_parms,
5493 tf_none,
5494 tparm,
5495 targs))
5496 {
5499 }
5500 }
5501 }
5502 }
5504 out:
5508 }
5510 /* Convert the indicated template ARG as necessary to match the
5511 indicated template PARM. Returns the converted ARG, or
5512 error_mark_node if the conversion was unsuccessful. Error and
5513 warning messages are issued under control of COMPLAIN. This
5514 conversion is for the Ith parameter in the parameter list. ARGS is
5515 the full set of template arguments deduced so far. */
5517 static tree
5519 tree arg,
5520 tree args,
5521 tsubst_flags_t complain,
5523 tree in_decl)
5524 {
5525 tree orig_arg;
5526 tree val;
5531 {
5532 /* The template argument was the name of some
5533 member function. That's usually
5534 invalid, but static members are OK. In any
5535 case, grab the underlying fields/functions
5536 and issue an error later if required. */
5539 }
5547 /* When determining whether an argument pack expansion is a template,
5548 look at the pattern. */
5552 /* Deal with an injected-class-name used as a template template arg. */
5554 {
5557 {
5565 }
5566 }
5568 is_tmpl_type =
5583 {
5589 typename_type,
5593 }
5595 {
5597 {
5599 {
5609 else
5611 }
5612 }
5614 }
5616 {
5618 {
5624 else
5626 }
5628 }
5631 {
5633 {
5635 /* The number of argument required is not known yet.
5636 Just accept it for now. */
5638 else
5639 {
5641 tree argparm;
5647 args))
5648 {
5651 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5652 TEMPLATE_DECL. */
5654 {
5659 }
5660 }
5661 else
5662 {
5664 {
5670 }
5673 }
5674 }
5675 }
5676 else
5678 /* We only form one instance of each template specialization.
5679 Therefore, if we use a non-canonical variant (i.e., a
5680 typedef), any future messages referring to the type will use
5681 the typedef, which is confusing if those future uses do not
5682 themselves also use the typedef. */
5685 }
5686 else
5687 {
5694 {
5697 else
5698 {
5699 /* Not sure if this is reachable, but it doesn't hurt
5700 to be robust. */
5703 }
5704 }
5706 /* We used to call digest_init here. However, digest_init
5707 will report errors, which we don't want when complain
5708 is zero. More importantly, digest_init will try too
5709 hard to convert things: for example, `0' should not be
5710 converted to pointer type at this point according to
5711 the standard. Accepting this is not merely an
5712 extension, since deciding whether or not these
5713 conversions can occur is part of determining which
5714 function template to call, or whether a given explicit
5715 argument specification is valid. */
5717 else
5726 {
5727 /* Strip typedefs from the SCOPE_REF. */
5732 }
5733 }
5736 }
5738 /* Coerces the remaining template arguments in INNER_ARGS (from
5739 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5740 Returns the coerced argument pack. PARM_IDX is the position of this
5741 parameter in the template parameter list. ARGS is the original
5742 template argument list. */
5743 static tree
5746 tree args,
5747 tree inner_args,
5749 tree new_args,
5751 tree in_decl,
5752 tsubst_flags_t complain)
5753 {
5756 tree packed_args;
5757 tree argument_pack;
5767 {
5768 /* When the template parameter is a non-type template
5769 parameter pack whose type uses parameter packs, we need
5770 to look at each of the template arguments
5771 separately. Build a vector of the types for these
5772 non-type template parameters in PACKED_TYPES. */
5773 tree expansion
5781 /* Check that we have the right number of arguments. */
5785 {
5786 int needed_parms
5791 }
5793 /* If we aren't able to check the actual arguments now
5794 (because they haven't been expanded yet), we can at least
5795 verify that all of the types used for the non-type
5796 template parameter pack are, in fact, valid for non-type
5797 template parameters. */
5800 {
5803 {
5807 }
5808 }
5809 }
5811 /* Convert the remaining arguments, which will be a part of the
5812 parameter pack "parm". */
5814 {
5819 {
5820 /* When we have a vector of types (corresponding to the
5821 non-type template parameter pack that uses parameter
5822 packs in its type, as mention above), and the
5823 argument is not an expansion (which expands to a
5824 currently unknown number of arguments), clone the
5825 parm and give it the next type in PACKED_TYPES. */
5829 }
5834 in_decl);
5838 }
5843 else
5844 {
5849 }
5852 #ifdef ENABLE_CHECKING
5855 #endif
5857 }
5859 /* Convert all template arguments to their appropriate types, and
5860 return a vector containing the innermost resulting template
5861 arguments. If any error occurs, return error_mark_node. Error and
5862 warning messages are issued under control of COMPLAIN.
5864 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5865 for arguments not specified in ARGS. Otherwise, if
5866 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5867 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5868 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5869 ARGS. */
5871 static tree
5873 tree args,
5874 tree in_decl,
5875 tsubst_flags_t complain,
5878 {
5880 tree inner_args;
5881 tree new_args;
5882 tree new_inner_args;
5886 /* When used as a boolean value, indicates whether this is a
5887 variadic template parameter list. Since it's an int, we can also
5888 subtract it from nparms to get the number of non-variadic
5889 parameters. */
5894 /* Determine if there are any parameter packs. */
5896 {
5900 }
5903 /* If there are 0 or 1 parameter packs, we need to expand any argument
5904 packs so that we can deduce a parameter pack from some non-packed args
5905 followed by an argument pack, as in variadic85.C. If there are more
5906 than that, we need to leave argument packs intact so the arguments are
5907 assigned to the right parameter packs. This should only happen when
5908 dealing with a nested class inside a partial specialization of a class
5909 template, as in variadic92.C. */
5916 && require_all_args
5917 && (!use_default_args
5920 {
5922 {
5925 {
5928 }
5935 }
5938 }
5940 /* We need to evaluate the template arguments, even though this
5941 template-id may be nested within a "sizeof". */
5949 {
5950 tree arg;
5951 tree parm;
5953 /* Get the Ith template parameter. */
5957 {
5960 }
5962 /* Calculate the next argument. */
5965 else
5970 {
5971 /* All remaining arguments will be placed in the
5972 template parameter pack PARM. */
5978 /* Store this argument. */
5980 lost++;
5983 /* We are done with all of the arguments. */
5987 }
5989 {
5991 {
5993 {
5994 /* FIXME this restriction was removed by N2555; see
5995 bug 35722. */
5996 /* If ARG is a pack expansion, but PARM is not a
5997 template parameter pack (if it were, we would have
5998 handled it above), we're trying to expand into a
5999 fixed-length argument list. */
6003 else
6006 }
6008 }
6009 }
6011 {
6012 /* There must be a default arg in this case. */
6015 /* The position of the first default template argument,
6016 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6017 Record that. */
6020 }
6021 else
6025 {
6028 }
6030 /* This only occurs if there was an error in the template
6031 parameter list itself (which we would already have
6032 reported) that we are trying to recover from, e.g., a class
6033 template with a parameter list such as
6034 template<typename..., typename>. */
6036 else
6042 lost++;
6044 }
6051 #ifdef ENABLE_CHECKING
6055 #endif
6058 }
6060 /* Returns 1 if template args OT and NT are equivalent. */
6062 static int
6064 {
6069 /* For member templates */
6076 {
6093 }
6095 {
6096 /* We get here probably because we are in the middle of substituting
6097 into the pattern of a pack expansion. In that case the
6098 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
6099 interested in. So we want to use the initial pack argument for
6100 the comparison. */
6105 }
6110 else
6112 }
6114 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
6115 of template arguments. Returns 0 otherwise. */
6117 int
6119 {
6126 {
6132 }
6134 }
6136 static void
6138 {
6148 /* We are called both from instantiate_decl, where we've already had a
6149 tinst_level pushed, and instantiate_template, where we haven't.
6150 Compensate. */
6161 else
6170 }
6173 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6174 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6175 documentation for TEMPLATE_ID_EXPR. */
6177 tree
6179 {
6180 tree type;
6190 {
6192 unknown_type_node,
6194 arglist);
6196 }
6203 }
6205 /* Within the scope of a template class S<T>, the name S gets bound
6206 (in build_self_reference) to a TYPE_DECL for the class, not a
6207 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6208 or one of its enclosing classes, and that type is a template,
6209 return the associated TEMPLATE_DECL. Otherwise, the original
6210 DECL is returned.
6212 Also handle the case when DECL is a TREE_LIST of ambiguous
6213 injected-class-names from different bases. */
6215 tree
6217 {
6221 /* DR 176: A lookup that finds an injected-class-name (10.2
6222 [class.member.lookup]) can result in an ambiguity in certain cases
6223 (for example, if it is found in more than one base class). If all of
6224 the injected-class-names that are found refer to specializations of
6225 the same class template, and if the name is followed by a
6226 template-argument-list, the reference refers to the class template
6227 itself and not a specialization thereof, and is not ambiguous. */
6229 {
6232 {
6238 }
6241 else
6243 }
6249 }
6251 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
6252 parameters, find the desired type.
6254 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
6256 IN_DECL, if non-NULL, is the template declaration we are trying to
6257 instantiate.
6259 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
6260 the class we are looking up.
6262 Issue error and warning messages under control of COMPLAIN.
6264 If the template class is really a local class in a template
6265 function, then the FUNCTION_CONTEXT is the function in which it is
6266 being instantiated.
6268 ??? Note that this function is currently called *twice* for each
6269 template-id: the first time from the parser, while creating the
6270 incomplete type (finish_template_type), and the second type during the
6271 real instantiation (instantiate_template_class). This is surely something
6272 that we want to avoid. It also causes some problems with argument
6273 coercion (see convert_nontype_argument for more information on this). */
6275 tree
6277 tree arglist,
6278 tree in_decl,
6279 tree context,
6281 tsubst_flags_t complain)
6282 {
6284 tree t;
6287 spec_entry elt;
6288 hashval_t hash;
6293 {
6297 else
6298 {
6305 }
6308 }
6310 {
6313 /* If we are declaring a constructor, say A<T>::A<T>, we will get
6314 an implicit typename for the second A. Deal with it. */
6319 {
6322 }
6323 }
6326 {
6329 }
6333 {
6337 }
6339 /* Issue an error message if we didn't find a template. */
6341 {
6345 }
6348 /* Make sure it's a user visible template, if it was named by
6349 the user. */
6352 {
6354 {
6358 }
6360 }
6365 {
6366 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
6367 template arguments */
6369 tree parm;
6370 tree arglist2;
6371 tree outer;
6375 /* Consider an example where a template template parameter declared as
6377 template <class T, class U = std::allocator<T> > class TT
6379 The template parameter level of T and U are one level larger than
6380 of TT. To proper process the default argument of U, say when an
6381 instantiation `TT<int>' is seen, we need to build the full
6382 arguments containing {int} as the innermost level. Outer levels,
6383 available when not appearing as default template argument, can be
6384 obtained from the arguments of the enclosing template.
6386 Suppose that TT is later substituted with std::vector. The above
6387 instantiation is `TT<int, std::allocator<T> >' with TT at
6388 level 1, and T at level 2, while the template arguments at level 1
6389 becomes {std::vector} and the inner level 2 is {int}. */
6395 /* This is an argument of the current template, so we haven't set
6396 DECL_CONTEXT yet. */
6403 complain,
6413 }
6414 else
6415 {
6417 tree gen_tmpl;
6418 tree type_decl;
6431 {
6432 /* We've been given an incomplete set of template arguments.
6433 For example, given:
6435 template <class T> struct S1 {
6436 template <class U> struct S2 {};
6437 template <class U> struct S2<U*> {};
6438 };
6440 we will be called with an ARGLIST of `U*', but the
6441 TEMPLATE will be `template <class T> template
6442 <class U> struct S1<T>::S2'. We must fill in the missing
6443 arguments. */
6444 arglist
6446 arglist);
6448 }
6450 /* Now we should have enough arguments. */
6453 /* From here on, we're only interested in the most general
6454 template. */
6456 /* Calculate the BOUND_ARGS. These will be the args that are
6457 actually tsubst'd into the definition to create the
6458 instantiation. */
6460 {
6461 /* We have multiple levels of arguments to coerce, at once. */
6471 {
6474 complain,
6478 /* Don't process further if one of the levels fails. */
6480 {
6481 /* Restore the ARGLIST to its full size. */
6484 }
6488 /* We temporarily reduce the length of the ARGLIST so
6489 that coerce_template_parms will see only the arguments
6490 corresponding to the template parameters it is
6491 examining. */
6493 }
6495 /* Restore the ARGLIST to its full size. */
6499 }
6500 else
6501 arglist
6504 gen_tmpl,
6505 complain,
6510 /* We were unable to bind the arguments. */
6513 /* In the scope of a template class, explicit references to the
6514 template class refer to the type of the template, not any
6515 instantiation of it. For example, in:
6517 template <class T> class C { void f(C<T>); }
6519 the `C<T>' is just the same as `C'. Outside of the
6520 class, however, such a reference is an instantiation. */
6524 /* comp_template_args is expensive, check it last. */
6526 arglist))
6529 /* If we already have this specialization, return it. */
6541 /* If the deduced arguments are invalid, then the binding
6542 failed. */
6546 complain))
6553 {
6558 }
6565 /* Create the type. */
6567 {
6569 {
6575 }
6576 else
6577 {
6578 /* We don't want to call start_enum for this type, since
6579 the values for the enumeration constants may involve
6580 template parameters. And, no one should be interested
6581 in the enumeration constants for such a type. */
6584 }
6585 }
6586 else
6587 {
6594 /* A local class. Make sure the decl gets registered properly. */
6599 /* This instantiation is another name for the primary
6600 template type. Set the TYPE_CANONICAL field
6601 appropriately. */
6604 /* Some of the template arguments require structural
6605 equality testing, so this template class requires
6606 structural equality testing. */
6608 }
6610 /* If we called start_enum or pushtag above, this information
6611 will already be set up. */
6613 {
6620 }
6621 else
6629 {
6632 }
6634 /* Let's consider the explicit specialization of a member
6635 of a class template specialization that is implicitely instantiated,
6636 e.g.:
6637 template<class T>
6638 struct S
6639 {
6640 template<class U> struct M {}; //#0
6641 };
6643 template<>
6644 template<>
6645 struct S<int>::M<char> //#1
6646 {
6647 int i;
6648 };
6649 [temp.expl.spec]/4 says this is valid.
6651 In this case, when we write:
6652 S<int>::M<char> m;
6654 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
6655 the one of #0.
6657 When we encounter #1, we want to store the partial instantiation
6658 of M (template<class T> S<int>::M<T>) in it's CLASSTYPE_TI_TEMPLATE.
6660 For all cases other than this "explicit specialization of member of a
6661 class template", we just want to store the most general template into
6662 the CLASSTYPE_TI_TEMPLATE of M.
6664 This case of "explicit specialization of member of a class template"
6665 only happens when:
6666 1/ the enclosing class is an instantiation of, and therefore not
6667 the same as, the context of the most general template, and
6668 2/ we aren't looking at the partial instantiation itself, i.e.
6669 the innermost arguments are not the same as the innermost parms of
6670 the most general template.
6672 So it's only when 1/ and 2/ happens that we want to use the partial
6673 instantiation of the member template in lieu of its most general
6674 template. */
6678 /* the enclosing class must be an instantiation... */
6681 {
6682 tree partial_inst_args;
6685 partial_inst_args =
6691 use_partial_inst_tmpl =
6692 /*...and we must not be looking at the partial instantiation
6693 itself. */
6695 partial_inst_args);
6696 }
6699 /* This case is easy; there are no member templates involved. */
6701 else
6702 {
6703 /* This is a full instantiation of a member template. Find
6704 the partial instantiation of which this is an instance. */
6706 /* Temporarily reduce by one the number of levels in the ARGLIST
6707 so as to avoid comparing the last set of arguments. */
6712 }
6722 /* Note this use of the partial instantiation so we can check it
6723 later in maybe_process_partial_specialization. */
6729 /* Now that the type has been registered on the instantiations
6730 list, we set up the enumerators. Because the enumeration
6731 constants may involve the enumeration type itself, we make
6732 sure to register the type first, and then create the
6733 constants. That way, doing tsubst_expr for the enumeration
6734 constants won't result in recursive calls here; we'll find
6735 the instantiation and exit above. */
6739 /* If the type makes use of template parameters, the
6740 code that generates debugging information will crash. */
6743 /* Possibly limit visibility based on template args. */
6748 }
6750 }
6751 \f
6752 struct pair_fn_data
6753 {
6754 tree_fn_t fn;
6756 /* True when we should also visit template parameters that occur in
6757 non-deduced contexts. */
6760 };
6762 /* Called from for_each_template_parm via walk_tree. */
6764 static tree
6766 {
6779 {
6783 /* Fall through. */
6806 /* Since we're not going to walk subtrees, we have to do this
6807 explicitly here. */
6811 /* Fall through. */
6814 /* Check the return type. */
6819 /* Check the parameter types. Since default arguments are not
6820 instantiated until they are needed, the TYPE_ARG_TYPES may
6821 contain expressions that involve template parameters. But,
6822 no-one should be looking at them yet. And, once they're
6823 instantiated, they don't contain template parameters, so
6824 there's no point in looking at them then, either. */
6825 {
6826 tree parm;
6833 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6834 want walk_tree walking into them itself. */
6836 }
6853 /* Fall through. */
6869 /* Record template parameters such as `T' inside `TT<T>'. */
6873 /* Fall through. */
6885 /* A template template parameter is encountered. */
6891 /* Already substituted template template parameter */
6914 /* If there's no type, then this thing must be some expression
6915 involving template parameters. */
6936 }
6938 /* We didn't find any template parameters we liked. */
6940 }
6942 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6943 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6944 call FN with the parameter and the DATA.
6945 If FN returns nonzero, the iteration is terminated, and
6946 for_each_template_parm returns 1. Otherwise, the iteration
6947 continues. If FN never returns a nonzero value, the value
6948 returned by for_each_template_parm is 0. If FN is NULL, it is
6949 considered to be the function which always returns 1.
6951 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6952 parameters that occur in non-deduced contexts. When false, only
6953 visits those template parameters that can be deduced. */
6955 static int
6959 {
6963 /* Set up. */
6968 /* Walk the tree. (Conceptually, we would like to walk without
6969 duplicates, but for_each_template_parm_r recursively calls
6970 for_each_template_parm, so we would need to reorganize a fair
6971 bit to use walk_tree_without_duplicates, so we keep our own
6972 visited list.) */
6975 else
6978 for_each_template_parm_r,
6982 /* Clean up. */
6984 {
6987 }
6990 }
6992 /* Returns true if T depends on any template parameter. */
6994 int
6996 {
7023 else
7024 {
7027 }
7032 }
7034 /* Returns true if T depends on any template parameter with level LEVEL. */
7036 int
7038 {
7041 }
7045 #ifdef GATHER_STATISTICS
7047 #endif
7051 /* We're starting to instantiate D; record the template instantiation context
7052 for diagnostics and to restore it later. */
7054 int
7056 {
7060 {
7061 /* If the instantiation in question still has unbound template parms,
7062 we don't really care if we can't instantiate it, so just return.
7063 This happens with base instantiation for implicit `typename'. */
7075 }
7085 #ifdef GATHER_STATISTICS
7088 #endif
7092 }
7094 /* We're done instantiating this template; return to the instantiation
7095 context. */
7097 void
7099 {
7100 /* Restore the filename and line number stashed away when we started
7101 this instantiation. */
7106 }
7108 /* We're instantiating a deferred template; restore the template
7109 instantiation context in which the instantiation was requested, which
7110 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
7112 static tree
7114 {
7124 }
7126 /* Returns the TINST_LEVEL which gives the original instantiation
7127 context. */
7131 {
7137 }
7139 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
7141 bool
7143 {
7144 tree parms;
7161 }
7163 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
7164 vector of template arguments, as for tsubst.
7166 Returns an appropriate tsubst'd friend declaration. */
7168 static tree
7170 {
7171 tree new_friend;
7176 /* This was a friend declared with an explicit template
7177 argument list, e.g.:
7179 friend void f<>(T);
7181 to indicate that f was a template instantiation, not a new
7182 function declaration. Now, we have to figure out what
7183 instantiation of what template. */
7184 {
7186 tree new_args;
7187 tree tmpl;
7190 /* Friend functions are looked up in the containing namespace scope.
7191 We must enter that scope, to avoid finding member functions of the
7192 current class with same name. */
7207 tsk_none);
7209 }
7213 /* The NEW_FRIEND will look like an instantiation, to the
7214 compiler, but is not an instantiation from the point of view of
7215 the language. For example, we might have had:
7217 template <class T> struct S {
7218 template <class U> friend void f(T, U);
7219 };
7221 Then, in S<int>, template <class U> void f(int, U) is not an
7222 instantiation of anything. */
7228 {
7232 }
7234 /* The mangled name for the NEW_FRIEND is incorrect. The function
7235 is not a template instantiation and should not be mangled like
7236 one. Therefore, we forget the mangling here; we'll recompute it
7237 later if we need it. */
7239 {
7242 }
7245 {
7246 tree old_decl;
7247 tree new_friend_template_info;
7248 tree new_friend_result_template_info;
7249 tree ns;
7252 /* We must save some information from NEW_FRIEND before calling
7253 duplicate decls since that function will free NEW_FRIEND if
7254 possible. */
7256 new_friend_is_defn =
7261 {
7262 /* This declaration is a `primary' template. */
7265 new_friend_result_template_info
7267 }
7268 else
7271 /* Make the init_value nonzero so pushdecl knows this is a defn. */
7275 /* Inside pushdecl_namespace_level, we will push into the
7276 current namespace. However, the friend function should go
7277 into the namespace of the template. */
7287 {
7288 /* This new friend declaration matched an existing
7289 declaration. For example, given:
7291 template <class T> void f(T);
7292 template <class U> class C {
7293 template <class T> friend void f(T) {}
7294 };
7296 the friend declaration actually provides the definition
7297 of `f', once C has been instantiated for some type. So,
7298 old_decl will be the out-of-class template declaration,
7299 while new_friend is the in-class definition.
7301 But, if `f' was called before this point, the
7302 instantiation of `f' will have DECL_TI_ARGS corresponding
7303 to `T' but not to `U', references to which might appear
7304 in the definition of `f'. Previously, the most general
7305 template for an instantiation of `f' was the out-of-class
7306 version; now it is the in-class version. Therefore, we
7307 run through all specialization of `f', adding to their
7308 DECL_TI_ARGS appropriately. In particular, they need a
7309 new set of outer arguments, corresponding to the
7310 arguments for this class instantiation.
7312 The same situation can arise with something like this:
7314 friend void f(int);
7315 template <class T> class C {
7316 friend void f(T) {}
7317 };
7319 when `C<int>' is instantiated. Now, `f(int)' is defined
7320 in the class. */
7323 /* On the other hand, if the in-class declaration does
7324 *not* provide a definition, then we don't want to alter
7325 existing definitions. We can just leave everything
7326 alone. */
7327 ;
7328 else
7329 {
7333 /* Overwrite whatever template info was there before, if
7334 any, with the new template information pertaining to
7335 the declaration. */
7339 {
7340 /* We should have called reregister_specialization in
7341 duplicate_decls. */
7346 /* Instantiate it if the global has already been used. */
7350 }
7351 else
7352 {
7353 tree t;
7355 /* Indicate that the old function template is a partial
7356 instantiation. */
7364 /* Reassign any specializations already in the hash table
7365 to the new more general template, and add the
7366 additional template args. */
7370 {
7372 spec_entry elt;
7384 register_specialization
7387 }
7389 }
7390 }
7392 /* The information from NEW_FRIEND has been merged into OLD_DECL
7393 by duplicate_decls. */
7395 }
7396 }
7397 else
7398 {
7402 /* In the code
7403 template <class T> class C {
7404 template <class U> friend void C1<U>::f (); // case 1
7405 friend void C2<T>::f (); // case 2
7406 };
7407 we only need to make sure CONTEXT is a complete type for
7408 case 2. To distinguish between the two cases, we note that
7409 CONTEXT of case 1 remains dependent type after tsubst while
7410 this isn't true for case 2. */
7420 {
7421 /* Check to see that the declaration is really present, and,
7422 possibly obtain an improved declaration. */
7428 }
7429 }
7432 }
7434 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
7435 template arguments, as for tsubst.
7437 Returns an appropriate tsubst'd friend type or error_mark_node on
7438 failure. */
7440 static tree
7442 {
7443 tree friend_type;
7444 tree tmpl;
7445 tree context;
7450 {
7453 else
7455 }
7457 /* Look for a class template declaration. We look for hidden names
7458 because two friend declarations of the same template are the
7459 same. For example, in:
7461 struct A {
7462 template <typename> friend class F;
7463 };
7464 template <typename> struct B {
7465 template <typename> friend class F;
7466 };
7468 both F templates are the same. */
7473 /* But, if we don't find one, it might be because we're in a
7474 situation like this:
7476 template <class T>
7477 struct S {
7478 template <class U>
7479 friend struct S;
7480 };
7482 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
7483 for `S<int>', not the TEMPLATE_DECL. */
7485 {
7488 }
7491 {
7492 /* The friend template has already been declared. Just
7493 check to see that the declarations match, and install any new
7494 default parameters. We must tsubst the default parameters,
7495 of course. We only need the innermost template parameters
7496 because that is all that redeclare_class_template will look
7497 at. */
7500 {
7501 tree parms;
7502 location_t saved_input_location;
7511 }
7514 }
7515 else
7516 {
7517 /* The friend template has not already been declared. In this
7518 case, the instantiation of the template class will cause the
7519 injection of this template into the global scope. */
7524 /* The new TMPL is not an instantiation of anything, so we
7525 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7526 the new type because that is supposed to be the corresponding
7527 template decl, i.e., TMPL. */
7534 /* Inject this template into the global scope. */
7536 }
7539 {
7542 else
7544 }
7547 }
7549 /* Returns zero if TYPE cannot be completed later due to circularity.
7550 Otherwise returns one. */
7552 static int
7554 {
7564 else
7566 }
7568 /* Apply any attributes which had to be deferred until instantiation
7569 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7570 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7572 static void
7575 {
7577 tree t;
7582 {
7586 }
7589 {
7593 }
7594 else
7598 {
7603 {
7606 {
7609 /* If the first attribute argument is an identifier, don't
7610 pass it through tsubst. Attributes like mode, format,
7611 cleanup and several target specific attributes expect it
7612 unmodified. */
7618 {
7619 tree chain
7621 in_decl,
7626 chain);
7627 }
7628 else
7634 }
7635 else
7637 }
7640 }
7641 }
7643 /* Perform (or defer) access check for typedefs that were referenced
7644 from within the template TMPL code.
7645 This is a subroutine of instantiate_template and instantiate_class_template.
7646 TMPL is the template to consider and TARGS is the list of arguments of
7647 that template. */
7649 static void
7651 {
7652 location_t saved_location;
7667 {
7679 /* Make access check error messages point to the location
7680 of the use of the typedef. */
7684 }
7686 }
7688 tree
7690 {
7692 tree typedecl;
7693 tree pbinfo;
7694 tree base_list;
7705 /* Figure out which template is being instantiated. */
7709 /* Determine what specialization of the original template to
7710 instantiate. */
7713 {
7716 }
7718 {
7719 /* This TYPE is actually an instantiation of a partial
7720 specialization. We replace the innermost set of ARGS with
7721 the arguments appropriate for substitution. For example,
7722 given:
7724 template <class T> struct S {};
7725 template <class T> struct S<T*> {};
7727 and supposing that we are instantiating S<int*>, ARGS will
7728 presently be {int*} -- but we need {int}. */
7731 }
7732 else
7733 {
7736 }
7738 /* If the template we're instantiating is incomplete, then clearly
7739 there's nothing we can do. */
7743 /* If we've recursively instantiated too many templates, stop. */
7747 /* Now we're really doing the instantiation. Mark the type as in
7748 the process of being defined. */
7751 /* We may be in the middle of deferred access check. Disable
7752 it now. */
7756 /* Use #pragma pack from the template context. */
7762 /* Set the input location to the most specialized template definition.
7763 This is needed if tsubsting causes an error. */
7784 {
7787 }
7791 /* We should never instantiate a nested class before its enclosing
7792 class; we need to look up the nested class by name before we can
7793 instantiate it, and that lookup should instantiate the enclosing
7794 class. */
7801 {
7802 tree pbase_binfo;
7804 tree pushed_scope;
7807 /* We must enter the scope containing the type, as that is where
7808 the accessibility of types named in dependent bases are
7809 looked up from. */
7812 /* Substitute into each of the bases to determine the actual
7813 basetypes. */
7815 {
7816 tree base;
7822 {
7823 expanded_bases =
7830 }
7833 {
7835 /* Extract the already-expanded base class. */
7837 else
7838 /* Substitute to figure out the base class. */
7840 NULL_TREE);
7848 }
7849 }
7851 /* The list is now in reverse order; correct that. */
7856 }
7857 /* Now call xref_basetypes to set up all the base-class
7858 information. */
7865 /* Now that our base classes are set up, enter the scope of the
7866 class, so that name lookups into base classes, etc. will work
7867 correctly. This is precisely analogous to what we do in
7868 begin_class_definition when defining an ordinary non-template
7869 class, except we also need to push the enclosing classes. */
7872 /* Now members are processed in the order of declaration. */
7875 {
7879 {
7881 {
7882 /* Build new CLASSTYPE_NESTED_UTDS. */
7884 tree newtag;
7890 /* If the member is a class template, then -- even after
7891 substitution -- there may be dependent types in the
7892 template argument list for the class. We increment
7893 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7894 that function will assume that no types are dependent
7895 when outside of a template. */
7905 {
7909 /* Unfortunately, lookup_template_class sets
7910 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7911 instantiation (i.e., for the type of a member
7912 template class nested within a template class.)
7913 This behavior is required for
7914 maybe_process_partial_specialization to work
7915 correctly, but is not accurate in this case;
7916 the TAG is not an instantiation of anything.
7917 (The corresponding TEMPLATE_DECL is an
7918 instantiation, but the TYPE is not.) */
7921 /* Now, we call pushtag to put this NEWTAG into the scope of
7922 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7923 pushtag calling push_template_decl. We don't have to do
7924 this for enums because it will already have been done in
7925 tsubst_enum. */
7929 }
7930 }
7933 {
7934 /* Build new TYPE_METHODS. */
7935 tree r;
7944 }
7945 else
7946 {
7947 /* Build new TYPE_FIELDS. */
7949 {
7950 tree condition =
7958 }
7960 {
7961 tree r;
7963 /* The file and line for this declaration, to
7964 assist in error message reporting. Since we
7965 called push_tinst_level above, we don't need to
7966 restore these. */
7975 {
7976 /* In [temp.inst]:
7978 [t]he initialization (and any associated
7979 side-effects) of a static data member does
7980 not occur unless the static data member is
7981 itself used in a way that requires the
7982 definition of the static data member to
7983 exist.
7985 Therefore, we do not substitute into the
7986 initialized for the static data member here. */
7987 finish_static_data_member_decl
7995 }
7997 {
7998 /* Determine whether R has a valid type and can be
7999 completed later. If R is invalid, then it is
8000 replaced by error_mark_node so that it will not be
8001 added to TYPE_FIELDS. */
8007 {
8010 }
8011 }
8013 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
8014 such a thing will already have been added to the field
8015 list by tsubst_enum in finish_member_declaration in the
8016 CLASSTYPE_NESTED_UTDS case above. */
8020 {
8023 }
8024 }
8025 }
8026 }
8027 else
8028 {
8030 {
8031 /* Build new CLASSTYPE_FRIEND_CLASSES. */
8037 {
8038 /* template <class T> friend class C; */
8041 }
8043 {
8044 /* template <class T> friend class C::D; */
8050 }
8052 {
8053 /* This could be either
8055 friend class T::C;
8057 when dependent_type_p is false or
8059 template <class U> friend class T::C;
8061 otherwise. */
8064 /* Bump processing_template_decl for correct
8065 dependent_type_p calculation. */
8070 }
8073 {
8074 /* friend class C;
8076 where C hasn't been declared yet. Let's lookup name
8077 from namespace scope directly, bypassing any name that
8078 come from dependent base class. */
8081 /* The call to xref_tag_from_type does injection for friend
8082 classes. */
8084 friend_type =
8088 }
8090 /* friend class C<T>; */
8093 /* Otherwise it's
8095 friend class C;
8097 where C is already declared or
8099 friend class C<int>;
8101 We don't have to do anything in these cases. */
8104 /* Trick make_friend_class into realizing that the friend
8105 we're adding is a template, not an ordinary class. It's
8106 important that we use make_friend_class since it will
8107 perform some error-checking and output cross-reference
8108 information. */
8116 }
8117 else
8118 {
8119 /* Build new DECL_FRIENDLIST. */
8120 tree r;
8122 /* The file and line for this declaration, to
8123 assist in error message reporting. Since we
8124 called push_tinst_level above, we don't need to
8125 restore these. */
8129 {
8132 }
8137 {
8140 }
8141 }
8142 }
8143 }
8145 /* Set the file and line number information to whatever is given for
8146 the class itself. This puts error messages involving generated
8147 implicit functions at a predictable point, and the same point
8148 that would be used for non-template classes. */
8155 /* Now that the class is complete, instantiate default arguments for
8156 any member functions. We don't do this earlier because the
8157 default arguments may reference members of the class. */
8161 /* Implicitly generated member functions will not have template
8162 information; they are not instantiations, but instead are
8163 created "fresh" for each instantiation. */
8167 /* Some typedefs referenced from within the template code need to be access
8168 checked at template instantiation time, i.e now. These types were
8169 added to the template at parsing time. Let's get those and perform
8170 the access checks then. */
8179 /* The vtable for a template class can be emitted in any translation
8180 unit in which the class is instantiated. When there is no key
8181 method, however, finish_struct_1 will already have added TYPE to
8182 the keyed_classes list. */
8187 }
8189 static tree
8191 {
8192 tree r;
8198 else
8199 {
8203 }
8205 }
8207 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
8208 NONTYPE_ARGUMENT_PACK. */
8210 static tree
8212 {
8213 /* Collect all of the extra "packed" parameters into an
8214 argument pack. */
8215 tree parmvec;
8216 tree parmtypevec;
8221 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
8225 {
8228 }
8230 /* Build the argument packs. */
8236 }
8238 /* Substitute ARGS into T, which is an pack expansion
8239 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
8240 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
8241 (if only a partial substitution could be performed) or
8242 ERROR_MARK_NODE if there was an error. */
8243 tree
8245 tree in_decl)
8246 {
8247 tree pattern;
8250 tree result;
8257 /* Determine the argument packs that will instantiate the parameter
8258 packs used in the expansion expression. While we're at it,
8259 compute the number of arguments to be expanded and make sure it
8260 is consistent. */
8263 {
8269 {
8272 {
8273 /* This can happen for a parameter name used later in a function
8274 declaration (such as in a late-specified return type). Just
8275 make a dummy decl, since it's only used for its type. */
8279 }
8280 }
8281 else
8282 {
8289 }
8296 /* This can only happen if we forget to expand an argument
8297 pack somewhere else. Just return an error, silently. */
8298 {
8302 }
8307 {
8312 /* The argument pack that the parameter maps to is just an
8313 expansion of the parameter itself, such as one would
8314 find in the implicit typedef of a class inside the
8315 class itself. Consider this parameter "unsubstituted",
8316 so that we will maintain the outer pack expansion. */
8318 }
8321 {
8325 /* It's all-or-nothing with incomplete argument packs. */
8335 {
8337 /* We got explicit args for some packs but not others;
8338 do nothing now and try again after deduction. */
8343 pattern);
8344 else
8347 pattern);
8349 }
8351 /* Keep track of the parameter packs and their corresponding
8352 argument packs. */
8355 }
8356 else
8357 /* We can't substitute for this parameter pack. */
8360 unsubstituted_packs);
8361 }
8363 /* We cannot expand this expansion expression, because we don't have
8364 all of the argument packs we need. Substitute into the pattern
8365 and return a PACK_EXPANSION_*. The caller will need to deal with
8366 that. */
8368 {
8369 tree new_pat;
8373 else
8376 }
8378 /* We could not find any argument packs that work. */
8383 {
8384 /* We're in a late-specified return type, so we don't have a local
8385 specializations table. Create one for doing this expansion. */
8388 hash_local_specialization,
8389 eq_local_specializations,
8390 NULL);
8391 }
8393 /* For each argument in each argument pack, substitute into the
8394 pattern. */
8397 {
8398 /* For parameter pack, change the substitution of the parameter
8399 pack to the ith argument in its argument pack, then expand
8400 the pattern. */
8402 {
8406 {
8407 /* Select the Ith argument from the pack. */
8413 }
8414 else
8415 {
8421 {
8422 /* Select the Ith argument from the pack. */
8426 }
8428 /* Update the corresponding argument. */
8430 }
8431 }
8433 /* Substitute into the PATTERN with the altered arguments. */
8438 else
8442 /* When we have incomplete argument packs, the last "expanded"
8443 result is itself a pack expansion, which allows us
8444 to deduce more arguments. */
8449 {
8452 }
8453 }
8455 /* Update ARGS to restore the substitution from parameter packs to
8456 their argument packs. */
8458 {
8463 else
8464 {
8468 /* Update the corresponding argument. */
8472 else
8474 }
8475 }
8478 {
8481 }
8484 }
8486 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
8487 TMPL. We do this using DECL_PARM_INDEX, which should work even with
8488 parameter packs; all parms generated from a function parameter pack will
8489 have the same DECL_PARM_INDEX. */
8491 tree
8493 {
8495 tree patparm;
8498 {
8504 }
8505 else
8506 {
8511 }
8514 }
8516 /* Substitute ARGS into the vector or list of template arguments T. */
8518 static tree
8520 {
8527 {
8529 tree new_arg;
8534 {
8535 /* Substitute into an expansion expression. */
8539 /* Add to the expanded length adjustment the number of
8540 expanded arguments. We subtract one from this
8541 measurement, because the argument pack expression
8542 itself is already counted as 1 in
8543 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
8544 the argument pack is empty. */
8546 }
8548 {
8549 /* Substitute into each of the arguments. */
8555 new_arg,
8569 }
8570 }
8571 else
8580 }
8585 /* Make space for the expanded arguments coming from template
8586 argument packs. */
8588 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
8589 arguments for a member template.
8590 In that case each TREE_VEC in ORIG_T represents a level of template
8591 arguments, and ORIG_T won't carry any non defaulted argument count.
8592 It will rather be the nested TREE_VECs that will carry one.
8593 In other words, ORIG_T carries a non defaulted argument count only
8594 if it doesn't contain any nested TREE_VEC. */
8596 {
8600 }
8602 {
8606 {
8609 /* Now expand the template argument pack "in place". */
8612 }
8613 else
8614 {
8616 out++;
8617 }
8618 }
8621 }
8623 /* Return the result of substituting ARGS into the template parameters
8624 given by PARMS. If there are m levels of ARGS and m + n levels of
8625 PARMS, then the result will contain n levels of PARMS. For
8626 example, if PARMS is `template <class T> template <class U>
8627 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8628 result will be `template <int*, double, class V>'. */
8630 static tree
8632 {
8636 /* When substituting into a template, we must set
8637 PROCESSING_TEMPLATE_DECL as the template parameters may be
8638 dependent if they are based on one-another, and the dependency
8639 predicates are short-circuit outside of templates. */
8646 {
8647 tree new_vec =
8652 {
8653 tree tuple;
8654 tree default_value;
8655 tree parm_decl;
8677 }
8683 }
8688 }
8690 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8691 type T. If T is not an aggregate or enumeration type, it is
8692 handled as if by tsubst. IN_DECL is as for tsubst. If
8693 ENTERING_SCOPE is nonzero, T is the context for a template which
8694 we are presently tsubst'ing. Return the substituted value. */
8696 static tree
8698 tree args,
8699 tsubst_flags_t complain,
8700 tree in_decl,
8702 {
8707 {
8712 /* Else fall through. */
8716 {
8717 tree argvec;
8718 tree context;
8719 tree r;
8723 /* In "sizeof(X<I>)" we need to evaluate "I". */
8729 /* First, determine the context for the type we are looking
8730 up. */
8733 {
8736 /* If context is a nested class inside a class template,
8737 it may still need to be instantiated (c++/33959). */
8740 }
8742 /* Then, figure out what arguments are appropriate for the
8743 type we are trying to find. For example, given:
8745 template <class T> struct S;
8746 template <class T, class U> void f(T, U) { S<U> su; }
8748 and supposing that we are instantiating f<int, double>,
8749 then our ARGS will be {int, double}, but, when looking up
8750 S we only want {double}. */
8755 else
8756 {
8760 }
8766 }
8767 else
8768 /* This is not a template type, so there's nothing to do. */
8773 }
8774 }
8776 /* Substitute into the default argument ARG (a default argument for
8777 FN), which has the indicated TYPE. */
8779 tree
8781 {
8785 /* This default argument came from a template. Instantiate the
8786 default argument here, not in tsubst. In the case of
8787 something like:
8789 template <class T>
8790 struct S {
8791 static T t();
8792 void f(T = t());
8793 };
8795 we must be careful to do name lookup in the scope of S<T>,
8796 rather than in the current class. */
8798 /* The "this" pointer is not valid in a default argument. */
8800 {
8805 }
8808 /* The default argument expression may cause implicitly defined
8809 member functions to be synthesized, which will result in garbage
8810 collection. We must treat this situation as if we were within
8811 the body of function so as to avoid collecting live data on the
8812 stack. */
8820 /* Restore the "this" pointer. */
8822 {
8825 }
8827 /* Make sure the default argument is reasonable. */
8833 }
8835 /* Substitute into all the default arguments for FN. */
8837 static void
8839 {
8840 tree arg;
8841 tree tmpl_args;
8845 /* If this function is not yet instantiated, we certainly don't need
8846 its default arguments. */
8851 arg;
8857 }
8859 /* Substitute the ARGS into the T, which is a _DECL. Return the
8860 result of the substitution. Issue error and warning messages under
8861 control of COMPLAIN. */
8863 static tree
8865 {
8866 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
8867 location_t saved_loc;
8872 /* Set the filename and linenumber to improve error-reporting. */
8877 {
8879 {
8880 /* We can get here when processing a member function template,
8881 member class template, or template template parameter. */
8883 tree spec;
8884 tree tmpl_args;
8885 tree full_args;
8888 {
8889 /* Template template parameter is treated here. */
8902 complain);
8905 }
8907 /* We might already have an instance of this template.
8908 The ARGS are for the surrounding class type, so the
8909 full args contain the tsubst'd args for the context,
8910 plus the innermost args from the template decl. */
8914 /* Because this is a template, the arguments will still be
8915 dependent, even after substitution. If
8916 PROCESSING_TEMPLATE_DECL is not set, the dependency
8917 predicates will short-circuit. */
8925 /* If this is a default template template argument,
8926 tsubst might not have changed anything. */
8933 {
8936 }
8938 /* Make a new template decl. It will be similar to the
8939 original, but will record the current template arguments.
8940 We also create a new function declaration, which is just
8941 like the old one, but points to this new template, rather
8942 than the old one. */
8950 {
8951 tree new_type;
8963 }
8964 else
8965 {
8966 tree new_decl;
8978 }
8984 /* The template parameters for this new template are all the
8985 template parameters for the old template, except the
8986 outermost level of parameters. */
8989 complain);
8995 /* Record this non-type partial instantiation. */
8999 }
9003 {
9004 tree ctx;
9007 tree gen_tmpl;
9008 tree type;
9013 /* Nobody should be tsubst'ing into non-template functions. */
9017 {
9018 tree spec;
9021 /* If T is not dependent, just return it. We have to
9022 increment PROCESSING_TEMPLATE_DECL because
9023 value_dependent_expression_p assumes that nothing is
9024 dependent when PROCESSING_TEMPLATE_DECL is zero. */
9031 /* Calculate the most general template of which R is a
9032 specialization, and the complete set of arguments used to
9033 specialize R. */
9036 (DECL_TEMPLATE_RESULT
9040 /* Check to see if we already have this specialization. */
9045 {
9048 }
9050 /* We can see more levels of arguments than parameters if
9051 there was a specialization of a member template, like
9052 this:
9054 template <class T> struct S { template <class U> void f(); }
9055 template <> template <class U> void S<int>::f(U);
9057 Here, we'll be substituting into the specialization,
9058 because that's where we can find the code we actually
9059 want to generate, but we'll have enough arguments for
9060 the most general template.
9062 We also deal with the peculiar case:
9064 template <class T> struct S {
9065 template <class U> friend void f();
9066 };
9067 template <class U> void f() {}
9068 template S<int>;
9069 template void f<double>();
9071 Here, the ARGS for the instantiation of will be {int,
9072 double}. But, we only need as many ARGS as there are
9073 levels of template parameters in CODE_PATTERN. We are
9074 careful not to get fooled into reducing the ARGS in
9075 situations like:
9077 template <class T> struct S { template <class U> void f(U); }
9078 template <class T> template <> void S<T>::f(int) {}
9080 which we can spot because the pattern will be a
9081 specialization in this case. */
9083 parms_depth =
9088 }
9089 else
9090 {
9091 /* This special case arises when we have something like this:
9093 template <class T> struct S {
9094 friend void f<int>(int, double);
9095 };
9097 Here, the DECL_TI_TEMPLATE for the friend declaration
9098 will be an IDENTIFIER_NODE. We are being called from
9099 tsubst_friend_function, and we want only to create a
9100 new decl (R) with appropriate types so that we can call
9101 determine_specialization. */
9103 }
9106 {
9109 else
9113 }
9114 else
9115 {
9118 }
9123 /* We do NOT check for matching decls pushed separately at this
9124 point, as they may not represent instantiations of this
9125 template, and in any case are considered separate under the
9126 discrete model. */
9130 /* Clear out the mangled name and RTL for the instantiation. */
9133 /* Leave DECL_INITIAL set on deleted instantiations. */
9139 /* Type-conversion operator. Reconstruct the name, in
9140 case it's the name of one of the template's parameters. */
9150 /* If this is an instantiation of a function with internal
9151 linkage, we already know what object file linkage will be
9152 assigned to the instantiation. */
9161 /* We'll re-clone as appropriate in instantiate_template. */
9164 /* If we aren't complaining now, return on error before we register
9165 the specialization so that we'll complain eventually. */
9171 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
9172 this in the special friend case mentioned above where
9173 GEN_TMPL is NULL. */
9175 {
9181 /* We're not supposed to instantiate default arguments
9182 until they are called, for a template. But, for a
9183 declaration like:
9185 template <class T> void f ()
9186 { extern void g(int i = T()); }
9188 we should do the substitution when the template is
9189 instantiated. We handle the member function case in
9190 instantiate_class_template since the default arguments
9191 might refer to other members of the class. */
9196 }
9197 else
9200 /* Copy the list of befriending classes. */
9204 {
9208 in_decl);
9209 }
9212 {
9216 /* If this is an instantiation of a member template, clone it.
9217 If it isn't, that'll be handled by
9218 clone_constructors_and_destructors. */
9221 }
9232 /* Possibly limit visibility based on template args. */
9235 {
9239 }
9247 }
9251 {
9259 {
9260 /* If there is a local specialization that isn't a
9261 parameter pack, it means that we're doing a "simple"
9262 substitution from inside tsubst_pack_expansion. Just
9263 return the local specialization (which will be a single
9264 parm). */
9271 /* Expand the TYPE_PACK_EXPANSION that provides the types for
9272 the parameters in this function parameter pack. */
9276 {
9279 /* Zero-length parameter packs are boring. Just substitute
9280 into the chain. */
9284 }
9285 else
9286 {
9287 /* All we did was update the type. Make a note of that. */
9290 }
9291 }
9293 /* Loop through all of the parameter's we'll build. When T is
9294 a function parameter pack, LEN is the number of expanded
9295 types in EXPANDED_TYPES; otherwise, LEN is 1. */
9298 {
9304 /* An argument of a function parameter pack is not a parameter
9305 pack. */
9309 /* We're on the Ith parameter of the function parameter
9310 pack. */
9311 {
9312 /* Get the Ith type. */
9316 /* Rename the parameter to include the index. */
9319 }
9321 /* We're dealing with a normal parameter. */
9329 {
9332 else
9335 }
9345 /* Keep track of the first new parameter we
9346 generate. That's what will be returned to the
9347 caller. */
9351 /* Build a proper chain of parameters when substituting
9352 into a function parameter pack. */
9355 }
9361 /* FIRST_R contains the start of the chain we've built. */
9363 }
9367 {
9368 tree type;
9377 /* DECL_INITIAL gives the number of bits in a bit-field. */
9382 /* We don't have to set DECL_CONTEXT here; it is set by
9383 finish_member_declaration. */
9390 }
9394 /* We reach here only for member using decls. */
9396 {
9397 r = do_class_using_decl
9402 else
9403 {
9406 }
9407 }
9408 else
9409 {
9412 }
9417 {
9420 tree spec;
9422 tree ctx;
9428 {
9429 /* If this is the canonical decl, we don't have to
9430 mess with instantiations, and often we can't (for
9431 typename, template type parms and such). Note that
9432 TYPE_NAME is not correct for the above test if
9433 we've copied the type for a typedef. */
9439 }
9441 /* Check to see if we already have the specialization we
9442 need. */
9445 {
9446 /* T is a static data member or namespace-scope entity.
9447 We have to substitute into namespace-scope variables
9448 (even though such entities are never templates) because
9449 of cases like:
9451 template <class T> void f() { extern T t; }
9453 where the entity referenced is not known until
9454 instantiation time. */
9458 {
9460 complain,
9462 /* If CTX is unchanged, then T is in fact the
9463 specialization we want. That situation occurs when
9464 referencing a static data member within in its own
9465 class. We can use pointer equality, rather than
9466 same_type_p, because DECL_CONTEXT is always
9467 canonical. */
9470 }
9473 {
9479 }
9480 }
9481 else
9482 {
9483 /* A local variable. */
9485 /* Subsequent calls to pushdecl will fill this in. */
9488 }
9489 /* If we already have the specialization we need, there is
9490 nothing more to do. */
9492 {
9495 }
9497 /* Create a new node for the specialization we need. */
9500 {
9503 else
9508 }
9510 {
9511 /* Even if the original location is out of scope, the
9512 newly substituted one is not. */
9519 {
9520 /* It may seem that this case cannot occur, since:
9522 typedef void f();
9523 void g() { f x; }
9525 declares a function, not a variable. However:
9527 typedef void f();
9528 template <typename T> void g() { T t; }
9529 template void g<f>();
9531 is an attempt to declare a variable with function
9532 type. */
9534 /* R is not yet sufficiently initialized, so we
9535 just use its name. */
9538 }
9545 {
9550 }
9551 }
9557 /* Clear out the mangled name and RTL for the instantiation. */
9561 /* The initializer must not be expanded until it is required;
9562 see [temp.inst]. */
9568 {
9569 /* Possibly limit visibility based on template args. */
9572 {
9576 }
9578 }
9581 {
9582 /* A static data member declaration is always marked
9583 external when it is declared in-class, even if an
9584 initializer is present. We mimic the non-template
9585 processing here. */
9591 }
9593 {
9594 /* We're substituting this var in a decltype outside of its
9595 scope, such as for a lambda return type. Don't add it to
9596 local_specializations, do perform auto deduction. */
9598 tree init
9603 {
9606 }
9607 }
9608 else
9617 /* Preserve a typedef that names a type. */
9619 {
9622 }
9625 }
9630 }
9631 #undef RETURN
9633 out:
9634 /* Restore the file and line information. */
9638 }
9640 /* Substitute into the ARG_TYPES of a function type. */
9642 static tree
9644 tree args,
9645 tsubst_flags_t complain,
9646 tree in_decl)
9647 {
9648 tree remaining_arg_types;
9652 tree default_arg;
9663 {
9664 /* For a pack expansion, perform substitution on the
9665 entire expression. Later on, we'll handle the arguments
9666 one-by-one. */
9671 /* So that we'll spin through the parameters, one by one. */
9673 else
9674 {
9675 /* We only partially substituted into the parameter
9676 pack. Our type is TYPE_PACK_EXPANSION. */
9679 }
9680 }
9693 {
9695 {
9699 }
9701 }
9703 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9704 top-level qualifiers as required. */
9707 /* We do not substitute into default arguments here. The standard
9708 mandates that they be instantiated only when needed, which is
9709 done in build_over_call. */
9713 {
9714 /* We've instantiated a template before its default arguments
9715 have been parsed. This can happen for a nested template
9716 class, and is not an error unless we require the default
9717 argument in a call of this function. */
9718 remaining_arg_types =
9721 remaining_arg_types);
9722 }
9723 else
9724 remaining_arg_types =
9726 }
9729 }
9731 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9732 *not* handle the exception-specification for FNTYPE, because the
9733 initial substitution of explicitly provided template parameters
9734 during argument deduction forbids substitution into the
9735 exception-specification:
9737 [temp.deduct]
9739 All references in the function type of the function template to the
9740 corresponding template parameters are replaced by the specified tem-
9741 plate argument values. If a substitution in a template parameter or
9742 in the function type of the function template results in an invalid
9743 type, type deduction fails. [Note: The equivalent substitution in
9744 exception specifications is done only when the function is instanti-
9745 ated, at which point a program is ill-formed if the substitution
9746 results in an invalid type.] */
9748 static tree
9750 tree args,
9751 tsubst_flags_t complain,
9752 tree in_decl)
9753 {
9754 tree return_type;
9755 tree arg_types;
9756 tree fntype;
9758 /* The TYPE_CONTEXT is not used for function/method types. */
9761 /* Substitute the return type. */
9765 /* The standard does not presently indicate that creation of a
9766 function type with an invalid return type is a deduction failure.
9767 However, that is clearly analogous to creating an array of "void"
9768 or a reference to a reference. This is core issue #486. */
9771 {
9773 {
9776 else
9778 }
9780 }
9782 /* Substitute the argument types. */
9788 /* Construct a new type node and return it. */
9791 else
9792 {
9795 {
9796 /* [temp.deduct]
9798 Type deduction may fail for any of the following
9799 reasons:
9801 -- Attempting to create "pointer to member of T" when T
9802 is not a class type. */
9805 r);
9807 }
9811 }
9816 }
9818 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9819 ARGS into that specification, and return the substituted
9820 specification. If there is no specification, return NULL_TREE. */
9822 static tree
9824 tree args,
9825 tsubst_flags_t complain,
9826 tree in_decl)
9827 {
9828 tree specs;
9829 tree new_specs;
9834 {
9837 else
9839 {
9840 tree spec;
9845 {
9846 /* Expand the pack expansion type. */
9849 in_decl);
9855 else
9856 {
9857 /* We're substituting into a member template, so
9858 we got a TYPE_PACK_EXPANSION back. Add that
9859 expansion and move on. */
9863 expanded_specs,
9864 complain);
9867 }
9868 }
9871 {
9874 else
9879 complain);
9880 }
9883 }
9884 }
9886 }
9888 /* Take the tree structure T and replace template parameters used
9889 therein with the argument vector ARGS. IN_DECL is an associated
9890 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9891 Issue error and warning messages under control of COMPLAIN. Note
9892 that we must be relatively non-tolerant of extensions here, in
9893 order to preserve conformance; if we allow substitutions that
9894 should not be allowed, we may allow argument deductions that should
9895 not succeed, and therefore report ambiguous overload situations
9896 where there are none. In theory, we could allow the substitution,
9897 but indicate that it should have failed, and allow our caller to
9898 make sure that the right thing happens, but we don't try to do this
9899 yet.
9901 This function is used for dealing with types, decls and the like;
9902 for expressions, use tsubst_expr or tsubst_copy. */
9904 tree
9906 {
9925 else
9930 /* Reuse typedefs. We need to do this to handle dependent attributes,
9931 such as attribute aligned. */
9935 {
9941 {
9945 }
9950 else
9951 /* The typedef is from a non-template context. */
9955 {
9957 r = cp_build_qualified_type_real
9961 }
9962 /* Else we must be instantiating the typedef, so fall through. */
9963 }
9976 {
10003 {
10009 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
10010 needed. */
10018 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
10019 with TREE_SIDE_EFFECTS that indicates this is not an integral
10020 constant expression. */
10023 {
10026 }
10032 {
10036 }
10038 /* [temp.deduct]
10040 Type deduction may fail for any of the following
10041 reasons:
10043 Attempting to create an array with a size that is
10044 zero or negative. */
10046 /* We must fail if performing argument deduction (as
10047 indicated by the state of complain), so that
10048 another substitution can be found. */
10052 {
10057 }
10060 }
10066 {
10079 {
10083 /* See through ARGUMENT_PACK_SELECT arguments. */
10085 }
10090 {
10092 /* If ARG is an argument pack, we don't actually want to
10093 perform a substitution here, because substitutions
10094 for argument packs are only done
10095 element-by-element. We can get to this point when
10096 substituting the type of a non-type template
10097 parameter pack, when that type actually contains
10098 template parameter packs from an outer template, e.g.,
10100 template<typename... Types> struct A {
10101 template<Types... Values> struct B { };
10102 }; */
10106 {
10110 /* cv-quals from the template are discarded when
10111 substituting in a function or reference type. */
10116 else
10119 return cp_build_qualified_type_real
10121 }
10123 {
10124 /* We are processing a type constructed from a
10125 template template parameter. */
10131 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
10132 are resolving nested-types in the signature of a
10133 member function templates. Otherwise ARG is a
10134 TEMPLATE_DECL and is the real template to be
10135 instantiated. */
10143 complain);
10144 return cp_build_qualified_type_real
10146 }
10147 else
10148 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
10150 }
10153 /* This can happen during the attempted tsubst'ing in
10154 unify. This means that we don't yet have any information
10155 about the template parameter in question. */
10158 /* If we get here, we must have been looking at a parm for a
10159 more deeply nested template. Make a new version of this
10160 template parameter, but with a lower level. */
10162 {
10167 {
10169 r = cp_build_qualified_type_real
10173 }
10174 else
10175 {
10186 /* We have reduced the level of the template
10187 template parameter, but not the levels of its
10188 template parameters, so canonical_type_parameter
10189 will not be able to find the canonical template
10190 template parameter for this level. Thus, we
10191 require structural equality checking to compare
10192 TEMPLATE_TEMPLATE_PARMs. */
10196 else
10200 {
10208 }
10209 }
10218 }
10221 }
10224 {
10232 {
10236 }
10239 {
10243 }
10246 {
10250 }
10256 }
10259 /* We should never be tsubsting a binfo. */
10263 /* A vector of template arguments. */
10269 {
10278 /* [temp.deduct]
10280 Type deduction may fail for any of the following
10281 reasons:
10283 -- Attempting to create a pointer to reference type.
10284 -- Attempting to create a reference to a reference type or
10285 a reference to void.
10287 Core issue 106 says that creating a reference to a reference
10288 during instantiation is no longer a cause for failure. We
10289 only enforce this check in strict C++98 mode. */
10293 {
10296 /* We keep track of the last time we issued this error
10297 message to avoid spewing a ton of messages during a
10298 single bad template instantiation. */
10301 {
10306 else
10309 }
10312 }
10314 {
10318 }
10320 /* In C++0x, during template argument substitution, when there is an
10321 attempt to create a reference to a reference type, reference
10322 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
10324 "If a template-argument for a template-parameter T names a type
10325 that is a reference to a type A, an attempt to create the type
10326 'lvalue reference to cv T' creates the type 'lvalue reference to
10327 A,' while an attempt to create the type type rvalue reference to
10328 cv T' creates the type T"
10329 */
10330 r = cp_build_reference_type
10333 else
10338 /* Will this ever be needed for TYPE_..._TO values? */
10342 }
10344 {
10347 {
10348 /* [temp.deduct]
10350 Type deduction may fail for any of the following
10351 reasons:
10353 -- Attempting to create "pointer to member of T" when T
10354 is not a class type. */
10358 }
10360 {
10364 }
10366 {
10370 }
10373 {
10374 /* The type of the implicit object parameter gets its
10375 cv-qualifiers from the FUNCTION_TYPE. */
10376 tree memptr;
10380 complain);
10381 }
10382 else
10385 complain);
10386 }
10389 {
10390 tree fntype;
10391 tree specs;
10396 /* Substitute the exception specification. */
10398 in_decl);
10404 }
10406 {
10411 /* As an optimization, we avoid regenerating the array type if
10412 it will obviously be the same as T. */
10416 /* These checks should match the ones in grokdeclarator.
10418 [temp.deduct]
10420 The deduction may fail for any of the following reasons:
10422 -- Attempting to create an array with an element type that
10423 is void, a function type, or a reference type, or [DR337]
10424 an abstract class type. */
10428 {
10432 }
10434 {
10437 type);
10439 }
10444 {
10447 }
10450 }
10454 {
10463 }
10467 {
10473 }
10476 {
10486 {
10490 }
10492 {
10493 /* Normally, make_typename_type does not require that the CTX
10494 have complete type in order to allow things like:
10496 template <class T> struct S { typename S<T>::X Y; };
10498 But, such constructs have already been resolved by this
10499 point, so here CTX really should have complete type, unless
10500 it's a partial instantiation. */
10504 {
10508 }
10509 }
10516 {
10519 }
10522 {
10529 }
10531 return cp_build_qualified_type_real
10533 }
10536 {
10548 }
10556 {
10564 }
10567 {
10575 }
10578 {
10579 tree type;
10595 complain);
10596 }
10599 {
10600 tree type;
10616 else
10617 type = finish_decltype_type
10622 complain);
10623 }
10627 {
10631 tree packed_out =
10633 args,
10634 complain,
10635 in_decl);
10638 /* For template nontype argument packs, also substitute into
10639 the type. */
10644 }
10651 }
10652 }
10654 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10655 type of the expression on the left-hand side of the "." or "->"
10656 operator. */
10658 static tree
10661 {
10662 tree name;
10663 tree qualifying_scope;
10664 tree fns;
10665 tree optype;
10669 /* A baselink indicates a function from a base class. Both the
10670 BASELINK_ACCESS_BINFO and the base class referenced may
10671 indicate bases of the template class, rather than the
10672 instantiated class. In addition, lookups that were not
10673 ambiguous before may be ambiguous now. Therefore, we perform
10674 the lookup again. */
10681 {
10688 }
10694 /* If lookup found a single function, mark it as used at this
10695 point. (If it lookup found multiple functions the one selected
10696 later by overload resolution will be marked as used at that
10697 point.) */
10703 /* Add back the template arguments, if present. */
10708 template_args);
10709 /* Update the conversion operator type. */
10715 qualifying_scope,
10716 object_type);
10717 }
10719 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10720 true if the qualified-id will be a postfix-expression in-and-of
10721 itself; false if more of the postfix-expression follows the
10722 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10723 of "&". */
10725 static tree
10729 {
10730 tree expr;
10731 tree scope;
10732 tree name;
10734 tree template_args;
10738 /* Figure out what name to look up. */
10741 {
10748 }
10749 else
10750 {
10753 }
10755 /* Substitute into the qualifying scope. When there are no ARGS, we
10756 are just trying to simplify a non-dependent expression. In that
10757 case the qualifying scope may be dependent, and, in any case,
10758 substituting will not help. */
10761 {
10764 }
10765 else
10773 {
10775 {
10776 /* A BIT_NOT_EXPR is used to represent a destructor. */
10778 {
10782 }
10783 else
10786 }
10787 else
10791 {
10793 {
10797 }
10799 }
10800 }
10803 {
10805 scope);
10806 /* Remember that there was a reference to this entity. */
10808 }
10811 {
10817 }
10826 {
10827 expr = (adjust_result_of_qualified_name_lookup
10829 expr = (finish_qualified_id_expr
10833 }
10835 /* Expressions do not generally have reference type. */
10837 /* However, if we're about to form a pointer-to-member, we just
10838 want the referenced member referenced. */
10843 }
10845 /* Like tsubst, but deals with expressions. This function just replaces
10846 template parms; to finish processing the resultant expression, use
10847 tsubst_expr. */
10849 static tree
10851 {
10853 tree r;
10861 {
10866 {
10867 tree c;
10868 /* This can happen for a parameter name used later in a function
10869 declaration (such as in a late-specified return type). Just
10870 make a dummy decl, since it's only used for its type. */
10872 /* We copy T because want to tsubst the PARM_DECL only,
10873 not the following PARM_DECLs that are chained to T. */
10876 /* Give it the template pattern as its context; its true context
10877 hasn't been instantiated yet and this is good enough for
10878 mangling. */
10880 }
10888 {
10889 tree enum_type;
10890 tree v;
10894 /* There is no need to substitute into namespace-scope
10895 enumerators. */
10898 /* If ARGS is NULL, then T is known to be non-dependent. */
10902 /* Unfortunately, we cannot just call lookup_name here.
10903 Consider:
10905 template <int I> int f() {
10906 enum E { a = I };
10907 struct S { void g() { E e = a; } };
10908 };
10910 When we instantiate f<7>::S::g(), say, lookup_name is not
10911 clever enough to find f<7>::a. */
10912 enum_type
10922 /* We didn't find the name. That should never happen; if
10923 name-lookup found it during preliminary parsing, we
10924 should find it again here during instantiation. */
10926 }
10931 {
10932 tree ctx;
10937 {
10940 {
10944 }
10946 }
10947 }
10970 {
10971 /* Template template argument like the following example need
10972 special treatment:
10974 template <template <class> class TT> struct C {};
10975 template <class T> struct D {
10976 template <class U> struct E {};
10977 C<E> c; // #1
10978 };
10979 D<int> d; // #2
10981 We are processing the template argument `E' in #1 for
10982 the template instantiation #2. Originally, `E' is a
10983 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10984 have to substitute this with one having context `D<int>'. */
10988 }
10989 else
10990 /* Ordinary template template argument. */
10999 return build1
11005 {
11006 /* We only want to compute the number of arguments. */
11020 {
11027 else
11030 }
11031 else
11033 }
11034 /* Fall through */
11048 return build1
11053 {
11054 tree object;
11055 tree name;
11060 {
11064 }
11067 {
11077 }
11082 in_decl);
11083 else
11086 }
11124 return build_nt
11137 return build_nt
11144 {
11152 }
11157 {
11158 r = build_nt
11164 }
11167 {
11168 r = build_nt
11174 }
11177 {
11178 r = build_nt
11184 }
11187 {
11188 /* Substituted template arguments */
11197 }
11200 {
11220 }
11245 {
11248 }
11249 else
11253 /* This is handled by tsubst_copy_and_build. */
11258 in_decl),
11262 /* We shouldn't have built any of these during initial template
11263 generation. Instead, they should be built during instantiation
11264 in response to the saved STMT_IS_FULL_EXPR_P setting. */
11281 }
11282 }
11284 /* Like tsubst_copy, but specifically for OpenMP clauses. */
11286 static tree
11288 tree in_decl)
11289 {
11293 {
11299 {
11302 {
11308 }
11309 /* FALLTHRU */
11331 }
11332 }
11335 }
11337 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
11339 static tree
11341 tree in_decl)
11342 {
11343 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
11368 #undef RECUR
11369 }
11371 /* Substitute one OMP_FOR iterator. */
11373 static void
11378 {
11379 #define RECUR(NODE) \
11380 tsubst_expr ((NODE), args, complain, in_decl, \
11381 integral_constant_expression_p)
11390 {
11397 }
11401 {
11407 complain);
11408 else
11415 }
11418 {
11419 tree c;
11421 {
11432 }
11434 {
11439 {
11442 }
11443 }
11444 }
11450 else
11454 {
11465 {
11472 }
11473 else
11479 {
11485 }
11489 {
11496 }
11497 else
11503 }
11509 #undef RECUR
11510 }
11512 /* Like tsubst_copy for expressions, etc. but also does semantic
11513 processing. */
11515 static tree
11518 {
11519 #define RECUR(NODE) \
11520 tsubst_expr ((NODE), args, complain, in_decl, \
11521 integral_constant_expression_p)
11534 {
11536 {
11537 tree_stmt_iterator i;
11541 }
11556 else
11565 {
11566 tree decl;
11567 tree init;
11573 {
11576 tree decl;
11584 else
11586 }
11587 else
11588 {
11592 {
11593 /* By marking the declaration as instantiated, we avoid
11594 trying to instantiate it. Since instantiate_decl can't
11595 handle local variables, and since we've already done
11596 all that needs to be done, that's the right thing to
11597 do. */
11602 /* Anonymous aggregates are a special case. */
11604 else
11605 {
11609 {
11610 /* For __PRETTY_FUNCTION__ we have to adjust the
11611 initializer. */
11615 }
11616 else
11617 {
11621 /* If we had an initializer but it
11622 instantiated to nothing,
11623 value-initialize the object. This will
11624 only occur when the initializer was a
11625 pack expansion where the parameter packs
11626 used in that expansion were of length
11627 zero. */
11629 else
11631 }
11634 }
11635 }
11636 }
11638 /* A DECL_EXPR can also be used as an expression, in the condition
11639 clause of an if/for/while construct. */
11641 }
11679 {
11683 }
11691 else
11699 else
11726 {
11728 tree label;
11733 }
11739 /* Computed goto's must be tsubst'd into. On the other hand,
11740 non-computed gotos must not be; the identifier in question
11741 will have no binding. */
11743 else
11749 tmp = finish_asm_stmt
11756 {
11761 }
11766 {
11771 }
11772 else
11773 {
11778 else
11785 else
11791 else
11793 }
11797 {
11801 {
11803 /* Prevent instantiate_decl from trying to instantiate
11804 this variable. We've already done all that needs to be
11805 done. */
11808 }
11813 }
11821 {
11822 tree condition =
11824 args,
11831 }
11852 {
11867 integral_constant_expression_p);
11876 {
11880 }
11881 else
11882 {
11890 }
11904 }
11935 {
11940 }
11956 integral_constant_expression_p);
11957 }
11960 #undef RECUR
11961 }
11963 /* T is a postfix-expression that is not being used in a function
11964 call. Return the substituted version of T. */
11966 static tree
11968 tsubst_flags_t complain,
11969 tree in_decl)
11970 {
11974 else
11980 }
11982 /* Like tsubst but deals with expressions and performs semantic
11983 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11985 tree
11987 tree args,
11988 tsubst_flags_t complain,
11989 tree in_decl,
11992 {
11993 #define RECUR(NODE) \
11994 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11996 integral_constant_expression_p)
11998 tree op1;
12004 {
12007 /* Fall through. */
12009 {
12010 tree decl;
12011 cp_id_kind idk;
12016 {
12019 }
12021 /* Look up the name. */
12024 /* By convention, expressions use ERROR_MARK_NODE to indicate
12025 failure, not NULL_TREE. */
12031 integral_constant_expression_p,
12039 input_location);
12045 }
12048 {
12049 tree object;
12057 {
12060 }
12061 else
12068 else
12070 }
12073 {
12077 {
12078 /* A type conversion to reference type will be enclosed in
12079 such an indirect ref, but the substitution of the cast
12080 will have also added such an indirect ref. */
12083 }
12084 else
12087 }
12090 return build_nop
12099 {
12100 tree type;
12101 tree op;
12106 {
12111 }
12116 {
12129 }
12130 }
12148 complain);
12155 else
12157 in_decl);
12194 return build_x_binary_op
12198 ? ERROR_MARK
12202 ? ERROR_MARK
12205 complain);
12218 /* Fall through */
12223 {
12224 /* When there are no ARGS, we are trying to evaluate a
12225 non-dependent expression from the parser. Trying to do
12226 the substitutions may not work. */
12229 }
12230 else
12231 {
12239 }
12243 else
12248 {
12249 tree r = build_x_modify_expr
12253 complain);
12254 /* TREE_NO_WARNING must be set if either the expression was
12255 parenthesized or it uses an operator such as >>= rather
12256 than plain assignment. In the former case, it was already
12257 set and must be copied. In the latter case,
12258 build_x_modify_expr sets it and it must not be reset
12259 here. */
12263 }
12268 /* Remember that there was a reference to this entity. */
12274 {
12279 tree ret;
12283 else
12284 {
12288 }
12290 /* If there was an initializer in the original tree, but it
12291 instantiated to an empty list, then we should pass a
12292 non-NULL empty vector to tell build_new that it was an
12293 empty initializer() rather than no initializer. This can
12294 only happen when the initializer is a pack expansion whose
12295 parameter packs are of length zero. */
12298 else
12299 {
12303 else
12304 {
12307 }
12308 }
12315 complain);
12323 }
12326 return delete_sanity
12335 complain);
12338 {
12339 tree function;
12344 tree ret;
12347 /* When we parsed the expression, we determined whether or
12348 not Koenig lookup should be performed. */
12351 {
12356 }
12357 else
12358 {
12360 {
12366 }
12367 else
12371 in_decl,
12373 integral_constant_expression_p);
12377 }
12382 {
12388 else
12389 {
12390 /* Expand the pack expansion and push each entry onto
12391 CALL_ARGS. */
12394 {
12399 {
12404 }
12405 }
12406 else
12407 {
12408 /* A partial substitution. Add one entry. */
12410 }
12411 }
12412 }
12414 /* We do not perform argument-dependent lookup if normal
12415 lookup finds a non-function, in accordance with the
12416 expected resolution of DR 218. */
12419 /* If lookup found a member function, the Koenig lookup is
12420 not appropriate, even if an unqualified-name was used
12421 to denote the function. */
12424 /* Only do this when substitution turns a dependent call
12425 into a non-dependent call. */
12431 {
12435 }
12437 /* Remember that there was a reference to this entity. */
12444 {
12449 complain);
12450 else
12451 ret = (build_new_method_call
12457 complain));
12458 }
12459 else
12462 koenig_p,
12463 complain);
12468 }
12471 return build_x_conditional_expr
12475 complain);
12478 return finish_pseudo_destructor_expr
12484 {
12492 {
12493 /* We have pack expansions, so expand those and
12494 create a new list out of it. */
12497 tree chain;
12500 /* Expand the argument expressions. */
12508 /* Build the rest of the list. */
12513 /* Determine the number of arguments. */
12515 {
12518 }
12521 else
12522 {
12523 /* Since we only performed a partial substitution into
12524 the argument pack, we only return a single list
12525 node. */
12532 }
12534 /* Convert the argument vectors into a TREE_LIST */
12537 {
12538 /* Grab the Ith values. */
12539 i--;
12542 value
12546 /* Build the list (backwards). */
12548 }
12551 }
12567 }
12570 {
12571 tree object;
12572 tree object_type;
12573 tree member;
12577 /* Remember that there was a reference to this entity. */
12587 else
12593 {
12595 {
12600 {
12603 }
12605 {
12609 }
12610 }
12611 }
12614 {
12615 tree tmpl;
12616 tree args;
12618 /* Lookup the template functions now that we know what the
12619 scope is. */
12626 {
12629 args);
12630 member = (adjust_result_of_qualified_name_lookup
12632 object_type));
12633 }
12634 else
12635 {
12637 input_location);
12639 }
12640 }
12644 {
12646 {
12650 else
12653 }
12655 }
12661 complain);
12662 }
12665 return build_throw
12669 {
12677 tree r;
12682 /* digest_init will do the wrong thing if we let it. */
12686 /* We do not want to process the index of aggregate
12687 initializers as they are identifier nodes which will be
12688 looked up by digest_init. */
12694 {
12699 {
12700 /* Substitute into the pack expansion. */
12702 in_decl);
12705 ;
12707 /* Just move the argument into place. */
12709 else
12710 {
12711 /* Update the length of the final CONSTRUCTOR
12712 arguments vector, and note that we will need to
12713 copy.*/
12716 }
12717 }
12718 else
12720 }
12723 {
12728 idx++)
12729 {
12731 {
12736 }
12737 else
12739 }
12740 }
12749 }
12752 {
12757 }
12762 /* Fall through */
12765 {
12769 /* If the original type was a reference, we'll be wrapped in
12770 the appropriate INDIRECT_REF. */
12773 }
12778 in_decl));
12784 {
12793 }
12796 {
12802 integral_constant_expression_p);
12806 /* If the resulting list of expression statement is empty,
12807 fold it further into void_zero_node. */
12812 }
12816 /* As in finish_id_expression, we resolve enumeration constants
12817 to their underlying values. */
12819 {
12822 }
12826 {
12847 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
12849 /* Now that we know visibility, instantiate the type so we have a
12850 declaration of the op() for later calls to lambda_function. */
12858 }
12861 /* Handle Objective-C++ constructs, if appropriate. */
12862 {
12863 tree subst
12868 }
12870 }
12872 #undef RECUR
12873 }
12875 /* Verify that the instantiated ARGS are valid. For type arguments,
12876 make sure that the type's linkage is ok. For non-type arguments,
12877 make sure they are constants if they are integral or enumerations.
12878 Emit an error under control of COMPLAIN, and return TRUE on error. */
12880 static bool
12882 {
12884 {
12894 }
12896 {
12897 /* [basic.link]: A name with no linkage (notably, the name
12898 of a class or enumeration declared in a local scope)
12899 shall not be used to declare an entity with linkage.
12900 This implies that names with no linkage cannot be used as
12901 template arguments
12903 DR 757 relaxes this restriction for C++0x. */
12908 {
12909 /* DR 488 makes use of a type with no linkage cause
12910 type deduction to fail. */
12912 {
12915 else
12918 }
12920 }
12921 /* In order to avoid all sorts of complications, we do not
12922 allow variably-modified types as template arguments. */
12924 {
12928 }
12929 }
12930 /* A non-type argument of integral or enumerated type must be a
12931 constant. */
12935 {
12939 }
12941 }
12943 static bool
12945 {
12950 {
12953 }
12957 }
12959 /* Instantiate the indicated variable or function template TMPL with
12960 the template arguments in TARG_PTR. */
12962 tree
12964 {
12966 tree fndecl;
12967 tree gen_tmpl;
12968 tree spec;
12969 HOST_WIDE_INT saved_processing_template_decl;
12976 /* If this function is a clone, handle it specially. */
12978 {
12979 tree spec;
12980 tree clone;
12982 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
12983 DECL_CLONED_FUNCTION. */
12989 /* Look for the clone. */
12993 /* We should always have found the clone by now. */
12996 }
12998 /* Check to see if we already have this specialization. */
13001 /* The TMPL is a partial instantiation. To get a full set of
13002 arguments we must add the arguments used to perform the
13003 partial instantiation. */
13005 targ_ptr);
13007 /* It would be nice to avoid hashing here and then again in tsubst_decl,
13008 but it doesn't seem to be on the hot path. */
13020 complain))
13023 /* We are building a FUNCTION_DECL, during which the access of its
13024 parameters and return types have to be checked. However this
13025 FUNCTION_DECL which is the desired context for access checking
13026 is not built yet. We solve this chicken-and-egg problem by
13027 deferring all checks until we have the FUNCTION_DECL. */
13030 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
13031 (because, for example, we have encountered a non-dependent
13032 function call in the body of a template function and must now
13033 determine which of several overloaded functions will be called),
13034 within the instantiation itself we are not processing a
13035 template. */
13038 /* Substitute template parameters to obtain the specialization. */
13045 /* Now we know the specialization, compute access previously
13046 deferred. */
13049 /* Some typedefs referenced from within the template code need to be access
13050 checked at template instantiation time, i.e now. These types were
13051 added to the template at parsing time. Let's get those and perfom
13052 the acces checks then. */
13058 /* The DECL_TI_TEMPLATE should always be the immediate parent
13059 template, not the most general template. */
13062 /* If we've just instantiated the main entry point for a function,
13063 instantiate all the alternate entry points as well. We do this
13064 by cloning the instantiation of the main entry point, not by
13065 instantiating the template clones. */
13070 }
13072 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
13073 NARGS elements of the arguments that are being used when calling
13074 it. TARGS is a vector into which the deduced template arguments
13075 are placed.
13077 Return zero for success, 2 for an incomplete match that doesn't resolve
13078 all the types, and 1 for complete failure. An error message will be
13079 printed only for an incomplete match.
13081 If FN is a conversion operator, or we are trying to produce a specific
13082 specialization, RETURN_TYPE is the return type desired.
13084 The EXPLICIT_TARGS are explicit template arguments provided via a
13085 template-id.
13087 The parameter STRICT is one of:
13089 DEDUCE_CALL:
13090 We are deducing arguments for a function call, as in
13091 [temp.deduct.call].
13093 DEDUCE_CONV:
13094 We are deducing arguments for a conversion function, as in
13095 [temp.deduct.conv].
13097 DEDUCE_EXACT:
13098 We are deducing arguments when doing an explicit instantiation
13099 as in [temp.explicit], when determining an explicit specialization
13100 as in [temp.expl.spec], or when taking the address of a function
13101 template, as in [temp.deduct.funcaddr]. */
13103 int
13105 tree explicit_targs,
13106 tree targs,
13109 tree return_type,
13110 unification_kind_t strict,
13112 {
13113 tree parms;
13114 tree fntype;
13122 {
13123 /* [temp.deduct]
13125 The specified template arguments must match the template
13126 parameters in kind (i.e., type, nontype, template), and there
13127 must not be more arguments than there are parameters;
13128 otherwise type deduction fails.
13130 Nontype arguments must match the types of the corresponding
13131 nontype template parameters, or must be convertible to the
13132 types of the corresponding nontype parameters as specified in
13133 _temp.arg.nontype_, otherwise type deduction fails.
13135 All references in the function type of the function template
13136 to the corresponding template parameters are replaced by the
13137 specified template argument values. If a substitution in a
13138 template parameter or in the function type of the function
13139 template results in an invalid type, type deduction fails. */
13142 tree converted_args;
13148 converted_args
13155 /* Substitute the explicit args into the function type. This is
13156 necessary so that, for instance, explicitly declared function
13157 arguments can match null pointed constants. If we were given
13158 an incomplete set of explicit args, we must not do semantic
13159 processing during substitution as we could create partial
13160 instantiations. */
13162 {
13166 /* Dig out the actual parm. */
13169 {
13172 }
13174 {
13177 }
13180 {
13182 tree targ;
13185 /* Mark the argument pack as "incomplete". We could
13186 still deduce more arguments during unification. */
13189 {
13193 }
13195 /* We have some incomplete argument packs. */
13197 }
13198 }
13201 /* Any substitution is guaranteed to be incomplete if there
13202 are incomplete argument packs, because we can still deduce
13203 more arguments. */
13205 else
13215 /* Place the explicitly specified arguments in TARGS. */
13218 }
13220 /* Never do unification on the 'this' parameter. */
13224 {
13233 }
13235 /* We allow incomplete unification without an error message here
13236 because the standard doesn't seem to explicitly prohibit it. Our
13237 callers must be ready to deal with unification failures in any
13238 event. */
13244 {
13247 /* Clear the "incomplete" flags on all argument packs. */
13249 {
13252 {
13255 }
13256 }
13257 }
13259 /* Now that we have bindings for all of the template arguments,
13260 ensure that the arguments deduced for the template template
13261 parameters have compatible template parameter lists. We cannot
13262 check this property before we have deduced all template
13263 arguments, because the template parameter types of a template
13264 template parameter might depend on prior template parameters
13265 deduced after the template template parameter. The following
13266 ill-formed example illustrates this issue:
13268 template<typename T, template<T> class C> void f(C<5>, T);
13270 template<int N> struct X {};
13272 void g() {
13273 f(X<5>(), 5l); // error: template argument deduction fails
13274 }
13276 The template parameter list of 'C' depends on the template type
13277 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
13278 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
13279 time that we deduce 'C'. */
13281 && !template_template_parm_bindings_ok_p
13286 /* All is well so far. Now, check:
13288 [temp.deduct]
13290 When all template arguments have been deduced, all uses of
13291 template parameters in nondeduced contexts are replaced with
13292 the corresponding deduced argument values. If the
13293 substitution results in an invalid type, as described above,
13294 type deduction fails. */
13295 {
13300 /* If we're looking for an exact match, check that what we got
13301 is indeed an exact match. It might not be if some template
13302 parameters are used in non-deduced contexts. */
13304 {
13307 tree sarg
13314 }
13315 }
13318 }
13320 /* Adjust types before performing type deduction, as described in
13321 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
13322 sections are symmetric. PARM is the type of a function parameter
13323 or the return type of the conversion function. ARG is the type of
13324 the argument passed to the call, or the type of the value
13325 initialized with the result of the conversion function.
13326 ARG_EXPR is the original argument expression, which may be null. */
13328 static int
13332 tree arg_expr)
13333 {
13337 {
13342 {
13343 /* Swap PARM and ARG throughout the remainder of this
13344 function; the handling is precisely symmetric since PARM
13345 will initialize ARG rather than vice versa. */
13350 }
13353 /* Core issue #873: Do the DR606 thing (see below) for these cases,
13354 too, but here handle it by stripping the reference from PARM
13355 rather than by adding it to ARG. */
13363 /* Nothing else to do in this case. */
13368 }
13371 {
13372 /* [temp.deduct.call]
13374 If P is not a reference type:
13376 --If A is an array type, the pointer type produced by the
13377 array-to-pointer standard conversion (_conv.array_) is
13378 used in place of A for type deduction; otherwise,
13380 --If A is a function type, the pointer type produced by
13381 the function-to-pointer standard conversion
13382 (_conv.func_) is used in place of A for type deduction;
13383 otherwise,
13385 --If A is a cv-qualified type, the top level
13386 cv-qualifiers of A's type are ignored for type
13387 deduction. */
13392 else
13394 }
13396 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
13397 of the form T&&, where T is a template parameter, and the argument
13398 is an lvalue, T is deduced as A& */
13406 /* [temp.deduct.call]
13408 If P is a cv-qualified type, the top level cv-qualifiers
13409 of P's type are ignored for type deduction. If P is a
13410 reference type, the type referred to by P is used for
13411 type deduction. */
13414 {
13417 }
13419 /* DR 322. For conversion deduction, remove a reference type on parm
13420 too (which has been swapped into ARG). */
13425 }
13427 /* Most parms like fn_type_unification.
13429 If SUBR is 1, we're being called recursively (to unify the
13430 arguments of a function or method parameter of a function
13431 template). */
13433 static int
13435 tree targs,
13436 tree xparms,
13440 unification_kind_t strict,
13442 {
13448 tree parms;
13457 /* Reset the number of non-defaulted template arguments contained
13458 in in TARGS. */
13462 {
13478 }
13480 again:
13488 {
13501 /* We can't deduce anything from this, but we might get all the
13502 template args from other function args. */
13505 /* Conversions will be performed on a function argument that
13506 corresponds with a function parameter that contains only
13507 non-deducible template parameters and explicitly specified
13508 template parameters. */
13510 {
13511 tree type;
13515 else
13522 flags))
13526 }
13529 {
13532 {
13533 /* [temp.deduct.type]
13535 A template-argument can be deduced from a pointer to
13536 function or pointer to member function argument if
13537 the set of overloaded functions does not contain
13538 function templates and at most one of a set of
13539 overloaded functions provides a unique match. */
13545 }
13550 }
13552 {
13557 arg_expr);
13563 }
13564 }
13570 {
13571 /* Unify the remaining arguments with the pack expansion type. */
13572 tree argvec;
13575 /* Allocate a TREE_VEC and copy in all of the arguments */
13580 /* Copy the parameter into parmvec. */
13586 /* Advance to the end of the list of parameters. */
13588 }
13590 /* Fail if we've reached the end of the parm list, and more args
13591 are present, and the parm list isn't variadic. */
13594 /* Fail if parms are left and they don't have default values. */
13602 {
13603 tree tparm;
13610 /* If this is an undeduced nontype parameter that depends on
13611 a type parameter, try another pass; its type may have been
13612 deduced from a later argument than the one from which
13613 this parameter can be deduced. */
13619 /* Core issue #226 (C++0x) [temp.deduct]:
13621 If a template argument has not been deduced, its
13622 default template argument, if any, is used.
13624 When we are in C++98 mode, TREE_PURPOSE will either
13625 be NULL_TREE or ERROR_MARK_NODE, so we do not need
13626 to explicitly check cxx_dialect here. */
13628 {
13636 else
13637 {
13639 /* The position of the first default template argument,
13640 is also the number of non-defaulted arguments in TARGS.
13641 Record that. */
13645 }
13646 }
13648 /* If the type parameter is a parameter pack, then it will
13649 be deduced to an empty parameter pack. */
13651 {
13652 tree arg;
13655 {
13659 }
13660 else
13667 }
13670 }
13671 #ifdef ENABLE_CHECKING
13674 #endif
13677 }
13679 /* Subroutine of type_unification_real. Args are like the variables
13680 at the call site. ARG is an overloaded function (or template-id);
13681 we try deducing template args from each of the overloads, and if
13682 only one succeeds, we go with that. Modifies TARGS and returns
13683 true on success. */
13685 static bool
13687 tree targs,
13688 tree parm,
13689 tree arg,
13690 unification_kind_t strict,
13692 {
13699 {
13702 }
13703 else
13707 /* Handle `&x' where `x' is some static or non-static member
13708 function name. */
13714 /* Strip baselink information. */
13719 {
13720 /* If we got some explicit template args, we need to plug them into
13721 the affected templates before we try to unify, in case the
13722 explicit args will completely resolve the templates in question. */
13728 {
13739 {
13744 {
13747 }
13748 }
13750 }
13751 }
13754 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13755 -- but the deduction does not succeed because the expression is
13756 not just the function on its own. */
13758 else
13764 {
13767 }
13769 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13770 to function or pointer to member function argument if the set of
13771 overloaded functions does not contain function templates and at most
13772 one of a set of overloaded functions provides a unique match.
13774 So if we found multiple possibilities, we return success but don't
13775 deduce anything. */
13778 {
13783 }
13788 }
13790 /* Core DR 115: In contexts where deduction is done and fails, or in
13791 contexts where deduction is not done, if a template argument list is
13792 specified and it, along with any default template arguments, identifies
13793 a single function template specialization, then the template-id is an
13794 lvalue for the function template specialization. */
13796 tree
13798 {
13811 {
13814 }
13816 {
13819 }
13821 {
13824 }
13827 {
13831 /* If we got some explicit template args, we need to plug them into
13832 the affected templates before we try to unify, in case the
13833 explicit args will completely resolve the templates in question. */
13841 {
13852 {
13855 {
13858 }
13860 {
13863 }
13864 }
13866 }
13868 {
13880 }
13882 /* There were no good options and at least one bad one, so let the
13883 user know what the problem is. */
13885 }
13887 }
13889 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13890 overload. Fills TARGS with any deduced arguments, or error_mark_node if
13891 different overloads deduce different arguments for a given parm.
13892 ADDR_P is true if the expression for which deduction is being
13893 performed was of the form "& fn" rather than simply "fn".
13895 Returns 1 on success. */
13897 static int
13899 tree orig_targs,
13900 tree targs,
13901 tree parm,
13902 tree arg,
13903 unification_kind_t strict,
13906 {
13908 tree tempargs;
13911 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13912 to function or pointer to member function argument if the set of
13913 overloaded functions does not contain function templates and at most
13914 one of a set of overloaded functions provides a unique match.
13916 So if this is a template, just return success. */
13928 /* We don't copy orig_targs for this because if we have already deduced
13929 some template args from previous args, unify would complain when we
13930 try to deduce a template parameter for the same argument, even though
13931 there isn't really a conflict. */
13938 /* First make sure we didn't deduce anything that conflicts with
13939 explicitly specified args. */
13941 {
13948 /* Since we're unifying against ourselves, we will fill in
13949 template args used in the function parm list with our own
13950 template parms. Discard them. */
13954 }
13957 {
13962 }
13965 }
13967 /* PARM is a template class (perhaps with unbound template
13968 parameters). ARG is a fully instantiated type. If ARG can be
13969 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
13970 TARGS are as for unify. */
13972 static tree
13974 {
13975 tree copy_of_targs;
13982 /* We need to make a new template argument vector for the call to
13983 unify. If we used TARGS, we'd clutter it up with the result of
13984 the attempted unification, even if this class didn't work out.
13985 We also don't want to commit ourselves to all the unifications
13986 we've already done, since unification is supposed to be done on
13987 an argument-by-argument basis. In other words, consider the
13988 following pathological case:
13990 template <int I, int J, int K>
13991 struct S {};
13993 template <int I, int J>
13994 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
13996 template <int I, int J, int K>
13997 void f(S<I, J, K>, S<I, I, I>);
13999 void g() {
14000 S<0, 0, 0> s0;
14001 S<0, 1, 2> s2;
14003 f(s0, s2);
14004 }
14006 Now, by the time we consider the unification involving `s2', we
14007 already know that we must have `f<0, 0, 0>'. But, even though
14008 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
14009 because there are two ways to unify base classes of S<0, 1, 2>
14010 with S<I, I, I>. If we kept the already deduced knowledge, we
14011 would reject the possibility I=1. */
14014 /* If unification failed, we're done. */
14020 }
14022 /* Given a template type PARM and a class type ARG, find the unique
14023 base type in ARG that is an instance of PARM. We do not examine
14024 ARG itself; only its base-classes. If there is not exactly one
14025 appropriate base class, return NULL_TREE. PARM may be the type of
14026 a partial specialization, as well as a plain template type. Used
14027 by unify. */
14029 static tree
14031 {
14033 tree binfo;
14039 /* The type could not be completed. */
14042 /* Walk in inheritance graph order. The search order is not
14043 important, and this avoids multiple walks of virtual bases. */
14045 {
14049 {
14050 /* If there is more than one satisfactory baseclass, then:
14052 [temp.deduct.call]
14054 If they yield more than one possible deduced A, the type
14055 deduction fails.
14057 applies. */
14062 }
14063 }
14066 }
14068 /* Returns the level of DECL, which declares a template parameter. */
14070 static int
14072 {
14074 {
14084 }
14086 }
14088 /* Decide whether ARG can be unified with PARM, considering only the
14089 cv-qualifiers of each type, given STRICT as documented for unify.
14090 Returns nonzero iff the unification is OK on that basis. */
14092 static int
14094 {
14100 {
14101 /* Although a CVR qualifier is ignored when being applied to a
14102 substituted template parameter ([8.3.2]/1 for example), that
14103 does not apply during deduction [14.8.2.4]/1, (even though
14104 that is not explicitly mentioned, [14.8.2.4]/9 indicates
14105 this). Except when we're allowing additional CV qualifiers
14106 at the outer level [14.8.2.1]/3,1st bullet. */
14116 }
14127 }
14129 /* Determines the LEVEL and INDEX for the template parameter PARM. */
14130 void
14132 {
14136 {
14139 }
14140 else
14141 {
14144 }
14145 }
14147 /* Unifies the remaining arguments in PACKED_ARGS with the pack
14148 expansion at the end of PACKED_PARMS. Returns 0 if the type
14149 deduction succeeds, 1 otherwise. STRICT is the same as in
14150 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
14151 call argument list. We'll need to adjust the arguments to make them
14152 types. SUBR tells us if this is from a recursive call to
14153 type_unification_real. */
14154 int
14158 {
14159 tree parm
14166 /* Determine the parameter packs we will be deducing from the
14167 pattern, and record their current deductions. */
14170 {
14174 /* Determine the index and level of this parameter pack. */
14177 /* Keep track of the parameter packs and their corresponding
14178 argument packs. */
14181 }
14183 /* Loop through all of the arguments that have not yet been
14184 unified and unify each with the pattern. */
14186 {
14189 /* For each parameter pack, clear out the deduced value so that
14190 we can deduce it again. */
14192 {
14197 }
14199 /* Unify the pattern with the current argument. */
14200 {
14207 {
14210 /* This mirrors what we do in type_unification_real. */
14212 {
14214 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
14215 | UNIFY_ALLOW_MORE_CV_QUAL
14229 }
14232 {
14235 {
14236 /* [temp.deduct.type] A template-argument can be
14237 deduced from a pointer to function or pointer
14238 to member function argument if the set of
14239 overloaded functions does not contain function
14240 templates and at most one of a set of
14241 overloaded functions provides a unique
14242 match. */
14247 sub_strict)
14251 }
14254 {
14259 }
14260 }
14265 arg_strict |=
14268 }
14271 {
14272 /* For deduction from an init-list we need the actual list. */
14277 }
14278 }
14280 /* For each parameter pack, collect the deduced value. */
14282 {
14288 }
14289 }
14291 /* Verify that the results of unification with the parameter packs
14292 produce results consistent with what we've seen before, and make
14293 the deduced argument packs available. */
14295 {
14302 /* By default keep the original deduced argument pack.
14303 If necessary, more specific code is going to update the
14304 resulting deduced argument later down in this function. */
14308 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
14309 actually deduce anything. */
14317 {
14318 /* Prepend the explicit arguments onto NEW_ARGS. */
14324 /* Copy the explicit arguments. */
14329 /* Copy the deduced arguments. */
14333 }
14336 {
14337 tree result;
14338 /* Build the deduced *_ARGUMENT_PACK. */
14340 {
14345 }
14346 else
14351 /* Note the deduced argument packs for this parameter
14352 pack. */
14354 }
14358 {
14359 /* We only had the explicitly-provided arguments before, but
14360 now we have a complete set of arguments. */
14366 }
14368 new_args))
14369 /* Inconsistent unification of this parameter pack. */
14371 }
14374 }
14376 /* Deduce the value of template parameters. TPARMS is the (innermost)
14377 set of template parameters to a template. TARGS is the bindings
14378 for those template parameters, as determined thus far; TARGS may
14379 include template arguments for outer levels of template parameters
14380 as well. PARM is a parameter to a template function, or a
14381 subcomponent of that parameter; ARG is the corresponding argument.
14382 This function attempts to match PARM with ARG in a manner
14383 consistent with the existing assignments in TARGS. If more values
14384 are deduced, then TARGS is updated.
14386 Returns 0 if the type deduction succeeds, 1 otherwise. The
14387 parameter STRICT is a bitwise or of the following flags:
14389 UNIFY_ALLOW_NONE:
14390 Require an exact match between PARM and ARG.
14391 UNIFY_ALLOW_MORE_CV_QUAL:
14392 Allow the deduced ARG to be more cv-qualified (by qualification
14393 conversion) than ARG.
14394 UNIFY_ALLOW_LESS_CV_QUAL:
14395 Allow the deduced ARG to be less cv-qualified than ARG.
14396 UNIFY_ALLOW_DERIVED:
14397 Allow the deduced ARG to be a template base class of ARG,
14398 or a pointer to a template base class of the type pointed to by
14399 ARG.
14400 UNIFY_ALLOW_INTEGER:
14401 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
14402 case for more information.
14403 UNIFY_ALLOW_OUTER_LEVEL:
14404 This is the outermost level of a deduction. Used to determine validity
14405 of qualification conversions. A valid qualification conversion must
14406 have const qualified pointers leading up to the inner type which
14407 requires additional CV quals, except at the outer level, where const
14408 is not required [conv.qual]. It would be normal to set this flag in
14409 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
14410 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
14411 This is the outermost level of a deduction, and PARM can be more CV
14412 qualified at this point.
14413 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
14414 This is the outermost level of a deduction, and PARM can be less CV
14415 qualified at this point. */
14417 static int
14419 {
14421 tree targ;
14422 tree tparm;
14425 /* I don't think this will do the right thing with respect to types.
14426 But the only case I've seen it in so far has been array bounds, where
14427 signedness is the only information lost, and I think that will be
14428 okay. */
14436 /* We can't deduce anything from this, but we might get all the
14437 template args from other function args. */
14440 /* If PARM uses template parameters, then we can't bail out here,
14441 even if ARG == PARM, since we won't record unifications for the
14442 template parameters. We might need them if we're trying to
14443 figure out which of two things is more specialized. */
14447 /* Handle init lists early, so the rest of the function can assume
14448 we're dealing with a type. */
14450 {
14455 /* Replace T with std::initializer_list<T> for deduction. */
14461 /* We can only deduce from an initializer list argument if the
14462 parameter is std::initializer_list; otherwise this is a
14463 non-deduced context. */
14469 {
14476 {
14478 /* It should only be possible to get here for a call. */
14480 elt_strict |= maybe_adjust_types_for_deduction
14483 }
14487 }
14489 /* If the std::initializer_list<T> deduction worked, replace the
14490 deduced A with std::initializer_list<A>. */
14492 {
14497 }
14499 }
14501 /* Immediately reject some pairs that won't unify because of
14502 cv-qualification mismatches. */
14505 /* It is the elements of the array which hold the cv quals of an array
14506 type, and the elements might be template type parms. We'll check
14507 when we recurse. */
14509 /* We check the cv-qualifiers when unifying with template type
14510 parameters below. We want to allow ARG `const T' to unify with
14511 PARM `T' for example, when computing which of two templates
14512 is more specialized, for example. */
14526 {
14530 /* In a type which contains a nested-name-specifier, template
14531 argument values cannot be deduced for template parameters used
14532 within the nested-name-specifier. */
14544 /* The PARM is not one we're trying to unify. Just check
14545 to see if it matches ARG. */
14552 /* Check for mixed types and values. */
14560 {
14561 /* ARG must be constructed from a template class or a template
14562 template parameter. */
14567 {
14570 tree parm_parms
14571 = DECL_INNERMOST_TEMPLATE_PARMS
14576 /* The resolution to DR150 makes clear that default
14577 arguments for an N-argument may not be used to bind T
14578 to a template template parameter with fewer than N
14579 parameters. It is not safe to permit the binding of
14580 default arguments as an extension, as that may change
14581 the meaning of a conforming program. Consider:
14583 struct Dense { static const unsigned int dim = 1; };
14585 template <template <typename> class View,
14586 typename Block>
14587 void operator+(float, View<Block> const&);
14589 template <typename Block,
14590 unsigned int Dim = Block::dim>
14591 struct Lvalue_proxy { operator float() const; };
14593 void
14594 test_1d (void) {
14595 Lvalue_proxy<Dense> p;
14596 float b;
14597 b + p;
14598 }
14600 Here, if Lvalue_proxy is permitted to bind to View, then
14601 the global operator+ will be used; if they are not, the
14602 Lvalue_proxy will be converted to float. */
14604 argvec,
14606 tf_none,
14612 /* Deduce arguments T, i from TT<T> or TT<i>.
14613 We check each element of PARMVEC and ARGVEC individually
14614 rather than the whole TREE_VEC since they can have
14615 different number of elements. */
14622 /* Check if the parameters end in a pack, making them
14623 variadic. */
14632 {
14636 UNIFY_ALLOW_NONE))
14638 }
14643 UNIFY_ALLOW_NONE,
14647 }
14650 /* Fall through to deduce template name. */
14651 }
14655 {
14656 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
14658 /* Simple cases: Value already set, does match or doesn't. */
14663 }
14664 else
14665 {
14666 /* If PARM is `const T' and ARG is only `int', we don't have
14667 a match unless we are allowing additional qualification.
14668 If ARG is `const int' and PARM is just `T' that's OK;
14669 that binds `const int' to `T'. */
14674 /* Consider the case where ARG is `const volatile int' and
14675 PARM is `const T'. Then, T should be `volatile int'. */
14676 arg = cp_build_qualified_type_real
14681 /* Simple cases: Value already set, does match or doesn't. */
14687 /* Make sure that ARG is not a variable-sized array. (Note
14688 that were talking about variable-sized arrays (like
14689 `int[n]'), rather than arrays of unknown size (like
14690 `int[]').) We'll get very confused by such a type since
14691 the bound of the array will not be computable in an
14692 instantiation. Besides, such types are not allowed in
14693 ISO C++, so we can do as we please here. */
14697 /* Strip typedefs as in convert_template_argument. */
14699 }
14701 /* If ARG is a parameter pack or an expansion, we cannot unify
14702 against it unless PARM is also a parameter pack. */
14707 /* If the argument deduction results is a METHOD_TYPE,
14708 then there is a problem.
14709 METHOD_TYPE doesn't map to any real C++ type the result of
14710 the deduction can not be of that type. */
14724 /* The PARM is not one we're trying to unify. Just check
14725 to see if it matches ARG. */
14735 /* [temp.deduct.type] If, in the declaration of a function template
14736 with a non-type template-parameter, the non-type
14737 template-parameter is used in an expression in the function
14738 parameter-list and, if the corresponding template-argument is
14739 deduced, the template-argument type shall match the type of the
14740 template-parameter exactly, except that a template-argument
14741 deduced from an array bound may be of any integral type.
14742 The non-type parameter might use already deduced type parameters. */
14745 /* Template-parameter dependent expression. Just accept it for now.
14746 It will later be processed in convert_template_argument. */
14747 ;
14753 /* Convert the ARG to the type of PARM; the deduced non-type
14754 template argument must exactly match the types of the
14755 corresponding parameter. */
14758 /* We haven't deduced the type of this parameter yet. Try again
14759 later. */
14761 else
14764 /* If ARG is a parameter pack or an expansion, we cannot unify
14765 against it unless PARM is also a parameter pack. */
14774 {
14775 /* A pointer-to-member constant can be unified only with
14776 another constant. */
14780 /* Just unify the class member. It would be useless (and possibly
14781 wrong, depending on the strict flags) to unify also
14782 PTRMEM_CST_CLASS, because we want to be sure that both parm and
14783 arg refer to the same variable, even if through different
14784 classes. For instance:
14786 struct A { int x; };
14787 struct B : A { };
14789 Unification of &A::x and &B::x must succeed. */
14792 }
14795 {
14799 /* [temp.deduct.call]
14801 A can be another pointer or pointer to member type that can
14802 be converted to the deduced A via a qualification
14803 conversion (_conv.qual_).
14805 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14806 This will allow for additional cv-qualification of the
14807 pointed-to types if appropriate. */
14810 /* The derived-to-base conversion only persists through one
14811 level of pointers. */
14816 }
14831 {
14832 tree parm_max;
14833 tree arg_max;
14837 /* Our representation of array types uses "N - 1" as the
14838 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14839 not an integer constant. We cannot unify arbitrarily
14840 complex expressions, so we eliminate the MINUS_EXPRs
14841 here. */
14845 {
14848 }
14852 {
14853 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14854 trying to unify the type of a variable with the type
14855 of a template parameter. For example:
14857 template <unsigned int N>
14858 void f (char (&) [N]);
14859 int g();
14860 void h(int i) {
14861 char a[g(i)];
14862 f(a);
14863 }
14865 Here, the type of the ARG will be "int [g(i)]", and
14866 may be a SAVE_EXPR, etc. */
14870 }
14872 /* If only one of the bounds used a MINUS_EXPR, compensate
14873 by adding one to the other bound. */
14876 integer_type_node,
14877 parm_max,
14878 integer_one_node);
14881 integer_type_node,
14882 arg_max,
14883 integer_one_node);
14887 }
14901 /* We have already checked cv-qualification at the top of the
14902 function. */
14906 /* As far as unification is concerned, this wins. Later checks
14907 will invalidate it if necessary. */
14910 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
14911 /* Type INTEGER_CST can come from ordinary constant template args. */
14921 {
14930 UNIFY_ALLOW_NONE))
14933 }
14941 {
14948 strict);
14949 }
14952 {
14956 {
14957 /* First, we try to unify the PARM and ARG directly. */
14962 {
14963 /* Fallback to the special case allowed in
14964 [temp.deduct.call]:
14966 If P is a class, and P has the form
14967 template-id, then A can be a derived class of
14968 the deduced A. Likewise, if P is a pointer to
14969 a class of the form template-id, A can be a
14970 pointer to a derived class pointed to by the
14971 deduced A. */
14976 }
14977 }
14981 /* Perhaps PARM is something like S<U> and ARG is S<int>.
14982 Then, we should unify `int' and `U'. */
14984 else
14985 /* There's no chance of unification succeeding. */
14990 }
14997 {
15000 tree a;
15006 /* CV qualifications for methods can never be deduced, they must
15007 match exactly. We need to check them explicitly here,
15008 because type_unification_real treats them as any other
15009 cv-qualified parameter. */
15011 && (!check_cv_quals_for_unify
15031 LOOKUP_NORMAL);
15032 }
15035 /* Unify a pointer to member with a pointer to member function, which
15036 deduces the type of the member as a function type. */
15038 {
15039 tree method_type;
15040 tree fntype;
15041 cp_cv_quals cv_quals;
15043 /* Check top-level cv qualifiers */
15051 /* Determine the type of the function we are unifying against. */
15053 fntype =
15057 /* Extract the cv-qualifiers of the member function from the
15058 implicit object parameter and place them on the function
15059 type to be restored later. */
15060 cv_quals =
15064 }
15072 strict);
15083 /* Matched cases are handled by the ARG == PARM test above. */
15087 /* A non-type template parameter that is a variable should be a
15088 an integral constant, in which case, it whould have been
15089 folded into its (constant) value. So we should not be getting
15090 a variable here. */
15095 {
15103 {
15105 {
15107 /* We can unify against something with a trailing
15108 parameter pack. */
15110 else
15111 /* Since there is something following the pack
15112 expansion, we cannot unify this template argument
15113 list. */
15115 }
15116 }
15119 /* If we don't have enough arguments to satisfy the parameters
15120 (not counting the pack expression at the end), or we have
15121 too many arguments for a parameter list that doesn't end in
15122 a pack expression, we can't unify. */
15127 /* Unify all of the parameters that precede the (optional)
15128 pack expression. */
15130 {
15134 }
15142 }
15148 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
15149 nodes. */
15153 /* Unification fails if we hit an error node. */
15159 /* We must be looking at an expression. This can happen with
15160 something like:
15162 template <int I>
15163 void foo(S<I>, S<I + 2>);
15165 This is a "nondeduced context":
15167 [deduct.type]
15169 The nondeduced contexts are:
15171 --A type that is a template-id in which one or more of
15172 the template-arguments is an expression that references
15173 a template-parameter.
15175 In these cases, we assume deduction succeeded, but don't
15176 actually infer any unifications. */
15181 else
15183 }
15184 }
15185 \f
15186 /* Note that DECL can be defined in this translation unit, if
15187 required. */
15189 static void
15191 {
15192 tree clone;
15196 }
15198 /* Called if RESULT is explicitly instantiated, or is a member of an
15199 explicitly instantiated class. */
15201 void
15203 {
15206 /* If this entity has already been written out, it's too late to
15207 make any modifications. */
15212 /* The TREE_PUBLIC flag for function declarations will have been
15213 set correctly by tsubst. */
15216 /* This might have been set by an earlier implicit instantiation. */
15221 else
15222 {
15224 /* Always make artificials weak. */
15227 /* For WIN32 we also want to put explicit instantiations in
15228 linkonce sections. */
15231 }
15233 /* If EXTERN_P, then this function will not be emitted -- unless
15234 followed by an explicit instantiation, at which point its linkage
15235 will be adjusted. If !EXTERN_P, then this function will be
15236 emitted here. In neither circumstance do we want
15237 import_export_decl to adjust the linkage. */
15239 }
15241 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
15242 important template arguments. If any are missing, we check whether
15243 they're important by using error_mark_node for substituting into any
15244 args that were used for partial ordering (the ones between ARGS and END)
15245 and seeing if it bubbles up. */
15247 static bool
15249 {
15254 {
15257 }
15259 {
15261 {
15265 }
15266 }
15268 }
15270 /* Given two function templates PAT1 and PAT2, return:
15272 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
15273 -1 if PAT2 is more specialized than PAT1.
15274 0 if neither is more specialized.
15276 LEN indicates the number of parameters we should consider
15277 (defaulted parameters should not be considered).
15279 The 1998 std underspecified function template partial ordering, and
15280 DR214 addresses the issue. We take pairs of arguments, one from
15281 each of the templates, and deduce them against each other. One of
15282 the templates will be more specialized if all the *other*
15283 template's arguments deduce against its arguments and at least one
15284 of its arguments *does* *not* deduce against the other template's
15285 corresponding argument. Deduction is done as for class templates.
15286 The arguments used in deduction have reference and top level cv
15287 qualifiers removed. Iff both arguments were originally reference
15288 types *and* deduction succeeds in both directions, the template
15289 with the more cv-qualified argument wins for that pairing (if
15290 neither is more cv-qualified, they both are equal). Unlike regular
15291 deduction, after all the arguments have been deduced in this way,
15292 we do *not* verify the deduced template argument values can be
15293 substituted into non-deduced contexts.
15295 The logic can be a bit confusing here, because we look at deduce1 and
15296 targs1 to see if pat2 is at least as specialized, and vice versa; if we
15297 can find template arguments for pat1 to make arg1 look like arg2, that
15298 means that arg2 is at least as specialized as arg1. */
15300 int
15302 {
15315 /* Remove the this parameter from non-static member functions. If
15316 one is a non-static member function and the other is not a static
15317 member function, remove the first parameter from that function
15318 also. This situation occurs for operator functions where we
15319 locate both a member function (with this pointer) and non-member
15320 operator (with explicit first operand). */
15322 {
15327 }
15329 {
15332 {
15333 len--;
15335 }
15336 }
15338 /* If only one is a conversion operator, they are unordered. */
15342 /* Consider the return type for a conversion function */
15344 {
15347 len++;
15348 }
15350 processing_template_decl++;
15356 /* Stop when an ellipsis is seen. */
15358 {
15367 {
15368 /* When both arguments are pack expansions, we need only
15369 unify the patterns themselves. */
15373 /* This is the last comparison we need to do. */
15375 }
15378 {
15381 }
15384 {
15387 }
15390 {
15391 /* Only of the args is a reference, see if we should apply
15392 array/function pointer decay to it. This is not part of
15393 DR214, but is, IMHO, consistent with the deduction rules
15394 for the function call itself, and with our earlier
15395 implementation of the underspecified partial ordering
15396 rules. (nathan). */
15398 {
15400 {
15403 /* FALLTHROUGH. */
15410 }
15411 }
15412 else
15413 {
15415 {
15418 /* FALLTHROUGH. */
15425 }
15426 }
15427 }
15433 {
15439 /* Setup the parameter vector, which contains only ARG1. */
15442 /* Setup the argument vector, which contains the remaining
15443 arguments. */
15452 /* We cannot deduce in the other direction, because ARG1 is
15453 a pack expansion but ARG2 is not. */
15455 }
15457 {
15463 /* Setup the parameter vector, which contains only ARG1. */
15466 /* Setup the argument vector, which contains the remaining
15467 arguments. */
15476 /* We cannot deduce in the other direction, because ARG2 is
15477 a pack expansion but ARG1 is not.*/
15479 }
15481 else
15482 {
15483 /* The normal case, where neither argument is a pack
15484 expansion. */
15487 }
15489 /* If we couldn't deduce arguments for tparms1 to make arg1 match
15490 arg2, then arg2 is not as specialized as arg1. */
15496 /* "If, for a given type, deduction succeeds in both directions
15497 (i.e., the types are identical after the transformations above)
15498 and if the type from the argument template is more cv-qualified
15499 than the type from the parameter template (as described above)
15500 that type is considered to be more specialized than the other. If
15501 neither type is more cv-qualified than the other then neither type
15502 is more specialized than the other." */
15506 {
15511 }
15514 /* We've failed to deduce something in either direction.
15515 These must be unordered. */
15520 /* We have already processed all of the arguments in our
15521 handing of the pack expansion type. */
15526 }
15528 /* "In most cases, all template parameters must have values in order for
15529 deduction to succeed, but for partial ordering purposes a template
15530 parameter may remain without a value provided it is not used in the
15531 types being used for partial ordering."
15533 Thus, if we are missing any of the targs1 we need to substitute into
15534 origs1, then pat2 is not as specialized as pat1. This can happen when
15535 there is a nondeduced context. */
15541 processing_template_decl--;
15543 /* All things being equal, if the next argument is a pack expansion
15544 for one function but not for the other, prefer the
15545 non-variadic function. FIXME this is bogus; see c++/41958. */
15549 {
15552 }
15558 else
15560 }
15562 /* Determine which of two partial specializations is more specialized.
15564 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
15565 to the first partial specialization. The TREE_VALUE is the
15566 innermost set of template parameters for the partial
15567 specialization. PAT2 is similar, but for the second template.
15569 Return 1 if the first partial specialization is more specialized;
15570 -1 if the second is more specialized; 0 if neither is more
15571 specialized.
15573 See [temp.class.order] for information about determining which of
15574 two templates is more specialized. */
15576 static int
15578 {
15579 tree targs;
15587 /* Just like what happens for functions, if we are ordering between
15588 different class template specializations, we may encounter dependent
15589 types in the arguments, and we need our dependency check functions
15590 to behave correctly. */
15596 {
15599 }
15605 {
15608 }
15611 /* In the case of a tie where at least one of the class templates
15612 has a parameter pack at the end, the template with the most
15613 non-packed parameters wins. */
15615 && any_deductions
15618 {
15624 /* We don't count the pack expansion at the end. */
15634 }
15637 }
15639 /* Return the template arguments that will produce the function signature
15640 DECL from the function template FN, with the explicit template
15641 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
15642 also match. Return NULL_TREE if no satisfactory arguments could be
15643 found. */
15645 static tree
15647 {
15650 tree decl_type;
15651 tree decl_arg_types;
15654 tree arg;
15656 /* Substitute the explicit template arguments into the type of DECL.
15657 The call to fn_type_unification will handle substitution into the
15658 FN. */
15661 {
15662 tree tmpl;
15663 tree converted_args;
15667 else
15668 /* We can get here for some invalid specializations. */
15671 converted_args
15674 tf_none,
15683 }
15685 /* Never do unification on the 'this' parameter. */
15704 }
15706 /* Return the innermost template arguments that, when applied to a
15707 template specialization whose innermost template parameters are
15708 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
15709 ARGS.
15711 For example, suppose we have:
15713 template <class T, class U> struct S {};
15714 template <class T> struct S<T*, int> {};
15716 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
15717 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
15718 int}. The resulting vector will be {double}, indicating that `T'
15719 is bound to `double'. */
15721 static tree
15723 {
15725 tree deduced_args;
15726 tree innermost_deduced_args;
15730 {
15734 innermost_deduced_args);
15735 }
15736 else
15742 UNIFY_ALLOW_NONE))
15749 /* Verify that nondeduced template arguments agree with the type
15750 obtained from argument deduction.
15752 For example:
15754 struct A { typedef int X; };
15755 template <class T, class U> struct C {};
15756 template <class T> struct C<T, typename T::X> {};
15758 Then with the instantiation `C<A, int>', we can deduce that
15759 `T' is `A' but unify () does not check whether `typename T::X'
15760 is `int'. */
15763 /* We only need to check the innermost arguments; the other
15764 arguments will always agree. */
15769 /* Now that we have bindings for all of the template arguments,
15770 ensure that the arguments deduced for the template template
15771 parameters have compatible template parameter lists. See the use
15772 of template_template_parm_bindings_ok_p in fn_type_unification
15773 for more information. */
15778 }
15780 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
15781 Return the TREE_LIST node with the most specialized template, if
15782 any. If there is no most specialized template, the error_mark_node
15783 is returned.
15785 Note that this function does not look at, or modify, the
15786 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
15787 returned is one of the elements of INSTANTIATIONS, callers may
15788 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
15789 and retrieve it from the value returned. */
15791 tree
15793 {
15800 {
15806 fate--;
15811 fate++;
15816 {
15817 /* Equally specialized, move to next function. If there
15818 is no next function, nothing's most specialized. */
15823 }
15824 }
15827 /* Now verify that champ is better than everything earlier in the
15828 instantiation list. */
15836 {
15839 }
15841 processing_template_decl--;
15847 }
15849 /* If DECL is a specialization of some template, return the most
15850 general such template. Otherwise, returns NULL_TREE.
15852 For example, given:
15854 template <class T> struct S { template <class U> void f(U); };
15856 if TMPL is `template <class U> void S<int>::f(U)' this will return
15857 the full template. This function will not trace past partial
15858 specializations, however. For example, given in addition:
15860 template <class T> struct S<T*> { template <class U> void f(U); };
15862 if TMPL is `template <class U> void S<int*>::f(U)' this will return
15863 `template <class T> template <class U> S<T*>::f(U)'. */
15865 tree
15867 {
15868 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15869 an immediate specialization. */
15871 {
15875 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15876 template friend. */
15881 }
15883 /* Look for more and more general templates. */
15885 {
15886 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15887 (See cp-tree.h for details.) */
15895 /* Stop if we run into an explicitly specialized class template. */
15902 }
15905 }
15907 /* Return the most specialized of the class template partial
15908 specializations of TMPL which can produce TYPE, a specialization of
15909 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
15910 a _TYPE node corresponding to the partial specialization, while the
15911 TREE_PURPOSE is the set of template arguments that must be
15912 substituted into the TREE_TYPE in order to generate TYPE.
15914 If the choice of partial specialization is ambiguous, a diagnostic
15915 is issued, and the error_mark_node is returned. If there are no
15916 partial specializations of TMPL matching TYPE, then NULL_TREE is
15917 returned. */
15919 static tree
15921 {
15923 tree t;
15924 tree champ;
15927 tree args;
15933 /* For determining which partial specialization to use, only the
15934 innermost args are interesting. */
15936 {
15939 }
15942 {
15943 tree partial_spec_args;
15944 tree spec_args;
15952 {
15955 /* Discard the outer levels of args, and then substitute in the
15956 template args from the enclosing class. */
15958 partial_spec_args = tsubst_template_args
15961 /* PARMS already refers to just the innermost parms, but the
15962 template parms in partial_spec_args had their levels lowered
15963 by tsubst, so we need to do the same for the parm list. We
15964 can't just tsubst the TREE_VEC itself, as tsubst wants to
15965 treat a TREE_VEC as an argument vector. */
15971 }
15973 partial_spec_args =
15976 partial_spec_args),
15987 partial_spec_args,
15988 args);
15990 {
15995 }
15996 }
16006 {
16009 ;
16010 else
16011 {
16013 {
16016 {
16019 }
16020 }
16022 }
16023 }
16027 {
16030 {
16033 }
16034 }
16037 {
16043 {
16046 }
16049 }
16052 }
16054 /* Explicitly instantiate DECL. */
16056 void
16058 {
16063 /* An error occurred, for which grokdeclarator has already issued
16064 an appropriate message. */
16067 {
16070 }
16072 {
16073 /* There is an asymmetry here in the way VAR_DECLs and
16074 FUNCTION_DECLs are handled by grokdeclarator. In the case of
16075 the latter, the DECL we get back will be marked as a
16076 template instantiation, and the appropriate
16077 DECL_TEMPLATE_INFO will be set up. This does not happen for
16078 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
16079 should handle VAR_DECLs as it currently handles
16080 FUNCTION_DECLs. */
16082 {
16085 }
16088 {
16091 }
16093 {
16098 }
16099 }
16101 {
16104 }
16105 else
16108 /* Check for various error cases. Note that if the explicit
16109 instantiation is valid the RESULT will currently be marked as an
16110 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
16111 until we get here. */
16114 {
16115 /* DR 259 [temp.spec].
16117 Both an explicit instantiation and a declaration of an explicit
16118 specialization shall not appear in a program unless the explicit
16119 instantiation follows a declaration of the explicit specialization.
16121 For a given set of template parameters, if an explicit
16122 instantiation of a template appears after a declaration of an
16123 explicit specialization for that template, the explicit
16124 instantiation has no effect. */
16126 }
16128 {
16129 /* [temp.spec]
16131 No program shall explicitly instantiate any template more
16132 than once.
16134 We check DECL_NOT_REALLY_EXTERN so as not to complain when
16135 the first instantiation was `extern' and the second is not,
16136 and EXTERN_P for the opposite case. */
16139 /* If an "extern" explicit instantiation follows an ordinary
16140 explicit instantiation, the template is instantiated. */
16143 }
16145 {
16148 }
16150 {
16153 }
16156 ;
16158 {
16161 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
16164 }
16165 else
16173 }
16175 static void
16177 {
16183 {
16186 }
16187 }
16189 /* Called from do_type_instantiation through binding_table_foreach to
16190 do recursive instantiation for the type bound in ENTRY. */
16191 static void
16193 {
16199 }
16201 /* Called from do_type_instantiation to instantiate a member
16202 (a member function or a static member variable) of an
16203 explicitly instantiated class template. */
16204 static void
16206 {
16211 }
16213 /* Perform an explicit instantiation of template class T. STORAGE, if
16214 non-null, is the RID for extern, inline or static. COMPLAIN is
16215 nonzero if this is called from the parser, zero if called recursively,
16216 since the standard is unclear (as detailed below). */
16218 void
16220 {
16230 {
16233 }
16238 {
16241 t);
16243 }
16246 {
16248 {
16250 {
16253 "ISO C++ 1998 forbids the use of %<extern%> on "
16255 }
16256 else
16258 "ISO C++ forbids the use of %qE"
16260 }
16268 else
16269 {
16271 storage);
16273 }
16274 }
16277 {
16278 /* DR 259 [temp.spec].
16280 Both an explicit instantiation and a declaration of an explicit
16281 specialization shall not appear in a program unless the explicit
16282 instantiation follows a declaration of the explicit specialization.
16284 For a given set of template parameters, if an explicit
16285 instantiation of a template appears after a declaration of an
16286 explicit specialization for that template, the explicit
16287 instantiation has no effect. */
16289 }
16291 {
16292 /* [temp.spec]
16294 No program shall explicitly instantiate any template more
16295 than once.
16297 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
16298 instantiation was `extern'. If EXTERN_P then the second is.
16299 These cases are OK. */
16306 /* If we've already instantiated the template, just return now. */
16309 }
16317 {
16318 tree tmp;
16320 /* In contrast to implicit instantiation, where only the
16321 declarations, and not the definitions, of members are
16322 instantiated, we have here:
16324 [temp.explicit]
16326 The explicit instantiation of a class template specialization
16327 implies the instantiation of all of its members not
16328 previously explicitly specialized in the translation unit
16329 containing the explicit instantiation.
16331 Of course, we can't instantiate member template classes, since
16332 we don't have any arguments for them. Note that the standard
16333 is unclear on whether the instantiation of the members are
16334 *explicit* instantiations or not. However, the most natural
16335 interpretation is that it should be an explicit instantiation. */
16350 }
16351 }
16353 /* Given a function DECL, which is a specialization of TMPL, modify
16354 DECL to be a re-instantiation of TMPL with the same template
16355 arguments. TMPL should be the template into which tsubst'ing
16356 should occur for DECL, not the most general template.
16358 One reason for doing this is a scenario like this:
16360 template <class T>
16361 void f(const T&, int i);
16363 void g() { f(3, 7); }
16365 template <class T>
16366 void f(const T& t, const int i) { }
16368 Note that when the template is first instantiated, with
16369 instantiate_template, the resulting DECL will have no name for the
16370 first parameter, and the wrong type for the second. So, when we go
16371 to instantiate the DECL, we regenerate it. */
16373 static void
16375 {
16376 /* The arguments used to instantiate DECL, from the most general
16377 template. */
16378 tree args;
16379 tree code_pattern;
16384 /* Make sure that we can see identifiers, and compute access
16385 correctly. */
16389 {
16390 tree decl_parm;
16391 tree pattern_parm;
16392 tree specs;
16405 specs);
16407 /* Merge parameter declarations. */
16410 pattern_parm
16414 {
16415 tree parm_type;
16416 tree attributes;
16421 NULL_TREE);
16427 {
16430 }
16433 }
16434 /* Merge any parameters that match with the function parameter
16435 pack. */
16437 {
16439 tree expanded_types;
16440 /* Expand the TYPE_PACK_EXPANSION that provides the types for
16441 the parameters in this function parameter pack. */
16446 {
16447 tree parm_type;
16448 tree attributes;
16451 /* Rename the parameter to include the index. */
16460 {
16463 }
16465 }
16466 }
16467 /* Merge additional specifiers from the CODE_PATTERN. */
16471 }
16473 {
16481 }
16482 else
16486 }
16488 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
16489 substituted to get DECL. */
16491 tree
16493 {
16496 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
16497 for the instantiation. This is not always the most general
16498 template. Consider, for example:
16500 template <class T>
16501 struct S { template <class U> void f();
16502 template <> void f<int>(); };
16504 and an instantiation of S<double>::f<int>. We want TD to be the
16505 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
16507 more general template. */
16509 /* We must also deal with friend templates. Given:
16511 template <class T> struct S {
16512 template <class U> friend void f() {};
16513 };
16515 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
16516 so far as the language is concerned, but that's still
16517 where we get the pattern for the instantiation from. On
16518 other hand, if the definition comes outside the class, say:
16520 template <class T> struct S {
16521 template <class U> friend void f();
16522 };
16523 template <class U> friend void f() {}
16525 we don't need to look any further. That's what the check for
16526 DECL_INITIAL is for. */
16530 {
16531 /* The present template, TD, should not be a definition. If it
16532 were a definition, we should be using it! Note that we
16533 cannot restructure the loop to just keep going until we find
16534 a template with a definition, since that might go too far if
16535 a specialization was declared, but not defined. */
16539 /* Fetch the more general template. */
16541 }
16544 }
16546 /* Returns true if we need to instantiate this template instance even if we
16547 know we aren't going to emit it.. */
16549 bool
16551 {
16552 /* We always instantiate inline functions so that we can inline them. An
16553 explicit instantiation declaration prohibits implicit instantiation of
16554 non-inline functions. With high levels of optimization, we would
16555 normally inline non-inline functions -- but we're not allowed to do
16556 that for "extern template" functions. Therefore, we check
16557 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
16560 /* And we need to instantiate static data members so that
16561 their initializers are available in integral constant
16562 expressions. */
16565 }
16567 /* Produce the definition of D, a _DECL generated from a template. If
16568 DEFER_OK is nonzero, then we don't have to actually do the
16569 instantiation now; we just have to do it sometime. Normally it is
16570 an error if this is an explicit instantiation but D is undefined.
16571 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
16572 explicitly instantiated class template. */
16574 tree
16577 {
16579 tree gen_args;
16580 tree args;
16581 tree td;
16582 tree code_pattern;
16583 tree spec;
16584 tree gen_tmpl;
16590 /* This function should only be used to instantiate templates for
16591 functions and static member variables. */
16595 /* Variables are never deferred; if instantiation is required, they
16596 are instantiated right away. That allows for better code in the
16597 case that an expression refers to the value of the variable --
16598 if the variable has a constant value the referring expression can
16599 take advantage of that fact. */
16603 /* Don't instantiate cloned functions. Instead, instantiate the
16604 functions they cloned. */
16610 /* D has already been instantiated or explicitly specialized, so
16611 there's nothing for us to do here.
16613 It might seem reasonable to check whether or not D is an explicit
16614 instantiation, and, if so, stop here. But when an explicit
16615 instantiation is deferred until the end of the compilation,
16616 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
16617 the instantiation. */
16620 /* Check to see whether we know that this template will be
16621 instantiated in some other file, as with "extern template"
16622 extension. */
16625 /* In general, we do not instantiate such templates. */
16633 /* We should already have the extra args. */
16636 /* And what's in the hash table should match D. */
16640 /* This needs to happen before any tsubsting. */
16646 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
16647 for the instantiation. */
16651 /* We should never be trying to instantiate a member of a class
16652 template or partial specialization. */
16657 /* In the case of a friend template whose definition is provided
16658 outside the class, we may have too many arguments. Drop the
16659 ones we don't need. The same is true for specializations. */
16660 args = get_innermost_template_args
16662 else
16667 else
16670 /* We may be in the middle of deferred access check. Disable it now. */
16673 /* Unless an explicit instantiation directive has already determined
16674 the linkage of D, remember that a definition is available for
16675 this entity. */
16683 /* If D is a member of an explicitly instantiated class template,
16684 and no definition is available, treat it like an implicit
16685 instantiation. */
16688 {
16692 }
16694 /* Recheck the substitutions to obtain any warning messages
16695 about ignoring cv qualifiers. Don't do this for artificial decls,
16696 as it breaks the context-sensitive substitution for lambda op(). */
16698 {
16702 /* Make sure that we can see identifiers, and compute access
16703 correctly. D is already the target FUNCTION_DECL with the
16704 right context. */
16708 {
16711 d);
16712 /* Don't simply tsubst the function type, as that will give
16713 duplicate warnings about poor parameter qualifications.
16714 The function arguments are the same as the decl_arguments
16715 without the top level cv qualifiers. */
16717 }
16721 }
16723 /* Defer all other templates, unless we have been explicitly
16724 forbidden from doing so. */
16726 template. */
16727 ! pattern_defined
16728 /* If it's OK to postpone instantiation, do so. */
16729 || defer_ok
16730 /* If this is a static data member that will be defined
16731 elsewhere, we don't want to instantiate the entire data
16732 member, but we do want to instantiate the initializer so that
16733 we can substitute that elsewhere. */
16735 {
16736 /* The definition of the static data member is now required so
16737 we must substitute the initializer. */
16741 {
16742 tree ns;
16743 tree init;
16749 args,
16754 LOOKUP_ONLYCONVERTING);
16757 }
16759 /* We restore the source position here because it's used by
16760 add_pending_template. */
16766 /* [temp.explicit]
16768 The definition of a non-exported function template, a
16769 non-exported member function template, or a non-exported
16770 member function or static data member of a class template
16771 shall be present in every translation unit in which it is
16772 explicitly instantiated. */
16776 /* ??? Historically, we have instantiated inline functions, even
16777 when marked as "extern template". */
16781 }
16782 /* Tell the repository that D is available in this translation unit
16783 -- and see if it is supposed to be instantiated here. */
16785 {
16786 /* In a PCH file, despite the fact that the repository hasn't
16787 requested instantiation in the PCH it is still possible that
16788 an instantiation will be required in a file that includes the
16789 PCH. */
16792 /* Instantiate inline functions so that the inliner can do its
16793 job, even though we'll not be emitting a copy of this
16794 function. */
16797 }
16803 /* Mark D as instantiated so that recursive calls to
16804 instantiate_decl do not try to instantiate it again. */
16807 /* Regenerate the declaration in case the template has been modified
16808 by a subsequent redeclaration. */
16811 /* We already set the file and line above. Reset them now in case
16812 they changed as a result of calling regenerate_decl_from_template. */
16816 {
16817 tree init;
16819 /* Clear out DECL_RTL; whatever was there before may not be right
16820 since we've reset the type of the declaration. */
16824 /* The initializer is placed in DECL_INITIAL by
16825 regenerate_decl_from_template. Pull it out so that
16826 cp_finish_decl can process it. */
16831 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
16832 initializer. That function will defer actual emission until
16833 we have a chance to determine linkage. */
16836 /* Enter the scope of D so that access-checking works correctly. */
16840 }
16842 {
16843 htab_t saved_local_specializations;
16844 tree subst_decl;
16845 tree tmpl_parm;
16846 tree spec_parm;
16848 /* Save away the current list, in case we are instantiating one
16849 template from within the body of another. */
16852 /* Set up the list of local specializations. */
16854 hash_local_specialization,
16855 eq_local_specializations,
16856 NULL);
16858 /* Set up context. */
16861 /* Create substitution entries for the parameters. */
16866 {
16870 }
16872 {
16876 }
16878 {
16879 /* Register the (value) argument pack as a specialization of
16880 TMPL_PARM, then move on. */
16885 }
16888 /* Substitute into the body of the function. */
16893 /* Set the current input_location to the end of the function
16894 so that finish_function knows where we are. */
16897 /* We don't need the local specializations any more. */
16901 /* Finish the function. */
16904 }
16906 /* We're not deferring instantiation any more. */
16912 out:
16920 }
16922 /* Run through the list of templates that we wish we could
16923 instantiate, and instantiate any we can. RETRIES is the
16924 number of times we retry pending template instantiation. */
16926 void
16928 {
16932 /* Instantiating templates may trigger vtable generation. This in turn
16933 may require further template instantiations. We place a limit here
16934 to avoid infinite loop. */
16936 {
16940 " instantiating %q+D, possibly from virtual table generation"
16944 /* Pretend that we defined it. */
16947 }
16949 do
16950 {
16955 {
16960 {
16961 tree fn;
16964 {
16968 fn;
16976 }
16979 }
16980 else
16981 {
16984 {
16985 instantiation
16991 }
16995 }
16998 /* If INSTANTIATION has been instantiated, then we don't
16999 need to consider it again in the future. */
17001 else
17002 {
17005 }
17008 }
17010 }
17014 }
17016 /* Substitute ARGVEC into T, which is a list of initializers for
17017 either base class or a non-static data member. The TREE_PURPOSEs
17018 are DECLs, and the TREE_VALUEs are the initializer values. Used by
17019 instantiate_decl. */
17021 static tree
17023 {
17027 {
17028 tree decl;
17029 tree init;
17035 {
17036 tree expr;
17037 tree arg;
17039 /* Expand the base class expansion type into separate base
17040 classes. */
17042 tf_warning_or_error,
17043 NULL_TREE);
17047 /* We'll be building separate TREE_LISTs of arguments for
17048 each base. */
17054 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
17055 expand each argument in the TREE_VALUE of t. */
17061 /* VOID_TYPE_NODE is used to indicate
17062 value-initialization. */
17063 {
17066 }
17067 else
17068 {
17069 /* Substitute parameter packs into each argument in the
17070 TREE_LIST. */
17073 {
17074 tree expanded_exprs;
17076 /* Expand the argument. */
17078 expanded_exprs
17080 tf_warning_or_error,
17081 NULL_TREE);
17085 /* Prepend each of the expanded expressions to the
17086 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
17088 {
17093 }
17094 }
17097 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
17098 since we built them backwards. */
17100 {
17103 }
17104 }
17105 }
17108 {
17110 {
17114 }
17115 else
17116 {
17128 }
17131 {
17135 }
17136 }
17137 }
17139 }
17141 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
17143 static void
17145 {
17150 else
17152 }
17154 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
17155 is the instantiation (which should have been created with
17156 start_enum) and ARGS are the template arguments to use. */
17158 static void
17160 {
17161 tree e;
17164 {
17165 tree value;
17166 tree decl;
17169 /* Note that in a template enum, the TREE_VALUE is the
17170 CONST_DECL, not the corresponding INTEGER_CST. */
17175 /* Give this enumeration constant the correct access. */
17178 /* Actually build the enumerator itself. */
17180 }
17185 }
17187 /* DECL is a FUNCTION_DECL that is a template specialization. Return
17188 its type -- but without substituting the innermost set of template
17189 arguments. So, innermost set of template parameters will appear in
17190 the type. */
17192 tree
17194 {
17195 tree fn_type;
17196 tree tmpl;
17197 tree targs;
17198 tree tparms;
17206 /* There should be as many levels of arguments as there are levels
17207 of parameters. */
17213 /* No substitution is necessary. */
17214 ;
17215 else
17216 {
17218 tree partial_args;
17220 /* Replace the innermost level of the TARGS with NULL_TREEs to
17221 let tsubst know not to substitute for those parameters. */
17230 /* Disable access control as this function is used only during
17231 name-mangling. */
17236 /* Now, do the (partial) substitution to figure out the
17237 appropriate function type. */
17241 /* Substitute into the template parameters to obtain the real
17242 innermost set of parameters. This step is important if the
17243 innermost set of template parameters contains value
17244 parameters whose types depend on outer template parameters. */
17249 }
17252 }
17254 /* Return truthvalue if we're processing a template different from
17255 the last one involved in diagnostics. */
17256 int
17258 {
17260 }
17262 /* Remember current template involved in diagnostics. */
17263 void
17265 {
17267 }
17271 {
17273 }
17275 /* [temp.param] Check that template non-type parm TYPE is of an allowable
17276 type. Return zero for ok, nonzero for disallowed. Issue error and
17277 warning messages under control of COMPLAIN. */
17279 static int
17281 {
17296 }
17298 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
17299 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
17301 static bool
17303 {
17304 tree scope;
17306 /* [temp.dep.type]
17308 A type is dependent if it is:
17310 -- a template parameter. Template template parameters are types
17311 for us (since TYPE_P holds true for them) so we handle
17312 them here. */
17316 /* -- a qualified-id with a nested-name-specifier which contains a
17317 class-name that names a dependent type or whose unqualified-id
17318 names a dependent type. */
17321 /* -- a cv-qualified type where the cv-unqualified type is
17322 dependent. */
17324 /* -- a compound type constructed from any dependent type. */
17334 {
17335 tree arg_type;
17340 arg_type;
17345 }
17346 /* -- an array type constructed from any dependent type or whose
17347 size is specified by a constant expression that is
17348 value-dependent. */
17350 {
17355 }
17358 {
17359 /* If this is the TYPE_DOMAIN of an array type, consider it
17360 dependent. We already checked for value-dependence in
17361 compute_array_index_type. */
17363 }
17365 /* -- a template-id in which either the template name is a template
17366 parameter ... */
17369 /* ... or any of the template arguments is a dependent type or
17370 an expression that is type-dependent or value-dependent. */
17372 && (any_dependent_template_arguments_p
17376 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
17377 argument of the `typeof' expression is not type-dependent, then
17378 it should already been have resolved. */
17383 /* A template argument pack is dependent if any of its packed
17384 arguments are. */
17386 {
17392 }
17394 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
17395 be template parameters. */
17399 /* The standard does not specifically mention types that are local
17400 to template functions or local classes, but they should be
17401 considered dependent too. For example:
17403 template <int I> void f() {
17404 enum E { a = I };
17405 S<sizeof (E)> s;
17406 }
17408 The size of `E' cannot be known until the value of `I' has been
17409 determined. Therefore, `E' must be considered dependent. */
17416 /* Other types are non-dependent. */
17418 }
17420 /* Returns TRUE if TYPE is dependent, in the sense of
17421 [temp.dep.type]. */
17423 bool
17425 {
17426 /* If there are no template parameters in scope, then there can't be
17427 any dependent types. */
17429 {
17430 /* If we are not processing a template, then nobody should be
17431 providing us with a dependent type. */
17435 }
17437 /* If the type is NULL, we have not computed a type for the entity
17438 in question; in that case, the type is dependent. */
17442 /* Erroneous types can be considered non-dependent. */
17446 /* If we have not already computed the appropriate value for TYPE,
17447 do so now. */
17449 {
17452 }
17455 }
17457 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
17458 lookup. In other words, a dependent type that is not the current
17459 instantiation. */
17461 bool
17463 {
17466 }
17468 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
17470 static bool
17472 {
17473 tree scope;
17474 tree name;
17484 /* [temp.dep.expr]
17486 An id-expression is type-dependent if it contains a
17487 nested-name-specifier that contains a class-name that names a
17488 dependent type. */
17489 /* The suggested resolution to Core Issue 224 implies that if the
17490 qualifying type is the current class, then we must peek
17491 inside it. */
17500 }
17502 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
17503 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
17504 expression. */
17506 bool
17508 {
17512 /* A name declared with a dependent type. */
17517 {
17519 /* A name that has not been looked up -- must be dependent. */
17523 /* A non-type template parm. */
17527 /* A non-type template parm. */
17533 /* A constant with integral or enumeration type and is initialized
17534 with an expression that is value-dependent. */
17546 /* These expressions are value-dependent if the type to which
17547 the cast occurs is dependent or the expression being casted
17548 is value-dependent. */
17549 {
17555 /* A functional cast has a list of operands. */
17558 {
17559 /* If there are no operands, it must be an expression such
17560 as "int()". This should not happen for aggregate types
17561 because it would form non-constant expressions. */
17565 }
17571 }
17575 /* A `sizeof' expression is value-dependent if the operand is
17576 type-dependent or is a pack expansion. */
17592 /* A CALL_EXPR may appear in a constant expression if it is a
17593 call to a builtin function, e.g., __builtin_constant_p. All
17594 such calls are value-dependent. */
17598 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
17599 is value-dependent. */
17600 {
17609 }
17612 {
17616 }
17623 /* A constant expression is value-dependent if any subexpression is
17624 value-dependent. */
17626 {
17636 || (value_dependent_expression_p
17641 {
17644 /* In some cases, some of the operands may be missing.
17645 (For example, in the case of PREDECREMENT_EXPR, the
17646 amount to increment by may be missing.) That doesn't
17647 make the expression dependent. */
17649 && (value_dependent_expression_p
17653 }
17657 }
17658 }
17660 /* The expression is not value-dependent. */
17662 }
17664 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
17665 [temp.dep.expr]. */
17667 bool
17669 {
17676 /* An unresolved name is always dependent. */
17681 /* Some expression forms are never type-dependent. */
17692 /* The types of these expressions depends only on the type to which
17693 the cast occurs. */
17701 /* The types of these expressions depends only on the type created
17702 by the expression. */
17705 {
17706 /* For NEW_EXPR tree nodes created inside a template, either
17707 the object type itself or a TREE_LIST may appear as the
17708 operand 1. */
17711 /* This is an array type. We need to check array dimensions
17712 as well. */
17714 || value_dependent_expression_p
17716 else
17718 }
17722 type_dependent_expression_p))
17728 && (any_dependent_template_arguments_p
17740 {
17741 tree elt;
17745 {
17748 }
17750 }
17752 /* A static data member of the current instantiation with incomplete
17753 array type is type-dependent, as the definition and specializations
17754 can have different bounds. */
17762 {
17767 {
17773 }
17774 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
17782 {
17787 }
17792 {
17796 }
17798 }
17803 }
17805 /* Like type_dependent_expression_p, but it also works while not processing
17806 a template definition, i.e. during substitution or mangling. */
17808 bool
17810 {
17816 }
17818 /* Returns TRUE if ARGS contains a type-dependent expression. */
17820 bool
17822 {
17824 tree arg;
17827 {
17830 }
17832 }
17834 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
17835 expressions) contains any value-dependent expressions. */
17837 bool
17839 {
17845 }
17847 /* Returns TRUE if the ARG (a template argument) is dependent. */
17849 bool
17851 {
17859 {
17863 {
17866 }
17869 }
17872 else
17875 }
17877 /* Returns true if ARGS (a collection of template arguments) contains
17878 any types that require structural equality testing. */
17880 bool
17882 {
17892 {
17895 {
17901 {
17902 /* Look inside the argument pack. */
17905 }
17908 {
17922 }
17923 }
17924 }
17927 }
17929 /* Returns true if ARGS (a collection of template arguments) contains
17930 any dependent arguments. */
17932 bool
17934 {
17944 {
17949 }
17952 }
17954 /* Returns TRUE if the template TMPL is dependent. */
17956 bool
17958 {
17960 {
17962 {
17966 }
17968 }
17970 /* Template template parameters are dependent. */
17974 /* So are names that have not been looked up. */
17978 /* So are member templates of dependent classes. */
17982 }
17984 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
17986 bool
17988 {
17991 }
17993 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
17994 is dependent. */
17996 bool
17998 {
18005 {
18026 {
18030 }
18034 {
18038 {
18043 }
18044 }
18045 }
18048 }
18050 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
18051 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
18052 no such TYPE can be found. Note that this function peers inside
18053 uninstantiated templates and therefore should be used only in
18054 extremely limited situations. ONLY_CURRENT_P restricts this
18055 peering to the currently open classes hierarchy (which is required
18056 when comparing types). */
18058 tree
18060 {
18061 tree scope;
18062 tree name;
18063 tree decl;
18065 tree pushed_scope;
18066 tree result;
18071 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
18072 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
18073 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
18074 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
18075 identifier of the TYPENAME_TYPE anymore.
18076 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
18077 TYPENAME_TYPE instead, we avoid messing up with a possible
18078 typedef variant case. */
18081 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
18082 it first before we can figure out what NAME refers to. */
18085 /* If we don't know what SCOPE refers to, then we cannot resolve the
18086 TYPENAME_TYPE. */
18089 /* If the SCOPE is a template type parameter, we have no way of
18090 resolving the name. */
18093 /* If the SCOPE is not the current instantiation, there's no reason
18094 to look inside it. */
18097 /* If this is a typedef, we don't want to look inside (c++/11987). */
18100 /* If SCOPE isn't the template itself, it will not have a valid
18101 TYPE_FIELDS list. */
18103 /* scope is either the template itself or a compatible instantiation
18104 like X<T>, so look up the name in the original template. */
18106 else
18107 /* scope is a partial instantiation, so we can't do the lookup or we
18108 will lose the template arguments. */
18110 /* Enter the SCOPE so that name lookup will be resolved as if we
18111 were in the class definition. In particular, SCOPE will no
18112 longer be considered a dependent type. */
18114 /* Look up the declaration. */
18119 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
18120 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
18125 {
18129 }
18132 {
18133 tree tmpl;
18134 tree args;
18135 /* Obtain the template and the arguments. */
18138 /* Instantiate the template. */
18144 }
18146 /* Leave the SCOPE. */
18150 /* If we failed to resolve it, return the original typename. */
18154 /* If lookup found a typename type, resolve that too. */
18156 {
18157 /* Ill-formed programs can cause infinite recursion here, so we
18158 must catch that. */
18162 }
18164 /* Qualify the resulting type. */
18170 }
18172 /* EXPR is an expression which is not type-dependent. Return a proxy
18173 for EXPR that can be used to compute the types of larger
18174 expressions containing EXPR. */
18176 tree
18178 {
18179 tree inner_expr;
18181 /* Preserve null pointer constants so that the type of things like
18182 "p == 0" where "p" is a pointer can be determined. */
18185 /* Preserve OVERLOADs; the functions must be available to resolve
18186 types. */
18197 /* There is no need to return a proxy for a variable. */
18200 /* Preserve string constants; conversions from string constants to
18201 "char *" are allowed, even though normally a "const char *"
18202 cannot be used to initialize a "char *". */
18205 /* Preserve arithmetic constants, as an optimization -- there is no
18206 reason to create a new node. */
18209 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
18210 There is at least one place where we want to know that a
18211 particular expression is a throw-expression: when checking a ?:
18212 expression, there are special rules if the second or third
18213 argument is a throw-expression. */
18232 /* If the type is unknown, it can't really be non-dependent */
18235 /* Otherwise, build a NON_DEPENDENT_EXPR.
18237 REFERENCE_TYPEs are not stripped for expressions in templates
18238 because doing so would play havoc with mangling. Consider, for
18239 example:
18241 template <typename T> void f<T& g>() { g(); }
18243 In the body of "f", the expression for "g" will have
18244 REFERENCE_TYPE, even though the standard says that it should
18245 not. The reason is that we must preserve the syntactic form of
18246 the expression so that mangling (say) "f<g>" inside the body of
18247 "f" works out correctly. Therefore, the REFERENCE_TYPE is
18248 stripped here. */
18250 }
18252 /* ARGS is a vector of expressions as arguments to a function call.
18253 Replace the arguments with equivalent non-dependent expressions.
18254 This modifies ARGS in place. */
18256 void
18258 {
18260 tree arg;
18263 {
18267 }
18268 }
18270 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
18271 with a level one deeper than the actual template parms. */
18273 tree
18275 {
18288 }
18290 /* Given type ARG, return std::initializer_list<ARG>. */
18292 static tree
18294 {
18295 tree std_init_list = namespace_binding
18297 tree argvec;
18299 {
18303 }
18308 }
18310 /* Replace auto in TYPE with std::initializer_list<auto>. */
18312 static tree
18314 {
18321 }
18323 /* walk_tree helper for do_auto_deduction. */
18325 static tree
18328 {
18329 /* Is this a variable with the type we're looking for? */
18333 else
18335 }
18337 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
18338 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
18340 tree
18342 {
18345 tree decl;
18348 /* The name of the object being declared shall not appear in the
18349 initializer expression. */
18352 {
18356 }
18358 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
18359 with either a new invented type template parameter U or, if the
18360 initializer is a braced-init-list (8.5.4), with
18361 std::initializer_list<U>. */
18374 {
18377 }
18379 /* If the list of declarators contains more than one declarator, the type
18380 of each declared variable is determined as described above. If the
18381 type deduced for the template parameter U is not the same in each
18382 deduction, the program is ill-formed. */
18385 {
18389 }
18395 }
18397 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
18398 result. */
18400 tree
18402 {
18403 tree argvec;
18412 }
18414 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
18416 bool
18418 {
18422 else
18424 }
18426 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
18427 appear as a type-specifier for the declaration in question, we don't
18428 have to look through the whole type. */
18430 tree
18432 {
18449 }
18451 /* For a given template T, return the vector of typedefs referenced
18452 in T for which access check is needed at T instantiation time.
18453 T is either a FUNCTION_DECL or a RECORD_TYPE.
18454 Those typedefs were added to T by the function
18455 append_type_to_template_for_access_check. */
18459 {
18460 tree ti;
18471 {
18476 }
18479 }
18481 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
18482 tied to T. That list of typedefs will be access checked at
18483 T instantiation time.
18484 T is either a FUNCTION_DECL or a RECORD_TYPE.
18485 TYPE_DECL is a TYPE_DECL node representing a typedef.
18486 SCOPE is the scope through which TYPE_DECL is accessed.
18487 LOCATION is the location of the usage point of TYPE_DECL.
18489 This function is a subroutine of
18490 append_type_to_template_for_access_check. */
18492 static void
18494 tree type_decl,
18495 tree scope,
18496 location_t location)
18497 {
18498 qualified_typedef_usage_t typedef_usage;
18499 tree ti;
18506 && type_decl
18522 }
18524 /* Append TYPE_DECL to the template TEMPL.
18525 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
18526 At TEMPL instanciation time, TYPE_DECL will be checked to see
18527 if it can be accessed through SCOPE.
18528 LOCATION is the location of the usage point of TYPE_DECL.
18530 e.g. consider the following code snippet:
18532 class C
18533 {
18534 typedef int myint;
18535 };
18537 template<class U> struct S
18538 {
18539 C::myint mi; // <-- usage point of the typedef C::myint
18540 };
18542 S<char> s;
18544 At S<char> instantiation time, we need to check the access of C::myint
18545 In other words, we need to check the access of the myint typedef through
18546 the C scope. For that purpose, this function will add the myint typedef
18547 and the scope C through which its being accessed to a list of typedefs
18548 tied to the template S. That list will be walked at template instantiation
18549 time and access check performed on each typedefs it contains.
18550 Note that this particular code snippet should yield an error because
18551 myint is private to C. */
18553 void
18555 tree type_decl,
18556 tree scope,
18557 location_t location)
18558 {
18564 /* Make sure we don't append the type to the template twice. */
18575 }
18577 /* Set up the hash tables for template instantiations. */
18579 void
18581 {
18583 hash_specialization,
18584 eq_specializations,
18585 ggc_free);
18587 hash_specialization,
18588 eq_specializations,
18589 ggc_free);
18590 }
18592 /* Print stats about the template hash tables for -fstats. */
18594 void
18596 {
18605 }