| blob | 52b123cb3117bc11defdb92804b1f8e759b3a156 |
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". */
50 /* The type of functions taking a tree, and some additional data, and
51 returning an int. */
54 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work. */
60 };
65 /* The PENDING_ATTRIBUTE is a list node that records an attribute whose
66 instantiation has been deferred until the whole class has been
67 instantiated. This deferral currently only happens to the lock attributes
68 whose arguments could be data members declared later in the class
69 specification, as shown in the following example:
71 template <typename T>
72 class Bar {
73 T shared_var GUARDED_BY(lock);
74 Mutex lock;
75 }; */
77 tree decl;
78 tree attributes;
80 tree args;
81 tsubst_flags_t complain;
82 tree in_decl;
84 };
98 /* Live only within one (recursive) call to tsubst_expr. We use
99 this to pass the statement expression node from the STMT_EXPR
100 to the EXPR_STMT that is its result. */
103 /* A map from local variable declarations in the body of the template
104 presently being instantiated to the corresponding instantiated
105 local variables. */
108 /* Contains canonical template parameter types. The vector is indexed by
109 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
110 TREE_LIST, whose TREE_VALUEs contain the canonical template
111 parameters of various types and levels. */
114 #define UNIFY_ALLOW_NONE 0
115 #define UNIFY_ALLOW_MORE_CV_QUAL 1
116 #define UNIFY_ALLOW_LESS_CV_QUAL 2
117 #define UNIFY_ALLOW_DERIVED 4
118 #define UNIFY_ALLOW_INTEGER 8
119 #define UNIFY_ALLOW_OUTER_LEVEL 16
120 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
121 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
143 tree);
201 /* Make the current scope suitable for access checking when we are
202 processing T. T can be FUNCTION_DECL for instantiated function
203 template, or VAR_DECL for static member variable (need by
204 instantiate_decl). */
206 static void
208 {
216 else
220 {
221 saved_access_scope = tree_cons
224 }
225 }
227 /* Restore the scope set up by push_access_scope. T is the node we
228 are processing. */
230 static void
232 {
234 {
237 }
241 else
243 }
245 /* Do any processing required when DECL (a member template
246 declaration) is finished. Returns the TEMPLATE_DECL corresponding
247 to DECL, unless it is a specialization, in which case the DECL
248 itself is returned. */
250 tree
252 {
259 {
260 tree type;
268 {
272 }
274 }
278 {
280 {
283 }
284 else
286 }
287 else
291 }
293 /* Return the template info node corresponding to T, whatever T is. */
295 tree
297 {
310 }
312 /* Returns the template nesting level of the indicated class TYPE.
314 For example, in:
315 template <class T>
316 struct A
317 {
318 template <class U>
319 struct B {};
320 };
322 A<T>::B<U> has depth two, while A<T> has depth one.
323 Both A<T>::B<int> and A<int>::B<U> have depth one, if
324 they are instantiations, not specializations.
326 This function is guaranteed to return 0 if passed NULL_TREE so
327 that, for example, `template_class_depth (current_class_type)' is
328 always safe. */
330 int
332 {
339 {
345 }
348 }
350 /* Subroutine of maybe_begin_member_template_processing.
351 Returns true if processing DECL needs us to push template parms. */
353 static bool
355 {
361 }
363 /* Subroutine of maybe_begin_member_template_processing.
364 Push the template parms in PARMS, starting from LEVELS steps into the
365 chain, and ending at the beginning, since template parms are listed
366 innermost first. */
368 static void
370 {
378 current_template_parms
384 NULL);
386 {
395 {
402 {
403 /* Make a CONST_DECL as is done in process_template_parm.
404 It is ugly that we recreate this here; the original
405 version built in process_template_parm is no longer
406 available. */
415 }
420 }
421 }
422 }
424 /* Restore the template parameter context for a member template or
425 a friend template defined in a class definition. */
427 void
429 {
430 tree parms;
434 {
439 {
442 }
445 }
447 /* Remember how many levels of template parameters we pushed so that
448 we can pop them later. */
450 }
452 /* Undo the effects of maybe_begin_member_template_processing. */
454 void
456 {
465 {
469 }
470 }
472 /* Return a new template argument vector which contains all of ARGS,
473 but has as its innermost set of arguments the EXTRA_ARGS. */
475 static tree
477 {
478 tree new_args;
493 }
495 /* Like add_to_template_args, but only the outermost ARGS are added to
496 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
497 (EXTRA_ARGS) levels are added. This function is used to combine
498 the template arguments from a partial instantiation with the
499 template arguments used to attain the full instantiation from the
500 partial instantiation. */
502 static tree
504 {
505 tree new_args;
507 /* If there are more levels of EXTRA_ARGS than there are ARGS,
508 something very fishy is going on. */
511 /* If *all* the new arguments will be the EXTRA_ARGS, just return
512 them. */
516 /* For the moment, we make ARGS look like it contains fewer levels. */
521 /* Now, we restore ARGS to its full dimensions. */
525 }
527 /* Return the N levels of innermost template arguments from the ARGS. */
529 tree
531 {
532 tree new_args;
538 /* If N is 1, just return the innermost set of template arguments. */
542 /* If we're not removing anything, just return the arguments we were
543 given. */
549 /* Make a new set of arguments, not containing the outer arguments. */
556 }
558 /* The inverse of get_innermost_template_args: Return all but the innermost
559 EXTRA_LEVELS levels of template arguments from the ARGS. */
561 static tree
563 {
564 tree new_args;
570 /* If N is 1, just return the outermost set of template arguments. */
574 /* If we're not removing anything, just return the arguments we were
575 given. */
580 /* Make a new set of arguments, not containing the inner arguments. */
587 }
589 /* We've got a template header coming up; push to a new level for storing
590 the parms. */
592 void
594 {
595 /* We use a non-tag-transparent scope here, which causes pushtag to
596 put tags in this scope, rather than in the enclosing class or
597 namespace scope. This is the right thing, since we want
598 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
599 global template class, push_template_decl handles putting the
600 TEMPLATE_DECL into top-level scope. For a nested template class,
601 e.g.:
603 template <class T> struct S1 {
604 template <class T> struct S2 {};
605 };
607 pushtag contains special code to call pushdecl_with_scope on the
608 TEMPLATE_DECL for S2. */
613 }
615 /* This routine is called when a specialization is declared. If it is
616 invalid to declare a specialization here, an error is reported and
617 false is returned, otherwise this routine will return true. */
619 static bool
621 {
624 /* [temp.expl.spec]
626 An explicit specialization shall be declared in the namespace of
627 which the template is a member, or, for member templates, in the
628 namespace of which the enclosing class or enclosing class
629 template is a member. An explicit specialization of a member
630 function, member class or static data member of a class template
631 shall be declared in the namespace of which the class template
632 is a member. */
634 {
637 }
639 /* [temp.expl.spec]
641 In an explicit specialization declaration for a member of a class
642 template or a member template that appears in namespace scope,
643 the member template and some of its enclosing class templates may
644 remain unspecialized, except that the declaration shall not
645 explicitly specialize a class member template if its enclosing
646 class templates are not explicitly specialized as well. */
648 {
651 }
654 }
656 /* We've just seen template <>. */
658 bool
660 {
664 }
666 /* Called at then end of processing a declaration preceded by
667 template<>. */
669 void
671 {
674 }
676 /* Any template <>'s that we have seen thus far are not referring to a
677 function specialization. */
679 void
681 {
684 }
686 /* We've just seen a template header. If SPECIALIZATION is nonzero,
687 it was of the form template <>. */
689 static void
691 {
693 template_header_count++;
694 }
696 /* We're beginning an explicit instantiation. */
698 void
700 {
703 }
706 void
708 {
711 }
713 /* An explicit specialization or partial specialization TMPL is being
714 declared. Check that the namespace in which the specialization is
715 occurring is permissible. Returns false iff it is invalid to
716 specialize TMPL in the current namespace. */
718 static bool
720 {
723 /* [tmpl.expl.spec]
725 An explicit specialization shall be declared in the namespace of
726 which the template is a member, or, for member templates, in the
727 namespace of which the enclosing class or enclosing class
728 template is a member. An explicit specialization of a member
729 function, member class or static data member of a class template
730 shall be declared in the namespace of which the class template is
731 a member. */
733 /* Same or super-using namespace. */
735 else
736 {
740 }
741 }
743 /* SPEC is an explicit instantiation. Check that it is valid to
744 perform this explicit instantiation in the current namespace. */
746 static void
748 {
749 tree ns;
751 /* DR 275: An explicit instantiation shall appear in an enclosing
752 namespace of its template. */
758 }
760 /* The TYPE is being declared. If it is a template type, that means it
761 is a partial specialization. Do appropriate error-checking. */
763 tree
765 {
766 tree context;
772 {
776 }
781 {
782 /* This is for ordinary explicit specialization and partial
783 specialization of a template class such as:
785 template <> class C<int>;
787 or:
789 template <class T> class C<T*>;
791 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
795 {
799 {
803 }
804 }
807 }
813 {
814 /* This is for an explicit specialization of member class
815 template according to [temp.expl.spec/18]:
817 template <> template <class U> class C<int>::D;
819 The context `C<int>' must be an implicit instantiation.
820 Otherwise this is just a member class template declared
821 earlier like:
823 template <> class C<int> { template <class U> class D; };
824 template <> template <class U> class C<int>::D;
826 In the first case, `C<int>::D' is a specialization of `C<T>::D'
827 while in the second case, `C<int>::D' is a primary template
828 and `C<T>::D' may not exist. */
832 {
833 tree t;
837 {
841 }
843 /* Check for invalid specialization after instantiation:
845 template <> template <> class C<int>::D<int>;
846 template <> template <class U> class C<int>::D; */
856 /* Mark TYPE as a specialization. And as a result, we only
857 have one level of template argument for the innermost
858 class template. */
862 }
863 }
865 {
868 }
871 }
873 /* Returns nonzero if we can optimize the retrieval of specializations
874 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
875 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
879 {
882 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
883 parameter. */
885 /* The optimized lookup depends on the fact that the
886 template arguments for the member function template apply
887 purely to the containing class, which is not true if the
888 containing class is an explicit or partial
889 specialization. */
893 /* It is possible to have a template that is not a member
894 template and is not a member of a template class:
896 template <typename T>
897 struct S { friend A::f(); };
899 Here, the friend function is a template, but the context does
900 not have template information. The optimized lookup relies
901 on having ARGS be the template arguments for both the class
902 and the function template. */
904 }
906 /* Retrieve the specialization (in the sense of [temp.spec] - a
907 specialization is either an instantiation or an explicit
908 specialization) of TMPL for the given template ARGS. If there is
909 no such specialization, return NULL_TREE. The ARGS are a vector of
910 arguments, or a vector of vectors of arguments, in the case of
911 templates with more than one level of parameters.
913 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
914 then we search for a partial specialization matching ARGS. This
915 parameter is ignored if TMPL is not a class template. */
917 static tree
920 {
926 /* There should be as many levels of arguments as there are
927 levels of parameters. */
932 {
933 tree class_template;
934 tree class_specialization;
936 tree fns;
939 /* The template arguments actually apply to the containing
940 class. Find the class specialization with those
941 arguments. */
943 class_specialization
948 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
949 for the specialization. */
953 /* Iterate through the methods with the indicated name, looking
954 for the one that has an instance of TMPL. */
957 {
961 }
963 }
964 else
965 {
969 /* Class templates store their instantiations on the
970 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
971 DECL_TEMPLATE_SPECIALIZATIONS list. */
976 else
979 /* Iterate through the list until we find a matching template. */
981 {
985 {
986 /* Use the move-to-front heuristic to speed up future
987 searches. */
989 {
993 }
995 }
997 }
998 }
1001 }
1003 /* Like retrieve_specialization, but for local declarations. */
1005 static tree
1007 {
1008 tree spec;
1016 }
1018 /* Returns nonzero iff DECL is a specialization of TMPL. */
1020 int
1022 {
1023 tree t;
1026 {
1032 }
1033 else
1034 {
1043 }
1046 }
1048 /* Returns nonzero iff DECL is a specialization of friend declaration
1049 FRIEND_DECL according to [temp.friend]. */
1051 bool
1053 {
1060 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1061 of a template class, we want to check if DECL is a specialization
1062 if this. */
1066 {
1067 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1070 }
1075 /* There is nothing to do if this is not a template friend. */
1082 /* [temp.friend/6]
1083 A member of a class template may be declared to be a friend of a
1084 non-template class. In this case, the corresponding member of
1085 every specialization of the class template is a friend of the
1086 class granting friendship.
1088 For example, given a template friend declaration
1090 template <class T> friend void A<T>::f();
1092 the member function below is considered a friend
1094 template <> struct A<int> {
1095 void f();
1096 };
1098 For this type of template friend, TEMPLATE_DEPTH below will be
1099 nonzero. To determine if DECL is a friend of FRIEND, we first
1100 check if the enclosing class is a specialization of another. */
1107 {
1108 /* Next, we check the members themselves. In order to handle
1109 a few tricky cases, such as when FRIEND_DECL's are
1111 template <class T> friend void A<T>::g(T t);
1112 template <class T> template <T t> friend void A<T>::h();
1114 and DECL's are
1116 void A<int>::g(int);
1117 template <int> void A<int>::h();
1119 we need to figure out ARGS, the template arguments from
1120 the context of DECL. This is required for template substitution
1121 of `T' in the function parameter of `g' and template parameter
1122 of `h' in the above examples. Here ARGS corresponds to `int'. */
1129 {
1131 {
1134 else
1136 current_depth++;
1137 }
1139 }
1142 {
1144 tree friend_type;
1145 tree decl_type;
1146 tree friend_args_type;
1147 tree decl_args_type;
1149 /* Make sure that both DECL and FRIEND_DECL are templates or
1150 non-templates. */
1156 {
1157 /* If both are templates, check template parameter list. */
1158 tree friend_parms
1163 friend_parms))
1167 }
1168 else
1176 /* Check if return types match. */
1180 /* Check if function parameter types match, ignoring the
1181 `this' parameter. */
1190 }
1191 else
1192 {
1193 /* DECL is a TYPE_DECL */
1197 /* Make sure that both DECL and FRIEND_DECL are templates or
1198 non-templates. */
1199 is_template
1206 {
1207 tree friend_parms;
1208 /* If both are templates, check the name of the two
1209 TEMPLATE_DECL's first because is_friend didn't. */
1214 /* Now check template parameter list. */
1215 friend_parms
1218 return comp_template_parms
1220 friend_parms);
1221 }
1222 else
1225 }
1226 }
1228 }
1230 /* Register the specialization SPEC as a specialization of TMPL with
1231 the indicated ARGS. IS_FRIEND indicates whether the specialization
1232 is actually just a friend declaration. Returns SPEC, or an
1233 equivalent prior declaration, if available. */
1235 static tree
1237 {
1238 tree fn;
1244 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1245 register it; we want the corresponding TEMPLATE_DECL instead.
1246 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1247 the more obvious `uses_template_parms (spec)' to avoid problems
1248 with default function arguments. In particular, given
1249 something like this:
1251 template <class T> void f(T t1, T t = T())
1253 the default argument expression is not substituted for in an
1254 instantiation unless and until it is actually needed. */
1259 /* We can sometimes try to re-register a specialization that we've
1260 already got. In particular, regenerate_decl_from_template calls
1261 duplicate_decls which will update the specialization list. But,
1262 we'll still get called again here anyhow. It's more convenient
1263 to simply allow this than to try to prevent it. */
1267 {
1269 {
1272 {
1274 fn);
1276 }
1277 else
1278 {
1279 tree clone;
1280 /* This situation should occur only if the first
1281 specialization is an implicit instantiation, the
1282 second is an explicit specialization, and the
1283 implicit instantiation has not yet been used. That
1284 situation can occur if we have implicitly
1285 instantiated a member function and then specialized
1286 it later.
1288 We can also wind up here if a friend declaration that
1289 looked like an instantiation turns out to be a
1290 specialization:
1292 template <class T> void foo(T);
1293 class S { friend void foo<>(int) };
1294 template <> void foo(int);
1296 We transform the existing DECL in place so that any
1297 pointers to it become pointers to the updated
1298 declaration.
1300 If there was a definition for the template, but not
1301 for the specialization, we want this to look as if
1302 there were no definition, and vice versa. */
1305 /* The call to duplicate_decls will have applied
1306 [temp.expl.spec]:
1308 An explicit specialization of a function template
1309 is inline only if it is explicitly declared to be,
1310 and independently of whether its function template
1311 is.
1313 to the primary function; now copy the inline bits to
1314 the various clones. */
1321 }
1322 }
1324 {
1326 /* Dup decl failed, but this is a new definition. Set the
1327 line number so any errors match this new
1328 definition. */
1332 }
1333 }
1335 /* A specialization must be declared in the same namespace as the
1336 template it is specializing. */
1346 }
1348 /* Unregister the specialization SPEC as a specialization of TMPL.
1349 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1350 if the SPEC was listed as a specialization of TMPL. */
1352 bool
1354 {
1361 {
1364 else
1367 }
1370 }
1372 /* Compare an entry in the local specializations hash table P1 (which
1373 is really a pointer to a TREE_LIST) with P2 (which is really a
1374 DECL). */
1376 static int
1378 {
1380 }
1382 /* Hash P1, an entry in the local specializations table. */
1384 static hashval_t
1386 {
1388 }
1390 /* Like register_specialization, but for local declarations. We are
1391 registering SPEC, an instantiation of TMPL. */
1393 static void
1395 {
1401 }
1403 /* TYPE is a class type. Returns true if TYPE is an explicitly
1404 specialized class. */
1406 bool
1408 {
1412 }
1414 /* Print the list of candidate FNS in an error message. */
1416 void
1418 {
1419 tree fn;
1424 {
1425 tree f;
1430 }
1431 }
1433 /* Returns the template (one of the functions given by TEMPLATE_ID)
1434 which can be specialized to match the indicated DECL with the
1435 explicit template args given in TEMPLATE_ID. The DECL may be
1436 NULL_TREE if none is available. In that case, the functions in
1437 TEMPLATE_ID are non-members.
1439 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1440 specialization of a member template.
1442 The TEMPLATE_COUNT is the number of references to qualifying
1443 template classes that appeared in the name of the function. See
1444 check_explicit_specialization for a more accurate description.
1446 TSK indicates what kind of template declaration (if any) is being
1447 declared. TSK_TEMPLATE indicates that the declaration given by
1448 DECL, though a FUNCTION_DECL, has template parameters, and is
1449 therefore a template function.
1451 The template args (those explicitly specified and those deduced)
1452 are output in a newly created vector *TARGS_OUT.
1454 If it is impossible to determine the result, an error message is
1455 issued. The error_mark_node is returned to indicate failure. */
1457 static tree
1459 tree decl,
1463 tmpl_spec_kind tsk)
1464 {
1465 tree fns;
1466 tree targs;
1467 tree explicit_targs;
1469 /* A TREE_LIST of templates of which DECL may be a specialization.
1470 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1471 corresponding TREE_PURPOSE is the set of template arguments that,
1472 when used to instantiate the template, would produce a function
1473 with the signature of DECL. */
1489 /* Check for baselinks. */
1494 {
1497 }
1499 /* Count the number of template headers specified for this
1500 specialization. */
1508 {
1512 {
1513 tree decl_arg_types;
1514 tree fn_arg_types;
1516 /* In case of explicit specialization, we need to check if
1517 the number of template headers appearing in the specialization
1518 is correct. This is usually done in check_explicit_specialization,
1519 but the check done there cannot be exhaustive when specializing
1520 member functions. Consider the following code:
1522 template <> void A<int>::f(int);
1523 template <> template <> void A<int>::f(int);
1525 Assuming that A<int> is not itself an explicit specialization
1526 already, the first line specializes "f" which is a non-template
1527 member function, whilst the second line specializes "f" which
1528 is a template member function. So both lines are syntactically
1529 correct, and check_explicit_specialization does not reject
1530 them.
1532 Here, we can do better, as we are matching the specialization
1533 against the declarations. We count the number of template
1534 headers, and we check if they match TEMPLATE_COUNT + 1
1535 (TEMPLATE_COUNT is the number of qualifying template classes,
1536 plus there must be another header for the member template
1537 itself).
1539 Notice that if header_count is zero, this is not a
1540 specialization but rather a template instantiation, so there
1541 is no check we can perform here. */
1545 /* Check that the number of template arguments at the
1546 innermost level for DECL is the same as for FN. */
1554 /* DECL might be a specialization of FN. */
1558 /* For a non-static member function, we need to make sure
1559 that the const qualification is the same. Since
1560 get_bindings does not try to merge the "this" parameter,
1561 we must do the comparison explicitly. */
1567 /* Skip the "this" parameter and, for constructors of
1568 classes with virtual bases, the VTT parameter. A
1569 full specialization of a constructor will have a VTT
1570 parameter, but a template never will. */
1571 decl_arg_types
1573 fn_arg_types
1576 /* Check that the number of function parameters matches.
1577 For example,
1578 template <class T> void f(int i = 0);
1579 template <> void f<int>();
1580 The specialization f<int> is invalid but is not caught
1581 by get_bindings below. */
1585 /* Function templates cannot be specializations; there are
1586 no partial specializations of functions. Therefore, if
1587 the type of DECL does not match FN, there is no
1588 match. */
1590 {
1594 }
1596 /* See whether this function might be a specialization of this
1597 template. */
1601 /* We cannot deduce template arguments that when used to
1602 specialize TMPL will produce DECL. */
1605 /* Save this template, and the arguments deduced. */
1607 }
1609 /* FN is an ordinary member function, and we need a
1610 specialization of a member template. */
1611 ;
1613 /* We can get IDENTIFIER_NODEs here in certain erroneous
1614 cases. */
1615 ;
1617 /* This is just an ordinary non-member function. Nothing can
1618 be a specialization of that. */
1619 ;
1621 /* Cannot specialize functions that are created implicitly. */
1622 ;
1623 else
1624 {
1625 tree decl_arg_types;
1627 /* This is an ordinary member function. However, since
1628 we're here, we can assume it's enclosing class is a
1629 template class. For example,
1631 template <typename T> struct S { void f(); };
1632 template <> void S<int>::f() {}
1634 Here, S<int>::f is a non-template, but S<int> is a
1635 template class. If FN has the same type as DECL, we
1636 might be in business. */
1639 /* Its enclosing class is an explicit specialization
1640 of a template class. This is not a candidate. */
1645 /* The return types differ. */
1648 /* Adjust the type of DECL in case FN is a static member. */
1655 decl_arg_types))
1656 /* They match! */
1658 }
1659 }
1662 {
1663 /* We have:
1665 [temp.expl.spec]
1667 It is possible for a specialization with a given function
1668 signature to be instantiated from more than one function
1669 template. In such cases, explicit specification of the
1670 template arguments must be used to uniquely identify the
1671 function template specialization being specialized.
1673 Note that here, there's no suggestion that we're supposed to
1674 determine which of the candidate templates is most
1675 specialized. However, we, also have:
1677 [temp.func.order]
1679 Partial ordering of overloaded function template
1680 declarations is used in the following contexts to select
1681 the function template to which a function template
1682 specialization refers:
1684 -- when an explicit specialization refers to a function
1685 template.
1687 So, we do use the partial ordering rules, at least for now.
1688 This extension can only serve to make invalid programs valid,
1689 so it's safe. And, there is strong anecdotal evidence that
1690 the committee intended the partial ordering rules to apply;
1691 the EDG front end has that behavior, and John Spicer claims
1692 that the committee simply forgot to delete the wording in
1693 [temp.expl.spec]. */
1696 {
1699 }
1700 }
1703 {
1707 }
1711 {
1717 }
1719 /* We have one, and exactly one, match. */
1721 {
1723 /* DECL is a re-declaration of a template function. */
1726 /* It was a specialization of an ordinary member function in a
1727 template class. */
1730 }
1732 /* It was a specialization of a template. */
1735 {
1740 }
1741 else
1744 }
1746 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1747 but with the default argument values filled in from those in the
1748 TMPL_TYPES. */
1750 static tree
1752 tree tmpl_types)
1753 {
1754 tree new_spec_types;
1762 /* Substitute into the rest of the list. */
1763 new_spec_types =
1767 /* Add the default argument for this parameter. */
1770 new_spec_types);
1771 }
1773 /* DECL is an explicit specialization. Replicate default arguments
1774 from the template it specializes. (That way, code like:
1776 template <class T> void f(T = 3);
1777 template <> void f(double);
1778 void g () { f (); }
1780 works, as required.) An alternative approach would be to look up
1781 the correct default arguments at the call-site, but this approach
1782 is consistent with how implicit instantiations are handled. */
1784 static void
1786 {
1787 tree tmpl;
1788 tree spec_types;
1789 tree tmpl_types;
1790 tree new_spec_types;
1791 tree old_type;
1792 tree new_type;
1793 tree t;
1798 /* See if there's anything we need to do. */
1811 {
1812 /* Remove the this pointer, but remember the object's type for
1813 CV quals. */
1819 {
1820 /* DECL may contain more parameters than TMPL due to the extra
1821 in-charge parameter in constructors and destructors. */
1824 }
1826 {
1829 }
1830 }
1832 /* Compute the merged default arguments. */
1833 new_spec_types =
1836 /* Compute the new FUNCTION_TYPE. */
1838 {
1842 new_spec_types);
1845 /* Put the in-charge parameter back. */
1848 new_spec_types);
1852 new_spec_types);
1853 }
1854 else
1856 new_spec_types);
1862 }
1864 /* Check to see if the function just declared, as indicated in
1865 DECLARATOR, and in DECL, is a specialization of a function
1866 template. We may also discover that the declaration is an explicit
1867 instantiation at this point.
1869 Returns DECL, or an equivalent declaration that should be used
1870 instead if all goes well. Issues an error message if something is
1871 amiss. Returns error_mark_node if the error is not easily
1872 recoverable.
1874 FLAGS is a bitmask consisting of the following flags:
1876 2: The function has a definition.
1877 4: The function is a friend.
1879 The TEMPLATE_COUNT is the number of references to qualifying
1880 template classes that appeared in the name of the function. For
1881 example, in
1883 template <class T> struct S { void f(); };
1884 void S<int>::f();
1886 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1887 classes are not counted in the TEMPLATE_COUNT, so that in
1889 template <class T> struct S {};
1890 template <> struct S<int> { void f(); }
1891 template <> void S<int>::f();
1893 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1894 invalid; there should be no template <>.)
1896 If the function is a specialization, it is marked as such via
1897 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1898 is set up correctly, and it is added to the list of specializations
1899 for that template. */
1901 tree
1903 tree decl,
1906 {
1914 tmpl_spec_kind tsk;
1917 {
1920 else
1922 }
1923 else
1927 {
1930 {
1933 }
1935 {
1937 /* This could be something like:
1939 template <class T> void f(T);
1940 class S { friend void f<>(int); } */
1942 else
1943 {
1944 /* This case handles bogus declarations like template <>
1945 template <class T> void f<int>(); */
1948 declarator);
1950 }
1951 }
1955 /* The error has already been reported in
1956 check_specialization_scope. */
1962 /* Fall through. */
1975 decl);
1978 else
1982 /* Fall through. */
1987 else
1993 {
1994 /* This case handles bogus declarations like template <>
1995 template <class T> void f<int>(); */
2000 else
2002 declarator);
2004 }
2007 /* This is a specialization of a member template, without
2008 specialization the containing class. Something like:
2010 template <class T> struct S {
2011 template <class U> void f (U);
2012 };
2013 template <> template <class U> void S<int>::f(U) {}
2015 That's a specialization -- but of the entire template. */
2021 }
2024 {
2028 {
2032 }
2033 }
2036 {
2040 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2042 {
2043 tree fns;
2048 else
2049 {
2050 /* If there is no class context, the explicit instantiation
2051 must be at namespace scope. */
2054 /* Find the namespace binding, using the declaration
2055 context. */
2059 {
2062 }
2063 else
2064 {
2070 }
2071 }
2074 }
2080 {
2082 /* A specialization in class scope. This is invalid,
2083 but the error will already have been flagged by
2084 check_specialization_scope. */
2086 else
2087 {
2088 /* It's not valid to write an explicit instantiation in
2089 class scope, e.g.:
2091 class C { template void f(); }
2093 This case is caught by the parser. However, on
2094 something like:
2096 template class C { void f(); };
2098 (which is invalid) we can get here. The error will be
2099 issued later. */
2100 ;
2101 }
2104 }
2107 IDENTIFIER_NODE))
2108 {
2109 /* Find the list of functions in ctype that have the same
2110 name as the declared function. */
2116 {
2121 {
2122 /* From [temp.expl.spec]:
2124 If such an explicit specialization for the member
2125 of a class template names an implicitly-declared
2126 special member function (clause _special_), the
2127 program is ill-formed.
2129 Similar language is found in [temp.explicit]. */
2132 }
2135 }
2138 {
2142 }
2143 else
2144 {
2146 tree ovl;
2148 /* For a type-conversion operator, we cannot do a
2149 name-based lookup. We might be looking for `operator
2150 int' which will be a specialization of `operator T'.
2151 So, we find *all* the conversion operators, and then
2152 select from them. */
2160 {
2162 /* There are no more conversion functions. */
2165 /* Glue all these conversion functions together
2166 with those we already have. */
2169 }
2170 }
2173 {
2176 }
2177 else
2179 }
2181 /* Figure out what exactly is being specialized at this point.
2182 Note that for an explicit instantiation, even one for a
2183 member function, we cannot tell apriori whether the
2184 instantiation is for a member template, or just a member
2185 function of a template class. Even if a member template is
2186 being instantiated, the member template arguments may be
2187 elided if they can be deduced from the rest of the
2188 declaration. */
2191 member_specialization,
2192 template_count,
2193 tsk);
2196 /* We couldn't figure out what this declaration was
2197 specializing. */
2199 else
2200 {
2204 {
2205 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2206 is done by do_decl_instantiation later. */
2212 {
2213 /* If TMPL is not the most general template (for
2214 example, if TMPL is a friend template that is
2215 injected into namespace scope), then there will
2216 be too many levels of TARGS. Remove some of them
2217 here. */
2219 tree new_targs;
2226 }
2229 }
2231 /* If we thought that the DECL was a member function, but it
2232 turns out to be specializing a static member function,
2233 make DECL a static member function as well. */
2238 /* If this is a specialization of a member template of a
2239 template class, we want to return the TEMPLATE_DECL, not
2240 the specialization of it. */
2242 {
2246 {
2250 /* We want to use the argument list specified in the
2251 definition, not in the original declaration. */
2254 }
2256 }
2258 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2261 /* Inherit default function arguments from the template
2262 DECL is specializing. */
2265 /* This specialization has the same protection as the
2266 template it specializes. */
2270 /* 7.1.1-1 [dcl.stc]
2272 A storage-class-specifier shall not be specified in an
2273 explicit specialization...
2275 The parser rejects these, so unless action is taken here,
2276 explicit function specializations will always appear with
2277 global linkage.
2279 The action recommended by the C++ CWG in response to C++
2280 defect report 605 is to make the storage class and linkage
2281 of the explicit specialization match the templated function:
2283 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2284 */
2286 {
2290 /* This specialization has the same linkage and visibility as
2291 the function template it specializes. */
2294 {
2297 }
2300 {
2303 }
2304 }
2306 /* If DECL is a friend declaration, declared using an
2307 unqualified name, the namespace associated with DECL may
2308 have been set incorrectly. For example, in:
2310 template <typename T> void f(T);
2311 namespace N {
2312 struct S { friend void f<int>(int); }
2313 }
2315 we will have set the DECL_CONTEXT for the friend
2316 declaration to N, rather than to the global namespace. */
2321 /* This is not really a declaration of a specialization.
2322 It's just the name of an instantiation. But, it's not
2323 a request for an instantiation, either. */
2326 /* This is indeed a specialization. In case of constructors
2327 and destructors, we need in-charge and not-in-charge
2328 versions in V3 ABI. */
2331 /* Register this specialization so that we can find it
2332 again. */
2334 }
2335 }
2338 }
2340 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2341 parameters. These are represented in the same format used for
2342 DECL_TEMPLATE_PARMS. */
2344 int
2346 {
2347 const_tree p1;
2348 const_tree p2;
2356 {
2368 {
2372 /* If either of the template parameters are invalid, assume
2373 they match for the sake of error recovery. */
2386 }
2387 }
2390 /* One set of parameters has more parameters lists than the
2391 other. */
2395 }
2397 /* Determine whether PARM is a parameter pack. */
2398 bool
2400 {
2401 /* Determine if we have a non-type template parameter pack. */
2406 /* If this is a list of template parameters, we could get a
2407 TYPE_DECL or a TEMPLATE_DECL. */
2414 }
2416 /* Determine whether ARGS describes a variadic template args list,
2417 i.e., one that is terminated by a template argument pack. */
2418 static bool
2420 {
2422 tree last_parm;
2436 }
2438 /* Generate a new name for the parameter pack name NAME (an
2439 IDENTIFIER_NODE) that incorporates its */
2440 static tree
2442 {
2443 /* Munge the name to include the parameter index. */
2451 }
2453 /* Structure used to track the progress of find_parameter_packs_r. */
2454 struct find_parameter_pack_data
2455 {
2456 /* TREE_LIST that will contain all of the parameter packs found by
2457 the traversal. */
2460 /* Set of AST nodes that have been visited by the traversal. */
2462 };
2464 /* Identifies all of the argument packs that occur in a template
2465 argument and appends them to the TREE_LIST inside DATA, which is a
2466 find_parameter_pack_data structure. This is a subroutine of
2467 make_pack_expansion and uses_parameter_packs. */
2468 static tree
2470 {
2476 /* Identify whether this is a parameter pack or not. */
2478 {
2492 {
2493 /* We don't want to walk into the type of a PARM_DECL,
2494 because we don't want to see the type parameter pack. */
2497 }
2501 /* Not a parameter pack. */
2503 }
2506 {
2507 /* Add this parameter pack to the list. */
2509 }
2515 /* This switch statement will return immediately if we don't find a
2516 parameter pack. */
2518 {
2523 /* Check the template itself. */
2526 /* Check the template arguments. */
2542 /* Fall through. */
2581 /* If T is a tree list node whose purpose field is an error_mark_node,
2582 T actually contains the tokens for an lock attribute argument list in
2583 its value field. (See cp_parser_save_attribute_arg_list in cp/parser.c.)
2584 In that case, don't try to walk the tree value field as it is not a
2585 valid tree node. */
2593 }
2596 }
2598 /* Determines if the expression or type T uses any parameter packs. */
2599 bool
2601 {
2609 }
2611 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2612 representation a base-class initializer into a parameter pack
2613 expansion. If all goes well, the resulting node will be an
2614 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2615 respectively. */
2616 tree
2618 {
2619 tree result;
2628 {
2629 /* The only time we will see a TREE_LIST here is for a base
2630 class initializer. In this case, the TREE_PURPOSE will be a
2631 _TYPE node (representing the base class expansion we're
2632 initializing) and the TREE_VALUE will be a TREE_LIST
2633 containing the initialization arguments.
2635 The resulting expansion looks somewhat different from most
2636 expansions. Rather than returning just one _EXPANSION, we
2637 return a TREE_LIST whose TREE_PURPOSE is a
2638 TYPE_PACK_EXPANSION containing the bases that will be
2639 initialized. The TREE_VALUE will be identical to the
2640 original TREE_VALUE, which is a list of arguments that will
2641 be passed to each base. We do not introduce any new pack
2642 expansion nodes into the TREE_VALUE (although it is possible
2643 that some already exist), because the TREE_PURPOSE and
2644 TREE_VALUE all need to be expanded together with the same
2645 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2646 resulting TREE_PURPOSE will mention the parameter packs in
2647 both the bases and the arguments to the bases. */
2648 tree purpose;
2649 tree value;
2652 /* Determine which parameter packs will be used by the base
2653 class expansion. */
2660 {
2664 }
2667 {
2668 /* Collect the sets of parameter packs used in each of the
2669 initialization arguments. */
2671 {
2672 /* Determine which parameter packs will be expanded in this
2673 argument. */
2676 }
2677 }
2681 /* Create the pack expansion type for the base type. */
2686 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2687 they will rarely be compared to anything. */
2691 }
2696 /* Build the PACK_EXPANSION_* node. */
2700 {
2701 /* Propagate type and const-expression information. */
2704 }
2705 else
2706 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2707 they will rarely be compared to anything. */
2710 /* Determine which parameter packs will be expanded. */
2716 /* Make sure we found some parameter packs. */
2718 {
2721 else
2724 }
2728 }
2730 /* Checks T for any "bare" parameter packs, which have not yet been
2731 expanded, and issues an error if any are found. This operation can
2732 only be done on full expressions or types (e.g., an expression
2733 statement, "if" condition, etc.), because we could have expressions like:
2735 foo(f(g(h(args)))...)
2737 where "args" is a parameter pack. check_for_bare_parameter_packs
2738 should not be called for the subexpressions args, h(args),
2739 g(h(args)), or f(g(h(args))), because we would produce erroneous
2740 error messages.
2742 Returns TRUE and emits an error if there were bare parameter packs,
2743 returns FALSE otherwise. */
2744 bool
2746 {
2762 {
2765 {
2774 else
2779 else
2783 }
2786 }
2789 }
2791 /* Expand any parameter packs that occur in the template arguments in
2792 ARGS. */
2793 tree
2795 {
2800 /* First, determine if we need to expand anything, and the number of
2801 slots we'll need. */
2803 {
2806 {
2810 else
2812 }
2813 else
2814 {
2816 num_result_args++;
2817 }
2818 }
2820 /* If no expansion is necessary, we're done. */
2824 /* Expand arguments. */
2827 {
2830 {
2835 }
2836 else
2837 {
2840 }
2841 }
2844 }
2846 /* Checks if DECL shadows a template parameter.
2848 [temp.local]: A template-parameter shall not be redeclared within its
2849 scope (including nested scopes).
2851 Emits an error and returns TRUE if the DECL shadows a parameter,
2852 returns FALSE otherwise. */
2854 bool
2856 {
2857 tree olddecl;
2859 /* If we're not in a template, we can't possibly shadow a template
2860 parameter. */
2864 /* Figure out what we're shadowing. */
2869 /* If there's no previous binding for this name, we're not shadowing
2870 anything, let alone a template parameter. */
2874 /* If we're not shadowing a template parameter, we're done. Note
2875 that OLDDECL might be an OVERLOAD (or perhaps even an
2876 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2877 node. */
2881 /* We check for decl != olddecl to avoid bogus errors for using a
2882 name inside a class. We check TPFI to avoid duplicate errors for
2883 inline member templates. */
2891 }
2893 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2894 ORIG_LEVEL, DECL, and TYPE. */
2896 static tree
2900 tree decl,
2901 tree type)
2902 {
2913 }
2915 /* Find the canonical type parameter for the given template type
2916 parameter. Returns the canonical type parameter, which may be TYPE
2917 if no such parameter existed. */
2918 static tree
2920 {
2921 tree list;
2935 else
2936 {
2941 }
2942 }
2944 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2945 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2946 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2947 new one is created. */
2949 static tree
2951 tsubst_flags_t complain)
2952 {
2956 {
2974 /* Template template parameters need this. */
2979 }
2982 }
2984 /* Process information from new template parameter PARM and append it to the
2985 LIST being built. This new parameter is a non-type parameter iff
2986 IS_NON_TYPE is true. This new parameter is a parameter
2987 pack iff IS_PARAMETER_PACK is true. */
2989 tree
2992 {
2994 tree defval;
2995 tree err_parm_list;
3002 {
3006 {
3010 else
3012 }
3015 }
3016 else
3020 {
3026 {
3030 }
3031 else
3032 {
3033 /* [temp.param]
3035 The top-level cv-qualifiers on the template-parameter are
3036 ignored when determining its type. */
3039 {
3043 }
3046 {
3047 /* This template parameter is not a parameter pack, but it
3048 should be. Complain about "bare" parameter packs. */
3051 /* Recover by calling this a parameter pack. */
3053 }
3054 }
3056 /* A template parameter is not modifiable. */
3064 processing_template_decl,
3069 }
3070 else
3071 {
3072 tree t;
3076 {
3078 /* This is for distinguishing between real templates and template
3079 template parameters */
3083 }
3084 else
3085 {
3087 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3089 }
3096 processing_template_decl,
3100 }
3106 }
3108 /* The end of a template parameter list has been reached. Process the
3109 tree list into a parameter vector, converting each parameter into a more
3110 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3111 as PARM_DECLs. */
3113 tree
3115 {
3120 current_template_parms
3125 {
3129 }
3134 }
3136 /* end_template_decl is called after a template declaration is seen. */
3138 void
3140 {
3146 /* This matches the pushlevel in begin_template_parm_list. */
3151 }
3153 /* Within the declaration of a template, return all levels of template
3154 parameters that apply. The template parameters are represented as
3155 a TREE_VEC, in the form documented in cp-tree.h for template
3156 arguments. */
3158 static tree
3160 {
3161 tree header;
3166 /* If there is only one level of template parameters, we do not
3167 create a TREE_VEC of TREE_VECs. Instead, we return a single
3168 TREE_VEC containing the arguments. */
3173 {
3179 {
3182 /* T will be a list if we are called from within a
3183 begin/end_template_parm_list pair, but a vector directly
3184 if within a begin/end_member_template_processing pair. */
3186 {
3190 {
3193 {
3197 {
3198 /* Turn this argument into a TYPE_ARGUMENT_PACK
3199 with a single element, which expands T. */
3205 }
3206 }
3207 else
3208 {
3212 {
3213 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3214 with a single element, which expands T. */
3222 }
3223 }
3225 }
3226 }
3227 }
3231 else
3233 }
3236 }
3238 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3239 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3240 a member template. Used by push_template_decl below. */
3242 static tree
3244 {
3250 {
3259 }
3262 }
3264 struct template_parm_data
3265 {
3266 /* The level of the template parameters we are currently
3267 processing. */
3270 /* The index of the specialization argument we are currently
3271 processing. */
3274 /* An array whose size is the number of template parameters. The
3275 elements are nonzero if the parameter has been used in any one
3276 of the arguments processed so far. */
3279 /* An array whose size is the number of template arguments. The
3280 elements are nonzero if the argument makes use of template
3281 parameters of this level. */
3283 };
3285 /* Subroutine of push_template_decl used to see if each template
3286 parameter in a partial specialization is used in the explicit
3287 argument list. If T is of the LEVEL given in DATA (which is
3288 treated as a template_parm_data*), then DATA->PARMS is marked
3289 appropriately. */
3291 static int
3293 {
3299 {
3302 }
3303 else
3304 {
3307 }
3310 {
3313 }
3315 /* Return zero so that for_each_template_parm will continue the
3316 traversal of the tree; we want to mark *every* template parm. */
3318 }
3320 /* Process the partial specialization DECL. */
3322 static tree
3324 {
3330 tree inner_parms;
3343 /* We check that each of the template parameters given in the
3344 partial specialization is used in the argument list to the
3345 specialization. For example:
3347 template <class T> struct S;
3348 template <class T> struct S<T*>;
3350 The second declaration is OK because `T*' uses the template
3351 parameter T, whereas
3353 template <class T> struct S<int>;
3355 is no good. Even trickier is:
3357 template <class T>
3358 struct S1
3359 {
3360 template <class U>
3361 struct S2;
3362 template <class U>
3363 struct S2<T>;
3364 };
3366 The S2<T> declaration is actually invalid; it is a
3367 full-specialization. Of course,
3369 template <class U>
3370 struct S2<T (*)(U)>;
3372 or some such would have been OK. */
3380 {
3385 NULL,
3387 }
3390 {
3391 /* One of the template parms was not used in the
3392 specialization. */
3394 {
3397 }
3400 }
3402 /* [temp.class.spec]
3404 The argument list of the specialization shall not be identical to
3405 the implicit argument list of the primary template. */
3412 /* [temp.class.spec]
3414 A partially specialized non-type argument expression shall not
3415 involve template parameters of the partial specialization except
3416 when the argument expression is a simple identifier.
3418 The type of a template parameter corresponding to a specialized
3419 non-type argument shall not be dependent on a parameter of the
3420 specialization.
3422 Also, we verify that pack expansions only occur at the
3423 end of the argument list. */
3427 {
3434 {
3435 /* Extract the arguments from the argument pack. We'll be
3436 iterating over these in the following loop. */
3439 }
3442 {
3444 /* Get the Jth argument in the parameter pack. */
3448 {
3449 /* Pack expansions must come at the end of the
3450 argument list. */
3453 {
3456 else
3461 }
3462 }
3465 /* We only care about the pattern. */
3471 /* This next line is the `argument expression is not just a
3472 simple identifier' condition and also the `specialized
3473 non-type argument' bit. */
3475 {
3479 arg);
3480 else
3481 {
3482 /* Look at the corresponding template parameter,
3483 marking which template parameters its type depends
3484 upon. */
3488 {
3489 /* We haven't yet initialized TPD2. Do so now. */
3490 tpd2.arg_uses_template_parms
3492 /* The number of parameters here is the number in the
3493 main template, which, as checked in the assertion
3494 above, is NARGS. */
3498 }
3500 /* Mark the template parameters. But this time, we're
3501 looking for the template parameters of the main
3502 template, not in the specialization. */
3509 NULL,
3513 {
3514 /* The type depended on some template parameters.
3515 If they are fully specialized in the
3516 specialization, that's OK. */
3521 {
3524 type,
3525 arg);
3527 }
3528 }
3529 }
3530 }
3531 }
3532 }
3536 /* We've already got this specialization. */
3544 }
3546 /* Check that a template declaration's use of default arguments and
3547 parameter packs is not invalid. Here, PARMS are the template
3548 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3549 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3550 specialization.
3553 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3554 declaration (but not a definition); 1 indicates a declaration, 2
3555 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3556 emitted for extraneous default arguments.
3558 Returns TRUE if there were no errors found, FALSE otherwise. */
3560 bool
3563 {
3566 tree parm_level;
3569 /* [temp.param]
3571 A default template-argument shall not be specified in a
3572 function template declaration or a function template definition, nor
3573 in the template-parameter-list of the definition of a member of a
3574 class template. */
3577 /* You can't have a function template declaration in a local
3578 scope, nor you can you define a member of a class template in a
3579 local scope. */
3585 /* If this is either a friend defined in the scope of the class
3586 or a member function. */
3592 /* And, if it was a member function, it really was defined in
3593 the scope of the class. */
3596 /* We already checked these parameters when the template was
3597 declared, so there's no need to do it again now. This function
3598 was defined in class scope, but we're processing it's body now
3599 that the class is complete. */
3602 /* Core issue 226 (C++0x only): the following only applies to class
3603 templates. */
3605 {
3606 /* [temp.param]
3608 If a template-parameter has a default template-argument, all
3609 subsequent template-parameters shall have a default
3610 template-argument supplied. */
3612 {
3619 {
3629 {
3631 /* For better subsequent error-recovery, we indicate that
3632 there should have been a default argument. */
3635 }
3637 && !is_partial
3638 && !is_friend_decl
3639 /* Don't complain about an enclosing partial
3640 specialization. */
3645 {
3646 /* A primary class template can only have one
3647 parameter pack, at the end of the template
3648 parameter list. */
3653 else
3661 }
3662 }
3663 }
3664 }
3667 || is_partial
3668 || !is_primary
3670 /* For an ordinary class template, default template arguments are
3671 allowed at the innermost level, e.g.:
3672 template <class T = int>
3673 struct S {};
3674 but, in a partial specialization, they're not allowed even
3675 there, as we have in [temp.class.spec]:
3677 The template parameter list of a specialization shall not
3678 contain default template argument values.
3680 So, for a partial specialization, or for a function template
3681 (in C++98/C++03), we look at all of them. */
3682 ;
3683 else
3684 /* But, for a primary class template that is not a partial
3685 specialization we look at all template parameters except the
3686 innermost ones. */
3689 /* Figure out what error message to issue. */
3698 else
3702 /* If we're inside a class definition, there's no need to
3703 examine the parameters to the class itself. On the one
3704 hand, they will be checked when the class is defined, and,
3705 on the other, default arguments are valid in things like:
3706 template <class T = double>
3707 struct S { template <class U> void f(U); };
3708 Here the default argument for `S' has no bearing on the
3709 declaration of `f'. */
3711 else
3712 /* Check everything. */
3718 {
3725 {
3730 {
3732 {
3739 }
3741 /* Clear out the default argument so that we are not
3742 confused later. */
3744 }
3745 }
3747 /* At this point, if we're still interested in issuing messages,
3748 they must apply to classes surrounding the object declared. */
3751 }
3754 }
3756 /* Worker for push_template_decl_real, called via
3757 for_each_template_parm. DATA is really an int, indicating the
3758 level of the parameters we are interested in. If T is a template
3759 parameter of that level, return nonzero. */
3761 static int
3763 {
3769 else
3772 }
3774 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3775 parameters given by current_template_args, or reuses a
3776 previously existing one, if appropriate. Returns the DECL, or an
3777 equivalent one, if it is replaced via a call to duplicate_decls.
3779 If IS_FRIEND is true, DECL is a friend declaration. */
3781 tree
3783 {
3784 tree tmpl;
3785 tree args;
3786 tree info;
3787 tree ctx;
3791 /* True if the template is a member template, in the sense of
3792 [temp.mem]. */
3798 /* See if this is a partial specialization. */
3807 /* For a friend, we want the context of the friend function, not
3808 the type of which it is a friend. */
3812 /* In the case of a virtual function, we want the class in which
3813 it is defined. */
3815 else
3816 /* Otherwise, if we're currently defining some class, the DECL
3817 is assumed to be a member of the class. */
3826 /* See if this is a primary template. */
3828 /* A friend template that specifies a class context, i.e.
3829 template <typename T> friend void A<T>::f();
3830 is not primary. */
3832 else
3836 {
3841 {
3844 }
3846 {
3848 {
3849 /* [temp.mem]
3851 A destructor shall not be a member template. */
3854 }
3861 {
3862 /* [basic.stc.dynamic.allocation]
3864 An allocation function can be a function
3865 template. ... Template allocation functions shall
3866 have two or more parameters. */
3869 }
3870 }
3874 else
3875 {
3878 }
3879 }
3881 /* Check to see that the rules regarding the use of default
3882 arguments are not being violated. */
3886 /* Ensure that there are no parameter packs in the type of this
3887 declaration that have not been expanded. */
3889 {
3890 /* Check each of the arguments individually to see if there are
3891 any bare parameter packs. */
3897 {
3900 {
3901 /* This is a PARM_DECL that contains unexpanded parameter
3902 packs. We have already complained about this in the
3903 check_for_bare_parameter_packs call, so just replace
3904 these types with ERROR_MARK_NODE. */
3907 }
3911 }
3913 /* Check for bare parameter packs in the return type and the
3914 exception specifiers. */
3916 /* Errors were already issued, set return type to int
3917 as the frontend doesn't expect error_mark_node as
3918 the return type. */
3922 }
3924 {
3927 }
3938 {
3943 /* If DECL is a TYPE_DECL for a class-template, then there won't
3944 be DECL_LANG_SPECIFIC. The information equivalent to
3945 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3949 {
3950 /* Since a template declaration already existed for this
3951 class-type, we must be redeclaring it here. Make sure
3952 that the redeclaration is valid. */
3954 current_template_parms);
3955 /* We don't need to create a new TEMPLATE_DECL; just use the
3956 one we already had. */
3958 }
3959 else
3960 {
3962 member_template_p);
3967 {
3968 /* A specialization of a member template of a template
3969 class. */
3973 }
3974 }
3975 }
3976 else
3977 {
3983 {
3986 }
3994 {
3995 tree new_tmpl;
3997 /* The declaration is a specialization of a member
3998 template, declared outside the class. Therefore, the
3999 innermost template arguments will be NULL, so we
4000 replace them with the arguments determined by the
4001 earlier call to check_explicit_specialization. */
4004 new_tmpl
4006 member_template_p);
4016 args,
4017 is_friend);
4019 }
4021 /* Make sure the template headers we got make sense. */
4026 {
4029 }
4030 else
4032 {
4037 {
4041 else
4046 }
4050 else
4054 }
4056 /* Check that the parms are used in the appropriate qualifying scopes
4057 in the declarator. */
4061 {
4067 /* Avoid crash in import_export_decl. */
4070 }
4071 }
4076 /* Push template declarations for global functions and types. Note
4077 that we do not try to push a global template friend declared in a
4078 template class; such a thing may well depend on the template
4079 parameters of the class. */
4082 {
4087 /* Hide template friend classes that haven't been declared yet. */
4089 {
4092 }
4093 }
4096 {
4102 {
4105 /* It is a conversion operator. See if the type converted to
4106 depends on innermost template operands. */
4109 depth))
4111 }
4113 /* Give template template parms a DECL_CONTEXT of the template
4114 for which they are a parameter. */
4117 {
4121 }
4122 }
4124 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4125 back to its most general template. If TMPL is a specialization,
4126 ARGS may only have the innermost set of arguments. Add the missing
4127 argument levels if necessary. */
4139 }
4141 tree
4143 {
4145 }
4147 /* Called when a class template TYPE is redeclared with the indicated
4148 template PARMS, e.g.:
4150 template <class T> struct S;
4151 template <class T> struct S {}; */
4153 bool
4155 {
4156 tree tmpl;
4157 tree tmpl_parms;
4161 {
4164 }
4168 /* The type is nested in some template class. Nothing to worry
4169 about here; there are no new template parameters for the nested
4170 type. */
4174 {
4176 tmpl);
4178 }
4184 {
4190 }
4193 {
4194 tree tmpl_parm;
4195 tree parm;
4196 tree tmpl_default;
4197 tree parm_default;
4208 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4209 TEMPLATE_DECL. */
4220 {
4224 }
4227 {
4228 /* We have in [temp.param]:
4230 A template-parameter may not be given default arguments
4231 by two different declarations in the same scope. */
4235 }
4238 /* Update the previous template parameters (which are the ones
4239 that will really count) with the new default value. */
4242 /* Update the new parameters, too; they'll be used as the
4243 parameters for any members. */
4245 }
4248 }
4250 /* Simplify EXPR if it is a non-dependent expression. Returns the
4251 (possibly simplified) expression. */
4253 tree
4255 {
4259 /* If we're in a template, but EXPR isn't value dependent, simplify
4260 it. We're supposed to treat:
4262 template <typename T> void f(T[1 + 1]);
4263 template <typename T> void f(T[2]);
4265 as two declarations of the same function, for example. */
4269 {
4270 HOST_WIDE_INT saved_processing_template_decl;
4276 tf_error,
4281 }
4283 }
4285 /* EXPR is an expression which is used in a constant-expression context.
4286 For instance, it could be a VAR_DECL with a constant initializer.
4287 Extract the innermost constant expression.
4289 This is basically a more powerful version of
4290 integral_constant_value, which can be used also in templates where
4291 initializers can maintain a syntactic rather than semantic form
4292 (even if they are non-dependent, for access-checking purposes). */
4294 static tree
4296 {
4298 do
4299 {
4302 }
4306 }
4308 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4309 must be a function or a pointer-to-function type, as specified
4310 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4311 and check that the resulting function has external linkage. */
4313 static tree
4315 {
4329 /* [temp.arg.nontype]/1
4331 A template-argument for a non-type, non-template template-parameter
4332 shall be one of:
4333 [...]
4334 -- the address of an object or function with external linkage. */
4336 {
4341 }
4344 }
4346 /* Attempt to convert the non-type template parameter EXPR to the
4347 indicated TYPE. If the conversion is successful, return the
4348 converted value. If the conversion is unsuccessful, return
4349 NULL_TREE if we issued an error message, or error_mark_node if we
4350 did not. We issue error messages for out-and-out bad template
4351 parameters, but not simply because the conversion failed, since we
4352 might be just trying to do argument deduction. Both TYPE and EXPR
4353 must be non-dependent.
4355 The conversion follows the special rules described in
4356 [temp.arg.nontype], and it is much more strict than an implicit
4357 conversion.
4359 This function is called twice for each template argument (see
4360 lookup_template_class for a more accurate description of this
4361 problem). This means that we need to handle expressions which
4362 are not valid in a C++ source, but can be created from the
4363 first call (for instance, casts to perform conversions). These
4364 hacks can go away after we fix the double coercion problem. */
4366 static tree
4368 {
4369 tree expr_type;
4371 /* Detect immediately string literals as invalid non-type argument.
4372 This special-case is not needed for correctness (we would easily
4373 catch this later), but only to provide better diagnostic for this
4374 common user mistake. As suggested by DR 100, we do not mention
4375 linkage issues in the diagnostic as this is not the point. */
4377 {
4382 }
4384 /* If we are in a template, EXPR may be non-dependent, but still
4385 have a syntactic, rather than semantic, form. For example, EXPR
4386 might be a SCOPE_REF, rather than the VAR_DECL to which the
4387 SCOPE_REF refers. Preserving the qualifying scope is necessary
4388 so that access checking can be performed when the template is
4389 instantiated -- but here we need the resolved form so that we can
4390 convert the argument. */
4396 /* HACK: Due to double coercion, we can get a
4397 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4398 which is the tree that we built on the first call (see
4399 below when coercing to reference to object or to reference to
4400 function). We just strip everything and get to the arg.
4401 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4402 for examples. */
4404 {
4406 {
4407 /* ??? Maybe we could use convert_from_reference here, but we
4408 would need to relax its constraints because the NOP_EXPR
4409 could actually change the type to something more cv-qualified,
4410 and this is not folded by convert_from_reference. */
4421 }
4423 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4424 parameter is a pointer to object, through decay and
4425 qualification conversion. Let's strip everything. */
4427 {
4431 /* Skip the ADDR_EXPR only if it is part of the decay for
4432 an array. Otherwise, it is part of the original argument
4433 in the source code. */
4437 }
4438 }
4440 /* [temp.arg.nontype]/5, bullet 1
4442 For a non-type template-parameter of integral or enumeration type,
4443 integral promotions (_conv.prom_) and integral conversions
4444 (_conv.integral_) are applied. */
4446 {
4451 /* Notice that there are constant expressions like '4 % 0' which
4452 do not fold into integer constants. */
4454 {
4458 }
4460 /* At this point, an implicit conversion does what we want,
4461 because we already know that the expression is of integral
4462 type. */
4467 /* Conversion was allowed: fold it to a bare integer constant. */
4469 }
4470 /* [temp.arg.nontype]/5, bullet 2
4472 For a non-type template-parameter of type pointer to object,
4473 qualification conversions (_conv.qual_) and the array-to-pointer
4474 conversion (_conv.array_) are applied. */
4476 {
4477 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4479 A template-argument for a non-type, non-template template-parameter
4480 shall be one of: [...]
4482 -- the name of a non-type template-parameter;
4483 -- the address of an object or function with external linkage, [...]
4484 expressed as "& id-expression" where the & is optional if the name
4485 refers to a function or array, or if the corresponding
4486 template-parameter is a reference.
4488 Here, we do not care about functions, as they are invalid anyway
4489 for a parameter of type pointer-to-object. */
4492 /* Non-type template parameters are OK. */
4493 ;
4496 {
4498 {
4500 "because %qD is a variable, not the address of "
4504 }
4505 /* Other values, like integer constants, might be valid
4506 non-type arguments of some other type. */
4508 }
4509 else
4510 {
4511 tree decl;
4516 {
4521 }
4523 {
4528 }
4529 }
4538 }
4539 /* [temp.arg.nontype]/5, bullet 3
4541 For a non-type template-parameter of type reference to object, no
4542 conversions apply. The type referred to by the reference may be more
4543 cv-qualified than the (otherwise identical) type of the
4544 template-argument. The template-parameter is bound directly to the
4545 template-argument, which must be an lvalue. */
4547 {
4549 expr_type))
4553 {
4557 }
4560 {
4564 }
4566 /* [temp.arg.nontype]/1
4568 A template-argument for a non-type, non-template template-parameter
4569 shall be one of: [...]
4571 -- the address of an object or function with external linkage. */
4573 {
4578 }
4581 }
4582 /* [temp.arg.nontype]/5, bullet 4
4584 For a non-type template-parameter of type pointer to function, only
4585 the function-to-pointer conversion (_conv.func_) is applied. If the
4586 template-argument represents a set of overloaded functions (or a
4587 pointer to such), the matching function is selected from the set
4588 (_over.over_). */
4590 {
4591 /* If the argument is a template-id, we might not have enough
4592 context information to decay the pointer. */
4594 {
4598 }
4605 {
4609 }
4610 }
4611 /* [temp.arg.nontype]/5, bullet 5
4613 For a non-type template-parameter of type reference to function, no
4614 conversions apply. If the template-argument represents a set of
4615 overloaded functions, the matching function is selected from the set
4616 (_over.over_). */
4618 {
4620 {
4625 }
4632 }
4633 /* [temp.arg.nontype]/5, bullet 6
4635 For a non-type template-parameter of type pointer to member function,
4636 no conversions apply. If the template-argument represents a set of
4637 overloaded member functions, the matching member function is selected
4638 from the set (_over.over_). */
4640 {
4645 /* There is no way to disable standard conversions in
4646 resolve_address_of_overloaded_function (called by
4647 instantiate_type). It is possible that the call succeeded by
4648 converting &B::I to &D::I (where B is a base of D), so we need
4649 to reject this conversion here.
4651 Actually, even if there was a way to disable standard conversions,
4652 it would still be better to reject them here so that we can
4653 provide a superior diagnostic. */
4655 {
4656 /* Make sure we are just one standard conversion off. */
4663 }
4664 }
4665 /* [temp.arg.nontype]/5, bullet 7
4667 For a non-type template-parameter of type pointer to data member,
4668 qualification conversions (_conv.qual_) are applied. */
4670 {
4674 }
4675 /* A template non-type parameter must be one of the above. */
4676 else
4679 /* Sanity check: did we actually convert the argument to the
4680 right type? */
4683 }
4685 /* Subroutine of coerce_template_template_parms, which returns 1 if
4686 PARM_PARM and ARG_PARM match using the rule for the template
4687 parameters of template template parameters. Both PARM and ARG are
4688 template parameters; the rest of the arguments are the same as for
4689 coerce_template_template_parms.
4690 */
4691 static int
4693 tree arg,
4694 tsubst_flags_t complain,
4695 tree in_decl,
4696 tree outer_args)
4697 {
4706 {
4708 /* We encounter instantiations of templates like
4709 template <template <template <class> class> class TT>
4710 class C; */
4711 {
4718 }
4719 /* Fall through. */
4724 /* Argument is a parameter pack but parameter is not. */
4729 /* The tsubst call is used to handle cases such as
4731 template <int> class C {};
4732 template <class T, template <T> class TT> class D {};
4733 D<int, C> d;
4735 i.e. the parameter list of TT depends on earlier parameters. */
4737 && !same_type_p
4744 /* Argument is a parameter pack but parameter is not. */
4751 }
4754 }
4757 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4758 template template parameters. Both PARM_PARMS and ARG_PARMS are
4759 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4760 or PARM_DECL.
4762 Consider the example:
4763 template <class T> class A;
4764 template<template <class U> class TT> class B;
4766 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4767 the parameters to A, and OUTER_ARGS contains A. */
4769 static int
4771 tree arg_parms,
4772 tsubst_flags_t complain,
4773 tree in_decl,
4774 tree outer_args)
4775 {
4786 /* Determine whether we have a parameter pack at the end of the
4787 template template parameter's template parameter list. */
4789 {
4796 {
4810 }
4811 }
4817 /* Check all of the template parameters except the parameter pack at
4818 the end (if any). */
4820 {
4829 outer_args))
4832 }
4835 {
4836 /* Check each of the template parameters in the template
4837 argument against the template parameter pack at the end of
4838 the template template parameter. */
4845 {
4852 outer_args))
4854 }
4855 }
4858 }
4860 /* Verifies that the deduced template arguments (in TARGS) for the
4861 template template parameters (in TPARMS) represent valid bindings,
4862 by comparing the template parameter list of each template argument
4863 to the template parameter list of its corresponding template
4864 template parameter, in accordance with DR150. This
4865 routine can only be called after all template arguments have been
4866 deduced. It will return TRUE if all of the template template
4867 parameter bindings are okay, FALSE otherwise. */
4868 bool
4870 {
4874 /* We're dealing with template parms in this process. */
4880 {
4885 {
4890 {
4891 /* Look inside the argument pack. */
4894 }
4897 {
4901 /* Extract the next argument from the argument
4902 pack. */
4906 /* Look at the pattern of the pack expansion. */
4909 /* Extract the template parameters from the template
4910 argument. */
4916 /* Verify that we can coerce the template template
4917 parameters from the template argument to the template
4918 parameter. This requires an exact match. */
4920 && !coerce_template_template_parms
4922 targ_parms,
4923 tf_none,
4924 tparm,
4925 targs))
4926 {
4929 }
4930 }
4931 }
4932 }
4934 out:
4938 }
4940 /* Convert the indicated template ARG as necessary to match the
4941 indicated template PARM. Returns the converted ARG, or
4942 error_mark_node if the conversion was unsuccessful. Error and
4943 warning messages are issued under control of COMPLAIN. This
4944 conversion is for the Ith parameter in the parameter list. ARGS is
4945 the full set of template arguments deduced so far. */
4947 static tree
4949 tree arg,
4950 tree args,
4951 tsubst_flags_t complain,
4953 tree in_decl)
4954 {
4955 tree orig_arg;
4956 tree val;
4961 {
4962 /* The template argument was the name of some
4963 member function. That's usually
4964 invalid, but static members are OK. In any
4965 case, grab the underlying fields/functions
4966 and issue an error later if required. */
4969 }
4977 /* When determining whether an argument pack expansion is a template,
4978 look at the pattern. */
4982 is_tmpl_type =
4997 {
5003 typename_type,
5007 }
5009 {
5011 {
5013 {
5023 else
5025 }
5026 }
5028 }
5030 {
5032 {
5038 else
5040 }
5042 }
5045 {
5047 {
5049 /* The number of argument required is not known yet.
5050 Just accept it for now. */
5052 else
5053 {
5055 tree argparm;
5061 args))
5062 {
5065 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5066 TEMPLATE_DECL. */
5068 {
5073 {
5076 }
5077 }
5078 }
5079 else
5080 {
5082 {
5088 }
5091 }
5092 }
5093 }
5094 else
5096 /* We only form one instance of each template specialization.
5097 Therefore, if we use a non-canonical variant (i.e., a
5098 typedef), any future messages referring to the type will use
5099 the typedef, which is confusing if those future uses do not
5100 themselves also use the typedef. */
5103 }
5104 else
5105 {
5112 {
5115 else
5116 {
5117 /* Not sure if this is reachable, but it doesn't hurt
5118 to be robust. */
5121 }
5122 }
5124 /* We used to call digest_init here. However, digest_init
5125 will report errors, which we don't want when complain
5126 is zero. More importantly, digest_init will try too
5127 hard to convert things: for example, `0' should not be
5128 converted to pointer type at this point according to
5129 the standard. Accepting this is not merely an
5130 extension, since deciding whether or not these
5131 conversions can occur is part of determining which
5132 function template to call, or whether a given explicit
5133 argument specification is valid. */
5135 else
5142 }
5145 }
5147 /* Coerces the remaining template arguments in INNER_ARGS (from
5148 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5149 Returns the coerced argument pack. PARM_IDX is the position of this
5150 parameter in the template parameter list. ARGS is the original
5151 template argument list. */
5152 static tree
5155 tree args,
5156 tree inner_args,
5158 tree new_args,
5160 tree in_decl,
5161 tsubst_flags_t complain)
5162 {
5165 tree packed_args;
5166 tree argument_pack;
5176 {
5177 /* When the template parameter is a non-type template
5178 parameter pack whose type uses parameter packs, we need
5179 to look at each of the template arguments
5180 separately. Build a vector of the types for these
5181 non-type template parameters in PACKED_TYPES. */
5182 tree expansion
5190 /* Check that we have the right number of arguments. */
5194 {
5195 int needed_parms
5200 }
5202 /* If we aren't able to check the actual arguments now
5203 (because they haven't been expanded yet), we can at least
5204 verify that all of the types used for the non-type
5205 template parameter pack are, in fact, valid for non-type
5206 template parameters. */
5209 {
5212 {
5216 }
5217 }
5218 }
5220 /* Convert the remaining arguments, which will be a part of the
5221 parameter pack "parm". */
5223 {
5228 {
5229 /* When we have a vector of types (corresponding to the
5230 non-type template parameter pack that uses parameter
5231 packs in its type, as mention above), and the
5232 argument is not an expansion (which expands to a
5233 currently unknown number of arguments), clone the
5234 parm and give it the next type in PACKED_TYPES. */
5238 }
5243 in_decl);
5247 }
5252 else
5253 {
5258 }
5262 }
5264 /* Convert all template arguments to their appropriate types, and
5265 return a vector containing the innermost resulting template
5266 arguments. If any error occurs, return error_mark_node. Error and
5267 warning messages are issued under control of COMPLAIN.
5269 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5270 for arguments not specified in ARGS. Otherwise, if
5271 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5272 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5273 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5274 ARGS. */
5276 static tree
5278 tree args,
5279 tree in_decl,
5280 tsubst_flags_t complain,
5283 {
5285 tree inner_args;
5286 tree new_args;
5287 tree new_inner_args;
5290 /* When used as a boolean value, indicates whether this is a
5291 variadic template parameter list. Since it's an int, we can also
5292 subtract it from nparms to get the number of non-variadic
5293 parameters. */
5298 /* Determine if there are any parameter packs. */
5300 {
5304 }
5307 /* If there are 0 or 1 parameter packs, we need to expand any argument
5308 packs so that we can deduce a parameter pack from some non-packed args
5309 followed by an argument pack, as in variadic85.C. If there are more
5310 than that, we need to leave argument packs intact so the arguments are
5311 assigned to the right parameter packs. This should only happen when
5312 dealing with a nested class inside a partial specialization of a class
5313 template, as in variadic92.C. */
5320 && require_all_args
5321 && (!use_default_args
5324 {
5326 {
5329 {
5332 }
5339 }
5342 }
5344 /* We need to evaluate the template arguments, even though this
5345 template-id may be nested within a "sizeof". */
5351 {
5352 tree arg;
5353 tree parm;
5355 /* Get the Ith template parameter. */
5359 {
5362 }
5364 /* Calculate the next argument. */
5367 else
5372 {
5373 /* All remaining arguments will be placed in the
5374 template parameter pack PARM. */
5380 /* Store this argument. */
5382 lost++;
5385 /* We are done with all of the arguments. */
5389 }
5391 {
5393 {
5395 {
5396 /* FIXME this restriction was removed by N2555; see
5397 bug 35722. */
5398 /* If ARG is a pack expansion, but PARM is not a
5399 template parameter pack (if it were, we would have
5400 handled it above), we're trying to expand into a
5401 fixed-length argument list. */
5405 else
5408 }
5410 }
5411 }
5413 /* There must be a default arg in this case. */
5416 else
5420 {
5423 }
5425 /* This only occurs if there was an error in the template
5426 parameter list itself (which we would already have
5427 reported) that we are trying to recover from, e.g., a class
5428 template with a parameter list such as
5429 template<typename..., typename>. */
5431 else
5437 lost++;
5439 }
5446 }
5448 /* Returns 1 if template args OT and NT are equivalent. */
5450 static int
5452 {
5457 /* For member templates */
5464 {
5481 }
5486 else
5488 }
5490 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5491 of template arguments. Returns 0 otherwise. */
5493 int
5495 {
5502 {
5508 }
5510 }
5512 static void
5514 {
5524 /* We are called both from instantiate_decl, where we've already had a
5525 tinst_level pushed, and instantiate_template, where we haven't.
5526 Compensate. */
5537 else
5546 }
5549 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5550 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5551 documentation for TEMPLATE_ID_EXPR. */
5553 tree
5555 {
5556 tree type;
5566 {
5568 unknown_type_node,
5570 arglist);
5572 }
5579 }
5581 /* Within the scope of a template class S<T>, the name S gets bound
5582 (in build_self_reference) to a TYPE_DECL for the class, not a
5583 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5584 or one of its enclosing classes, and that type is a template,
5585 return the associated TEMPLATE_DECL. Otherwise, the original
5586 DECL is returned. */
5588 tree
5590 {
5597 }
5599 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5600 parameters, find the desired type.
5602 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5604 IN_DECL, if non-NULL, is the template declaration we are trying to
5605 instantiate.
5607 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5608 the class we are looking up.
5610 Issue error and warning messages under control of COMPLAIN.
5612 If the template class is really a local class in a template
5613 function, then the FUNCTION_CONTEXT is the function in which it is
5614 being instantiated.
5616 ??? Note that this function is currently called *twice* for each
5617 template-id: the first time from the parser, while creating the
5618 incomplete type (finish_template_type), and the second type during the
5619 real instantiation (instantiate_template_class). This is surely something
5620 that we want to avoid. It also causes some problems with argument
5621 coercion (see convert_nontype_argument for more information on this). */
5623 tree
5625 tree arglist,
5626 tree in_decl,
5627 tree context,
5629 tsubst_flags_t complain)
5630 {
5632 tree t;
5637 {
5641 else
5642 {
5649 }
5652 }
5654 {
5657 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5658 an implicit typename for the second A. Deal with it. */
5663 {
5666 }
5667 }
5670 {
5673 }
5677 {
5681 }
5683 /* Issue an error message if we didn't find a template. */
5685 {
5689 }
5692 /* Make sure it's a user visible template, if it was named by
5693 the user. */
5696 {
5698 {
5702 }
5704 }
5709 {
5710 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5711 template arguments */
5713 tree parm;
5714 tree arglist2;
5715 tree outer;
5719 /* Consider an example where a template template parameter declared as
5721 template <class T, class U = std::allocator<T> > class TT
5723 The template parameter level of T and U are one level larger than
5724 of TT. To proper process the default argument of U, say when an
5725 instantiation `TT<int>' is seen, we need to build the full
5726 arguments containing {int} as the innermost level. Outer levels,
5727 available when not appearing as default template argument, can be
5728 obtained from the arguments of the enclosing template.
5730 Suppose that TT is later substituted with std::vector. The above
5731 instantiation is `TT<int, std::allocator<T> >' with TT at
5732 level 1, and T at level 2, while the template arguments at level 1
5733 becomes {std::vector} and the inner level 2 is {int}. */
5739 /* This is an argument of the current template, so we haven't set
5740 DECL_CONTEXT yet. */
5747 complain,
5757 }
5758 else
5759 {
5761 tree gen_tmpl;
5762 tree type_decl;
5774 {
5775 /* We've been given an incomplete set of template arguments.
5776 For example, given:
5778 template <class T> struct S1 {
5779 template <class U> struct S2 {};
5780 template <class U> struct S2<U*> {};
5781 };
5783 we will be called with an ARGLIST of `U*', but the
5784 TEMPLATE will be `template <class T> template
5785 <class U> struct S1<T>::S2'. We must fill in the missing
5786 arguments. */
5787 arglist
5789 arglist);
5791 }
5793 /* Now we should have enough arguments. */
5796 /* From here on, we're only interested in the most general
5797 template. */
5800 /* Calculate the BOUND_ARGS. These will be the args that are
5801 actually tsubst'd into the definition to create the
5802 instantiation. */
5804 {
5805 /* We have multiple levels of arguments to coerce, at once. */
5815 {
5818 complain,
5822 /* Don't process further if one of the levels fails. */
5824 {
5825 /* Restore the ARGLIST to its full size. */
5828 }
5832 /* We temporarily reduce the length of the ARGLIST so
5833 that coerce_template_parms will see only the arguments
5834 corresponding to the template parameters it is
5835 examining. */
5837 }
5839 /* Restore the ARGLIST to its full size. */
5843 }
5844 else
5845 arglist
5848 templ,
5849 complain,
5854 /* We were unable to bind the arguments. */
5857 /* In the scope of a template class, explicit references to the
5858 template class refer to the type of the template, not any
5859 instantiation of it. For example, in:
5861 template <class T> class C { void f(C<T>); }
5863 the `C<T>' is just the same as `C'. Outside of the
5864 class, however, such a reference is an instantiation. */
5866 arglist))
5867 {
5871 {
5872 tree ctx;
5882 /* We're not in the scope of the class, so the
5883 TEMPLATE_TYPE is not the type we want after all. */
5885 found_ctx:;
5886 }
5887 }
5891 /* If we already have this specialization, return it. */
5897 /* This type is a "partial instantiation" if any of the template
5898 arguments still involve template parameters. Note that we set
5899 IS_PARTIAL_INSTANTIATION for partial specializations as
5900 well. */
5903 /* If the deduced arguments are invalid, then the binding
5904 failed. */
5908 complain))
5914 {
5919 }
5926 /* Create the type. */
5928 {
5930 {
5936 }
5937 else
5938 {
5939 /* We don't want to call start_enum for this type, since
5940 the values for the enumeration constants may involve
5941 template parameters. And, no one should be interested
5942 in the enumeration constants for such a type. */
5945 }
5946 }
5947 else
5948 {
5955 /* A local class. Make sure the decl gets registered properly. */
5960 /* This instantiation is another name for the primary
5961 template type. Set the TYPE_CANONICAL field
5962 appropriately. */
5965 /* Some of the template arguments require structural
5966 equality testing, so this template class requires
5967 structural equality testing. */
5969 }
5971 /* If we called start_enum or pushtag above, this information
5972 will already be set up. */
5974 {
5982 }
5983 else
5991 {
5994 }
5996 /* Set up the template information. We have to figure out which
5997 template is the immediate parent if this is a full
5998 instantiation. */
6001 /* This case is easy; there are no member templates involved. */
6003 else
6004 {
6005 /* This is a full instantiation of a member template. Look
6006 for a partial instantiation of which this is an instance. */
6010 {
6014 /* We only want partial instantiations, here, not
6015 specializations or full instantiations. */
6020 /* Temporarily reduce by one the number of levels in the
6021 ARGLIST and in FOUND so as to avoid comparing the
6022 last set of arguments. */
6026 /* See if the arguments match. If they do, then TMPL is
6027 the partial instantiation we want. */
6030 /* Restore the argument vectors to their full size. */
6035 {
6038 }
6039 }
6042 {
6043 /* There was no partial instantiation. This happens
6044 where C<T> is a member template of A<T> and it's used
6045 in something like
6047 template <typename T> struct B { A<T>::C<int> m; };
6048 B<float>;
6050 Create the partial instantiation.
6051 */
6055 }
6056 }
6065 /* Now that the type has been registered on the instantiations
6066 list, we set up the enumerators. Because the enumeration
6067 constants may involve the enumeration type itself, we make
6068 sure to register the type first, and then create the
6069 constants. That way, doing tsubst_expr for the enumeration
6070 constants won't result in recursive calls here; we'll find
6071 the instantiation and exit above. */
6075 /* If the type makes use of template parameters, the
6076 code that generates debugging information will crash. */
6079 /* Possibly limit visibility based on template args. */
6084 }
6086 }
6087 \f
6088 struct pair_fn_data
6089 {
6090 tree_fn_t fn;
6092 /* True when we should also visit template parameters that occur in
6093 non-deduced contexts. */
6096 };
6098 /* Called from for_each_template_parm via walk_tree. */
6100 static tree
6102 {
6115 {
6119 /* Fall through. */
6142 /* Since we're not going to walk subtrees, we have to do this
6143 explicitly here. */
6147 /* Fall through. */
6150 /* Check the return type. */
6155 /* Check the parameter types. Since default arguments are not
6156 instantiated until they are needed, the TYPE_ARG_TYPES may
6157 contain expressions that involve template parameters. But,
6158 no-one should be looking at them yet. And, once they're
6159 instantiated, they don't contain template parameters, so
6160 there's no point in looking at them then, either. */
6161 {
6162 tree parm;
6169 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6170 want walk_tree walking into them itself. */
6172 }
6189 /* Fall through. */
6205 /* Record template parameters such as `T' inside `TT<T>'. */
6209 /* Fall through. */
6221 /* A template template parameter is encountered. */
6227 /* Already substituted template template parameter */
6250 /* If there's no type, then this thing must be some expression
6251 involving template parameters. */
6272 }
6274 /* We didn't find any template parameters we liked. */
6276 }
6278 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6279 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6280 call FN with the parameter and the DATA.
6281 If FN returns nonzero, the iteration is terminated, and
6282 for_each_template_parm returns 1. Otherwise, the iteration
6283 continues. If FN never returns a nonzero value, the value
6284 returned by for_each_template_parm is 0. If FN is NULL, it is
6285 considered to be the function which always returns 1.
6287 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6288 parameters that occur in non-deduced contexts. When false, only
6289 visits those template parameters that can be deduced. */
6291 static int
6295 {
6299 /* Set up. */
6304 /* Walk the tree. (Conceptually, we would like to walk without
6305 duplicates, but for_each_template_parm_r recursively calls
6306 for_each_template_parm, so we would need to reorganize a fair
6307 bit to use walk_tree_without_duplicates, so we keep our own
6308 visited list.) */
6311 else
6314 for_each_template_parm_r,
6318 /* Clean up. */
6320 {
6323 }
6326 }
6328 /* Returns true if T depends on any template parameter. */
6330 int
6332 {
6358 else
6359 {
6362 }
6367 }
6369 /* Returns true if T depends on any template parameter with level LEVEL. */
6371 int
6373 {
6376 }
6380 #ifdef GATHER_STATISTICS
6382 #endif
6386 /* We're starting to instantiate D; record the template instantiation context
6387 for diagnostics and to restore it later. */
6389 static int
6391 {
6395 {
6396 /* If the instantiation in question still has unbound template parms,
6397 we don't really care if we can't instantiate it, so just return.
6398 This happens with base instantiation for implicit `typename'. */
6410 }
6420 #ifdef GATHER_STATISTICS
6423 #endif
6427 }
6429 /* We're done instantiating this template; return to the instantiation
6430 context. */
6432 static void
6434 {
6435 /* Restore the filename and line number stashed away when we started
6436 this instantiation. */
6441 }
6443 /* We're instantiating a deferred template; restore the template
6444 instantiation context in which the instantiation was requested, which
6445 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6447 static tree
6449 {
6459 }
6461 /* Returns the TINST_LEVEL which gives the original instantiation
6462 context. */
6466 {
6472 }
6474 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
6476 bool
6478 {
6479 tree parms;
6496 }
6498 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6499 vector of template arguments, as for tsubst.
6501 Returns an appropriate tsubst'd friend declaration. */
6503 static tree
6505 {
6506 tree new_friend;
6511 /* This was a friend declared with an explicit template
6512 argument list, e.g.:
6514 friend void f<>(T);
6516 to indicate that f was a template instantiation, not a new
6517 function declaration. Now, we have to figure out what
6518 instantiation of what template. */
6519 {
6521 tree new_args;
6522 tree tmpl;
6525 /* Friend functions are looked up in the containing namespace scope.
6526 We must enter that scope, to avoid finding member functions of the
6527 current class with same name. */
6542 tsk_none);
6544 }
6548 /* The NEW_FRIEND will look like an instantiation, to the
6549 compiler, but is not an instantiation from the point of view of
6550 the language. For example, we might have had:
6552 template <class T> struct S {
6553 template <class U> friend void f(T, U);
6554 };
6556 Then, in S<int>, template <class U> void f(int, U) is not an
6557 instantiation of anything. */
6563 {
6567 }
6569 /* The mangled name for the NEW_FRIEND is incorrect. The function
6570 is not a template instantiation and should not be mangled like
6571 one. Therefore, we forget the mangling here; we'll recompute it
6572 later if we need it. */
6574 {
6577 }
6580 {
6581 tree old_decl;
6582 tree new_friend_template_info;
6583 tree new_friend_result_template_info;
6584 tree ns;
6587 /* We must save some information from NEW_FRIEND before calling
6588 duplicate decls since that function will free NEW_FRIEND if
6589 possible. */
6591 new_friend_is_defn =
6596 {
6597 /* This declaration is a `primary' template. */
6600 new_friend_result_template_info
6602 }
6603 else
6606 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6610 /* Inside pushdecl_namespace_level, we will push into the
6611 current namespace. However, the friend function should go
6612 into the namespace of the template. */
6622 {
6623 /* This new friend declaration matched an existing
6624 declaration. For example, given:
6626 template <class T> void f(T);
6627 template <class U> class C {
6628 template <class T> friend void f(T) {}
6629 };
6631 the friend declaration actually provides the definition
6632 of `f', once C has been instantiated for some type. So,
6633 old_decl will be the out-of-class template declaration,
6634 while new_friend is the in-class definition.
6636 But, if `f' was called before this point, the
6637 instantiation of `f' will have DECL_TI_ARGS corresponding
6638 to `T' but not to `U', references to which might appear
6639 in the definition of `f'. Previously, the most general
6640 template for an instantiation of `f' was the out-of-class
6641 version; now it is the in-class version. Therefore, we
6642 run through all specialization of `f', adding to their
6643 DECL_TI_ARGS appropriately. In particular, they need a
6644 new set of outer arguments, corresponding to the
6645 arguments for this class instantiation.
6647 The same situation can arise with something like this:
6649 friend void f(int);
6650 template <class T> class C {
6651 friend void f(T) {}
6652 };
6654 when `C<int>' is instantiated. Now, `f(int)' is defined
6655 in the class. */
6658 /* On the other hand, if the in-class declaration does
6659 *not* provide a definition, then we don't want to alter
6660 existing definitions. We can just leave everything
6661 alone. */
6662 ;
6663 else
6664 {
6665 /* Overwrite whatever template info was there before, if
6666 any, with the new template information pertaining to
6667 the declaration. */
6673 old_decl);
6674 else
6675 {
6676 tree t;
6677 tree new_friend_args;
6686 {
6692 }
6694 /* Now, since specializations are always supposed to
6695 hang off of the most general template, we must move
6696 them. */
6699 {
6704 }
6705 }
6706 }
6708 /* The information from NEW_FRIEND has been merged into OLD_DECL
6709 by duplicate_decls. */
6711 }
6712 }
6713 else
6714 {
6718 /* In the code
6719 template <class T> class C {
6720 template <class U> friend void C1<U>::f (); // case 1
6721 friend void C2<T>::f (); // case 2
6722 };
6723 we only need to make sure CONTEXT is a complete type for
6724 case 2. To distinguish between the two cases, we note that
6725 CONTEXT of case 1 remains dependent type after tsubst while
6726 this isn't true for case 2. */
6736 {
6737 /* Check to see that the declaration is really present, and,
6738 possibly obtain an improved declaration. */
6744 }
6745 }
6748 }
6750 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6751 template arguments, as for tsubst.
6753 Returns an appropriate tsubst'd friend type or error_mark_node on
6754 failure. */
6756 static tree
6758 {
6759 tree friend_type;
6760 tree tmpl;
6761 tree context;
6766 {
6769 else
6771 }
6773 /* Look for a class template declaration. We look for hidden names
6774 because two friend declarations of the same template are the
6775 same. For example, in:
6777 struct A {
6778 template <typename> friend class F;
6779 };
6780 template <typename> struct B {
6781 template <typename> friend class F;
6782 };
6784 both F templates are the same. */
6789 /* But, if we don't find one, it might be because we're in a
6790 situation like this:
6792 template <class T>
6793 struct S {
6794 template <class U>
6795 friend struct S;
6796 };
6798 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6799 for `S<int>', not the TEMPLATE_DECL. */
6801 {
6804 }
6807 {
6808 /* The friend template has already been declared. Just
6809 check to see that the declarations match, and install any new
6810 default parameters. We must tsubst the default parameters,
6811 of course. We only need the innermost template parameters
6812 because that is all that redeclare_class_template will look
6813 at. */
6816 {
6817 tree parms;
6818 location_t saved_input_location;
6827 }
6830 }
6831 else
6832 {
6833 /* The friend template has not already been declared. In this
6834 case, the instantiation of the template class will cause the
6835 injection of this template into the global scope. */
6840 /* The new TMPL is not an instantiation of anything, so we
6841 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6842 the new type because that is supposed to be the corresponding
6843 template decl, i.e., TMPL. */
6850 /* Inject this template into the global scope. */
6852 }
6855 {
6858 else
6860 }
6863 }
6865 /* Returns zero if TYPE cannot be completed later due to circularity.
6866 Otherwise returns one. */
6868 static int
6870 {
6880 else
6882 }
6884 /* Apply any attributes which had to be deferred until instantiation
6885 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6886 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6888 static void
6891 {
6893 tree t;
6898 {
6902 }
6905 {
6909 }
6910 else
6914 {
6919 {
6922 {
6925 /* If this is a lock attribute with arguments, we defer the
6926 instantiation until the whole class specification has been
6927 instantiated because the lock attribute arguments could
6928 reference data members declared later (lexically). */
6931 {
6943 }
6944 /* If the first attribute argument is an identifier, don't
6945 pass it through tsubst. Attributes like mode, format,
6946 cleanup and several target specific attributes expect it
6947 unmodified. */
6953 {
6954 tree chain
6956 in_decl,
6961 chain);
6962 }
6963 else
6969 }
6970 else
6972 }
6975 }
6976 }
6978 /* Reverse the order of elements in the pending attribute list, PA_LIST,
6979 and return the new head of the list (old last element). */
6983 {
6986 {
6990 }
6992 }
6994 tree
6996 {
6998 tree typedecl;
6999 tree pbinfo;
7000 tree base_list;
7010 /* Figure out which template is being instantiated. */
7014 /* Determine what specialization of the original template to
7015 instantiate. */
7018 {
7021 }
7023 {
7024 /* This TYPE is actually an instantiation of a partial
7025 specialization. We replace the innermost set of ARGS with
7026 the arguments appropriate for substitution. For example,
7027 given:
7029 template <class T> struct S {};
7030 template <class T> struct S<T*> {};
7032 and supposing that we are instantiating S<int*>, ARGS will
7033 presently be {int*} -- but we need {int}. */
7036 }
7037 else
7038 {
7041 }
7043 /* If the template we're instantiating is incomplete, then clearly
7044 there's nothing we can do. */
7048 /* If we've recursively instantiated too many templates, stop. */
7052 /* Now we're really doing the instantiation. Mark the type as in
7053 the process of being defined. */
7056 /* We may be in the middle of deferred access check. Disable
7057 it now. */
7064 /* Set the input location to the template definition. This is needed
7065 if tsubsting causes an error. */
7086 {
7089 }
7093 /* We should never instantiate a nested class before its enclosing
7094 class; we need to look up the nested class by name before we can
7095 instantiate it, and that lookup should instantiate the enclosing
7096 class. */
7103 {
7104 tree pbase_binfo;
7106 tree pushed_scope;
7109 /* We must enter the scope containing the type, as that is where
7110 the accessibility of types named in dependent bases are
7111 looked up from. */
7114 /* Substitute into each of the bases to determine the actual
7115 basetypes. */
7117 {
7118 tree base;
7124 {
7125 expanded_bases =
7132 }
7135 {
7137 /* Extract the already-expanded base class. */
7139 else
7140 /* Substitute to figure out the base class. */
7142 NULL_TREE);
7150 }
7151 }
7153 /* The list is now in reverse order; correct that. */
7158 }
7159 /* Now call xref_basetypes to set up all the base-class
7160 information. */
7167 /* Now that our base classes are set up, enter the scope of the
7168 class, so that name lookups into base classes, etc. will work
7169 correctly. This is precisely analogous to what we do in
7170 begin_class_definition when defining an ordinary non-template
7171 class, except we also need to push the enclosing classes. */
7174 /* Now members are processed in the order of declaration. */
7177 {
7181 {
7183 {
7184 /* Build new CLASSTYPE_NESTED_UTDS. */
7186 tree newtag;
7192 /* If the member is a class template, then -- even after
7193 substitution -- there may be dependent types in the
7194 template argument list for the class. We increment
7195 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7196 that function will assume that no types are dependent
7197 when outside of a template. */
7207 {
7211 /* Unfortunately, lookup_template_class sets
7212 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7213 instantiation (i.e., for the type of a member
7214 template class nested within a template class.)
7215 This behavior is required for
7216 maybe_process_partial_specialization to work
7217 correctly, but is not accurate in this case;
7218 the TAG is not an instantiation of anything.
7219 (The corresponding TEMPLATE_DECL is an
7220 instantiation, but the TYPE is not.) */
7223 /* Now, we call pushtag to put this NEWTAG into the scope of
7224 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7225 pushtag calling push_template_decl. We don't have to do
7226 this for enums because it will already have been done in
7227 tsubst_enum. */
7231 }
7232 }
7235 {
7236 /* Build new TYPE_METHODS. */
7237 tree r;
7246 }
7247 else
7248 {
7249 /* Build new TYPE_FIELDS. */
7251 {
7252 tree condition =
7260 }
7262 {
7263 tree r;
7265 /* The file and line for this declaration, to
7266 assist in error message reporting. Since we
7267 called push_tinst_level above, we don't need to
7268 restore these. */
7277 {
7278 /* In [temp.inst]:
7280 [t]he initialization (and any associated
7281 side-effects) of a static data member does
7282 not occur unless the static data member is
7283 itself used in a way that requires the
7284 definition of the static data member to
7285 exist.
7287 Therefore, we do not substitute into the
7288 initialized for the static data member here. */
7289 finish_static_data_member_decl
7297 }
7299 {
7300 /* Determine whether R has a valid type and can be
7301 completed later. If R is invalid, then it is
7302 replaced by error_mark_node so that it will not be
7303 added to TYPE_FIELDS. */
7309 {
7312 }
7313 }
7315 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7316 such a thing will already have been added to the field
7317 list by tsubst_enum in finish_member_declaration in the
7318 CLASSTYPE_NESTED_UTDS case above. */
7322 {
7325 }
7326 }
7327 }
7328 }
7329 else
7330 {
7332 {
7333 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7339 {
7340 /* template <class T> friend class C; */
7343 }
7345 {
7346 /* template <class T> friend class C::D; */
7352 }
7354 {
7355 /* This could be either
7357 friend class T::C;
7359 when dependent_type_p is false or
7361 template <class U> friend class T::C;
7363 otherwise. */
7366 /* Bump processing_template_decl for correct
7367 dependent_type_p calculation. */
7372 }
7375 {
7376 /* friend class C;
7378 where C hasn't been declared yet. Let's lookup name
7379 from namespace scope directly, bypassing any name that
7380 come from dependent base class. */
7383 /* The call to xref_tag_from_type does injection for friend
7384 classes. */
7386 friend_type =
7390 }
7392 /* friend class C<T>; */
7395 /* Otherwise it's
7397 friend class C;
7399 where C is already declared or
7401 friend class C<int>;
7403 We don't have to do anything in these cases. */
7406 /* Trick make_friend_class into realizing that the friend
7407 we're adding is a template, not an ordinary class. It's
7408 important that we use make_friend_class since it will
7409 perform some error-checking and output cross-reference
7410 information. */
7418 }
7419 else
7420 {
7421 /* Build new DECL_FRIENDLIST. */
7422 tree r;
7424 /* The file and line for this declaration, to
7425 assist in error message reporting. Since we
7426 called push_tinst_level above, we don't need to
7427 restore these. */
7431 {
7434 }
7439 {
7442 }
7443 }
7444 }
7445 }
7447 /* Set the file and line number information to whatever is given for
7448 the class itself. This puts error messages involving generated
7449 implicit functions at a predictable point, and the same point
7450 that would be used for non-template classes. */
7457 /* Now that the class is complete, instantiate default arguments for
7458 any member functions. We don't do this earlier because the
7459 default arguments may reference members of the class. */
7463 /* Implicitly generated member functions will not have template
7464 information; they are not instantiations, but instead are
7465 created "fresh" for each instantiation. */
7469 /* Instantiate the deferred lock attributes and apply them to the
7470 corresponding decls. We don't do this earlier because the lock
7471 attribute arguments may reference data members of the class. */
7473 {
7478 {
7486 }
7490 }
7497 /* The vtable for a template class can be emitted in any translation
7498 unit in which the class is instantiated. When there is no key
7499 method, however, finish_struct_1 will already have added TYPE to
7500 the keyed_classes list. */
7505 }
7507 static tree
7509 {
7510 tree r;
7516 else
7517 {
7521 }
7523 }
7525 /* Substitute ARGS into T, which is an pack expansion
7526 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7527 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7528 (if only a partial substitution could be performed) or
7529 ERROR_MARK_NODE if there was an error. */
7530 tree
7532 tree in_decl)
7533 {
7534 tree pattern;
7537 tree result;
7543 /* Determine the argument packs that will instantiate the parameter
7544 packs used in the expansion expression. While we're at it,
7545 compute the number of arguments to be expanded and make sure it
7546 is consistent. */
7549 {
7556 else
7557 {
7564 }
7571 /* This can only happen if we forget to expand an argument
7572 pack somewhere else. Just return an error, silently. */
7573 {
7577 }
7582 {
7587 /* The argument pack that the parameter maps to is just an
7588 expansion of the parameter itself, such as one would
7589 find in the implicit typedef of a class inside the
7590 class itself. Consider this parameter "unsubstituted",
7591 so that we will maintain the outer pack expansion. */
7593 }
7596 {
7600 /* It's all-or-nothing with incomplete argument packs. */
7608 {
7611 }
7613 {
7617 pattern);
7618 else
7621 pattern);
7623 }
7625 /* Keep track of the parameter packs and their corresponding
7626 argument packs. */
7629 }
7630 else
7631 /* We can't substitute for this parameter pack. */
7634 unsubstituted_packs);
7635 }
7637 /* We cannot expand this expansion expression, because we don't have
7638 all of the argument packs we need. Substitute into the pattern
7639 and return a PACK_EXPANSION_*. The caller will need to deal with
7640 that. */
7643 in_decl));
7645 /* We could not find any argument packs that work. */
7649 /* For each argument in each argument pack, substitute into the
7650 pattern. */
7653 {
7654 /* For parameter pack, change the substitution of the parameter
7655 pack to the ith argument in its argument pack, then expand
7656 the pattern. */
7658 {
7662 {
7663 /* Select the Ith argument from the pack. */
7669 }
7670 else
7671 {
7677 {
7678 /* Select the Ith argument from the pack. */
7682 }
7684 /* Update the corresponding argument. */
7686 }
7687 }
7689 /* Substitute into the PATTERN with the altered arguments. */
7694 else
7698 /* When we have incomplete argument packs, the last "expanded"
7699 result is itself a pack expansion, which allows us
7700 to deduce more arguments. */
7705 {
7708 }
7709 }
7711 /* Update ARGS to restore the substitution from parameter packs to
7712 their argument packs. */
7714 {
7719 else
7720 {
7724 /* Update the corresponding argument. */
7728 else
7730 }
7731 }
7734 }
7736 /* Substitute ARGS into the vector or list of template arguments T. */
7738 static tree
7740 {
7747 {
7749 tree new_arg;
7754 {
7755 /* Substitute into an expansion expression. */
7759 /* Add to the expanded length adjustment the number of
7760 expanded arguments. We subtract one from this
7761 measurement, because the argument pack expression
7762 itself is already counted as 1 in
7763 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7764 the argument pack is empty. */
7766 }
7768 {
7769 /* Substitute into each of the arguments. */
7773 new_arg,
7787 }
7788 }
7789 else
7798 }
7803 /* Make space for the expanded arguments coming from template
7804 argument packs. */
7807 {
7811 {
7814 /* Now expand the template argument pack "in place". */
7817 }
7818 else
7819 {
7821 out++;
7822 }
7823 }
7826 }
7828 /* Return the result of substituting ARGS into the template parameters
7829 given by PARMS. If there are m levels of ARGS and m + n levels of
7830 PARMS, then the result will contain n levels of PARMS. For
7831 example, if PARMS is `template <class T> template <class U>
7832 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7833 result will be `template <int*, double, class V>'. */
7835 static tree
7837 {
7841 /* When substituting into a template, we must set
7842 PROCESSING_TEMPLATE_DECL as the template parameters may be
7843 dependent if they are based on one-another, and the dependency
7844 predicates are short-circuit outside of templates. */
7851 {
7852 tree new_vec =
7857 {
7858 tree tuple;
7859 tree default_value;
7860 tree parm_decl;
7882 }
7888 }
7893 }
7895 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7896 type T. If T is not an aggregate or enumeration type, it is
7897 handled as if by tsubst. IN_DECL is as for tsubst. If
7898 ENTERING_SCOPE is nonzero, T is the context for a template which
7899 we are presently tsubst'ing. Return the substituted value. */
7901 static tree
7903 tree args,
7904 tsubst_flags_t complain,
7905 tree in_decl,
7907 {
7912 {
7917 /* Else fall through. */
7921 {
7922 tree argvec;
7923 tree context;
7924 tree r;
7927 /* In "sizeof(X<I>)" we need to evaluate "I". */
7931 /* First, determine the context for the type we are looking
7932 up. */
7935 {
7938 /* If context is a nested class inside a class template,
7939 it may still need to be instantiated (c++/33959). */
7942 }
7944 /* Then, figure out what arguments are appropriate for the
7945 type we are trying to find. For example, given:
7947 template <class T> struct S;
7948 template <class T, class U> void f(T, U) { S<U> su; }
7950 and supposing that we are instantiating f<int, double>,
7951 then our ARGS will be {int, double}, but, when looking up
7952 S we only want {double}. */
7957 else
7958 {
7962 }
7967 }
7968 else
7969 /* This is not a template type, so there's nothing to do. */
7974 }
7975 }
7977 /* Substitute into the default argument ARG (a default argument for
7978 FN), which has the indicated TYPE. */
7980 tree
7982 {
7986 /* This default argument came from a template. Instantiate the
7987 default argument here, not in tsubst. In the case of
7988 something like:
7990 template <class T>
7991 struct S {
7992 static T t();
7993 void f(T = t());
7994 };
7996 we must be careful to do name lookup in the scope of S<T>,
7997 rather than in the current class. */
7999 /* The "this" pointer is not valid in a default argument. */
8001 {
8006 }
8009 /* The default argument expression may cause implicitly defined
8010 member functions to be synthesized, which will result in garbage
8011 collection. We must treat this situation as if we were within
8012 the body of function so as to avoid collecting live data on the
8013 stack. */
8021 /* Restore the "this" pointer. */
8023 {
8026 }
8030 /* Make sure the default argument is reasonable. */
8034 }
8036 /* Substitute into all the default arguments for FN. */
8038 static void
8040 {
8041 tree arg;
8042 tree tmpl_args;
8046 /* If this function is not yet instantiated, we certainly don't need
8047 its default arguments. */
8052 arg;
8058 }
8060 /* Substitute the ARGS into the T, which is a _DECL. Return the
8061 result of the substitution. Issue error and warning messages under
8062 control of COMPLAIN. */
8064 static tree
8066 {
8067 location_t saved_loc;
8071 /* Set the filename and linenumber to improve error-reporting. */
8076 {
8078 {
8079 /* We can get here when processing a member function template,
8080 member class template, and template template parameter of
8081 a template class. */
8083 tree spec;
8084 tree tmpl_args;
8085 tree full_args;
8088 {
8089 /* Template template parameter is treated here. */
8101 complain);
8104 }
8106 /* We might already have an instance of this template.
8107 The ARGS are for the surrounding class type, so the
8108 full args contain the tsubst'd args for the context,
8109 plus the innermost args from the template decl. */
8113 /* Because this is a template, the arguments will still be
8114 dependent, even after substitution. If
8115 PROCESSING_TEMPLATE_DECL is not set, the dependency
8116 predicates will short-circuit. */
8124 /* tsubst_template_args doesn't copy the vector if
8125 nothing changed. But, *something* should have
8126 changed. */
8132 {
8135 }
8137 /* Make a new template decl. It will be similar to the
8138 original, but will record the current template arguments.
8139 We also create a new function declaration, which is just
8140 like the old one, but points to this new template, rather
8141 than the old one. */
8149 {
8150 tree new_type;
8162 }
8163 else
8164 {
8165 tree new_decl;
8177 }
8183 /* The template parameters for this new template are all the
8184 template parameters for the old template, except the
8185 outermost level of parameters. */
8188 complain);
8194 /* Record this non-type partial instantiation. */
8198 }
8202 {
8203 tree ctx;
8206 tree gen_tmpl;
8207 tree type;
8212 /* Nobody should be tsubst'ing into non-template functions. */
8216 {
8217 tree spec;
8220 /* If T is not dependent, just return it. We have to
8221 increment PROCESSING_TEMPLATE_DECL because
8222 value_dependent_expression_p assumes that nothing is
8223 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8230 /* Calculate the most general template of which R is a
8231 specialization, and the complete set of arguments used to
8232 specialize R. */
8238 /* Check to see if we already have this specialization. */
8243 {
8246 }
8248 /* We can see more levels of arguments than parameters if
8249 there was a specialization of a member template, like
8250 this:
8252 template <class T> struct S { template <class U> void f(); }
8253 template <> template <class U> void S<int>::f(U);
8255 Here, we'll be substituting into the specialization,
8256 because that's where we can find the code we actually
8257 want to generate, but we'll have enough arguments for
8258 the most general template.
8260 We also deal with the peculiar case:
8262 template <class T> struct S {
8263 template <class U> friend void f();
8264 };
8265 template <class U> void f() {}
8266 template S<int>;
8267 template void f<double>();
8269 Here, the ARGS for the instantiation of will be {int,
8270 double}. But, we only need as many ARGS as there are
8271 levels of template parameters in CODE_PATTERN. We are
8272 careful not to get fooled into reducing the ARGS in
8273 situations like:
8275 template <class T> struct S { template <class U> void f(U); }
8276 template <class T> template <> void S<T>::f(int) {}
8278 which we can spot because the pattern will be a
8279 specialization in this case. */
8281 parms_depth =
8286 }
8287 else
8288 {
8289 /* This special case arises when we have something like this:
8291 template <class T> struct S {
8292 friend void f<int>(int, double);
8293 };
8295 Here, the DECL_TI_TEMPLATE for the friend declaration
8296 will be an IDENTIFIER_NODE. We are being called from
8297 tsubst_friend_function, and we want only to create a
8298 new decl (R) with appropriate types so that we can call
8299 determine_specialization. */
8301 }
8304 {
8307 else
8311 }
8312 else
8313 {
8316 }
8321 /* We do NOT check for matching decls pushed separately at this
8322 point, as they may not represent instantiations of this
8323 template, and in any case are considered separate under the
8324 discrete model. */
8328 /* Clear out the mangled name and RTL for the instantiation. */
8331 /* Leave DECL_INITIAL set on deleted instantiations. */
8337 /* Type-conversion operator. Reconstruct the name, in
8338 case it's the name of one of the template's parameters. */
8348 /* If this is an instantiation of a function with internal
8349 linkage, we already know what object file linkage will be
8350 assigned to the instantiation. */
8360 {
8365 }
8367 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8368 this in the special friend case mentioned above where
8369 GEN_TMPL is NULL. */
8371 {
8377 /* We're not supposed to instantiate default arguments
8378 until they are called, for a template. But, for a
8379 declaration like:
8381 template <class T> void f ()
8382 { extern void g(int i = T()); }
8384 we should do the substitution when the template is
8385 instantiated. We handle the member function case in
8386 instantiate_class_template since the default arguments
8387 might refer to other members of the class. */
8392 }
8393 else
8396 /* Copy the list of befriending classes. */
8400 {
8404 in_decl);
8405 }
8408 {
8412 /* If this is an instantiation of a member template, clone it.
8413 If it isn't, that'll be handled by
8414 clone_constructors_and_destructors. */
8417 }
8427 /* Possibly limit visibility based on template args. */
8430 {
8434 }
8439 }
8443 {
8451 {
8452 /* If there is a local specialization that isn't a
8453 parameter pack, it means that we're doing a "simple"
8454 substitution from inside tsubst_pack_expansion. Just
8455 return the local specialization (which will be a single
8456 parm). */
8463 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8464 the parameters in this function parameter pack. */
8468 {
8471 /* Zero-length parameter packs are boring. Just substitute
8472 into the chain. */
8476 }
8477 else
8478 {
8479 /* All we did was update the type. Make a note of that. */
8482 }
8483 }
8485 /* Loop through all of the parameter's we'll build. When T is
8486 a function parameter pack, LEN is the number of expanded
8487 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8490 {
8497 /* We're on the Ith parameter of the function parameter
8498 pack. */
8499 {
8500 /* Get the Ith type. */
8504 /* Rename the parameter to include the index. */
8507 }
8509 /* We're dealing with a normal parameter. */
8517 {
8520 else
8523 }
8533 /* Keep track of the first new parameter we
8534 generate. That's what will be returned to the
8535 caller. */
8539 /* Build a proper chain of parameters when substituting
8540 into a function parameter pack. */
8543 }
8549 /* FIRST_R contains the start of the chain we've built. */
8551 }
8555 {
8556 tree type;
8565 /* DECL_INITIAL gives the number of bits in a bit-field. */
8570 /* We don't have to set DECL_CONTEXT here; it is set by
8571 finish_member_declaration. */
8578 }
8582 /* We reach here only for member using decls. */
8584 {
8585 r = do_class_using_decl
8590 else
8591 {
8594 }
8595 }
8596 else
8597 {
8600 }
8605 {
8608 tree spec;
8610 tree ctx;
8616 {
8617 /* If this is the canonical decl, we don't have to
8618 mess with instantiations, and often we can't (for
8619 typename, template type parms and such). Note that
8620 TYPE_NAME is not correct for the above test if
8621 we've copied the type for a typedef. */
8627 }
8629 /* Check to see if we already have the specialization we
8630 need. */
8633 {
8634 /* T is a static data member or namespace-scope entity.
8635 We have to substitute into namespace-scope variables
8636 (even though such entities are never templates) because
8637 of cases like:
8639 template <class T> void f() { extern T t; }
8641 where the entity referenced is not known until
8642 instantiation time. */
8646 {
8648 complain,
8650 /* If CTX is unchanged, then T is in fact the
8651 specialization we want. That situation occurs when
8652 referencing a static data member within in its own
8653 class. We can use pointer equality, rather than
8654 same_type_p, because DECL_CONTEXT is always
8655 canonical. */
8658 }
8661 {
8665 spec = (retrieve_specialization
8668 }
8669 }
8670 else
8671 {
8672 /* A local variable. */
8674 /* Subsequent calls to pushdecl will fill this in. */
8677 }
8678 /* If we already have the specialization we need, there is
8679 nothing more to do. */
8681 {
8684 }
8686 /* Create a new node for the specialization we need. */
8691 {
8692 /* Even if the original location is out of scope, the
8693 newly substituted one is not. */
8700 {
8701 /* It may seem that this case cannot occur, since:
8703 typedef void f();
8704 void g() { f x; }
8706 declares a function, not a variable. However:
8708 typedef void f();
8709 template <typename T> void g() { T t; }
8710 template void g<f>();
8712 is an attempt to declare a variable with function
8713 type. */
8715 /* R is not yet sufficiently initialized, so we
8716 just use its name. */
8719 }
8726 {
8731 }
8732 }
8738 /* Clear out the mangled name and RTL for the instantiation. */
8742 /* The initializer must not be expanded until it is required;
8743 see [temp.inst]. */
8749 {
8750 /* Possibly limit visibility based on template args. */
8753 {
8757 }
8759 }
8760 /* Preserve a typedef that names a type. */
8764 {
8769 }
8772 {
8773 /* A static data member declaration is always marked
8774 external when it is declared in-class, even if an
8775 initializer is present. We mimic the non-template
8776 processing here. */
8782 }
8783 else
8792 }
8797 }
8799 /* Restore the file and line information. */
8803 }
8805 /* Substitute into the ARG_TYPES of a function type. */
8807 static tree
8809 tree args,
8810 tsubst_flags_t complain,
8811 tree in_decl)
8812 {
8813 tree remaining_arg_types;
8817 tree default_arg;
8828 {
8829 /* For a pack expansion, perform substitution on the
8830 entire expression. Later on, we'll handle the arguments
8831 one-by-one. */
8836 /* So that we'll spin through the parameters, one by one. */
8838 else
8839 {
8840 /* We only partially substituted into the parameter
8841 pack. Our type is TYPE_PACK_EXPANSION. */
8844 }
8845 }
8858 {
8860 {
8864 }
8866 }
8868 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8869 top-level qualifiers as required. */
8872 /* We do not substitute into default arguments here. The standard
8873 mandates that they be instantiated only when needed, which is
8874 done in build_over_call. */
8878 {
8879 /* We've instantiated a template before its default arguments
8880 have been parsed. This can happen for a nested template
8881 class, and is not an error unless we require the default
8882 argument in a call of this function. */
8883 remaining_arg_types =
8886 remaining_arg_types);
8887 }
8888 else
8889 remaining_arg_types =
8891 }
8894 }
8896 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8897 *not* handle the exception-specification for FNTYPE, because the
8898 initial substitution of explicitly provided template parameters
8899 during argument deduction forbids substitution into the
8900 exception-specification:
8902 [temp.deduct]
8904 All references in the function type of the function template to the
8905 corresponding template parameters are replaced by the specified tem-
8906 plate argument values. If a substitution in a template parameter or
8907 in the function type of the function template results in an invalid
8908 type, type deduction fails. [Note: The equivalent substitution in
8909 exception specifications is done only when the function is instanti-
8910 ated, at which point a program is ill-formed if the substitution
8911 results in an invalid type.] */
8913 static tree
8915 tree args,
8916 tsubst_flags_t complain,
8917 tree in_decl)
8918 {
8919 tree return_type;
8920 tree arg_types;
8921 tree fntype;
8923 /* The TYPE_CONTEXT is not used for function/method types. */
8926 /* Substitute the return type. */
8930 /* The standard does not presently indicate that creation of a
8931 function type with an invalid return type is a deduction failure.
8932 However, that is clearly analogous to creating an array of "void"
8933 or a reference to a reference. This is core issue #486. */
8936 {
8938 {
8941 else
8943 }
8945 }
8947 /* Substitute the argument types. */
8953 /* Construct a new type node and return it. */
8956 else
8957 {
8960 {
8961 /* [temp.deduct]
8963 Type deduction may fail for any of the following
8964 reasons:
8966 -- Attempting to create "pointer to member of T" when T
8967 is not a class type. */
8970 r);
8972 }
8976 }
8981 }
8983 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8984 ARGS into that specification, and return the substituted
8985 specification. If there is no specification, return NULL_TREE. */
8987 static tree
8989 tree args,
8990 tsubst_flags_t complain,
8991 tree in_decl)
8992 {
8993 tree specs;
8994 tree new_specs;
8999 {
9002 else
9004 {
9005 tree spec;
9010 {
9011 /* Expand the pack expansion type. */
9014 in_decl);
9020 else
9021 {
9022 /* We're substituting into a member template, so
9023 we got a TYPE_PACK_EXPANSION back. Add that
9024 expansion and move on. */
9028 expanded_specs,
9029 complain);
9032 }
9033 }
9036 {
9039 else
9044 complain);
9045 }
9048 }
9049 }
9051 }
9053 /* Take the tree structure T and replace template parameters used
9054 therein with the argument vector ARGS. IN_DECL is an associated
9055 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9056 Issue error and warning messages under control of COMPLAIN. Note
9057 that we must be relatively non-tolerant of extensions here, in
9058 order to preserve conformance; if we allow substitutions that
9059 should not be allowed, we may allow argument deductions that should
9060 not succeed, and therefore report ambiguous overload situations
9061 where there are none. In theory, we could allow the substitution,
9062 but indicate that it should have failed, and allow our caller to
9063 make sure that the right thing happens, but we don't try to do this
9064 yet.
9066 This function is used for dealing with types, decls and the like;
9067 for expressions, use tsubst_expr or tsubst_copy. */
9069 static tree
9071 {
9090 else
9095 /* Reuse typedefs. We need to do this to handle dependent attributes,
9096 such as attribute aligned. */
9100 {
9106 {
9110 }
9115 else
9116 /* The typedef is from a non-template context. */
9120 {
9122 r = cp_build_qualified_type_real
9126 }
9127 /* Else we must be instantiating the typedef, so fall through. */
9128 }
9140 {
9167 {
9177 {
9181 }
9183 /* [temp.deduct]
9185 Type deduction may fail for any of the following
9186 reasons:
9188 Attempting to create an array with a size that is
9189 zero or negative. */
9191 /* We must fail if performing argument deduction (as
9192 indicated by the state of complain), so that
9193 another substitution can be found. */
9197 {
9202 }
9205 }
9211 {
9224 {
9228 /* See through ARGUMENT_PACK_SELECT arguments. */
9230 }
9235 {
9237 /* If ARG is an argument pack, we don't actually want to
9238 perform a substitution here, because substitutions
9239 for argument packs are only done
9240 element-by-element. We can get to this point when
9241 substituting the type of a non-type template
9242 parameter pack, when that type actually contains
9243 template parameter packs from an outer template, e.g.,
9245 template<typename... Types> struct A {
9246 template<Types... Values> struct B { };
9247 }; */
9251 {
9255 /* cv-quals from the template are discarded when
9256 substituting in a function or reference type. */
9261 else
9264 return cp_build_qualified_type_real
9266 }
9268 {
9269 /* We are processing a type constructed from a
9270 template template parameter. */
9276 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9277 are resolving nested-types in the signature of a
9278 member function templates. Otherwise ARG is a
9279 TEMPLATE_DECL and is the real template to be
9280 instantiated. */
9288 complain);
9289 return cp_build_qualified_type_real
9291 }
9292 else
9293 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9295 }
9298 /* This can happen during the attempted tsubst'ing in
9299 unify. This means that we don't yet have any information
9300 about the template parameter in question. */
9303 /* If we get here, we must have been looking at a parm for a
9304 more deeply nested template. Make a new version of this
9305 template parameter, but with a lower level. */
9307 {
9312 {
9314 r = cp_build_qualified_type_real
9318 }
9319 else
9320 {
9331 /* We have reduced the level of the template
9332 template parameter, but not the levels of its
9333 template parameters, so canonical_type_parameter
9334 will not be able to find the canonical template
9335 template parameter for this level. Thus, we
9336 require structural equality checking to compare
9337 TEMPLATE_TEMPLATE_PARMs. */
9341 else
9345 {
9353 }
9354 }
9363 }
9366 }
9369 {
9377 {
9381 }
9384 {
9388 }
9391 {
9395 }
9401 }
9404 /* We should never be tsubsting a binfo. */
9408 /* A vector of template arguments. */
9414 {
9423 /* [temp.deduct]
9425 Type deduction may fail for any of the following
9426 reasons:
9428 -- Attempting to create a pointer to reference type.
9429 -- Attempting to create a reference to a reference type or
9430 a reference to void.
9432 Core issue 106 says that creating a reference to a reference
9433 during instantiation is no longer a cause for failure. We
9434 only enforce this check in strict C++98 mode. */
9438 {
9441 /* We keep track of the last time we issued this error
9442 message to avoid spewing a ton of messages during a
9443 single bad template instantiation. */
9446 {
9449 else
9452 type);
9454 }
9457 }
9459 {
9463 }
9465 /* In C++0x, during template argument substitution, when there is an
9466 attempt to create a reference to a reference type, reference
9467 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9469 "If a template-argument for a template-parameter T names a type
9470 that is a reference to a type A, an attempt to create the type
9471 'lvalue reference to cv T' creates the type 'lvalue reference to
9472 A,' while an attempt to create the type type rvalue reference to
9473 cv T' creates the type T"
9474 */
9475 r = cp_build_reference_type
9478 else
9483 /* Will this ever be needed for TYPE_..._TO values? */
9487 }
9489 {
9492 {
9493 /* [temp.deduct]
9495 Type deduction may fail for any of the following
9496 reasons:
9498 -- Attempting to create "pointer to member of T" when T
9499 is not a class type. */
9503 }
9505 {
9509 }
9511 {
9515 }
9518 {
9519 /* The type of the implicit object parameter gets its
9520 cv-qualifiers from the FUNCTION_TYPE. */
9521 tree method_type;
9524 tree memptr;
9530 complain);
9531 }
9532 else
9535 complain);
9536 }
9539 {
9540 tree fntype;
9541 tree specs;
9546 /* Substitute the exception specification. */
9548 in_decl);
9554 }
9556 {
9561 /* As an optimization, we avoid regenerating the array type if
9562 it will obviously be the same as T. */
9566 /* These checks should match the ones in grokdeclarator.
9568 [temp.deduct]
9570 The deduction may fail for any of the following reasons:
9572 -- Attempting to create an array with an element type that
9573 is void, a function type, or a reference type, or [DR337]
9574 an abstract class type. */
9578 {
9582 }
9584 {
9587 type);
9589 }
9594 {
9597 }
9600 }
9604 {
9612 }
9616 {
9622 }
9625 {
9635 {
9639 }
9641 {
9642 /* Normally, make_typename_type does not require that the CTX
9643 have complete type in order to allow things like:
9645 template <class T> struct S { typename S<T>::X Y; };
9647 But, such constructs have already been resolved by this
9648 point, so here CTX really should have complete type, unless
9649 it's a partial instantiation. */
9652 {
9656 }
9657 }
9664 {
9667 }
9670 {
9677 }
9679 return cp_build_qualified_type_real
9681 }
9684 {
9696 }
9704 {
9712 }
9715 {
9723 }
9726 {
9727 tree type;
9736 complain);
9737 }
9740 {
9741 tree type;
9751 type =
9757 complain);
9758 }
9762 {
9764 tree packed_out =
9766 args,
9767 complain,
9768 in_decl);
9771 /* For template nontype argument packs, also substitute into
9772 the type. */
9777 }
9784 }
9785 }
9787 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9788 type of the expression on the left-hand side of the "." or "->"
9789 operator. */
9791 static tree
9794 {
9795 tree name;
9796 tree qualifying_scope;
9797 tree fns;
9798 tree optype;
9802 /* A baselink indicates a function from a base class. Both the
9803 BASELINK_ACCESS_BINFO and the base class referenced may
9804 indicate bases of the template class, rather than the
9805 instantiated class. In addition, lookups that were not
9806 ambiguous before may be ambiguous now. Therefore, we perform
9807 the lookup again. */
9814 {
9821 }
9825 /* If lookup found a single function, mark it as used at this
9826 point. (If it lookup found multiple functions the one selected
9827 later by overload resolution will be marked as used at that
9828 point.) */
9834 /* Add back the template arguments, if present. */
9839 template_args);
9840 /* Update the conversion operator type. */
9847 qualifying_scope,
9848 object_type);
9849 }
9851 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9852 true if the qualified-id will be a postfix-expression in-and-of
9853 itself; false if more of the postfix-expression follows the
9854 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9855 of "&". */
9857 static tree
9861 {
9862 tree expr;
9863 tree scope;
9864 tree name;
9866 tree template_args;
9870 /* Figure out what name to look up. */
9873 {
9880 }
9881 else
9882 {
9885 }
9887 /* Substitute into the qualifying scope. When there are no ARGS, we
9888 are just trying to simplify a non-dependent expression. In that
9889 case the qualifying scope may be dependent, and, in any case,
9890 substituting will not help. */
9893 {
9896 }
9897 else
9906 {
9908 /* If this were actually a destructor call, it would have been
9909 parsed as such by the parser. */
9911 else
9915 {
9917 {
9921 }
9923 }
9924 }
9927 {
9929 scope);
9930 /* Remember that there was a reference to this entity. */
9932 }
9935 {
9941 }
9950 {
9951 expr = (adjust_result_of_qualified_name_lookup
9953 expr = (finish_qualified_id_expr
9957 }
9959 /* Expressions do not generally have reference type. */
9961 /* However, if we're about to form a pointer-to-member, we just
9962 want the referenced member referenced. */
9967 }
9969 /* Like tsubst, but deals with expressions. This function just replaces
9970 template parms; to finish processing the resultant expression, use
9971 tsubst_expr. */
9973 static tree
9975 {
9977 tree r;
9985 {
9990 {
9991 /* This can happen for a parameter name used later in a function
9992 declaration (such as in a late-specified return type).
9993 Replace it with an arbitrary expression with the same type
9994 (*(T*)0). This should only occur in an unevaluated context
9995 (i.e. decltype). */
10002 }
10010 {
10011 tree enum_type;
10012 tree v;
10016 /* There is no need to substitute into namespace-scope
10017 enumerators. */
10020 /* If ARGS is NULL, then T is known to be non-dependent. */
10024 /* Unfortunately, we cannot just call lookup_name here.
10025 Consider:
10027 template <int I> int f() {
10028 enum E { a = I };
10029 struct S { void g() { E e = a; } };
10030 };
10032 When we instantiate f<7>::S::g(), say, lookup_name is not
10033 clever enough to find f<7>::a. */
10034 enum_type
10044 /* We didn't find the name. That should never happen; if
10045 name-lookup found it during preliminary parsing, we
10046 should find it again here during instantiation. */
10048 }
10053 {
10054 tree ctx;
10059 {
10062 {
10063 /* Suppress the error message if we are processing a lock
10064 attribute. */
10070 }
10072 }
10073 }
10096 {
10097 /* Template template argument like the following example need
10098 special treatment:
10100 template <template <class> class TT> struct C {};
10101 template <class T> struct D {
10102 template <class U> struct E {};
10103 C<E> c; // #1
10104 };
10105 D<int> d; // #2
10107 We are processing the template argument `E' in #1 for
10108 the template instantiation #2. Originally, `E' is a
10109 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10110 have to substitute this with one having context `D<int>'. */
10114 }
10115 else
10116 /* Ordinary template template argument. */
10125 return build1
10131 {
10132 /* We only want to compute the number of arguments. */
10146 {
10153 else
10156 }
10157 else
10159 }
10160 /* Fall through */
10174 return build1
10179 {
10180 tree object;
10181 tree name;
10186 {
10190 }
10193 {
10203 }
10208 in_decl);
10209 else
10212 }
10250 return build_nt
10263 return build_nt
10270 {
10278 }
10283 {
10284 r = build_nt
10290 }
10293 {
10294 r = build_nt
10300 }
10303 {
10304 r = build_nt
10310 }
10313 {
10314 /* Substituted template arguments */
10323 }
10326 {
10346 }
10371 {
10374 }
10375 else
10379 /* This is handled by tsubst_copy_and_build. */
10384 in_decl),
10388 /* We shouldn't have built any of these during initial template
10389 generation. Instead, they should be built during instantiation
10390 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10407 }
10408 }
10410 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10412 static tree
10414 tree in_decl)
10415 {
10419 {
10425 {
10428 {
10434 }
10435 /* FALLTHRU */
10457 }
10458 }
10461 }
10463 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10465 static tree
10467 tree in_decl)
10468 {
10469 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10494 #undef RECUR
10495 }
10497 /* Substitute one OMP_FOR iterator. */
10499 static void
10504 {
10505 #define RECUR(NODE) \
10506 tsubst_expr ((NODE), args, complain, in_decl, \
10507 integral_constant_expression_p)
10516 {
10523 }
10527 {
10533 complain);
10534 else
10541 }
10544 {
10545 tree c;
10547 {
10558 }
10560 {
10565 {
10568 }
10569 }
10570 }
10576 else
10580 {
10591 {
10598 }
10599 else
10605 {
10611 }
10615 {
10622 }
10623 else
10629 }
10635 #undef RECUR
10636 }
10638 /* Like tsubst_copy for expressions, etc. but also does semantic
10639 processing. */
10641 static tree
10644 {
10645 #define RECUR(NODE) \
10646 tsubst_expr ((NODE), args, complain, in_decl, \
10647 integral_constant_expression_p)
10660 {
10662 {
10663 tree_stmt_iterator i;
10667 }
10682 else
10691 {
10692 tree decl;
10693 tree init;
10699 {
10702 tree decl;
10710 else
10712 }
10713 else
10714 {
10718 {
10719 /* By marking the declaration as instantiated, we avoid
10720 trying to instantiate it. Since instantiate_decl can't
10721 handle local variables, and since we've already done
10722 all that needs to be done, that's the right thing to
10723 do. */
10728 /* Anonymous aggregates are a special case. */
10730 else
10731 {
10735 {
10736 /* For __PRETTY_FUNCTION__ we have to adjust the
10737 initializer. */
10741 }
10742 else
10743 {
10747 /* If we had an initializer but it
10748 instantiated to nothing,
10749 value-initialize the object. This will
10750 only occur when the initializer was a
10751 pack expansion where the parameter packs
10752 used in that expansion were of length
10753 zero. */
10755 else
10757 }
10760 }
10761 }
10762 }
10764 /* A DECL_EXPR can also be used as an expression, in the condition
10765 clause of an if/for/while construct. */
10767 }
10805 {
10809 }
10817 else
10825 else
10857 /* Computed goto's must be tsubst'd into. On the other hand,
10858 non-computed gotos must not be; the identifier in question
10859 will have no binding. */
10861 else
10867 tmp = finish_asm_stmt
10873 {
10878 }
10883 {
10888 }
10889 else
10890 {
10895 else
10902 else
10908 else
10910 }
10914 {
10918 {
10920 /* Prevent instantiate_decl from trying to instantiate
10921 this variable. We've already done all that needs to be
10922 done. */
10925 }
10930 }
10938 {
10939 tree condition =
10941 args,
10948 }
10969 {
10984 integral_constant_expression_p);
10993 {
10997 }
10998 else
10999 {
11007 }
11021 }
11052 {
11057 }
11073 integral_constant_expression_p);
11074 }
11077 #undef RECUR
11078 }
11080 /* T is a postfix-expression that is not being used in a function
11081 call. Return the substituted version of T. */
11083 static tree
11085 tsubst_flags_t complain,
11086 tree in_decl)
11087 {
11091 else
11097 }
11099 /* Like tsubst but deals with expressions and performs semantic
11100 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11102 tree
11104 tree args,
11105 tsubst_flags_t complain,
11106 tree in_decl,
11109 {
11110 #define RECUR(NODE) \
11111 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11113 integral_constant_expression_p)
11115 tree op1;
11121 {
11124 /* Fall through. */
11126 {
11127 tree decl;
11128 cp_id_kind idk;
11133 {
11136 }
11138 /* Look up the name. */
11141 /* By convention, expressions use ERROR_MARK_NODE to indicate
11142 failure, not NULL_TREE. */
11148 integral_constant_expression_p,
11156 input_location);
11162 }
11165 {
11166 tree object;
11174 {
11177 }
11178 else
11185 else
11187 }
11190 {
11194 {
11195 /* A type conversion to reference type will be enclosed in
11196 such an indirect ref, but the substitution of the cast
11197 will have also added such an indirect ref. */
11200 }
11201 else
11204 }
11207 return build_nop
11216 {
11217 tree type;
11218 tree op;
11223 {
11228 }
11233 {
11246 }
11247 }
11265 complain);
11272 else
11274 in_decl);
11311 return build_x_binary_op
11315 ? ERROR_MARK
11319 ? ERROR_MARK
11322 complain);
11335 /* Fall through */
11340 {
11341 /* When there are no ARGS, we are trying to evaluate a
11342 non-dependent expression from the parser. Trying to do
11343 the substitutions may not work. */
11346 }
11347 else
11348 {
11354 }
11358 else
11363 {
11364 tree r = build_x_modify_expr
11368 complain);
11369 /* TREE_NO_WARNING must be set if either the expression was
11370 parenthesized or it uses an operator such as >>= rather
11371 than plain assignment. In the former case, it was already
11372 set and must be copied. In the latter case,
11373 build_x_modify_expr sets it and it must not be reset
11374 here. */
11378 }
11383 /* Remember that there was a reference to this entity. */
11389 {
11393 /* If there was an initializer in the original tree, but
11394 it instantiated to an empty list, then we should pass on
11395 VOID_ZERO_NODE to tell build_new that it was an empty
11396 initializer () rather than no initializer. This can only
11397 happen when the initializer is a pack expansion whose
11398 parameter packs are of length zero. */
11401 return build_new
11405 init,
11407 complain);
11408 }
11411 return delete_sanity
11420 complain);
11423 {
11424 tree function;
11425 tree call_args;
11430 /* When we parsed the expression, we determined whether or
11431 not Koenig lookup should be performed. */
11434 {
11439 }
11440 else
11441 {
11443 {
11449 }
11450 else
11454 in_decl,
11456 integral_constant_expression_p);
11460 }
11462 /* FIXME: Rewrite this so as not to construct an arglist. */
11465 /* We do not perform argument-dependent lookup if normal
11466 lookup finds a non-function, in accordance with the
11467 expected resolution of DR 218. */
11470 /* If lookup found a member function, the Koenig lookup is
11471 not appropriate, even if an unqualified-name was used
11472 to denote the function. */
11478 {
11481 }
11483 /* Remember that there was a reference to this entity. */
11490 {
11495 complain);
11496 else
11503 complain));
11504 }
11505 /* Pass -1 for koenig_p so that build_new_function_call will
11506 allow hidden friends found by arg-dependent lookup at template
11507 parsing time. */
11511 complain);
11512 }
11515 return build_x_conditional_expr
11519 complain);
11522 return finish_pseudo_destructor_expr
11528 {
11536 {
11537 /* We have pack expansions, so expand those and
11538 create a new list out of it. */
11541 tree chain;
11544 /* Expand the argument expressions. */
11552 /* Build the rest of the list. */
11557 /* Determine the number of arguments. */
11559 {
11562 }
11565 else
11566 {
11567 /* Since we only performed a partial substitution into
11568 the argument pack, we only return a single list
11569 node. */
11576 }
11578 /* Convert the argument vectors into a TREE_LIST */
11581 {
11582 /* Grab the Ith values. */
11583 i--;
11586 value
11590 /* Build the list (backwards). */
11592 }
11595 }
11611 }
11614 {
11615 tree object;
11616 tree object_type;
11617 tree member;
11621 /* Remember that there was a reference to this entity. */
11631 else
11637 {
11639 {
11644 {
11647 }
11649 {
11653 }
11654 }
11655 }
11658 {
11659 tree tmpl;
11660 tree args;
11662 /* Lookup the template functions now that we know what the
11663 scope is. */
11670 {
11673 args);
11674 member = (adjust_result_of_qualified_name_lookup
11676 object_type));
11677 }
11678 else
11679 {
11681 input_location);
11683 }
11684 }
11688 {
11690 {
11694 else
11697 }
11699 }
11705 complain);
11706 }
11709 return build_throw
11713 {
11721 tree r;
11726 /* digest_init will do the wrong thing if we let it. */
11730 /* We do not want to process the index of aggregate
11731 initializers as they are identifier nodes which will be
11732 looked up by digest_init. */
11738 {
11743 {
11744 /* Substitute into the pack expansion. */
11746 in_decl);
11749 ;
11751 /* Just move the argument into place. */
11753 else
11754 {
11755 /* Update the length of the final CONSTRUCTOR
11756 arguments vector, and note that we will need to
11757 copy.*/
11760 }
11761 }
11762 else
11764 }
11767 {
11772 idx++)
11773 {
11775 {
11780 }
11781 else
11783 }
11784 }
11793 }
11796 {
11801 }
11806 /* Fall through */
11809 {
11813 /* If the original type was a reference, we'll be wrapped in
11814 the appropriate INDIRECT_REF. */
11817 }
11822 in_decl));
11828 {
11837 }
11840 {
11846 integral_constant_expression_p);
11851 }
11855 /* As in finish_id_expression, we resolve enumeration constants
11856 to their underlying values. */
11858 {
11861 }
11865 /* Handle Objective-C++ constructs, if appropriate. */
11866 {
11867 tree subst
11872 }
11874 }
11876 #undef RECUR
11877 }
11879 /* Verify that the instantiated ARGS are valid. For type arguments,
11880 make sure that the type's linkage is ok. For non-type arguments,
11881 make sure they are constants if they are integral or enumerations.
11882 Emit an error under control of COMPLAIN, and return TRUE on error. */
11884 static bool
11886 {
11888 {
11898 }
11900 {
11901 /* [basic.link]: A name with no linkage (notably, the name
11902 of a class or enumeration declared in a local scope)
11903 shall not be used to declare an entity with linkage.
11904 This implies that names with no linkage cannot be used as
11905 template arguments. */
11909 {
11910 /* DR 488 makes use of a type with no linkage cause
11911 type deduction to fail. */
11913 {
11916 else
11919 }
11921 }
11922 /* In order to avoid all sorts of complications, we do not
11923 allow variably-modified types as template arguments. */
11925 {
11929 }
11930 }
11931 /* A non-type argument of integral or enumerated type must be a
11932 constant. */
11936 {
11940 }
11942 }
11944 static bool
11946 {
11951 {
11954 }
11958 }
11960 /* Instantiate the indicated variable or function template TMPL with
11961 the template arguments in TARG_PTR. */
11963 tree
11965 {
11966 tree fndecl;
11967 tree gen_tmpl;
11968 tree spec;
11969 HOST_WIDE_INT saved_processing_template_decl;
11976 /* If this function is a clone, handle it specially. */
11978 {
11979 tree spec;
11980 tree clone;
11983 complain);
11987 /* Look for the clone. */
11991 /* We should always have found the clone by now. */
11994 }
11996 /* Check to see if we already have this specialization. */
12004 {
12005 /* The TMPL is a partial instantiation. To get a full set of
12006 arguments we must add the arguments used to perform the
12007 partial instantiation. */
12009 targ_ptr);
12011 /* Check to see if we already have this specialization. */
12016 }
12019 complain))
12022 /* We are building a FUNCTION_DECL, during which the access of its
12023 parameters and return types have to be checked. However this
12024 FUNCTION_DECL which is the desired context for access checking
12025 is not built yet. We solve this chicken-and-egg problem by
12026 deferring all checks until we have the FUNCTION_DECL. */
12029 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
12030 (because, for example, we have encountered a non-dependent
12031 function call in the body of a template function and must now
12032 determine which of several overloaded functions will be called),
12033 within the instantiation itself we are not processing a
12034 template. */
12037 /* Substitute template parameters to obtain the specialization. */
12044 /* Now we know the specialization, compute access previously
12045 deferred. */
12051 /* The DECL_TI_TEMPLATE should always be the immediate parent
12052 template, not the most general template. */
12055 /* If we've just instantiated the main entry point for a function,
12056 instantiate all the alternate entry points as well. We do this
12057 by cloning the instantiation of the main entry point, not by
12058 instantiating the template clones. */
12063 }
12065 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
12066 arguments that are being used when calling it. TARGS is a vector
12067 into which the deduced template arguments are placed.
12069 Return zero for success, 2 for an incomplete match that doesn't resolve
12070 all the types, and 1 for complete failure. An error message will be
12071 printed only for an incomplete match.
12073 If FN is a conversion operator, or we are trying to produce a specific
12074 specialization, RETURN_TYPE is the return type desired.
12076 The EXPLICIT_TARGS are explicit template arguments provided via a
12077 template-id.
12079 The parameter STRICT is one of:
12081 DEDUCE_CALL:
12082 We are deducing arguments for a function call, as in
12083 [temp.deduct.call].
12085 DEDUCE_CONV:
12086 We are deducing arguments for a conversion function, as in
12087 [temp.deduct.conv].
12089 DEDUCE_EXACT:
12090 We are deducing arguments when doing an explicit instantiation
12091 as in [temp.explicit], when determining an explicit specialization
12092 as in [temp.expl.spec], or when taking the address of a function
12093 template, as in [temp.deduct.funcaddr]. */
12095 int
12097 tree explicit_targs,
12098 tree targs,
12099 tree args,
12100 tree return_type,
12101 unification_kind_t strict,
12103 {
12104 tree parms;
12105 tree fntype;
12113 {
12114 /* [temp.deduct]
12116 The specified template arguments must match the template
12117 parameters in kind (i.e., type, nontype, template), and there
12118 must not be more arguments than there are parameters;
12119 otherwise type deduction fails.
12121 Nontype arguments must match the types of the corresponding
12122 nontype template parameters, or must be convertible to the
12123 types of the corresponding nontype parameters as specified in
12124 _temp.arg.nontype_, otherwise type deduction fails.
12126 All references in the function type of the function template
12127 to the corresponding template parameters are replaced by the
12128 specified template argument values. If a substitution in a
12129 template parameter or in the function type of the function
12130 template results in an invalid type, type deduction fails. */
12133 tree converted_args;
12139 converted_args
12146 /* Substitute the explicit args into the function type. This is
12147 necessary so that, for instance, explicitly declared function
12148 arguments can match null pointed constants. If we were given
12149 an incomplete set of explicit args, we must not do semantic
12150 processing during substitution as we could create partial
12151 instantiations. */
12153 {
12157 /* Dig out the actual parm. */
12160 {
12163 }
12165 {
12168 }
12171 {
12173 tree targ;
12176 /* Mark the argument pack as "incomplete". We could
12177 still deduce more arguments during unification. */
12180 {
12184 }
12186 /* We have some incomplete argument packs. */
12188 }
12189 }
12192 /* Any substitution is guaranteed to be incomplete if there
12193 are incomplete argument packs, because we can still deduce
12194 more arguments. */
12196 else
12206 /* Place the explicitly specified arguments in TARGS. */
12209 }
12211 /* Never do unification on the 'this' parameter. */
12215 {
12218 }
12220 /* We allow incomplete unification without an error message here
12221 because the standard doesn't seem to explicitly prohibit it. Our
12222 callers must be ready to deal with unification failures in any
12223 event. */
12229 {
12232 /* Clear the "incomplete" flags on all argument packs. */
12234 {
12237 {
12240 }
12241 }
12242 }
12244 /* Now that we have bindings for all of the template arguments,
12245 ensure that the arguments deduced for the template template
12246 parameters have compatible template parameter lists. We cannot
12247 check this property before we have deduced all template
12248 arguments, because the template parameter types of a template
12249 template parameter might depend on prior template parameters
12250 deduced after the template template parameter. The following
12251 ill-formed example illustrates this issue:
12253 template<typename T, template<T> class C> void f(C<5>, T);
12255 template<int N> struct X {};
12257 void g() {
12258 f(X<5>(), 5l); // error: template argument deduction fails
12259 }
12261 The template parameter list of 'C' depends on the template type
12262 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
12263 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
12264 time that we deduce 'C'. */
12266 && !template_template_parm_bindings_ok_p
12271 /* All is well so far. Now, check:
12273 [temp.deduct]
12275 When all template arguments have been deduced, all uses of
12276 template parameters in nondeduced contexts are replaced with
12277 the corresponding deduced argument values. If the
12278 substitution results in an invalid type, as described above,
12279 type deduction fails. */
12285 }
12287 /* Adjust types before performing type deduction, as described in
12288 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
12289 sections are symmetric. PARM is the type of a function parameter
12290 or the return type of the conversion function. ARG is the type of
12291 the argument passed to the call, or the type of the value
12292 initialized with the result of the conversion function.
12293 ARG_EXPR is the original argument expression, which may be null. */
12295 static int
12299 tree arg_expr)
12300 {
12304 {
12309 {
12310 /* Swap PARM and ARG throughout the remainder of this
12311 function; the handling is precisely symmetric since PARM
12312 will initialize ARG rather than vice versa. */
12317 }
12320 /* There is nothing to do in this case. */
12325 }
12328 {
12329 /* [temp.deduct.call]
12331 If P is not a reference type:
12333 --If A is an array type, the pointer type produced by the
12334 array-to-pointer standard conversion (_conv.array_) is
12335 used in place of A for type deduction; otherwise,
12337 --If A is a function type, the pointer type produced by
12338 the function-to-pointer standard conversion
12339 (_conv.func_) is used in place of A for type deduction;
12340 otherwise,
12342 --If A is a cv-qualified type, the top level
12343 cv-qualifiers of A's type are ignored for type
12344 deduction. */
12349 else
12351 }
12353 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
12354 of the form T&&, where T is a template parameter, and the argument
12355 is an lvalue, T is deduced as A& */
12363 /* [temp.deduct.call]
12365 If P is a cv-qualified type, the top level cv-qualifiers
12366 of P's type are ignored for type deduction. If P is a
12367 reference type, the type referred to by P is used for
12368 type deduction. */
12371 {
12374 }
12376 /* DR 322. For conversion deduction, remove a reference type on parm
12377 too (which has been swapped into ARG). */
12382 }
12384 /* Most parms like fn_type_unification.
12386 If SUBR is 1, we're being called recursively (to unify the
12387 arguments of a function or method parameter of a function
12388 template). */
12390 static int
12392 tree targs,
12393 tree xparms,
12394 tree xargs,
12396 unification_kind_t strict,
12398 {
12412 {
12428 }
12430 again:
12436 {
12449 /* We can't deduce anything from this, but we might get all the
12450 template args from other function args. */
12453 /* Conversions will be performed on a function argument that
12454 corresponds with a function parameter that contains only
12455 non-deducible template parameters and explicitly specified
12456 template parameters. */
12458 {
12459 tree type;
12463 else
12470 flags))
12474 }
12477 {
12480 {
12481 /* [temp.deduct.type]
12483 A template-argument can be deduced from a pointer to
12484 function or pointer to member function argument if
12485 the set of overloaded functions does not contain
12486 function templates and at most one of a set of
12487 overloaded functions provides a unique match. */
12493 }
12498 }
12500 {
12505 arg_expr);
12511 }
12512 }
12518 {
12519 /* Unify the remaining arguments with the pack expansion type. */
12520 tree argvec;
12523 tree t;
12525 /* Count the number of arguments that remain. */
12527 len++;
12529 /* Allocate a TREE_VEC and copy in all of the arguments */
12532 {
12535 }
12537 /* Copy the parameter into parmvec. */
12543 /* Advance to the end of the list of parameters. */
12545 }
12547 /* Fail if we've reached the end of the parm list, and more args
12548 are present, and the parm list isn't variadic. */
12551 /* Fail if parms are left and they don't have default values. */
12559 {
12560 tree tparm;
12567 /* If this is an undeduced nontype parameter that depends on
12568 a type parameter, try another pass; its type may have been
12569 deduced from a later argument than the one from which
12570 this parameter can be deduced. */
12576 /* Core issue #226 (C++0x) [temp.deduct]:
12578 If a template argument has not been deduced, its
12579 default template argument, if any, is used.
12581 When we are in C++98 mode, TREE_PURPOSE will either
12582 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12583 to explicitly check cxx_dialect here. */
12585 {
12590 else
12591 {
12594 }
12595 }
12597 /* If the type parameter is a parameter pack, then it will
12598 be deduced to an empty parameter pack. */
12600 {
12601 tree arg;
12604 {
12608 }
12609 else
12616 }
12619 }
12622 }
12624 /* Subroutine of type_unification_real. Args are like the variables
12625 at the call site. ARG is an overloaded function (or template-id);
12626 we try deducing template args from each of the overloads, and if
12627 only one succeeds, we go with that. Modifies TARGS and returns
12628 true on success. */
12630 static bool
12632 tree targs,
12633 tree parm,
12634 tree arg,
12635 unification_kind_t strict,
12637 {
12643 {
12646 }
12647 else
12651 /* Handle `&x' where `x' is some static or non-static member
12652 function name. */
12658 /* Strip baselink information. */
12663 {
12664 /* If we got some explicit template args, we need to plug them into
12665 the affected templates before we try to unify, in case the
12666 explicit args will completely resolve the templates in question. */
12672 {
12683 {
12687 }
12689 }
12690 }
12693 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12694 -- but the deduction does not succeed because the expression is
12695 not just the function on its own. */
12697 else
12703 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12704 to function or pointer to member function argument if the set of
12705 overloaded functions does not contain function templates and at most
12706 one of a set of overloaded functions provides a unique match.
12708 So if we found multiple possibilities, we return success but don't
12709 deduce anything. */
12712 {
12717 }
12722 }
12724 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12725 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12726 different overloads deduce different arguments for a given parm.
12727 ADDR_P is true if the expression for which deduction is being
12728 performed was of the form "& fn" rather than simply "fn".
12730 Returns 1 on success. */
12732 static int
12734 tree orig_targs,
12735 tree targs,
12736 tree parm,
12737 tree arg,
12738 unification_kind_t strict,
12741 {
12743 tree tempargs;
12746 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12747 to function or pointer to member function argument if the set of
12748 overloaded functions does not contain function templates and at most
12749 one of a set of overloaded functions provides a unique match.
12751 So if this is a template, just return success. */
12763 /* We don't copy orig_targs for this because if we have already deduced
12764 some template args from previous args, unify would complain when we
12765 try to deduce a template parameter for the same argument, even though
12766 there isn't really a conflict. */
12773 /* First make sure we didn't deduce anything that conflicts with
12774 explicitly specified args. */
12776 {
12783 /* Since we're unifying against ourselves, we will fill in
12784 template args used in the function parm list with our own
12785 template parms. Discard them. */
12789 }
12792 {
12797 }
12800 }
12802 /* PARM is a template class (perhaps with unbound template
12803 parameters). ARG is a fully instantiated type. If ARG can be
12804 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12805 TARGS are as for unify. */
12807 static tree
12809 {
12810 tree copy_of_targs;
12817 /* We need to make a new template argument vector for the call to
12818 unify. If we used TARGS, we'd clutter it up with the result of
12819 the attempted unification, even if this class didn't work out.
12820 We also don't want to commit ourselves to all the unifications
12821 we've already done, since unification is supposed to be done on
12822 an argument-by-argument basis. In other words, consider the
12823 following pathological case:
12825 template <int I, int J, int K>
12826 struct S {};
12828 template <int I, int J>
12829 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12831 template <int I, int J, int K>
12832 void f(S<I, J, K>, S<I, I, I>);
12834 void g() {
12835 S<0, 0, 0> s0;
12836 S<0, 1, 2> s2;
12838 f(s0, s2);
12839 }
12841 Now, by the time we consider the unification involving `s2', we
12842 already know that we must have `f<0, 0, 0>'. But, even though
12843 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12844 because there are two ways to unify base classes of S<0, 1, 2>
12845 with S<I, I, I>. If we kept the already deduced knowledge, we
12846 would reject the possibility I=1. */
12849 /* If unification failed, we're done. */
12855 }
12857 /* Given a template type PARM and a class type ARG, find the unique
12858 base type in ARG that is an instance of PARM. We do not examine
12859 ARG itself; only its base-classes. If there is not exactly one
12860 appropriate base class, return NULL_TREE. PARM may be the type of
12861 a partial specialization, as well as a plain template type. Used
12862 by unify. */
12864 static tree
12866 {
12868 tree binfo;
12874 /* The type could not be completed. */
12877 /* Walk in inheritance graph order. The search order is not
12878 important, and this avoids multiple walks of virtual bases. */
12880 {
12884 {
12885 /* If there is more than one satisfactory baseclass, then:
12887 [temp.deduct.call]
12889 If they yield more than one possible deduced A, the type
12890 deduction fails.
12892 applies. */
12897 }
12898 }
12901 }
12903 /* Returns the level of DECL, which declares a template parameter. */
12905 static int
12907 {
12909 {
12919 }
12921 }
12923 /* Decide whether ARG can be unified with PARM, considering only the
12924 cv-qualifiers of each type, given STRICT as documented for unify.
12925 Returns nonzero iff the unification is OK on that basis. */
12927 static int
12929 {
12935 {
12936 /* Although a CVR qualifier is ignored when being applied to a
12937 substituted template parameter ([8.3.2]/1 for example), that
12938 does not apply during deduction [14.8.2.4]/1, (even though
12939 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12940 this). Except when we're allowing additional CV qualifiers
12941 at the outer level [14.8.2.1]/3,1st bullet. */
12951 }
12962 }
12964 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12965 void
12967 {
12971 {
12974 }
12975 else
12976 {
12979 }
12980 }
12982 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12983 expansion at the end of PACKED_PARMS. Returns 0 if the type
12984 deduction succeeds, 1 otherwise. STRICT is the same as in
12985 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12986 call argument list. We'll need to adjust the arguments to make them
12987 types. SUBR tells us if this is from a recursive call to
12988 type_unification_real. */
12989 int
12993 {
12994 tree parm
13001 /* Determine the parameter packs we will be deducing from the
13002 pattern, and record their current deductions. */
13005 {
13009 /* Determine the index and level of this parameter pack. */
13012 /* Keep track of the parameter packs and their corresponding
13013 argument packs. */
13016 }
13018 /* Loop through all of the arguments that have not yet been
13019 unified and unify each with the pattern. */
13021 {
13024 /* For each parameter pack, clear out the deduced value so that
13025 we can deduce it again. */
13027 {
13032 }
13034 /* Unify the pattern with the current argument. */
13035 {
13042 {
13045 /* This mirrors what we do in type_unification_real. */
13047 {
13049 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
13050 | UNIFY_ALLOW_MORE_CV_QUAL
13064 }
13067 {
13070 {
13071 /* [temp.deduct.type] A template-argument can be
13072 deduced from a pointer to function or pointer
13073 to member function argument if the set of
13074 overloaded functions does not contain function
13075 templates and at most one of a set of
13076 overloaded functions provides a unique
13077 match. */
13084 }
13087 {
13092 }
13093 }
13098 arg_strict |=
13100 arg_expr);
13101 }
13104 {
13107 }
13108 }
13110 /* For each parameter pack, collect the deduced value. */
13112 {
13118 }
13119 }
13121 /* Verify that the results of unification with the parameter packs
13122 produce results consistent with what we've seen before, and make
13123 the deduced argument packs available. */
13125 {
13131 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
13132 actually deduce anything. */
13140 {
13141 /* Prepend the explicit arguments onto NEW_ARGS. */
13147 /* Copy the explicit arguments. */
13152 /* Copy the deduced arguments. */
13156 }
13159 {
13160 tree result;
13165 /* Build the deduced *_ARGUMENT_PACK. */
13167 {
13172 }
13173 else
13178 /* Note the deduced argument packs for this parameter
13179 pack. */
13181 }
13185 {
13186 /* We only had the explicitly-provided arguments before, but
13187 now we have a complete set of arguments. */
13192 /* Keep the original deduced argument pack. */
13198 }
13200 new_args))
13201 /* Inconsistent unification of this parameter pack. */
13203 else
13204 {
13209 /* Keep the original deduced argument pack. */
13211 }
13212 }
13215 }
13217 /* Deduce the value of template parameters. TPARMS is the (innermost)
13218 set of template parameters to a template. TARGS is the bindings
13219 for those template parameters, as determined thus far; TARGS may
13220 include template arguments for outer levels of template parameters
13221 as well. PARM is a parameter to a template function, or a
13222 subcomponent of that parameter; ARG is the corresponding argument.
13223 This function attempts to match PARM with ARG in a manner
13224 consistent with the existing assignments in TARGS. If more values
13225 are deduced, then TARGS is updated.
13227 Returns 0 if the type deduction succeeds, 1 otherwise. The
13228 parameter STRICT is a bitwise or of the following flags:
13230 UNIFY_ALLOW_NONE:
13231 Require an exact match between PARM and ARG.
13232 UNIFY_ALLOW_MORE_CV_QUAL:
13233 Allow the deduced ARG to be more cv-qualified (by qualification
13234 conversion) than ARG.
13235 UNIFY_ALLOW_LESS_CV_QUAL:
13236 Allow the deduced ARG to be less cv-qualified than ARG.
13237 UNIFY_ALLOW_DERIVED:
13238 Allow the deduced ARG to be a template base class of ARG,
13239 or a pointer to a template base class of the type pointed to by
13240 ARG.
13241 UNIFY_ALLOW_INTEGER:
13242 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
13243 case for more information.
13244 UNIFY_ALLOW_OUTER_LEVEL:
13245 This is the outermost level of a deduction. Used to determine validity
13246 of qualification conversions. A valid qualification conversion must
13247 have const qualified pointers leading up to the inner type which
13248 requires additional CV quals, except at the outer level, where const
13249 is not required [conv.qual]. It would be normal to set this flag in
13250 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
13251 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
13252 This is the outermost level of a deduction, and PARM can be more CV
13253 qualified at this point.
13254 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
13255 This is the outermost level of a deduction, and PARM can be less CV
13256 qualified at this point. */
13258 static int
13260 {
13262 tree targ;
13263 tree tparm;
13266 /* I don't think this will do the right thing with respect to types.
13267 But the only case I've seen it in so far has been array bounds, where
13268 signedness is the only information lost, and I think that will be
13269 okay. */
13277 /* We can't deduce anything from this, but we might get all the
13278 template args from other function args. */
13281 /* If PARM uses template parameters, then we can't bail out here,
13282 even if ARG == PARM, since we won't record unifications for the
13283 template parameters. We might need them if we're trying to
13284 figure out which of two things is more specialized. */
13288 /* Handle init lists early, so the rest of the function can assume
13289 we're dealing with a type. */
13291 {
13296 /* We can only deduce from an initializer list argument if the
13297 parameter is std::initializer_list; otherwise this is a
13298 non-deduced context. */
13304 {
13307 {
13309 /* It should only be possible to get here for a call. */
13311 elt_strict |= maybe_adjust_types_for_deduction
13314 }
13318 }
13320 }
13322 /* Immediately reject some pairs that won't unify because of
13323 cv-qualification mismatches. */
13326 /* It is the elements of the array which hold the cv quals of an array
13327 type, and the elements might be template type parms. We'll check
13328 when we recurse. */
13330 /* We check the cv-qualifiers when unifying with template type
13331 parameters below. We want to allow ARG `const T' to unify with
13332 PARM `T' for example, when computing which of two templates
13333 is more specialized, for example. */
13347 {
13351 /* In a type which contains a nested-name-specifier, template
13352 argument values cannot be deduced for template parameters used
13353 within the nested-name-specifier. */
13365 /* The PARM is not one we're trying to unify. Just check
13366 to see if it matches ARG. */
13373 /* Check for mixed types and values. */
13381 {
13382 /* ARG must be constructed from a template class or a template
13383 template parameter. */
13388 {
13391 tree parm_parms
13392 = DECL_INNERMOST_TEMPLATE_PARMS
13397 /* The resolution to DR150 makes clear that default
13398 arguments for an N-argument may not be used to bind T
13399 to a template template parameter with fewer than N
13400 parameters. It is not safe to permit the binding of
13401 default arguments as an extension, as that may change
13402 the meaning of a conforming program. Consider:
13404 struct Dense { static const unsigned int dim = 1; };
13406 template <template <typename> class View,
13407 typename Block>
13408 void operator+(float, View<Block> const&);
13410 template <typename Block,
13411 unsigned int Dim = Block::dim>
13412 struct Lvalue_proxy { operator float() const; };
13414 void
13415 test_1d (void) {
13416 Lvalue_proxy<Dense> p;
13417 float b;
13418 b + p;
13419 }
13421 Here, if Lvalue_proxy is permitted to bind to View, then
13422 the global operator+ will be used; if they are not, the
13423 Lvalue_proxy will be converted to float. */
13425 argvec,
13427 tf_none,
13433 /* Deduce arguments T, i from TT<T> or TT<i>.
13434 We check each element of PARMVEC and ARGVEC individually
13435 rather than the whole TREE_VEC since they can have
13436 different number of elements. */
13443 /* Check if the parameters end in a pack, making them
13444 variadic. */
13453 {
13457 UNIFY_ALLOW_NONE))
13459 }
13464 UNIFY_ALLOW_NONE,
13468 }
13471 /* Fall through to deduce template name. */
13472 }
13476 {
13477 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
13479 /* Simple cases: Value already set, does match or doesn't. */
13484 }
13485 else
13486 {
13487 /* If PARM is `const T' and ARG is only `int', we don't have
13488 a match unless we are allowing additional qualification.
13489 If ARG is `const int' and PARM is just `T' that's OK;
13490 that binds `const int' to `T'. */
13495 /* Consider the case where ARG is `const volatile int' and
13496 PARM is `const T'. Then, T should be `volatile int'. */
13497 arg = cp_build_qualified_type_real
13502 /* Simple cases: Value already set, does match or doesn't. */
13508 /* Make sure that ARG is not a variable-sized array. (Note
13509 that were talking about variable-sized arrays (like
13510 `int[n]'), rather than arrays of unknown size (like
13511 `int[]').) We'll get very confused by such a type since
13512 the bound of the array will not be computable in an
13513 instantiation. Besides, such types are not allowed in
13514 ISO C++, so we can do as we please here. */
13517 }
13519 /* If ARG is a parameter pack or an expansion, we cannot unify
13520 against it unless PARM is also a parameter pack. */
13535 /* The PARM is not one we're trying to unify. Just check
13536 to see if it matches ARG. */
13546 /* [temp.deduct.type] If, in the declaration of a function template
13547 with a non-type template-parameter, the non-type
13548 template-parameter is used in an expression in the function
13549 parameter-list and, if the corresponding template-argument is
13550 deduced, the template-argument type shall match the type of the
13551 template-parameter exactly, except that a template-argument
13552 deduced from an array bound may be of any integral type.
13553 The non-type parameter might use already deduced type parameters. */
13556 /* Template-parameter dependent expression. Just accept it for now.
13557 It will later be processed in convert_template_argument. */
13558 ;
13564 /* Convert the ARG to the type of PARM; the deduced non-type
13565 template argument must exactly match the types of the
13566 corresponding parameter. */
13569 /* We haven't deduced the type of this parameter yet. Try again
13570 later. */
13572 else
13575 /* If ARG is a parameter pack or an expansion, we cannot unify
13576 against it unless PARM is also a parameter pack. */
13585 {
13586 /* A pointer-to-member constant can be unified only with
13587 another constant. */
13591 /* Just unify the class member. It would be useless (and possibly
13592 wrong, depending on the strict flags) to unify also
13593 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13594 arg refer to the same variable, even if through different
13595 classes. For instance:
13597 struct A { int x; };
13598 struct B : A { };
13600 Unification of &A::x and &B::x must succeed. */
13603 }
13606 {
13610 /* [temp.deduct.call]
13612 A can be another pointer or pointer to member type that can
13613 be converted to the deduced A via a qualification
13614 conversion (_conv.qual_).
13616 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13617 This will allow for additional cv-qualification of the
13618 pointed-to types if appropriate. */
13621 /* The derived-to-base conversion only persists through one
13622 level of pointers. */
13627 }
13642 {
13643 tree parm_max;
13644 tree arg_max;
13648 /* Our representation of array types uses "N - 1" as the
13649 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13650 not an integer constant. We cannot unify arbitrarily
13651 complex expressions, so we eliminate the MINUS_EXPRs
13652 here. */
13656 {
13659 }
13663 {
13664 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13665 trying to unify the type of a variable with the type
13666 of a template parameter. For example:
13668 template <unsigned int N>
13669 void f (char (&) [N]);
13670 int g();
13671 void h(int i) {
13672 char a[g(i)];
13673 f(a);
13674 }
13676 Here, the type of the ARG will be "int [g(i)]", and
13677 may be a SAVE_EXPR, etc. */
13681 }
13683 /* If only one of the bounds used a MINUS_EXPR, compensate
13684 by adding one to the other bound. */
13687 integer_type_node,
13688 parm_max,
13689 integer_one_node);
13692 integer_type_node,
13693 arg_max,
13694 integer_one_node);
13698 }
13712 /* We have already checked cv-qualification at the top of the
13713 function. */
13717 /* As far as unification is concerned, this wins. Later checks
13718 will invalidate it if necessary. */
13721 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13722 /* Type INTEGER_CST can come from ordinary constant template args. */
13732 {
13741 UNIFY_ALLOW_NONE))
13744 }
13752 {
13759 strict);
13760 }
13763 {
13767 {
13768 /* First, we try to unify the PARM and ARG directly. */
13773 {
13774 /* Fallback to the special case allowed in
13775 [temp.deduct.call]:
13777 If P is a class, and P has the form
13778 template-id, then A can be a derived class of
13779 the deduced A. Likewise, if P is a pointer to
13780 a class of the form template-id, A can be a
13781 pointer to a derived class pointed to by the
13782 deduced A. */
13787 }
13788 }
13792 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13793 Then, we should unify `int' and `U'. */
13795 else
13796 /* There's no chance of unification succeeding. */
13801 }
13811 /* CV qualifications for methods can never be deduced, they must
13812 match exactly. We need to check them explicitly here,
13813 because type_unification_real treats them as any other
13814 cv-qualified parameter. */
13816 && (!check_cv_quals_for_unify
13827 LOOKUP_NORMAL);
13830 /* Unify a pointer to member with a pointer to member function, which
13831 deduces the type of the member as a function type. */
13833 {
13834 tree method_type;
13835 tree fntype;
13836 cp_cv_quals cv_quals;
13838 /* Check top-level cv qualifiers */
13846 /* Determine the type of the function we are unifying against. */
13848 fntype =
13852 /* Extract the cv-qualifiers of the member function from the
13853 implicit object parameter and place them on the function
13854 type to be restored later. */
13855 cv_quals =
13859 }
13867 strict);
13878 /* Matched cases are handled by the ARG == PARM test above. */
13883 {
13891 {
13893 {
13895 /* We can unify against something with a trailing
13896 parameter pack. */
13898 else
13899 /* Since there is something following the pack
13900 expansion, we cannot unify this template argument
13901 list. */
13903 }
13904 }
13907 /* If we don't have enough arguments to satisfy the parameters
13908 (not counting the pack expression at the end), or we have
13909 too many arguments for a parameter list that doesn't end in
13910 a pack expression, we can't unify. */
13915 /* Unify all of the parameters that precede the (optional)
13916 pack expression. */
13918 {
13922 }
13930 }
13936 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13937 nodes. */
13941 /* Unification fails if we hit an error node. */
13947 /* We must be looking at an expression. This can happen with
13948 something like:
13950 template <int I>
13951 void foo(S<I>, S<I + 2>);
13953 This is a "nondeduced context":
13955 [deduct.type]
13957 The nondeduced contexts are:
13959 --A type that is a template-id in which one or more of
13960 the template-arguments is an expression that references
13961 a template-parameter.
13963 In these cases, we assume deduction succeeded, but don't
13964 actually infer any unifications. */
13969 else
13971 }
13972 }
13973 \f
13974 /* Note that DECL can be defined in this translation unit, if
13975 required. */
13977 static void
13979 {
13980 tree clone;
13984 }
13986 /* Called if RESULT is explicitly instantiated, or is a member of an
13987 explicitly instantiated class. */
13989 void
13991 {
13994 /* If this entity has already been written out, it's too late to
13995 make any modifications. */
14000 /* The TREE_PUBLIC flag for function declarations will have been
14001 set correctly by tsubst. */
14004 /* This might have been set by an earlier implicit instantiation. */
14009 else
14010 {
14012 /* Always make artificials weak. */
14015 /* For WIN32 we also want to put explicit instantiations in
14016 linkonce sections. */
14019 }
14021 /* If EXTERN_P, then this function will not be emitted -- unless
14022 followed by an explicit instantiation, at which point its linkage
14023 will be adjusted. If !EXTERN_P, then this function will be
14024 emitted here. In neither circumstance do we want
14025 import_export_decl to adjust the linkage. */
14027 }
14029 /* Given two function templates PAT1 and PAT2, return:
14031 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
14032 -1 if PAT2 is more specialized than PAT1.
14033 0 if neither is more specialized.
14035 LEN indicates the number of parameters we should consider
14036 (defaulted parameters should not be considered).
14038 The 1998 std underspecified function template partial ordering, and
14039 DR214 addresses the issue. We take pairs of arguments, one from
14040 each of the templates, and deduce them against each other. One of
14041 the templates will be more specialized if all the *other*
14042 template's arguments deduce against its arguments and at least one
14043 of its arguments *does* *not* deduce against the other template's
14044 corresponding argument. Deduction is done as for class templates.
14045 The arguments used in deduction have reference and top level cv
14046 qualifiers removed. Iff both arguments were originally reference
14047 types *and* deduction succeeds in both directions, the template
14048 with the more cv-qualified argument wins for that pairing (if
14049 neither is more cv-qualified, they both are equal). Unlike regular
14050 deduction, after all the arguments have been deduced in this way,
14051 we do *not* verify the deduced template argument values can be
14052 substituted into non-deduced contexts, nor do we have to verify
14053 that all template arguments have been deduced. */
14055 int
14057 {
14069 /* Remove the this parameter from non-static member functions. If
14070 one is a non-static member function and the other is not a static
14071 member function, remove the first parameter from that function
14072 also. This situation occurs for operator functions where we
14073 locate both a member function (with this pointer) and non-member
14074 operator (with explicit first operand). */
14076 {
14081 }
14083 {
14086 {
14087 len--;
14089 }
14090 }
14092 /* If only one is a conversion operator, they are unordered. */
14096 /* Consider the return type for a conversion function */
14098 {
14101 len++;
14102 }
14104 processing_template_decl++;
14107 /* Stop when an ellipsis is seen. */
14109 {
14118 {
14119 /* When both arguments are pack expansions, we need only
14120 unify the patterns themselves. */
14124 /* This is the last comparison we need to do. */
14126 }
14129 {
14132 }
14135 {
14138 }
14141 {
14142 /* Only of the args is a reference, see if we should apply
14143 array/function pointer decay to it. This is not part of
14144 DR214, but is, IMHO, consistent with the deduction rules
14145 for the function call itself, and with our earlier
14146 implementation of the underspecified partial ordering
14147 rules. (nathan). */
14149 {
14151 {
14154 /* FALLTHROUGH. */
14161 }
14162 }
14163 else
14164 {
14166 {
14169 /* FALLTHROUGH. */
14176 }
14177 }
14178 }
14184 {
14190 /* Setup the parameter vector, which contains only ARG1. */
14193 /* Setup the argument vector, which contains the remaining
14194 arguments. */
14203 /* We cannot deduce in the other direction, because ARG1 is
14204 a pack expansion but ARG2 is not. */
14206 }
14208 {
14214 /* Setup the parameter vector, which contains only ARG1. */
14217 /* Setup the argument vector, which contains the remaining
14218 arguments. */
14227 /* We cannot deduce in the other direction, because ARG2 is
14228 a pack expansion but ARG1 is not.*/
14230 }
14232 else
14233 {
14234 /* The normal case, where neither argument is a pack
14235 expansion. */
14238 }
14245 /* We've failed to deduce something in either direction.
14246 These must be unordered. */
14250 {
14251 /* Deduces in both directions, see if quals can
14252 disambiguate. Pretend the worse one failed to deduce. */
14257 }
14265 /* We have already processed all of the arguments in our
14266 handing of the pack expansion type. */
14271 }
14273 processing_template_decl--;
14275 /* All things being equal, if the next argument is a pack expansion
14276 for one function but not for the other, prefer the
14277 non-variadic function. */
14281 {
14286 }
14289 }
14291 /* Determine which of two partial specializations is more specialized.
14293 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
14294 to the first partial specialization. The TREE_VALUE is the
14295 innermost set of template parameters for the partial
14296 specialization. PAT2 is similar, but for the second template.
14298 Return 1 if the first partial specialization is more specialized;
14299 -1 if the second is more specialized; 0 if neither is more
14300 specialized.
14302 See [temp.class.order] for information about determining which of
14303 two templates is more specialized. */
14305 static int
14307 {
14308 tree targs;
14316 /* Just like what happens for functions, if we are ordering between
14317 different class template specializations, we may encounter dependent
14318 types in the arguments, and we need our dependency check functions
14319 to behave correctly. */
14325 {
14328 }
14334 {
14337 }
14340 /* In the case of a tie where at least one of the class templates
14341 has a parameter pack at the end, the template with the most
14342 non-packed parameters wins. */
14344 && any_deductions
14347 {
14353 /* We don't count the pack expansion at the end. */
14363 }
14366 }
14368 /* Return the template arguments that will produce the function signature
14369 DECL from the function template FN, with the explicit template
14370 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
14371 also match. Return NULL_TREE if no satisfactory arguments could be
14372 found. */
14374 static tree
14376 {
14379 tree decl_type;
14380 tree decl_arg_types;
14382 /* Substitute the explicit template arguments into the type of DECL.
14383 The call to fn_type_unification will handle substitution into the
14384 FN. */
14387 {
14388 tree tmpl;
14389 tree converted_args;
14393 else
14394 /* We can get here for some invalid specializations. */
14397 converted_args
14400 tf_none,
14409 }
14411 /* Never do unification on the 'this' parameter. */
14416 decl_arg_types,
14423 }
14425 /* Return the innermost template arguments that, when applied to a
14426 template specialization whose innermost template parameters are
14427 TPARMS, and whose specialization arguments are PARMS, yield the
14428 ARGS.
14430 For example, suppose we have:
14432 template <class T, class U> struct S {};
14433 template <class T> struct S<T*, int> {};
14435 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
14436 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
14437 int}. The resulting vector will be {double}, indicating that `T'
14438 is bound to `double'. */
14440 static tree
14442 {
14444 tree deduced_args;
14445 tree innermost_deduced_args;
14449 {
14453 innermost_deduced_args);
14454 }
14455 else
14461 UNIFY_ALLOW_NONE))
14468 /* Verify that nondeduced template arguments agree with the type
14469 obtained from argument deduction.
14471 For example:
14473 struct A { typedef int X; };
14474 template <class T, class U> struct C {};
14475 template <class T> struct C<T, typename T::X> {};
14477 Then with the instantiation `C<A, int>', we can deduce that
14478 `T' is `A' but unify () does not check whether `typename T::X'
14479 is `int'. */
14482 /* We only need to check the innermost arguments; the other
14483 arguments will always agree. */
14488 /* Now that we have bindings for all of the template arguments,
14489 ensure that the arguments deduced for the template template
14490 parameters have compatible template parameter lists. See the use
14491 of template_template_parm_bindings_ok_p in fn_type_unification
14492 for more information. */
14497 }
14499 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
14500 Return the TREE_LIST node with the most specialized template, if
14501 any. If there is no most specialized template, the error_mark_node
14502 is returned.
14504 Note that this function does not look at, or modify, the
14505 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
14506 returned is one of the elements of INSTANTIATIONS, callers may
14507 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
14508 and retrieve it from the value returned. */
14510 tree
14512 {
14519 {
14525 fate--;
14530 fate++;
14535 {
14536 /* Equally specialized, move to next function. If there
14537 is no next function, nothing's most specialized. */
14542 }
14543 }
14546 /* Now verify that champ is better than everything earlier in the
14547 instantiation list. */
14555 {
14558 }
14560 processing_template_decl--;
14566 }
14568 /* If DECL is a specialization of some template, return the most
14569 general such template. Otherwise, returns NULL_TREE.
14571 For example, given:
14573 template <class T> struct S { template <class U> void f(U); };
14575 if TMPL is `template <class U> void S<int>::f(U)' this will return
14576 the full template. This function will not trace past partial
14577 specializations, however. For example, given in addition:
14579 template <class T> struct S<T*> { template <class U> void f(U); };
14581 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14582 `template <class T> template <class U> S<T*>::f(U)'. */
14584 tree
14586 {
14587 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14588 an immediate specialization. */
14590 {
14594 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14595 template friend. */
14600 }
14602 /* Look for more and more general templates. */
14604 {
14605 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14606 (See cp-tree.h for details.) */
14614 /* Stop if we run into an explicitly specialized class template. */
14621 }
14624 }
14626 /* Return the most specialized of the class template partial
14627 specializations of TMPL which can produce TYPE, a specialization of
14628 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14629 a _TYPE node corresponding to the partial specialization, while the
14630 TREE_PURPOSE is the set of template arguments that must be
14631 substituted into the TREE_TYPE in order to generate TYPE.
14633 If the choice of partial specialization is ambiguous, a diagnostic
14634 is issued, and the error_mark_node is returned. If there are no
14635 partial specializations of TMPL matching TYPE, then NULL_TREE is
14636 returned. */
14638 static tree
14640 {
14642 tree t;
14643 tree champ;
14646 tree args;
14652 /* For determining which partial specialization to use, only the
14653 innermost args are interesting. */
14655 {
14658 }
14661 {
14662 tree partial_spec_args;
14663 tree spec_args;
14668 {
14673 /* Discard the outer levels of args, and then substitute in the
14674 template args from the enclosing class. */
14676 partial_spec_args = tsubst_template_args
14679 /* PARMS already refers to just the innermost parms, but the
14680 template parms in partial_spec_args had their levels lowered
14681 by tsubst, so we need to do the same for the parm list. We
14682 can't just tsubst the TREE_VEC itself, as tsubst wants to
14683 treat a TREE_VEC as an argument vector. */
14690 }
14692 partial_spec_args,
14693 args);
14695 {
14700 }
14701 }
14711 {
14714 ;
14715 else
14716 {
14718 {
14721 {
14724 }
14725 }
14727 }
14728 }
14732 {
14735 {
14738 }
14739 }
14742 {
14746 {
14749 }
14751 }
14754 }
14756 /* Explicitly instantiate DECL. */
14758 void
14760 {
14765 /* An error occurred, for which grokdeclarator has already issued
14766 an appropriate message. */
14769 {
14772 }
14774 {
14775 /* There is an asymmetry here in the way VAR_DECLs and
14776 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14777 the latter, the DECL we get back will be marked as a
14778 template instantiation, and the appropriate
14779 DECL_TEMPLATE_INFO will be set up. This does not happen for
14780 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14781 should handle VAR_DECLs as it currently handles
14782 FUNCTION_DECLs. */
14784 {
14787 }
14790 {
14793 }
14795 {
14800 }
14801 }
14803 {
14806 }
14807 else
14810 /* Check for various error cases. Note that if the explicit
14811 instantiation is valid the RESULT will currently be marked as an
14812 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14813 until we get here. */
14816 {
14817 /* DR 259 [temp.spec].
14819 Both an explicit instantiation and a declaration of an explicit
14820 specialization shall not appear in a program unless the explicit
14821 instantiation follows a declaration of the explicit specialization.
14823 For a given set of template parameters, if an explicit
14824 instantiation of a template appears after a declaration of an
14825 explicit specialization for that template, the explicit
14826 instantiation has no effect. */
14828 }
14830 {
14831 /* [temp.spec]
14833 No program shall explicitly instantiate any template more
14834 than once.
14836 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14837 the first instantiation was `extern' and the second is not,
14838 and EXTERN_P for the opposite case. */
14841 /* If an "extern" explicit instantiation follows an ordinary
14842 explicit instantiation, the template is instantiated. */
14845 }
14847 {
14850 }
14852 {
14855 }
14858 ;
14860 {
14863 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
14866 }
14867 else
14875 }
14877 static void
14879 {
14885 {
14888 }
14889 }
14891 /* Called from do_type_instantiation through binding_table_foreach to
14892 do recursive instantiation for the type bound in ENTRY. */
14893 static void
14895 {
14901 }
14903 /* Called from do_type_instantiation to instantiate a member
14904 (a member function or a static member variable) of an
14905 explicitly instantiated class template. */
14906 static void
14908 {
14913 }
14915 /* Perform an explicit instantiation of template class T. STORAGE, if
14916 non-null, is the RID for extern, inline or static. COMPLAIN is
14917 nonzero if this is called from the parser, zero if called recursively,
14918 since the standard is unclear (as detailed below). */
14920 void
14922 {
14932 {
14935 }
14940 {
14943 t);
14945 }
14948 {
14950 {
14952 {
14955 "ISO C++ 1998 forbids the use of %<extern%> on "
14957 }
14958 else
14960 "ISO C++ forbids the use of %qE"
14962 }
14970 else
14971 {
14973 storage);
14975 }
14976 }
14979 {
14980 /* DR 259 [temp.spec].
14982 Both an explicit instantiation and a declaration of an explicit
14983 specialization shall not appear in a program unless the explicit
14984 instantiation follows a declaration of the explicit specialization.
14986 For a given set of template parameters, if an explicit
14987 instantiation of a template appears after a declaration of an
14988 explicit specialization for that template, the explicit
14989 instantiation has no effect. */
14991 }
14993 {
14994 /* [temp.spec]
14996 No program shall explicitly instantiate any template more
14997 than once.
14999 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
15000 instantiation was `extern'. If EXTERN_P then the second is.
15001 These cases are OK. */
15008 /* If we've already instantiated the template, just return now. */
15011 }
15019 {
15020 tree tmp;
15022 /* In contrast to implicit instantiation, where only the
15023 declarations, and not the definitions, of members are
15024 instantiated, we have here:
15026 [temp.explicit]
15028 The explicit instantiation of a class template specialization
15029 implies the instantiation of all of its members not
15030 previously explicitly specialized in the translation unit
15031 containing the explicit instantiation.
15033 Of course, we can't instantiate member template classes, since
15034 we don't have any arguments for them. Note that the standard
15035 is unclear on whether the instantiation of the members are
15036 *explicit* instantiations or not. However, the most natural
15037 interpretation is that it should be an explicit instantiation. */
15052 }
15053 }
15055 /* Given a function DECL, which is a specialization of TMPL, modify
15056 DECL to be a re-instantiation of TMPL with the same template
15057 arguments. TMPL should be the template into which tsubst'ing
15058 should occur for DECL, not the most general template.
15060 One reason for doing this is a scenario like this:
15062 template <class T>
15063 void f(const T&, int i);
15065 void g() { f(3, 7); }
15067 template <class T>
15068 void f(const T& t, const int i) { }
15070 Note that when the template is first instantiated, with
15071 instantiate_template, the resulting DECL will have no name for the
15072 first parameter, and the wrong type for the second. So, when we go
15073 to instantiate the DECL, we regenerate it. */
15075 static void
15077 {
15078 /* The arguments used to instantiate DECL, from the most general
15079 template. */
15080 tree args;
15081 tree code_pattern;
15086 /* Make sure that we can see identifiers, and compute access
15087 correctly. */
15091 {
15092 tree decl_parm;
15093 tree pattern_parm;
15094 tree specs;
15107 specs);
15109 /* Merge parameter declarations. */
15112 pattern_parm
15116 {
15117 tree parm_type;
15118 tree attributes;
15123 NULL_TREE);
15129 {
15132 }
15135 }
15136 /* Merge any parameters that match with the function parameter
15137 pack. */
15139 {
15141 tree expanded_types;
15142 /* Expand the TYPE_PACK_EXPANSION that provides the types for
15143 the parameters in this function parameter pack. */
15148 {
15149 tree parm_type;
15150 tree attributes;
15153 /* Rename the parameter to include the index. */
15162 {
15165 }
15167 }
15168 }
15169 /* Merge additional specifiers from the CODE_PATTERN. */
15173 }
15179 else
15183 }
15185 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
15186 substituted to get DECL. */
15188 tree
15190 {
15193 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
15194 for the instantiation. This is not always the most general
15195 template. Consider, for example:
15197 template <class T>
15198 struct S { template <class U> void f();
15199 template <> void f<int>(); };
15201 and an instantiation of S<double>::f<int>. We want TD to be the
15202 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
15204 more general template. */
15206 /* We must also deal with friend templates. Given:
15208 template <class T> struct S {
15209 template <class U> friend void f() {};
15210 };
15212 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
15213 so far as the language is concerned, but that's still
15214 where we get the pattern for the instantiation from. On
15215 other hand, if the definition comes outside the class, say:
15217 template <class T> struct S {
15218 template <class U> friend void f();
15219 };
15220 template <class U> friend void f() {}
15222 we don't need to look any further. That's what the check for
15223 DECL_INITIAL is for. */
15227 {
15228 /* The present template, TD, should not be a definition. If it
15229 were a definition, we should be using it! Note that we
15230 cannot restructure the loop to just keep going until we find
15231 a template with a definition, since that might go too far if
15232 a specialization was declared, but not defined. */
15236 /* Fetch the more general template. */
15238 }
15241 }
15243 /* Produce the definition of D, a _DECL generated from a template. If
15244 DEFER_OK is nonzero, then we don't have to actually do the
15245 instantiation now; we just have to do it sometime. Normally it is
15246 an error if this is an explicit instantiation but D is undefined.
15247 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
15248 explicitly instantiated class template. */
15250 tree
15253 {
15255 tree gen_args;
15256 tree args;
15257 tree td;
15258 tree code_pattern;
15259 tree spec;
15260 tree gen_tmpl;
15266 /* This function should only be used to instantiate templates for
15267 functions and static member variables. */
15271 /* Variables are never deferred; if instantiation is required, they
15272 are instantiated right away. That allows for better code in the
15273 case that an expression refers to the value of the variable --
15274 if the variable has a constant value the referring expression can
15275 take advantage of that fact. */
15279 /* Don't instantiate cloned functions. Instead, instantiate the
15280 functions they cloned. */
15285 /* D has already been instantiated. It might seem reasonable to
15286 check whether or not D is an explicit instantiation, and, if so,
15287 stop here. But when an explicit instantiation is deferred
15288 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
15289 is set, even though we still need to do the instantiation. */
15292 /* If we already have a specialization of this declaration, then
15293 there's no reason to instantiate it. Note that
15294 retrieve_specialization gives us both instantiations and
15295 specializations, so we must explicitly check
15296 DECL_TEMPLATE_SPECIALIZATION. */
15304 /* This needs to happen before any tsubsting. */
15310 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
15311 for the instantiation. */
15315 /* We should never be trying to instantiate a member of a class
15316 template or partial specialization. */
15321 /* In the case of a friend template whose definition is provided
15322 outside the class, we may have too many arguments. Drop the
15323 ones we don't need. The same is true for specializations. */
15324 args = get_innermost_template_args
15326 else
15331 else
15334 /* We may be in the middle of deferred access check. Disable it now. */
15337 /* Unless an explicit instantiation directive has already determined
15338 the linkage of D, remember that a definition is available for
15339 this entity. */
15347 /* If D is a member of an explicitly instantiated class template,
15348 and no definition is available, treat it like an implicit
15349 instantiation. */
15352 {
15356 }
15359 {
15360 /* Recheck the substitutions to obtain any warning messages
15361 about ignoring cv qualifiers. */
15365 /* Make sure that we can see identifiers, and compute access
15366 correctly. D is already the target FUNCTION_DECL with the
15367 right context. */
15371 {
15374 d);
15375 /* Don't simply tsubst the function type, as that will give
15376 duplicate warnings about poor parameter qualifications.
15377 The function arguments are the same as the decl_arguments
15378 without the top level cv qualifiers. */
15380 }
15384 }
15386 /* Check to see whether we know that this template will be
15387 instantiated in some other file, as with "extern template"
15388 extension. */
15390 /* In general, we do not instantiate such templates... */
15392 /* ... but we instantiate inline functions so that we can inline
15393 them. An explicit instantiation declaration prohibits implicit
15394 instantiation of non-inline functions. With high levels of
15395 optimization, we would normally inline non-inline functions
15396 -- but we're not allowed to do that for "extern template" functions.
15397 Therefore, we check DECL_DECLARED_INLINE_P, rather than
15398 possibly_inlined_p. And ... */
15401 /* ... we instantiate static data members whose values are
15402 needed in integral constant expressions. */
15406 /* Defer all other templates, unless we have been explicitly
15407 forbidden from doing so. */
15409 template. */
15410 ! pattern_defined
15411 /* If it's OK to postpone instantiation, do so. */
15412 || defer_ok
15413 /* If this is a static data member that will be defined
15414 elsewhere, we don't want to instantiate the entire data
15415 member, but we do want to instantiate the initializer so that
15416 we can substitute that elsewhere. */
15418 {
15419 /* The definition of the static data member is now required so
15420 we must substitute the initializer. */
15424 {
15425 tree ns;
15426 tree init;
15432 args,
15437 LOOKUP_ONLYCONVERTING);
15440 }
15442 /* We restore the source position here because it's used by
15443 add_pending_template. */
15449 /* [temp.explicit]
15451 The definition of a non-exported function template, a
15452 non-exported member function template, or a non-exported
15453 member function or static data member of a class template
15454 shall be present in every translation unit in which it is
15455 explicitly instantiated. */
15459 /* ??? Historically, we have instantiated inline functions, even
15460 when marked as "extern template". */
15464 }
15465 /* Tell the repository that D is available in this translation unit
15466 -- and see if it is supposed to be instantiated here. */
15468 {
15469 /* In a PCH file, despite the fact that the repository hasn't
15470 requested instantiation in the PCH it is still possible that
15471 an instantiation will be required in a file that includes the
15472 PCH. */
15475 /* Instantiate inline functions so that the inliner can do its
15476 job, even though we'll not be emitting a copy of this
15477 function. */
15480 }
15486 /* Mark D as instantiated so that recursive calls to
15487 instantiate_decl do not try to instantiate it again. */
15490 /* Regenerate the declaration in case the template has been modified
15491 by a subsequent redeclaration. */
15494 /* We already set the file and line above. Reset them now in case
15495 they changed as a result of calling regenerate_decl_from_template. */
15499 {
15500 tree init;
15502 /* Clear out DECL_RTL; whatever was there before may not be right
15503 since we've reset the type of the declaration. */
15507 /* The initializer is placed in DECL_INITIAL by
15508 regenerate_decl_from_template. Pull it out so that
15509 finish_decl can process it. */
15514 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
15515 initializer. That function will defer actual emission until
15516 we have a chance to determine linkage. */
15519 /* Enter the scope of D so that access-checking works correctly. */
15523 }
15525 {
15526 htab_t saved_local_specializations;
15527 tree subst_decl;
15528 tree tmpl_parm;
15529 tree spec_parm;
15531 /* Save away the current list, in case we are instantiating one
15532 template from within the body of another. */
15535 /* Set up the list of local specializations. */
15537 hash_local_specialization,
15538 eq_local_specializations,
15539 NULL);
15541 /* Set up context. */
15544 /* Create substitution entries for the parameters. */
15549 {
15553 }
15555 {
15559 }
15561 {
15562 /* Collect all of the extra "packed" parameters into an
15563 argument pack. */
15564 tree parmvec;
15565 tree parmtypevec;
15569 tree t;
15571 /* Count how many parameters remain. */
15573 len++;
15575 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
15579 {
15582 }
15584 /* Build the argument packs. */
15589 /* Register the (value) argument pack as a specialization of
15590 TMPL_PARM, then move on. */
15593 }
15596 /* Substitute into the body of the function. */
15601 /* Set the current input_location to the end of the function
15602 so that finish_function knows where we are. */
15605 /* We don't need the local specializations any more. */
15609 /* Finish the function. */
15612 }
15614 /* We're not deferring instantiation any more. */
15620 out:
15628 }
15630 /* Run through the list of templates that we wish we could
15631 instantiate, and instantiate any we can. RETRIES is the
15632 number of times we retry pending template instantiation. */
15634 void
15636 {
15640 /* Instantiating templates may trigger vtable generation. This in turn
15641 may require further template instantiations. We place a limit here
15642 to avoid infinite loop. */
15644 {
15648 " instantiating %q+D, possibly from virtual table generation"
15652 /* Pretend that we defined it. */
15655 }
15657 do
15658 {
15663 {
15668 {
15669 tree fn;
15672 {
15676 fn;
15684 }
15687 }
15688 else
15689 {
15692 {
15693 instantiation
15699 }
15703 }
15706 /* If INSTANTIATION has been instantiated, then we don't
15707 need to consider it again in the future. */
15709 else
15710 {
15713 }
15716 }
15718 }
15722 }
15724 /* Substitute ARGVEC into T, which is a list of initializers for
15725 either base class or a non-static data member. The TREE_PURPOSEs
15726 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15727 instantiate_decl. */
15729 static tree
15731 {
15735 {
15736 tree decl;
15737 tree init;
15743 {
15744 tree expr;
15745 tree arg;
15747 /* Expand the base class expansion type into separate base
15748 classes. */
15750 tf_warning_or_error,
15751 NULL_TREE);
15755 /* We'll be building separate TREE_LISTs of arguments for
15756 each base. */
15762 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15763 expand each argument in the TREE_VALUE of t. */
15769 /* VOID_TYPE_NODE is used to indicate
15770 value-initialization. */
15771 {
15774 }
15775 else
15776 {
15777 /* Substitute parameter packs into each argument in the
15778 TREE_LIST. */
15781 {
15782 tree expanded_exprs;
15784 /* Expand the argument. */
15786 expanded_exprs
15788 tf_warning_or_error,
15789 NULL_TREE);
15793 /* Prepend each of the expanded expressions to the
15794 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15796 {
15801 }
15802 }
15805 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15806 since we built them backwards. */
15808 {
15811 }
15812 }
15813 }
15816 {
15818 {
15822 }
15823 else
15824 {
15836 }
15839 {
15843 }
15844 }
15845 }
15847 }
15849 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15851 static void
15853 {
15858 else
15860 }
15862 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15863 is the instantiation (which should have been created with
15864 start_enum) and ARGS are the template arguments to use. */
15866 static void
15868 {
15869 tree e;
15872 {
15873 tree value;
15874 tree decl;
15877 /* Note that in a template enum, the TREE_VALUE is the
15878 CONST_DECL, not the corresponding INTEGER_CST. */
15883 /* Give this enumeration constant the correct access. */
15886 /* Actually build the enumerator itself. */
15888 }
15893 }
15895 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15896 its type -- but without substituting the innermost set of template
15897 arguments. So, innermost set of template parameters will appear in
15898 the type. */
15900 tree
15902 {
15903 tree fn_type;
15904 tree tmpl;
15905 tree targs;
15906 tree tparms;
15914 /* There should be as many levels of arguments as there are levels
15915 of parameters. */
15921 /* No substitution is necessary. */
15922 ;
15923 else
15924 {
15926 tree partial_args;
15928 /* Replace the innermost level of the TARGS with NULL_TREEs to
15929 let tsubst know not to substitute for those parameters. */
15938 /* Disable access control as this function is used only during
15939 name-mangling. */
15944 /* Now, do the (partial) substitution to figure out the
15945 appropriate function type. */
15949 /* Substitute into the template parameters to obtain the real
15950 innermost set of parameters. This step is important if the
15951 innermost set of template parameters contains value
15952 parameters whose types depend on outer template parameters. */
15957 }
15960 }
15962 /* Return truthvalue if we're processing a template different from
15963 the last one involved in diagnostics. */
15964 int
15966 {
15968 }
15970 /* Remember current template involved in diagnostics. */
15971 void
15973 {
15975 }
15979 {
15981 }
15983 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15984 type. Return zero for ok, nonzero for disallowed. Issue error and
15985 warning messages under control of COMPLAIN. */
15987 static int
15989 {
16004 }
16006 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
16007 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
16009 static bool
16011 {
16012 tree scope;
16014 /* [temp.dep.type]
16016 A type is dependent if it is:
16018 -- a template parameter. Template template parameters are types
16019 for us (since TYPE_P holds true for them) so we handle
16020 them here. */
16024 /* -- a qualified-id with a nested-name-specifier which contains a
16025 class-name that names a dependent type or whose unqualified-id
16026 names a dependent type. */
16029 /* -- a cv-qualified type where the cv-unqualified type is
16030 dependent. */
16032 /* -- a compound type constructed from any dependent type. */
16042 {
16043 tree arg_type;
16048 arg_type;
16053 }
16054 /* -- an array type constructed from any dependent type or whose
16055 size is specified by a constant expression that is
16056 value-dependent. */
16058 {
16063 }
16066 {
16067 /* If this is the TYPE_DOMAIN of an array type, consider it
16068 dependent. */
16071 }
16073 /* -- a template-id in which either the template name is a template
16074 parameter ... */
16077 /* ... or any of the template arguments is a dependent type or
16078 an expression that is type-dependent or value-dependent. */
16080 && (any_dependent_template_arguments_p
16084 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
16085 argument of the `typeof' expression is not type-dependent, then
16086 it should already been have resolved. */
16091 /* A template argument pack is dependent if any of its packed
16092 arguments are. */
16094 {
16100 }
16102 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
16103 be template parameters. */
16107 /* The standard does not specifically mention types that are local
16108 to template functions or local classes, but they should be
16109 considered dependent too. For example:
16111 template <int I> void f() {
16112 enum E { a = I };
16113 S<sizeof (E)> s;
16114 }
16116 The size of `E' cannot be known until the value of `I' has been
16117 determined. Therefore, `E' must be considered dependent. */
16124 /* Other types are non-dependent. */
16126 }
16128 /* Returns TRUE if TYPE is dependent, in the sense of
16129 [temp.dep.type]. */
16131 bool
16133 {
16134 /* If there are no template parameters in scope, then there can't be
16135 any dependent types. */
16137 {
16138 /* If we are not processing a template, then nobody should be
16139 providing us with a dependent type. */
16143 }
16145 /* If the type is NULL, we have not computed a type for the entity
16146 in question; in that case, the type is dependent. */
16150 /* Erroneous types can be considered non-dependent. */
16154 /* If we have not already computed the appropriate value for TYPE,
16155 do so now. */
16157 {
16160 }
16163 }
16165 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
16166 lookup. In other words, a dependent type that is not the current
16167 instantiation. */
16169 bool
16171 {
16173 }
16175 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
16177 static bool
16179 {
16180 tree scope;
16181 tree name;
16191 /* [temp.dep.expr]
16193 An id-expression is type-dependent if it contains a
16194 nested-name-specifier that contains a class-name that names a
16195 dependent type. */
16196 /* The suggested resolution to Core Issue 224 implies that if the
16197 qualifying type is the current class, then we must peek
16198 inside it. */
16207 }
16209 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
16210 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
16211 expression. */
16213 bool
16215 {
16219 /* A name declared with a dependent type. */
16224 {
16226 /* A name that has not been looked up -- must be dependent. */
16230 /* A non-type template parm. */
16234 /* A non-type template parm. */
16240 /* A constant with integral or enumeration type and is initialized
16241 with an expression that is value-dependent. */
16253 /* These expressions are value-dependent if the type to which
16254 the cast occurs is dependent or the expression being casted
16255 is value-dependent. */
16256 {
16262 /* A functional cast has a list of operands. */
16265 {
16266 /* If there are no operands, it must be an expression such
16267 as "int()". This should not happen for aggregate types
16268 because it would form non-constant expressions. */
16272 }
16278 }
16282 /* A `sizeof' expression is value-dependent if the operand is
16283 type-dependent or is a pack expansion. */
16299 /* A CALL_EXPR may appear in a constant expression if it is a
16300 call to a builtin function, e.g., __builtin_constant_p. All
16301 such calls are value-dependent. */
16305 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
16306 is value-dependent. */
16307 {
16316 }
16319 {
16323 }
16330 /* A constant expression is value-dependent if any subexpression is
16331 value-dependent. */
16333 {
16343 || (value_dependent_expression_p
16348 {
16351 /* In some cases, some of the operands may be missing.
16352 (For example, in the case of PREDECREMENT_EXPR, the
16353 amount to increment by may be missing.) That doesn't
16354 make the expression dependent. */
16356 && (value_dependent_expression_p
16360 }
16364 }
16365 }
16367 /* The expression is not value-dependent. */
16369 }
16371 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
16372 [temp.dep.expr]. */
16374 bool
16376 {
16383 /* An unresolved name is always dependent. */
16388 /* Some expression forms are never type-dependent. */
16399 /* The types of these expressions depends only on the type to which
16400 the cast occurs. */
16408 /* The types of these expressions depends only on the type created
16409 by the expression. */
16412 {
16413 /* For NEW_EXPR tree nodes created inside a template, either
16414 the object type itself or a TREE_LIST may appear as the
16415 operand 1. */
16418 /* This is an array type. We need to check array dimensions
16419 as well. */
16421 || value_dependent_expression_p
16423 else
16425 }
16429 type_dependent_expression_p))
16435 && (any_dependent_template_arguments_p
16447 {
16448 tree elt;
16452 {
16455 }
16457 }
16460 {
16465 {
16471 }
16472 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
16480 {
16485 }
16490 {
16494 }
16496 }
16501 }
16503 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
16504 contains a type-dependent expression. */
16506 bool
16508 {
16510 {
16516 }
16518 }
16520 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
16521 expressions) contains any value-dependent expressions. */
16523 bool
16525 {
16531 }
16533 /* Returns TRUE if the ARG (a template argument) is dependent. */
16535 bool
16537 {
16545 {
16549 {
16552 }
16555 }
16558 else
16561 }
16563 /* Returns true if ARGS (a collection of template arguments) contains
16564 any types that require structural equality testing. */
16566 bool
16568 {
16578 {
16581 {
16587 {
16588 /* Look inside the argument pack. */
16591 }
16594 {
16608 }
16609 }
16610 }
16613 }
16615 /* Returns true if ARGS (a collection of template arguments) contains
16616 any dependent arguments. */
16618 bool
16620 {
16630 {
16635 }
16638 }
16640 /* Returns TRUE if the template TMPL is dependent. */
16642 bool
16644 {
16646 {
16648 {
16652 }
16654 }
16656 /* Template template parameters are dependent. */
16660 /* So are names that have not been looked up. */
16664 /* So are member templates of dependent classes. */
16668 }
16670 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16672 bool
16674 {
16677 }
16679 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
16680 is dependent. */
16682 bool
16684 {
16691 {
16712 {
16716 }
16720 {
16724 {
16729 }
16730 }
16731 }
16734 }
16736 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16737 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16738 no such TYPE can be found. Note that this function peers inside
16739 uninstantiated templates and therefore should be used only in
16740 extremely limited situations. ONLY_CURRENT_P restricts this
16741 peering to the currently open classes hierarchy (which is required
16742 when comparing types). */
16744 tree
16746 {
16747 tree scope;
16748 tree name;
16749 tree decl;
16751 tree pushed_scope;
16752 tree result;
16759 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16760 it first before we can figure out what NAME refers to. */
16763 /* If we don't know what SCOPE refers to, then we cannot resolve the
16764 TYPENAME_TYPE. */
16767 /* If the SCOPE is a template type parameter, we have no way of
16768 resolving the name. */
16771 /* If the SCOPE is not the current instantiation, there's no reason
16772 to look inside it. */
16775 /* If SCOPE isn't the template itself, it will not have a valid
16776 TYPE_FIELDS list. */
16778 /* scope is either the template itself or a compatible instantiation
16779 like X<T>, so look up the name in the original template. */
16781 else
16782 /* scope is a partial instantiation, so we can't do the lookup or we
16783 will lose the template arguments. */
16785 /* Enter the SCOPE so that name lookup will be resolved as if we
16786 were in the class definition. In particular, SCOPE will no
16787 longer be considered a dependent type. */
16789 /* Look up the declaration. */
16794 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16795 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16800 {
16804 }
16807 {
16808 tree tmpl;
16809 tree args;
16810 /* Obtain the template and the arguments. */
16813 /* Instantiate the template. */
16819 }
16821 /* Leave the SCOPE. */
16825 /* If we failed to resolve it, return the original typename. */
16829 /* If lookup found a typename type, resolve that too. */
16831 {
16832 /* Ill-formed programs can cause infinite recursion here, so we
16833 must catch that. */
16837 }
16839 /* Qualify the resulting type. */
16845 }
16847 /* EXPR is an expression which is not type-dependent. Return a proxy
16848 for EXPR that can be used to compute the types of larger
16849 expressions containing EXPR. */
16851 tree
16853 {
16854 tree inner_expr;
16856 /* Preserve null pointer constants so that the type of things like
16857 "p == 0" where "p" is a pointer can be determined. */
16860 /* Preserve OVERLOADs; the functions must be available to resolve
16861 types. */
16872 /* There is no need to return a proxy for a variable. */
16875 /* Preserve string constants; conversions from string constants to
16876 "char *" are allowed, even though normally a "const char *"
16877 cannot be used to initialize a "char *". */
16880 /* Preserve arithmetic constants, as an optimization -- there is no
16881 reason to create a new node. */
16884 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16885 There is at least one place where we want to know that a
16886 particular expression is a throw-expression: when checking a ?:
16887 expression, there are special rules if the second or third
16888 argument is a throw-expression. */
16907 /* If the type is unknown, it can't really be non-dependent */
16910 /* Otherwise, build a NON_DEPENDENT_EXPR.
16912 REFERENCE_TYPEs are not stripped for expressions in templates
16913 because doing so would play havoc with mangling. Consider, for
16914 example:
16916 template <typename T> void f<T& g>() { g(); }
16918 In the body of "f", the expression for "g" will have
16919 REFERENCE_TYPE, even though the standard says that it should
16920 not. The reason is that we must preserve the syntactic form of
16921 the expression so that mangling (say) "f<g>" inside the body of
16922 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16923 stripped here. */
16925 }
16927 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16928 Return a new TREE_LIST with the various arguments replaced with
16929 equivalent non-dependent expressions. */
16931 tree
16933 {
16934 tree a;
16935 tree new_args;
16941 new_args);
16943 }
16945 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
16946 with a level one deeper than the actual template parms. */
16948 tree
16950 {
16951 tree au;
16953 /* ??? Is it worth caching this for multiple autos at the same level? */
16965 }
16967 /* Replace auto in TYPE with std::initializer_list<auto>. */
16969 static tree
16971 {
16972 tree std_init_list = namespace_binding
16974 tree argvec;
16975 tree init_auto;
16977 {
16981 }
16991 }
16993 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
16994 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
16996 tree
16998 {
17002 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
17003 with either a new invented type template parameter U or, if the
17004 initializer is a braced-init-list (8.5.4), with
17005 std::initializer_list<U>. */
17018 {
17021 }
17026 }
17028 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
17029 result. */
17031 tree
17033 {
17034 tree argvec;
17043 }
17045 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
17047 bool
17049 {
17053 else
17055 }
17057 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
17058 appear as a type-specifier for the declaration in question, we don't
17059 have to look through the whole type. */
17061 tree
17063 {
17080 }