| blob | d1c33d65277251e353dac094e3d04e4aaf975147 |
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. */
1568 {
1572 val);
1575 /* Otherwise just compare the types during lookup. */
1584 {
1589 }
1590 }
1591 }
1594 }
1596 /* Unregister the specialization SPEC as a specialization of TMPL.
1597 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1598 if the SPEC was listed as a specialization of TMPL.
1600 Note that SPEC has been ggc_freed, so we can't look inside it. */
1602 bool
1604 {
1606 spec_entry elt;
1614 {
1619 }
1622 }
1624 /* Compare an entry in the local specializations hash table P1 (which
1625 is really a pointer to a TREE_LIST) with P2 (which is really a
1626 DECL). */
1628 static int
1630 {
1632 }
1634 /* Hash P1, an entry in the local specializations table. */
1636 static hashval_t
1638 {
1640 }
1642 /* Like register_specialization, but for local declarations. We are
1643 registering SPEC, an instantiation of TMPL. */
1645 static void
1647 {
1653 }
1655 /* TYPE is a class type. Returns true if TYPE is an explicitly
1656 specialized class. */
1658 bool
1660 {
1664 }
1666 /* Print the list of functions at FNS, going through all the overloads
1667 for each element of the list. Alternatively, FNS can not be a
1668 TREE_LIST, in which case it will be printed together with all the
1669 overloads.
1671 MORE and *STR should respectively be FALSE and NULL when the function
1672 is called from the outside. They are used internally on recursive
1673 calls. print_candidates manages the two parameters and leaves NULL
1674 in *STR when it ends. */
1676 static void
1678 {
1684 {
1689 }
1690 else
1691 {
1693 {
1694 /* Pick the prefix string. */
1696 {
1699 }
1703 }
1706 }
1709 {
1712 }
1713 }
1715 /* Print the list of candidate FNS in an error message. */
1717 void
1719 {
1723 }
1725 /* Returns the template (one of the functions given by TEMPLATE_ID)
1726 which can be specialized to match the indicated DECL with the
1727 explicit template args given in TEMPLATE_ID. The DECL may be
1728 NULL_TREE if none is available. In that case, the functions in
1729 TEMPLATE_ID are non-members.
1731 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1732 specialization of a member template.
1734 The TEMPLATE_COUNT is the number of references to qualifying
1735 template classes that appeared in the name of the function. See
1736 check_explicit_specialization for a more accurate description.
1738 TSK indicates what kind of template declaration (if any) is being
1739 declared. TSK_TEMPLATE indicates that the declaration given by
1740 DECL, though a FUNCTION_DECL, has template parameters, and is
1741 therefore a template function.
1743 The template args (those explicitly specified and those deduced)
1744 are output in a newly created vector *TARGS_OUT.
1746 If it is impossible to determine the result, an error message is
1747 issued. The error_mark_node is returned to indicate failure. */
1749 static tree
1751 tree decl,
1755 tmpl_spec_kind tsk)
1756 {
1757 tree fns;
1758 tree targs;
1759 tree explicit_targs;
1761 /* A TREE_LIST of templates of which DECL may be a specialization.
1762 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1763 corresponding TREE_PURPOSE is the set of template arguments that,
1764 when used to instantiate the template, would produce a function
1765 with the signature of DECL. */
1781 /* Check for baselinks. */
1786 {
1789 }
1791 /* Count the number of template headers specified for this
1792 specialization. */
1800 {
1804 {
1805 tree decl_arg_types;
1806 tree fn_arg_types;
1808 /* In case of explicit specialization, we need to check if
1809 the number of template headers appearing in the specialization
1810 is correct. This is usually done in check_explicit_specialization,
1811 but the check done there cannot be exhaustive when specializing
1812 member functions. Consider the following code:
1814 template <> void A<int>::f(int);
1815 template <> template <> void A<int>::f(int);
1817 Assuming that A<int> is not itself an explicit specialization
1818 already, the first line specializes "f" which is a non-template
1819 member function, whilst the second line specializes "f" which
1820 is a template member function. So both lines are syntactically
1821 correct, and check_explicit_specialization does not reject
1822 them.
1824 Here, we can do better, as we are matching the specialization
1825 against the declarations. We count the number of template
1826 headers, and we check if they match TEMPLATE_COUNT + 1
1827 (TEMPLATE_COUNT is the number of qualifying template classes,
1828 plus there must be another header for the member template
1829 itself).
1831 Notice that if header_count is zero, this is not a
1832 specialization but rather a template instantiation, so there
1833 is no check we can perform here. */
1837 /* Check that the number of template arguments at the
1838 innermost level for DECL is the same as for FN. */
1846 /* DECL might be a specialization of FN. */
1850 /* For a non-static member function, we need to make sure
1851 that the const qualification is the same. Since
1852 get_bindings does not try to merge the "this" parameter,
1853 we must do the comparison explicitly. */
1859 /* Skip the "this" parameter and, for constructors of
1860 classes with virtual bases, the VTT parameter. A
1861 full specialization of a constructor will have a VTT
1862 parameter, but a template never will. */
1863 decl_arg_types
1865 fn_arg_types
1868 /* Check that the number of function parameters matches.
1869 For example,
1870 template <class T> void f(int i = 0);
1871 template <> void f<int>();
1872 The specialization f<int> is invalid but is not caught
1873 by get_bindings below. */
1877 /* Function templates cannot be specializations; there are
1878 no partial specializations of functions. Therefore, if
1879 the type of DECL does not match FN, there is no
1880 match. */
1882 {
1886 }
1888 /* See whether this function might be a specialization of this
1889 template. */
1893 /* We cannot deduce template arguments that when used to
1894 specialize TMPL will produce DECL. */
1897 /* Save this template, and the arguments deduced. */
1899 }
1901 /* FN is an ordinary member function, and we need a
1902 specialization of a member template. */
1903 ;
1905 /* We can get IDENTIFIER_NODEs here in certain erroneous
1906 cases. */
1907 ;
1909 /* This is just an ordinary non-member function. Nothing can
1910 be a specialization of that. */
1911 ;
1913 /* Cannot specialize functions that are created implicitly. */
1914 ;
1915 else
1916 {
1917 tree decl_arg_types;
1919 /* This is an ordinary member function. However, since
1920 we're here, we can assume it's enclosing class is a
1921 template class. For example,
1923 template <typename T> struct S { void f(); };
1924 template <> void S<int>::f() {}
1926 Here, S<int>::f is a non-template, but S<int> is a
1927 template class. If FN has the same type as DECL, we
1928 might be in business. */
1931 /* Its enclosing class is an explicit specialization
1932 of a template class. This is not a candidate. */
1937 /* The return types differ. */
1940 /* Adjust the type of DECL in case FN is a static member. */
1947 decl_arg_types))
1948 /* They match! */
1950 }
1951 }
1954 {
1955 /* We have:
1957 [temp.expl.spec]
1959 It is possible for a specialization with a given function
1960 signature to be instantiated from more than one function
1961 template. In such cases, explicit specification of the
1962 template arguments must be used to uniquely identify the
1963 function template specialization being specialized.
1965 Note that here, there's no suggestion that we're supposed to
1966 determine which of the candidate templates is most
1967 specialized. However, we, also have:
1969 [temp.func.order]
1971 Partial ordering of overloaded function template
1972 declarations is used in the following contexts to select
1973 the function template to which a function template
1974 specialization refers:
1976 -- when an explicit specialization refers to a function
1977 template.
1979 So, we do use the partial ordering rules, at least for now.
1980 This extension can only serve to make invalid programs valid,
1981 so it's safe. And, there is strong anecdotal evidence that
1982 the committee intended the partial ordering rules to apply;
1983 the EDG front end has that behavior, and John Spicer claims
1984 that the committee simply forgot to delete the wording in
1985 [temp.expl.spec]. */
1988 {
1991 }
1992 }
1995 {
2003 }
2007 {
2013 }
2015 /* We have one, and exactly one, match. */
2017 {
2020 /* DECL is a re-declaration or partial instantiation of a template
2021 function. */
2024 /* It was a specialization of an ordinary member function in a
2025 template class. */
2027 }
2029 /* It was a specialization of a template. */
2032 {
2037 }
2038 else
2041 }
2043 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2044 but with the default argument values filled in from those in the
2045 TMPL_TYPES. */
2047 static tree
2049 tree tmpl_types)
2050 {
2051 tree new_spec_types;
2059 /* Substitute into the rest of the list. */
2060 new_spec_types =
2064 /* Add the default argument for this parameter. */
2067 new_spec_types);
2068 }
2070 /* DECL is an explicit specialization. Replicate default arguments
2071 from the template it specializes. (That way, code like:
2073 template <class T> void f(T = 3);
2074 template <> void f(double);
2075 void g () { f (); }
2077 works, as required.) An alternative approach would be to look up
2078 the correct default arguments at the call-site, but this approach
2079 is consistent with how implicit instantiations are handled. */
2081 static void
2083 {
2084 tree tmpl;
2085 tree spec_types;
2086 tree tmpl_types;
2087 tree new_spec_types;
2088 tree old_type;
2089 tree new_type;
2090 tree t;
2095 /* See if there's anything we need to do. */
2108 {
2109 /* Remove the this pointer, but remember the object's type for
2110 CV quals. */
2116 {
2117 /* DECL may contain more parameters than TMPL due to the extra
2118 in-charge parameter in constructors and destructors. */
2121 }
2123 {
2126 }
2127 }
2129 /* Compute the merged default arguments. */
2130 new_spec_types =
2133 /* Compute the new FUNCTION_TYPE. */
2135 {
2139 new_spec_types);
2142 /* Put the in-charge parameter back. */
2145 new_spec_types);
2149 new_spec_types);
2150 }
2151 else
2153 new_spec_types);
2159 }
2161 /* Check to see if the function just declared, as indicated in
2162 DECLARATOR, and in DECL, is a specialization of a function
2163 template. We may also discover that the declaration is an explicit
2164 instantiation at this point.
2166 Returns DECL, or an equivalent declaration that should be used
2167 instead if all goes well. Issues an error message if something is
2168 amiss. Returns error_mark_node if the error is not easily
2169 recoverable.
2171 FLAGS is a bitmask consisting of the following flags:
2173 2: The function has a definition.
2174 4: The function is a friend.
2176 The TEMPLATE_COUNT is the number of references to qualifying
2177 template classes that appeared in the name of the function. For
2178 example, in
2180 template <class T> struct S { void f(); };
2181 void S<int>::f();
2183 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2184 classes are not counted in the TEMPLATE_COUNT, so that in
2186 template <class T> struct S {};
2187 template <> struct S<int> { void f(); }
2188 template <> void S<int>::f();
2190 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2191 invalid; there should be no template <>.)
2193 If the function is a specialization, it is marked as such via
2194 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2195 is set up correctly, and it is added to the list of specializations
2196 for that template. */
2198 tree
2200 tree decl,
2203 {
2211 tmpl_spec_kind tsk;
2214 {
2217 else
2219 }
2220 else
2224 {
2227 {
2230 }
2232 {
2234 /* This could be something like:
2236 template <class T> void f(T);
2237 class S { friend void f<>(int); } */
2239 else
2240 {
2241 /* This case handles bogus declarations like template <>
2242 template <class T> void f<int>(); */
2245 declarator);
2247 }
2248 }
2252 /* The error has already been reported in
2253 check_specialization_scope. */
2259 /* Fall through. */
2272 decl);
2275 else
2279 /* Fall through. */
2284 else
2290 {
2291 /* This case handles bogus declarations like template <>
2292 template <class T> void f<int>(); */
2297 else
2299 declarator);
2301 }
2304 /* This is a specialization of a member template, without
2305 specialization the containing class. Something like:
2307 template <class T> struct S {
2308 template <class U> void f (U);
2309 };
2310 template <> template <class U> void S<int>::f(U) {}
2312 That's a specialization -- but of the entire template. */
2318 }
2321 {
2325 {
2329 }
2330 }
2333 {
2337 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2339 {
2340 tree fns;
2345 else
2346 {
2347 /* If there is no class context, the explicit instantiation
2348 must be at namespace scope. */
2351 /* Find the namespace binding, using the declaration
2352 context. */
2356 {
2359 }
2360 else
2361 {
2367 }
2368 }
2371 }
2377 {
2379 /* A specialization in class scope. This is invalid,
2380 but the error will already have been flagged by
2381 check_specialization_scope. */
2383 else
2384 {
2385 /* It's not valid to write an explicit instantiation in
2386 class scope, e.g.:
2388 class C { template void f(); }
2390 This case is caught by the parser. However, on
2391 something like:
2393 template class C { void f(); };
2395 (which is invalid) we can get here. The error will be
2396 issued later. */
2397 ;
2398 }
2401 }
2404 IDENTIFIER_NODE))
2405 {
2406 /* Find the list of functions in ctype that have the same
2407 name as the declared function. */
2413 {
2418 {
2419 /* From [temp.expl.spec]:
2421 If such an explicit specialization for the member
2422 of a class template names an implicitly-declared
2423 special member function (clause _special_), the
2424 program is ill-formed.
2426 Similar language is found in [temp.explicit]. */
2429 }
2432 }
2435 {
2439 }
2440 else
2441 {
2443 tree ovl;
2445 /* For a type-conversion operator, we cannot do a
2446 name-based lookup. We might be looking for `operator
2447 int' which will be a specialization of `operator T'.
2448 So, we find *all* the conversion operators, and then
2449 select from them. */
2457 {
2459 /* There are no more conversion functions. */
2462 /* Glue all these conversion functions together
2463 with those we already have. */
2466 }
2467 }
2470 {
2473 }
2474 else
2476 }
2478 /* Figure out what exactly is being specialized at this point.
2479 Note that for an explicit instantiation, even one for a
2480 member function, we cannot tell apriori whether the
2481 instantiation is for a member template, or just a member
2482 function of a template class. Even if a member template is
2483 being instantiated, the member template arguments may be
2484 elided if they can be deduced from the rest of the
2485 declaration. */
2488 member_specialization,
2489 template_count,
2490 tsk);
2493 /* We couldn't figure out what this declaration was
2494 specializing. */
2496 else
2497 {
2501 {
2502 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2503 is done by do_decl_instantiation later. */
2509 {
2510 /* If TMPL is not the most general template (for
2511 example, if TMPL is a friend template that is
2512 injected into namespace scope), then there will
2513 be too many levels of TARGS. Remove some of them
2514 here. */
2516 tree new_targs;
2523 }
2526 }
2528 /* If we thought that the DECL was a member function, but it
2529 turns out to be specializing a static member function,
2530 make DECL a static member function as well. */
2535 /* If this is a specialization of a member template of a
2536 template class, we want to return the TEMPLATE_DECL, not
2537 the specialization of it. */
2539 {
2544 {
2545 tree parm;
2549 /* We want to use the argument list specified in the
2550 definition, not in the original declaration. */
2555 }
2558 }
2560 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2563 /* Inherit default function arguments from the template
2564 DECL is specializing. */
2567 /* This specialization has the same protection as the
2568 template it specializes. */
2572 /* 7.1.1-1 [dcl.stc]
2574 A storage-class-specifier shall not be specified in an
2575 explicit specialization...
2577 The parser rejects these, so unless action is taken here,
2578 explicit function specializations will always appear with
2579 global linkage.
2581 The action recommended by the C++ CWG in response to C++
2582 defect report 605 is to make the storage class and linkage
2583 of the explicit specialization match the templated function:
2585 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2586 */
2588 {
2592 /* This specialization has the same linkage and visibility as
2593 the function template it specializes. */
2596 {
2599 }
2602 {
2605 }
2606 }
2608 /* If DECL is a friend declaration, declared using an
2609 unqualified name, the namespace associated with DECL may
2610 have been set incorrectly. For example, in:
2612 template <typename T> void f(T);
2613 namespace N {
2614 struct S { friend void f<int>(int); }
2615 }
2617 we will have set the DECL_CONTEXT for the friend
2618 declaration to N, rather than to the global namespace. */
2623 /* This is not really a declaration of a specialization.
2624 It's just the name of an instantiation. But, it's not
2625 a request for an instantiation, either. */
2628 /* This is indeed a specialization. In case of constructors
2629 and destructors, we need in-charge and not-in-charge
2630 versions in V3 ABI. */
2633 /* Register this specialization so that we can find it
2634 again. */
2636 }
2637 }
2640 }
2642 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2643 parameters. These are represented in the same format used for
2644 DECL_TEMPLATE_PARMS. */
2646 int
2648 {
2649 const_tree p1;
2650 const_tree p2;
2658 {
2670 {
2674 /* If either of the template parameters are invalid, assume
2675 they match for the sake of error recovery. */
2688 }
2689 }
2692 /* One set of parameters has more parameters lists than the
2693 other. */
2697 }
2699 /* Determine whether PARM is a parameter pack. */
2701 bool
2703 {
2704 /* Determine if we have a non-type template parameter pack. */
2709 /* If this is a list of template parameters, we could get a
2710 TYPE_DECL or a TEMPLATE_DECL. */
2717 }
2719 /* Determine if T is a function parameter pack. */
2721 bool
2723 {
2727 }
2729 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2730 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2732 tree
2734 {
2741 }
2743 /* Return true iff the function parameter PARAM_DECL was expanded
2744 from the function parameter pack PACK. */
2746 bool
2748 {
2753 /* The parameter pack and its pack arguments have the same
2754 DECL_PARM_INDEX. */
2756 }
2758 /* Determine whether ARGS describes a variadic template args list,
2759 i.e., one that is terminated by a template argument pack. */
2761 static bool
2763 {
2765 tree last_parm;
2779 }
2781 /* Generate a new name for the parameter pack name NAME (an
2782 IDENTIFIER_NODE) that incorporates its */
2784 static tree
2786 {
2787 /* Munge the name to include the parameter index. */
2788 #define NUMBUF_LEN 128
2800 }
2802 /* Return true if T is a primary function
2803 or class template instantiation. */
2805 bool
2807 {
2819 }
2821 /* Return true if PARM is a template template parameter. */
2823 bool
2825 {
2827 }
2829 /* Return the template parameters of T if T is a
2830 primary template instantiation, NULL otherwise. */
2832 tree
2834 {
2839 parms = INNERMOST_TEMPLATE_PARMS
2843 }
2845 /* Return the template parameters of the LEVELth level from the full list
2846 of template parameters PARMS. */
2848 tree
2850 {
2851 tree p;
2862 }
2864 /* Returns the template arguments of T if T is a template instantiation,
2865 NULL otherwise. */
2867 tree
2869 {
2877 }
2879 /* Return the argument pack elements of T if T is a template argument pack,
2880 NULL otherwise. */
2882 tree
2884 {
2890 }
2892 /* Structure used to track the progress of find_parameter_packs_r. */
2893 struct find_parameter_pack_data
2894 {
2895 /* TREE_LIST that will contain all of the parameter packs found by
2896 the traversal. */
2899 /* Set of AST nodes that have been visited by the traversal. */
2901 };
2903 /* Identifies all of the argument packs that occur in a template
2904 argument and appends them to the TREE_LIST inside DATA, which is a
2905 find_parameter_pack_data structure. This is a subroutine of
2906 make_pack_expansion and uses_parameter_packs. */
2907 static tree
2909 {
2915 /* Identify whether this is a parameter pack or not. */
2917 {
2931 {
2932 /* We don't want to walk into the type of a PARM_DECL,
2933 because we don't want to see the type parameter pack. */
2936 }
2940 /* Not a parameter pack. */
2942 }
2945 {
2946 /* Add this parameter pack to the list. */
2948 }
2954 /* This switch statement will return immediately if we don't find a
2955 parameter pack. */
2957 {
2962 /* Check the template itself. */
2965 /* Check the template arguments. */
2981 /* Fall through. */
3022 }
3025 }
3027 /* Determines if the expression or type T uses any parameter packs. */
3028 bool
3030 {
3038 }
3040 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3041 representation a base-class initializer into a parameter pack
3042 expansion. If all goes well, the resulting node will be an
3043 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3044 respectively. */
3045 tree
3047 {
3048 tree result;
3057 {
3058 /* The only time we will see a TREE_LIST here is for a base
3059 class initializer. In this case, the TREE_PURPOSE will be a
3060 _TYPE node (representing the base class expansion we're
3061 initializing) and the TREE_VALUE will be a TREE_LIST
3062 containing the initialization arguments.
3064 The resulting expansion looks somewhat different from most
3065 expansions. Rather than returning just one _EXPANSION, we
3066 return a TREE_LIST whose TREE_PURPOSE is a
3067 TYPE_PACK_EXPANSION containing the bases that will be
3068 initialized. The TREE_VALUE will be identical to the
3069 original TREE_VALUE, which is a list of arguments that will
3070 be passed to each base. We do not introduce any new pack
3071 expansion nodes into the TREE_VALUE (although it is possible
3072 that some already exist), because the TREE_PURPOSE and
3073 TREE_VALUE all need to be expanded together with the same
3074 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3075 resulting TREE_PURPOSE will mention the parameter packs in
3076 both the bases and the arguments to the bases. */
3077 tree purpose;
3078 tree value;
3081 /* Determine which parameter packs will be used by the base
3082 class expansion. */
3089 {
3093 }
3096 {
3097 /* Collect the sets of parameter packs used in each of the
3098 initialization arguments. */
3100 {
3101 /* Determine which parameter packs will be expanded in this
3102 argument. */
3105 }
3106 }
3110 /* Create the pack expansion type for the base type. */
3115 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3116 they will rarely be compared to anything. */
3120 }
3125 /* Build the PACK_EXPANSION_* node. */
3126 result = for_types
3131 {
3132 /* Propagate type and const-expression information. */
3135 }
3136 else
3137 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3138 they will rarely be compared to anything. */
3141 /* Determine which parameter packs will be expanded. */
3147 /* Make sure we found some parameter packs. */
3149 {
3152 else
3155 }
3159 }
3161 /* Checks T for any "bare" parameter packs, which have not yet been
3162 expanded, and issues an error if any are found. This operation can
3163 only be done on full expressions or types (e.g., an expression
3164 statement, "if" condition, etc.), because we could have expressions like:
3166 foo(f(g(h(args)))...)
3168 where "args" is a parameter pack. check_for_bare_parameter_packs
3169 should not be called for the subexpressions args, h(args),
3170 g(h(args)), or f(g(h(args))), because we would produce erroneous
3171 error messages.
3173 Returns TRUE and emits an error if there were bare parameter packs,
3174 returns FALSE otherwise. */
3175 bool
3177 {
3193 {
3196 {
3205 else
3210 else
3214 }
3217 }
3220 }
3222 /* Expand any parameter packs that occur in the template arguments in
3223 ARGS. */
3224 tree
3226 {
3232 /* First, determine if we need to expand anything, and the number of
3233 slots we'll need. */
3235 {
3240 {
3244 else
3246 }
3247 else
3248 {
3250 num_result_args++;
3251 }
3252 }
3254 /* If no expansion is necessary, we're done. */
3258 /* Expand arguments. */
3261 non_default_args_count =
3264 {
3267 {
3274 }
3275 else
3276 {
3279 }
3280 }
3284 }
3286 /* Checks if DECL shadows a template parameter.
3288 [temp.local]: A template-parameter shall not be redeclared within its
3289 scope (including nested scopes).
3291 Emits an error and returns TRUE if the DECL shadows a parameter,
3292 returns FALSE otherwise. */
3294 bool
3296 {
3297 tree olddecl;
3299 /* If we're not in a template, we can't possibly shadow a template
3300 parameter. */
3304 /* Figure out what we're shadowing. */
3309 /* If there's no previous binding for this name, we're not shadowing
3310 anything, let alone a template parameter. */
3314 /* If we're not shadowing a template parameter, we're done. Note
3315 that OLDDECL might be an OVERLOAD (or perhaps even an
3316 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3317 node. */
3321 /* We check for decl != olddecl to avoid bogus errors for using a
3322 name inside a class. We check TPFI to avoid duplicate errors for
3323 inline member templates. */
3331 }
3333 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3334 ORIG_LEVEL, DECL, and TYPE. */
3336 static tree
3340 tree decl,
3341 tree type)
3342 {
3353 }
3355 /* Find the canonical type parameter for the given template type
3356 parameter. Returns the canonical type parameter, which may be TYPE
3357 if no such parameter existed. */
3358 static tree
3360 {
3361 tree list;
3375 else
3376 {
3381 }
3382 }
3384 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3385 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3386 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3387 new one is created. */
3389 static tree
3391 tsubst_flags_t complain)
3392 {
3397 {
3416 /* Template template parameters need this. */
3421 }
3424 }
3426 /* Process information from new template parameter PARM and append it to the
3427 LIST being built. This new parameter is a non-type parameter iff
3428 IS_NON_TYPE is true. This new parameter is a parameter
3429 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3430 PARM_LOC. */
3432 tree
3435 {
3437 tree defval;
3438 tree err_parm_list;
3445 {
3449 {
3453 else
3455 }
3458 }
3459 else
3463 {
3469 {
3473 }
3474 else
3475 {
3476 /* [temp.param]
3478 The top-level cv-qualifiers on the template-parameter are
3479 ignored when determining its type. */
3482 {
3486 }
3489 {
3490 /* This template parameter is not a parameter pack, but it
3491 should be. Complain about "bare" parameter packs. */
3494 /* Recover by calling this a parameter pack. */
3496 }
3497 }
3499 /* A template parameter is not modifiable. */
3508 processing_template_decl,
3513 }
3514 else
3515 {
3516 tree t;
3520 {
3522 /* This is for distinguishing between real templates and template
3523 template parameters */
3527 }
3528 else
3529 {
3531 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3534 }
3541 processing_template_decl,
3545 }
3551 }
3553 /* The end of a template parameter list has been reached. Process the
3554 tree list into a parameter vector, converting each parameter into a more
3555 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3556 as PARM_DECLs. */
3558 tree
3560 {
3565 current_template_parms
3570 {
3576 current_template_parms;
3577 }
3582 }
3584 /* end_template_decl is called after a template declaration is seen. */
3586 void
3588 {
3594 /* This matches the pushlevel in begin_template_parm_list. */
3599 }
3601 /* Within the declaration of a template, return all levels of template
3602 parameters that apply. The template parameters are represented as
3603 a TREE_VEC, in the form documented in cp-tree.h for template
3604 arguments. */
3606 static tree
3608 {
3609 tree header;
3614 /* If there is only one level of template parameters, we do not
3615 create a TREE_VEC of TREE_VECs. Instead, we return a single
3616 TREE_VEC containing the arguments. */
3621 {
3627 {
3630 /* T will be a list if we are called from within a
3631 begin/end_template_parm_list pair, but a vector directly
3632 if within a begin/end_member_template_processing pair. */
3634 {
3638 {
3641 {
3645 {
3646 /* Turn this argument into a TYPE_ARGUMENT_PACK
3647 with a single element, which expands T. */
3649 #ifdef ENABLE_CHECKING
3650 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3652 #endif
3657 }
3658 }
3659 else
3660 {
3664 {
3665 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3666 with a single element, which expands T. */
3669 #ifdef ENABLE_CHECKING
3670 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3672 #endif
3678 }
3679 }
3681 }
3682 }
3683 }
3685 #ifdef ENABLE_CHECKING
3687 #endif
3691 else
3693 }
3696 }
3698 /* Update the declared TYPE by doing any lookups which were thought to be
3699 dependent, but are not now that we know the SCOPE of the declarator. */
3701 tree
3703 {
3714 /* Don't bother building up the args in this case. */
3716 {
3717 /* tsubst in the args corresponding to the template parameters,
3718 including auto if present. Most things will be unchanged, but
3719 make_typename_type and tsubst_qualified_id will resolve
3720 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3723 tree pushed;
3725 {
3729 }
3734 }
3740 {
3743 else
3745 }
3747 }
3749 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3750 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3751 a member template. Used by push_template_decl below. */
3753 static tree
3755 {
3762 }
3764 struct template_parm_data
3765 {
3766 /* The level of the template parameters we are currently
3767 processing. */
3770 /* The index of the specialization argument we are currently
3771 processing. */
3774 /* An array whose size is the number of template parameters. The
3775 elements are nonzero if the parameter has been used in any one
3776 of the arguments processed so far. */
3779 /* An array whose size is the number of template arguments. The
3780 elements are nonzero if the argument makes use of template
3781 parameters of this level. */
3783 };
3785 /* Subroutine of push_template_decl used to see if each template
3786 parameter in a partial specialization is used in the explicit
3787 argument list. If T is of the LEVEL given in DATA (which is
3788 treated as a template_parm_data*), then DATA->PARMS is marked
3789 appropriately. */
3791 static int
3793 {
3799 {
3802 }
3803 else
3804 {
3807 }
3810 {
3813 }
3815 /* Return zero so that for_each_template_parm will continue the
3816 traversal of the tree; we want to mark *every* template parm. */
3818 }
3820 /* Process the partial specialization DECL. */
3822 static tree
3824 {
3830 tree inner_parms;
3843 /* We check that each of the template parameters given in the
3844 partial specialization is used in the argument list to the
3845 specialization. For example:
3847 template <class T> struct S;
3848 template <class T> struct S<T*>;
3850 The second declaration is OK because `T*' uses the template
3851 parameter T, whereas
3853 template <class T> struct S<int>;
3855 is no good. Even trickier is:
3857 template <class T>
3858 struct S1
3859 {
3860 template <class U>
3861 struct S2;
3862 template <class U>
3863 struct S2<T>;
3864 };
3866 The S2<T> declaration is actually invalid; it is a
3867 full-specialization. Of course,
3869 template <class U>
3870 struct S2<T (*)(U)>;
3872 or some such would have been OK. */
3880 {
3885 NULL,
3887 }
3890 {
3891 /* One of the template parms was not used in the
3892 specialization. */
3894 {
3897 }
3900 }
3902 /* [temp.class.spec]
3904 The argument list of the specialization shall not be identical to
3905 the implicit argument list of the primary template. */
3912 /* [temp.class.spec]
3914 A partially specialized non-type argument expression shall not
3915 involve template parameters of the partial specialization except
3916 when the argument expression is a simple identifier.
3918 The type of a template parameter corresponding to a specialized
3919 non-type argument shall not be dependent on a parameter of the
3920 specialization.
3922 Also, we verify that pack expansions only occur at the
3923 end of the argument list. */
3927 {
3934 {
3935 /* Extract the arguments from the argument pack. We'll be
3936 iterating over these in the following loop. */
3939 }
3942 {
3944 /* Get the Jth argument in the parameter pack. */
3948 {
3949 /* Pack expansions must come at the end of the
3950 argument list. */
3953 {
3957 else
3960 }
3961 }
3964 /* We only care about the pattern. */
3970 /* This next line is the `argument expression is not just a
3971 simple identifier' condition and also the `specialized
3972 non-type argument' bit. */
3974 {
3978 arg);
3979 else
3980 {
3981 /* Look at the corresponding template parameter,
3982 marking which template parameters its type depends
3983 upon. */
3987 {
3988 /* We haven't yet initialized TPD2. Do so now. */
3989 tpd2.arg_uses_template_parms
3991 /* The number of parameters here is the number in the
3992 main template, which, as checked in the assertion
3993 above, is NARGS. */
3997 }
3999 /* Mark the template parameters. But this time, we're
4000 looking for the template parameters of the main
4001 template, not in the specialization. */
4008 NULL,
4012 {
4013 /* The type depended on some template parameters.
4014 If they are fully specialized in the
4015 specialization, that's OK. */
4024 "type %qT of template argument %qE depends "
4026 "type %qT of template argument %qE depends "
4028 type,
4029 arg);
4030 }
4031 }
4032 }
4033 }
4034 }
4036 /* We should only get here once. */
4044 }
4046 /* Check that a template declaration's use of default arguments and
4047 parameter packs is not invalid. Here, PARMS are the template
4048 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
4049 a primary template. IS_PARTIAL is nonzero if DECL is a partial
4050 specialization.
4053 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4054 declaration (but not a definition); 1 indicates a declaration, 2
4055 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4056 emitted for extraneous default arguments.
4058 Returns TRUE if there were no errors found, FALSE otherwise. */
4060 bool
4063 {
4066 tree parm_level;
4069 /* [temp.param]
4071 A default template-argument shall not be specified in a
4072 function template declaration or a function template definition, nor
4073 in the template-parameter-list of the definition of a member of a
4074 class template. */
4077 /* You can't have a function template declaration in a local
4078 scope, nor you can you define a member of a class template in a
4079 local scope. */
4086 /* If this is either a friend defined in the scope of the class
4087 or a member function. */
4093 /* And, if it was a member function, it really was defined in
4094 the scope of the class. */
4097 /* We already checked these parameters when the template was
4098 declared, so there's no need to do it again now. This function
4099 was defined in class scope, but we're processing it's body now
4100 that the class is complete. */
4103 /* Core issue 226 (C++0x only): the following only applies to class
4104 templates. */
4106 {
4107 /* [temp.param]
4109 If a template-parameter has a default template-argument, all
4110 subsequent template-parameters shall have a default
4111 template-argument supplied. */
4113 {
4120 {
4130 {
4132 /* For better subsequent error-recovery, we indicate that
4133 there should have been a default argument. */
4136 }
4138 && !is_partial
4139 && !is_friend_decl
4140 /* Don't complain about an enclosing partial
4141 specialization. */
4146 {
4147 /* A primary class template can only have one
4148 parameter pack, at the end of the template
4149 parameter list. */
4154 else
4162 }
4163 }
4164 }
4165 }
4168 || is_partial
4169 || !is_primary
4171 /* For an ordinary class template, default template arguments are
4172 allowed at the innermost level, e.g.:
4173 template <class T = int>
4174 struct S {};
4175 but, in a partial specialization, they're not allowed even
4176 there, as we have in [temp.class.spec]:
4178 The template parameter list of a specialization shall not
4179 contain default template argument values.
4181 So, for a partial specialization, or for a function template
4182 (in C++98/C++03), we look at all of them. */
4183 ;
4184 else
4185 /* But, for a primary class template that is not a partial
4186 specialization we look at all template parameters except the
4187 innermost ones. */
4190 /* Figure out what error message to issue. */
4203 else
4207 /* If we're inside a class definition, there's no need to
4208 examine the parameters to the class itself. On the one
4209 hand, they will be checked when the class is defined, and,
4210 on the other, default arguments are valid in things like:
4211 template <class T = double>
4212 struct S { template <class U> void f(U); };
4213 Here the default argument for `S' has no bearing on the
4214 declaration of `f'. */
4216 else
4217 /* Check everything. */
4223 {
4230 {
4235 {
4237 {
4244 }
4246 /* Clear out the default argument so that we are not
4247 confused later. */
4249 }
4250 }
4252 /* At this point, if we're still interested in issuing messages,
4253 they must apply to classes surrounding the object declared. */
4257 }
4260 }
4262 /* Worker for push_template_decl_real, called via
4263 for_each_template_parm. DATA is really an int, indicating the
4264 level of the parameters we are interested in. If T is a template
4265 parameter of that level, return nonzero. */
4267 static int
4269 {
4275 else
4278 }
4280 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4281 parameters given by current_template_args, or reuses a
4282 previously existing one, if appropriate. Returns the DECL, or an
4283 equivalent one, if it is replaced via a call to duplicate_decls.
4285 If IS_FRIEND is true, DECL is a friend declaration. */
4287 tree
4289 {
4290 tree tmpl;
4291 tree args;
4292 tree info;
4293 tree ctx;
4297 /* True if the template is a member template, in the sense of
4298 [temp.mem]. */
4304 /* See if this is a partial specialization. */
4313 /* For a friend, we want the context of the friend function, not
4314 the type of which it is a friend. */
4318 /* In the case of a virtual function, we want the class in which
4319 it is defined. */
4321 else
4322 /* Otherwise, if we're currently defining some class, the DECL
4323 is assumed to be a member of the class. */
4332 /* See if this is a primary template. */
4334 /* A friend template that specifies a class context, i.e.
4335 template <typename T> friend void A<T>::f();
4336 is not primary. */
4338 else
4342 {
4347 {
4350 }
4352 {
4354 {
4355 /* [temp.mem]
4357 A destructor shall not be a member template. */
4360 }
4367 {
4368 /* [basic.stc.dynamic.allocation]
4370 An allocation function can be a function
4371 template. ... Template allocation functions shall
4372 have two or more parameters. */
4375 }
4376 }
4380 else
4381 {
4384 }
4385 }
4387 /* Check to see that the rules regarding the use of default
4388 arguments are not being violated. */
4392 /* Ensure that there are no parameter packs in the type of this
4393 declaration that have not been expanded. */
4395 {
4396 /* Check each of the arguments individually to see if there are
4397 any bare parameter packs. */
4403 {
4406 {
4407 /* This is a PARM_DECL that contains unexpanded parameter
4408 packs. We have already complained about this in the
4409 check_for_bare_parameter_packs call, so just replace
4410 these types with ERROR_MARK_NODE. */
4413 }
4417 }
4419 /* Check for bare parameter packs in the return type and the
4420 exception specifiers. */
4422 /* Errors were already issued, set return type to int
4423 as the frontend doesn't expect error_mark_node as
4424 the return type. */
4428 }
4430 {
4433 }
4444 {
4449 /* If DECL is a TYPE_DECL for a class-template, then there won't
4450 be DECL_LANG_SPECIFIC. The information equivalent to
4451 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4455 {
4456 /* Since a template declaration already existed for this
4457 class-type, we must be redeclaring it here. Make sure
4458 that the redeclaration is valid. */
4460 current_template_parms);
4461 /* We don't need to create a new TEMPLATE_DECL; just use the
4462 one we already had. */
4464 }
4465 else
4466 {
4468 member_template_p);
4473 {
4474 /* A specialization of a member template of a template
4475 class. */
4479 }
4480 }
4481 }
4482 else
4483 {
4489 {
4492 }
4500 {
4501 tree new_tmpl;
4503 /* The declaration is a specialization of a member
4504 template, declared outside the class. Therefore, the
4505 innermost template arguments will be NULL, so we
4506 replace them with the arguments determined by the
4507 earlier call to check_explicit_specialization. */
4510 new_tmpl
4512 member_template_p);
4522 args,
4525 }
4527 /* Make sure the template headers we got make sense. */
4532 {
4535 }
4536 else
4538 {
4543 {
4547 else
4552 }
4557 /* Can happen in erroneous input. */
4559 else
4563 }
4565 /* Check that the parms are used in the appropriate qualifying scopes
4566 in the declarator. */
4570 {
4576 /* Avoid crash in import_export_decl. */
4579 }
4580 }
4585 /* Push template declarations for global functions and types. Note
4586 that we do not try to push a global template friend declared in a
4587 template class; such a thing may well depend on the template
4588 parameters of the class. */
4591 {
4596 /* Hide template friend classes that haven't been declared yet. */
4598 {
4601 }
4602 }
4605 {
4611 {
4614 /* It is a conversion operator. See if the type converted to
4615 depends on innermost template operands. */
4618 depth))
4620 }
4622 /* Give template template parms a DECL_CONTEXT of the template
4623 for which they are a parameter. */
4626 {
4630 }
4631 }
4633 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4634 back to its most general template. If TMPL is a specialization,
4635 ARGS may only have the innermost set of arguments. Add the missing
4636 argument levels if necessary. */
4648 }
4650 tree
4652 {
4654 }
4656 /* Called when a class template TYPE is redeclared with the indicated
4657 template PARMS, e.g.:
4659 template <class T> struct S;
4660 template <class T> struct S {}; */
4662 bool
4664 {
4665 tree tmpl;
4666 tree tmpl_parms;
4670 {
4673 }
4677 /* The type is nested in some template class. Nothing to worry
4678 about here; there are no new template parameters for the nested
4679 type. */
4683 {
4685 tmpl);
4687 }
4693 {
4703 }
4706 {
4707 tree tmpl_parm;
4708 tree parm;
4709 tree tmpl_default;
4710 tree parm_default;
4724 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4725 TEMPLATE_DECL. */
4735 {
4739 }
4742 {
4743 /* We have in [temp.param]:
4745 A template-parameter may not be given default arguments
4746 by two different declarations in the same scope. */
4751 }
4754 /* Update the previous template parameters (which are the ones
4755 that will really count) with the new default value. */
4758 /* Update the new parameters, too; they'll be used as the
4759 parameters for any members. */
4761 }
4764 }
4766 /* Simplify EXPR if it is a non-dependent expression. Returns the
4767 (possibly simplified) expression. */
4769 tree
4771 {
4775 /* If we're in a template, but EXPR isn't value dependent, simplify
4776 it. We're supposed to treat:
4778 template <typename T> void f(T[1 + 1]);
4779 template <typename T> void f(T[2]);
4781 as two declarations of the same function, for example. */
4785 {
4786 HOST_WIDE_INT saved_processing_template_decl;
4792 tf_error,
4797 }
4799 }
4801 /* EXPR is an expression which is used in a constant-expression context.
4802 For instance, it could be a VAR_DECL with a constant initializer.
4803 Extract the innermost constant expression.
4805 This is basically a more powerful version of
4806 integral_constant_value, which can be used also in templates where
4807 initializers can maintain a syntactic rather than semantic form
4808 (even if they are non-dependent, for access-checking purposes). */
4810 static tree
4812 {
4814 do
4815 {
4818 }
4822 }
4824 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4825 must be a function or a pointer-to-function type, as specified
4826 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4827 and check that the resulting function has external linkage. */
4829 static tree
4831 {
4845 /* [temp.arg.nontype]/1
4847 A template-argument for a non-type, non-template template-parameter
4848 shall be one of:
4849 [...]
4850 -- the address of an object or function with external linkage. */
4852 {
4857 }
4860 }
4862 /* Subroutine of convert_nontype_argument.
4863 Check if EXPR of type TYPE is a valid pointer-to-member constant.
4864 Emit an error otherwise. */
4866 static bool
4868 {
4876 }
4878 /* Attempt to convert the non-type template parameter EXPR to the
4879 indicated TYPE. If the conversion is successful, return the
4880 converted value. If the conversion is unsuccessful, return
4881 NULL_TREE if we issued an error message, or error_mark_node if we
4882 did not. We issue error messages for out-and-out bad template
4883 parameters, but not simply because the conversion failed, since we
4884 might be just trying to do argument deduction. Both TYPE and EXPR
4885 must be non-dependent.
4887 The conversion follows the special rules described in
4888 [temp.arg.nontype], and it is much more strict than an implicit
4889 conversion.
4891 This function is called twice for each template argument (see
4892 lookup_template_class for a more accurate description of this
4893 problem). This means that we need to handle expressions which
4894 are not valid in a C++ source, but can be created from the
4895 first call (for instance, casts to perform conversions). These
4896 hacks can go away after we fix the double coercion problem. */
4898 static tree
4900 {
4901 tree expr_type;
4903 /* Detect immediately string literals as invalid non-type argument.
4904 This special-case is not needed for correctness (we would easily
4905 catch this later), but only to provide better diagnostic for this
4906 common user mistake. As suggested by DR 100, we do not mention
4907 linkage issues in the diagnostic as this is not the point. */
4909 {
4914 }
4916 /* If we are in a template, EXPR may be non-dependent, but still
4917 have a syntactic, rather than semantic, form. For example, EXPR
4918 might be a SCOPE_REF, rather than the VAR_DECL to which the
4919 SCOPE_REF refers. Preserving the qualifying scope is necessary
4920 so that access checking can be performed when the template is
4921 instantiated -- but here we need the resolved form so that we can
4922 convert the argument. */
4928 /* HACK: Due to double coercion, we can get a
4929 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4930 which is the tree that we built on the first call (see
4931 below when coercing to reference to object or to reference to
4932 function). We just strip everything and get to the arg.
4933 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4934 for examples. */
4936 {
4938 {
4939 /* ??? Maybe we could use convert_from_reference here, but we
4940 would need to relax its constraints because the NOP_EXPR
4941 could actually change the type to something more cv-qualified,
4942 and this is not folded by convert_from_reference. */
4953 }
4955 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4956 parameter is a pointer to object, through decay and
4957 qualification conversion. Let's strip everything. */
4959 {
4963 /* Skip the ADDR_EXPR only if it is part of the decay for
4964 an array. Otherwise, it is part of the original argument
4965 in the source code. */
4969 }
4970 }
4972 /* [temp.arg.nontype]/5, bullet 1
4974 For a non-type template-parameter of integral or enumeration type,
4975 integral promotions (_conv.prom_) and integral conversions
4976 (_conv.integral_) are applied. */
4978 {
4983 /* Notice that there are constant expressions like '4 % 0' which
4984 do not fold into integer constants. */
4986 {
4990 }
4992 /* At this point, an implicit conversion does what we want,
4993 because we already know that the expression is of integral
4994 type. */
4999 /* Conversion was allowed: fold it to a bare integer constant. */
5001 }
5002 /* [temp.arg.nontype]/5, bullet 2
5004 For a non-type template-parameter of type pointer to object,
5005 qualification conversions (_conv.qual_) and the array-to-pointer
5006 conversion (_conv.array_) are applied. */
5008 {
5009 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5011 A template-argument for a non-type, non-template template-parameter
5012 shall be one of: [...]
5014 -- the name of a non-type template-parameter;
5015 -- the address of an object or function with external linkage, [...]
5016 expressed as "& id-expression" where the & is optional if the name
5017 refers to a function or array, or if the corresponding
5018 template-parameter is a reference.
5020 Here, we do not care about functions, as they are invalid anyway
5021 for a parameter of type pointer-to-object. */
5024 /* Non-type template parameters are OK. */
5025 ;
5028 {
5030 {
5032 "because %qD is a variable, not the address of "
5036 }
5037 /* Other values, like integer constants, might be valid
5038 non-type arguments of some other type. */
5040 }
5041 else
5042 {
5043 tree decl;
5048 {
5053 }
5055 {
5060 }
5061 }
5070 }
5071 /* [temp.arg.nontype]/5, bullet 3
5073 For a non-type template-parameter of type reference to object, no
5074 conversions apply. The type referred to by the reference may be more
5075 cv-qualified than the (otherwise identical) type of the
5076 template-argument. The template-parameter is bound directly to the
5077 template-argument, which must be an lvalue. */
5079 {
5081 expr_type))
5085 {
5089 }
5092 {
5096 }
5098 /* [temp.arg.nontype]/1
5100 A template-argument for a non-type, non-template template-parameter
5101 shall be one of: [...]
5103 -- the address of an object or function with external linkage. */
5106 {
5109 {
5111 "because a reference variable does not have a constant "
5114 }
5115 }
5118 {
5123 }
5126 {
5131 }
5134 }
5135 /* [temp.arg.nontype]/5, bullet 4
5137 For a non-type template-parameter of type pointer to function, only
5138 the function-to-pointer conversion (_conv.func_) is applied. If the
5139 template-argument represents a set of overloaded functions (or a
5140 pointer to such), the matching function is selected from the set
5141 (_over.over_). */
5143 {
5144 /* If the argument is a template-id, we might not have enough
5145 context information to decay the pointer. */
5147 {
5151 }
5158 {
5162 }
5163 }
5164 /* [temp.arg.nontype]/5, bullet 5
5166 For a non-type template-parameter of type reference to function, no
5167 conversions apply. If the template-argument represents a set of
5168 overloaded functions, the matching function is selected from the set
5169 (_over.over_). */
5171 {
5173 {
5178 }
5185 }
5186 /* [temp.arg.nontype]/5, bullet 6
5188 For a non-type template-parameter of type pointer to member function,
5189 no conversions apply. If the template-argument represents a set of
5190 overloaded member functions, the matching member function is selected
5191 from the set (_over.over_). */
5193 {
5198 /* [temp.arg.nontype] bullet 1 says the pointer to member
5199 expression must be a pointer-to-member constant. */
5203 /* There is no way to disable standard conversions in
5204 resolve_address_of_overloaded_function (called by
5205 instantiate_type). It is possible that the call succeeded by
5206 converting &B::I to &D::I (where B is a base of D), so we need
5207 to reject this conversion here.
5209 Actually, even if there was a way to disable standard conversions,
5210 it would still be better to reject them here so that we can
5211 provide a superior diagnostic. */
5213 {
5217 /* If we are just one standard conversion off, explain. */
5222 }
5223 }
5224 /* [temp.arg.nontype]/5, bullet 7
5226 For a non-type template-parameter of type pointer to data member,
5227 qualification conversions (_conv.qual_) are applied. */
5229 {
5230 /* [temp.arg.nontype] bullet 1 says the pointer to member
5231 expression must be a pointer-to-member constant. */
5238 }
5239 /* A template non-type parameter must be one of the above. */
5240 else
5243 /* Sanity check: did we actually convert the argument to the
5244 right type? */
5247 }
5249 /* Subroutine of coerce_template_template_parms, which returns 1 if
5250 PARM_PARM and ARG_PARM match using the rule for the template
5251 parameters of template template parameters. Both PARM and ARG are
5252 template parameters; the rest of the arguments are the same as for
5253 coerce_template_template_parms.
5254 */
5255 static int
5257 tree arg,
5258 tsubst_flags_t complain,
5259 tree in_decl,
5260 tree outer_args)
5261 {
5270 {
5272 /* We encounter instantiations of templates like
5273 template <template <template <class> class> class TT>
5274 class C; */
5275 {
5282 }
5283 /* Fall through. */
5288 /* Argument is a parameter pack but parameter is not. */
5293 /* The tsubst call is used to handle cases such as
5295 template <int> class C {};
5296 template <class T, template <T> class TT> class D {};
5297 D<int, C> d;
5299 i.e. the parameter list of TT depends on earlier parameters. */
5301 && !same_type_p
5308 /* Argument is a parameter pack but parameter is not. */
5315 }
5318 }
5321 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5322 template template parameters. Both PARM_PARMS and ARG_PARMS are
5323 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5324 or PARM_DECL.
5326 Consider the example:
5327 template <class T> class A;
5328 template<template <class U> class TT> class B;
5330 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5331 the parameters to A, and OUTER_ARGS contains A. */
5333 static int
5335 tree arg_parms,
5336 tsubst_flags_t complain,
5337 tree in_decl,
5338 tree outer_args)
5339 {
5350 /* Determine whether we have a parameter pack at the end of the
5351 template template parameter's template parameter list. */
5353 {
5360 {
5374 }
5375 }
5381 /* Check all of the template parameters except the parameter pack at
5382 the end (if any). */
5384 {
5393 outer_args))
5396 }
5399 {
5400 /* Check each of the template parameters in the template
5401 argument against the template parameter pack at the end of
5402 the template template parameter. */
5409 {
5416 outer_args))
5418 }
5419 }
5422 }
5424 /* Verifies that the deduced template arguments (in TARGS) for the
5425 template template parameters (in TPARMS) represent valid bindings,
5426 by comparing the template parameter list of each template argument
5427 to the template parameter list of its corresponding template
5428 template parameter, in accordance with DR150. This
5429 routine can only be called after all template arguments have been
5430 deduced. It will return TRUE if all of the template template
5431 parameter bindings are okay, FALSE otherwise. */
5432 bool
5434 {
5438 /* We're dealing with template parms in this process. */
5444 {
5449 {
5454 {
5455 /* Look inside the argument pack. */
5458 }
5461 {
5465 /* Extract the next argument from the argument
5466 pack. */
5470 /* Look at the pattern of the pack expansion. */
5473 /* Extract the template parameters from the template
5474 argument. */
5480 /* Verify that we can coerce the template template
5481 parameters from the template argument to the template
5482 parameter. This requires an exact match. */
5484 && !coerce_template_template_parms
5486 targ_parms,
5487 tf_none,
5488 tparm,
5489 targs))
5490 {
5493 }
5494 }
5495 }
5496 }
5498 out:
5502 }
5504 /* Convert the indicated template ARG as necessary to match the
5505 indicated template PARM. Returns the converted ARG, or
5506 error_mark_node if the conversion was unsuccessful. Error and
5507 warning messages are issued under control of COMPLAIN. This
5508 conversion is for the Ith parameter in the parameter list. ARGS is
5509 the full set of template arguments deduced so far. */
5511 static tree
5513 tree arg,
5514 tree args,
5515 tsubst_flags_t complain,
5517 tree in_decl)
5518 {
5519 tree orig_arg;
5520 tree val;
5525 {
5526 /* The template argument was the name of some
5527 member function. That's usually
5528 invalid, but static members are OK. In any
5529 case, grab the underlying fields/functions
5530 and issue an error later if required. */
5533 }
5541 /* When determining whether an argument pack expansion is a template,
5542 look at the pattern. */
5546 /* Deal with an injected-class-name used as a template template arg. */
5548 {
5551 {
5559 }
5560 }
5562 is_tmpl_type =
5577 {
5583 typename_type,
5587 }
5589 {
5591 {
5593 {
5603 else
5605 }
5606 }
5608 }
5610 {
5612 {
5618 else
5620 }
5622 }
5625 {
5627 {
5629 /* The number of argument required is not known yet.
5630 Just accept it for now. */
5632 else
5633 {
5635 tree argparm;
5641 args))
5642 {
5645 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5646 TEMPLATE_DECL. */
5648 {
5653 }
5654 }
5655 else
5656 {
5658 {
5664 }
5667 }
5668 }
5669 }
5670 else
5672 /* We only form one instance of each template specialization.
5673 Therefore, if we use a non-canonical variant (i.e., a
5674 typedef), any future messages referring to the type will use
5675 the typedef, which is confusing if those future uses do not
5676 themselves also use the typedef. */
5679 }
5680 else
5681 {
5688 {
5691 else
5692 {
5693 /* Not sure if this is reachable, but it doesn't hurt
5694 to be robust. */
5697 }
5698 }
5700 /* We used to call digest_init here. However, digest_init
5701 will report errors, which we don't want when complain
5702 is zero. More importantly, digest_init will try too
5703 hard to convert things: for example, `0' should not be
5704 converted to pointer type at this point according to
5705 the standard. Accepting this is not merely an
5706 extension, since deciding whether or not these
5707 conversions can occur is part of determining which
5708 function template to call, or whether a given explicit
5709 argument specification is valid. */
5711 else
5720 {
5721 /* Strip typedefs from the SCOPE_REF. */
5726 }
5727 }
5730 }
5732 /* Coerces the remaining template arguments in INNER_ARGS (from
5733 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5734 Returns the coerced argument pack. PARM_IDX is the position of this
5735 parameter in the template parameter list. ARGS is the original
5736 template argument list. */
5737 static tree
5740 tree args,
5741 tree inner_args,
5743 tree new_args,
5745 tree in_decl,
5746 tsubst_flags_t complain)
5747 {
5750 tree packed_args;
5751 tree argument_pack;
5761 {
5762 /* When the template parameter is a non-type template
5763 parameter pack whose type uses parameter packs, we need
5764 to look at each of the template arguments
5765 separately. Build a vector of the types for these
5766 non-type template parameters in PACKED_TYPES. */
5767 tree expansion
5775 /* Check that we have the right number of arguments. */
5779 {
5780 int needed_parms
5785 }
5787 /* If we aren't able to check the actual arguments now
5788 (because they haven't been expanded yet), we can at least
5789 verify that all of the types used for the non-type
5790 template parameter pack are, in fact, valid for non-type
5791 template parameters. */
5794 {
5797 {
5801 }
5802 }
5803 }
5805 /* Convert the remaining arguments, which will be a part of the
5806 parameter pack "parm". */
5808 {
5813 {
5814 /* When we have a vector of types (corresponding to the
5815 non-type template parameter pack that uses parameter
5816 packs in its type, as mention above), and the
5817 argument is not an expansion (which expands to a
5818 currently unknown number of arguments), clone the
5819 parm and give it the next type in PACKED_TYPES. */
5823 }
5828 in_decl);
5832 }
5837 else
5838 {
5843 }
5846 #ifdef ENABLE_CHECKING
5849 #endif
5851 }
5853 /* Convert all template arguments to their appropriate types, and
5854 return a vector containing the innermost resulting template
5855 arguments. If any error occurs, return error_mark_node. Error and
5856 warning messages are issued under control of COMPLAIN.
5858 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5859 for arguments not specified in ARGS. Otherwise, if
5860 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5861 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5862 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5863 ARGS. */
5865 static tree
5867 tree args,
5868 tree in_decl,
5869 tsubst_flags_t complain,
5872 {
5874 tree inner_args;
5875 tree new_args;
5876 tree new_inner_args;
5880 /* When used as a boolean value, indicates whether this is a
5881 variadic template parameter list. Since it's an int, we can also
5882 subtract it from nparms to get the number of non-variadic
5883 parameters. */
5888 /* Determine if there are any parameter packs. */
5890 {
5894 }
5897 /* If there are 0 or 1 parameter packs, we need to expand any argument
5898 packs so that we can deduce a parameter pack from some non-packed args
5899 followed by an argument pack, as in variadic85.C. If there are more
5900 than that, we need to leave argument packs intact so the arguments are
5901 assigned to the right parameter packs. This should only happen when
5902 dealing with a nested class inside a partial specialization of a class
5903 template, as in variadic92.C. */
5910 && require_all_args
5911 && (!use_default_args
5914 {
5916 {
5919 {
5922 }
5929 }
5932 }
5934 /* We need to evaluate the template arguments, even though this
5935 template-id may be nested within a "sizeof". */
5943 {
5944 tree arg;
5945 tree parm;
5947 /* Get the Ith template parameter. */
5951 {
5954 }
5956 /* Calculate the next argument. */
5959 else
5964 {
5965 /* All remaining arguments will be placed in the
5966 template parameter pack PARM. */
5972 /* Store this argument. */
5974 lost++;
5977 /* We are done with all of the arguments. */
5981 }
5983 {
5985 {
5987 {
5988 /* FIXME this restriction was removed by N2555; see
5989 bug 35722. */
5990 /* If ARG is a pack expansion, but PARM is not a
5991 template parameter pack (if it were, we would have
5992 handled it above), we're trying to expand into a
5993 fixed-length argument list. */
5997 else
6000 }
6002 }
6003 }
6005 {
6006 /* There must be a default arg in this case. */
6009 /* The position of the first default template argument,
6010 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6011 Record that. */
6014 }
6015 else
6019 {
6022 }
6024 /* This only occurs if there was an error in the template
6025 parameter list itself (which we would already have
6026 reported) that we are trying to recover from, e.g., a class
6027 template with a parameter list such as
6028 template<typename..., typename>. */
6030 else
6036 lost++;
6038 }
6045 #ifdef ENABLE_CHECKING
6049 #endif
6052 }
6054 /* Returns 1 if template args OT and NT are equivalent. */
6056 static int
6058 {
6063 /* For member templates */
6070 {
6087 }
6089 {
6090 /* We get here probably because we are in the middle of substituting
6091 into the pattern of a pack expansion. In that case the
6092 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
6093 interested in. So we want to use the initial pack argument for
6094 the comparison. */
6099 }
6104 else
6106 }
6108 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
6109 of template arguments. Returns 0 otherwise. */
6111 int
6113 {
6120 {
6126 }
6128 }
6130 static void
6132 {
6142 /* We are called both from instantiate_decl, where we've already had a
6143 tinst_level pushed, and instantiate_template, where we haven't.
6144 Compensate. */
6155 else
6164 }
6167 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6168 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6169 documentation for TEMPLATE_ID_EXPR. */
6171 tree
6173 {
6174 tree type;
6184 {
6186 unknown_type_node,
6188 arglist);
6190 }
6197 }
6199 /* Within the scope of a template class S<T>, the name S gets bound
6200 (in build_self_reference) to a TYPE_DECL for the class, not a
6201 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6202 or one of its enclosing classes, and that type is a template,
6203 return the associated TEMPLATE_DECL. Otherwise, the original
6204 DECL is returned.
6206 Also handle the case when DECL is a TREE_LIST of ambiguous
6207 injected-class-names from different bases. */
6209 tree
6211 {
6215 /* DR 176: A lookup that finds an injected-class-name (10.2
6216 [class.member.lookup]) can result in an ambiguity in certain cases
6217 (for example, if it is found in more than one base class). If all of
6218 the injected-class-names that are found refer to specializations of
6219 the same class template, and if the name is followed by a
6220 template-argument-list, the reference refers to the class template
6221 itself and not a specialization thereof, and is not ambiguous. */
6223 {
6226 {
6232 }
6235 else
6237 }
6243 }
6245 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
6246 parameters, find the desired type.
6248 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
6250 IN_DECL, if non-NULL, is the template declaration we are trying to
6251 instantiate.
6253 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
6254 the class we are looking up.
6256 Issue error and warning messages under control of COMPLAIN.
6258 If the template class is really a local class in a template
6259 function, then the FUNCTION_CONTEXT is the function in which it is
6260 being instantiated.
6262 ??? Note that this function is currently called *twice* for each
6263 template-id: the first time from the parser, while creating the
6264 incomplete type (finish_template_type), and the second type during the
6265 real instantiation (instantiate_template_class). This is surely something
6266 that we want to avoid. It also causes some problems with argument
6267 coercion (see convert_nontype_argument for more information on this). */
6269 tree
6271 tree arglist,
6272 tree in_decl,
6273 tree context,
6275 tsubst_flags_t complain)
6276 {
6278 tree t;
6281 spec_entry elt;
6282 hashval_t hash;
6287 {
6291 else
6292 {
6299 }
6302 }
6304 {
6307 /* If we are declaring a constructor, say A<T>::A<T>, we will get
6308 an implicit typename for the second A. Deal with it. */
6313 {
6316 }
6317 }
6320 {
6323 }
6327 {
6331 }
6333 /* Issue an error message if we didn't find a template. */
6335 {
6339 }
6342 /* Make sure it's a user visible template, if it was named by
6343 the user. */
6346 {
6348 {
6352 }
6354 }
6359 {
6360 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
6361 template arguments */
6363 tree parm;
6364 tree arglist2;
6365 tree outer;
6369 /* Consider an example where a template template parameter declared as
6371 template <class T, class U = std::allocator<T> > class TT
6373 The template parameter level of T and U are one level larger than
6374 of TT. To proper process the default argument of U, say when an
6375 instantiation `TT<int>' is seen, we need to build the full
6376 arguments containing {int} as the innermost level. Outer levels,
6377 available when not appearing as default template argument, can be
6378 obtained from the arguments of the enclosing template.
6380 Suppose that TT is later substituted with std::vector. The above
6381 instantiation is `TT<int, std::allocator<T> >' with TT at
6382 level 1, and T at level 2, while the template arguments at level 1
6383 becomes {std::vector} and the inner level 2 is {int}. */
6389 /* This is an argument of the current template, so we haven't set
6390 DECL_CONTEXT yet. */
6397 complain,
6407 }
6408 else
6409 {
6411 tree gen_tmpl;
6412 tree type_decl;
6425 {
6426 /* We've been given an incomplete set of template arguments.
6427 For example, given:
6429 template <class T> struct S1 {
6430 template <class U> struct S2 {};
6431 template <class U> struct S2<U*> {};
6432 };
6434 we will be called with an ARGLIST of `U*', but the
6435 TEMPLATE will be `template <class T> template
6436 <class U> struct S1<T>::S2'. We must fill in the missing
6437 arguments. */
6438 arglist
6440 arglist);
6442 }
6444 /* Now we should have enough arguments. */
6447 /* From here on, we're only interested in the most general
6448 template. */
6450 /* Calculate the BOUND_ARGS. These will be the args that are
6451 actually tsubst'd into the definition to create the
6452 instantiation. */
6454 {
6455 /* We have multiple levels of arguments to coerce, at once. */
6465 {
6468 complain,
6472 /* Don't process further if one of the levels fails. */
6474 {
6475 /* Restore the ARGLIST to its full size. */
6478 }
6482 /* We temporarily reduce the length of the ARGLIST so
6483 that coerce_template_parms will see only the arguments
6484 corresponding to the template parameters it is
6485 examining. */
6487 }
6489 /* Restore the ARGLIST to its full size. */
6493 }
6494 else
6495 arglist
6498 gen_tmpl,
6499 complain,
6504 /* We were unable to bind the arguments. */
6507 /* In the scope of a template class, explicit references to the
6508 template class refer to the type of the template, not any
6509 instantiation of it. For example, in:
6511 template <class T> class C { void f(C<T>); }
6513 the `C<T>' is just the same as `C'. Outside of the
6514 class, however, such a reference is an instantiation. */
6518 /* comp_template_args is expensive, check it last. */
6520 arglist))
6523 /* If we already have this specialization, return it. */
6535 /* If the deduced arguments are invalid, then the binding
6536 failed. */
6540 complain))
6547 {
6552 }
6559 /* Create the type. */
6561 {
6563 {
6569 }
6570 else
6571 {
6572 /* We don't want to call start_enum for this type, since
6573 the values for the enumeration constants may involve
6574 template parameters. And, no one should be interested
6575 in the enumeration constants for such a type. */
6578 }
6579 }
6580 else
6581 {
6588 /* A local class. Make sure the decl gets registered properly. */
6593 /* This instantiation is another name for the primary
6594 template type. Set the TYPE_CANONICAL field
6595 appropriately. */
6598 /* Some of the template arguments require structural
6599 equality testing, so this template class requires
6600 structural equality testing. */
6602 }
6604 /* If we called start_enum or pushtag above, this information
6605 will already be set up. */
6607 {
6614 }
6615 else
6623 {
6626 }
6628 /* Let's consider the explicit specialization of a member
6629 of a class template specialization that is implicitely instantiated,
6630 e.g.:
6631 template<class T>
6632 struct S
6633 {
6634 template<class U> struct M {}; //#0
6635 };
6637 template<>
6638 template<>
6639 struct S<int>::M<char> //#1
6640 {
6641 int i;
6642 };
6643 [temp.expl.spec]/4 says this is valid.
6645 In this case, when we write:
6646 S<int>::M<char> m;
6648 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
6649 the one of #0.
6651 When we encounter #1, we want to store the partial instantiation
6652 of M (template<class T> S<int>::M<T>) in it's CLASSTYPE_TI_TEMPLATE.
6654 For all cases other than this "explicit specialization of member of a
6655 class template", we just want to store the most general template into
6656 the CLASSTYPE_TI_TEMPLATE of M.
6658 This case of "explicit specialization of member of a class template"
6659 only happens when:
6660 1/ the enclosing class is an instantiation of, and therefore not
6661 the same as, the context of the most general template, and
6662 2/ we aren't looking at the partial instantiation itself, i.e.
6663 the innermost arguments are not the same as the innermost parms of
6664 the most general template.
6666 So it's only when 1/ and 2/ happens that we want to use the partial
6667 instantiation of the member template in lieu of its most general
6668 template. */
6672 /* the enclosing class must be an instantiation... */
6675 {
6676 tree partial_inst_args;
6679 partial_inst_args =
6685 use_partial_inst_tmpl =
6686 /*...and we must not be looking at the partial instantiation
6687 itself. */
6689 partial_inst_args);
6690 }
6693 /* This case is easy; there are no member templates involved. */
6695 else
6696 {
6697 /* This is a full instantiation of a member template. Find
6698 the partial instantiation of which this is an instance. */
6700 /* Temporarily reduce by one the number of levels in the ARGLIST
6701 so as to avoid comparing the last set of arguments. */
6706 }
6716 /* Note this use of the partial instantiation so we can check it
6717 later in maybe_process_partial_specialization. */
6723 /* Now that the type has been registered on the instantiations
6724 list, we set up the enumerators. Because the enumeration
6725 constants may involve the enumeration type itself, we make
6726 sure to register the type first, and then create the
6727 constants. That way, doing tsubst_expr for the enumeration
6728 constants won't result in recursive calls here; we'll find
6729 the instantiation and exit above. */
6733 /* If the type makes use of template parameters, the
6734 code that generates debugging information will crash. */
6737 /* Possibly limit visibility based on template args. */
6742 }
6744 }
6745 \f
6746 struct pair_fn_data
6747 {
6748 tree_fn_t fn;
6750 /* True when we should also visit template parameters that occur in
6751 non-deduced contexts. */
6754 };
6756 /* Called from for_each_template_parm via walk_tree. */
6758 static tree
6760 {
6773 {
6777 /* Fall through. */
6800 /* Since we're not going to walk subtrees, we have to do this
6801 explicitly here. */
6805 /* Fall through. */
6808 /* Check the return type. */
6813 /* Check the parameter types. Since default arguments are not
6814 instantiated until they are needed, the TYPE_ARG_TYPES may
6815 contain expressions that involve template parameters. But,
6816 no-one should be looking at them yet. And, once they're
6817 instantiated, they don't contain template parameters, so
6818 there's no point in looking at them then, either. */
6819 {
6820 tree parm;
6827 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6828 want walk_tree walking into them itself. */
6830 }
6847 /* Fall through. */
6863 /* Record template parameters such as `T' inside `TT<T>'. */
6867 /* Fall through. */
6879 /* A template template parameter is encountered. */
6885 /* Already substituted template template parameter */
6908 /* If there's no type, then this thing must be some expression
6909 involving template parameters. */
6930 }
6932 /* We didn't find any template parameters we liked. */
6934 }
6936 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6937 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6938 call FN with the parameter and the DATA.
6939 If FN returns nonzero, the iteration is terminated, and
6940 for_each_template_parm returns 1. Otherwise, the iteration
6941 continues. If FN never returns a nonzero value, the value
6942 returned by for_each_template_parm is 0. If FN is NULL, it is
6943 considered to be the function which always returns 1.
6945 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6946 parameters that occur in non-deduced contexts. When false, only
6947 visits those template parameters that can be deduced. */
6949 static int
6953 {
6957 /* Set up. */
6962 /* Walk the tree. (Conceptually, we would like to walk without
6963 duplicates, but for_each_template_parm_r recursively calls
6964 for_each_template_parm, so we would need to reorganize a fair
6965 bit to use walk_tree_without_duplicates, so we keep our own
6966 visited list.) */
6969 else
6972 for_each_template_parm_r,
6976 /* Clean up. */
6978 {
6981 }
6984 }
6986 /* Returns true if T depends on any template parameter. */
6988 int
6990 {
7017 else
7018 {
7021 }
7026 }
7028 /* Returns true if T depends on any template parameter with level LEVEL. */
7030 int
7032 {
7035 }
7039 #ifdef GATHER_STATISTICS
7041 #endif
7045 /* We're starting to instantiate D; record the template instantiation context
7046 for diagnostics and to restore it later. */
7048 int
7050 {
7054 {
7055 /* If the instantiation in question still has unbound template parms,
7056 we don't really care if we can't instantiate it, so just return.
7057 This happens with base instantiation for implicit `typename'. */
7069 }
7079 #ifdef GATHER_STATISTICS
7082 #endif
7086 }
7088 /* We're done instantiating this template; return to the instantiation
7089 context. */
7091 void
7093 {
7094 /* Restore the filename and line number stashed away when we started
7095 this instantiation. */
7100 }
7102 /* We're instantiating a deferred template; restore the template
7103 instantiation context in which the instantiation was requested, which
7104 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
7106 static tree
7108 {
7118 }
7120 /* Returns the TINST_LEVEL which gives the original instantiation
7121 context. */
7125 {
7131 }
7133 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
7135 bool
7137 {
7138 tree parms;
7155 }
7157 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
7158 vector of template arguments, as for tsubst.
7160 Returns an appropriate tsubst'd friend declaration. */
7162 static tree
7164 {
7165 tree new_friend;
7170 /* This was a friend declared with an explicit template
7171 argument list, e.g.:
7173 friend void f<>(T);
7175 to indicate that f was a template instantiation, not a new
7176 function declaration. Now, we have to figure out what
7177 instantiation of what template. */
7178 {
7180 tree new_args;
7181 tree tmpl;
7184 /* Friend functions are looked up in the containing namespace scope.
7185 We must enter that scope, to avoid finding member functions of the
7186 current class with same name. */
7201 tsk_none);
7203 }
7207 /* The NEW_FRIEND will look like an instantiation, to the
7208 compiler, but is not an instantiation from the point of view of
7209 the language. For example, we might have had:
7211 template <class T> struct S {
7212 template <class U> friend void f(T, U);
7213 };
7215 Then, in S<int>, template <class U> void f(int, U) is not an
7216 instantiation of anything. */
7222 {
7226 }
7228 /* The mangled name for the NEW_FRIEND is incorrect. The function
7229 is not a template instantiation and should not be mangled like
7230 one. Therefore, we forget the mangling here; we'll recompute it
7231 later if we need it. */
7233 {
7236 }
7239 {
7240 tree old_decl;
7241 tree new_friend_template_info;
7242 tree new_friend_result_template_info;
7243 tree ns;
7246 /* We must save some information from NEW_FRIEND before calling
7247 duplicate decls since that function will free NEW_FRIEND if
7248 possible. */
7250 new_friend_is_defn =
7255 {
7256 /* This declaration is a `primary' template. */
7259 new_friend_result_template_info
7261 }
7262 else
7265 /* Make the init_value nonzero so pushdecl knows this is a defn. */
7269 /* Inside pushdecl_namespace_level, we will push into the
7270 current namespace. However, the friend function should go
7271 into the namespace of the template. */
7281 {
7282 /* This new friend declaration matched an existing
7283 declaration. For example, given:
7285 template <class T> void f(T);
7286 template <class U> class C {
7287 template <class T> friend void f(T) {}
7288 };
7290 the friend declaration actually provides the definition
7291 of `f', once C has been instantiated for some type. So,
7292 old_decl will be the out-of-class template declaration,
7293 while new_friend is the in-class definition.
7295 But, if `f' was called before this point, the
7296 instantiation of `f' will have DECL_TI_ARGS corresponding
7297 to `T' but not to `U', references to which might appear
7298 in the definition of `f'. Previously, the most general
7299 template for an instantiation of `f' was the out-of-class
7300 version; now it is the in-class version. Therefore, we
7301 run through all specialization of `f', adding to their
7302 DECL_TI_ARGS appropriately. In particular, they need a
7303 new set of outer arguments, corresponding to the
7304 arguments for this class instantiation.
7306 The same situation can arise with something like this:
7308 friend void f(int);
7309 template <class T> class C {
7310 friend void f(T) {}
7311 };
7313 when `C<int>' is instantiated. Now, `f(int)' is defined
7314 in the class. */
7317 /* On the other hand, if the in-class declaration does
7318 *not* provide a definition, then we don't want to alter
7319 existing definitions. We can just leave everything
7320 alone. */
7321 ;
7322 else
7323 {
7327 /* Overwrite whatever template info was there before, if
7328 any, with the new template information pertaining to
7329 the declaration. */
7333 /* We should have called reregister_specialization in
7334 duplicate_decls. */
7338 else
7339 {
7340 tree t;
7342 /* Indicate that the old function template is a partial
7343 instantiation. */
7351 /* Reassign any specializations already in the hash table
7352 to the new more general template, and add the
7353 additional template args. */
7357 {
7359 spec_entry elt;
7371 register_specialization
7374 }
7376 }
7377 }
7379 /* The information from NEW_FRIEND has been merged into OLD_DECL
7380 by duplicate_decls. */
7382 }
7383 }
7384 else
7385 {
7389 /* In the code
7390 template <class T> class C {
7391 template <class U> friend void C1<U>::f (); // case 1
7392 friend void C2<T>::f (); // case 2
7393 };
7394 we only need to make sure CONTEXT is a complete type for
7395 case 2. To distinguish between the two cases, we note that
7396 CONTEXT of case 1 remains dependent type after tsubst while
7397 this isn't true for case 2. */
7407 {
7408 /* Check to see that the declaration is really present, and,
7409 possibly obtain an improved declaration. */
7415 }
7416 }
7419 }
7421 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
7422 template arguments, as for tsubst.
7424 Returns an appropriate tsubst'd friend type or error_mark_node on
7425 failure. */
7427 static tree
7429 {
7430 tree friend_type;
7431 tree tmpl;
7432 tree context;
7437 {
7440 else
7442 }
7444 /* Look for a class template declaration. We look for hidden names
7445 because two friend declarations of the same template are the
7446 same. For example, in:
7448 struct A {
7449 template <typename> friend class F;
7450 };
7451 template <typename> struct B {
7452 template <typename> friend class F;
7453 };
7455 both F templates are the same. */
7460 /* But, if we don't find one, it might be because we're in a
7461 situation like this:
7463 template <class T>
7464 struct S {
7465 template <class U>
7466 friend struct S;
7467 };
7469 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
7470 for `S<int>', not the TEMPLATE_DECL. */
7472 {
7475 }
7478 {
7479 /* The friend template has already been declared. Just
7480 check to see that the declarations match, and install any new
7481 default parameters. We must tsubst the default parameters,
7482 of course. We only need the innermost template parameters
7483 because that is all that redeclare_class_template will look
7484 at. */
7487 {
7488 tree parms;
7489 location_t saved_input_location;
7498 }
7501 }
7502 else
7503 {
7504 /* The friend template has not already been declared. In this
7505 case, the instantiation of the template class will cause the
7506 injection of this template into the global scope. */
7511 /* The new TMPL is not an instantiation of anything, so we
7512 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7513 the new type because that is supposed to be the corresponding
7514 template decl, i.e., TMPL. */
7521 /* Inject this template into the global scope. */
7523 }
7526 {
7529 else
7531 }
7534 }
7536 /* Returns zero if TYPE cannot be completed later due to circularity.
7537 Otherwise returns one. */
7539 static int
7541 {
7551 else
7553 }
7555 /* Apply any attributes which had to be deferred until instantiation
7556 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7557 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7559 static void
7562 {
7564 tree t;
7569 {
7573 }
7576 {
7580 }
7581 else
7585 {
7590 {
7593 {
7596 /* If the first attribute argument is an identifier, don't
7597 pass it through tsubst. Attributes like mode, format,
7598 cleanup and several target specific attributes expect it
7599 unmodified. */
7605 {
7606 tree chain
7608 in_decl,
7613 chain);
7614 }
7615 else
7621 }
7622 else
7624 }
7627 }
7628 }
7630 /* Perform (or defer) access check for typedefs that were referenced
7631 from within the template TMPL code.
7632 This is a subroutine of instantiate_template and instantiate_class_template.
7633 TMPL is the template to consider and TARGS is the list of arguments of
7634 that template. */
7636 static void
7638 {
7639 location_t saved_location;
7654 {
7666 /* Make access check error messages point to the location
7667 of the use of the typedef. */
7671 }
7673 }
7675 tree
7677 {
7679 tree typedecl;
7680 tree pbinfo;
7681 tree base_list;
7692 /* Figure out which template is being instantiated. */
7696 /* Determine what specialization of the original template to
7697 instantiate. */
7700 {
7703 }
7705 {
7706 /* This TYPE is actually an instantiation of a partial
7707 specialization. We replace the innermost set of ARGS with
7708 the arguments appropriate for substitution. For example,
7709 given:
7711 template <class T> struct S {};
7712 template <class T> struct S<T*> {};
7714 and supposing that we are instantiating S<int*>, ARGS will
7715 presently be {int*} -- but we need {int}. */
7718 }
7719 else
7720 {
7723 }
7725 /* If the template we're instantiating is incomplete, then clearly
7726 there's nothing we can do. */
7730 /* If we've recursively instantiated too many templates, stop. */
7734 /* Now we're really doing the instantiation. Mark the type as in
7735 the process of being defined. */
7738 /* We may be in the middle of deferred access check. Disable
7739 it now. */
7743 /* Use #pragma pack from the template context. */
7749 /* Set the input location to the most specialized template definition.
7750 This is needed if tsubsting causes an error. */
7771 {
7774 }
7778 /* We should never instantiate a nested class before its enclosing
7779 class; we need to look up the nested class by name before we can
7780 instantiate it, and that lookup should instantiate the enclosing
7781 class. */
7788 {
7789 tree pbase_binfo;
7791 tree pushed_scope;
7794 /* We must enter the scope containing the type, as that is where
7795 the accessibility of types named in dependent bases are
7796 looked up from. */
7799 /* Substitute into each of the bases to determine the actual
7800 basetypes. */
7802 {
7803 tree base;
7809 {
7810 expanded_bases =
7817 }
7820 {
7822 /* Extract the already-expanded base class. */
7824 else
7825 /* Substitute to figure out the base class. */
7827 NULL_TREE);
7835 }
7836 }
7838 /* The list is now in reverse order; correct that. */
7843 }
7844 /* Now call xref_basetypes to set up all the base-class
7845 information. */
7852 /* Now that our base classes are set up, enter the scope of the
7853 class, so that name lookups into base classes, etc. will work
7854 correctly. This is precisely analogous to what we do in
7855 begin_class_definition when defining an ordinary non-template
7856 class, except we also need to push the enclosing classes. */
7859 /* Now members are processed in the order of declaration. */
7862 {
7866 {
7868 {
7869 /* Build new CLASSTYPE_NESTED_UTDS. */
7871 tree newtag;
7877 /* If the member is a class template, then -- even after
7878 substitution -- there may be dependent types in the
7879 template argument list for the class. We increment
7880 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7881 that function will assume that no types are dependent
7882 when outside of a template. */
7892 {
7896 /* Unfortunately, lookup_template_class sets
7897 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7898 instantiation (i.e., for the type of a member
7899 template class nested within a template class.)
7900 This behavior is required for
7901 maybe_process_partial_specialization to work
7902 correctly, but is not accurate in this case;
7903 the TAG is not an instantiation of anything.
7904 (The corresponding TEMPLATE_DECL is an
7905 instantiation, but the TYPE is not.) */
7908 /* Now, we call pushtag to put this NEWTAG into the scope of
7909 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7910 pushtag calling push_template_decl. We don't have to do
7911 this for enums because it will already have been done in
7912 tsubst_enum. */
7916 }
7917 }
7920 {
7921 /* Build new TYPE_METHODS. */
7922 tree r;
7931 }
7932 else
7933 {
7934 /* Build new TYPE_FIELDS. */
7936 {
7937 tree condition =
7945 }
7947 {
7948 tree r;
7950 /* The file and line for this declaration, to
7951 assist in error message reporting. Since we
7952 called push_tinst_level above, we don't need to
7953 restore these. */
7962 {
7963 /* In [temp.inst]:
7965 [t]he initialization (and any associated
7966 side-effects) of a static data member does
7967 not occur unless the static data member is
7968 itself used in a way that requires the
7969 definition of the static data member to
7970 exist.
7972 Therefore, we do not substitute into the
7973 initialized for the static data member here. */
7974 finish_static_data_member_decl
7982 }
7984 {
7985 /* Determine whether R has a valid type and can be
7986 completed later. If R is invalid, then it is
7987 replaced by error_mark_node so that it will not be
7988 added to TYPE_FIELDS. */
7994 {
7997 }
7998 }
8000 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
8001 such a thing will already have been added to the field
8002 list by tsubst_enum in finish_member_declaration in the
8003 CLASSTYPE_NESTED_UTDS case above. */
8007 {
8010 }
8011 }
8012 }
8013 }
8014 else
8015 {
8017 {
8018 /* Build new CLASSTYPE_FRIEND_CLASSES. */
8024 {
8025 /* template <class T> friend class C; */
8028 }
8030 {
8031 /* template <class T> friend class C::D; */
8037 }
8039 {
8040 /* This could be either
8042 friend class T::C;
8044 when dependent_type_p is false or
8046 template <class U> friend class T::C;
8048 otherwise. */
8051 /* Bump processing_template_decl for correct
8052 dependent_type_p calculation. */
8057 }
8060 {
8061 /* friend class C;
8063 where C hasn't been declared yet. Let's lookup name
8064 from namespace scope directly, bypassing any name that
8065 come from dependent base class. */
8068 /* The call to xref_tag_from_type does injection for friend
8069 classes. */
8071 friend_type =
8075 }
8077 /* friend class C<T>; */
8080 /* Otherwise it's
8082 friend class C;
8084 where C is already declared or
8086 friend class C<int>;
8088 We don't have to do anything in these cases. */
8091 /* Trick make_friend_class into realizing that the friend
8092 we're adding is a template, not an ordinary class. It's
8093 important that we use make_friend_class since it will
8094 perform some error-checking and output cross-reference
8095 information. */
8103 }
8104 else
8105 {
8106 /* Build new DECL_FRIENDLIST. */
8107 tree r;
8109 /* The file and line for this declaration, to
8110 assist in error message reporting. Since we
8111 called push_tinst_level above, we don't need to
8112 restore these. */
8116 {
8119 }
8124 {
8127 }
8128 }
8129 }
8130 }
8132 /* Set the file and line number information to whatever is given for
8133 the class itself. This puts error messages involving generated
8134 implicit functions at a predictable point, and the same point
8135 that would be used for non-template classes. */
8142 /* Now that the class is complete, instantiate default arguments for
8143 any member functions. We don't do this earlier because the
8144 default arguments may reference members of the class. */
8148 /* Implicitly generated member functions will not have template
8149 information; they are not instantiations, but instead are
8150 created "fresh" for each instantiation. */
8154 /* Some typedefs referenced from within the template code need to be access
8155 checked at template instantiation time, i.e now. These types were
8156 added to the template at parsing time. Let's get those and perform
8157 the access checks then. */
8166 /* The vtable for a template class can be emitted in any translation
8167 unit in which the class is instantiated. When there is no key
8168 method, however, finish_struct_1 will already have added TYPE to
8169 the keyed_classes list. */
8174 }
8176 static tree
8178 {
8179 tree r;
8185 else
8186 {
8190 }
8192 }
8194 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
8195 NONTYPE_ARGUMENT_PACK. */
8197 static tree
8199 {
8200 /* Collect all of the extra "packed" parameters into an
8201 argument pack. */
8202 tree parmvec;
8203 tree parmtypevec;
8208 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
8212 {
8215 }
8217 /* Build the argument packs. */
8223 }
8225 /* Substitute ARGS into T, which is an pack expansion
8226 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
8227 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
8228 (if only a partial substitution could be performed) or
8229 ERROR_MARK_NODE if there was an error. */
8230 tree
8232 tree in_decl)
8233 {
8234 tree pattern;
8237 tree result;
8244 /* Determine the argument packs that will instantiate the parameter
8245 packs used in the expansion expression. While we're at it,
8246 compute the number of arguments to be expanded and make sure it
8247 is consistent. */
8250 {
8256 {
8259 {
8260 /* This can happen for a parameter name used later in a function
8261 declaration (such as in a late-specified return type). Just
8262 make a dummy decl, since it's only used for its type. */
8266 }
8267 }
8268 else
8269 {
8276 }
8283 /* This can only happen if we forget to expand an argument
8284 pack somewhere else. Just return an error, silently. */
8285 {
8289 }
8294 {
8299 /* The argument pack that the parameter maps to is just an
8300 expansion of the parameter itself, such as one would
8301 find in the implicit typedef of a class inside the
8302 class itself. Consider this parameter "unsubstituted",
8303 so that we will maintain the outer pack expansion. */
8305 }
8308 {
8312 /* It's all-or-nothing with incomplete argument packs. */
8322 {
8324 /* We got explicit args for some packs but not others;
8325 do nothing now and try again after deduction. */
8330 pattern);
8331 else
8334 pattern);
8336 }
8338 /* Keep track of the parameter packs and their corresponding
8339 argument packs. */
8342 }
8343 else
8344 /* We can't substitute for this parameter pack. */
8347 unsubstituted_packs);
8348 }
8350 /* We cannot expand this expansion expression, because we don't have
8351 all of the argument packs we need. Substitute into the pattern
8352 and return a PACK_EXPANSION_*. The caller will need to deal with
8353 that. */
8355 {
8356 tree new_pat;
8360 else
8363 }
8365 /* We could not find any argument packs that work. */
8370 {
8371 /* We're in a late-specified return type, so we don't have a local
8372 specializations table. Create one for doing this expansion. */
8375 hash_local_specialization,
8376 eq_local_specializations,
8377 NULL);
8378 }
8380 /* For each argument in each argument pack, substitute into the
8381 pattern. */
8384 {
8385 /* For parameter pack, change the substitution of the parameter
8386 pack to the ith argument in its argument pack, then expand
8387 the pattern. */
8389 {
8393 {
8394 /* Select the Ith argument from the pack. */
8400 }
8401 else
8402 {
8408 {
8409 /* Select the Ith argument from the pack. */
8413 }
8415 /* Update the corresponding argument. */
8417 }
8418 }
8420 /* Substitute into the PATTERN with the altered arguments. */
8425 else
8429 /* When we have incomplete argument packs, the last "expanded"
8430 result is itself a pack expansion, which allows us
8431 to deduce more arguments. */
8436 {
8439 }
8440 }
8442 /* Update ARGS to restore the substitution from parameter packs to
8443 their argument packs. */
8445 {
8450 else
8451 {
8455 /* Update the corresponding argument. */
8459 else
8461 }
8462 }
8465 {
8468 }
8471 }
8473 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
8474 TMPL. We do this using DECL_PARM_INDEX, which should work even with
8475 parameter packs; all parms generated from a function parameter pack will
8476 have the same DECL_PARM_INDEX. */
8478 tree
8480 {
8482 tree patparm;
8485 {
8491 }
8492 else
8493 {
8498 }
8501 }
8503 /* Substitute ARGS into the vector or list of template arguments T. */
8505 static tree
8507 {
8514 {
8516 tree new_arg;
8521 {
8522 /* Substitute into an expansion expression. */
8526 /* Add to the expanded length adjustment the number of
8527 expanded arguments. We subtract one from this
8528 measurement, because the argument pack expression
8529 itself is already counted as 1 in
8530 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
8531 the argument pack is empty. */
8533 }
8535 {
8536 /* Substitute into each of the arguments. */
8542 new_arg,
8556 }
8557 }
8558 else
8567 }
8572 /* Make space for the expanded arguments coming from template
8573 argument packs. */
8575 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
8576 arguments for a member template.
8577 In that case each TREE_VEC in ORIG_T represents a level of template
8578 arguments, and ORIG_T won't carry any non defaulted argument count.
8579 It will rather be the nested TREE_VECs that will carry one.
8580 In other words, ORIG_T carries a non defaulted argument count only
8581 if it doesn't contain any nested TREE_VEC. */
8583 {
8587 }
8589 {
8593 {
8596 /* Now expand the template argument pack "in place". */
8599 }
8600 else
8601 {
8603 out++;
8604 }
8605 }
8608 }
8610 /* Return the result of substituting ARGS into the template parameters
8611 given by PARMS. If there are m levels of ARGS and m + n levels of
8612 PARMS, then the result will contain n levels of PARMS. For
8613 example, if PARMS is `template <class T> template <class U>
8614 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8615 result will be `template <int*, double, class V>'. */
8617 static tree
8619 {
8623 /* When substituting into a template, we must set
8624 PROCESSING_TEMPLATE_DECL as the template parameters may be
8625 dependent if they are based on one-another, and the dependency
8626 predicates are short-circuit outside of templates. */
8633 {
8634 tree new_vec =
8639 {
8640 tree tuple;
8641 tree default_value;
8642 tree parm_decl;
8664 }
8670 }
8675 }
8677 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8678 type T. If T is not an aggregate or enumeration type, it is
8679 handled as if by tsubst. IN_DECL is as for tsubst. If
8680 ENTERING_SCOPE is nonzero, T is the context for a template which
8681 we are presently tsubst'ing. Return the substituted value. */
8683 static tree
8685 tree args,
8686 tsubst_flags_t complain,
8687 tree in_decl,
8689 {
8694 {
8699 /* Else fall through. */
8703 {
8704 tree argvec;
8705 tree context;
8706 tree r;
8710 /* In "sizeof(X<I>)" we need to evaluate "I". */
8716 /* First, determine the context for the type we are looking
8717 up. */
8720 {
8723 /* If context is a nested class inside a class template,
8724 it may still need to be instantiated (c++/33959). */
8727 }
8729 /* Then, figure out what arguments are appropriate for the
8730 type we are trying to find. For example, given:
8732 template <class T> struct S;
8733 template <class T, class U> void f(T, U) { S<U> su; }
8735 and supposing that we are instantiating f<int, double>,
8736 then our ARGS will be {int, double}, but, when looking up
8737 S we only want {double}. */
8742 else
8743 {
8747 }
8753 }
8754 else
8755 /* This is not a template type, so there's nothing to do. */
8760 }
8761 }
8763 /* Substitute into the default argument ARG (a default argument for
8764 FN), which has the indicated TYPE. */
8766 tree
8768 {
8772 /* This default argument came from a template. Instantiate the
8773 default argument here, not in tsubst. In the case of
8774 something like:
8776 template <class T>
8777 struct S {
8778 static T t();
8779 void f(T = t());
8780 };
8782 we must be careful to do name lookup in the scope of S<T>,
8783 rather than in the current class. */
8785 /* The "this" pointer is not valid in a default argument. */
8787 {
8792 }
8795 /* The default argument expression may cause implicitly defined
8796 member functions to be synthesized, which will result in garbage
8797 collection. We must treat this situation as if we were within
8798 the body of function so as to avoid collecting live data on the
8799 stack. */
8807 /* Restore the "this" pointer. */
8809 {
8812 }
8814 /* Make sure the default argument is reasonable. */
8820 }
8822 /* Substitute into all the default arguments for FN. */
8824 static void
8826 {
8827 tree arg;
8828 tree tmpl_args;
8832 /* If this function is not yet instantiated, we certainly don't need
8833 its default arguments. */
8838 arg;
8844 }
8846 /* Substitute the ARGS into the T, which is a _DECL. Return the
8847 result of the substitution. Issue error and warning messages under
8848 control of COMPLAIN. */
8850 static tree
8852 {
8853 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
8854 location_t saved_loc;
8859 /* Set the filename and linenumber to improve error-reporting. */
8864 {
8866 {
8867 /* We can get here when processing a member function template,
8868 member class template, or template template parameter. */
8870 tree spec;
8871 tree tmpl_args;
8872 tree full_args;
8875 {
8876 /* Template template parameter is treated here. */
8889 complain);
8892 }
8894 /* We might already have an instance of this template.
8895 The ARGS are for the surrounding class type, so the
8896 full args contain the tsubst'd args for the context,
8897 plus the innermost args from the template decl. */
8901 /* Because this is a template, the arguments will still be
8902 dependent, even after substitution. If
8903 PROCESSING_TEMPLATE_DECL is not set, the dependency
8904 predicates will short-circuit. */
8912 /* If this is a default template template argument,
8913 tsubst might not have changed anything. */
8920 {
8923 }
8925 /* Make a new template decl. It will be similar to the
8926 original, but will record the current template arguments.
8927 We also create a new function declaration, which is just
8928 like the old one, but points to this new template, rather
8929 than the old one. */
8937 {
8938 tree new_type;
8950 }
8951 else
8952 {
8953 tree new_decl;
8965 }
8971 /* The template parameters for this new template are all the
8972 template parameters for the old template, except the
8973 outermost level of parameters. */
8976 complain);
8982 /* Record this non-type partial instantiation. */
8986 }
8990 {
8991 tree ctx;
8994 tree gen_tmpl;
8995 tree type;
9000 /* Nobody should be tsubst'ing into non-template functions. */
9004 {
9005 tree spec;
9008 /* If T is not dependent, just return it. We have to
9009 increment PROCESSING_TEMPLATE_DECL because
9010 value_dependent_expression_p assumes that nothing is
9011 dependent when PROCESSING_TEMPLATE_DECL is zero. */
9018 /* Calculate the most general template of which R is a
9019 specialization, and the complete set of arguments used to
9020 specialize R. */
9023 (DECL_TEMPLATE_RESULT
9027 /* Check to see if we already have this specialization. */
9032 {
9035 }
9037 /* We can see more levels of arguments than parameters if
9038 there was a specialization of a member template, like
9039 this:
9041 template <class T> struct S { template <class U> void f(); }
9042 template <> template <class U> void S<int>::f(U);
9044 Here, we'll be substituting into the specialization,
9045 because that's where we can find the code we actually
9046 want to generate, but we'll have enough arguments for
9047 the most general template.
9049 We also deal with the peculiar case:
9051 template <class T> struct S {
9052 template <class U> friend void f();
9053 };
9054 template <class U> void f() {}
9055 template S<int>;
9056 template void f<double>();
9058 Here, the ARGS for the instantiation of will be {int,
9059 double}. But, we only need as many ARGS as there are
9060 levels of template parameters in CODE_PATTERN. We are
9061 careful not to get fooled into reducing the ARGS in
9062 situations like:
9064 template <class T> struct S { template <class U> void f(U); }
9065 template <class T> template <> void S<T>::f(int) {}
9067 which we can spot because the pattern will be a
9068 specialization in this case. */
9070 parms_depth =
9075 }
9076 else
9077 {
9078 /* This special case arises when we have something like this:
9080 template <class T> struct S {
9081 friend void f<int>(int, double);
9082 };
9084 Here, the DECL_TI_TEMPLATE for the friend declaration
9085 will be an IDENTIFIER_NODE. We are being called from
9086 tsubst_friend_function, and we want only to create a
9087 new decl (R) with appropriate types so that we can call
9088 determine_specialization. */
9090 }
9093 {
9096 else
9100 }
9101 else
9102 {
9105 }
9110 /* We do NOT check for matching decls pushed separately at this
9111 point, as they may not represent instantiations of this
9112 template, and in any case are considered separate under the
9113 discrete model. */
9117 /* Clear out the mangled name and RTL for the instantiation. */
9120 /* Leave DECL_INITIAL set on deleted instantiations. */
9126 /* Type-conversion operator. Reconstruct the name, in
9127 case it's the name of one of the template's parameters. */
9137 /* If this is an instantiation of a function with internal
9138 linkage, we already know what object file linkage will be
9139 assigned to the instantiation. */
9148 /* We'll re-clone as appropriate in instantiate_template. */
9151 /* If we aren't complaining now, return on error before we register
9152 the specialization so that we'll complain eventually. */
9158 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
9159 this in the special friend case mentioned above where
9160 GEN_TMPL is NULL. */
9162 {
9168 /* We're not supposed to instantiate default arguments
9169 until they are called, for a template. But, for a
9170 declaration like:
9172 template <class T> void f ()
9173 { extern void g(int i = T()); }
9175 we should do the substitution when the template is
9176 instantiated. We handle the member function case in
9177 instantiate_class_template since the default arguments
9178 might refer to other members of the class. */
9183 }
9184 else
9187 /* Copy the list of befriending classes. */
9191 {
9195 in_decl);
9196 }
9199 {
9203 /* If this is an instantiation of a member template, clone it.
9204 If it isn't, that'll be handled by
9205 clone_constructors_and_destructors. */
9208 }
9219 /* Possibly limit visibility based on template args. */
9222 {
9226 }
9234 }
9238 {
9246 {
9247 /* If there is a local specialization that isn't a
9248 parameter pack, it means that we're doing a "simple"
9249 substitution from inside tsubst_pack_expansion. Just
9250 return the local specialization (which will be a single
9251 parm). */
9258 /* Expand the TYPE_PACK_EXPANSION that provides the types for
9259 the parameters in this function parameter pack. */
9263 {
9266 /* Zero-length parameter packs are boring. Just substitute
9267 into the chain. */
9271 }
9272 else
9273 {
9274 /* All we did was update the type. Make a note of that. */
9277 }
9278 }
9280 /* Loop through all of the parameter's we'll build. When T is
9281 a function parameter pack, LEN is the number of expanded
9282 types in EXPANDED_TYPES; otherwise, LEN is 1. */
9285 {
9291 /* An argument of a function parameter pack is not a parameter
9292 pack. */
9296 /* We're on the Ith parameter of the function parameter
9297 pack. */
9298 {
9299 /* Get the Ith type. */
9303 /* Rename the parameter to include the index. */
9306 }
9308 /* We're dealing with a normal parameter. */
9316 {
9319 else
9322 }
9332 /* Keep track of the first new parameter we
9333 generate. That's what will be returned to the
9334 caller. */
9338 /* Build a proper chain of parameters when substituting
9339 into a function parameter pack. */
9342 }
9348 /* FIRST_R contains the start of the chain we've built. */
9350 }
9354 {
9355 tree type;
9364 /* DECL_INITIAL gives the number of bits in a bit-field. */
9369 /* We don't have to set DECL_CONTEXT here; it is set by
9370 finish_member_declaration. */
9377 }
9381 /* We reach here only for member using decls. */
9383 {
9384 r = do_class_using_decl
9389 else
9390 {
9393 }
9394 }
9395 else
9396 {
9399 }
9404 {
9407 tree spec;
9409 tree ctx;
9415 {
9416 /* If this is the canonical decl, we don't have to
9417 mess with instantiations, and often we can't (for
9418 typename, template type parms and such). Note that
9419 TYPE_NAME is not correct for the above test if
9420 we've copied the type for a typedef. */
9426 }
9428 /* Check to see if we already have the specialization we
9429 need. */
9432 {
9433 /* T is a static data member or namespace-scope entity.
9434 We have to substitute into namespace-scope variables
9435 (even though such entities are never templates) because
9436 of cases like:
9438 template <class T> void f() { extern T t; }
9440 where the entity referenced is not known until
9441 instantiation time. */
9445 {
9447 complain,
9449 /* If CTX is unchanged, then T is in fact the
9450 specialization we want. That situation occurs when
9451 referencing a static data member within in its own
9452 class. We can use pointer equality, rather than
9453 same_type_p, because DECL_CONTEXT is always
9454 canonical. */
9457 }
9460 {
9466 }
9467 }
9468 else
9469 {
9470 /* A local variable. */
9472 /* Subsequent calls to pushdecl will fill this in. */
9475 }
9476 /* If we already have the specialization we need, there is
9477 nothing more to do. */
9479 {
9482 }
9484 /* Create a new node for the specialization we need. */
9487 {
9490 else
9493 }
9495 {
9496 /* Even if the original location is out of scope, the
9497 newly substituted one is not. */
9504 {
9505 /* It may seem that this case cannot occur, since:
9507 typedef void f();
9508 void g() { f x; }
9510 declares a function, not a variable. However:
9512 typedef void f();
9513 template <typename T> void g() { T t; }
9514 template void g<f>();
9516 is an attempt to declare a variable with function
9517 type. */
9519 /* R is not yet sufficiently initialized, so we
9520 just use its name. */
9523 }
9530 {
9535 }
9536 }
9542 /* Clear out the mangled name and RTL for the instantiation. */
9546 /* The initializer must not be expanded until it is required;
9547 see [temp.inst]. */
9553 {
9554 /* Possibly limit visibility based on template args. */
9557 {
9561 }
9563 }
9566 {
9567 /* A static data member declaration is always marked
9568 external when it is declared in-class, even if an
9569 initializer is present. We mimic the non-template
9570 processing here. */
9576 }
9578 {
9579 /* We're substituting this var in a decltype outside of its
9580 scope, such as for a lambda return type. Don't add it to
9581 local_specializations, do perform auto deduction. */
9583 tree init
9588 {
9591 }
9592 }
9593 else
9602 /* Preserve a typedef that names a type. */
9604 {
9607 }
9610 }
9615 }
9616 #undef RETURN
9618 out:
9619 /* Restore the file and line information. */
9623 }
9625 /* Substitute into the ARG_TYPES of a function type. */
9627 static tree
9629 tree args,
9630 tsubst_flags_t complain,
9631 tree in_decl)
9632 {
9633 tree remaining_arg_types;
9637 tree default_arg;
9648 {
9649 /* For a pack expansion, perform substitution on the
9650 entire expression. Later on, we'll handle the arguments
9651 one-by-one. */
9656 /* So that we'll spin through the parameters, one by one. */
9658 else
9659 {
9660 /* We only partially substituted into the parameter
9661 pack. Our type is TYPE_PACK_EXPANSION. */
9664 }
9665 }
9678 {
9680 {
9684 }
9686 }
9688 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9689 top-level qualifiers as required. */
9692 /* We do not substitute into default arguments here. The standard
9693 mandates that they be instantiated only when needed, which is
9694 done in build_over_call. */
9698 {
9699 /* We've instantiated a template before its default arguments
9700 have been parsed. This can happen for a nested template
9701 class, and is not an error unless we require the default
9702 argument in a call of this function. */
9703 remaining_arg_types =
9706 remaining_arg_types);
9707 }
9708 else
9709 remaining_arg_types =
9711 }
9714 }
9716 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9717 *not* handle the exception-specification for FNTYPE, because the
9718 initial substitution of explicitly provided template parameters
9719 during argument deduction forbids substitution into the
9720 exception-specification:
9722 [temp.deduct]
9724 All references in the function type of the function template to the
9725 corresponding template parameters are replaced by the specified tem-
9726 plate argument values. If a substitution in a template parameter or
9727 in the function type of the function template results in an invalid
9728 type, type deduction fails. [Note: The equivalent substitution in
9729 exception specifications is done only when the function is instanti-
9730 ated, at which point a program is ill-formed if the substitution
9731 results in an invalid type.] */
9733 static tree
9735 tree args,
9736 tsubst_flags_t complain,
9737 tree in_decl)
9738 {
9739 tree return_type;
9740 tree arg_types;
9741 tree fntype;
9743 /* The TYPE_CONTEXT is not used for function/method types. */
9746 /* Substitute the return type. */
9750 /* The standard does not presently indicate that creation of a
9751 function type with an invalid return type is a deduction failure.
9752 However, that is clearly analogous to creating an array of "void"
9753 or a reference to a reference. This is core issue #486. */
9756 {
9758 {
9761 else
9763 }
9765 }
9767 /* Substitute the argument types. */
9773 /* Construct a new type node and return it. */
9776 else
9777 {
9780 {
9781 /* [temp.deduct]
9783 Type deduction may fail for any of the following
9784 reasons:
9786 -- Attempting to create "pointer to member of T" when T
9787 is not a class type. */
9790 r);
9792 }
9796 }
9801 }
9803 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9804 ARGS into that specification, and return the substituted
9805 specification. If there is no specification, return NULL_TREE. */
9807 static tree
9809 tree args,
9810 tsubst_flags_t complain,
9811 tree in_decl)
9812 {
9813 tree specs;
9814 tree new_specs;
9819 {
9822 else
9824 {
9825 tree spec;
9830 {
9831 /* Expand the pack expansion type. */
9834 in_decl);
9840 else
9841 {
9842 /* We're substituting into a member template, so
9843 we got a TYPE_PACK_EXPANSION back. Add that
9844 expansion and move on. */
9848 expanded_specs,
9849 complain);
9852 }
9853 }
9856 {
9859 else
9864 complain);
9865 }
9868 }
9869 }
9871 }
9873 /* Take the tree structure T and replace template parameters used
9874 therein with the argument vector ARGS. IN_DECL is an associated
9875 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9876 Issue error and warning messages under control of COMPLAIN. Note
9877 that we must be relatively non-tolerant of extensions here, in
9878 order to preserve conformance; if we allow substitutions that
9879 should not be allowed, we may allow argument deductions that should
9880 not succeed, and therefore report ambiguous overload situations
9881 where there are none. In theory, we could allow the substitution,
9882 but indicate that it should have failed, and allow our caller to
9883 make sure that the right thing happens, but we don't try to do this
9884 yet.
9886 This function is used for dealing with types, decls and the like;
9887 for expressions, use tsubst_expr or tsubst_copy. */
9889 tree
9891 {
9910 else
9915 /* Reuse typedefs. We need to do this to handle dependent attributes,
9916 such as attribute aligned. */
9920 {
9926 {
9930 }
9935 else
9936 /* The typedef is from a non-template context. */
9940 {
9942 r = cp_build_qualified_type_real
9946 }
9947 /* Else we must be instantiating the typedef, so fall through. */
9948 }
9961 {
9988 {
9994 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
9995 needed. */
10003 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
10004 with TREE_SIDE_EFFECTS that indicates this is not an integral
10005 constant expression. */
10008 {
10011 }
10017 {
10021 }
10023 /* [temp.deduct]
10025 Type deduction may fail for any of the following
10026 reasons:
10028 Attempting to create an array with a size that is
10029 zero or negative. */
10031 /* We must fail if performing argument deduction (as
10032 indicated by the state of complain), so that
10033 another substitution can be found. */
10037 {
10042 }
10045 }
10051 {
10064 {
10068 /* See through ARGUMENT_PACK_SELECT arguments. */
10070 }
10075 {
10077 /* If ARG is an argument pack, we don't actually want to
10078 perform a substitution here, because substitutions
10079 for argument packs are only done
10080 element-by-element. We can get to this point when
10081 substituting the type of a non-type template
10082 parameter pack, when that type actually contains
10083 template parameter packs from an outer template, e.g.,
10085 template<typename... Types> struct A {
10086 template<Types... Values> struct B { };
10087 }; */
10091 {
10095 /* cv-quals from the template are discarded when
10096 substituting in a function or reference type. */
10101 else
10104 return cp_build_qualified_type_real
10106 }
10108 {
10109 /* We are processing a type constructed from a
10110 template template parameter. */
10116 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
10117 are resolving nested-types in the signature of a
10118 member function templates. Otherwise ARG is a
10119 TEMPLATE_DECL and is the real template to be
10120 instantiated. */
10128 complain);
10129 return cp_build_qualified_type_real
10131 }
10132 else
10133 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
10135 }
10138 /* This can happen during the attempted tsubst'ing in
10139 unify. This means that we don't yet have any information
10140 about the template parameter in question. */
10143 /* If we get here, we must have been looking at a parm for a
10144 more deeply nested template. Make a new version of this
10145 template parameter, but with a lower level. */
10147 {
10152 {
10154 r = cp_build_qualified_type_real
10158 }
10159 else
10160 {
10171 /* We have reduced the level of the template
10172 template parameter, but not the levels of its
10173 template parameters, so canonical_type_parameter
10174 will not be able to find the canonical template
10175 template parameter for this level. Thus, we
10176 require structural equality checking to compare
10177 TEMPLATE_TEMPLATE_PARMs. */
10181 else
10185 {
10193 }
10194 }
10203 }
10206 }
10209 {
10217 {
10221 }
10224 {
10228 }
10231 {
10235 }
10241 }
10244 /* We should never be tsubsting a binfo. */
10248 /* A vector of template arguments. */
10254 {
10263 /* [temp.deduct]
10265 Type deduction may fail for any of the following
10266 reasons:
10268 -- Attempting to create a pointer to reference type.
10269 -- Attempting to create a reference to a reference type or
10270 a reference to void.
10272 Core issue 106 says that creating a reference to a reference
10273 during instantiation is no longer a cause for failure. We
10274 only enforce this check in strict C++98 mode. */
10278 {
10281 /* We keep track of the last time we issued this error
10282 message to avoid spewing a ton of messages during a
10283 single bad template instantiation. */
10286 {
10291 else
10294 }
10297 }
10299 {
10303 }
10305 /* In C++0x, during template argument substitution, when there is an
10306 attempt to create a reference to a reference type, reference
10307 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
10309 "If a template-argument for a template-parameter T names a type
10310 that is a reference to a type A, an attempt to create the type
10311 'lvalue reference to cv T' creates the type 'lvalue reference to
10312 A,' while an attempt to create the type type rvalue reference to
10313 cv T' creates the type T"
10314 */
10315 r = cp_build_reference_type
10318 else
10323 /* Will this ever be needed for TYPE_..._TO values? */
10327 }
10329 {
10332 {
10333 /* [temp.deduct]
10335 Type deduction may fail for any of the following
10336 reasons:
10338 -- Attempting to create "pointer to member of T" when T
10339 is not a class type. */
10343 }
10345 {
10349 }
10351 {
10355 }
10358 {
10359 /* The type of the implicit object parameter gets its
10360 cv-qualifiers from the FUNCTION_TYPE. */
10361 tree memptr;
10365 complain);
10366 }
10367 else
10370 complain);
10371 }
10374 {
10375 tree fntype;
10376 tree specs;
10381 /* Substitute the exception specification. */
10383 in_decl);
10389 }
10391 {
10396 /* As an optimization, we avoid regenerating the array type if
10397 it will obviously be the same as T. */
10401 /* These checks should match the ones in grokdeclarator.
10403 [temp.deduct]
10405 The deduction may fail for any of the following reasons:
10407 -- Attempting to create an array with an element type that
10408 is void, a function type, or a reference type, or [DR337]
10409 an abstract class type. */
10413 {
10417 }
10419 {
10422 type);
10424 }
10429 {
10432 }
10435 }
10439 {
10448 }
10452 {
10458 }
10461 {
10471 {
10475 }
10477 {
10478 /* Normally, make_typename_type does not require that the CTX
10479 have complete type in order to allow things like:
10481 template <class T> struct S { typename S<T>::X Y; };
10483 But, such constructs have already been resolved by this
10484 point, so here CTX really should have complete type, unless
10485 it's a partial instantiation. */
10489 {
10493 }
10494 }
10501 {
10504 }
10507 {
10514 }
10516 return cp_build_qualified_type_real
10518 }
10521 {
10533 }
10541 {
10549 }
10552 {
10560 }
10563 {
10564 tree type;
10580 complain);
10581 }
10584 {
10585 tree type;
10601 else
10602 type = finish_decltype_type
10607 complain);
10608 }
10612 {
10616 tree packed_out =
10618 args,
10619 complain,
10620 in_decl);
10623 /* For template nontype argument packs, also substitute into
10624 the type. */
10629 }
10636 }
10637 }
10639 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10640 type of the expression on the left-hand side of the "." or "->"
10641 operator. */
10643 static tree
10646 {
10647 tree name;
10648 tree qualifying_scope;
10649 tree fns;
10650 tree optype;
10654 /* A baselink indicates a function from a base class. Both the
10655 BASELINK_ACCESS_BINFO and the base class referenced may
10656 indicate bases of the template class, rather than the
10657 instantiated class. In addition, lookups that were not
10658 ambiguous before may be ambiguous now. Therefore, we perform
10659 the lookup again. */
10666 {
10673 }
10679 /* If lookup found a single function, mark it as used at this
10680 point. (If it lookup found multiple functions the one selected
10681 later by overload resolution will be marked as used at that
10682 point.) */
10688 /* Add back the template arguments, if present. */
10693 template_args);
10694 /* Update the conversion operator type. */
10700 qualifying_scope,
10701 object_type);
10702 }
10704 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10705 true if the qualified-id will be a postfix-expression in-and-of
10706 itself; false if more of the postfix-expression follows the
10707 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10708 of "&". */
10710 static tree
10714 {
10715 tree expr;
10716 tree scope;
10717 tree name;
10719 tree template_args;
10723 /* Figure out what name to look up. */
10726 {
10733 }
10734 else
10735 {
10738 }
10740 /* Substitute into the qualifying scope. When there are no ARGS, we
10741 are just trying to simplify a non-dependent expression. In that
10742 case the qualifying scope may be dependent, and, in any case,
10743 substituting will not help. */
10746 {
10749 }
10750 else
10758 {
10760 {
10761 /* A BIT_NOT_EXPR is used to represent a destructor. */
10763 {
10767 }
10768 else
10771 }
10772 else
10776 {
10778 {
10782 }
10784 }
10785 }
10788 {
10790 scope);
10791 /* Remember that there was a reference to this entity. */
10793 }
10796 {
10802 }
10811 {
10812 expr = (adjust_result_of_qualified_name_lookup
10814 expr = (finish_qualified_id_expr
10818 }
10820 /* Expressions do not generally have reference type. */
10822 /* However, if we're about to form a pointer-to-member, we just
10823 want the referenced member referenced. */
10828 }
10830 /* Like tsubst, but deals with expressions. This function just replaces
10831 template parms; to finish processing the resultant expression, use
10832 tsubst_expr. */
10834 static tree
10836 {
10838 tree r;
10846 {
10851 {
10852 tree c;
10853 /* This can happen for a parameter name used later in a function
10854 declaration (such as in a late-specified return type). Just
10855 make a dummy decl, since it's only used for its type. */
10857 /* We copy T because want to tsubst the PARM_DECL only,
10858 not the following PARM_DECLs that are chained to T. */
10861 /* Give it the template pattern as its context; its true context
10862 hasn't been instantiated yet and this is good enough for
10863 mangling. */
10865 }
10873 {
10874 tree enum_type;
10875 tree v;
10879 /* There is no need to substitute into namespace-scope
10880 enumerators. */
10883 /* If ARGS is NULL, then T is known to be non-dependent. */
10887 /* Unfortunately, we cannot just call lookup_name here.
10888 Consider:
10890 template <int I> int f() {
10891 enum E { a = I };
10892 struct S { void g() { E e = a; } };
10893 };
10895 When we instantiate f<7>::S::g(), say, lookup_name is not
10896 clever enough to find f<7>::a. */
10897 enum_type
10907 /* We didn't find the name. That should never happen; if
10908 name-lookup found it during preliminary parsing, we
10909 should find it again here during instantiation. */
10911 }
10916 {
10917 tree ctx;
10922 {
10925 {
10929 }
10931 }
10932 }
10955 {
10956 /* Template template argument like the following example need
10957 special treatment:
10959 template <template <class> class TT> struct C {};
10960 template <class T> struct D {
10961 template <class U> struct E {};
10962 C<E> c; // #1
10963 };
10964 D<int> d; // #2
10966 We are processing the template argument `E' in #1 for
10967 the template instantiation #2. Originally, `E' is a
10968 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10969 have to substitute this with one having context `D<int>'. */
10973 }
10974 else
10975 /* Ordinary template template argument. */
10984 return build1
10990 {
10991 /* We only want to compute the number of arguments. */
11005 {
11012 else
11015 }
11016 else
11018 }
11019 /* Fall through */
11033 return build1
11038 {
11039 tree object;
11040 tree name;
11045 {
11049 }
11052 {
11062 }
11067 in_decl);
11068 else
11071 }
11109 return build_nt
11122 return build_nt
11129 {
11137 }
11142 {
11143 r = build_nt
11149 }
11152 {
11153 r = build_nt
11159 }
11162 {
11163 r = build_nt
11169 }
11172 {
11173 /* Substituted template arguments */
11182 }
11185 {
11205 }
11230 {
11233 }
11234 else
11238 /* This is handled by tsubst_copy_and_build. */
11243 in_decl),
11247 /* We shouldn't have built any of these during initial template
11248 generation. Instead, they should be built during instantiation
11249 in response to the saved STMT_IS_FULL_EXPR_P setting. */
11266 }
11267 }
11269 /* Like tsubst_copy, but specifically for OpenMP clauses. */
11271 static tree
11273 tree in_decl)
11274 {
11278 {
11284 {
11287 {
11293 }
11294 /* FALLTHRU */
11316 }
11317 }
11320 }
11322 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
11324 static tree
11326 tree in_decl)
11327 {
11328 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
11353 #undef RECUR
11354 }
11356 /* Substitute one OMP_FOR iterator. */
11358 static void
11363 {
11364 #define RECUR(NODE) \
11365 tsubst_expr ((NODE), args, complain, in_decl, \
11366 integral_constant_expression_p)
11375 {
11382 }
11386 {
11392 complain);
11393 else
11400 }
11403 {
11404 tree c;
11406 {
11417 }
11419 {
11424 {
11427 }
11428 }
11429 }
11435 else
11439 {
11450 {
11457 }
11458 else
11464 {
11470 }
11474 {
11481 }
11482 else
11488 }
11494 #undef RECUR
11495 }
11497 /* Like tsubst_copy for expressions, etc. but also does semantic
11498 processing. */
11500 static tree
11503 {
11504 #define RECUR(NODE) \
11505 tsubst_expr ((NODE), args, complain, in_decl, \
11506 integral_constant_expression_p)
11519 {
11521 {
11522 tree_stmt_iterator i;
11526 }
11541 else
11550 {
11551 tree decl;
11552 tree init;
11558 {
11561 tree decl;
11569 else
11571 }
11572 else
11573 {
11577 {
11578 /* By marking the declaration as instantiated, we avoid
11579 trying to instantiate it. Since instantiate_decl can't
11580 handle local variables, and since we've already done
11581 all that needs to be done, that's the right thing to
11582 do. */
11587 /* Anonymous aggregates are a special case. */
11589 else
11590 {
11594 {
11595 /* For __PRETTY_FUNCTION__ we have to adjust the
11596 initializer. */
11600 }
11601 else
11602 {
11606 /* If we had an initializer but it
11607 instantiated to nothing,
11608 value-initialize the object. This will
11609 only occur when the initializer was a
11610 pack expansion where the parameter packs
11611 used in that expansion were of length
11612 zero. */
11614 else
11616 }
11619 }
11620 }
11621 }
11623 /* A DECL_EXPR can also be used as an expression, in the condition
11624 clause of an if/for/while construct. */
11626 }
11664 {
11668 }
11676 else
11684 else
11711 {
11713 tree label;
11718 }
11724 /* Computed goto's must be tsubst'd into. On the other hand,
11725 non-computed gotos must not be; the identifier in question
11726 will have no binding. */
11728 else
11734 tmp = finish_asm_stmt
11741 {
11746 }
11751 {
11756 }
11757 else
11758 {
11763 else
11770 else
11776 else
11778 }
11782 {
11786 {
11788 /* Prevent instantiate_decl from trying to instantiate
11789 this variable. We've already done all that needs to be
11790 done. */
11793 }
11798 }
11806 {
11807 tree condition =
11809 args,
11816 }
11837 {
11852 integral_constant_expression_p);
11861 {
11865 }
11866 else
11867 {
11875 }
11889 }
11920 {
11925 }
11941 integral_constant_expression_p);
11942 }
11945 #undef RECUR
11946 }
11948 /* T is a postfix-expression that is not being used in a function
11949 call. Return the substituted version of T. */
11951 static tree
11953 tsubst_flags_t complain,
11954 tree in_decl)
11955 {
11959 else
11965 }
11967 /* Like tsubst but deals with expressions and performs semantic
11968 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11970 tree
11972 tree args,
11973 tsubst_flags_t complain,
11974 tree in_decl,
11977 {
11978 #define RECUR(NODE) \
11979 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11981 integral_constant_expression_p)
11983 tree op1;
11989 {
11992 /* Fall through. */
11994 {
11995 tree decl;
11996 cp_id_kind idk;
12001 {
12004 }
12006 /* Look up the name. */
12009 /* By convention, expressions use ERROR_MARK_NODE to indicate
12010 failure, not NULL_TREE. */
12016 integral_constant_expression_p,
12024 input_location);
12030 }
12033 {
12034 tree object;
12042 {
12045 }
12046 else
12053 else
12055 }
12058 {
12062 {
12063 /* A type conversion to reference type will be enclosed in
12064 such an indirect ref, but the substitution of the cast
12065 will have also added such an indirect ref. */
12068 }
12069 else
12072 }
12075 return build_nop
12084 {
12085 tree type;
12086 tree op;
12091 {
12096 }
12101 {
12114 }
12115 }
12133 complain);
12140 else
12142 in_decl);
12179 return build_x_binary_op
12183 ? ERROR_MARK
12187 ? ERROR_MARK
12190 complain);
12203 /* Fall through */
12208 {
12209 /* When there are no ARGS, we are trying to evaluate a
12210 non-dependent expression from the parser. Trying to do
12211 the substitutions may not work. */
12214 }
12215 else
12216 {
12224 }
12228 else
12233 {
12234 tree r = build_x_modify_expr
12238 complain);
12239 /* TREE_NO_WARNING must be set if either the expression was
12240 parenthesized or it uses an operator such as >>= rather
12241 than plain assignment. In the former case, it was already
12242 set and must be copied. In the latter case,
12243 build_x_modify_expr sets it and it must not be reset
12244 here. */
12248 }
12253 /* Remember that there was a reference to this entity. */
12259 {
12264 tree ret;
12268 else
12269 {
12273 }
12275 /* If there was an initializer in the original tree, but it
12276 instantiated to an empty list, then we should pass a
12277 non-NULL empty vector to tell build_new that it was an
12278 empty initializer() rather than no initializer. This can
12279 only happen when the initializer is a pack expansion whose
12280 parameter packs are of length zero. */
12283 else
12284 {
12288 else
12289 {
12292 }
12293 }
12300 complain);
12308 }
12311 return delete_sanity
12320 complain);
12323 {
12324 tree function;
12329 tree ret;
12332 /* When we parsed the expression, we determined whether or
12333 not Koenig lookup should be performed. */
12336 {
12341 }
12342 else
12343 {
12345 {
12351 }
12352 else
12356 in_decl,
12358 integral_constant_expression_p);
12362 }
12367 {
12373 else
12374 {
12375 /* Expand the pack expansion and push each entry onto
12376 CALL_ARGS. */
12379 {
12384 {
12389 }
12390 }
12391 else
12392 {
12393 /* A partial substitution. Add one entry. */
12395 }
12396 }
12397 }
12399 /* We do not perform argument-dependent lookup if normal
12400 lookup finds a non-function, in accordance with the
12401 expected resolution of DR 218. */
12404 /* If lookup found a member function, the Koenig lookup is
12405 not appropriate, even if an unqualified-name was used
12406 to denote the function. */
12409 /* Only do this when substitution turns a dependent call
12410 into a non-dependent call. */
12416 {
12420 }
12422 /* Remember that there was a reference to this entity. */
12429 {
12434 complain);
12435 else
12436 ret = (build_new_method_call
12442 complain));
12443 }
12444 else
12447 koenig_p,
12448 complain);
12453 }
12456 return build_x_conditional_expr
12460 complain);
12463 return finish_pseudo_destructor_expr
12469 {
12477 {
12478 /* We have pack expansions, so expand those and
12479 create a new list out of it. */
12482 tree chain;
12485 /* Expand the argument expressions. */
12493 /* Build the rest of the list. */
12498 /* Determine the number of arguments. */
12500 {
12503 }
12506 else
12507 {
12508 /* Since we only performed a partial substitution into
12509 the argument pack, we only return a single list
12510 node. */
12517 }
12519 /* Convert the argument vectors into a TREE_LIST */
12522 {
12523 /* Grab the Ith values. */
12524 i--;
12527 value
12531 /* Build the list (backwards). */
12533 }
12536 }
12552 }
12555 {
12556 tree object;
12557 tree object_type;
12558 tree member;
12562 /* Remember that there was a reference to this entity. */
12572 else
12578 {
12580 {
12585 {
12588 }
12590 {
12594 }
12595 }
12596 }
12599 {
12600 tree tmpl;
12601 tree args;
12603 /* Lookup the template functions now that we know what the
12604 scope is. */
12611 {
12614 args);
12615 member = (adjust_result_of_qualified_name_lookup
12617 object_type));
12618 }
12619 else
12620 {
12622 input_location);
12624 }
12625 }
12629 {
12631 {
12635 else
12638 }
12640 }
12646 complain);
12647 }
12650 return build_throw
12654 {
12662 tree r;
12667 /* digest_init will do the wrong thing if we let it. */
12671 /* We do not want to process the index of aggregate
12672 initializers as they are identifier nodes which will be
12673 looked up by digest_init. */
12679 {
12684 {
12685 /* Substitute into the pack expansion. */
12687 in_decl);
12690 ;
12692 /* Just move the argument into place. */
12694 else
12695 {
12696 /* Update the length of the final CONSTRUCTOR
12697 arguments vector, and note that we will need to
12698 copy.*/
12701 }
12702 }
12703 else
12705 }
12708 {
12713 idx++)
12714 {
12716 {
12721 }
12722 else
12724 }
12725 }
12734 }
12737 {
12742 }
12747 /* Fall through */
12750 {
12754 /* If the original type was a reference, we'll be wrapped in
12755 the appropriate INDIRECT_REF. */
12758 }
12763 in_decl));
12769 {
12778 }
12781 {
12787 integral_constant_expression_p);
12791 /* If the resulting list of expression statement is empty,
12792 fold it further into void_zero_node. */
12797 }
12801 /* As in finish_id_expression, we resolve enumeration constants
12802 to their underlying values. */
12804 {
12807 }
12811 {
12832 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
12834 /* Now that we know visibility, instantiate the type so we have a
12835 declaration of the op() for later calls to lambda_function. */
12843 }
12846 /* Handle Objective-C++ constructs, if appropriate. */
12847 {
12848 tree subst
12853 }
12855 }
12857 #undef RECUR
12858 }
12860 /* Verify that the instantiated ARGS are valid. For type arguments,
12861 make sure that the type's linkage is ok. For non-type arguments,
12862 make sure they are constants if they are integral or enumerations.
12863 Emit an error under control of COMPLAIN, and return TRUE on error. */
12865 static bool
12867 {
12869 {
12879 }
12881 {
12882 /* [basic.link]: A name with no linkage (notably, the name
12883 of a class or enumeration declared in a local scope)
12884 shall not be used to declare an entity with linkage.
12885 This implies that names with no linkage cannot be used as
12886 template arguments
12888 DR 757 relaxes this restriction for C++0x. */
12893 {
12894 /* DR 488 makes use of a type with no linkage cause
12895 type deduction to fail. */
12897 {
12900 else
12903 }
12905 }
12906 /* In order to avoid all sorts of complications, we do not
12907 allow variably-modified types as template arguments. */
12909 {
12913 }
12914 }
12915 /* A non-type argument of integral or enumerated type must be a
12916 constant. */
12920 {
12924 }
12926 }
12928 static bool
12930 {
12935 {
12938 }
12942 }
12944 /* Instantiate the indicated variable or function template TMPL with
12945 the template arguments in TARG_PTR. */
12947 tree
12949 {
12951 tree fndecl;
12952 tree gen_tmpl;
12953 tree spec;
12954 HOST_WIDE_INT saved_processing_template_decl;
12961 /* If this function is a clone, handle it specially. */
12963 {
12964 tree spec;
12965 tree clone;
12967 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
12968 DECL_CLONED_FUNCTION. */
12974 /* Look for the clone. */
12978 /* We should always have found the clone by now. */
12981 }
12983 /* Check to see if we already have this specialization. */
12986 /* The TMPL is a partial instantiation. To get a full set of
12987 arguments we must add the arguments used to perform the
12988 partial instantiation. */
12990 targ_ptr);
12992 /* It would be nice to avoid hashing here and then again in tsubst_decl,
12993 but it doesn't seem to be on the hot path. */
13005 complain))
13008 /* We are building a FUNCTION_DECL, during which the access of its
13009 parameters and return types have to be checked. However this
13010 FUNCTION_DECL which is the desired context for access checking
13011 is not built yet. We solve this chicken-and-egg problem by
13012 deferring all checks until we have the FUNCTION_DECL. */
13015 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
13016 (because, for example, we have encountered a non-dependent
13017 function call in the body of a template function and must now
13018 determine which of several overloaded functions will be called),
13019 within the instantiation itself we are not processing a
13020 template. */
13023 /* Substitute template parameters to obtain the specialization. */
13030 /* Now we know the specialization, compute access previously
13031 deferred. */
13034 /* Some typedefs referenced from within the template code need to be access
13035 checked at template instantiation time, i.e now. These types were
13036 added to the template at parsing time. Let's get those and perfom
13037 the acces checks then. */
13043 /* The DECL_TI_TEMPLATE should always be the immediate parent
13044 template, not the most general template. */
13047 /* If we've just instantiated the main entry point for a function,
13048 instantiate all the alternate entry points as well. We do this
13049 by cloning the instantiation of the main entry point, not by
13050 instantiating the template clones. */
13055 }
13057 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
13058 NARGS elements of the arguments that are being used when calling
13059 it. TARGS is a vector into which the deduced template arguments
13060 are placed.
13062 Return zero for success, 2 for an incomplete match that doesn't resolve
13063 all the types, and 1 for complete failure. An error message will be
13064 printed only for an incomplete match.
13066 If FN is a conversion operator, or we are trying to produce a specific
13067 specialization, RETURN_TYPE is the return type desired.
13069 The EXPLICIT_TARGS are explicit template arguments provided via a
13070 template-id.
13072 The parameter STRICT is one of:
13074 DEDUCE_CALL:
13075 We are deducing arguments for a function call, as in
13076 [temp.deduct.call].
13078 DEDUCE_CONV:
13079 We are deducing arguments for a conversion function, as in
13080 [temp.deduct.conv].
13082 DEDUCE_EXACT:
13083 We are deducing arguments when doing an explicit instantiation
13084 as in [temp.explicit], when determining an explicit specialization
13085 as in [temp.expl.spec], or when taking the address of a function
13086 template, as in [temp.deduct.funcaddr]. */
13088 int
13090 tree explicit_targs,
13091 tree targs,
13094 tree return_type,
13095 unification_kind_t strict,
13097 {
13098 tree parms;
13099 tree fntype;
13107 {
13108 /* [temp.deduct]
13110 The specified template arguments must match the template
13111 parameters in kind (i.e., type, nontype, template), and there
13112 must not be more arguments than there are parameters;
13113 otherwise type deduction fails.
13115 Nontype arguments must match the types of the corresponding
13116 nontype template parameters, or must be convertible to the
13117 types of the corresponding nontype parameters as specified in
13118 _temp.arg.nontype_, otherwise type deduction fails.
13120 All references in the function type of the function template
13121 to the corresponding template parameters are replaced by the
13122 specified template argument values. If a substitution in a
13123 template parameter or in the function type of the function
13124 template results in an invalid type, type deduction fails. */
13127 tree converted_args;
13133 converted_args
13140 /* Substitute the explicit args into the function type. This is
13141 necessary so that, for instance, explicitly declared function
13142 arguments can match null pointed constants. If we were given
13143 an incomplete set of explicit args, we must not do semantic
13144 processing during substitution as we could create partial
13145 instantiations. */
13147 {
13151 /* Dig out the actual parm. */
13154 {
13157 }
13159 {
13162 }
13165 {
13167 tree targ;
13170 /* Mark the argument pack as "incomplete". We could
13171 still deduce more arguments during unification. */
13174 {
13178 }
13180 /* We have some incomplete argument packs. */
13182 }
13183 }
13186 /* Any substitution is guaranteed to be incomplete if there
13187 are incomplete argument packs, because we can still deduce
13188 more arguments. */
13190 else
13200 /* Place the explicitly specified arguments in TARGS. */
13203 }
13205 /* Never do unification on the 'this' parameter. */
13209 {
13218 }
13220 /* We allow incomplete unification without an error message here
13221 because the standard doesn't seem to explicitly prohibit it. Our
13222 callers must be ready to deal with unification failures in any
13223 event. */
13229 {
13232 /* Clear the "incomplete" flags on all argument packs. */
13234 {
13237 {
13240 }
13241 }
13242 }
13244 /* Now that we have bindings for all of the template arguments,
13245 ensure that the arguments deduced for the template template
13246 parameters have compatible template parameter lists. We cannot
13247 check this property before we have deduced all template
13248 arguments, because the template parameter types of a template
13249 template parameter might depend on prior template parameters
13250 deduced after the template template parameter. The following
13251 ill-formed example illustrates this issue:
13253 template<typename T, template<T> class C> void f(C<5>, T);
13255 template<int N> struct X {};
13257 void g() {
13258 f(X<5>(), 5l); // error: template argument deduction fails
13259 }
13261 The template parameter list of 'C' depends on the template type
13262 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
13263 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
13264 time that we deduce 'C'. */
13266 && !template_template_parm_bindings_ok_p
13271 /* All is well so far. Now, check:
13273 [temp.deduct]
13275 When all template arguments have been deduced, all uses of
13276 template parameters in nondeduced contexts are replaced with
13277 the corresponding deduced argument values. If the
13278 substitution results in an invalid type, as described above,
13279 type deduction fails. */
13280 {
13285 /* If we're looking for an exact match, check that what we got
13286 is indeed an exact match. It might not be if some template
13287 parameters are used in non-deduced contexts. */
13289 {
13292 tree sarg
13299 }
13300 }
13303 }
13305 /* Adjust types before performing type deduction, as described in
13306 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
13307 sections are symmetric. PARM is the type of a function parameter
13308 or the return type of the conversion function. ARG is the type of
13309 the argument passed to the call, or the type of the value
13310 initialized with the result of the conversion function.
13311 ARG_EXPR is the original argument expression, which may be null. */
13313 static int
13317 tree arg_expr)
13318 {
13322 {
13327 {
13328 /* Swap PARM and ARG throughout the remainder of this
13329 function; the handling is precisely symmetric since PARM
13330 will initialize ARG rather than vice versa. */
13335 }
13338 /* Core issue #873: Do the DR606 thing (see below) for these cases,
13339 too, but here handle it by stripping the reference from PARM
13340 rather than by adding it to ARG. */
13348 /* Nothing else to do in this case. */
13353 }
13356 {
13357 /* [temp.deduct.call]
13359 If P is not a reference type:
13361 --If A is an array type, the pointer type produced by the
13362 array-to-pointer standard conversion (_conv.array_) is
13363 used in place of A for type deduction; otherwise,
13365 --If A is a function type, the pointer type produced by
13366 the function-to-pointer standard conversion
13367 (_conv.func_) is used in place of A for type deduction;
13368 otherwise,
13370 --If A is a cv-qualified type, the top level
13371 cv-qualifiers of A's type are ignored for type
13372 deduction. */
13377 else
13379 }
13381 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
13382 of the form T&&, where T is a template parameter, and the argument
13383 is an lvalue, T is deduced as A& */
13391 /* [temp.deduct.call]
13393 If P is a cv-qualified type, the top level cv-qualifiers
13394 of P's type are ignored for type deduction. If P is a
13395 reference type, the type referred to by P is used for
13396 type deduction. */
13399 {
13402 }
13404 /* DR 322. For conversion deduction, remove a reference type on parm
13405 too (which has been swapped into ARG). */
13410 }
13412 /* Most parms like fn_type_unification.
13414 If SUBR is 1, we're being called recursively (to unify the
13415 arguments of a function or method parameter of a function
13416 template). */
13418 static int
13420 tree targs,
13421 tree xparms,
13425 unification_kind_t strict,
13427 {
13433 tree parms;
13442 /* Reset the number of non-defaulted template arguments contained
13443 in in TARGS. */
13447 {
13463 }
13465 again:
13473 {
13486 /* We can't deduce anything from this, but we might get all the
13487 template args from other function args. */
13490 /* Conversions will be performed on a function argument that
13491 corresponds with a function parameter that contains only
13492 non-deducible template parameters and explicitly specified
13493 template parameters. */
13495 {
13496 tree type;
13500 else
13507 flags))
13511 }
13514 {
13517 {
13518 /* [temp.deduct.type]
13520 A template-argument can be deduced from a pointer to
13521 function or pointer to member function argument if
13522 the set of overloaded functions does not contain
13523 function templates and at most one of a set of
13524 overloaded functions provides a unique match. */
13530 }
13535 }
13537 {
13542 arg_expr);
13548 }
13549 }
13555 {
13556 /* Unify the remaining arguments with the pack expansion type. */
13557 tree argvec;
13560 /* Allocate a TREE_VEC and copy in all of the arguments */
13565 /* Copy the parameter into parmvec. */
13571 /* Advance to the end of the list of parameters. */
13573 }
13575 /* Fail if we've reached the end of the parm list, and more args
13576 are present, and the parm list isn't variadic. */
13579 /* Fail if parms are left and they don't have default values. */
13587 {
13588 tree tparm;
13595 /* If this is an undeduced nontype parameter that depends on
13596 a type parameter, try another pass; its type may have been
13597 deduced from a later argument than the one from which
13598 this parameter can be deduced. */
13604 /* Core issue #226 (C++0x) [temp.deduct]:
13606 If a template argument has not been deduced, its
13607 default template argument, if any, is used.
13609 When we are in C++98 mode, TREE_PURPOSE will either
13610 be NULL_TREE or ERROR_MARK_NODE, so we do not need
13611 to explicitly check cxx_dialect here. */
13613 {
13621 else
13622 {
13624 /* The position of the first default template argument,
13625 is also the number of non-defaulted arguments in TARGS.
13626 Record that. */
13630 }
13631 }
13633 /* If the type parameter is a parameter pack, then it will
13634 be deduced to an empty parameter pack. */
13636 {
13637 tree arg;
13640 {
13644 }
13645 else
13652 }
13655 }
13656 #ifdef ENABLE_CHECKING
13659 #endif
13662 }
13664 /* Subroutine of type_unification_real. Args are like the variables
13665 at the call site. ARG is an overloaded function (or template-id);
13666 we try deducing template args from each of the overloads, and if
13667 only one succeeds, we go with that. Modifies TARGS and returns
13668 true on success. */
13670 static bool
13672 tree targs,
13673 tree parm,
13674 tree arg,
13675 unification_kind_t strict,
13677 {
13684 {
13687 }
13688 else
13692 /* Handle `&x' where `x' is some static or non-static member
13693 function name. */
13699 /* Strip baselink information. */
13704 {
13705 /* If we got some explicit template args, we need to plug them into
13706 the affected templates before we try to unify, in case the
13707 explicit args will completely resolve the templates in question. */
13713 {
13724 {
13729 {
13732 }
13733 }
13735 }
13736 }
13739 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13740 -- but the deduction does not succeed because the expression is
13741 not just the function on its own. */
13743 else
13749 {
13752 }
13754 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13755 to function or pointer to member function argument if the set of
13756 overloaded functions does not contain function templates and at most
13757 one of a set of overloaded functions provides a unique match.
13759 So if we found multiple possibilities, we return success but don't
13760 deduce anything. */
13763 {
13768 }
13773 }
13775 /* Core DR 115: In contexts where deduction is done and fails, or in
13776 contexts where deduction is not done, if a template argument list is
13777 specified and it, along with any default template arguments, identifies
13778 a single function template specialization, then the template-id is an
13779 lvalue for the function template specialization. */
13781 tree
13783 {
13796 {
13799 }
13801 {
13804 }
13806 {
13809 }
13812 {
13816 /* If we got some explicit template args, we need to plug them into
13817 the affected templates before we try to unify, in case the
13818 explicit args will completely resolve the templates in question. */
13826 {
13837 {
13840 {
13843 }
13845 {
13848 }
13849 }
13851 }
13853 {
13865 }
13867 /* There were no good options and at least one bad one, so let the
13868 user know what the problem is. */
13870 }
13872 }
13874 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13875 overload. Fills TARGS with any deduced arguments, or error_mark_node if
13876 different overloads deduce different arguments for a given parm.
13877 ADDR_P is true if the expression for which deduction is being
13878 performed was of the form "& fn" rather than simply "fn".
13880 Returns 1 on success. */
13882 static int
13884 tree orig_targs,
13885 tree targs,
13886 tree parm,
13887 tree arg,
13888 unification_kind_t strict,
13891 {
13893 tree tempargs;
13896 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13897 to function or pointer to member function argument if the set of
13898 overloaded functions does not contain function templates and at most
13899 one of a set of overloaded functions provides a unique match.
13901 So if this is a template, just return success. */
13913 /* We don't copy orig_targs for this because if we have already deduced
13914 some template args from previous args, unify would complain when we
13915 try to deduce a template parameter for the same argument, even though
13916 there isn't really a conflict. */
13923 /* First make sure we didn't deduce anything that conflicts with
13924 explicitly specified args. */
13926 {
13933 /* Since we're unifying against ourselves, we will fill in
13934 template args used in the function parm list with our own
13935 template parms. Discard them. */
13939 }
13942 {
13947 }
13950 }
13952 /* PARM is a template class (perhaps with unbound template
13953 parameters). ARG is a fully instantiated type. If ARG can be
13954 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
13955 TARGS are as for unify. */
13957 static tree
13959 {
13960 tree copy_of_targs;
13967 /* We need to make a new template argument vector for the call to
13968 unify. If we used TARGS, we'd clutter it up with the result of
13969 the attempted unification, even if this class didn't work out.
13970 We also don't want to commit ourselves to all the unifications
13971 we've already done, since unification is supposed to be done on
13972 an argument-by-argument basis. In other words, consider the
13973 following pathological case:
13975 template <int I, int J, int K>
13976 struct S {};
13978 template <int I, int J>
13979 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
13981 template <int I, int J, int K>
13982 void f(S<I, J, K>, S<I, I, I>);
13984 void g() {
13985 S<0, 0, 0> s0;
13986 S<0, 1, 2> s2;
13988 f(s0, s2);
13989 }
13991 Now, by the time we consider the unification involving `s2', we
13992 already know that we must have `f<0, 0, 0>'. But, even though
13993 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
13994 because there are two ways to unify base classes of S<0, 1, 2>
13995 with S<I, I, I>. If we kept the already deduced knowledge, we
13996 would reject the possibility I=1. */
13999 /* If unification failed, we're done. */
14005 }
14007 /* Given a template type PARM and a class type ARG, find the unique
14008 base type in ARG that is an instance of PARM. We do not examine
14009 ARG itself; only its base-classes. If there is not exactly one
14010 appropriate base class, return NULL_TREE. PARM may be the type of
14011 a partial specialization, as well as a plain template type. Used
14012 by unify. */
14014 static tree
14016 {
14018 tree binfo;
14024 /* The type could not be completed. */
14027 /* Walk in inheritance graph order. The search order is not
14028 important, and this avoids multiple walks of virtual bases. */
14030 {
14034 {
14035 /* If there is more than one satisfactory baseclass, then:
14037 [temp.deduct.call]
14039 If they yield more than one possible deduced A, the type
14040 deduction fails.
14042 applies. */
14047 }
14048 }
14051 }
14053 /* Returns the level of DECL, which declares a template parameter. */
14055 static int
14057 {
14059 {
14069 }
14071 }
14073 /* Decide whether ARG can be unified with PARM, considering only the
14074 cv-qualifiers of each type, given STRICT as documented for unify.
14075 Returns nonzero iff the unification is OK on that basis. */
14077 static int
14079 {
14085 {
14086 /* Although a CVR qualifier is ignored when being applied to a
14087 substituted template parameter ([8.3.2]/1 for example), that
14088 does not apply during deduction [14.8.2.4]/1, (even though
14089 that is not explicitly mentioned, [14.8.2.4]/9 indicates
14090 this). Except when we're allowing additional CV qualifiers
14091 at the outer level [14.8.2.1]/3,1st bullet. */
14101 }
14112 }
14114 /* Determines the LEVEL and INDEX for the template parameter PARM. */
14115 void
14117 {
14121 {
14124 }
14125 else
14126 {
14129 }
14130 }
14132 /* Unifies the remaining arguments in PACKED_ARGS with the pack
14133 expansion at the end of PACKED_PARMS. Returns 0 if the type
14134 deduction succeeds, 1 otherwise. STRICT is the same as in
14135 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
14136 call argument list. We'll need to adjust the arguments to make them
14137 types. SUBR tells us if this is from a recursive call to
14138 type_unification_real. */
14139 int
14143 {
14144 tree parm
14151 /* Determine the parameter packs we will be deducing from the
14152 pattern, and record their current deductions. */
14155 {
14159 /* Determine the index and level of this parameter pack. */
14162 /* Keep track of the parameter packs and their corresponding
14163 argument packs. */
14166 }
14168 /* Loop through all of the arguments that have not yet been
14169 unified and unify each with the pattern. */
14171 {
14174 /* For each parameter pack, clear out the deduced value so that
14175 we can deduce it again. */
14177 {
14182 }
14184 /* Unify the pattern with the current argument. */
14185 {
14192 {
14195 /* This mirrors what we do in type_unification_real. */
14197 {
14199 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
14200 | UNIFY_ALLOW_MORE_CV_QUAL
14214 }
14217 {
14220 {
14221 /* [temp.deduct.type] A template-argument can be
14222 deduced from a pointer to function or pointer
14223 to member function argument if the set of
14224 overloaded functions does not contain function
14225 templates and at most one of a set of
14226 overloaded functions provides a unique
14227 match. */
14232 sub_strict)
14236 }
14239 {
14244 }
14245 }
14250 arg_strict |=
14253 }
14256 {
14257 /* For deduction from an init-list we need the actual list. */
14262 }
14263 }
14265 /* For each parameter pack, collect the deduced value. */
14267 {
14273 }
14274 }
14276 /* Verify that the results of unification with the parameter packs
14277 produce results consistent with what we've seen before, and make
14278 the deduced argument packs available. */
14280 {
14287 /* By default keep the original deduced argument pack.
14288 If necessary, more specific code is going to update the
14289 resulting deduced argument later down in this function. */
14293 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
14294 actually deduce anything. */
14302 {
14303 /* Prepend the explicit arguments onto NEW_ARGS. */
14309 /* Copy the explicit arguments. */
14314 /* Copy the deduced arguments. */
14318 }
14321 {
14322 tree result;
14323 /* Build the deduced *_ARGUMENT_PACK. */
14325 {
14330 }
14331 else
14336 /* Note the deduced argument packs for this parameter
14337 pack. */
14339 }
14343 {
14344 /* We only had the explicitly-provided arguments before, but
14345 now we have a complete set of arguments. */
14351 }
14353 new_args))
14354 /* Inconsistent unification of this parameter pack. */
14356 }
14359 }
14361 /* Deduce the value of template parameters. TPARMS is the (innermost)
14362 set of template parameters to a template. TARGS is the bindings
14363 for those template parameters, as determined thus far; TARGS may
14364 include template arguments for outer levels of template parameters
14365 as well. PARM is a parameter to a template function, or a
14366 subcomponent of that parameter; ARG is the corresponding argument.
14367 This function attempts to match PARM with ARG in a manner
14368 consistent with the existing assignments in TARGS. If more values
14369 are deduced, then TARGS is updated.
14371 Returns 0 if the type deduction succeeds, 1 otherwise. The
14372 parameter STRICT is a bitwise or of the following flags:
14374 UNIFY_ALLOW_NONE:
14375 Require an exact match between PARM and ARG.
14376 UNIFY_ALLOW_MORE_CV_QUAL:
14377 Allow the deduced ARG to be more cv-qualified (by qualification
14378 conversion) than ARG.
14379 UNIFY_ALLOW_LESS_CV_QUAL:
14380 Allow the deduced ARG to be less cv-qualified than ARG.
14381 UNIFY_ALLOW_DERIVED:
14382 Allow the deduced ARG to be a template base class of ARG,
14383 or a pointer to a template base class of the type pointed to by
14384 ARG.
14385 UNIFY_ALLOW_INTEGER:
14386 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
14387 case for more information.
14388 UNIFY_ALLOW_OUTER_LEVEL:
14389 This is the outermost level of a deduction. Used to determine validity
14390 of qualification conversions. A valid qualification conversion must
14391 have const qualified pointers leading up to the inner type which
14392 requires additional CV quals, except at the outer level, where const
14393 is not required [conv.qual]. It would be normal to set this flag in
14394 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
14395 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
14396 This is the outermost level of a deduction, and PARM can be more CV
14397 qualified at this point.
14398 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
14399 This is the outermost level of a deduction, and PARM can be less CV
14400 qualified at this point. */
14402 static int
14404 {
14406 tree targ;
14407 tree tparm;
14410 /* I don't think this will do the right thing with respect to types.
14411 But the only case I've seen it in so far has been array bounds, where
14412 signedness is the only information lost, and I think that will be
14413 okay. */
14421 /* We can't deduce anything from this, but we might get all the
14422 template args from other function args. */
14425 /* If PARM uses template parameters, then we can't bail out here,
14426 even if ARG == PARM, since we won't record unifications for the
14427 template parameters. We might need them if we're trying to
14428 figure out which of two things is more specialized. */
14432 /* Handle init lists early, so the rest of the function can assume
14433 we're dealing with a type. */
14435 {
14440 /* Replace T with std::initializer_list<T> for deduction. */
14446 /* We can only deduce from an initializer list argument if the
14447 parameter is std::initializer_list; otherwise this is a
14448 non-deduced context. */
14454 {
14457 {
14459 /* It should only be possible to get here for a call. */
14461 elt_strict |= maybe_adjust_types_for_deduction
14464 }
14468 }
14470 /* If the std::initializer_list<T> deduction worked, replace the
14471 deduced A with std::initializer_list<A>. */
14473 {
14478 }
14480 }
14482 /* Immediately reject some pairs that won't unify because of
14483 cv-qualification mismatches. */
14486 /* It is the elements of the array which hold the cv quals of an array
14487 type, and the elements might be template type parms. We'll check
14488 when we recurse. */
14490 /* We check the cv-qualifiers when unifying with template type
14491 parameters below. We want to allow ARG `const T' to unify with
14492 PARM `T' for example, when computing which of two templates
14493 is more specialized, for example. */
14507 {
14511 /* In a type which contains a nested-name-specifier, template
14512 argument values cannot be deduced for template parameters used
14513 within the nested-name-specifier. */
14525 /* The PARM is not one we're trying to unify. Just check
14526 to see if it matches ARG. */
14533 /* Check for mixed types and values. */
14541 {
14542 /* ARG must be constructed from a template class or a template
14543 template parameter. */
14548 {
14551 tree parm_parms
14552 = DECL_INNERMOST_TEMPLATE_PARMS
14557 /* The resolution to DR150 makes clear that default
14558 arguments for an N-argument may not be used to bind T
14559 to a template template parameter with fewer than N
14560 parameters. It is not safe to permit the binding of
14561 default arguments as an extension, as that may change
14562 the meaning of a conforming program. Consider:
14564 struct Dense { static const unsigned int dim = 1; };
14566 template <template <typename> class View,
14567 typename Block>
14568 void operator+(float, View<Block> const&);
14570 template <typename Block,
14571 unsigned int Dim = Block::dim>
14572 struct Lvalue_proxy { operator float() const; };
14574 void
14575 test_1d (void) {
14576 Lvalue_proxy<Dense> p;
14577 float b;
14578 b + p;
14579 }
14581 Here, if Lvalue_proxy is permitted to bind to View, then
14582 the global operator+ will be used; if they are not, the
14583 Lvalue_proxy will be converted to float. */
14585 argvec,
14587 tf_none,
14593 /* Deduce arguments T, i from TT<T> or TT<i>.
14594 We check each element of PARMVEC and ARGVEC individually
14595 rather than the whole TREE_VEC since they can have
14596 different number of elements. */
14603 /* Check if the parameters end in a pack, making them
14604 variadic. */
14613 {
14617 UNIFY_ALLOW_NONE))
14619 }
14624 UNIFY_ALLOW_NONE,
14628 }
14631 /* Fall through to deduce template name. */
14632 }
14636 {
14637 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
14639 /* Simple cases: Value already set, does match or doesn't. */
14644 }
14645 else
14646 {
14647 /* If PARM is `const T' and ARG is only `int', we don't have
14648 a match unless we are allowing additional qualification.
14649 If ARG is `const int' and PARM is just `T' that's OK;
14650 that binds `const int' to `T'. */
14655 /* Consider the case where ARG is `const volatile int' and
14656 PARM is `const T'. Then, T should be `volatile int'. */
14657 arg = cp_build_qualified_type_real
14662 /* Simple cases: Value already set, does match or doesn't. */
14668 /* Make sure that ARG is not a variable-sized array. (Note
14669 that were talking about variable-sized arrays (like
14670 `int[n]'), rather than arrays of unknown size (like
14671 `int[]').) We'll get very confused by such a type since
14672 the bound of the array will not be computable in an
14673 instantiation. Besides, such types are not allowed in
14674 ISO C++, so we can do as we please here. */
14678 /* Strip typedefs as in convert_template_argument. */
14680 }
14682 /* If ARG is a parameter pack or an expansion, we cannot unify
14683 against it unless PARM is also a parameter pack. */
14688 /* If the argument deduction results is a METHOD_TYPE,
14689 then there is a problem.
14690 METHOD_TYPE doesn't map to any real C++ type the result of
14691 the deduction can not be of that type. */
14705 /* The PARM is not one we're trying to unify. Just check
14706 to see if it matches ARG. */
14716 /* [temp.deduct.type] If, in the declaration of a function template
14717 with a non-type template-parameter, the non-type
14718 template-parameter is used in an expression in the function
14719 parameter-list and, if the corresponding template-argument is
14720 deduced, the template-argument type shall match the type of the
14721 template-parameter exactly, except that a template-argument
14722 deduced from an array bound may be of any integral type.
14723 The non-type parameter might use already deduced type parameters. */
14726 /* Template-parameter dependent expression. Just accept it for now.
14727 It will later be processed in convert_template_argument. */
14728 ;
14734 /* Convert the ARG to the type of PARM; the deduced non-type
14735 template argument must exactly match the types of the
14736 corresponding parameter. */
14739 /* We haven't deduced the type of this parameter yet. Try again
14740 later. */
14742 else
14745 /* If ARG is a parameter pack or an expansion, we cannot unify
14746 against it unless PARM is also a parameter pack. */
14755 {
14756 /* A pointer-to-member constant can be unified only with
14757 another constant. */
14761 /* Just unify the class member. It would be useless (and possibly
14762 wrong, depending on the strict flags) to unify also
14763 PTRMEM_CST_CLASS, because we want to be sure that both parm and
14764 arg refer to the same variable, even if through different
14765 classes. For instance:
14767 struct A { int x; };
14768 struct B : A { };
14770 Unification of &A::x and &B::x must succeed. */
14773 }
14776 {
14780 /* [temp.deduct.call]
14782 A can be another pointer or pointer to member type that can
14783 be converted to the deduced A via a qualification
14784 conversion (_conv.qual_).
14786 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14787 This will allow for additional cv-qualification of the
14788 pointed-to types if appropriate. */
14791 /* The derived-to-base conversion only persists through one
14792 level of pointers. */
14797 }
14812 {
14813 tree parm_max;
14814 tree arg_max;
14818 /* Our representation of array types uses "N - 1" as the
14819 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14820 not an integer constant. We cannot unify arbitrarily
14821 complex expressions, so we eliminate the MINUS_EXPRs
14822 here. */
14826 {
14829 }
14833 {
14834 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14835 trying to unify the type of a variable with the type
14836 of a template parameter. For example:
14838 template <unsigned int N>
14839 void f (char (&) [N]);
14840 int g();
14841 void h(int i) {
14842 char a[g(i)];
14843 f(a);
14844 }
14846 Here, the type of the ARG will be "int [g(i)]", and
14847 may be a SAVE_EXPR, etc. */
14851 }
14853 /* If only one of the bounds used a MINUS_EXPR, compensate
14854 by adding one to the other bound. */
14857 integer_type_node,
14858 parm_max,
14859 integer_one_node);
14862 integer_type_node,
14863 arg_max,
14864 integer_one_node);
14868 }
14882 /* We have already checked cv-qualification at the top of the
14883 function. */
14887 /* As far as unification is concerned, this wins. Later checks
14888 will invalidate it if necessary. */
14891 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
14892 /* Type INTEGER_CST can come from ordinary constant template args. */
14902 {
14911 UNIFY_ALLOW_NONE))
14914 }
14922 {
14929 strict);
14930 }
14933 {
14937 {
14938 /* First, we try to unify the PARM and ARG directly. */
14943 {
14944 /* Fallback to the special case allowed in
14945 [temp.deduct.call]:
14947 If P is a class, and P has the form
14948 template-id, then A can be a derived class of
14949 the deduced A. Likewise, if P is a pointer to
14950 a class of the form template-id, A can be a
14951 pointer to a derived class pointed to by the
14952 deduced A. */
14957 }
14958 }
14962 /* Perhaps PARM is something like S<U> and ARG is S<int>.
14963 Then, we should unify `int' and `U'. */
14965 else
14966 /* There's no chance of unification succeeding. */
14971 }
14978 {
14981 tree a;
14987 /* CV qualifications for methods can never be deduced, they must
14988 match exactly. We need to check them explicitly here,
14989 because type_unification_real treats them as any other
14990 cv-qualified parameter. */
14992 && (!check_cv_quals_for_unify
15012 LOOKUP_NORMAL);
15013 }
15016 /* Unify a pointer to member with a pointer to member function, which
15017 deduces the type of the member as a function type. */
15019 {
15020 tree method_type;
15021 tree fntype;
15022 cp_cv_quals cv_quals;
15024 /* Check top-level cv qualifiers */
15032 /* Determine the type of the function we are unifying against. */
15034 fntype =
15038 /* Extract the cv-qualifiers of the member function from the
15039 implicit object parameter and place them on the function
15040 type to be restored later. */
15041 cv_quals =
15045 }
15053 strict);
15064 /* Matched cases are handled by the ARG == PARM test above. */
15068 /* A non-type template parameter that is a variable should be a
15069 an integral constant, in which case, it whould have been
15070 folded into its (constant) value. So we should not be getting
15071 a variable here. */
15076 {
15084 {
15086 {
15088 /* We can unify against something with a trailing
15089 parameter pack. */
15091 else
15092 /* Since there is something following the pack
15093 expansion, we cannot unify this template argument
15094 list. */
15096 }
15097 }
15100 /* If we don't have enough arguments to satisfy the parameters
15101 (not counting the pack expression at the end), or we have
15102 too many arguments for a parameter list that doesn't end in
15103 a pack expression, we can't unify. */
15108 /* Unify all of the parameters that precede the (optional)
15109 pack expression. */
15111 {
15115 }
15123 }
15129 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
15130 nodes. */
15134 /* Unification fails if we hit an error node. */
15140 /* We must be looking at an expression. This can happen with
15141 something like:
15143 template <int I>
15144 void foo(S<I>, S<I + 2>);
15146 This is a "nondeduced context":
15148 [deduct.type]
15150 The nondeduced contexts are:
15152 --A type that is a template-id in which one or more of
15153 the template-arguments is an expression that references
15154 a template-parameter.
15156 In these cases, we assume deduction succeeded, but don't
15157 actually infer any unifications. */
15162 else
15164 }
15165 }
15166 \f
15167 /* Note that DECL can be defined in this translation unit, if
15168 required. */
15170 static void
15172 {
15173 tree clone;
15177 }
15179 /* Called if RESULT is explicitly instantiated, or is a member of an
15180 explicitly instantiated class. */
15182 void
15184 {
15187 /* If this entity has already been written out, it's too late to
15188 make any modifications. */
15193 /* The TREE_PUBLIC flag for function declarations will have been
15194 set correctly by tsubst. */
15197 /* This might have been set by an earlier implicit instantiation. */
15202 else
15203 {
15205 /* Always make artificials weak. */
15208 /* For WIN32 we also want to put explicit instantiations in
15209 linkonce sections. */
15212 }
15214 /* If EXTERN_P, then this function will not be emitted -- unless
15215 followed by an explicit instantiation, at which point its linkage
15216 will be adjusted. If !EXTERN_P, then this function will be
15217 emitted here. In neither circumstance do we want
15218 import_export_decl to adjust the linkage. */
15220 }
15222 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
15223 important template arguments. If any are missing, we check whether
15224 they're important by using error_mark_node for substituting into any
15225 args that were used for partial ordering (the ones between ARGS and END)
15226 and seeing if it bubbles up. */
15228 static bool
15230 {
15235 {
15238 }
15240 {
15242 {
15246 }
15247 }
15249 }
15251 /* Given two function templates PAT1 and PAT2, return:
15253 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
15254 -1 if PAT2 is more specialized than PAT1.
15255 0 if neither is more specialized.
15257 LEN indicates the number of parameters we should consider
15258 (defaulted parameters should not be considered).
15260 The 1998 std underspecified function template partial ordering, and
15261 DR214 addresses the issue. We take pairs of arguments, one from
15262 each of the templates, and deduce them against each other. One of
15263 the templates will be more specialized if all the *other*
15264 template's arguments deduce against its arguments and at least one
15265 of its arguments *does* *not* deduce against the other template's
15266 corresponding argument. Deduction is done as for class templates.
15267 The arguments used in deduction have reference and top level cv
15268 qualifiers removed. Iff both arguments were originally reference
15269 types *and* deduction succeeds in both directions, the template
15270 with the more cv-qualified argument wins for that pairing (if
15271 neither is more cv-qualified, they both are equal). Unlike regular
15272 deduction, after all the arguments have been deduced in this way,
15273 we do *not* verify the deduced template argument values can be
15274 substituted into non-deduced contexts.
15276 The logic can be a bit confusing here, because we look at deduce1 and
15277 targs1 to see if pat2 is at least as specialized, and vice versa; if we
15278 can find template arguments for pat1 to make arg1 look like arg2, that
15279 means that arg2 is at least as specialized as arg1. */
15281 int
15283 {
15296 /* Remove the this parameter from non-static member functions. If
15297 one is a non-static member function and the other is not a static
15298 member function, remove the first parameter from that function
15299 also. This situation occurs for operator functions where we
15300 locate both a member function (with this pointer) and non-member
15301 operator (with explicit first operand). */
15303 {
15308 }
15310 {
15313 {
15314 len--;
15316 }
15317 }
15319 /* If only one is a conversion operator, they are unordered. */
15323 /* Consider the return type for a conversion function */
15325 {
15328 len++;
15329 }
15331 processing_template_decl++;
15337 /* Stop when an ellipsis is seen. */
15339 {
15348 {
15349 /* When both arguments are pack expansions, we need only
15350 unify the patterns themselves. */
15354 /* This is the last comparison we need to do. */
15356 }
15359 {
15362 }
15365 {
15368 }
15371 {
15372 /* Only of the args is a reference, see if we should apply
15373 array/function pointer decay to it. This is not part of
15374 DR214, but is, IMHO, consistent with the deduction rules
15375 for the function call itself, and with our earlier
15376 implementation of the underspecified partial ordering
15377 rules. (nathan). */
15379 {
15381 {
15384 /* FALLTHROUGH. */
15391 }
15392 }
15393 else
15394 {
15396 {
15399 /* FALLTHROUGH. */
15406 }
15407 }
15408 }
15414 {
15420 /* Setup the parameter vector, which contains only ARG1. */
15423 /* Setup the argument vector, which contains the remaining
15424 arguments. */
15433 /* We cannot deduce in the other direction, because ARG1 is
15434 a pack expansion but ARG2 is not. */
15436 }
15438 {
15444 /* Setup the parameter vector, which contains only ARG1. */
15447 /* Setup the argument vector, which contains the remaining
15448 arguments. */
15457 /* We cannot deduce in the other direction, because ARG2 is
15458 a pack expansion but ARG1 is not.*/
15460 }
15462 else
15463 {
15464 /* The normal case, where neither argument is a pack
15465 expansion. */
15468 }
15470 /* If we couldn't deduce arguments for tparms1 to make arg1 match
15471 arg2, then arg2 is not as specialized as arg1. */
15477 /* "If, for a given type, deduction succeeds in both directions
15478 (i.e., the types are identical after the transformations above)
15479 and if the type from the argument template is more cv-qualified
15480 than the type from the parameter template (as described above)
15481 that type is considered to be more specialized than the other. If
15482 neither type is more cv-qualified than the other then neither type
15483 is more specialized than the other." */
15487 {
15492 }
15495 /* We've failed to deduce something in either direction.
15496 These must be unordered. */
15501 /* We have already processed all of the arguments in our
15502 handing of the pack expansion type. */
15507 }
15509 /* "In most cases, all template parameters must have values in order for
15510 deduction to succeed, but for partial ordering purposes a template
15511 parameter may remain without a value provided it is not used in the
15512 types being used for partial ordering."
15514 Thus, if we are missing any of the targs1 we need to substitute into
15515 origs1, then pat2 is not as specialized as pat1. This can happen when
15516 there is a nondeduced context. */
15522 processing_template_decl--;
15524 /* All things being equal, if the next argument is a pack expansion
15525 for one function but not for the other, prefer the
15526 non-variadic function. FIXME this is bogus; see c++/41958. */
15530 {
15533 }
15539 else
15541 }
15543 /* Determine which of two partial specializations is more specialized.
15545 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
15546 to the first partial specialization. The TREE_VALUE is the
15547 innermost set of template parameters for the partial
15548 specialization. PAT2 is similar, but for the second template.
15550 Return 1 if the first partial specialization is more specialized;
15551 -1 if the second is more specialized; 0 if neither is more
15552 specialized.
15554 See [temp.class.order] for information about determining which of
15555 two templates is more specialized. */
15557 static int
15559 {
15560 tree targs;
15568 /* Just like what happens for functions, if we are ordering between
15569 different class template specializations, we may encounter dependent
15570 types in the arguments, and we need our dependency check functions
15571 to behave correctly. */
15577 {
15580 }
15586 {
15589 }
15592 /* In the case of a tie where at least one of the class templates
15593 has a parameter pack at the end, the template with the most
15594 non-packed parameters wins. */
15596 && any_deductions
15599 {
15605 /* We don't count the pack expansion at the end. */
15615 }
15618 }
15620 /* Return the template arguments that will produce the function signature
15621 DECL from the function template FN, with the explicit template
15622 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
15623 also match. Return NULL_TREE if no satisfactory arguments could be
15624 found. */
15626 static tree
15628 {
15631 tree decl_type;
15632 tree decl_arg_types;
15635 tree arg;
15637 /* Substitute the explicit template arguments into the type of DECL.
15638 The call to fn_type_unification will handle substitution into the
15639 FN. */
15642 {
15643 tree tmpl;
15644 tree converted_args;
15648 else
15649 /* We can get here for some invalid specializations. */
15652 converted_args
15655 tf_none,
15664 }
15666 /* Never do unification on the 'this' parameter. */
15685 }
15687 /* Return the innermost template arguments that, when applied to a
15688 template specialization whose innermost template parameters are
15689 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
15690 ARGS.
15692 For example, suppose we have:
15694 template <class T, class U> struct S {};
15695 template <class T> struct S<T*, int> {};
15697 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
15698 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
15699 int}. The resulting vector will be {double}, indicating that `T'
15700 is bound to `double'. */
15702 static tree
15704 {
15706 tree deduced_args;
15707 tree innermost_deduced_args;
15711 {
15715 innermost_deduced_args);
15716 }
15717 else
15723 UNIFY_ALLOW_NONE))
15730 /* Verify that nondeduced template arguments agree with the type
15731 obtained from argument deduction.
15733 For example:
15735 struct A { typedef int X; };
15736 template <class T, class U> struct C {};
15737 template <class T> struct C<T, typename T::X> {};
15739 Then with the instantiation `C<A, int>', we can deduce that
15740 `T' is `A' but unify () does not check whether `typename T::X'
15741 is `int'. */
15744 /* We only need to check the innermost arguments; the other
15745 arguments will always agree. */
15750 /* Now that we have bindings for all of the template arguments,
15751 ensure that the arguments deduced for the template template
15752 parameters have compatible template parameter lists. See the use
15753 of template_template_parm_bindings_ok_p in fn_type_unification
15754 for more information. */
15759 }
15761 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
15762 Return the TREE_LIST node with the most specialized template, if
15763 any. If there is no most specialized template, the error_mark_node
15764 is returned.
15766 Note that this function does not look at, or modify, the
15767 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
15768 returned is one of the elements of INSTANTIATIONS, callers may
15769 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
15770 and retrieve it from the value returned. */
15772 tree
15774 {
15781 {
15787 fate--;
15792 fate++;
15797 {
15798 /* Equally specialized, move to next function. If there
15799 is no next function, nothing's most specialized. */
15804 }
15805 }
15808 /* Now verify that champ is better than everything earlier in the
15809 instantiation list. */
15817 {
15820 }
15822 processing_template_decl--;
15828 }
15830 /* If DECL is a specialization of some template, return the most
15831 general such template. Otherwise, returns NULL_TREE.
15833 For example, given:
15835 template <class T> struct S { template <class U> void f(U); };
15837 if TMPL is `template <class U> void S<int>::f(U)' this will return
15838 the full template. This function will not trace past partial
15839 specializations, however. For example, given in addition:
15841 template <class T> struct S<T*> { template <class U> void f(U); };
15843 if TMPL is `template <class U> void S<int*>::f(U)' this will return
15844 `template <class T> template <class U> S<T*>::f(U)'. */
15846 tree
15848 {
15849 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15850 an immediate specialization. */
15852 {
15856 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15857 template friend. */
15862 }
15864 /* Look for more and more general templates. */
15866 {
15867 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15868 (See cp-tree.h for details.) */
15876 /* Stop if we run into an explicitly specialized class template. */
15883 }
15886 }
15888 /* Return the most specialized of the class template partial
15889 specializations of TMPL which can produce TYPE, a specialization of
15890 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
15891 a _TYPE node corresponding to the partial specialization, while the
15892 TREE_PURPOSE is the set of template arguments that must be
15893 substituted into the TREE_TYPE in order to generate TYPE.
15895 If the choice of partial specialization is ambiguous, a diagnostic
15896 is issued, and the error_mark_node is returned. If there are no
15897 partial specializations of TMPL matching TYPE, then NULL_TREE is
15898 returned. */
15900 static tree
15902 {
15904 tree t;
15905 tree champ;
15908 tree args;
15914 /* For determining which partial specialization to use, only the
15915 innermost args are interesting. */
15917 {
15920 }
15923 {
15924 tree partial_spec_args;
15925 tree spec_args;
15930 {
15935 /* Discard the outer levels of args, and then substitute in the
15936 template args from the enclosing class. */
15938 partial_spec_args = tsubst_template_args
15941 /* PARMS already refers to just the innermost parms, but the
15942 template parms in partial_spec_args had their levels lowered
15943 by tsubst, so we need to do the same for the parm list. We
15944 can't just tsubst the TREE_VEC itself, as tsubst wants to
15945 treat a TREE_VEC as an argument vector. */
15952 }
15954 partial_spec_args =
15957 partial_spec_args),
15966 partial_spec_args,
15967 args);
15969 {
15974 }
15975 }
15985 {
15988 ;
15989 else
15990 {
15992 {
15995 {
15998 }
15999 }
16001 }
16002 }
16006 {
16009 {
16012 }
16013 }
16016 {
16022 {
16025 }
16028 }
16031 }
16033 /* Explicitly instantiate DECL. */
16035 void
16037 {
16042 /* An error occurred, for which grokdeclarator has already issued
16043 an appropriate message. */
16046 {
16049 }
16051 {
16052 /* There is an asymmetry here in the way VAR_DECLs and
16053 FUNCTION_DECLs are handled by grokdeclarator. In the case of
16054 the latter, the DECL we get back will be marked as a
16055 template instantiation, and the appropriate
16056 DECL_TEMPLATE_INFO will be set up. This does not happen for
16057 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
16058 should handle VAR_DECLs as it currently handles
16059 FUNCTION_DECLs. */
16061 {
16064 }
16067 {
16070 }
16072 {
16077 }
16078 }
16080 {
16083 }
16084 else
16087 /* Check for various error cases. Note that if the explicit
16088 instantiation is valid the RESULT will currently be marked as an
16089 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
16090 until we get here. */
16093 {
16094 /* DR 259 [temp.spec].
16096 Both an explicit instantiation and a declaration of an explicit
16097 specialization shall not appear in a program unless the explicit
16098 instantiation follows a declaration of the explicit specialization.
16100 For a given set of template parameters, if an explicit
16101 instantiation of a template appears after a declaration of an
16102 explicit specialization for that template, the explicit
16103 instantiation has no effect. */
16105 }
16107 {
16108 /* [temp.spec]
16110 No program shall explicitly instantiate any template more
16111 than once.
16113 We check DECL_NOT_REALLY_EXTERN so as not to complain when
16114 the first instantiation was `extern' and the second is not,
16115 and EXTERN_P for the opposite case. */
16118 /* If an "extern" explicit instantiation follows an ordinary
16119 explicit instantiation, the template is instantiated. */
16122 }
16124 {
16127 }
16129 {
16132 }
16135 ;
16137 {
16140 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
16143 }
16144 else
16152 }
16154 static void
16156 {
16162 {
16165 }
16166 }
16168 /* Called from do_type_instantiation through binding_table_foreach to
16169 do recursive instantiation for the type bound in ENTRY. */
16170 static void
16172 {
16178 }
16180 /* Called from do_type_instantiation to instantiate a member
16181 (a member function or a static member variable) of an
16182 explicitly instantiated class template. */
16183 static void
16185 {
16190 }
16192 /* Perform an explicit instantiation of template class T. STORAGE, if
16193 non-null, is the RID for extern, inline or static. COMPLAIN is
16194 nonzero if this is called from the parser, zero if called recursively,
16195 since the standard is unclear (as detailed below). */
16197 void
16199 {
16209 {
16212 }
16217 {
16220 t);
16222 }
16225 {
16227 {
16229 {
16232 "ISO C++ 1998 forbids the use of %<extern%> on "
16234 }
16235 else
16237 "ISO C++ forbids the use of %qE"
16239 }
16247 else
16248 {
16250 storage);
16252 }
16253 }
16256 {
16257 /* DR 259 [temp.spec].
16259 Both an explicit instantiation and a declaration of an explicit
16260 specialization shall not appear in a program unless the explicit
16261 instantiation follows a declaration of the explicit specialization.
16263 For a given set of template parameters, if an explicit
16264 instantiation of a template appears after a declaration of an
16265 explicit specialization for that template, the explicit
16266 instantiation has no effect. */
16268 }
16270 {
16271 /* [temp.spec]
16273 No program shall explicitly instantiate any template more
16274 than once.
16276 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
16277 instantiation was `extern'. If EXTERN_P then the second is.
16278 These cases are OK. */
16285 /* If we've already instantiated the template, just return now. */
16288 }
16296 {
16297 tree tmp;
16299 /* In contrast to implicit instantiation, where only the
16300 declarations, and not the definitions, of members are
16301 instantiated, we have here:
16303 [temp.explicit]
16305 The explicit instantiation of a class template specialization
16306 implies the instantiation of all of its members not
16307 previously explicitly specialized in the translation unit
16308 containing the explicit instantiation.
16310 Of course, we can't instantiate member template classes, since
16311 we don't have any arguments for them. Note that the standard
16312 is unclear on whether the instantiation of the members are
16313 *explicit* instantiations or not. However, the most natural
16314 interpretation is that it should be an explicit instantiation. */
16329 }
16330 }
16332 /* Given a function DECL, which is a specialization of TMPL, modify
16333 DECL to be a re-instantiation of TMPL with the same template
16334 arguments. TMPL should be the template into which tsubst'ing
16335 should occur for DECL, not the most general template.
16337 One reason for doing this is a scenario like this:
16339 template <class T>
16340 void f(const T&, int i);
16342 void g() { f(3, 7); }
16344 template <class T>
16345 void f(const T& t, const int i) { }
16347 Note that when the template is first instantiated, with
16348 instantiate_template, the resulting DECL will have no name for the
16349 first parameter, and the wrong type for the second. So, when we go
16350 to instantiate the DECL, we regenerate it. */
16352 static void
16354 {
16355 /* The arguments used to instantiate DECL, from the most general
16356 template. */
16357 tree args;
16358 tree code_pattern;
16363 /* Make sure that we can see identifiers, and compute access
16364 correctly. */
16368 {
16369 tree decl_parm;
16370 tree pattern_parm;
16371 tree specs;
16384 specs);
16386 /* Merge parameter declarations. */
16389 pattern_parm
16393 {
16394 tree parm_type;
16395 tree attributes;
16400 NULL_TREE);
16406 {
16409 }
16412 }
16413 /* Merge any parameters that match with the function parameter
16414 pack. */
16416 {
16418 tree expanded_types;
16419 /* Expand the TYPE_PACK_EXPANSION that provides the types for
16420 the parameters in this function parameter pack. */
16425 {
16426 tree parm_type;
16427 tree attributes;
16430 /* Rename the parameter to include the index. */
16439 {
16442 }
16444 }
16445 }
16446 /* Merge additional specifiers from the CODE_PATTERN. */
16450 }
16456 else
16460 }
16462 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
16463 substituted to get DECL. */
16465 tree
16467 {
16470 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
16471 for the instantiation. This is not always the most general
16472 template. Consider, for example:
16474 template <class T>
16475 struct S { template <class U> void f();
16476 template <> void f<int>(); };
16478 and an instantiation of S<double>::f<int>. We want TD to be the
16479 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
16481 more general template. */
16483 /* We must also deal with friend templates. Given:
16485 template <class T> struct S {
16486 template <class U> friend void f() {};
16487 };
16489 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
16490 so far as the language is concerned, but that's still
16491 where we get the pattern for the instantiation from. On
16492 other hand, if the definition comes outside the class, say:
16494 template <class T> struct S {
16495 template <class U> friend void f();
16496 };
16497 template <class U> friend void f() {}
16499 we don't need to look any further. That's what the check for
16500 DECL_INITIAL is for. */
16504 {
16505 /* The present template, TD, should not be a definition. If it
16506 were a definition, we should be using it! Note that we
16507 cannot restructure the loop to just keep going until we find
16508 a template with a definition, since that might go too far if
16509 a specialization was declared, but not defined. */
16513 /* Fetch the more general template. */
16515 }
16518 }
16520 /* Returns true if we need to instantiate this template instance even if we
16521 know we aren't going to emit it.. */
16523 bool
16525 {
16526 /* We always instantiate inline functions so that we can inline them. An
16527 explicit instantiation declaration prohibits implicit instantiation of
16528 non-inline functions. With high levels of optimization, we would
16529 normally inline non-inline functions -- but we're not allowed to do
16530 that for "extern template" functions. Therefore, we check
16531 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
16534 /* And we need to instantiate static data members so that
16535 their initializers are available in integral constant
16536 expressions. */
16539 }
16541 /* Produce the definition of D, a _DECL generated from a template. If
16542 DEFER_OK is nonzero, then we don't have to actually do the
16543 instantiation now; we just have to do it sometime. Normally it is
16544 an error if this is an explicit instantiation but D is undefined.
16545 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
16546 explicitly instantiated class template. */
16548 tree
16551 {
16553 tree gen_args;
16554 tree args;
16555 tree td;
16556 tree code_pattern;
16557 tree spec;
16558 tree gen_tmpl;
16564 /* This function should only be used to instantiate templates for
16565 functions and static member variables. */
16569 /* Variables are never deferred; if instantiation is required, they
16570 are instantiated right away. That allows for better code in the
16571 case that an expression refers to the value of the variable --
16572 if the variable has a constant value the referring expression can
16573 take advantage of that fact. */
16577 /* Don't instantiate cloned functions. Instead, instantiate the
16578 functions they cloned. */
16584 /* D has already been instantiated or explicitly specialized, so
16585 there's nothing for us to do here.
16587 It might seem reasonable to check whether or not D is an explicit
16588 instantiation, and, if so, stop here. But when an explicit
16589 instantiation is deferred until the end of the compilation,
16590 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
16591 the instantiation. */
16594 /* Check to see whether we know that this template will be
16595 instantiated in some other file, as with "extern template"
16596 extension. */
16599 /* In general, we do not instantiate such templates. */
16607 /* We should already have the extra args. */
16610 /* And what's in the hash table should match D. */
16614 /* This needs to happen before any tsubsting. */
16620 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
16621 for the instantiation. */
16625 /* We should never be trying to instantiate a member of a class
16626 template or partial specialization. */
16631 /* In the case of a friend template whose definition is provided
16632 outside the class, we may have too many arguments. Drop the
16633 ones we don't need. The same is true for specializations. */
16634 args = get_innermost_template_args
16636 else
16641 else
16644 /* We may be in the middle of deferred access check. Disable it now. */
16647 /* Unless an explicit instantiation directive has already determined
16648 the linkage of D, remember that a definition is available for
16649 this entity. */
16657 /* If D is a member of an explicitly instantiated class template,
16658 and no definition is available, treat it like an implicit
16659 instantiation. */
16662 {
16666 }
16668 /* Recheck the substitutions to obtain any warning messages
16669 about ignoring cv qualifiers. Don't do this for artificial decls,
16670 as it breaks the context-sensitive substitution for lambda op(). */
16672 {
16676 /* Make sure that we can see identifiers, and compute access
16677 correctly. D is already the target FUNCTION_DECL with the
16678 right context. */
16682 {
16685 d);
16686 /* Don't simply tsubst the function type, as that will give
16687 duplicate warnings about poor parameter qualifications.
16688 The function arguments are the same as the decl_arguments
16689 without the top level cv qualifiers. */
16691 }
16695 }
16697 /* Defer all other templates, unless we have been explicitly
16698 forbidden from doing so. */
16700 template. */
16701 ! pattern_defined
16702 /* If it's OK to postpone instantiation, do so. */
16703 || defer_ok
16704 /* If this is a static data member that will be defined
16705 elsewhere, we don't want to instantiate the entire data
16706 member, but we do want to instantiate the initializer so that
16707 we can substitute that elsewhere. */
16709 {
16710 /* The definition of the static data member is now required so
16711 we must substitute the initializer. */
16715 {
16716 tree ns;
16717 tree init;
16723 args,
16728 LOOKUP_ONLYCONVERTING);
16731 }
16733 /* We restore the source position here because it's used by
16734 add_pending_template. */
16740 /* [temp.explicit]
16742 The definition of a non-exported function template, a
16743 non-exported member function template, or a non-exported
16744 member function or static data member of a class template
16745 shall be present in every translation unit in which it is
16746 explicitly instantiated. */
16750 /* ??? Historically, we have instantiated inline functions, even
16751 when marked as "extern template". */
16755 }
16756 /* Tell the repository that D is available in this translation unit
16757 -- and see if it is supposed to be instantiated here. */
16759 {
16760 /* In a PCH file, despite the fact that the repository hasn't
16761 requested instantiation in the PCH it is still possible that
16762 an instantiation will be required in a file that includes the
16763 PCH. */
16766 /* Instantiate inline functions so that the inliner can do its
16767 job, even though we'll not be emitting a copy of this
16768 function. */
16771 }
16777 /* Mark D as instantiated so that recursive calls to
16778 instantiate_decl do not try to instantiate it again. */
16781 /* Regenerate the declaration in case the template has been modified
16782 by a subsequent redeclaration. */
16785 /* We already set the file and line above. Reset them now in case
16786 they changed as a result of calling regenerate_decl_from_template. */
16790 {
16791 tree init;
16793 /* Clear out DECL_RTL; whatever was there before may not be right
16794 since we've reset the type of the declaration. */
16798 /* The initializer is placed in DECL_INITIAL by
16799 regenerate_decl_from_template. Pull it out so that
16800 cp_finish_decl can process it. */
16805 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
16806 initializer. That function will defer actual emission until
16807 we have a chance to determine linkage. */
16810 /* Enter the scope of D so that access-checking works correctly. */
16814 }
16816 {
16817 htab_t saved_local_specializations;
16818 tree subst_decl;
16819 tree tmpl_parm;
16820 tree spec_parm;
16822 /* Save away the current list, in case we are instantiating one
16823 template from within the body of another. */
16826 /* Set up the list of local specializations. */
16828 hash_local_specialization,
16829 eq_local_specializations,
16830 NULL);
16832 /* Set up context. */
16835 /* Create substitution entries for the parameters. */
16840 {
16844 }
16846 {
16850 }
16852 {
16853 /* Register the (value) argument pack as a specialization of
16854 TMPL_PARM, then move on. */
16859 }
16862 /* Substitute into the body of the function. */
16867 /* Set the current input_location to the end of the function
16868 so that finish_function knows where we are. */
16871 /* We don't need the local specializations any more. */
16875 /* Finish the function. */
16878 }
16880 /* We're not deferring instantiation any more. */
16886 out:
16894 }
16896 /* Run through the list of templates that we wish we could
16897 instantiate, and instantiate any we can. RETRIES is the
16898 number of times we retry pending template instantiation. */
16900 void
16902 {
16906 /* Instantiating templates may trigger vtable generation. This in turn
16907 may require further template instantiations. We place a limit here
16908 to avoid infinite loop. */
16910 {
16914 " instantiating %q+D, possibly from virtual table generation"
16918 /* Pretend that we defined it. */
16921 }
16923 do
16924 {
16929 {
16934 {
16935 tree fn;
16938 {
16942 fn;
16950 }
16953 }
16954 else
16955 {
16958 {
16959 instantiation
16965 }
16969 }
16972 /* If INSTANTIATION has been instantiated, then we don't
16973 need to consider it again in the future. */
16975 else
16976 {
16979 }
16982 }
16984 }
16988 }
16990 /* Substitute ARGVEC into T, which is a list of initializers for
16991 either base class or a non-static data member. The TREE_PURPOSEs
16992 are DECLs, and the TREE_VALUEs are the initializer values. Used by
16993 instantiate_decl. */
16995 static tree
16997 {
17001 {
17002 tree decl;
17003 tree init;
17009 {
17010 tree expr;
17011 tree arg;
17013 /* Expand the base class expansion type into separate base
17014 classes. */
17016 tf_warning_or_error,
17017 NULL_TREE);
17021 /* We'll be building separate TREE_LISTs of arguments for
17022 each base. */
17028 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
17029 expand each argument in the TREE_VALUE of t. */
17035 /* VOID_TYPE_NODE is used to indicate
17036 value-initialization. */
17037 {
17040 }
17041 else
17042 {
17043 /* Substitute parameter packs into each argument in the
17044 TREE_LIST. */
17047 {
17048 tree expanded_exprs;
17050 /* Expand the argument. */
17052 expanded_exprs
17054 tf_warning_or_error,
17055 NULL_TREE);
17059 /* Prepend each of the expanded expressions to the
17060 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
17062 {
17067 }
17068 }
17071 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
17072 since we built them backwards. */
17074 {
17077 }
17078 }
17079 }
17082 {
17084 {
17088 }
17089 else
17090 {
17102 }
17105 {
17109 }
17110 }
17111 }
17113 }
17115 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
17117 static void
17119 {
17124 else
17126 }
17128 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
17129 is the instantiation (which should have been created with
17130 start_enum) and ARGS are the template arguments to use. */
17132 static void
17134 {
17135 tree e;
17138 {
17139 tree value;
17140 tree decl;
17143 /* Note that in a template enum, the TREE_VALUE is the
17144 CONST_DECL, not the corresponding INTEGER_CST. */
17149 /* Give this enumeration constant the correct access. */
17152 /* Actually build the enumerator itself. */
17154 }
17159 }
17161 /* DECL is a FUNCTION_DECL that is a template specialization. Return
17162 its type -- but without substituting the innermost set of template
17163 arguments. So, innermost set of template parameters will appear in
17164 the type. */
17166 tree
17168 {
17169 tree fn_type;
17170 tree tmpl;
17171 tree targs;
17172 tree tparms;
17180 /* There should be as many levels of arguments as there are levels
17181 of parameters. */
17187 /* No substitution is necessary. */
17188 ;
17189 else
17190 {
17192 tree partial_args;
17194 /* Replace the innermost level of the TARGS with NULL_TREEs to
17195 let tsubst know not to substitute for those parameters. */
17204 /* Disable access control as this function is used only during
17205 name-mangling. */
17210 /* Now, do the (partial) substitution to figure out the
17211 appropriate function type. */
17215 /* Substitute into the template parameters to obtain the real
17216 innermost set of parameters. This step is important if the
17217 innermost set of template parameters contains value
17218 parameters whose types depend on outer template parameters. */
17223 }
17226 }
17228 /* Return truthvalue if we're processing a template different from
17229 the last one involved in diagnostics. */
17230 int
17232 {
17234 }
17236 /* Remember current template involved in diagnostics. */
17237 void
17239 {
17241 }
17245 {
17247 }
17249 /* [temp.param] Check that template non-type parm TYPE is of an allowable
17250 type. Return zero for ok, nonzero for disallowed. Issue error and
17251 warning messages under control of COMPLAIN. */
17253 static int
17255 {
17270 }
17272 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
17273 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
17275 static bool
17277 {
17278 tree scope;
17280 /* [temp.dep.type]
17282 A type is dependent if it is:
17284 -- a template parameter. Template template parameters are types
17285 for us (since TYPE_P holds true for them) so we handle
17286 them here. */
17290 /* -- a qualified-id with a nested-name-specifier which contains a
17291 class-name that names a dependent type or whose unqualified-id
17292 names a dependent type. */
17295 /* -- a cv-qualified type where the cv-unqualified type is
17296 dependent. */
17298 /* -- a compound type constructed from any dependent type. */
17308 {
17309 tree arg_type;
17314 arg_type;
17319 }
17320 /* -- an array type constructed from any dependent type or whose
17321 size is specified by a constant expression that is
17322 value-dependent. */
17324 {
17329 }
17332 {
17333 /* If this is the TYPE_DOMAIN of an array type, consider it
17334 dependent. We already checked for value-dependence in
17335 compute_array_index_type. */
17337 }
17339 /* -- a template-id in which either the template name is a template
17340 parameter ... */
17343 /* ... or any of the template arguments is a dependent type or
17344 an expression that is type-dependent or value-dependent. */
17346 && (any_dependent_template_arguments_p
17350 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
17351 argument of the `typeof' expression is not type-dependent, then
17352 it should already been have resolved. */
17357 /* A template argument pack is dependent if any of its packed
17358 arguments are. */
17360 {
17366 }
17368 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
17369 be template parameters. */
17373 /* The standard does not specifically mention types that are local
17374 to template functions or local classes, but they should be
17375 considered dependent too. For example:
17377 template <int I> void f() {
17378 enum E { a = I };
17379 S<sizeof (E)> s;
17380 }
17382 The size of `E' cannot be known until the value of `I' has been
17383 determined. Therefore, `E' must be considered dependent. */
17390 /* Other types are non-dependent. */
17392 }
17394 /* Returns TRUE if TYPE is dependent, in the sense of
17395 [temp.dep.type]. */
17397 bool
17399 {
17400 /* If there are no template parameters in scope, then there can't be
17401 any dependent types. */
17403 {
17404 /* If we are not processing a template, then nobody should be
17405 providing us with a dependent type. */
17409 }
17411 /* If the type is NULL, we have not computed a type for the entity
17412 in question; in that case, the type is dependent. */
17416 /* Erroneous types can be considered non-dependent. */
17420 /* If we have not already computed the appropriate value for TYPE,
17421 do so now. */
17423 {
17426 }
17429 }
17431 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
17432 lookup. In other words, a dependent type that is not the current
17433 instantiation. */
17435 bool
17437 {
17440 }
17442 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
17444 static bool
17446 {
17447 tree scope;
17448 tree name;
17458 /* [temp.dep.expr]
17460 An id-expression is type-dependent if it contains a
17461 nested-name-specifier that contains a class-name that names a
17462 dependent type. */
17463 /* The suggested resolution to Core Issue 224 implies that if the
17464 qualifying type is the current class, then we must peek
17465 inside it. */
17474 }
17476 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
17477 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
17478 expression. */
17480 bool
17482 {
17486 /* A name declared with a dependent type. */
17491 {
17493 /* A name that has not been looked up -- must be dependent. */
17497 /* A non-type template parm. */
17501 /* A non-type template parm. */
17507 /* A constant with integral or enumeration type and is initialized
17508 with an expression that is value-dependent. */
17520 /* These expressions are value-dependent if the type to which
17521 the cast occurs is dependent or the expression being casted
17522 is value-dependent. */
17523 {
17529 /* A functional cast has a list of operands. */
17532 {
17533 /* If there are no operands, it must be an expression such
17534 as "int()". This should not happen for aggregate types
17535 because it would form non-constant expressions. */
17539 }
17545 }
17549 /* A `sizeof' expression is value-dependent if the operand is
17550 type-dependent or is a pack expansion. */
17566 /* A CALL_EXPR may appear in a constant expression if it is a
17567 call to a builtin function, e.g., __builtin_constant_p. All
17568 such calls are value-dependent. */
17572 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
17573 is value-dependent. */
17574 {
17583 }
17586 {
17590 }
17597 /* A constant expression is value-dependent if any subexpression is
17598 value-dependent. */
17600 {
17610 || (value_dependent_expression_p
17615 {
17618 /* In some cases, some of the operands may be missing.
17619 (For example, in the case of PREDECREMENT_EXPR, the
17620 amount to increment by may be missing.) That doesn't
17621 make the expression dependent. */
17623 && (value_dependent_expression_p
17627 }
17631 }
17632 }
17634 /* The expression is not value-dependent. */
17636 }
17638 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
17639 [temp.dep.expr]. */
17641 bool
17643 {
17650 /* An unresolved name is always dependent. */
17655 /* Some expression forms are never type-dependent. */
17666 /* The types of these expressions depends only on the type to which
17667 the cast occurs. */
17675 /* The types of these expressions depends only on the type created
17676 by the expression. */
17679 {
17680 /* For NEW_EXPR tree nodes created inside a template, either
17681 the object type itself or a TREE_LIST may appear as the
17682 operand 1. */
17685 /* This is an array type. We need to check array dimensions
17686 as well. */
17688 || value_dependent_expression_p
17690 else
17692 }
17696 type_dependent_expression_p))
17702 && (any_dependent_template_arguments_p
17714 {
17715 tree elt;
17719 {
17722 }
17724 }
17727 {
17732 {
17738 }
17739 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
17747 {
17752 }
17757 {
17761 }
17763 }
17768 }
17770 /* Like type_dependent_expression_p, but it also works while not processing
17771 a template definition, i.e. during substitution or mangling. */
17773 bool
17775 {
17781 }
17783 /* Returns TRUE if ARGS contains a type-dependent expression. */
17785 bool
17787 {
17789 tree arg;
17792 {
17795 }
17797 }
17799 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
17800 expressions) contains any value-dependent expressions. */
17802 bool
17804 {
17810 }
17812 /* Returns TRUE if the ARG (a template argument) is dependent. */
17814 bool
17816 {
17824 {
17828 {
17831 }
17834 }
17837 else
17840 }
17842 /* Returns true if ARGS (a collection of template arguments) contains
17843 any types that require structural equality testing. */
17845 bool
17847 {
17857 {
17860 {
17866 {
17867 /* Look inside the argument pack. */
17870 }
17873 {
17887 }
17888 }
17889 }
17892 }
17894 /* Returns true if ARGS (a collection of template arguments) contains
17895 any dependent arguments. */
17897 bool
17899 {
17909 {
17914 }
17917 }
17919 /* Returns TRUE if the template TMPL is dependent. */
17921 bool
17923 {
17925 {
17927 {
17931 }
17933 }
17935 /* Template template parameters are dependent. */
17939 /* So are names that have not been looked up. */
17943 /* So are member templates of dependent classes. */
17947 }
17949 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
17951 bool
17953 {
17956 }
17958 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
17959 is dependent. */
17961 bool
17963 {
17970 {
17991 {
17995 }
17999 {
18003 {
18008 }
18009 }
18010 }
18013 }
18015 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
18016 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
18017 no such TYPE can be found. Note that this function peers inside
18018 uninstantiated templates and therefore should be used only in
18019 extremely limited situations. ONLY_CURRENT_P restricts this
18020 peering to the currently open classes hierarchy (which is required
18021 when comparing types). */
18023 tree
18025 {
18026 tree scope;
18027 tree name;
18028 tree decl;
18030 tree pushed_scope;
18031 tree result;
18036 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
18037 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
18038 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
18039 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
18040 identifier of the TYPENAME_TYPE anymore.
18041 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
18042 TYPENAME_TYPE instead, we avoid messing up with a possible
18043 typedef variant case. */
18046 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
18047 it first before we can figure out what NAME refers to. */
18050 /* If we don't know what SCOPE refers to, then we cannot resolve the
18051 TYPENAME_TYPE. */
18054 /* If the SCOPE is a template type parameter, we have no way of
18055 resolving the name. */
18058 /* If the SCOPE is not the current instantiation, there's no reason
18059 to look inside it. */
18062 /* If this is a typedef, we don't want to look inside (c++/11987). */
18065 /* If SCOPE isn't the template itself, it will not have a valid
18066 TYPE_FIELDS list. */
18068 /* scope is either the template itself or a compatible instantiation
18069 like X<T>, so look up the name in the original template. */
18071 else
18072 /* scope is a partial instantiation, so we can't do the lookup or we
18073 will lose the template arguments. */
18075 /* Enter the SCOPE so that name lookup will be resolved as if we
18076 were in the class definition. In particular, SCOPE will no
18077 longer be considered a dependent type. */
18079 /* Look up the declaration. */
18084 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
18085 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
18090 {
18094 }
18097 {
18098 tree tmpl;
18099 tree args;
18100 /* Obtain the template and the arguments. */
18103 /* Instantiate the template. */
18109 }
18111 /* Leave the SCOPE. */
18115 /* If we failed to resolve it, return the original typename. */
18119 /* If lookup found a typename type, resolve that too. */
18121 {
18122 /* Ill-formed programs can cause infinite recursion here, so we
18123 must catch that. */
18127 }
18129 /* Qualify the resulting type. */
18135 }
18137 /* EXPR is an expression which is not type-dependent. Return a proxy
18138 for EXPR that can be used to compute the types of larger
18139 expressions containing EXPR. */
18141 tree
18143 {
18144 tree inner_expr;
18146 /* Preserve null pointer constants so that the type of things like
18147 "p == 0" where "p" is a pointer can be determined. */
18150 /* Preserve OVERLOADs; the functions must be available to resolve
18151 types. */
18162 /* There is no need to return a proxy for a variable. */
18165 /* Preserve string constants; conversions from string constants to
18166 "char *" are allowed, even though normally a "const char *"
18167 cannot be used to initialize a "char *". */
18170 /* Preserve arithmetic constants, as an optimization -- there is no
18171 reason to create a new node. */
18174 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
18175 There is at least one place where we want to know that a
18176 particular expression is a throw-expression: when checking a ?:
18177 expression, there are special rules if the second or third
18178 argument is a throw-expression. */
18197 /* If the type is unknown, it can't really be non-dependent */
18200 /* Otherwise, build a NON_DEPENDENT_EXPR.
18202 REFERENCE_TYPEs are not stripped for expressions in templates
18203 because doing so would play havoc with mangling. Consider, for
18204 example:
18206 template <typename T> void f<T& g>() { g(); }
18208 In the body of "f", the expression for "g" will have
18209 REFERENCE_TYPE, even though the standard says that it should
18210 not. The reason is that we must preserve the syntactic form of
18211 the expression so that mangling (say) "f<g>" inside the body of
18212 "f" works out correctly. Therefore, the REFERENCE_TYPE is
18213 stripped here. */
18215 }
18217 /* ARGS is a vector of expressions as arguments to a function call.
18218 Replace the arguments with equivalent non-dependent expressions.
18219 This modifies ARGS in place. */
18221 void
18223 {
18225 tree arg;
18228 {
18232 }
18233 }
18235 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
18236 with a level one deeper than the actual template parms. */
18238 tree
18240 {
18253 }
18255 /* Given type ARG, return std::initializer_list<ARG>. */
18257 static tree
18259 {
18260 tree std_init_list = namespace_binding
18262 tree argvec;
18264 {
18268 }
18273 }
18275 /* Replace auto in TYPE with std::initializer_list<auto>. */
18277 static tree
18279 {
18286 }
18288 /* walk_tree helper for do_auto_deduction. */
18290 static tree
18293 {
18294 /* Is this a variable with the type we're looking for? */
18298 else
18300 }
18302 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
18303 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
18305 tree
18307 {
18310 tree decl;
18313 /* The name of the object being declared shall not appear in the
18314 initializer expression. */
18317 {
18321 }
18323 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
18324 with either a new invented type template parameter U or, if the
18325 initializer is a braced-init-list (8.5.4), with
18326 std::initializer_list<U>. */
18339 {
18342 }
18344 /* If the list of declarators contains more than one declarator, the type
18345 of each declared variable is determined as described above. If the
18346 type deduced for the template parameter U is not the same in each
18347 deduction, the program is ill-formed. */
18350 {
18354 }
18360 }
18362 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
18363 result. */
18365 tree
18367 {
18368 tree argvec;
18377 }
18379 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
18381 bool
18383 {
18387 else
18389 }
18391 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
18392 appear as a type-specifier for the declaration in question, we don't
18393 have to look through the whole type. */
18395 tree
18397 {
18414 }
18416 /* For a given template T, return the vector of typedefs referenced
18417 in T for which access check is needed at T instantiation time.
18418 T is either a FUNCTION_DECL or a RECORD_TYPE.
18419 Those typedefs were added to T by the function
18420 append_type_to_template_for_access_check. */
18424 {
18425 tree ti;
18436 {
18441 }
18444 }
18446 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
18447 tied to T. That list of typedefs will be access checked at
18448 T instantiation time.
18449 T is either a FUNCTION_DECL or a RECORD_TYPE.
18450 TYPE_DECL is a TYPE_DECL node representing a typedef.
18451 SCOPE is the scope through which TYPE_DECL is accessed.
18452 LOCATION is the location of the usage point of TYPE_DECL.
18454 This function is a subroutine of
18455 append_type_to_template_for_access_check. */
18457 static void
18459 tree type_decl,
18460 tree scope,
18461 location_t location)
18462 {
18463 qualified_typedef_usage_t typedef_usage;
18464 tree ti;
18471 && type_decl
18487 }
18489 /* Append TYPE_DECL to the template TEMPL.
18490 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
18491 At TEMPL instanciation time, TYPE_DECL will be checked to see
18492 if it can be accessed through SCOPE.
18493 LOCATION is the location of the usage point of TYPE_DECL.
18495 e.g. consider the following code snippet:
18497 class C
18498 {
18499 typedef int myint;
18500 };
18502 template<class U> struct S
18503 {
18504 C::myint mi; // <-- usage point of the typedef C::myint
18505 };
18507 S<char> s;
18509 At S<char> instantiation time, we need to check the access of C::myint
18510 In other words, we need to check the access of the myint typedef through
18511 the C scope. For that purpose, this function will add the myint typedef
18512 and the scope C through which its being accessed to a list of typedefs
18513 tied to the template S. That list will be walked at template instantiation
18514 time and access check performed on each typedefs it contains.
18515 Note that this particular code snippet should yield an error because
18516 myint is private to C. */
18518 void
18520 tree type_decl,
18521 tree scope,
18522 location_t location)
18523 {
18529 /* Make sure we don't append the type to the template twice. */
18540 }
18542 /* Set up the hash tables for template instantiations. */
18544 void
18546 {
18548 hash_specialization,
18549 eq_specializations,
18550 ggc_free);
18552 hash_specialization,
18553 eq_specializations,
18554 ggc_free);
18555 }
18557 /* Print stats about the template hash tables for -fstats. */
18559 void
18561 {
18570 }