| blob | 72ea5b2d74009c998d372b7019d19a3ccacf4a29 |
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 };
75 /* Live only within one (recursive) call to tsubst_expr. We use
76 this to pass the statement expression node from the STMT_EXPR
77 to the EXPR_STMT that is its result. */
80 /* A map from local variable declarations in the body of the template
81 presently being instantiated to the corresponding instantiated
82 local variables. */
85 /* Contains canonical template parameter types. The vector is indexed by
86 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
87 TREE_LIST, whose TREE_VALUEs contain the canonical template
88 parameters of various types and levels. */
91 #define UNIFY_ALLOW_NONE 0
92 #define UNIFY_ALLOW_MORE_CV_QUAL 1
93 #define UNIFY_ALLOW_LESS_CV_QUAL 2
94 #define UNIFY_ALLOW_DERIVED 4
95 #define UNIFY_ALLOW_INTEGER 8
96 #define UNIFY_ALLOW_OUTER_LEVEL 16
97 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
98 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
120 tree);
180 /* Make the current scope suitable for access checking when we are
181 processing T. T can be FUNCTION_DECL for instantiated function
182 template, or VAR_DECL for static member variable (need by
183 instantiate_decl). */
185 static void
187 {
195 else
199 {
200 saved_access_scope = tree_cons
203 }
204 }
206 /* Restore the scope set up by push_access_scope. T is the node we
207 are processing. */
209 static void
211 {
213 {
216 }
220 else
222 }
224 /* Do any processing required when DECL (a member template
225 declaration) is finished. Returns the TEMPLATE_DECL corresponding
226 to DECL, unless it is a specialization, in which case the DECL
227 itself is returned. */
229 tree
231 {
238 {
239 tree type;
247 {
251 }
253 }
257 {
259 {
262 }
263 else
265 }
266 else
270 }
272 /* Return the template info node corresponding to T, whatever T is. */
274 tree
276 {
289 }
291 /* Returns the template nesting level of the indicated class TYPE.
293 For example, in:
294 template <class T>
295 struct A
296 {
297 template <class U>
298 struct B {};
299 };
301 A<T>::B<U> has depth two, while A<T> has depth one.
302 Both A<T>::B<int> and A<int>::B<U> have depth one, if
303 they are instantiations, not specializations.
305 This function is guaranteed to return 0 if passed NULL_TREE so
306 that, for example, `template_class_depth (current_class_type)' is
307 always safe. */
309 int
311 {
318 {
324 }
327 }
329 /* Subroutine of maybe_begin_member_template_processing.
330 Returns true if processing DECL needs us to push template parms. */
332 static bool
334 {
340 }
342 /* Subroutine of maybe_begin_member_template_processing.
343 Push the template parms in PARMS, starting from LEVELS steps into the
344 chain, and ending at the beginning, since template parms are listed
345 innermost first. */
347 static void
349 {
357 current_template_parms
363 NULL);
365 {
374 {
381 {
382 /* Make a CONST_DECL as is done in process_template_parm.
383 It is ugly that we recreate this here; the original
384 version built in process_template_parm is no longer
385 available. */
394 }
399 }
400 }
401 }
403 /* Restore the template parameter context for a member template or
404 a friend template defined in a class definition. */
406 void
408 {
409 tree parms;
413 {
418 {
421 }
424 }
426 /* Remember how many levels of template parameters we pushed so that
427 we can pop them later. */
429 }
431 /* Undo the effects of maybe_begin_member_template_processing. */
433 void
435 {
444 {
448 }
449 }
451 /* Return a new template argument vector which contains all of ARGS,
452 but has as its innermost set of arguments the EXTRA_ARGS. */
454 static tree
456 {
457 tree new_args;
472 }
474 /* Like add_to_template_args, but only the outermost ARGS are added to
475 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
476 (EXTRA_ARGS) levels are added. This function is used to combine
477 the template arguments from a partial instantiation with the
478 template arguments used to attain the full instantiation from the
479 partial instantiation. */
481 static tree
483 {
484 tree new_args;
486 /* If there are more levels of EXTRA_ARGS than there are ARGS,
487 something very fishy is going on. */
490 /* If *all* the new arguments will be the EXTRA_ARGS, just return
491 them. */
495 /* For the moment, we make ARGS look like it contains fewer levels. */
500 /* Now, we restore ARGS to its full dimensions. */
504 }
506 /* Return the N levels of innermost template arguments from the ARGS. */
508 tree
510 {
511 tree new_args;
517 /* If N is 1, just return the innermost set of template arguments. */
521 /* If we're not removing anything, just return the arguments we were
522 given. */
528 /* Make a new set of arguments, not containing the outer arguments. */
535 }
537 /* The inverse of get_innermost_template_args: Return all but the innermost
538 EXTRA_LEVELS levels of template arguments from the ARGS. */
540 static tree
542 {
543 tree new_args;
549 /* If N is 1, just return the outermost set of template arguments. */
553 /* If we're not removing anything, just return the arguments we were
554 given. */
559 /* Make a new set of arguments, not containing the inner arguments. */
566 }
568 /* We've got a template header coming up; push to a new level for storing
569 the parms. */
571 void
573 {
574 /* We use a non-tag-transparent scope here, which causes pushtag to
575 put tags in this scope, rather than in the enclosing class or
576 namespace scope. This is the right thing, since we want
577 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
578 global template class, push_template_decl handles putting the
579 TEMPLATE_DECL into top-level scope. For a nested template class,
580 e.g.:
582 template <class T> struct S1 {
583 template <class T> struct S2 {};
584 };
586 pushtag contains special code to call pushdecl_with_scope on the
587 TEMPLATE_DECL for S2. */
592 }
594 /* This routine is called when a specialization is declared. If it is
595 invalid to declare a specialization here, an error is reported and
596 false is returned, otherwise this routine will return true. */
598 static bool
600 {
603 /* [temp.expl.spec]
605 An explicit specialization shall be declared in the namespace of
606 which the template is a member, or, for member templates, in the
607 namespace of which the enclosing class or enclosing class
608 template is a member. An explicit specialization of a member
609 function, member class or static data member of a class template
610 shall be declared in the namespace of which the class template
611 is a member. */
613 {
616 }
618 /* [temp.expl.spec]
620 In an explicit specialization declaration for a member of a class
621 template or a member template that appears in namespace scope,
622 the member template and some of its enclosing class templates may
623 remain unspecialized, except that the declaration shall not
624 explicitly specialize a class member template if its enclosing
625 class templates are not explicitly specialized as well. */
627 {
630 }
633 }
635 /* We've just seen template <>. */
637 bool
639 {
643 }
645 /* Called at then end of processing a declaration preceded by
646 template<>. */
648 void
650 {
653 }
655 /* Any template <>'s that we have seen thus far are not referring to a
656 function specialization. */
658 void
660 {
663 }
665 /* We've just seen a template header. If SPECIALIZATION is nonzero,
666 it was of the form template <>. */
668 static void
670 {
672 template_header_count++;
673 }
675 /* We're beginning an explicit instantiation. */
677 void
679 {
682 }
685 void
687 {
690 }
692 /* An explicit specialization or partial specialization TMPL is being
693 declared. Check that the namespace in which the specialization is
694 occurring is permissible. Returns false iff it is invalid to
695 specialize TMPL in the current namespace. */
697 static bool
699 {
702 /* [tmpl.expl.spec]
704 An explicit specialization shall be declared in the namespace of
705 which the template is a member, or, for member templates, in the
706 namespace of which the enclosing class or enclosing class
707 template is a member. An explicit specialization of a member
708 function, member class or static data member of a class template
709 shall be declared in the namespace of which the class template is
710 a member. */
712 /* Same or super-using namespace. */
714 else
715 {
719 }
720 }
722 /* SPEC is an explicit instantiation. Check that it is valid to
723 perform this explicit instantiation in the current namespace. */
725 static void
727 {
728 tree ns;
730 /* DR 275: An explicit instantiation shall appear in an enclosing
731 namespace of its template. */
737 }
739 /* The TYPE is being declared. If it is a template type, that means it
740 is a partial specialization. Do appropriate error-checking. */
742 tree
744 {
745 tree context;
751 {
755 }
760 {
761 /* This is for ordinary explicit specialization and partial
762 specialization of a template class such as:
764 template <> class C<int>;
766 or:
768 template <class T> class C<T*>;
770 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
774 {
778 {
782 }
783 }
786 }
792 {
793 /* This is for an explicit specialization of member class
794 template according to [temp.expl.spec/18]:
796 template <> template <class U> class C<int>::D;
798 The context `C<int>' must be an implicit instantiation.
799 Otherwise this is just a member class template declared
800 earlier like:
802 template <> class C<int> { template <class U> class D; };
803 template <> template <class U> class C<int>::D;
805 In the first case, `C<int>::D' is a specialization of `C<T>::D'
806 while in the second case, `C<int>::D' is a primary template
807 and `C<T>::D' may not exist. */
811 {
812 tree t;
816 {
820 }
822 /* Check for invalid specialization after instantiation:
824 template <> template <> class C<int>::D<int>;
825 template <> template <class U> class C<int>::D; */
835 /* Mark TYPE as a specialization. And as a result, we only
836 have one level of template argument for the innermost
837 class template. */
841 }
842 }
844 {
847 }
850 }
852 /* Returns nonzero if we can optimize the retrieval of specializations
853 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
854 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
858 {
861 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
862 parameter. */
864 /* The optimized lookup depends on the fact that the
865 template arguments for the member function template apply
866 purely to the containing class, which is not true if the
867 containing class is an explicit or partial
868 specialization. */
872 /* It is possible to have a template that is not a member
873 template and is not a member of a template class:
875 template <typename T>
876 struct S { friend A::f(); };
878 Here, the friend function is a template, but the context does
879 not have template information. The optimized lookup relies
880 on having ARGS be the template arguments for both the class
881 and the function template. */
883 }
885 /* Retrieve the specialization (in the sense of [temp.spec] - a
886 specialization is either an instantiation or an explicit
887 specialization) of TMPL for the given template ARGS. If there is
888 no such specialization, return NULL_TREE. The ARGS are a vector of
889 arguments, or a vector of vectors of arguments, in the case of
890 templates with more than one level of parameters.
892 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
893 then we search for a partial specialization matching ARGS. This
894 parameter is ignored if TMPL is not a class template. */
896 static tree
899 {
905 /* There should be as many levels of arguments as there are
906 levels of parameters. */
911 {
912 tree class_template;
913 tree class_specialization;
915 tree fns;
918 /* The template arguments actually apply to the containing
919 class. Find the class specialization with those
920 arguments. */
922 class_specialization
927 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
928 for the specialization. */
932 /* Iterate through the methods with the indicated name, looking
933 for the one that has an instance of TMPL. */
936 {
940 }
942 }
943 else
944 {
948 /* Class templates store their instantiations on the
949 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
950 DECL_TEMPLATE_SPECIALIZATIONS list. */
956 else
959 /* Iterate through the list until we find a matching template. */
961 {
965 {
966 /* Use the move-to-front heuristic to speed up future
967 searches. */
969 {
973 }
975 }
977 }
978 }
981 }
983 /* Like retrieve_specialization, but for local declarations. */
985 static tree
987 {
988 tree spec;
996 }
998 /* Returns nonzero iff DECL is a specialization of TMPL. */
1000 int
1002 {
1003 tree t;
1006 {
1012 }
1013 else
1014 {
1023 }
1026 }
1028 /* Returns nonzero iff DECL is a specialization of friend declaration
1029 FRIEND_DECL according to [temp.friend]. */
1031 bool
1033 {
1040 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1041 of a template class, we want to check if DECL is a specialization
1042 if this. */
1046 {
1047 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1050 }
1055 /* There is nothing to do if this is not a template friend. */
1062 /* [temp.friend/6]
1063 A member of a class template may be declared to be a friend of a
1064 non-template class. In this case, the corresponding member of
1065 every specialization of the class template is a friend of the
1066 class granting friendship.
1068 For example, given a template friend declaration
1070 template <class T> friend void A<T>::f();
1072 the member function below is considered a friend
1074 template <> struct A<int> {
1075 void f();
1076 };
1078 For this type of template friend, TEMPLATE_DEPTH below will be
1079 nonzero. To determine if DECL is a friend of FRIEND, we first
1080 check if the enclosing class is a specialization of another. */
1087 {
1088 /* Next, we check the members themselves. In order to handle
1089 a few tricky cases, such as when FRIEND_DECL's are
1091 template <class T> friend void A<T>::g(T t);
1092 template <class T> template <T t> friend void A<T>::h();
1094 and DECL's are
1096 void A<int>::g(int);
1097 template <int> void A<int>::h();
1099 we need to figure out ARGS, the template arguments from
1100 the context of DECL. This is required for template substitution
1101 of `T' in the function parameter of `g' and template parameter
1102 of `h' in the above examples. Here ARGS corresponds to `int'. */
1109 {
1111 {
1114 else
1116 current_depth++;
1117 }
1119 }
1122 {
1124 tree friend_type;
1125 tree decl_type;
1126 tree friend_args_type;
1127 tree decl_args_type;
1129 /* Make sure that both DECL and FRIEND_DECL are templates or
1130 non-templates. */
1136 {
1137 /* If both are templates, check template parameter list. */
1138 tree friend_parms
1143 friend_parms))
1147 }
1148 else
1156 /* Check if return types match. */
1160 /* Check if function parameter types match, ignoring the
1161 `this' parameter. */
1170 }
1171 else
1172 {
1173 /* DECL is a TYPE_DECL */
1177 /* Make sure that both DECL and FRIEND_DECL are templates or
1178 non-templates. */
1179 is_template
1186 {
1187 tree friend_parms;
1188 /* If both are templates, check the name of the two
1189 TEMPLATE_DECL's first because is_friend didn't. */
1194 /* Now check template parameter list. */
1195 friend_parms
1198 return comp_template_parms
1200 friend_parms);
1201 }
1202 else
1205 }
1206 }
1208 }
1210 /* Register the specialization SPEC as a specialization of TMPL with
1211 the indicated ARGS. IS_FRIEND indicates whether the specialization
1212 is actually just a friend declaration. Returns SPEC, or an
1213 equivalent prior declaration, if available. */
1215 static tree
1217 {
1218 tree fn;
1224 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1225 register it; we want the corresponding TEMPLATE_DECL instead.
1226 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1227 the more obvious `uses_template_parms (spec)' to avoid problems
1228 with default function arguments. In particular, given
1229 something like this:
1231 template <class T> void f(T t1, T t = T())
1233 the default argument expression is not substituted for in an
1234 instantiation unless and until it is actually needed. */
1239 /* We can sometimes try to re-register a specialization that we've
1240 already got. In particular, regenerate_decl_from_template calls
1241 duplicate_decls which will update the specialization list. But,
1242 we'll still get called again here anyhow. It's more convenient
1243 to simply allow this than to try to prevent it. */
1247 {
1249 {
1252 {
1254 fn);
1256 }
1257 else
1258 {
1259 tree clone;
1260 /* This situation should occur only if the first
1261 specialization is an implicit instantiation, the
1262 second is an explicit specialization, and the
1263 implicit instantiation has not yet been used. That
1264 situation can occur if we have implicitly
1265 instantiated a member function and then specialized
1266 it later.
1268 We can also wind up here if a friend declaration that
1269 looked like an instantiation turns out to be a
1270 specialization:
1272 template <class T> void foo(T);
1273 class S { friend void foo<>(int) };
1274 template <> void foo(int);
1276 We transform the existing DECL in place so that any
1277 pointers to it become pointers to the updated
1278 declaration.
1280 If there was a definition for the template, but not
1281 for the specialization, we want this to look as if
1282 there were no definition, and vice versa. */
1285 /* The call to duplicate_decls will have applied
1286 [temp.expl.spec]:
1288 An explicit specialization of a function template
1289 is inline only if it is explicitly declared to be,
1290 and independently of whether its function template
1291 is.
1293 to the primary function; now copy the inline bits to
1294 the various clones. */
1301 }
1302 }
1304 {
1306 /* Dup decl failed, but this is a new definition. Set the
1307 line number so any errors match this new
1308 definition. */
1312 }
1313 }
1315 /* A specialization must be declared in the same namespace as the
1316 template it is specializing. */
1326 }
1328 /* Unregister the specialization SPEC as a specialization of TMPL.
1329 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1330 if the SPEC was listed as a specialization of TMPL. */
1332 bool
1334 {
1341 {
1344 else
1347 }
1350 }
1352 /* Compare an entry in the local specializations hash table P1 (which
1353 is really a pointer to a TREE_LIST) with P2 (which is really a
1354 DECL). */
1356 static int
1358 {
1360 }
1362 /* Hash P1, an entry in the local specializations table. */
1364 static hashval_t
1366 {
1368 }
1370 /* Like register_specialization, but for local declarations. We are
1371 registering SPEC, an instantiation of TMPL. */
1373 static void
1375 {
1381 }
1383 /* TYPE is a class type. Returns true if TYPE is an explicitly
1384 specialized class. */
1386 bool
1388 {
1392 }
1394 /* Print the list of candidate FNS in an error message. */
1396 void
1398 {
1399 tree fn;
1404 {
1405 tree f;
1410 }
1411 }
1413 /* Returns the template (one of the functions given by TEMPLATE_ID)
1414 which can be specialized to match the indicated DECL with the
1415 explicit template args given in TEMPLATE_ID. The DECL may be
1416 NULL_TREE if none is available. In that case, the functions in
1417 TEMPLATE_ID are non-members.
1419 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1420 specialization of a member template.
1422 The TEMPLATE_COUNT is the number of references to qualifying
1423 template classes that appeared in the name of the function. See
1424 check_explicit_specialization for a more accurate description.
1426 TSK indicates what kind of template declaration (if any) is being
1427 declared. TSK_TEMPLATE indicates that the declaration given by
1428 DECL, though a FUNCTION_DECL, has template parameters, and is
1429 therefore a template function.
1431 The template args (those explicitly specified and those deduced)
1432 are output in a newly created vector *TARGS_OUT.
1434 If it is impossible to determine the result, an error message is
1435 issued. The error_mark_node is returned to indicate failure. */
1437 static tree
1439 tree decl,
1443 tmpl_spec_kind tsk)
1444 {
1445 tree fns;
1446 tree targs;
1447 tree explicit_targs;
1449 /* A TREE_LIST of templates of which DECL may be a specialization.
1450 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1451 corresponding TREE_PURPOSE is the set of template arguments that,
1452 when used to instantiate the template, would produce a function
1453 with the signature of DECL. */
1469 /* Check for baselinks. */
1474 {
1477 }
1479 /* Count the number of template headers specified for this
1480 specialization. */
1488 {
1492 {
1493 tree decl_arg_types;
1494 tree fn_arg_types;
1496 /* In case of explicit specialization, we need to check if
1497 the number of template headers appearing in the specialization
1498 is correct. This is usually done in check_explicit_specialization,
1499 but the check done there cannot be exhaustive when specializing
1500 member functions. Consider the following code:
1502 template <> void A<int>::f(int);
1503 template <> template <> void A<int>::f(int);
1505 Assuming that A<int> is not itself an explicit specialization
1506 already, the first line specializes "f" which is a non-template
1507 member function, whilst the second line specializes "f" which
1508 is a template member function. So both lines are syntactically
1509 correct, and check_explicit_specialization does not reject
1510 them.
1512 Here, we can do better, as we are matching the specialization
1513 against the declarations. We count the number of template
1514 headers, and we check if they match TEMPLATE_COUNT + 1
1515 (TEMPLATE_COUNT is the number of qualifying template classes,
1516 plus there must be another header for the member template
1517 itself).
1519 Notice that if header_count is zero, this is not a
1520 specialization but rather a template instantiation, so there
1521 is no check we can perform here. */
1525 /* Check that the number of template arguments at the
1526 innermost level for DECL is the same as for FN. */
1534 /* DECL might be a specialization of FN. */
1538 /* For a non-static member function, we need to make sure
1539 that the const qualification is the same. Since
1540 get_bindings does not try to merge the "this" parameter,
1541 we must do the comparison explicitly. */
1547 /* Skip the "this" parameter and, for constructors of
1548 classes with virtual bases, the VTT parameter. A
1549 full specialization of a constructor will have a VTT
1550 parameter, but a template never will. */
1551 decl_arg_types
1553 fn_arg_types
1556 /* Check that the number of function parameters matches.
1557 For example,
1558 template <class T> void f(int i = 0);
1559 template <> void f<int>();
1560 The specialization f<int> is invalid but is not caught
1561 by get_bindings below. */
1565 /* Function templates cannot be specializations; there are
1566 no partial specializations of functions. Therefore, if
1567 the type of DECL does not match FN, there is no
1568 match. */
1570 {
1574 }
1576 /* See whether this function might be a specialization of this
1577 template. */
1581 /* We cannot deduce template arguments that when used to
1582 specialize TMPL will produce DECL. */
1585 /* Save this template, and the arguments deduced. */
1587 }
1589 /* FN is an ordinary member function, and we need a
1590 specialization of a member template. */
1591 ;
1593 /* We can get IDENTIFIER_NODEs here in certain erroneous
1594 cases. */
1595 ;
1597 /* This is just an ordinary non-member function. Nothing can
1598 be a specialization of that. */
1599 ;
1601 /* Cannot specialize functions that are created implicitly. */
1602 ;
1603 else
1604 {
1605 tree decl_arg_types;
1607 /* This is an ordinary member function. However, since
1608 we're here, we can assume it's enclosing class is a
1609 template class. For example,
1611 template <typename T> struct S { void f(); };
1612 template <> void S<int>::f() {}
1614 Here, S<int>::f is a non-template, but S<int> is a
1615 template class. If FN has the same type as DECL, we
1616 might be in business. */
1619 /* Its enclosing class is an explicit specialization
1620 of a template class. This is not a candidate. */
1625 /* The return types differ. */
1628 /* Adjust the type of DECL in case FN is a static member. */
1635 decl_arg_types))
1636 /* They match! */
1638 }
1639 }
1642 {
1643 /* We have:
1645 [temp.expl.spec]
1647 It is possible for a specialization with a given function
1648 signature to be instantiated from more than one function
1649 template. In such cases, explicit specification of the
1650 template arguments must be used to uniquely identify the
1651 function template specialization being specialized.
1653 Note that here, there's no suggestion that we're supposed to
1654 determine which of the candidate templates is most
1655 specialized. However, we, also have:
1657 [temp.func.order]
1659 Partial ordering of overloaded function template
1660 declarations is used in the following contexts to select
1661 the function template to which a function template
1662 specialization refers:
1664 -- when an explicit specialization refers to a function
1665 template.
1667 So, we do use the partial ordering rules, at least for now.
1668 This extension can only serve to make invalid programs valid,
1669 so it's safe. And, there is strong anecdotal evidence that
1670 the committee intended the partial ordering rules to apply;
1671 the EDG front end has that behavior, and John Spicer claims
1672 that the committee simply forgot to delete the wording in
1673 [temp.expl.spec]. */
1676 {
1679 }
1680 }
1683 {
1687 }
1691 {
1697 }
1699 /* We have one, and exactly one, match. */
1701 {
1703 /* DECL is a re-declaration of a template function. */
1706 /* It was a specialization of an ordinary member function in a
1707 template class. */
1710 }
1712 /* It was a specialization of a template. */
1715 {
1720 }
1721 else
1724 }
1726 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1727 but with the default argument values filled in from those in the
1728 TMPL_TYPES. */
1730 static tree
1732 tree tmpl_types)
1733 {
1734 tree new_spec_types;
1742 /* Substitute into the rest of the list. */
1743 new_spec_types =
1747 /* Add the default argument for this parameter. */
1750 new_spec_types);
1751 }
1753 /* DECL is an explicit specialization. Replicate default arguments
1754 from the template it specializes. (That way, code like:
1756 template <class T> void f(T = 3);
1757 template <> void f(double);
1758 void g () { f (); }
1760 works, as required.) An alternative approach would be to look up
1761 the correct default arguments at the call-site, but this approach
1762 is consistent with how implicit instantiations are handled. */
1764 static void
1766 {
1767 tree tmpl;
1768 tree spec_types;
1769 tree tmpl_types;
1770 tree new_spec_types;
1771 tree old_type;
1772 tree new_type;
1773 tree t;
1778 /* See if there's anything we need to do. */
1791 {
1792 /* Remove the this pointer, but remember the object's type for
1793 CV quals. */
1799 {
1800 /* DECL may contain more parameters than TMPL due to the extra
1801 in-charge parameter in constructors and destructors. */
1804 }
1806 {
1809 }
1810 }
1812 /* Compute the merged default arguments. */
1813 new_spec_types =
1816 /* Compute the new FUNCTION_TYPE. */
1818 {
1822 new_spec_types);
1825 /* Put the in-charge parameter back. */
1828 new_spec_types);
1832 new_spec_types);
1833 }
1834 else
1836 new_spec_types);
1842 }
1844 /* Check to see if the function just declared, as indicated in
1845 DECLARATOR, and in DECL, is a specialization of a function
1846 template. We may also discover that the declaration is an explicit
1847 instantiation at this point.
1849 Returns DECL, or an equivalent declaration that should be used
1850 instead if all goes well. Issues an error message if something is
1851 amiss. Returns error_mark_node if the error is not easily
1852 recoverable.
1854 FLAGS is a bitmask consisting of the following flags:
1856 2: The function has a definition.
1857 4: The function is a friend.
1859 The TEMPLATE_COUNT is the number of references to qualifying
1860 template classes that appeared in the name of the function. For
1861 example, in
1863 template <class T> struct S { void f(); };
1864 void S<int>::f();
1866 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1867 classes are not counted in the TEMPLATE_COUNT, so that in
1869 template <class T> struct S {};
1870 template <> struct S<int> { void f(); }
1871 template <> void S<int>::f();
1873 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1874 invalid; there should be no template <>.)
1876 If the function is a specialization, it is marked as such via
1877 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1878 is set up correctly, and it is added to the list of specializations
1879 for that template. */
1881 tree
1883 tree decl,
1886 {
1894 tmpl_spec_kind tsk;
1897 {
1900 else
1902 }
1903 else
1907 {
1910 {
1913 }
1915 {
1917 /* This could be something like:
1919 template <class T> void f(T);
1920 class S { friend void f<>(int); } */
1922 else
1923 {
1924 /* This case handles bogus declarations like template <>
1925 template <class T> void f<int>(); */
1928 declarator);
1930 }
1931 }
1935 /* The error has already been reported in
1936 check_specialization_scope. */
1942 /* Fall through. */
1955 decl);
1958 else
1962 /* Fall through. */
1967 else
1973 {
1974 /* This case handles bogus declarations like template <>
1975 template <class T> void f<int>(); */
1980 else
1982 declarator);
1984 }
1987 /* This is a specialization of a member template, without
1988 specialization the containing class. Something like:
1990 template <class T> struct S {
1991 template <class U> void f (U);
1992 };
1993 template <> template <class U> void S<int>::f(U) {}
1995 That's a specialization -- but of the entire template. */
2001 }
2004 {
2008 {
2012 }
2013 }
2016 {
2020 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2022 {
2023 tree fns;
2028 else
2029 {
2030 /* If there is no class context, the explicit instantiation
2031 must be at namespace scope. */
2034 /* Find the namespace binding, using the declaration
2035 context. */
2039 {
2042 }
2043 else
2044 {
2050 }
2051 }
2054 }
2060 {
2062 /* A specialization in class scope. This is invalid,
2063 but the error will already have been flagged by
2064 check_specialization_scope. */
2066 else
2067 {
2068 /* It's not valid to write an explicit instantiation in
2069 class scope, e.g.:
2071 class C { template void f(); }
2073 This case is caught by the parser. However, on
2074 something like:
2076 template class C { void f(); };
2078 (which is invalid) we can get here. The error will be
2079 issued later. */
2080 ;
2081 }
2084 }
2087 IDENTIFIER_NODE))
2088 {
2089 /* Find the list of functions in ctype that have the same
2090 name as the declared function. */
2096 {
2101 {
2102 /* From [temp.expl.spec]:
2104 If such an explicit specialization for the member
2105 of a class template names an implicitly-declared
2106 special member function (clause _special_), the
2107 program is ill-formed.
2109 Similar language is found in [temp.explicit]. */
2112 }
2115 }
2118 {
2122 }
2123 else
2124 {
2126 tree ovl;
2128 /* For a type-conversion operator, we cannot do a
2129 name-based lookup. We might be looking for `operator
2130 int' which will be a specialization of `operator T'.
2131 So, we find *all* the conversion operators, and then
2132 select from them. */
2140 {
2142 /* There are no more conversion functions. */
2145 /* Glue all these conversion functions together
2146 with those we already have. */
2149 }
2150 }
2153 {
2156 }
2157 else
2159 }
2161 /* Figure out what exactly is being specialized at this point.
2162 Note that for an explicit instantiation, even one for a
2163 member function, we cannot tell apriori whether the
2164 instantiation is for a member template, or just a member
2165 function of a template class. Even if a member template is
2166 being instantiated, the member template arguments may be
2167 elided if they can be deduced from the rest of the
2168 declaration. */
2171 member_specialization,
2172 template_count,
2173 tsk);
2176 /* We couldn't figure out what this declaration was
2177 specializing. */
2179 else
2180 {
2184 {
2185 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2186 is done by do_decl_instantiation later. */
2192 {
2193 /* If TMPL is not the most general template (for
2194 example, if TMPL is a friend template that is
2195 injected into namespace scope), then there will
2196 be too many levels of TARGS. Remove some of them
2197 here. */
2199 tree new_targs;
2206 }
2209 }
2211 /* If we thought that the DECL was a member function, but it
2212 turns out to be specializing a static member function,
2213 make DECL a static member function as well. */
2218 /* If this is a specialization of a member template of a
2219 template class, we want to return the TEMPLATE_DECL, not
2220 the specialization of it. */
2222 {
2227 {
2228 tree parm;
2232 /* We want to use the argument list specified in the
2233 definition, not in the original declaration. */
2238 }
2240 }
2242 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2245 /* Inherit default function arguments from the template
2246 DECL is specializing. */
2249 /* This specialization has the same protection as the
2250 template it specializes. */
2254 /* 7.1.1-1 [dcl.stc]
2256 A storage-class-specifier shall not be specified in an
2257 explicit specialization...
2259 The parser rejects these, so unless action is taken here,
2260 explicit function specializations will always appear with
2261 global linkage.
2263 The action recommended by the C++ CWG in response to C++
2264 defect report 605 is to make the storage class and linkage
2265 of the explicit specialization match the templated function:
2267 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2268 */
2270 {
2274 /* This specialization has the same linkage and visibility as
2275 the function template it specializes. */
2278 {
2281 }
2284 {
2287 }
2288 }
2290 /* If DECL is a friend declaration, declared using an
2291 unqualified name, the namespace associated with DECL may
2292 have been set incorrectly. For example, in:
2294 template <typename T> void f(T);
2295 namespace N {
2296 struct S { friend void f<int>(int); }
2297 }
2299 we will have set the DECL_CONTEXT for the friend
2300 declaration to N, rather than to the global namespace. */
2305 /* This is not really a declaration of a specialization.
2306 It's just the name of an instantiation. But, it's not
2307 a request for an instantiation, either. */
2310 /* This is indeed a specialization. In case of constructors
2311 and destructors, we need in-charge and not-in-charge
2312 versions in V3 ABI. */
2315 /* Register this specialization so that we can find it
2316 again. */
2318 }
2319 }
2322 }
2324 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2325 parameters. These are represented in the same format used for
2326 DECL_TEMPLATE_PARMS. */
2328 int
2330 {
2331 const_tree p1;
2332 const_tree p2;
2340 {
2352 {
2356 /* If either of the template parameters are invalid, assume
2357 they match for the sake of error recovery. */
2370 }
2371 }
2374 /* One set of parameters has more parameters lists than the
2375 other. */
2379 }
2381 /* Determine whether PARM is a parameter pack. */
2382 bool
2384 {
2385 /* Determine if we have a non-type template parameter pack. */
2390 /* If this is a list of template parameters, we could get a
2391 TYPE_DECL or a TEMPLATE_DECL. */
2398 }
2400 /* Determine whether ARGS describes a variadic template args list,
2401 i.e., one that is terminated by a template argument pack. */
2402 static bool
2404 {
2406 tree last_parm;
2420 }
2422 /* Generate a new name for the parameter pack name NAME (an
2423 IDENTIFIER_NODE) that incorporates its */
2424 static tree
2426 {
2427 /* Munge the name to include the parameter index. */
2435 }
2437 /* Structure used to track the progress of find_parameter_packs_r. */
2438 struct find_parameter_pack_data
2439 {
2440 /* TREE_LIST that will contain all of the parameter packs found by
2441 the traversal. */
2444 /* Set of AST nodes that have been visited by the traversal. */
2446 };
2448 /* Identifies all of the argument packs that occur in a template
2449 argument and appends them to the TREE_LIST inside DATA, which is a
2450 find_parameter_pack_data structure. This is a subroutine of
2451 make_pack_expansion and uses_parameter_packs. */
2452 static tree
2454 {
2460 /* Identify whether this is a parameter pack or not. */
2462 {
2476 {
2477 /* We don't want to walk into the type of a PARM_DECL,
2478 because we don't want to see the type parameter pack. */
2481 }
2485 /* Not a parameter pack. */
2487 }
2490 {
2491 /* Add this parameter pack to the list. */
2493 }
2499 /* This switch statement will return immediately if we don't find a
2500 parameter pack. */
2502 {
2507 /* Check the template itself. */
2510 /* Check the template arguments. */
2526 /* Fall through. */
2567 }
2570 }
2572 /* Determines if the expression or type T uses any parameter packs. */
2573 bool
2575 {
2583 }
2585 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2586 representation a base-class initializer into a parameter pack
2587 expansion. If all goes well, the resulting node will be an
2588 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2589 respectively. */
2590 tree
2592 {
2593 tree result;
2602 {
2603 /* The only time we will see a TREE_LIST here is for a base
2604 class initializer. In this case, the TREE_PURPOSE will be a
2605 _TYPE node (representing the base class expansion we're
2606 initializing) and the TREE_VALUE will be a TREE_LIST
2607 containing the initialization arguments.
2609 The resulting expansion looks somewhat different from most
2610 expansions. Rather than returning just one _EXPANSION, we
2611 return a TREE_LIST whose TREE_PURPOSE is a
2612 TYPE_PACK_EXPANSION containing the bases that will be
2613 initialized. The TREE_VALUE will be identical to the
2614 original TREE_VALUE, which is a list of arguments that will
2615 be passed to each base. We do not introduce any new pack
2616 expansion nodes into the TREE_VALUE (although it is possible
2617 that some already exist), because the TREE_PURPOSE and
2618 TREE_VALUE all need to be expanded together with the same
2619 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2620 resulting TREE_PURPOSE will mention the parameter packs in
2621 both the bases and the arguments to the bases. */
2622 tree purpose;
2623 tree value;
2626 /* Determine which parameter packs will be used by the base
2627 class expansion. */
2634 {
2638 }
2641 {
2642 /* Collect the sets of parameter packs used in each of the
2643 initialization arguments. */
2645 {
2646 /* Determine which parameter packs will be expanded in this
2647 argument. */
2650 }
2651 }
2655 /* Create the pack expansion type for the base type. */
2660 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2661 they will rarely be compared to anything. */
2665 }
2670 /* Build the PACK_EXPANSION_* node. */
2674 {
2675 /* Propagate type and const-expression information. */
2678 }
2679 else
2680 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2681 they will rarely be compared to anything. */
2684 /* Determine which parameter packs will be expanded. */
2690 /* Make sure we found some parameter packs. */
2692 {
2695 else
2698 }
2702 }
2704 /* Checks T for any "bare" parameter packs, which have not yet been
2705 expanded, and issues an error if any are found. This operation can
2706 only be done on full expressions or types (e.g., an expression
2707 statement, "if" condition, etc.), because we could have expressions like:
2709 foo(f(g(h(args)))...)
2711 where "args" is a parameter pack. check_for_bare_parameter_packs
2712 should not be called for the subexpressions args, h(args),
2713 g(h(args)), or f(g(h(args))), because we would produce erroneous
2714 error messages.
2716 Returns TRUE and emits an error if there were bare parameter packs,
2717 returns FALSE otherwise. */
2718 bool
2720 {
2736 {
2739 {
2748 else
2753 else
2757 }
2760 }
2763 }
2765 /* Expand any parameter packs that occur in the template arguments in
2766 ARGS. */
2767 tree
2769 {
2774 /* First, determine if we need to expand anything, and the number of
2775 slots we'll need. */
2777 {
2780 {
2784 else
2786 }
2787 else
2788 {
2790 num_result_args++;
2791 }
2792 }
2794 /* If no expansion is necessary, we're done. */
2798 /* Expand arguments. */
2801 {
2804 {
2809 }
2810 else
2811 {
2814 }
2815 }
2818 }
2820 /* Checks if DECL shadows a template parameter.
2822 [temp.local]: A template-parameter shall not be redeclared within its
2823 scope (including nested scopes).
2825 Emits an error and returns TRUE if the DECL shadows a parameter,
2826 returns FALSE otherwise. */
2828 bool
2830 {
2831 tree olddecl;
2833 /* If we're not in a template, we can't possibly shadow a template
2834 parameter. */
2838 /* Figure out what we're shadowing. */
2843 /* If there's no previous binding for this name, we're not shadowing
2844 anything, let alone a template parameter. */
2848 /* If we're not shadowing a template parameter, we're done. Note
2849 that OLDDECL might be an OVERLOAD (or perhaps even an
2850 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2851 node. */
2855 /* We check for decl != olddecl to avoid bogus errors for using a
2856 name inside a class. We check TPFI to avoid duplicate errors for
2857 inline member templates. */
2865 }
2867 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2868 ORIG_LEVEL, DECL, and TYPE. */
2870 static tree
2874 tree decl,
2875 tree type)
2876 {
2887 }
2889 /* Find the canonical type parameter for the given template type
2890 parameter. Returns the canonical type parameter, which may be TYPE
2891 if no such parameter existed. */
2892 static tree
2894 {
2895 tree list;
2909 else
2910 {
2915 }
2916 }
2918 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2919 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2920 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2921 new one is created. */
2923 static tree
2925 tsubst_flags_t complain)
2926 {
2930 {
2948 /* Template template parameters need this. */
2953 }
2956 }
2958 /* Process information from new template parameter PARM and append it to the
2959 LIST being built. This new parameter is a non-type parameter iff
2960 IS_NON_TYPE is true. This new parameter is a parameter
2961 pack iff IS_PARAMETER_PACK is true. */
2963 tree
2966 {
2968 tree defval;
2969 tree err_parm_list;
2976 {
2980 {
2984 else
2986 }
2989 }
2990 else
2994 {
3000 {
3004 }
3005 else
3006 {
3007 /* [temp.param]
3009 The top-level cv-qualifiers on the template-parameter are
3010 ignored when determining its type. */
3013 {
3017 }
3020 {
3021 /* This template parameter is not a parameter pack, but it
3022 should be. Complain about "bare" parameter packs. */
3025 /* Recover by calling this a parameter pack. */
3027 }
3028 }
3030 /* A template parameter is not modifiable. */
3038 processing_template_decl,
3043 }
3044 else
3045 {
3046 tree t;
3050 {
3052 /* This is for distinguishing between real templates and template
3053 template parameters */
3057 }
3058 else
3059 {
3061 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3063 }
3070 processing_template_decl,
3074 }
3080 }
3082 /* The end of a template parameter list has been reached. Process the
3083 tree list into a parameter vector, converting each parameter into a more
3084 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3085 as PARM_DECLs. */
3087 tree
3089 {
3094 current_template_parms
3099 {
3103 }
3108 }
3110 /* end_template_decl is called after a template declaration is seen. */
3112 void
3114 {
3120 /* This matches the pushlevel in begin_template_parm_list. */
3125 }
3127 /* Within the declaration of a template, return all levels of template
3128 parameters that apply. The template parameters are represented as
3129 a TREE_VEC, in the form documented in cp-tree.h for template
3130 arguments. */
3132 static tree
3134 {
3135 tree header;
3140 /* If there is only one level of template parameters, we do not
3141 create a TREE_VEC of TREE_VECs. Instead, we return a single
3142 TREE_VEC containing the arguments. */
3147 {
3153 {
3156 /* T will be a list if we are called from within a
3157 begin/end_template_parm_list pair, but a vector directly
3158 if within a begin/end_member_template_processing pair. */
3160 {
3164 {
3167 {
3171 {
3172 /* Turn this argument into a TYPE_ARGUMENT_PACK
3173 with a single element, which expands T. */
3179 }
3180 }
3181 else
3182 {
3186 {
3187 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3188 with a single element, which expands T. */
3196 }
3197 }
3199 }
3200 }
3201 }
3205 else
3207 }
3210 }
3212 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3213 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3214 a member template. Used by push_template_decl below. */
3216 static tree
3218 {
3224 {
3233 }
3236 }
3238 struct template_parm_data
3239 {
3240 /* The level of the template parameters we are currently
3241 processing. */
3244 /* The index of the specialization argument we are currently
3245 processing. */
3248 /* An array whose size is the number of template parameters. The
3249 elements are nonzero if the parameter has been used in any one
3250 of the arguments processed so far. */
3253 /* An array whose size is the number of template arguments. The
3254 elements are nonzero if the argument makes use of template
3255 parameters of this level. */
3257 };
3259 /* Subroutine of push_template_decl used to see if each template
3260 parameter in a partial specialization is used in the explicit
3261 argument list. If T is of the LEVEL given in DATA (which is
3262 treated as a template_parm_data*), then DATA->PARMS is marked
3263 appropriately. */
3265 static int
3267 {
3273 {
3276 }
3277 else
3278 {
3281 }
3284 {
3287 }
3289 /* Return zero so that for_each_template_parm will continue the
3290 traversal of the tree; we want to mark *every* template parm. */
3292 }
3294 /* Process the partial specialization DECL. */
3296 static tree
3298 {
3304 tree inner_parms;
3317 /* We check that each of the template parameters given in the
3318 partial specialization is used in the argument list to the
3319 specialization. For example:
3321 template <class T> struct S;
3322 template <class T> struct S<T*>;
3324 The second declaration is OK because `T*' uses the template
3325 parameter T, whereas
3327 template <class T> struct S<int>;
3329 is no good. Even trickier is:
3331 template <class T>
3332 struct S1
3333 {
3334 template <class U>
3335 struct S2;
3336 template <class U>
3337 struct S2<T>;
3338 };
3340 The S2<T> declaration is actually invalid; it is a
3341 full-specialization. Of course,
3343 template <class U>
3344 struct S2<T (*)(U)>;
3346 or some such would have been OK. */
3354 {
3359 NULL,
3361 }
3364 {
3365 /* One of the template parms was not used in the
3366 specialization. */
3368 {
3371 }
3374 }
3376 /* [temp.class.spec]
3378 The argument list of the specialization shall not be identical to
3379 the implicit argument list of the primary template. */
3386 /* [temp.class.spec]
3388 A partially specialized non-type argument expression shall not
3389 involve template parameters of the partial specialization except
3390 when the argument expression is a simple identifier.
3392 The type of a template parameter corresponding to a specialized
3393 non-type argument shall not be dependent on a parameter of the
3394 specialization.
3396 Also, we verify that pack expansions only occur at the
3397 end of the argument list. */
3401 {
3408 {
3409 /* Extract the arguments from the argument pack. We'll be
3410 iterating over these in the following loop. */
3413 }
3416 {
3418 /* Get the Jth argument in the parameter pack. */
3422 {
3423 /* Pack expansions must come at the end of the
3424 argument list. */
3427 {
3430 else
3435 }
3436 }
3439 /* We only care about the pattern. */
3445 /* This next line is the `argument expression is not just a
3446 simple identifier' condition and also the `specialized
3447 non-type argument' bit. */
3449 {
3453 arg);
3454 else
3455 {
3456 /* Look at the corresponding template parameter,
3457 marking which template parameters its type depends
3458 upon. */
3462 {
3463 /* We haven't yet initialized TPD2. Do so now. */
3464 tpd2.arg_uses_template_parms
3466 /* The number of parameters here is the number in the
3467 main template, which, as checked in the assertion
3468 above, is NARGS. */
3472 }
3474 /* Mark the template parameters. But this time, we're
3475 looking for the template parameters of the main
3476 template, not in the specialization. */
3483 NULL,
3487 {
3488 /* The type depended on some template parameters.
3489 If they are fully specialized in the
3490 specialization, that's OK. */
3495 {
3498 type,
3499 arg);
3501 }
3502 }
3503 }
3504 }
3505 }
3506 }
3510 /* We've already got this specialization. */
3518 }
3520 /* Check that a template declaration's use of default arguments and
3521 parameter packs is not invalid. Here, PARMS are the template
3522 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3523 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3524 specialization.
3527 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3528 declaration (but not a definition); 1 indicates a declaration, 2
3529 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3530 emitted for extraneous default arguments.
3532 Returns TRUE if there were no errors found, FALSE otherwise. */
3534 bool
3537 {
3540 tree parm_level;
3543 /* [temp.param]
3545 A default template-argument shall not be specified in a
3546 function template declaration or a function template definition, nor
3547 in the template-parameter-list of the definition of a member of a
3548 class template. */
3551 /* You can't have a function template declaration in a local
3552 scope, nor you can you define a member of a class template in a
3553 local scope. */
3559 /* If this is either a friend defined in the scope of the class
3560 or a member function. */
3566 /* And, if it was a member function, it really was defined in
3567 the scope of the class. */
3570 /* We already checked these parameters when the template was
3571 declared, so there's no need to do it again now. This function
3572 was defined in class scope, but we're processing it's body now
3573 that the class is complete. */
3576 /* Core issue 226 (C++0x only): the following only applies to class
3577 templates. */
3579 {
3580 /* [temp.param]
3582 If a template-parameter has a default template-argument, all
3583 subsequent template-parameters shall have a default
3584 template-argument supplied. */
3586 {
3593 {
3603 {
3605 /* For better subsequent error-recovery, we indicate that
3606 there should have been a default argument. */
3609 }
3611 && !is_partial
3612 && !is_friend_decl
3613 /* Don't complain about an enclosing partial
3614 specialization. */
3619 {
3620 /* A primary class template can only have one
3621 parameter pack, at the end of the template
3622 parameter list. */
3627 else
3635 }
3636 }
3637 }
3638 }
3641 || is_partial
3642 || !is_primary
3644 /* For an ordinary class template, default template arguments are
3645 allowed at the innermost level, e.g.:
3646 template <class T = int>
3647 struct S {};
3648 but, in a partial specialization, they're not allowed even
3649 there, as we have in [temp.class.spec]:
3651 The template parameter list of a specialization shall not
3652 contain default template argument values.
3654 So, for a partial specialization, or for a function template
3655 (in C++98/C++03), we look at all of them. */
3656 ;
3657 else
3658 /* But, for a primary class template that is not a partial
3659 specialization we look at all template parameters except the
3660 innermost ones. */
3663 /* Figure out what error message to issue. */
3672 else
3676 /* If we're inside a class definition, there's no need to
3677 examine the parameters to the class itself. On the one
3678 hand, they will be checked when the class is defined, and,
3679 on the other, default arguments are valid in things like:
3680 template <class T = double>
3681 struct S { template <class U> void f(U); };
3682 Here the default argument for `S' has no bearing on the
3683 declaration of `f'. */
3685 else
3686 /* Check everything. */
3692 {
3699 {
3704 {
3706 {
3713 }
3715 /* Clear out the default argument so that we are not
3716 confused later. */
3718 }
3719 }
3721 /* At this point, if we're still interested in issuing messages,
3722 they must apply to classes surrounding the object declared. */
3725 }
3728 }
3730 /* Worker for push_template_decl_real, called via
3731 for_each_template_parm. DATA is really an int, indicating the
3732 level of the parameters we are interested in. If T is a template
3733 parameter of that level, return nonzero. */
3735 static int
3737 {
3743 else
3746 }
3748 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3749 parameters given by current_template_args, or reuses a
3750 previously existing one, if appropriate. Returns the DECL, or an
3751 equivalent one, if it is replaced via a call to duplicate_decls.
3753 If IS_FRIEND is true, DECL is a friend declaration. */
3755 tree
3757 {
3758 tree tmpl;
3759 tree args;
3760 tree info;
3761 tree ctx;
3765 /* True if the template is a member template, in the sense of
3766 [temp.mem]. */
3772 /* See if this is a partial specialization. */
3781 /* For a friend, we want the context of the friend function, not
3782 the type of which it is a friend. */
3786 /* In the case of a virtual function, we want the class in which
3787 it is defined. */
3789 else
3790 /* Otherwise, if we're currently defining some class, the DECL
3791 is assumed to be a member of the class. */
3800 /* See if this is a primary template. */
3802 /* A friend template that specifies a class context, i.e.
3803 template <typename T> friend void A<T>::f();
3804 is not primary. */
3806 else
3810 {
3815 {
3818 }
3820 {
3822 {
3823 /* [temp.mem]
3825 A destructor shall not be a member template. */
3828 }
3835 {
3836 /* [basic.stc.dynamic.allocation]
3838 An allocation function can be a function
3839 template. ... Template allocation functions shall
3840 have two or more parameters. */
3843 }
3844 }
3848 else
3849 {
3852 }
3853 }
3855 /* Check to see that the rules regarding the use of default
3856 arguments are not being violated. */
3860 /* Ensure that there are no parameter packs in the type of this
3861 declaration that have not been expanded. */
3863 {
3864 /* Check each of the arguments individually to see if there are
3865 any bare parameter packs. */
3871 {
3874 {
3875 /* This is a PARM_DECL that contains unexpanded parameter
3876 packs. We have already complained about this in the
3877 check_for_bare_parameter_packs call, so just replace
3878 these types with ERROR_MARK_NODE. */
3881 }
3885 }
3887 /* Check for bare parameter packs in the return type and the
3888 exception specifiers. */
3890 /* Errors were already issued, set return type to int
3891 as the frontend doesn't expect error_mark_node as
3892 the return type. */
3896 }
3898 {
3901 }
3912 {
3917 /* If DECL is a TYPE_DECL for a class-template, then there won't
3918 be DECL_LANG_SPECIFIC. The information equivalent to
3919 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3923 {
3924 /* Since a template declaration already existed for this
3925 class-type, we must be redeclaring it here. Make sure
3926 that the redeclaration is valid. */
3928 current_template_parms);
3929 /* We don't need to create a new TEMPLATE_DECL; just use the
3930 one we already had. */
3932 }
3933 else
3934 {
3936 member_template_p);
3941 {
3942 /* A specialization of a member template of a template
3943 class. */
3947 }
3948 }
3949 }
3950 else
3951 {
3957 {
3960 }
3968 {
3969 tree new_tmpl;
3971 /* The declaration is a specialization of a member
3972 template, declared outside the class. Therefore, the
3973 innermost template arguments will be NULL, so we
3974 replace them with the arguments determined by the
3975 earlier call to check_explicit_specialization. */
3978 new_tmpl
3980 member_template_p);
3990 args,
3991 is_friend);
3993 }
3995 /* Make sure the template headers we got make sense. */
4000 {
4003 }
4004 else
4006 {
4011 {
4015 else
4020 }
4024 else
4028 }
4030 /* Check that the parms are used in the appropriate qualifying scopes
4031 in the declarator. */
4035 {
4041 /* Avoid crash in import_export_decl. */
4044 }
4045 }
4050 /* Push template declarations for global functions and types. Note
4051 that we do not try to push a global template friend declared in a
4052 template class; such a thing may well depend on the template
4053 parameters of the class. */
4056 {
4061 /* Hide template friend classes that haven't been declared yet. */
4063 {
4066 }
4067 }
4070 {
4076 {
4079 /* It is a conversion operator. See if the type converted to
4080 depends on innermost template operands. */
4083 depth))
4085 }
4087 /* Give template template parms a DECL_CONTEXT of the template
4088 for which they are a parameter. */
4091 {
4095 }
4096 }
4098 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4099 back to its most general template. If TMPL is a specialization,
4100 ARGS may only have the innermost set of arguments. Add the missing
4101 argument levels if necessary. */
4113 }
4115 tree
4117 {
4119 }
4121 /* Called when a class template TYPE is redeclared with the indicated
4122 template PARMS, e.g.:
4124 template <class T> struct S;
4125 template <class T> struct S {}; */
4127 bool
4129 {
4130 tree tmpl;
4131 tree tmpl_parms;
4135 {
4138 }
4142 /* The type is nested in some template class. Nothing to worry
4143 about here; there are no new template parameters for the nested
4144 type. */
4148 {
4150 tmpl);
4152 }
4158 {
4164 }
4167 {
4168 tree tmpl_parm;
4169 tree parm;
4170 tree tmpl_default;
4171 tree parm_default;
4182 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4183 TEMPLATE_DECL. */
4194 {
4198 }
4201 {
4202 /* We have in [temp.param]:
4204 A template-parameter may not be given default arguments
4205 by two different declarations in the same scope. */
4209 }
4212 /* Update the previous template parameters (which are the ones
4213 that will really count) with the new default value. */
4216 /* Update the new parameters, too; they'll be used as the
4217 parameters for any members. */
4219 }
4222 }
4224 /* Simplify EXPR if it is a non-dependent expression. Returns the
4225 (possibly simplified) expression. */
4227 tree
4229 {
4233 /* If we're in a template, but EXPR isn't value dependent, simplify
4234 it. We're supposed to treat:
4236 template <typename T> void f(T[1 + 1]);
4237 template <typename T> void f(T[2]);
4239 as two declarations of the same function, for example. */
4243 {
4244 HOST_WIDE_INT saved_processing_template_decl;
4250 tf_error,
4255 }
4257 }
4259 /* EXPR is an expression which is used in a constant-expression context.
4260 For instance, it could be a VAR_DECL with a constant initializer.
4261 Extract the innermost constant expression.
4263 This is basically a more powerful version of
4264 integral_constant_value, which can be used also in templates where
4265 initializers can maintain a syntactic rather than semantic form
4266 (even if they are non-dependent, for access-checking purposes). */
4268 static tree
4270 {
4272 do
4273 {
4276 }
4280 }
4282 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4283 must be a function or a pointer-to-function type, as specified
4284 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4285 and check that the resulting function has external linkage. */
4287 static tree
4289 {
4303 /* [temp.arg.nontype]/1
4305 A template-argument for a non-type, non-template template-parameter
4306 shall be one of:
4307 [...]
4308 -- the address of an object or function with external linkage. */
4310 {
4315 }
4318 }
4320 /* Attempt to convert the non-type template parameter EXPR to the
4321 indicated TYPE. If the conversion is successful, return the
4322 converted value. If the conversion is unsuccessful, return
4323 NULL_TREE if we issued an error message, or error_mark_node if we
4324 did not. We issue error messages for out-and-out bad template
4325 parameters, but not simply because the conversion failed, since we
4326 might be just trying to do argument deduction. Both TYPE and EXPR
4327 must be non-dependent.
4329 The conversion follows the special rules described in
4330 [temp.arg.nontype], and it is much more strict than an implicit
4331 conversion.
4333 This function is called twice for each template argument (see
4334 lookup_template_class for a more accurate description of this
4335 problem). This means that we need to handle expressions which
4336 are not valid in a C++ source, but can be created from the
4337 first call (for instance, casts to perform conversions). These
4338 hacks can go away after we fix the double coercion problem. */
4340 static tree
4342 {
4343 tree expr_type;
4345 /* Detect immediately string literals as invalid non-type argument.
4346 This special-case is not needed for correctness (we would easily
4347 catch this later), but only to provide better diagnostic for this
4348 common user mistake. As suggested by DR 100, we do not mention
4349 linkage issues in the diagnostic as this is not the point. */
4351 {
4356 }
4358 /* If we are in a template, EXPR may be non-dependent, but still
4359 have a syntactic, rather than semantic, form. For example, EXPR
4360 might be a SCOPE_REF, rather than the VAR_DECL to which the
4361 SCOPE_REF refers. Preserving the qualifying scope is necessary
4362 so that access checking can be performed when the template is
4363 instantiated -- but here we need the resolved form so that we can
4364 convert the argument. */
4370 /* HACK: Due to double coercion, we can get a
4371 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4372 which is the tree that we built on the first call (see
4373 below when coercing to reference to object or to reference to
4374 function). We just strip everything and get to the arg.
4375 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4376 for examples. */
4378 {
4380 {
4381 /* ??? Maybe we could use convert_from_reference here, but we
4382 would need to relax its constraints because the NOP_EXPR
4383 could actually change the type to something more cv-qualified,
4384 and this is not folded by convert_from_reference. */
4395 }
4397 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4398 parameter is a pointer to object, through decay and
4399 qualification conversion. Let's strip everything. */
4401 {
4405 /* Skip the ADDR_EXPR only if it is part of the decay for
4406 an array. Otherwise, it is part of the original argument
4407 in the source code. */
4411 }
4412 }
4414 /* [temp.arg.nontype]/5, bullet 1
4416 For a non-type template-parameter of integral or enumeration type,
4417 integral promotions (_conv.prom_) and integral conversions
4418 (_conv.integral_) are applied. */
4420 {
4425 /* Notice that there are constant expressions like '4 % 0' which
4426 do not fold into integer constants. */
4428 {
4432 }
4434 /* At this point, an implicit conversion does what we want,
4435 because we already know that the expression is of integral
4436 type. */
4441 /* Conversion was allowed: fold it to a bare integer constant. */
4443 }
4444 /* [temp.arg.nontype]/5, bullet 2
4446 For a non-type template-parameter of type pointer to object,
4447 qualification conversions (_conv.qual_) and the array-to-pointer
4448 conversion (_conv.array_) are applied. */
4450 {
4451 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4453 A template-argument for a non-type, non-template template-parameter
4454 shall be one of: [...]
4456 -- the name of a non-type template-parameter;
4457 -- the address of an object or function with external linkage, [...]
4458 expressed as "& id-expression" where the & is optional if the name
4459 refers to a function or array, or if the corresponding
4460 template-parameter is a reference.
4462 Here, we do not care about functions, as they are invalid anyway
4463 for a parameter of type pointer-to-object. */
4466 /* Non-type template parameters are OK. */
4467 ;
4470 {
4472 {
4474 "because %qD is a variable, not the address of "
4478 }
4479 /* Other values, like integer constants, might be valid
4480 non-type arguments of some other type. */
4482 }
4483 else
4484 {
4485 tree decl;
4490 {
4495 }
4497 {
4502 }
4503 }
4512 }
4513 /* [temp.arg.nontype]/5, bullet 3
4515 For a non-type template-parameter of type reference to object, no
4516 conversions apply. The type referred to by the reference may be more
4517 cv-qualified than the (otherwise identical) type of the
4518 template-argument. The template-parameter is bound directly to the
4519 template-argument, which must be an lvalue. */
4521 {
4523 expr_type))
4527 {
4531 }
4534 {
4538 }
4540 /* [temp.arg.nontype]/1
4542 A template-argument for a non-type, non-template template-parameter
4543 shall be one of: [...]
4545 -- the address of an object or function with external linkage. */
4547 {
4552 }
4555 }
4556 /* [temp.arg.nontype]/5, bullet 4
4558 For a non-type template-parameter of type pointer to function, only
4559 the function-to-pointer conversion (_conv.func_) is applied. If the
4560 template-argument represents a set of overloaded functions (or a
4561 pointer to such), the matching function is selected from the set
4562 (_over.over_). */
4564 {
4565 /* If the argument is a template-id, we might not have enough
4566 context information to decay the pointer. */
4568 {
4572 }
4579 {
4583 }
4584 }
4585 /* [temp.arg.nontype]/5, bullet 5
4587 For a non-type template-parameter of type reference to function, no
4588 conversions apply. If the template-argument represents a set of
4589 overloaded functions, the matching function is selected from the set
4590 (_over.over_). */
4592 {
4594 {
4599 }
4606 }
4607 /* [temp.arg.nontype]/5, bullet 6
4609 For a non-type template-parameter of type pointer to member function,
4610 no conversions apply. If the template-argument represents a set of
4611 overloaded member functions, the matching member function is selected
4612 from the set (_over.over_). */
4614 {
4619 /* There is no way to disable standard conversions in
4620 resolve_address_of_overloaded_function (called by
4621 instantiate_type). It is possible that the call succeeded by
4622 converting &B::I to &D::I (where B is a base of D), so we need
4623 to reject this conversion here.
4625 Actually, even if there was a way to disable standard conversions,
4626 it would still be better to reject them here so that we can
4627 provide a superior diagnostic. */
4629 {
4630 /* Make sure we are just one standard conversion off. */
4637 }
4638 }
4639 /* [temp.arg.nontype]/5, bullet 7
4641 For a non-type template-parameter of type pointer to data member,
4642 qualification conversions (_conv.qual_) are applied. */
4644 {
4648 }
4649 /* A template non-type parameter must be one of the above. */
4650 else
4653 /* Sanity check: did we actually convert the argument to the
4654 right type? */
4657 }
4659 /* Subroutine of coerce_template_template_parms, which returns 1 if
4660 PARM_PARM and ARG_PARM match using the rule for the template
4661 parameters of template template parameters. Both PARM and ARG are
4662 template parameters; the rest of the arguments are the same as for
4663 coerce_template_template_parms.
4664 */
4665 static int
4667 tree arg,
4668 tsubst_flags_t complain,
4669 tree in_decl,
4670 tree outer_args)
4671 {
4680 {
4682 /* We encounter instantiations of templates like
4683 template <template <template <class> class> class TT>
4684 class C; */
4685 {
4692 }
4693 /* Fall through. */
4698 /* Argument is a parameter pack but parameter is not. */
4703 /* The tsubst call is used to handle cases such as
4705 template <int> class C {};
4706 template <class T, template <T> class TT> class D {};
4707 D<int, C> d;
4709 i.e. the parameter list of TT depends on earlier parameters. */
4711 && !same_type_p
4718 /* Argument is a parameter pack but parameter is not. */
4725 }
4728 }
4731 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4732 template template parameters. Both PARM_PARMS and ARG_PARMS are
4733 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4734 or PARM_DECL.
4736 Consider the example:
4737 template <class T> class A;
4738 template<template <class U> class TT> class B;
4740 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4741 the parameters to A, and OUTER_ARGS contains A. */
4743 static int
4745 tree arg_parms,
4746 tsubst_flags_t complain,
4747 tree in_decl,
4748 tree outer_args)
4749 {
4760 /* Determine whether we have a parameter pack at the end of the
4761 template template parameter's template parameter list. */
4763 {
4770 {
4784 }
4785 }
4791 /* Check all of the template parameters except the parameter pack at
4792 the end (if any). */
4794 {
4803 outer_args))
4806 }
4809 {
4810 /* Check each of the template parameters in the template
4811 argument against the template parameter pack at the end of
4812 the template template parameter. */
4819 {
4826 outer_args))
4828 }
4829 }
4832 }
4834 /* Verifies that the deduced template arguments (in TARGS) for the
4835 template template parameters (in TPARMS) represent valid bindings,
4836 by comparing the template parameter list of each template argument
4837 to the template parameter list of its corresponding template
4838 template parameter, in accordance with DR150. This
4839 routine can only be called after all template arguments have been
4840 deduced. It will return TRUE if all of the template template
4841 parameter bindings are okay, FALSE otherwise. */
4842 bool
4844 {
4848 /* We're dealing with template parms in this process. */
4854 {
4859 {
4864 {
4865 /* Look inside the argument pack. */
4868 }
4871 {
4875 /* Extract the next argument from the argument
4876 pack. */
4880 /* Look at the pattern of the pack expansion. */
4883 /* Extract the template parameters from the template
4884 argument. */
4890 /* Verify that we can coerce the template template
4891 parameters from the template argument to the template
4892 parameter. This requires an exact match. */
4894 && !coerce_template_template_parms
4896 targ_parms,
4897 tf_none,
4898 tparm,
4899 targs))
4900 {
4903 }
4904 }
4905 }
4906 }
4908 out:
4912 }
4914 /* Convert the indicated template ARG as necessary to match the
4915 indicated template PARM. Returns the converted ARG, or
4916 error_mark_node if the conversion was unsuccessful. Error and
4917 warning messages are issued under control of COMPLAIN. This
4918 conversion is for the Ith parameter in the parameter list. ARGS is
4919 the full set of template arguments deduced so far. */
4921 static tree
4923 tree arg,
4924 tree args,
4925 tsubst_flags_t complain,
4927 tree in_decl)
4928 {
4929 tree orig_arg;
4930 tree val;
4935 {
4936 /* The template argument was the name of some
4937 member function. That's usually
4938 invalid, but static members are OK. In any
4939 case, grab the underlying fields/functions
4940 and issue an error later if required. */
4943 }
4951 /* When determining whether an argument pack expansion is a template,
4952 look at the pattern. */
4956 is_tmpl_type =
4971 {
4977 typename_type,
4981 }
4983 {
4985 {
4987 {
4997 else
4999 }
5000 }
5002 }
5004 {
5006 {
5012 else
5014 }
5016 }
5019 {
5021 {
5023 /* The number of argument required is not known yet.
5024 Just accept it for now. */
5026 else
5027 {
5029 tree argparm;
5035 args))
5036 {
5039 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5040 TEMPLATE_DECL. */
5042 {
5047 {
5050 }
5051 }
5052 }
5053 else
5054 {
5056 {
5062 }
5065 }
5066 }
5067 }
5068 else
5070 /* We only form one instance of each template specialization.
5071 Therefore, if we use a non-canonical variant (i.e., a
5072 typedef), any future messages referring to the type will use
5073 the typedef, which is confusing if those future uses do not
5074 themselves also use the typedef. */
5077 }
5078 else
5079 {
5086 {
5089 else
5090 {
5091 /* Not sure if this is reachable, but it doesn't hurt
5092 to be robust. */
5095 }
5096 }
5098 /* We used to call digest_init here. However, digest_init
5099 will report errors, which we don't want when complain
5100 is zero. More importantly, digest_init will try too
5101 hard to convert things: for example, `0' should not be
5102 converted to pointer type at this point according to
5103 the standard. Accepting this is not merely an
5104 extension, since deciding whether or not these
5105 conversions can occur is part of determining which
5106 function template to call, or whether a given explicit
5107 argument specification is valid. */
5109 else
5116 }
5119 }
5121 /* Coerces the remaining template arguments in INNER_ARGS (from
5122 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5123 Returns the coerced argument pack. PARM_IDX is the position of this
5124 parameter in the template parameter list. ARGS is the original
5125 template argument list. */
5126 static tree
5129 tree args,
5130 tree inner_args,
5132 tree new_args,
5134 tree in_decl,
5135 tsubst_flags_t complain)
5136 {
5139 tree packed_args;
5140 tree argument_pack;
5150 {
5151 /* When the template parameter is a non-type template
5152 parameter pack whose type uses parameter packs, we need
5153 to look at each of the template arguments
5154 separately. Build a vector of the types for these
5155 non-type template parameters in PACKED_TYPES. */
5156 tree expansion
5164 /* Check that we have the right number of arguments. */
5168 {
5169 int needed_parms
5174 }
5176 /* If we aren't able to check the actual arguments now
5177 (because they haven't been expanded yet), we can at least
5178 verify that all of the types used for the non-type
5179 template parameter pack are, in fact, valid for non-type
5180 template parameters. */
5183 {
5186 {
5190 }
5191 }
5192 }
5194 /* Convert the remaining arguments, which will be a part of the
5195 parameter pack "parm". */
5197 {
5202 {
5203 /* When we have a vector of types (corresponding to the
5204 non-type template parameter pack that uses parameter
5205 packs in its type, as mention above), and the
5206 argument is not an expansion (which expands to a
5207 currently unknown number of arguments), clone the
5208 parm and give it the next type in PACKED_TYPES. */
5212 }
5217 in_decl);
5221 }
5226 else
5227 {
5232 }
5236 }
5238 /* Convert all template arguments to their appropriate types, and
5239 return a vector containing the innermost resulting template
5240 arguments. If any error occurs, return error_mark_node. Error and
5241 warning messages are issued under control of COMPLAIN.
5243 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5244 for arguments not specified in ARGS. Otherwise, if
5245 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5246 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5247 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5248 ARGS. */
5250 static tree
5252 tree args,
5253 tree in_decl,
5254 tsubst_flags_t complain,
5257 {
5259 tree inner_args;
5260 tree new_args;
5261 tree new_inner_args;
5264 /* When used as a boolean value, indicates whether this is a
5265 variadic template parameter list. Since it's an int, we can also
5266 subtract it from nparms to get the number of non-variadic
5267 parameters. */
5272 /* Determine if there are any parameter packs. */
5274 {
5278 }
5281 /* If there are 0 or 1 parameter packs, we need to expand any argument
5282 packs so that we can deduce a parameter pack from some non-packed args
5283 followed by an argument pack, as in variadic85.C. If there are more
5284 than that, we need to leave argument packs intact so the arguments are
5285 assigned to the right parameter packs. This should only happen when
5286 dealing with a nested class inside a partial specialization of a class
5287 template, as in variadic92.C. */
5294 && require_all_args
5295 && (!use_default_args
5298 {
5300 {
5303 {
5306 }
5313 }
5316 }
5318 /* We need to evaluate the template arguments, even though this
5319 template-id may be nested within a "sizeof". */
5325 {
5326 tree arg;
5327 tree parm;
5329 /* Get the Ith template parameter. */
5333 {
5336 }
5338 /* Calculate the next argument. */
5341 else
5346 {
5347 /* All remaining arguments will be placed in the
5348 template parameter pack PARM. */
5354 /* Store this argument. */
5356 lost++;
5359 /* We are done with all of the arguments. */
5363 }
5365 {
5367 {
5369 {
5370 /* FIXME this restriction was removed by N2555; see
5371 bug 35722. */
5372 /* If ARG is a pack expansion, but PARM is not a
5373 template parameter pack (if it were, we would have
5374 handled it above), we're trying to expand into a
5375 fixed-length argument list. */
5379 else
5382 }
5384 }
5385 }
5387 /* There must be a default arg in this case. */
5390 else
5394 {
5397 }
5399 /* This only occurs if there was an error in the template
5400 parameter list itself (which we would already have
5401 reported) that we are trying to recover from, e.g., a class
5402 template with a parameter list such as
5403 template<typename..., typename>. */
5405 else
5411 lost++;
5413 }
5420 }
5422 /* Returns 1 if template args OT and NT are equivalent. */
5424 static int
5426 {
5431 /* For member templates */
5438 {
5455 }
5460 else
5462 }
5464 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5465 of template arguments. Returns 0 otherwise. */
5467 int
5469 {
5476 {
5482 }
5484 }
5486 static void
5488 {
5498 /* We are called both from instantiate_decl, where we've already had a
5499 tinst_level pushed, and instantiate_template, where we haven't.
5500 Compensate. */
5511 else
5520 }
5523 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5524 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5525 documentation for TEMPLATE_ID_EXPR. */
5527 tree
5529 {
5530 tree type;
5540 {
5542 unknown_type_node,
5544 arglist);
5546 }
5553 }
5555 /* Within the scope of a template class S<T>, the name S gets bound
5556 (in build_self_reference) to a TYPE_DECL for the class, not a
5557 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5558 or one of its enclosing classes, and that type is a template,
5559 return the associated TEMPLATE_DECL. Otherwise, the original
5560 DECL is returned. */
5562 tree
5564 {
5571 }
5573 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5574 parameters, find the desired type.
5576 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5578 IN_DECL, if non-NULL, is the template declaration we are trying to
5579 instantiate.
5581 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5582 the class we are looking up.
5584 Issue error and warning messages under control of COMPLAIN.
5586 If the template class is really a local class in a template
5587 function, then the FUNCTION_CONTEXT is the function in which it is
5588 being instantiated.
5590 ??? Note that this function is currently called *twice* for each
5591 template-id: the first time from the parser, while creating the
5592 incomplete type (finish_template_type), and the second type during the
5593 real instantiation (instantiate_template_class). This is surely something
5594 that we want to avoid. It also causes some problems with argument
5595 coercion (see convert_nontype_argument for more information on this). */
5597 tree
5599 tree arglist,
5600 tree in_decl,
5601 tree context,
5603 tsubst_flags_t complain)
5604 {
5606 tree t;
5611 {
5615 else
5616 {
5623 }
5626 }
5628 {
5631 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5632 an implicit typename for the second A. Deal with it. */
5637 {
5640 }
5641 }
5644 {
5647 }
5651 {
5655 }
5657 /* Issue an error message if we didn't find a template. */
5659 {
5663 }
5666 /* Make sure it's a user visible template, if it was named by
5667 the user. */
5670 {
5672 {
5676 }
5678 }
5683 {
5684 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5685 template arguments */
5687 tree parm;
5688 tree arglist2;
5689 tree outer;
5693 /* Consider an example where a template template parameter declared as
5695 template <class T, class U = std::allocator<T> > class TT
5697 The template parameter level of T and U are one level larger than
5698 of TT. To proper process the default argument of U, say when an
5699 instantiation `TT<int>' is seen, we need to build the full
5700 arguments containing {int} as the innermost level. Outer levels,
5701 available when not appearing as default template argument, can be
5702 obtained from the arguments of the enclosing template.
5704 Suppose that TT is later substituted with std::vector. The above
5705 instantiation is `TT<int, std::allocator<T> >' with TT at
5706 level 1, and T at level 2, while the template arguments at level 1
5707 becomes {std::vector} and the inner level 2 is {int}. */
5713 /* This is an argument of the current template, so we haven't set
5714 DECL_CONTEXT yet. */
5721 complain,
5731 }
5732 else
5733 {
5735 tree gen_tmpl;
5736 tree type_decl;
5748 {
5749 /* We've been given an incomplete set of template arguments.
5750 For example, given:
5752 template <class T> struct S1 {
5753 template <class U> struct S2 {};
5754 template <class U> struct S2<U*> {};
5755 };
5757 we will be called with an ARGLIST of `U*', but the
5758 TEMPLATE will be `template <class T> template
5759 <class U> struct S1<T>::S2'. We must fill in the missing
5760 arguments. */
5761 arglist
5763 arglist);
5765 }
5767 /* Now we should have enough arguments. */
5770 /* From here on, we're only interested in the most general
5771 template. */
5774 /* Calculate the BOUND_ARGS. These will be the args that are
5775 actually tsubst'd into the definition to create the
5776 instantiation. */
5778 {
5779 /* We have multiple levels of arguments to coerce, at once. */
5789 {
5792 complain,
5796 /* Don't process further if one of the levels fails. */
5798 {
5799 /* Restore the ARGLIST to its full size. */
5802 }
5806 /* We temporarily reduce the length of the ARGLIST so
5807 that coerce_template_parms will see only the arguments
5808 corresponding to the template parameters it is
5809 examining. */
5811 }
5813 /* Restore the ARGLIST to its full size. */
5817 }
5818 else
5819 arglist
5822 templ,
5823 complain,
5828 /* We were unable to bind the arguments. */
5831 /* In the scope of a template class, explicit references to the
5832 template class refer to the type of the template, not any
5833 instantiation of it. For example, in:
5835 template <class T> class C { void f(C<T>); }
5837 the `C<T>' is just the same as `C'. Outside of the
5838 class, however, such a reference is an instantiation. */
5840 arglist))
5841 {
5845 {
5846 tree ctx;
5856 /* We're not in the scope of the class, so the
5857 TEMPLATE_TYPE is not the type we want after all. */
5859 found_ctx:;
5860 }
5861 }
5865 /* If we already have this specialization, return it. */
5871 /* This type is a "partial instantiation" if any of the template
5872 arguments still involve template parameters. Note that we set
5873 IS_PARTIAL_INSTANTIATION for partial specializations as
5874 well. */
5877 /* If the deduced arguments are invalid, then the binding
5878 failed. */
5882 complain))
5888 {
5893 }
5900 /* Create the type. */
5902 {
5904 {
5910 }
5911 else
5912 {
5913 /* We don't want to call start_enum for this type, since
5914 the values for the enumeration constants may involve
5915 template parameters. And, no one should be interested
5916 in the enumeration constants for such a type. */
5919 }
5920 }
5921 else
5922 {
5929 /* A local class. Make sure the decl gets registered properly. */
5934 /* This instantiation is another name for the primary
5935 template type. Set the TYPE_CANONICAL field
5936 appropriately. */
5939 /* Some of the template arguments require structural
5940 equality testing, so this template class requires
5941 structural equality testing. */
5943 }
5945 /* If we called start_enum or pushtag above, this information
5946 will already be set up. */
5948 {
5956 }
5957 else
5965 {
5968 }
5970 /* Set up the template information. We have to figure out which
5971 template is the immediate parent if this is a full
5972 instantiation. */
5975 /* This case is easy; there are no member templates involved. */
5977 else
5978 {
5979 /* This is a full instantiation of a member template. Look
5980 for a partial instantiation of which this is an instance. */
5984 {
5988 /* We only want partial instantiations, here, not
5989 specializations or full instantiations. */
5994 /* Temporarily reduce by one the number of levels in the
5995 ARGLIST and in FOUND so as to avoid comparing the
5996 last set of arguments. */
6000 /* See if the arguments match. If they do, then TMPL is
6001 the partial instantiation we want. */
6004 /* Restore the argument vectors to their full size. */
6009 {
6012 }
6013 }
6016 {
6017 /* There was no partial instantiation. This happens
6018 where C<T> is a member template of A<T> and it's used
6019 in something like
6021 template <typename T> struct B { A<T>::C<int> m; };
6022 B<float>;
6024 Create the partial instantiation.
6025 */
6029 }
6030 }
6039 /* Now that the type has been registered on the instantiations
6040 list, we set up the enumerators. Because the enumeration
6041 constants may involve the enumeration type itself, we make
6042 sure to register the type first, and then create the
6043 constants. That way, doing tsubst_expr for the enumeration
6044 constants won't result in recursive calls here; we'll find
6045 the instantiation and exit above. */
6049 /* If the type makes use of template parameters, the
6050 code that generates debugging information will crash. */
6053 /* Possibly limit visibility based on template args. */
6058 }
6060 }
6061 \f
6062 struct pair_fn_data
6063 {
6064 tree_fn_t fn;
6066 /* True when we should also visit template parameters that occur in
6067 non-deduced contexts. */
6070 };
6072 /* Called from for_each_template_parm via walk_tree. */
6074 static tree
6076 {
6089 {
6093 /* Fall through. */
6116 /* Since we're not going to walk subtrees, we have to do this
6117 explicitly here. */
6121 /* Fall through. */
6124 /* Check the return type. */
6129 /* Check the parameter types. Since default arguments are not
6130 instantiated until they are needed, the TYPE_ARG_TYPES may
6131 contain expressions that involve template parameters. But,
6132 no-one should be looking at them yet. And, once they're
6133 instantiated, they don't contain template parameters, so
6134 there's no point in looking at them then, either. */
6135 {
6136 tree parm;
6143 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6144 want walk_tree walking into them itself. */
6146 }
6163 /* Fall through. */
6179 /* Record template parameters such as `T' inside `TT<T>'. */
6183 /* Fall through. */
6195 /* A template template parameter is encountered. */
6201 /* Already substituted template template parameter */
6224 /* If there's no type, then this thing must be some expression
6225 involving template parameters. */
6246 }
6248 /* We didn't find any template parameters we liked. */
6250 }
6252 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6253 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6254 call FN with the parameter and the DATA.
6255 If FN returns nonzero, the iteration is terminated, and
6256 for_each_template_parm returns 1. Otherwise, the iteration
6257 continues. If FN never returns a nonzero value, the value
6258 returned by for_each_template_parm is 0. If FN is NULL, it is
6259 considered to be the function which always returns 1.
6261 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6262 parameters that occur in non-deduced contexts. When false, only
6263 visits those template parameters that can be deduced. */
6265 static int
6269 {
6273 /* Set up. */
6278 /* Walk the tree. (Conceptually, we would like to walk without
6279 duplicates, but for_each_template_parm_r recursively calls
6280 for_each_template_parm, so we would need to reorganize a fair
6281 bit to use walk_tree_without_duplicates, so we keep our own
6282 visited list.) */
6285 else
6288 for_each_template_parm_r,
6292 /* Clean up. */
6294 {
6297 }
6300 }
6302 /* Returns true if T depends on any template parameter. */
6304 int
6306 {
6333 else
6334 {
6337 }
6342 }
6344 /* Returns true if T depends on any template parameter with level LEVEL. */
6346 int
6348 {
6351 }
6355 #ifdef GATHER_STATISTICS
6357 #endif
6361 /* We're starting to instantiate D; record the template instantiation context
6362 for diagnostics and to restore it later. */
6364 static int
6366 {
6370 {
6371 /* If the instantiation in question still has unbound template parms,
6372 we don't really care if we can't instantiate it, so just return.
6373 This happens with base instantiation for implicit `typename'. */
6385 }
6395 #ifdef GATHER_STATISTICS
6398 #endif
6402 }
6404 /* We're done instantiating this template; return to the instantiation
6405 context. */
6407 static void
6409 {
6410 /* Restore the filename and line number stashed away when we started
6411 this instantiation. */
6416 }
6418 /* We're instantiating a deferred template; restore the template
6419 instantiation context in which the instantiation was requested, which
6420 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6422 static tree
6424 {
6434 }
6436 /* Returns the TINST_LEVEL which gives the original instantiation
6437 context. */
6441 {
6447 }
6449 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
6451 bool
6453 {
6454 tree parms;
6471 }
6473 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6474 vector of template arguments, as for tsubst.
6476 Returns an appropriate tsubst'd friend declaration. */
6478 static tree
6480 {
6481 tree new_friend;
6486 /* This was a friend declared with an explicit template
6487 argument list, e.g.:
6489 friend void f<>(T);
6491 to indicate that f was a template instantiation, not a new
6492 function declaration. Now, we have to figure out what
6493 instantiation of what template. */
6494 {
6496 tree new_args;
6497 tree tmpl;
6500 /* Friend functions are looked up in the containing namespace scope.
6501 We must enter that scope, to avoid finding member functions of the
6502 current class with same name. */
6517 tsk_none);
6519 }
6523 /* The NEW_FRIEND will look like an instantiation, to the
6524 compiler, but is not an instantiation from the point of view of
6525 the language. For example, we might have had:
6527 template <class T> struct S {
6528 template <class U> friend void f(T, U);
6529 };
6531 Then, in S<int>, template <class U> void f(int, U) is not an
6532 instantiation of anything. */
6538 {
6542 }
6544 /* The mangled name for the NEW_FRIEND is incorrect. The function
6545 is not a template instantiation and should not be mangled like
6546 one. Therefore, we forget the mangling here; we'll recompute it
6547 later if we need it. */
6549 {
6552 }
6555 {
6556 tree old_decl;
6557 tree new_friend_template_info;
6558 tree new_friend_result_template_info;
6559 tree ns;
6562 /* We must save some information from NEW_FRIEND before calling
6563 duplicate decls since that function will free NEW_FRIEND if
6564 possible. */
6566 new_friend_is_defn =
6571 {
6572 /* This declaration is a `primary' template. */
6575 new_friend_result_template_info
6577 }
6578 else
6581 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6585 /* Inside pushdecl_namespace_level, we will push into the
6586 current namespace. However, the friend function should go
6587 into the namespace of the template. */
6597 {
6598 /* This new friend declaration matched an existing
6599 declaration. For example, given:
6601 template <class T> void f(T);
6602 template <class U> class C {
6603 template <class T> friend void f(T) {}
6604 };
6606 the friend declaration actually provides the definition
6607 of `f', once C has been instantiated for some type. So,
6608 old_decl will be the out-of-class template declaration,
6609 while new_friend is the in-class definition.
6611 But, if `f' was called before this point, the
6612 instantiation of `f' will have DECL_TI_ARGS corresponding
6613 to `T' but not to `U', references to which might appear
6614 in the definition of `f'. Previously, the most general
6615 template for an instantiation of `f' was the out-of-class
6616 version; now it is the in-class version. Therefore, we
6617 run through all specialization of `f', adding to their
6618 DECL_TI_ARGS appropriately. In particular, they need a
6619 new set of outer arguments, corresponding to the
6620 arguments for this class instantiation.
6622 The same situation can arise with something like this:
6624 friend void f(int);
6625 template <class T> class C {
6626 friend void f(T) {}
6627 };
6629 when `C<int>' is instantiated. Now, `f(int)' is defined
6630 in the class. */
6633 /* On the other hand, if the in-class declaration does
6634 *not* provide a definition, then we don't want to alter
6635 existing definitions. We can just leave everything
6636 alone. */
6637 ;
6638 else
6639 {
6640 /* Overwrite whatever template info was there before, if
6641 any, with the new template information pertaining to
6642 the declaration. */
6648 old_decl);
6649 else
6650 {
6651 tree t;
6652 tree new_friend_args;
6661 {
6667 }
6669 /* Now, since specializations are always supposed to
6670 hang off of the most general template, we must move
6671 them. */
6674 {
6679 }
6680 }
6681 }
6683 /* The information from NEW_FRIEND has been merged into OLD_DECL
6684 by duplicate_decls. */
6686 }
6687 }
6688 else
6689 {
6693 /* In the code
6694 template <class T> class C {
6695 template <class U> friend void C1<U>::f (); // case 1
6696 friend void C2<T>::f (); // case 2
6697 };
6698 we only need to make sure CONTEXT is a complete type for
6699 case 2. To distinguish between the two cases, we note that
6700 CONTEXT of case 1 remains dependent type after tsubst while
6701 this isn't true for case 2. */
6711 {
6712 /* Check to see that the declaration is really present, and,
6713 possibly obtain an improved declaration. */
6719 }
6720 }
6723 }
6725 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6726 template arguments, as for tsubst.
6728 Returns an appropriate tsubst'd friend type or error_mark_node on
6729 failure. */
6731 static tree
6733 {
6734 tree friend_type;
6735 tree tmpl;
6736 tree context;
6741 {
6744 else
6746 }
6748 /* Look for a class template declaration. We look for hidden names
6749 because two friend declarations of the same template are the
6750 same. For example, in:
6752 struct A {
6753 template <typename> friend class F;
6754 };
6755 template <typename> struct B {
6756 template <typename> friend class F;
6757 };
6759 both F templates are the same. */
6764 /* But, if we don't find one, it might be because we're in a
6765 situation like this:
6767 template <class T>
6768 struct S {
6769 template <class U>
6770 friend struct S;
6771 };
6773 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6774 for `S<int>', not the TEMPLATE_DECL. */
6776 {
6779 }
6782 {
6783 /* The friend template has already been declared. Just
6784 check to see that the declarations match, and install any new
6785 default parameters. We must tsubst the default parameters,
6786 of course. We only need the innermost template parameters
6787 because that is all that redeclare_class_template will look
6788 at. */
6791 {
6792 tree parms;
6793 location_t saved_input_location;
6802 }
6805 }
6806 else
6807 {
6808 /* The friend template has not already been declared. In this
6809 case, the instantiation of the template class will cause the
6810 injection of this template into the global scope. */
6815 /* The new TMPL is not an instantiation of anything, so we
6816 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6817 the new type because that is supposed to be the corresponding
6818 template decl, i.e., TMPL. */
6825 /* Inject this template into the global scope. */
6827 }
6830 {
6833 else
6835 }
6838 }
6840 /* Returns zero if TYPE cannot be completed later due to circularity.
6841 Otherwise returns one. */
6843 static int
6845 {
6855 else
6857 }
6859 /* Apply any attributes which had to be deferred until instantiation
6860 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6861 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6863 static void
6866 {
6868 tree t;
6873 {
6877 }
6880 {
6884 }
6885 else
6889 {
6894 {
6897 {
6900 /* If the first attribute argument is an identifier, don't
6901 pass it through tsubst. Attributes like mode, format,
6902 cleanup and several target specific attributes expect it
6903 unmodified. */
6909 {
6910 tree chain
6912 in_decl,
6917 chain);
6918 }
6919 else
6925 }
6926 else
6928 }
6931 }
6932 }
6934 /* Perform (or defer) access check for typedefs that were referenced
6935 from within the template TMPL code.
6936 This is a subroutine of instantiate_template and instantiate_class_template.
6937 TMPL is the template to consider and TARGS is the list of arguments of
6938 that template. */
6940 static void
6942 {
6943 tree t;
6951 {
6965 }
6966 }
6968 tree
6970 {
6972 tree typedecl;
6973 tree pbinfo;
6974 tree base_list;
6984 /* Figure out which template is being instantiated. */
6988 /* Determine what specialization of the original template to
6989 instantiate. */
6992 {
6995 }
6997 {
6998 /* This TYPE is actually an instantiation of a partial
6999 specialization. We replace the innermost set of ARGS with
7000 the arguments appropriate for substitution. For example,
7001 given:
7003 template <class T> struct S {};
7004 template <class T> struct S<T*> {};
7006 and supposing that we are instantiating S<int*>, ARGS will
7007 presently be {int*} -- but we need {int}. */
7010 }
7011 else
7012 {
7015 }
7017 /* If the template we're instantiating is incomplete, then clearly
7018 there's nothing we can do. */
7022 /* If we've recursively instantiated too many templates, stop. */
7026 /* Now we're really doing the instantiation. Mark the type as in
7027 the process of being defined. */
7030 /* We may be in the middle of deferred access check. Disable
7031 it now. */
7038 /* Set the input location to the most specialized template definition.
7039 This is needed if tsubsting causes an error. */
7060 {
7063 }
7067 /* We should never instantiate a nested class before its enclosing
7068 class; we need to look up the nested class by name before we can
7069 instantiate it, and that lookup should instantiate the enclosing
7070 class. */
7077 {
7078 tree pbase_binfo;
7080 tree pushed_scope;
7083 /* We must enter the scope containing the type, as that is where
7084 the accessibility of types named in dependent bases are
7085 looked up from. */
7088 /* Substitute into each of the bases to determine the actual
7089 basetypes. */
7091 {
7092 tree base;
7098 {
7099 expanded_bases =
7106 }
7109 {
7111 /* Extract the already-expanded base class. */
7113 else
7114 /* Substitute to figure out the base class. */
7116 NULL_TREE);
7124 }
7125 }
7127 /* The list is now in reverse order; correct that. */
7132 }
7133 /* Now call xref_basetypes to set up all the base-class
7134 information. */
7141 /* Now that our base classes are set up, enter the scope of the
7142 class, so that name lookups into base classes, etc. will work
7143 correctly. This is precisely analogous to what we do in
7144 begin_class_definition when defining an ordinary non-template
7145 class, except we also need to push the enclosing classes. */
7148 /* Now members are processed in the order of declaration. */
7151 {
7155 {
7157 {
7158 /* Build new CLASSTYPE_NESTED_UTDS. */
7160 tree newtag;
7166 /* If the member is a class template, then -- even after
7167 substitution -- there may be dependent types in the
7168 template argument list for the class. We increment
7169 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7170 that function will assume that no types are dependent
7171 when outside of a template. */
7181 {
7185 /* Unfortunately, lookup_template_class sets
7186 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7187 instantiation (i.e., for the type of a member
7188 template class nested within a template class.)
7189 This behavior is required for
7190 maybe_process_partial_specialization to work
7191 correctly, but is not accurate in this case;
7192 the TAG is not an instantiation of anything.
7193 (The corresponding TEMPLATE_DECL is an
7194 instantiation, but the TYPE is not.) */
7197 /* Now, we call pushtag to put this NEWTAG into the scope of
7198 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7199 pushtag calling push_template_decl. We don't have to do
7200 this for enums because it will already have been done in
7201 tsubst_enum. */
7205 }
7206 }
7209 {
7210 /* Build new TYPE_METHODS. */
7211 tree r;
7220 }
7221 else
7222 {
7223 /* Build new TYPE_FIELDS. */
7225 {
7226 tree condition =
7234 }
7236 {
7237 tree r;
7239 /* The file and line for this declaration, to
7240 assist in error message reporting. Since we
7241 called push_tinst_level above, we don't need to
7242 restore these. */
7251 {
7252 /* In [temp.inst]:
7254 [t]he initialization (and any associated
7255 side-effects) of a static data member does
7256 not occur unless the static data member is
7257 itself used in a way that requires the
7258 definition of the static data member to
7259 exist.
7261 Therefore, we do not substitute into the
7262 initialized for the static data member here. */
7263 finish_static_data_member_decl
7271 }
7273 {
7274 /* Determine whether R has a valid type and can be
7275 completed later. If R is invalid, then it is
7276 replaced by error_mark_node so that it will not be
7277 added to TYPE_FIELDS. */
7283 {
7286 }
7287 }
7289 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7290 such a thing will already have been added to the field
7291 list by tsubst_enum in finish_member_declaration in the
7292 CLASSTYPE_NESTED_UTDS case above. */
7296 {
7299 }
7300 }
7301 }
7302 }
7303 else
7304 {
7306 {
7307 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7313 {
7314 /* template <class T> friend class C; */
7317 }
7319 {
7320 /* template <class T> friend class C::D; */
7326 }
7328 {
7329 /* This could be either
7331 friend class T::C;
7333 when dependent_type_p is false or
7335 template <class U> friend class T::C;
7337 otherwise. */
7340 /* Bump processing_template_decl for correct
7341 dependent_type_p calculation. */
7346 }
7349 {
7350 /* friend class C;
7352 where C hasn't been declared yet. Let's lookup name
7353 from namespace scope directly, bypassing any name that
7354 come from dependent base class. */
7357 /* The call to xref_tag_from_type does injection for friend
7358 classes. */
7360 friend_type =
7364 }
7366 /* friend class C<T>; */
7369 /* Otherwise it's
7371 friend class C;
7373 where C is already declared or
7375 friend class C<int>;
7377 We don't have to do anything in these cases. */
7380 /* Trick make_friend_class into realizing that the friend
7381 we're adding is a template, not an ordinary class. It's
7382 important that we use make_friend_class since it will
7383 perform some error-checking and output cross-reference
7384 information. */
7392 }
7393 else
7394 {
7395 /* Build new DECL_FRIENDLIST. */
7396 tree r;
7398 /* The file and line for this declaration, to
7399 assist in error message reporting. Since we
7400 called push_tinst_level above, we don't need to
7401 restore these. */
7405 {
7408 }
7413 {
7416 }
7417 }
7418 }
7419 }
7421 /* Set the file and line number information to whatever is given for
7422 the class itself. This puts error messages involving generated
7423 implicit functions at a predictable point, and the same point
7424 that would be used for non-template classes. */
7431 /* Now that the class is complete, instantiate default arguments for
7432 any member functions. We don't do this earlier because the
7433 default arguments may reference members of the class. */
7437 /* Implicitly generated member functions will not have template
7438 information; they are not instantiations, but instead are
7439 created "fresh" for each instantiation. */
7443 /* Some typedefs referenced from within the template code need to be access
7444 checked at template instantiation time, i.e now. These types were
7445 added to the template at parsing time. Let's get those and perform
7446 the access checks then. */
7454 /* The vtable for a template class can be emitted in any translation
7455 unit in which the class is instantiated. When there is no key
7456 method, however, finish_struct_1 will already have added TYPE to
7457 the keyed_classes list. */
7462 }
7464 static tree
7466 {
7467 tree r;
7473 else
7474 {
7478 }
7480 }
7482 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
7483 NONTYPE_ARGUMENT_PACK. */
7485 static tree
7487 {
7488 /* Collect all of the extra "packed" parameters into an
7489 argument pack. */
7490 tree parmvec;
7491 tree parmtypevec;
7496 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
7500 {
7503 }
7505 /* Build the argument packs. */
7511 }
7513 /* Substitute ARGS into T, which is an pack expansion
7514 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7515 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7516 (if only a partial substitution could be performed) or
7517 ERROR_MARK_NODE if there was an error. */
7518 tree
7520 tree in_decl)
7521 {
7522 tree pattern;
7525 tree result;
7532 /* Determine the argument packs that will instantiate the parameter
7533 packs used in the expansion expression. While we're at it,
7534 compute the number of arguments to be expanded and make sure it
7535 is consistent. */
7538 {
7544 {
7547 {
7548 /* This can happen for a parameter name used later in a function
7549 declaration (such as in a late-specified return type). Just
7550 make a dummy decl, since it's only used for its type. */
7554 }
7555 }
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. */
7650 {
7651 /* We're in a late-specified return type, so we don't have a local
7652 specializations table. Create one for doing this expansion. */
7655 hash_local_specialization,
7656 eq_local_specializations,
7657 NULL);
7658 }
7660 /* For each argument in each argument pack, substitute into the
7661 pattern. */
7664 {
7665 /* For parameter pack, change the substitution of the parameter
7666 pack to the ith argument in its argument pack, then expand
7667 the pattern. */
7669 {
7673 {
7674 /* Select the Ith argument from the pack. */
7680 }
7681 else
7682 {
7688 {
7689 /* Select the Ith argument from the pack. */
7693 }
7695 /* Update the corresponding argument. */
7697 }
7698 }
7700 /* Substitute into the PATTERN with the altered arguments. */
7705 else
7709 /* When we have incomplete argument packs, the last "expanded"
7710 result is itself a pack expansion, which allows us
7711 to deduce more arguments. */
7716 {
7719 }
7720 }
7722 /* Update ARGS to restore the substitution from parameter packs to
7723 their argument packs. */
7725 {
7730 else
7731 {
7735 /* Update the corresponding argument. */
7739 else
7741 }
7742 }
7745 {
7748 }
7751 }
7753 /* Substitute ARGS into the vector or list of template arguments T. */
7755 static tree
7757 {
7764 {
7766 tree new_arg;
7771 {
7772 /* Substitute into an expansion expression. */
7776 /* Add to the expanded length adjustment the number of
7777 expanded arguments. We subtract one from this
7778 measurement, because the argument pack expression
7779 itself is already counted as 1 in
7780 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7781 the argument pack is empty. */
7783 }
7785 {
7786 /* Substitute into each of the arguments. */
7790 new_arg,
7804 }
7805 }
7806 else
7815 }
7820 /* Make space for the expanded arguments coming from template
7821 argument packs. */
7824 {
7828 {
7831 /* Now expand the template argument pack "in place". */
7834 }
7835 else
7836 {
7838 out++;
7839 }
7840 }
7843 }
7845 /* Return the result of substituting ARGS into the template parameters
7846 given by PARMS. If there are m levels of ARGS and m + n levels of
7847 PARMS, then the result will contain n levels of PARMS. For
7848 example, if PARMS is `template <class T> template <class U>
7849 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7850 result will be `template <int*, double, class V>'. */
7852 static tree
7854 {
7858 /* When substituting into a template, we must set
7859 PROCESSING_TEMPLATE_DECL as the template parameters may be
7860 dependent if they are based on one-another, and the dependency
7861 predicates are short-circuit outside of templates. */
7868 {
7869 tree new_vec =
7874 {
7875 tree tuple;
7876 tree default_value;
7877 tree parm_decl;
7899 }
7905 }
7910 }
7912 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7913 type T. If T is not an aggregate or enumeration type, it is
7914 handled as if by tsubst. IN_DECL is as for tsubst. If
7915 ENTERING_SCOPE is nonzero, T is the context for a template which
7916 we are presently tsubst'ing. Return the substituted value. */
7918 static tree
7920 tree args,
7921 tsubst_flags_t complain,
7922 tree in_decl,
7924 {
7929 {
7934 /* Else fall through. */
7938 {
7939 tree argvec;
7940 tree context;
7941 tree r;
7944 /* In "sizeof(X<I>)" we need to evaluate "I". */
7948 /* First, determine the context for the type we are looking
7949 up. */
7952 {
7955 /* If context is a nested class inside a class template,
7956 it may still need to be instantiated (c++/33959). */
7959 }
7961 /* Then, figure out what arguments are appropriate for the
7962 type we are trying to find. For example, given:
7964 template <class T> struct S;
7965 template <class T, class U> void f(T, U) { S<U> su; }
7967 and supposing that we are instantiating f<int, double>,
7968 then our ARGS will be {int, double}, but, when looking up
7969 S we only want {double}. */
7974 else
7975 {
7979 }
7984 }
7985 else
7986 /* This is not a template type, so there's nothing to do. */
7991 }
7992 }
7994 /* Substitute into the default argument ARG (a default argument for
7995 FN), which has the indicated TYPE. */
7997 tree
7999 {
8003 /* This default argument came from a template. Instantiate the
8004 default argument here, not in tsubst. In the case of
8005 something like:
8007 template <class T>
8008 struct S {
8009 static T t();
8010 void f(T = t());
8011 };
8013 we must be careful to do name lookup in the scope of S<T>,
8014 rather than in the current class. */
8016 /* The "this" pointer is not valid in a default argument. */
8018 {
8023 }
8026 /* The default argument expression may cause implicitly defined
8027 member functions to be synthesized, which will result in garbage
8028 collection. We must treat this situation as if we were within
8029 the body of function so as to avoid collecting live data on the
8030 stack. */
8038 /* Restore the "this" pointer. */
8040 {
8043 }
8047 /* Make sure the default argument is reasonable. */
8051 }
8053 /* Substitute into all the default arguments for FN. */
8055 static void
8057 {
8058 tree arg;
8059 tree tmpl_args;
8063 /* If this function is not yet instantiated, we certainly don't need
8064 its default arguments. */
8069 arg;
8075 }
8077 /* Substitute the ARGS into the T, which is a _DECL. Return the
8078 result of the substitution. Issue error and warning messages under
8079 control of COMPLAIN. */
8081 static tree
8083 {
8084 location_t saved_loc;
8088 /* Set the filename and linenumber to improve error-reporting. */
8093 {
8095 {
8096 /* We can get here when processing a member function template,
8097 member class template, and template template parameter of
8098 a template class. */
8100 tree spec;
8101 tree tmpl_args;
8102 tree full_args;
8105 {
8106 /* Template template parameter is treated here. */
8118 complain);
8121 }
8123 /* We might already have an instance of this template.
8124 The ARGS are for the surrounding class type, so the
8125 full args contain the tsubst'd args for the context,
8126 plus the innermost args from the template decl. */
8130 /* Because this is a template, the arguments will still be
8131 dependent, even after substitution. If
8132 PROCESSING_TEMPLATE_DECL is not set, the dependency
8133 predicates will short-circuit. */
8141 /* tsubst_template_args doesn't copy the vector if
8142 nothing changed. But, *something* should have
8143 changed. */
8149 {
8152 }
8154 /* Make a new template decl. It will be similar to the
8155 original, but will record the current template arguments.
8156 We also create a new function declaration, which is just
8157 like the old one, but points to this new template, rather
8158 than the old one. */
8166 {
8167 tree new_type;
8179 }
8180 else
8181 {
8182 tree new_decl;
8194 }
8200 /* The template parameters for this new template are all the
8201 template parameters for the old template, except the
8202 outermost level of parameters. */
8205 complain);
8211 /* Record this non-type partial instantiation. */
8215 }
8219 {
8220 tree ctx;
8223 tree gen_tmpl;
8224 tree type;
8229 /* Nobody should be tsubst'ing into non-template functions. */
8233 {
8234 tree spec;
8237 /* If T is not dependent, just return it. We have to
8238 increment PROCESSING_TEMPLATE_DECL because
8239 value_dependent_expression_p assumes that nothing is
8240 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8247 /* Calculate the most general template of which R is a
8248 specialization, and the complete set of arguments used to
8249 specialize R. */
8255 /* Check to see if we already have this specialization. */
8260 {
8263 }
8265 /* We can see more levels of arguments than parameters if
8266 there was a specialization of a member template, like
8267 this:
8269 template <class T> struct S { template <class U> void f(); }
8270 template <> template <class U> void S<int>::f(U);
8272 Here, we'll be substituting into the specialization,
8273 because that's where we can find the code we actually
8274 want to generate, but we'll have enough arguments for
8275 the most general template.
8277 We also deal with the peculiar case:
8279 template <class T> struct S {
8280 template <class U> friend void f();
8281 };
8282 template <class U> void f() {}
8283 template S<int>;
8284 template void f<double>();
8286 Here, the ARGS for the instantiation of will be {int,
8287 double}. But, we only need as many ARGS as there are
8288 levels of template parameters in CODE_PATTERN. We are
8289 careful not to get fooled into reducing the ARGS in
8290 situations like:
8292 template <class T> struct S { template <class U> void f(U); }
8293 template <class T> template <> void S<T>::f(int) {}
8295 which we can spot because the pattern will be a
8296 specialization in this case. */
8298 parms_depth =
8303 }
8304 else
8305 {
8306 /* This special case arises when we have something like this:
8308 template <class T> struct S {
8309 friend void f<int>(int, double);
8310 };
8312 Here, the DECL_TI_TEMPLATE for the friend declaration
8313 will be an IDENTIFIER_NODE. We are being called from
8314 tsubst_friend_function, and we want only to create a
8315 new decl (R) with appropriate types so that we can call
8316 determine_specialization. */
8318 }
8321 {
8324 else
8328 }
8329 else
8330 {
8333 }
8338 /* We do NOT check for matching decls pushed separately at this
8339 point, as they may not represent instantiations of this
8340 template, and in any case are considered separate under the
8341 discrete model. */
8345 /* Clear out the mangled name and RTL for the instantiation. */
8348 /* Leave DECL_INITIAL set on deleted instantiations. */
8354 /* Type-conversion operator. Reconstruct the name, in
8355 case it's the name of one of the template's parameters. */
8365 /* If this is an instantiation of a function with internal
8366 linkage, we already know what object file linkage will be
8367 assigned to the instantiation. */
8377 {
8382 }
8384 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8385 this in the special friend case mentioned above where
8386 GEN_TMPL is NULL. */
8388 {
8394 /* We're not supposed to instantiate default arguments
8395 until they are called, for a template. But, for a
8396 declaration like:
8398 template <class T> void f ()
8399 { extern void g(int i = T()); }
8401 we should do the substitution when the template is
8402 instantiated. We handle the member function case in
8403 instantiate_class_template since the default arguments
8404 might refer to other members of the class. */
8409 }
8410 else
8413 /* Copy the list of befriending classes. */
8417 {
8421 in_decl);
8422 }
8425 {
8429 /* If this is an instantiation of a member template, clone it.
8430 If it isn't, that'll be handled by
8431 clone_constructors_and_destructors. */
8434 }
8444 /* Possibly limit visibility based on template args. */
8447 {
8451 }
8456 }
8460 {
8468 {
8469 /* If there is a local specialization that isn't a
8470 parameter pack, it means that we're doing a "simple"
8471 substitution from inside tsubst_pack_expansion. Just
8472 return the local specialization (which will be a single
8473 parm). */
8480 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8481 the parameters in this function parameter pack. */
8485 {
8488 /* Zero-length parameter packs are boring. Just substitute
8489 into the chain. */
8493 }
8494 else
8495 {
8496 /* All we did was update the type. Make a note of that. */
8499 }
8500 }
8502 /* Loop through all of the parameter's we'll build. When T is
8503 a function parameter pack, LEN is the number of expanded
8504 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8507 {
8514 /* We're on the Ith parameter of the function parameter
8515 pack. */
8516 {
8517 /* Get the Ith type. */
8521 /* Rename the parameter to include the index. */
8524 }
8526 /* We're dealing with a normal parameter. */
8534 {
8537 else
8540 }
8550 /* Keep track of the first new parameter we
8551 generate. That's what will be returned to the
8552 caller. */
8556 /* Build a proper chain of parameters when substituting
8557 into a function parameter pack. */
8560 }
8566 /* FIRST_R contains the start of the chain we've built. */
8568 }
8572 {
8573 tree type;
8582 /* DECL_INITIAL gives the number of bits in a bit-field. */
8587 /* We don't have to set DECL_CONTEXT here; it is set by
8588 finish_member_declaration. */
8595 }
8599 /* We reach here only for member using decls. */
8601 {
8602 r = do_class_using_decl
8607 else
8608 {
8611 }
8612 }
8613 else
8614 {
8617 }
8622 {
8625 tree spec;
8627 tree ctx;
8633 {
8634 /* If this is the canonical decl, we don't have to
8635 mess with instantiations, and often we can't (for
8636 typename, template type parms and such). Note that
8637 TYPE_NAME is not correct for the above test if
8638 we've copied the type for a typedef. */
8644 }
8646 /* Check to see if we already have the specialization we
8647 need. */
8650 {
8651 /* T is a static data member or namespace-scope entity.
8652 We have to substitute into namespace-scope variables
8653 (even though such entities are never templates) because
8654 of cases like:
8656 template <class T> void f() { extern T t; }
8658 where the entity referenced is not known until
8659 instantiation time. */
8663 {
8665 complain,
8667 /* If CTX is unchanged, then T is in fact the
8668 specialization we want. That situation occurs when
8669 referencing a static data member within in its own
8670 class. We can use pointer equality, rather than
8671 same_type_p, because DECL_CONTEXT is always
8672 canonical. */
8675 }
8678 {
8682 spec = (retrieve_specialization
8685 }
8686 }
8687 else
8688 {
8689 /* A local variable. */
8691 /* Subsequent calls to pushdecl will fill this in. */
8694 }
8695 /* If we already have the specialization we need, there is
8696 nothing more to do. */
8698 {
8701 }
8703 /* Create a new node for the specialization we need. */
8708 {
8709 /* Even if the original location is out of scope, the
8710 newly substituted one is not. */
8717 {
8718 /* It may seem that this case cannot occur, since:
8720 typedef void f();
8721 void g() { f x; }
8723 declares a function, not a variable. However:
8725 typedef void f();
8726 template <typename T> void g() { T t; }
8727 template void g<f>();
8729 is an attempt to declare a variable with function
8730 type. */
8732 /* R is not yet sufficiently initialized, so we
8733 just use its name. */
8736 }
8743 {
8748 }
8749 }
8755 /* Clear out the mangled name and RTL for the instantiation. */
8759 /* The initializer must not be expanded until it is required;
8760 see [temp.inst]. */
8766 {
8767 /* Possibly limit visibility based on template args. */
8770 {
8774 }
8776 }
8777 /* Preserve a typedef that names a type. */
8781 {
8786 }
8789 {
8790 /* A static data member declaration is always marked
8791 external when it is declared in-class, even if an
8792 initializer is present. We mimic the non-template
8793 processing here. */
8799 }
8800 else
8809 }
8814 }
8816 /* Restore the file and line information. */
8820 }
8822 /* Substitute into the ARG_TYPES of a function type. */
8824 static tree
8826 tree args,
8827 tsubst_flags_t complain,
8828 tree in_decl)
8829 {
8830 tree remaining_arg_types;
8834 tree default_arg;
8845 {
8846 /* For a pack expansion, perform substitution on the
8847 entire expression. Later on, we'll handle the arguments
8848 one-by-one. */
8853 /* So that we'll spin through the parameters, one by one. */
8855 else
8856 {
8857 /* We only partially substituted into the parameter
8858 pack. Our type is TYPE_PACK_EXPANSION. */
8861 }
8862 }
8875 {
8877 {
8881 }
8883 }
8885 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8886 top-level qualifiers as required. */
8889 /* We do not substitute into default arguments here. The standard
8890 mandates that they be instantiated only when needed, which is
8891 done in build_over_call. */
8895 {
8896 /* We've instantiated a template before its default arguments
8897 have been parsed. This can happen for a nested template
8898 class, and is not an error unless we require the default
8899 argument in a call of this function. */
8900 remaining_arg_types =
8903 remaining_arg_types);
8904 }
8905 else
8906 remaining_arg_types =
8908 }
8911 }
8913 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8914 *not* handle the exception-specification for FNTYPE, because the
8915 initial substitution of explicitly provided template parameters
8916 during argument deduction forbids substitution into the
8917 exception-specification:
8919 [temp.deduct]
8921 All references in the function type of the function template to the
8922 corresponding template parameters are replaced by the specified tem-
8923 plate argument values. If a substitution in a template parameter or
8924 in the function type of the function template results in an invalid
8925 type, type deduction fails. [Note: The equivalent substitution in
8926 exception specifications is done only when the function is instanti-
8927 ated, at which point a program is ill-formed if the substitution
8928 results in an invalid type.] */
8930 static tree
8932 tree args,
8933 tsubst_flags_t complain,
8934 tree in_decl)
8935 {
8936 tree return_type;
8937 tree arg_types;
8938 tree fntype;
8940 /* The TYPE_CONTEXT is not used for function/method types. */
8943 /* Substitute the return type. */
8947 /* The standard does not presently indicate that creation of a
8948 function type with an invalid return type is a deduction failure.
8949 However, that is clearly analogous to creating an array of "void"
8950 or a reference to a reference. This is core issue #486. */
8953 {
8955 {
8958 else
8960 }
8962 }
8964 /* Substitute the argument types. */
8970 /* Construct a new type node and return it. */
8973 else
8974 {
8977 {
8978 /* [temp.deduct]
8980 Type deduction may fail for any of the following
8981 reasons:
8983 -- Attempting to create "pointer to member of T" when T
8984 is not a class type. */
8987 r);
8989 }
8993 }
8998 }
9000 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9001 ARGS into that specification, and return the substituted
9002 specification. If there is no specification, return NULL_TREE. */
9004 static tree
9006 tree args,
9007 tsubst_flags_t complain,
9008 tree in_decl)
9009 {
9010 tree specs;
9011 tree new_specs;
9016 {
9019 else
9021 {
9022 tree spec;
9027 {
9028 /* Expand the pack expansion type. */
9031 in_decl);
9037 else
9038 {
9039 /* We're substituting into a member template, so
9040 we got a TYPE_PACK_EXPANSION back. Add that
9041 expansion and move on. */
9045 expanded_specs,
9046 complain);
9049 }
9050 }
9053 {
9056 else
9061 complain);
9062 }
9065 }
9066 }
9068 }
9070 /* Take the tree structure T and replace template parameters used
9071 therein with the argument vector ARGS. IN_DECL is an associated
9072 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9073 Issue error and warning messages under control of COMPLAIN. Note
9074 that we must be relatively non-tolerant of extensions here, in
9075 order to preserve conformance; if we allow substitutions that
9076 should not be allowed, we may allow argument deductions that should
9077 not succeed, and therefore report ambiguous overload situations
9078 where there are none. In theory, we could allow the substitution,
9079 but indicate that it should have failed, and allow our caller to
9080 make sure that the right thing happens, but we don't try to do this
9081 yet.
9083 This function is used for dealing with types, decls and the like;
9084 for expressions, use tsubst_expr or tsubst_copy. */
9086 tree
9088 {
9107 else
9112 /* Reuse typedefs. We need to do this to handle dependent attributes,
9113 such as attribute aligned. */
9117 {
9123 {
9127 }
9132 else
9133 /* The typedef is from a non-template context. */
9137 {
9139 r = cp_build_qualified_type_real
9143 }
9144 /* Else we must be instantiating the typedef, so fall through. */
9145 }
9157 {
9184 {
9190 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
9191 needed. */
9199 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
9200 with TREE_SIDE_EFFECTS that indicates this is not an integral
9201 constant expression. */
9204 {
9207 }
9213 {
9217 }
9219 /* [temp.deduct]
9221 Type deduction may fail for any of the following
9222 reasons:
9224 Attempting to create an array with a size that is
9225 zero or negative. */
9227 /* We must fail if performing argument deduction (as
9228 indicated by the state of complain), so that
9229 another substitution can be found. */
9233 {
9238 }
9241 }
9247 {
9260 {
9264 /* See through ARGUMENT_PACK_SELECT arguments. */
9266 }
9271 {
9273 /* If ARG is an argument pack, we don't actually want to
9274 perform a substitution here, because substitutions
9275 for argument packs are only done
9276 element-by-element. We can get to this point when
9277 substituting the type of a non-type template
9278 parameter pack, when that type actually contains
9279 template parameter packs from an outer template, e.g.,
9281 template<typename... Types> struct A {
9282 template<Types... Values> struct B { };
9283 }; */
9287 {
9291 /* cv-quals from the template are discarded when
9292 substituting in a function or reference type. */
9297 else
9300 return cp_build_qualified_type_real
9302 }
9304 {
9305 /* We are processing a type constructed from a
9306 template template parameter. */
9312 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9313 are resolving nested-types in the signature of a
9314 member function templates. Otherwise ARG is a
9315 TEMPLATE_DECL and is the real template to be
9316 instantiated. */
9324 complain);
9325 return cp_build_qualified_type_real
9327 }
9328 else
9329 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9331 }
9334 /* This can happen during the attempted tsubst'ing in
9335 unify. This means that we don't yet have any information
9336 about the template parameter in question. */
9339 /* If we get here, we must have been looking at a parm for a
9340 more deeply nested template. Make a new version of this
9341 template parameter, but with a lower level. */
9343 {
9348 {
9350 r = cp_build_qualified_type_real
9354 }
9355 else
9356 {
9367 /* We have reduced the level of the template
9368 template parameter, but not the levels of its
9369 template parameters, so canonical_type_parameter
9370 will not be able to find the canonical template
9371 template parameter for this level. Thus, we
9372 require structural equality checking to compare
9373 TEMPLATE_TEMPLATE_PARMs. */
9377 else
9381 {
9389 }
9390 }
9399 }
9402 }
9405 {
9413 {
9417 }
9420 {
9424 }
9427 {
9431 }
9437 }
9440 /* We should never be tsubsting a binfo. */
9444 /* A vector of template arguments. */
9450 {
9459 /* [temp.deduct]
9461 Type deduction may fail for any of the following
9462 reasons:
9464 -- Attempting to create a pointer to reference type.
9465 -- Attempting to create a reference to a reference type or
9466 a reference to void.
9468 Core issue 106 says that creating a reference to a reference
9469 during instantiation is no longer a cause for failure. We
9470 only enforce this check in strict C++98 mode. */
9474 {
9477 /* We keep track of the last time we issued this error
9478 message to avoid spewing a ton of messages during a
9479 single bad template instantiation. */
9482 {
9485 else
9488 type);
9490 }
9493 }
9495 {
9499 }
9501 /* In C++0x, during template argument substitution, when there is an
9502 attempt to create a reference to a reference type, reference
9503 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9505 "If a template-argument for a template-parameter T names a type
9506 that is a reference to a type A, an attempt to create the type
9507 'lvalue reference to cv T' creates the type 'lvalue reference to
9508 A,' while an attempt to create the type type rvalue reference to
9509 cv T' creates the type T"
9510 */
9511 r = cp_build_reference_type
9514 else
9519 /* Will this ever be needed for TYPE_..._TO values? */
9523 }
9525 {
9528 {
9529 /* [temp.deduct]
9531 Type deduction may fail for any of the following
9532 reasons:
9534 -- Attempting to create "pointer to member of T" when T
9535 is not a class type. */
9539 }
9541 {
9545 }
9547 {
9551 }
9554 {
9555 /* The type of the implicit object parameter gets its
9556 cv-qualifiers from the FUNCTION_TYPE. */
9557 tree method_type;
9560 tree memptr;
9566 complain);
9567 }
9568 else
9571 complain);
9572 }
9575 {
9576 tree fntype;
9577 tree specs;
9582 /* Substitute the exception specification. */
9584 in_decl);
9590 }
9592 {
9597 /* As an optimization, we avoid regenerating the array type if
9598 it will obviously be the same as T. */
9602 /* These checks should match the ones in grokdeclarator.
9604 [temp.deduct]
9606 The deduction may fail for any of the following reasons:
9608 -- Attempting to create an array with an element type that
9609 is void, a function type, or a reference type, or [DR337]
9610 an abstract class type. */
9614 {
9618 }
9620 {
9623 type);
9625 }
9630 {
9633 }
9636 }
9640 {
9648 }
9652 {
9658 }
9661 {
9671 {
9675 }
9677 {
9678 /* Normally, make_typename_type does not require that the CTX
9679 have complete type in order to allow things like:
9681 template <class T> struct S { typename S<T>::X Y; };
9683 But, such constructs have already been resolved by this
9684 point, so here CTX really should have complete type, unless
9685 it's a partial instantiation. */
9688 {
9692 }
9693 }
9700 {
9703 }
9706 {
9713 }
9715 return cp_build_qualified_type_real
9717 }
9720 {
9732 }
9740 {
9748 }
9751 {
9759 }
9762 {
9763 tree type;
9772 complain);
9773 }
9776 {
9777 tree type;
9787 type =
9793 complain);
9794 }
9798 {
9800 tree packed_out =
9802 args,
9803 complain,
9804 in_decl);
9807 /* For template nontype argument packs, also substitute into
9808 the type. */
9813 }
9820 }
9821 }
9823 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9824 type of the expression on the left-hand side of the "." or "->"
9825 operator. */
9827 static tree
9830 {
9831 tree name;
9832 tree qualifying_scope;
9833 tree fns;
9834 tree optype;
9838 /* A baselink indicates a function from a base class. Both the
9839 BASELINK_ACCESS_BINFO and the base class referenced may
9840 indicate bases of the template class, rather than the
9841 instantiated class. In addition, lookups that were not
9842 ambiguous before may be ambiguous now. Therefore, we perform
9843 the lookup again. */
9850 {
9857 }
9861 /* If lookup found a single function, mark it as used at this
9862 point. (If it lookup found multiple functions the one selected
9863 later by overload resolution will be marked as used at that
9864 point.) */
9870 /* Add back the template arguments, if present. */
9875 template_args);
9876 /* Update the conversion operator type. */
9883 qualifying_scope,
9884 object_type);
9885 }
9887 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9888 true if the qualified-id will be a postfix-expression in-and-of
9889 itself; false if more of the postfix-expression follows the
9890 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9891 of "&". */
9893 static tree
9897 {
9898 tree expr;
9899 tree scope;
9900 tree name;
9902 tree template_args;
9906 /* Figure out what name to look up. */
9909 {
9916 }
9917 else
9918 {
9921 }
9923 /* Substitute into the qualifying scope. When there are no ARGS, we
9924 are just trying to simplify a non-dependent expression. In that
9925 case the qualifying scope may be dependent, and, in any case,
9926 substituting will not help. */
9929 {
9932 }
9933 else
9937 {
9943 }
9946 {
9948 {
9949 /* A BIT_NOT_EXPR is used to represent a destructor. */
9951 {
9955 }
9956 else
9959 }
9960 else
9964 {
9966 {
9970 }
9972 }
9973 }
9976 {
9978 scope);
9979 /* Remember that there was a reference to this entity. */
9981 }
9984 {
9990 }
9999 {
10000 expr = (adjust_result_of_qualified_name_lookup
10002 expr = (finish_qualified_id_expr
10006 }
10008 /* Expressions do not generally have reference type. */
10010 /* However, if we're about to form a pointer-to-member, we just
10011 want the referenced member referenced. */
10016 }
10018 /* Like tsubst, but deals with expressions. This function just replaces
10019 template parms; to finish processing the resultant expression, use
10020 tsubst_expr. */
10022 static tree
10024 {
10026 tree r;
10034 {
10039 {
10040 tree c;
10041 /* This can happen for a parameter name used later in a function
10042 declaration (such as in a late-specified return type). Just
10043 make a dummy decl, since it's only used for its type. */
10045 /* We copy T because want to tsubst the PARM_DECL only,
10046 not the following PARM_DECLs that are chained to T. */
10049 /* Give it the template pattern as its context; its true context
10050 hasn't been instantiated yet and this is good enough for
10051 mangling. */
10053 }
10061 {
10062 tree enum_type;
10063 tree v;
10067 /* There is no need to substitute into namespace-scope
10068 enumerators. */
10071 /* If ARGS is NULL, then T is known to be non-dependent. */
10075 /* Unfortunately, we cannot just call lookup_name here.
10076 Consider:
10078 template <int I> int f() {
10079 enum E { a = I };
10080 struct S { void g() { E e = a; } };
10081 };
10083 When we instantiate f<7>::S::g(), say, lookup_name is not
10084 clever enough to find f<7>::a. */
10085 enum_type
10095 /* We didn't find the name. That should never happen; if
10096 name-lookup found it during preliminary parsing, we
10097 should find it again here during instantiation. */
10099 }
10104 {
10105 tree ctx;
10110 {
10113 {
10117 }
10119 }
10120 }
10143 {
10144 /* Template template argument like the following example need
10145 special treatment:
10147 template <template <class> class TT> struct C {};
10148 template <class T> struct D {
10149 template <class U> struct E {};
10150 C<E> c; // #1
10151 };
10152 D<int> d; // #2
10154 We are processing the template argument `E' in #1 for
10155 the template instantiation #2. Originally, `E' is a
10156 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10157 have to substitute this with one having context `D<int>'. */
10161 }
10162 else
10163 /* Ordinary template template argument. */
10172 return build1
10178 {
10179 /* We only want to compute the number of arguments. */
10193 {
10200 else
10203 }
10204 else
10206 }
10207 /* Fall through */
10221 return build1
10226 {
10227 tree object;
10228 tree name;
10233 {
10237 }
10240 {
10250 }
10255 in_decl);
10256 else
10259 }
10297 return build_nt
10310 return build_nt
10317 {
10325 }
10330 {
10331 r = build_nt
10337 }
10340 {
10341 r = build_nt
10347 }
10350 {
10351 r = build_nt
10357 }
10360 {
10361 /* Substituted template arguments */
10370 }
10373 {
10393 }
10418 {
10421 }
10422 else
10426 /* This is handled by tsubst_copy_and_build. */
10431 in_decl),
10435 /* We shouldn't have built any of these during initial template
10436 generation. Instead, they should be built during instantiation
10437 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10454 }
10455 }
10457 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10459 static tree
10461 tree in_decl)
10462 {
10466 {
10472 {
10475 {
10481 }
10482 /* FALLTHRU */
10504 }
10505 }
10508 }
10510 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10512 static tree
10514 tree in_decl)
10515 {
10516 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10541 #undef RECUR
10542 }
10544 /* Substitute one OMP_FOR iterator. */
10546 static void
10551 {
10552 #define RECUR(NODE) \
10553 tsubst_expr ((NODE), args, complain, in_decl, \
10554 integral_constant_expression_p)
10563 {
10570 }
10574 {
10580 complain);
10581 else
10588 }
10591 {
10592 tree c;
10594 {
10605 }
10607 {
10612 {
10615 }
10616 }
10617 }
10623 else
10627 {
10638 {
10645 }
10646 else
10652 {
10658 }
10662 {
10669 }
10670 else
10676 }
10682 #undef RECUR
10683 }
10685 /* Like tsubst_copy for expressions, etc. but also does semantic
10686 processing. */
10688 static tree
10691 {
10692 #define RECUR(NODE) \
10693 tsubst_expr ((NODE), args, complain, in_decl, \
10694 integral_constant_expression_p)
10707 {
10709 {
10710 tree_stmt_iterator i;
10714 }
10729 else
10738 {
10739 tree decl;
10740 tree init;
10746 {
10749 tree decl;
10757 else
10759 }
10760 else
10761 {
10765 {
10766 /* By marking the declaration as instantiated, we avoid
10767 trying to instantiate it. Since instantiate_decl can't
10768 handle local variables, and since we've already done
10769 all that needs to be done, that's the right thing to
10770 do. */
10775 /* Anonymous aggregates are a special case. */
10777 else
10778 {
10782 {
10783 /* For __PRETTY_FUNCTION__ we have to adjust the
10784 initializer. */
10788 }
10789 else
10790 {
10794 /* If we had an initializer but it
10795 instantiated to nothing,
10796 value-initialize the object. This will
10797 only occur when the initializer was a
10798 pack expansion where the parameter packs
10799 used in that expansion were of length
10800 zero. */
10802 else
10804 }
10807 }
10808 }
10809 }
10811 /* A DECL_EXPR can also be used as an expression, in the condition
10812 clause of an if/for/while construct. */
10814 }
10852 {
10856 }
10864 else
10872 else
10904 /* Computed goto's must be tsubst'd into. On the other hand,
10905 non-computed gotos must not be; the identifier in question
10906 will have no binding. */
10908 else
10914 tmp = finish_asm_stmt
10920 {
10925 }
10930 {
10935 }
10936 else
10937 {
10942 else
10949 else
10955 else
10957 }
10961 {
10965 {
10967 /* Prevent instantiate_decl from trying to instantiate
10968 this variable. We've already done all that needs to be
10969 done. */
10972 }
10977 }
10985 {
10986 tree condition =
10988 args,
10995 }
11016 {
11031 integral_constant_expression_p);
11040 {
11044 }
11045 else
11046 {
11054 }
11068 }
11099 {
11104 }
11120 integral_constant_expression_p);
11121 }
11124 #undef RECUR
11125 }
11127 /* T is a postfix-expression that is not being used in a function
11128 call. Return the substituted version of T. */
11130 static tree
11132 tsubst_flags_t complain,
11133 tree in_decl)
11134 {
11138 else
11144 }
11146 /* Like tsubst but deals with expressions and performs semantic
11147 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11149 tree
11151 tree args,
11152 tsubst_flags_t complain,
11153 tree in_decl,
11156 {
11157 #define RECUR(NODE) \
11158 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11160 integral_constant_expression_p)
11162 tree op1;
11168 {
11171 /* Fall through. */
11173 {
11174 tree decl;
11175 cp_id_kind idk;
11180 {
11183 }
11185 /* Look up the name. */
11188 /* By convention, expressions use ERROR_MARK_NODE to indicate
11189 failure, not NULL_TREE. */
11195 integral_constant_expression_p,
11203 input_location);
11209 }
11212 {
11213 tree object;
11221 {
11224 }
11225 else
11232 else
11234 }
11237 {
11241 {
11242 /* A type conversion to reference type will be enclosed in
11243 such an indirect ref, but the substitution of the cast
11244 will have also added such an indirect ref. */
11247 }
11248 else
11251 }
11254 return build_nop
11263 {
11264 tree type;
11265 tree op;
11270 {
11275 }
11280 {
11293 }
11294 }
11312 complain);
11319 else
11321 in_decl);
11358 return build_x_binary_op
11362 ? ERROR_MARK
11366 ? ERROR_MARK
11369 complain);
11382 /* Fall through */
11387 {
11388 /* When there are no ARGS, we are trying to evaluate a
11389 non-dependent expression from the parser. Trying to do
11390 the substitutions may not work. */
11393 }
11394 else
11395 {
11401 }
11405 else
11410 {
11411 tree r = build_x_modify_expr
11415 complain);
11416 /* TREE_NO_WARNING must be set if either the expression was
11417 parenthesized or it uses an operator such as >>= rather
11418 than plain assignment. In the former case, it was already
11419 set and must be copied. In the latter case,
11420 build_x_modify_expr sets it and it must not be reset
11421 here. */
11425 }
11430 /* Remember that there was a reference to this entity. */
11436 {
11441 tree ret;
11445 else
11446 {
11450 }
11452 /* If there was an initializer in the original tree, but it
11453 instantiated to an empty list, then we should pass a
11454 non-NULL empty vector to tell build_new that it was an
11455 empty initializer() rather than no initializer. This can
11456 only happen when the initializer is a pack expansion whose
11457 parameter packs are of length zero. */
11460 else
11461 {
11465 else
11466 {
11469 }
11470 }
11477 complain);
11485 }
11488 return delete_sanity
11497 complain);
11500 {
11501 tree function;
11506 tree ret;
11509 /* When we parsed the expression, we determined whether or
11510 not Koenig lookup should be performed. */
11513 {
11518 }
11519 else
11520 {
11522 {
11528 }
11529 else
11533 in_decl,
11535 integral_constant_expression_p);
11539 }
11544 {
11550 else
11551 {
11552 /* Expand the pack expansion and push each entry onto
11553 CALL_ARGS. */
11556 {
11561 {
11566 }
11567 }
11568 else
11569 {
11570 /* A partial substitution. Add one entry. */
11572 }
11573 }
11574 }
11576 /* We do not perform argument-dependent lookup if normal
11577 lookup finds a non-function, in accordance with the
11578 expected resolution of DR 218. */
11581 /* If lookup found a member function, the Koenig lookup is
11582 not appropriate, even if an unqualified-name was used
11583 to denote the function. */
11586 /* Only do this when substitution turns a dependent call
11587 into a non-dependent call. */
11593 {
11597 }
11599 /* Remember that there was a reference to this entity. */
11606 {
11611 complain);
11612 else
11613 ret = (build_new_method_call
11619 complain));
11620 }
11621 else
11624 koenig_p,
11625 complain);
11630 }
11633 return build_x_conditional_expr
11637 complain);
11640 return finish_pseudo_destructor_expr
11646 {
11654 {
11655 /* We have pack expansions, so expand those and
11656 create a new list out of it. */
11659 tree chain;
11662 /* Expand the argument expressions. */
11670 /* Build the rest of the list. */
11675 /* Determine the number of arguments. */
11677 {
11680 }
11683 else
11684 {
11685 /* Since we only performed a partial substitution into
11686 the argument pack, we only return a single list
11687 node. */
11694 }
11696 /* Convert the argument vectors into a TREE_LIST */
11699 {
11700 /* Grab the Ith values. */
11701 i--;
11704 value
11708 /* Build the list (backwards). */
11710 }
11713 }
11729 }
11732 {
11733 tree object;
11734 tree object_type;
11735 tree member;
11739 /* Remember that there was a reference to this entity. */
11749 else
11755 {
11757 {
11762 {
11765 }
11767 {
11771 }
11772 }
11773 }
11776 {
11777 tree tmpl;
11778 tree args;
11780 /* Lookup the template functions now that we know what the
11781 scope is. */
11788 {
11791 args);
11792 member = (adjust_result_of_qualified_name_lookup
11794 object_type));
11795 }
11796 else
11797 {
11799 input_location);
11801 }
11802 }
11806 {
11808 {
11812 else
11815 }
11817 }
11823 complain);
11824 }
11827 return build_throw
11831 {
11839 tree r;
11844 /* digest_init will do the wrong thing if we let it. */
11848 /* We do not want to process the index of aggregate
11849 initializers as they are identifier nodes which will be
11850 looked up by digest_init. */
11856 {
11861 {
11862 /* Substitute into the pack expansion. */
11864 in_decl);
11867 ;
11869 /* Just move the argument into place. */
11871 else
11872 {
11873 /* Update the length of the final CONSTRUCTOR
11874 arguments vector, and note that we will need to
11875 copy.*/
11878 }
11879 }
11880 else
11882 }
11885 {
11890 idx++)
11891 {
11893 {
11898 }
11899 else
11901 }
11902 }
11911 }
11914 {
11919 }
11924 /* Fall through */
11927 {
11931 /* If the original type was a reference, we'll be wrapped in
11932 the appropriate INDIRECT_REF. */
11935 }
11940 in_decl));
11946 {
11955 }
11958 {
11964 integral_constant_expression_p);
11969 }
11973 /* As in finish_id_expression, we resolve enumeration constants
11974 to their underlying values. */
11976 {
11979 }
11983 /* Handle Objective-C++ constructs, if appropriate. */
11984 {
11985 tree subst
11990 }
11992 }
11994 #undef RECUR
11995 }
11997 /* Verify that the instantiated ARGS are valid. For type arguments,
11998 make sure that the type's linkage is ok. For non-type arguments,
11999 make sure they are constants if they are integral or enumerations.
12000 Emit an error under control of COMPLAIN, and return TRUE on error. */
12002 static bool
12004 {
12006 {
12016 }
12018 {
12019 /* [basic.link]: A name with no linkage (notably, the name
12020 of a class or enumeration declared in a local scope)
12021 shall not be used to declare an entity with linkage.
12022 This implies that names with no linkage cannot be used as
12023 template arguments. */
12027 {
12028 /* DR 488 makes use of a type with no linkage cause
12029 type deduction to fail. */
12031 {
12034 else
12037 }
12039 }
12040 /* In order to avoid all sorts of complications, we do not
12041 allow variably-modified types as template arguments. */
12043 {
12047 }
12048 }
12049 /* A non-type argument of integral or enumerated type must be a
12050 constant. */
12054 {
12058 }
12060 }
12062 static bool
12064 {
12069 {
12072 }
12076 }
12078 /* Instantiate the indicated variable or function template TMPL with
12079 the template arguments in TARG_PTR. */
12081 tree
12083 {
12084 tree fndecl;
12085 tree gen_tmpl;
12086 tree spec;
12087 HOST_WIDE_INT saved_processing_template_decl;
12094 /* If this function is a clone, handle it specially. */
12096 {
12097 tree spec;
12098 tree clone;
12101 complain);
12105 /* Look for the clone. */
12109 /* We should always have found the clone by now. */
12112 }
12114 /* Check to see if we already have this specialization. */
12122 {
12123 /* The TMPL is a partial instantiation. To get a full set of
12124 arguments we must add the arguments used to perform the
12125 partial instantiation. */
12127 targ_ptr);
12129 /* Check to see if we already have this specialization. */
12134 }
12137 complain))
12140 /* We are building a FUNCTION_DECL, during which the access of its
12141 parameters and return types have to be checked. However this
12142 FUNCTION_DECL which is the desired context for access checking
12143 is not built yet. We solve this chicken-and-egg problem by
12144 deferring all checks until we have the FUNCTION_DECL. */
12147 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
12148 (because, for example, we have encountered a non-dependent
12149 function call in the body of a template function and must now
12150 determine which of several overloaded functions will be called),
12151 within the instantiation itself we are not processing a
12152 template. */
12155 /* Substitute template parameters to obtain the specialization. */
12162 /* Now we know the specialization, compute access previously
12163 deferred. */
12166 /* Some typedefs referenced from within the template code need to be access
12167 checked at template instantiation time, i.e now. These types were
12168 added to the template at parsing time. Let's get those and perfom
12169 the acces checks then. */
12175 /* The DECL_TI_TEMPLATE should always be the immediate parent
12176 template, not the most general template. */
12179 /* If we've just instantiated the main entry point for a function,
12180 instantiate all the alternate entry points as well. We do this
12181 by cloning the instantiation of the main entry point, not by
12182 instantiating the template clones. */
12187 }
12189 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
12190 NARGS elements of the arguments that are being used when calling
12191 it. TARGS is a vector into which the deduced template arguments
12192 are placed.
12194 Return zero for success, 2 for an incomplete match that doesn't resolve
12195 all the types, and 1 for complete failure. An error message will be
12196 printed only for an incomplete match.
12198 If FN is a conversion operator, or we are trying to produce a specific
12199 specialization, RETURN_TYPE is the return type desired.
12201 The EXPLICIT_TARGS are explicit template arguments provided via a
12202 template-id.
12204 The parameter STRICT is one of:
12206 DEDUCE_CALL:
12207 We are deducing arguments for a function call, as in
12208 [temp.deduct.call].
12210 DEDUCE_CONV:
12211 We are deducing arguments for a conversion function, as in
12212 [temp.deduct.conv].
12214 DEDUCE_EXACT:
12215 We are deducing arguments when doing an explicit instantiation
12216 as in [temp.explicit], when determining an explicit specialization
12217 as in [temp.expl.spec], or when taking the address of a function
12218 template, as in [temp.deduct.funcaddr]. */
12220 int
12222 tree explicit_targs,
12223 tree targs,
12226 tree return_type,
12227 unification_kind_t strict,
12229 {
12230 tree parms;
12231 tree fntype;
12239 {
12240 /* [temp.deduct]
12242 The specified template arguments must match the template
12243 parameters in kind (i.e., type, nontype, template), and there
12244 must not be more arguments than there are parameters;
12245 otherwise type deduction fails.
12247 Nontype arguments must match the types of the corresponding
12248 nontype template parameters, or must be convertible to the
12249 types of the corresponding nontype parameters as specified in
12250 _temp.arg.nontype_, otherwise type deduction fails.
12252 All references in the function type of the function template
12253 to the corresponding template parameters are replaced by the
12254 specified template argument values. If a substitution in a
12255 template parameter or in the function type of the function
12256 template results in an invalid type, type deduction fails. */
12259 tree converted_args;
12265 converted_args
12272 /* Substitute the explicit args into the function type. This is
12273 necessary so that, for instance, explicitly declared function
12274 arguments can match null pointed constants. If we were given
12275 an incomplete set of explicit args, we must not do semantic
12276 processing during substitution as we could create partial
12277 instantiations. */
12279 {
12283 /* Dig out the actual parm. */
12286 {
12289 }
12291 {
12294 }
12297 {
12299 tree targ;
12302 /* Mark the argument pack as "incomplete". We could
12303 still deduce more arguments during unification. */
12306 {
12310 }
12312 /* We have some incomplete argument packs. */
12314 }
12315 }
12318 /* Any substitution is guaranteed to be incomplete if there
12319 are incomplete argument packs, because we can still deduce
12320 more arguments. */
12322 else
12332 /* Place the explicitly specified arguments in TARGS. */
12335 }
12337 /* Never do unification on the 'this' parameter. */
12341 {
12350 }
12352 /* We allow incomplete unification without an error message here
12353 because the standard doesn't seem to explicitly prohibit it. Our
12354 callers must be ready to deal with unification failures in any
12355 event. */
12361 {
12364 /* Clear the "incomplete" flags on all argument packs. */
12366 {
12369 {
12372 }
12373 }
12374 }
12376 /* Now that we have bindings for all of the template arguments,
12377 ensure that the arguments deduced for the template template
12378 parameters have compatible template parameter lists. We cannot
12379 check this property before we have deduced all template
12380 arguments, because the template parameter types of a template
12381 template parameter might depend on prior template parameters
12382 deduced after the template template parameter. The following
12383 ill-formed example illustrates this issue:
12385 template<typename T, template<T> class C> void f(C<5>, T);
12387 template<int N> struct X {};
12389 void g() {
12390 f(X<5>(), 5l); // error: template argument deduction fails
12391 }
12393 The template parameter list of 'C' depends on the template type
12394 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
12395 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
12396 time that we deduce 'C'. */
12398 && !template_template_parm_bindings_ok_p
12403 /* All is well so far. Now, check:
12405 [temp.deduct]
12407 When all template arguments have been deduced, all uses of
12408 template parameters in nondeduced contexts are replaced with
12409 the corresponding deduced argument values. If the
12410 substitution results in an invalid type, as described above,
12411 type deduction fails. */
12412 {
12417 /* If we're looking for an exact match, check that what we got
12418 is indeed an exact match. It might not be if some template
12419 parameters are used in non-deduced contexts. */
12421 {
12424 tree sarg
12431 }
12432 }
12435 }
12437 /* Adjust types before performing type deduction, as described in
12438 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
12439 sections are symmetric. PARM is the type of a function parameter
12440 or the return type of the conversion function. ARG is the type of
12441 the argument passed to the call, or the type of the value
12442 initialized with the result of the conversion function.
12443 ARG_EXPR is the original argument expression, which may be null. */
12445 static int
12449 tree arg_expr)
12450 {
12454 {
12459 {
12460 /* Swap PARM and ARG throughout the remainder of this
12461 function; the handling is precisely symmetric since PARM
12462 will initialize ARG rather than vice versa. */
12467 }
12470 /* There is nothing to do in this case. */
12475 }
12478 {
12479 /* [temp.deduct.call]
12481 If P is not a reference type:
12483 --If A is an array type, the pointer type produced by the
12484 array-to-pointer standard conversion (_conv.array_) is
12485 used in place of A for type deduction; otherwise,
12487 --If A is a function type, the pointer type produced by
12488 the function-to-pointer standard conversion
12489 (_conv.func_) is used in place of A for type deduction;
12490 otherwise,
12492 --If A is a cv-qualified type, the top level
12493 cv-qualifiers of A's type are ignored for type
12494 deduction. */
12499 else
12501 }
12503 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
12504 of the form T&&, where T is a template parameter, and the argument
12505 is an lvalue, T is deduced as A& */
12513 /* [temp.deduct.call]
12515 If P is a cv-qualified type, the top level cv-qualifiers
12516 of P's type are ignored for type deduction. If P is a
12517 reference type, the type referred to by P is used for
12518 type deduction. */
12521 {
12524 }
12526 /* DR 322. For conversion deduction, remove a reference type on parm
12527 too (which has been swapped into ARG). */
12532 }
12534 /* Most parms like fn_type_unification.
12536 If SUBR is 1, we're being called recursively (to unify the
12537 arguments of a function or method parameter of a function
12538 template). */
12540 static int
12542 tree targs,
12543 tree xparms,
12547 unification_kind_t strict,
12549 {
12555 tree parms;
12565 {
12581 }
12583 again:
12591 {
12604 /* We can't deduce anything from this, but we might get all the
12605 template args from other function args. */
12608 /* Conversions will be performed on a function argument that
12609 corresponds with a function parameter that contains only
12610 non-deducible template parameters and explicitly specified
12611 template parameters. */
12613 {
12614 tree type;
12618 else
12625 flags))
12629 }
12632 {
12635 {
12636 /* [temp.deduct.type]
12638 A template-argument can be deduced from a pointer to
12639 function or pointer to member function argument if
12640 the set of overloaded functions does not contain
12641 function templates and at most one of a set of
12642 overloaded functions provides a unique match. */
12648 }
12653 }
12655 {
12660 arg_expr);
12666 }
12667 }
12673 {
12674 /* Unify the remaining arguments with the pack expansion type. */
12675 tree argvec;
12678 /* Allocate a TREE_VEC and copy in all of the arguments */
12683 /* Copy the parameter into parmvec. */
12689 /* Advance to the end of the list of parameters. */
12691 }
12693 /* Fail if we've reached the end of the parm list, and more args
12694 are present, and the parm list isn't variadic. */
12697 /* Fail if parms are left and they don't have default values. */
12705 {
12706 tree tparm;
12713 /* If this is an undeduced nontype parameter that depends on
12714 a type parameter, try another pass; its type may have been
12715 deduced from a later argument than the one from which
12716 this parameter can be deduced. */
12722 /* Core issue #226 (C++0x) [temp.deduct]:
12724 If a template argument has not been deduced, its
12725 default template argument, if any, is used.
12727 When we are in C++98 mode, TREE_PURPOSE will either
12728 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12729 to explicitly check cxx_dialect here. */
12731 {
12736 else
12737 {
12740 }
12741 }
12743 /* If the type parameter is a parameter pack, then it will
12744 be deduced to an empty parameter pack. */
12746 {
12747 tree arg;
12750 {
12754 }
12755 else
12762 }
12765 }
12768 }
12770 /* Subroutine of type_unification_real. Args are like the variables
12771 at the call site. ARG is an overloaded function (or template-id);
12772 we try deducing template args from each of the overloads, and if
12773 only one succeeds, we go with that. Modifies TARGS and returns
12774 true on success. */
12776 static bool
12778 tree targs,
12779 tree parm,
12780 tree arg,
12781 unification_kind_t strict,
12783 {
12790 {
12793 }
12794 else
12798 /* Handle `&x' where `x' is some static or non-static member
12799 function name. */
12805 /* Strip baselink information. */
12810 {
12811 /* If we got some explicit template args, we need to plug them into
12812 the affected templates before we try to unify, in case the
12813 explicit args will completely resolve the templates in question. */
12819 {
12830 {
12835 {
12838 }
12839 }
12841 }
12842 }
12845 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12846 -- but the deduction does not succeed because the expression is
12847 not just the function on its own. */
12849 else
12855 {
12858 }
12860 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12861 to function or pointer to member function argument if the set of
12862 overloaded functions does not contain function templates and at most
12863 one of a set of overloaded functions provides a unique match.
12865 So if we found multiple possibilities, we return success but don't
12866 deduce anything. */
12869 {
12874 }
12879 }
12881 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12882 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12883 different overloads deduce different arguments for a given parm.
12884 ADDR_P is true if the expression for which deduction is being
12885 performed was of the form "& fn" rather than simply "fn".
12887 Returns 1 on success. */
12889 static int
12891 tree orig_targs,
12892 tree targs,
12893 tree parm,
12894 tree arg,
12895 unification_kind_t strict,
12898 {
12900 tree tempargs;
12903 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12904 to function or pointer to member function argument if the set of
12905 overloaded functions does not contain function templates and at most
12906 one of a set of overloaded functions provides a unique match.
12908 So if this is a template, just return success. */
12920 /* We don't copy orig_targs for this because if we have already deduced
12921 some template args from previous args, unify would complain when we
12922 try to deduce a template parameter for the same argument, even though
12923 there isn't really a conflict. */
12930 /* First make sure we didn't deduce anything that conflicts with
12931 explicitly specified args. */
12933 {
12940 /* Since we're unifying against ourselves, we will fill in
12941 template args used in the function parm list with our own
12942 template parms. Discard them. */
12946 }
12949 {
12954 }
12957 }
12959 /* PARM is a template class (perhaps with unbound template
12960 parameters). ARG is a fully instantiated type. If ARG can be
12961 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12962 TARGS are as for unify. */
12964 static tree
12966 {
12967 tree copy_of_targs;
12974 /* We need to make a new template argument vector for the call to
12975 unify. If we used TARGS, we'd clutter it up with the result of
12976 the attempted unification, even if this class didn't work out.
12977 We also don't want to commit ourselves to all the unifications
12978 we've already done, since unification is supposed to be done on
12979 an argument-by-argument basis. In other words, consider the
12980 following pathological case:
12982 template <int I, int J, int K>
12983 struct S {};
12985 template <int I, int J>
12986 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12988 template <int I, int J, int K>
12989 void f(S<I, J, K>, S<I, I, I>);
12991 void g() {
12992 S<0, 0, 0> s0;
12993 S<0, 1, 2> s2;
12995 f(s0, s2);
12996 }
12998 Now, by the time we consider the unification involving `s2', we
12999 already know that we must have `f<0, 0, 0>'. But, even though
13000 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
13001 because there are two ways to unify base classes of S<0, 1, 2>
13002 with S<I, I, I>. If we kept the already deduced knowledge, we
13003 would reject the possibility I=1. */
13006 /* If unification failed, we're done. */
13012 }
13014 /* Given a template type PARM and a class type ARG, find the unique
13015 base type in ARG that is an instance of PARM. We do not examine
13016 ARG itself; only its base-classes. If there is not exactly one
13017 appropriate base class, return NULL_TREE. PARM may be the type of
13018 a partial specialization, as well as a plain template type. Used
13019 by unify. */
13021 static tree
13023 {
13025 tree binfo;
13031 /* The type could not be completed. */
13034 /* Walk in inheritance graph order. The search order is not
13035 important, and this avoids multiple walks of virtual bases. */
13037 {
13041 {
13042 /* If there is more than one satisfactory baseclass, then:
13044 [temp.deduct.call]
13046 If they yield more than one possible deduced A, the type
13047 deduction fails.
13049 applies. */
13054 }
13055 }
13058 }
13060 /* Returns the level of DECL, which declares a template parameter. */
13062 static int
13064 {
13066 {
13076 }
13078 }
13080 /* Decide whether ARG can be unified with PARM, considering only the
13081 cv-qualifiers of each type, given STRICT as documented for unify.
13082 Returns nonzero iff the unification is OK on that basis. */
13084 static int
13086 {
13092 {
13093 /* Although a CVR qualifier is ignored when being applied to a
13094 substituted template parameter ([8.3.2]/1 for example), that
13095 does not apply during deduction [14.8.2.4]/1, (even though
13096 that is not explicitly mentioned, [14.8.2.4]/9 indicates
13097 this). Except when we're allowing additional CV qualifiers
13098 at the outer level [14.8.2.1]/3,1st bullet. */
13108 }
13119 }
13121 /* Determines the LEVEL and INDEX for the template parameter PARM. */
13122 void
13124 {
13128 {
13131 }
13132 else
13133 {
13136 }
13137 }
13139 /* Unifies the remaining arguments in PACKED_ARGS with the pack
13140 expansion at the end of PACKED_PARMS. Returns 0 if the type
13141 deduction succeeds, 1 otherwise. STRICT is the same as in
13142 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
13143 call argument list. We'll need to adjust the arguments to make them
13144 types. SUBR tells us if this is from a recursive call to
13145 type_unification_real. */
13146 int
13150 {
13151 tree parm
13158 /* Determine the parameter packs we will be deducing from the
13159 pattern, and record their current deductions. */
13162 {
13166 /* Determine the index and level of this parameter pack. */
13169 /* Keep track of the parameter packs and their corresponding
13170 argument packs. */
13173 }
13175 /* Loop through all of the arguments that have not yet been
13176 unified and unify each with the pattern. */
13178 {
13181 /* For each parameter pack, clear out the deduced value so that
13182 we can deduce it again. */
13184 {
13189 }
13191 /* Unify the pattern with the current argument. */
13192 {
13199 {
13202 /* This mirrors what we do in type_unification_real. */
13204 {
13206 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
13207 | UNIFY_ALLOW_MORE_CV_QUAL
13221 }
13224 {
13227 {
13228 /* [temp.deduct.type] A template-argument can be
13229 deduced from a pointer to function or pointer
13230 to member function argument if the set of
13231 overloaded functions does not contain function
13232 templates and at most one of a set of
13233 overloaded functions provides a unique
13234 match. */
13239 sub_strict)
13243 }
13246 {
13251 }
13252 }
13257 arg_strict |=
13260 }
13263 {
13266 }
13267 }
13269 /* For each parameter pack, collect the deduced value. */
13271 {
13277 }
13278 }
13280 /* Verify that the results of unification with the parameter packs
13281 produce results consistent with what we've seen before, and make
13282 the deduced argument packs available. */
13284 {
13290 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
13291 actually deduce anything. */
13299 {
13300 /* Prepend the explicit arguments onto NEW_ARGS. */
13306 /* Copy the explicit arguments. */
13311 /* Copy the deduced arguments. */
13315 }
13318 {
13319 tree result;
13324 /* Build the deduced *_ARGUMENT_PACK. */
13326 {
13331 }
13332 else
13337 /* Note the deduced argument packs for this parameter
13338 pack. */
13340 }
13344 {
13345 /* We only had the explicitly-provided arguments before, but
13346 now we have a complete set of arguments. */
13351 /* Keep the original deduced argument pack. */
13357 }
13359 new_args))
13360 /* Inconsistent unification of this parameter pack. */
13362 else
13363 {
13368 /* Keep the original deduced argument pack. */
13370 }
13371 }
13374 }
13376 /* Deduce the value of template parameters. TPARMS is the (innermost)
13377 set of template parameters to a template. TARGS is the bindings
13378 for those template parameters, as determined thus far; TARGS may
13379 include template arguments for outer levels of template parameters
13380 as well. PARM is a parameter to a template function, or a
13381 subcomponent of that parameter; ARG is the corresponding argument.
13382 This function attempts to match PARM with ARG in a manner
13383 consistent with the existing assignments in TARGS. If more values
13384 are deduced, then TARGS is updated.
13386 Returns 0 if the type deduction succeeds, 1 otherwise. The
13387 parameter STRICT is a bitwise or of the following flags:
13389 UNIFY_ALLOW_NONE:
13390 Require an exact match between PARM and ARG.
13391 UNIFY_ALLOW_MORE_CV_QUAL:
13392 Allow the deduced ARG to be more cv-qualified (by qualification
13393 conversion) than ARG.
13394 UNIFY_ALLOW_LESS_CV_QUAL:
13395 Allow the deduced ARG to be less cv-qualified than ARG.
13396 UNIFY_ALLOW_DERIVED:
13397 Allow the deduced ARG to be a template base class of ARG,
13398 or a pointer to a template base class of the type pointed to by
13399 ARG.
13400 UNIFY_ALLOW_INTEGER:
13401 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
13402 case for more information.
13403 UNIFY_ALLOW_OUTER_LEVEL:
13404 This is the outermost level of a deduction. Used to determine validity
13405 of qualification conversions. A valid qualification conversion must
13406 have const qualified pointers leading up to the inner type which
13407 requires additional CV quals, except at the outer level, where const
13408 is not required [conv.qual]. It would be normal to set this flag in
13409 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
13410 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
13411 This is the outermost level of a deduction, and PARM can be more CV
13412 qualified at this point.
13413 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
13414 This is the outermost level of a deduction, and PARM can be less CV
13415 qualified at this point. */
13417 static int
13419 {
13421 tree targ;
13422 tree tparm;
13425 /* I don't think this will do the right thing with respect to types.
13426 But the only case I've seen it in so far has been array bounds, where
13427 signedness is the only information lost, and I think that will be
13428 okay. */
13436 /* We can't deduce anything from this, but we might get all the
13437 template args from other function args. */
13440 /* If PARM uses template parameters, then we can't bail out here,
13441 even if ARG == PARM, since we won't record unifications for the
13442 template parameters. We might need them if we're trying to
13443 figure out which of two things is more specialized. */
13447 /* Handle init lists early, so the rest of the function can assume
13448 we're dealing with a type. */
13450 {
13455 /* We can only deduce from an initializer list argument if the
13456 parameter is std::initializer_list; otherwise this is a
13457 non-deduced context. */
13463 {
13466 {
13468 /* It should only be possible to get here for a call. */
13470 elt_strict |= maybe_adjust_types_for_deduction
13473 }
13477 }
13479 }
13481 /* Immediately reject some pairs that won't unify because of
13482 cv-qualification mismatches. */
13485 /* It is the elements of the array which hold the cv quals of an array
13486 type, and the elements might be template type parms. We'll check
13487 when we recurse. */
13489 /* We check the cv-qualifiers when unifying with template type
13490 parameters below. We want to allow ARG `const T' to unify with
13491 PARM `T' for example, when computing which of two templates
13492 is more specialized, for example. */
13506 {
13510 /* In a type which contains a nested-name-specifier, template
13511 argument values cannot be deduced for template parameters used
13512 within the nested-name-specifier. */
13524 /* The PARM is not one we're trying to unify. Just check
13525 to see if it matches ARG. */
13532 /* Check for mixed types and values. */
13540 {
13541 /* ARG must be constructed from a template class or a template
13542 template parameter. */
13547 {
13550 tree parm_parms
13551 = DECL_INNERMOST_TEMPLATE_PARMS
13556 /* The resolution to DR150 makes clear that default
13557 arguments for an N-argument may not be used to bind T
13558 to a template template parameter with fewer than N
13559 parameters. It is not safe to permit the binding of
13560 default arguments as an extension, as that may change
13561 the meaning of a conforming program. Consider:
13563 struct Dense { static const unsigned int dim = 1; };
13565 template <template <typename> class View,
13566 typename Block>
13567 void operator+(float, View<Block> const&);
13569 template <typename Block,
13570 unsigned int Dim = Block::dim>
13571 struct Lvalue_proxy { operator float() const; };
13573 void
13574 test_1d (void) {
13575 Lvalue_proxy<Dense> p;
13576 float b;
13577 b + p;
13578 }
13580 Here, if Lvalue_proxy is permitted to bind to View, then
13581 the global operator+ will be used; if they are not, the
13582 Lvalue_proxy will be converted to float. */
13584 argvec,
13586 tf_none,
13592 /* Deduce arguments T, i from TT<T> or TT<i>.
13593 We check each element of PARMVEC and ARGVEC individually
13594 rather than the whole TREE_VEC since they can have
13595 different number of elements. */
13602 /* Check if the parameters end in a pack, making them
13603 variadic. */
13612 {
13616 UNIFY_ALLOW_NONE))
13618 }
13623 UNIFY_ALLOW_NONE,
13627 }
13630 /* Fall through to deduce template name. */
13631 }
13635 {
13636 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
13638 /* Simple cases: Value already set, does match or doesn't. */
13643 }
13644 else
13645 {
13646 /* If PARM is `const T' and ARG is only `int', we don't have
13647 a match unless we are allowing additional qualification.
13648 If ARG is `const int' and PARM is just `T' that's OK;
13649 that binds `const int' to `T'. */
13654 /* Consider the case where ARG is `const volatile int' and
13655 PARM is `const T'. Then, T should be `volatile int'. */
13656 arg = cp_build_qualified_type_real
13661 /* Simple cases: Value already set, does match or doesn't. */
13667 /* Make sure that ARG is not a variable-sized array. (Note
13668 that were talking about variable-sized arrays (like
13669 `int[n]'), rather than arrays of unknown size (like
13670 `int[]').) We'll get very confused by such a type since
13671 the bound of the array will not be computable in an
13672 instantiation. Besides, such types are not allowed in
13673 ISO C++, so we can do as we please here. */
13677 /* Strip typedefs as in convert_template_argument. */
13679 }
13681 /* If ARG is a parameter pack or an expansion, we cannot unify
13682 against it unless PARM is also a parameter pack. */
13687 /* If the argument deduction results is a METHOD_TYPE,
13688 then there is a problem.
13689 METHOD_TYPE doesn't map to any real C++ type the result of
13690 the deduction can not be of that type. */
13704 /* The PARM is not one we're trying to unify. Just check
13705 to see if it matches ARG. */
13715 /* [temp.deduct.type] If, in the declaration of a function template
13716 with a non-type template-parameter, the non-type
13717 template-parameter is used in an expression in the function
13718 parameter-list and, if the corresponding template-argument is
13719 deduced, the template-argument type shall match the type of the
13720 template-parameter exactly, except that a template-argument
13721 deduced from an array bound may be of any integral type.
13722 The non-type parameter might use already deduced type parameters. */
13725 /* Template-parameter dependent expression. Just accept it for now.
13726 It will later be processed in convert_template_argument. */
13727 ;
13733 /* Convert the ARG to the type of PARM; the deduced non-type
13734 template argument must exactly match the types of the
13735 corresponding parameter. */
13738 /* We haven't deduced the type of this parameter yet. Try again
13739 later. */
13741 else
13744 /* If ARG is a parameter pack or an expansion, we cannot unify
13745 against it unless PARM is also a parameter pack. */
13754 {
13755 /* A pointer-to-member constant can be unified only with
13756 another constant. */
13760 /* Just unify the class member. It would be useless (and possibly
13761 wrong, depending on the strict flags) to unify also
13762 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13763 arg refer to the same variable, even if through different
13764 classes. For instance:
13766 struct A { int x; };
13767 struct B : A { };
13769 Unification of &A::x and &B::x must succeed. */
13772 }
13775 {
13779 /* [temp.deduct.call]
13781 A can be another pointer or pointer to member type that can
13782 be converted to the deduced A via a qualification
13783 conversion (_conv.qual_).
13785 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13786 This will allow for additional cv-qualification of the
13787 pointed-to types if appropriate. */
13790 /* The derived-to-base conversion only persists through one
13791 level of pointers. */
13796 }
13811 {
13812 tree parm_max;
13813 tree arg_max;
13817 /* Our representation of array types uses "N - 1" as the
13818 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13819 not an integer constant. We cannot unify arbitrarily
13820 complex expressions, so we eliminate the MINUS_EXPRs
13821 here. */
13825 {
13828 }
13832 {
13833 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13834 trying to unify the type of a variable with the type
13835 of a template parameter. For example:
13837 template <unsigned int N>
13838 void f (char (&) [N]);
13839 int g();
13840 void h(int i) {
13841 char a[g(i)];
13842 f(a);
13843 }
13845 Here, the type of the ARG will be "int [g(i)]", and
13846 may be a SAVE_EXPR, etc. */
13850 }
13852 /* If only one of the bounds used a MINUS_EXPR, compensate
13853 by adding one to the other bound. */
13856 integer_type_node,
13857 parm_max,
13858 integer_one_node);
13861 integer_type_node,
13862 arg_max,
13863 integer_one_node);
13867 }
13881 /* We have already checked cv-qualification at the top of the
13882 function. */
13886 /* As far as unification is concerned, this wins. Later checks
13887 will invalidate it if necessary. */
13890 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13891 /* Type INTEGER_CST can come from ordinary constant template args. */
13901 {
13910 UNIFY_ALLOW_NONE))
13913 }
13921 {
13928 strict);
13929 }
13932 {
13936 {
13937 /* First, we try to unify the PARM and ARG directly. */
13942 {
13943 /* Fallback to the special case allowed in
13944 [temp.deduct.call]:
13946 If P is a class, and P has the form
13947 template-id, then A can be a derived class of
13948 the deduced A. Likewise, if P is a pointer to
13949 a class of the form template-id, A can be a
13950 pointer to a derived class pointed to by the
13951 deduced A. */
13956 }
13957 }
13961 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13962 Then, we should unify `int' and `U'. */
13964 else
13965 /* There's no chance of unification succeeding. */
13970 }
13977 {
13980 tree a;
13986 /* CV qualifications for methods can never be deduced, they must
13987 match exactly. We need to check them explicitly here,
13988 because type_unification_real treats them as any other
13989 cv-qualified parameter. */
13991 && (!check_cv_quals_for_unify
14011 LOOKUP_NORMAL);
14012 }
14015 /* Unify a pointer to member with a pointer to member function, which
14016 deduces the type of the member as a function type. */
14018 {
14019 tree method_type;
14020 tree fntype;
14021 cp_cv_quals cv_quals;
14023 /* Check top-level cv qualifiers */
14031 /* Determine the type of the function we are unifying against. */
14033 fntype =
14037 /* Extract the cv-qualifiers of the member function from the
14038 implicit object parameter and place them on the function
14039 type to be restored later. */
14040 cv_quals =
14044 }
14052 strict);
14063 /* Matched cases are handled by the ARG == PARM test above. */
14068 {
14076 {
14078 {
14080 /* We can unify against something with a trailing
14081 parameter pack. */
14083 else
14084 /* Since there is something following the pack
14085 expansion, we cannot unify this template argument
14086 list. */
14088 }
14089 }
14092 /* If we don't have enough arguments to satisfy the parameters
14093 (not counting the pack expression at the end), or we have
14094 too many arguments for a parameter list that doesn't end in
14095 a pack expression, we can't unify. */
14100 /* Unify all of the parameters that precede the (optional)
14101 pack expression. */
14103 {
14107 }
14115 }
14121 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
14122 nodes. */
14126 /* Unification fails if we hit an error node. */
14132 /* We must be looking at an expression. This can happen with
14133 something like:
14135 template <int I>
14136 void foo(S<I>, S<I + 2>);
14138 This is a "nondeduced context":
14140 [deduct.type]
14142 The nondeduced contexts are:
14144 --A type that is a template-id in which one or more of
14145 the template-arguments is an expression that references
14146 a template-parameter.
14148 In these cases, we assume deduction succeeded, but don't
14149 actually infer any unifications. */
14154 else
14156 }
14157 }
14158 \f
14159 /* Note that DECL can be defined in this translation unit, if
14160 required. */
14162 static void
14164 {
14165 tree clone;
14169 }
14171 /* Called if RESULT is explicitly instantiated, or is a member of an
14172 explicitly instantiated class. */
14174 void
14176 {
14179 /* If this entity has already been written out, it's too late to
14180 make any modifications. */
14185 /* The TREE_PUBLIC flag for function declarations will have been
14186 set correctly by tsubst. */
14189 /* This might have been set by an earlier implicit instantiation. */
14194 else
14195 {
14197 /* Always make artificials weak. */
14200 /* For WIN32 we also want to put explicit instantiations in
14201 linkonce sections. */
14204 }
14206 /* If EXTERN_P, then this function will not be emitted -- unless
14207 followed by an explicit instantiation, at which point its linkage
14208 will be adjusted. If !EXTERN_P, then this function will be
14209 emitted here. In neither circumstance do we want
14210 import_export_decl to adjust the linkage. */
14212 }
14214 /* Given two function templates PAT1 and PAT2, return:
14216 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
14217 -1 if PAT2 is more specialized than PAT1.
14218 0 if neither is more specialized.
14220 LEN indicates the number of parameters we should consider
14221 (defaulted parameters should not be considered).
14223 The 1998 std underspecified function template partial ordering, and
14224 DR214 addresses the issue. We take pairs of arguments, one from
14225 each of the templates, and deduce them against each other. One of
14226 the templates will be more specialized if all the *other*
14227 template's arguments deduce against its arguments and at least one
14228 of its arguments *does* *not* deduce against the other template's
14229 corresponding argument. Deduction is done as for class templates.
14230 The arguments used in deduction have reference and top level cv
14231 qualifiers removed. Iff both arguments were originally reference
14232 types *and* deduction succeeds in both directions, the template
14233 with the more cv-qualified argument wins for that pairing (if
14234 neither is more cv-qualified, they both are equal). Unlike regular
14235 deduction, after all the arguments have been deduced in this way,
14236 we do *not* verify the deduced template argument values can be
14237 substituted into non-deduced contexts, nor do we have to verify
14238 that all template arguments have been deduced. */
14240 int
14242 {
14254 /* Remove the this parameter from non-static member functions. If
14255 one is a non-static member function and the other is not a static
14256 member function, remove the first parameter from that function
14257 also. This situation occurs for operator functions where we
14258 locate both a member function (with this pointer) and non-member
14259 operator (with explicit first operand). */
14261 {
14266 }
14268 {
14271 {
14272 len--;
14274 }
14275 }
14277 /* If only one is a conversion operator, they are unordered. */
14281 /* Consider the return type for a conversion function */
14283 {
14286 len++;
14287 }
14289 processing_template_decl++;
14292 /* Stop when an ellipsis is seen. */
14294 {
14303 {
14304 /* When both arguments are pack expansions, we need only
14305 unify the patterns themselves. */
14309 /* This is the last comparison we need to do. */
14311 }
14314 {
14317 }
14320 {
14323 }
14326 {
14327 /* Only of the args is a reference, see if we should apply
14328 array/function pointer decay to it. This is not part of
14329 DR214, but is, IMHO, consistent with the deduction rules
14330 for the function call itself, and with our earlier
14331 implementation of the underspecified partial ordering
14332 rules. (nathan). */
14334 {
14336 {
14339 /* FALLTHROUGH. */
14346 }
14347 }
14348 else
14349 {
14351 {
14354 /* FALLTHROUGH. */
14361 }
14362 }
14363 }
14369 {
14375 /* Setup the parameter vector, which contains only ARG1. */
14378 /* Setup the argument vector, which contains the remaining
14379 arguments. */
14388 /* We cannot deduce in the other direction, because ARG1 is
14389 a pack expansion but ARG2 is not. */
14391 }
14393 {
14399 /* Setup the parameter vector, which contains only ARG1. */
14402 /* Setup the argument vector, which contains the remaining
14403 arguments. */
14412 /* We cannot deduce in the other direction, because ARG2 is
14413 a pack expansion but ARG1 is not.*/
14415 }
14417 else
14418 {
14419 /* The normal case, where neither argument is a pack
14420 expansion. */
14423 }
14430 /* We've failed to deduce something in either direction.
14431 These must be unordered. */
14435 {
14436 /* Deduces in both directions, see if quals can
14437 disambiguate. Pretend the worse one failed to deduce. */
14442 }
14450 /* We have already processed all of the arguments in our
14451 handing of the pack expansion type. */
14456 }
14458 processing_template_decl--;
14460 /* All things being equal, if the next argument is a pack expansion
14461 for one function but not for the other, prefer the
14462 non-variadic function. */
14466 {
14471 }
14474 }
14476 /* Determine which of two partial specializations is more specialized.
14478 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
14479 to the first partial specialization. The TREE_VALUE is the
14480 innermost set of template parameters for the partial
14481 specialization. PAT2 is similar, but for the second template.
14483 Return 1 if the first partial specialization is more specialized;
14484 -1 if the second is more specialized; 0 if neither is more
14485 specialized.
14487 See [temp.class.order] for information about determining which of
14488 two templates is more specialized. */
14490 static int
14492 {
14493 tree targs;
14501 /* Just like what happens for functions, if we are ordering between
14502 different class template specializations, we may encounter dependent
14503 types in the arguments, and we need our dependency check functions
14504 to behave correctly. */
14510 {
14513 }
14519 {
14522 }
14525 /* In the case of a tie where at least one of the class templates
14526 has a parameter pack at the end, the template with the most
14527 non-packed parameters wins. */
14529 && any_deductions
14532 {
14538 /* We don't count the pack expansion at the end. */
14548 }
14551 }
14553 /* Return the template arguments that will produce the function signature
14554 DECL from the function template FN, with the explicit template
14555 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
14556 also match. Return NULL_TREE if no satisfactory arguments could be
14557 found. */
14559 static tree
14561 {
14564 tree decl_type;
14565 tree decl_arg_types;
14568 tree arg;
14570 /* Substitute the explicit template arguments into the type of DECL.
14571 The call to fn_type_unification will handle substitution into the
14572 FN. */
14575 {
14576 tree tmpl;
14577 tree converted_args;
14581 else
14582 /* We can get here for some invalid specializations. */
14585 converted_args
14588 tf_none,
14597 }
14599 /* Never do unification on the 'this' parameter. */
14618 }
14620 /* Return the innermost template arguments that, when applied to a
14621 template specialization whose innermost template parameters are
14622 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
14623 ARGS.
14625 For example, suppose we have:
14627 template <class T, class U> struct S {};
14628 template <class T> struct S<T*, int> {};
14630 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
14631 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
14632 int}. The resulting vector will be {double}, indicating that `T'
14633 is bound to `double'. */
14635 static tree
14637 {
14639 tree deduced_args;
14640 tree innermost_deduced_args;
14644 {
14648 innermost_deduced_args);
14649 }
14650 else
14656 UNIFY_ALLOW_NONE))
14663 /* Verify that nondeduced template arguments agree with the type
14664 obtained from argument deduction.
14666 For example:
14668 struct A { typedef int X; };
14669 template <class T, class U> struct C {};
14670 template <class T> struct C<T, typename T::X> {};
14672 Then with the instantiation `C<A, int>', we can deduce that
14673 `T' is `A' but unify () does not check whether `typename T::X'
14674 is `int'. */
14677 /* We only need to check the innermost arguments; the other
14678 arguments will always agree. */
14683 /* Now that we have bindings for all of the template arguments,
14684 ensure that the arguments deduced for the template template
14685 parameters have compatible template parameter lists. See the use
14686 of template_template_parm_bindings_ok_p in fn_type_unification
14687 for more information. */
14692 }
14694 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
14695 Return the TREE_LIST node with the most specialized template, if
14696 any. If there is no most specialized template, the error_mark_node
14697 is returned.
14699 Note that this function does not look at, or modify, the
14700 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
14701 returned is one of the elements of INSTANTIATIONS, callers may
14702 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
14703 and retrieve it from the value returned. */
14705 tree
14707 {
14714 {
14720 fate--;
14725 fate++;
14730 {
14731 /* Equally specialized, move to next function. If there
14732 is no next function, nothing's most specialized. */
14737 }
14738 }
14741 /* Now verify that champ is better than everything earlier in the
14742 instantiation list. */
14750 {
14753 }
14755 processing_template_decl--;
14761 }
14763 /* If DECL is a specialization of some template, return the most
14764 general such template. Otherwise, returns NULL_TREE.
14766 For example, given:
14768 template <class T> struct S { template <class U> void f(U); };
14770 if TMPL is `template <class U> void S<int>::f(U)' this will return
14771 the full template. This function will not trace past partial
14772 specializations, however. For example, given in addition:
14774 template <class T> struct S<T*> { template <class U> void f(U); };
14776 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14777 `template <class T> template <class U> S<T*>::f(U)'. */
14779 tree
14781 {
14782 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14783 an immediate specialization. */
14785 {
14789 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14790 template friend. */
14795 }
14797 /* Look for more and more general templates. */
14799 {
14800 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14801 (See cp-tree.h for details.) */
14809 /* Stop if we run into an explicitly specialized class template. */
14816 }
14819 }
14821 /* Return the most specialized of the class template partial
14822 specializations of TMPL which can produce TYPE, a specialization of
14823 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14824 a _TYPE node corresponding to the partial specialization, while the
14825 TREE_PURPOSE is the set of template arguments that must be
14826 substituted into the TREE_TYPE in order to generate TYPE.
14828 If the choice of partial specialization is ambiguous, a diagnostic
14829 is issued, and the error_mark_node is returned. If there are no
14830 partial specializations of TMPL matching TYPE, then NULL_TREE is
14831 returned. */
14833 static tree
14835 {
14837 tree t;
14838 tree champ;
14841 tree args;
14847 /* For determining which partial specialization to use, only the
14848 innermost args are interesting. */
14850 {
14853 }
14856 {
14857 tree partial_spec_args;
14858 tree spec_args;
14863 {
14868 /* Discard the outer levels of args, and then substitute in the
14869 template args from the enclosing class. */
14871 partial_spec_args = tsubst_template_args
14874 /* PARMS already refers to just the innermost parms, but the
14875 template parms in partial_spec_args had their levels lowered
14876 by tsubst, so we need to do the same for the parm list. We
14877 can't just tsubst the TREE_VEC itself, as tsubst wants to
14878 treat a TREE_VEC as an argument vector. */
14885 }
14887 partial_spec_args,
14888 args);
14890 {
14895 }
14896 }
14906 {
14909 ;
14910 else
14911 {
14913 {
14916 {
14919 }
14920 }
14922 }
14923 }
14927 {
14930 {
14933 }
14934 }
14937 {
14941 {
14944 }
14946 }
14949 }
14951 /* Explicitly instantiate DECL. */
14953 void
14955 {
14960 /* An error occurred, for which grokdeclarator has already issued
14961 an appropriate message. */
14964 {
14967 }
14969 {
14970 /* There is an asymmetry here in the way VAR_DECLs and
14971 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14972 the latter, the DECL we get back will be marked as a
14973 template instantiation, and the appropriate
14974 DECL_TEMPLATE_INFO will be set up. This does not happen for
14975 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14976 should handle VAR_DECLs as it currently handles
14977 FUNCTION_DECLs. */
14979 {
14982 }
14985 {
14988 }
14990 {
14995 }
14996 }
14998 {
15001 }
15002 else
15005 /* Check for various error cases. Note that if the explicit
15006 instantiation is valid the RESULT will currently be marked as an
15007 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
15008 until we get here. */
15011 {
15012 /* DR 259 [temp.spec].
15014 Both an explicit instantiation and a declaration of an explicit
15015 specialization shall not appear in a program unless the explicit
15016 instantiation follows a declaration of the explicit specialization.
15018 For a given set of template parameters, if an explicit
15019 instantiation of a template appears after a declaration of an
15020 explicit specialization for that template, the explicit
15021 instantiation has no effect. */
15023 }
15025 {
15026 /* [temp.spec]
15028 No program shall explicitly instantiate any template more
15029 than once.
15031 We check DECL_NOT_REALLY_EXTERN so as not to complain when
15032 the first instantiation was `extern' and the second is not,
15033 and EXTERN_P for the opposite case. */
15036 /* If an "extern" explicit instantiation follows an ordinary
15037 explicit instantiation, the template is instantiated. */
15040 }
15042 {
15045 }
15047 {
15050 }
15053 ;
15055 {
15058 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
15061 }
15062 else
15070 }
15072 static void
15074 {
15080 {
15083 }
15084 }
15086 /* Called from do_type_instantiation through binding_table_foreach to
15087 do recursive instantiation for the type bound in ENTRY. */
15088 static void
15090 {
15096 }
15098 /* Called from do_type_instantiation to instantiate a member
15099 (a member function or a static member variable) of an
15100 explicitly instantiated class template. */
15101 static void
15103 {
15108 }
15110 /* Perform an explicit instantiation of template class T. STORAGE, if
15111 non-null, is the RID for extern, inline or static. COMPLAIN is
15112 nonzero if this is called from the parser, zero if called recursively,
15113 since the standard is unclear (as detailed below). */
15115 void
15117 {
15127 {
15130 }
15135 {
15138 t);
15140 }
15143 {
15145 {
15147 {
15150 "ISO C++ 1998 forbids the use of %<extern%> on "
15152 }
15153 else
15155 "ISO C++ forbids the use of %qE"
15157 }
15165 else
15166 {
15168 storage);
15170 }
15171 }
15174 {
15175 /* DR 259 [temp.spec].
15177 Both an explicit instantiation and a declaration of an explicit
15178 specialization shall not appear in a program unless the explicit
15179 instantiation follows a declaration of the explicit specialization.
15181 For a given set of template parameters, if an explicit
15182 instantiation of a template appears after a declaration of an
15183 explicit specialization for that template, the explicit
15184 instantiation has no effect. */
15186 }
15188 {
15189 /* [temp.spec]
15191 No program shall explicitly instantiate any template more
15192 than once.
15194 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
15195 instantiation was `extern'. If EXTERN_P then the second is.
15196 These cases are OK. */
15203 /* If we've already instantiated the template, just return now. */
15206 }
15214 {
15215 tree tmp;
15217 /* In contrast to implicit instantiation, where only the
15218 declarations, and not the definitions, of members are
15219 instantiated, we have here:
15221 [temp.explicit]
15223 The explicit instantiation of a class template specialization
15224 implies the instantiation of all of its members not
15225 previously explicitly specialized in the translation unit
15226 containing the explicit instantiation.
15228 Of course, we can't instantiate member template classes, since
15229 we don't have any arguments for them. Note that the standard
15230 is unclear on whether the instantiation of the members are
15231 *explicit* instantiations or not. However, the most natural
15232 interpretation is that it should be an explicit instantiation. */
15247 }
15248 }
15250 /* Given a function DECL, which is a specialization of TMPL, modify
15251 DECL to be a re-instantiation of TMPL with the same template
15252 arguments. TMPL should be the template into which tsubst'ing
15253 should occur for DECL, not the most general template.
15255 One reason for doing this is a scenario like this:
15257 template <class T>
15258 void f(const T&, int i);
15260 void g() { f(3, 7); }
15262 template <class T>
15263 void f(const T& t, const int i) { }
15265 Note that when the template is first instantiated, with
15266 instantiate_template, the resulting DECL will have no name for the
15267 first parameter, and the wrong type for the second. So, when we go
15268 to instantiate the DECL, we regenerate it. */
15270 static void
15272 {
15273 /* The arguments used to instantiate DECL, from the most general
15274 template. */
15275 tree args;
15276 tree code_pattern;
15281 /* Make sure that we can see identifiers, and compute access
15282 correctly. */
15286 {
15287 tree decl_parm;
15288 tree pattern_parm;
15289 tree specs;
15302 specs);
15304 /* Merge parameter declarations. */
15307 pattern_parm
15311 {
15312 tree parm_type;
15313 tree attributes;
15318 NULL_TREE);
15324 {
15327 }
15330 }
15331 /* Merge any parameters that match with the function parameter
15332 pack. */
15334 {
15336 tree expanded_types;
15337 /* Expand the TYPE_PACK_EXPANSION that provides the types for
15338 the parameters in this function parameter pack. */
15343 {
15344 tree parm_type;
15345 tree attributes;
15348 /* Rename the parameter to include the index. */
15357 {
15360 }
15362 }
15363 }
15364 /* Merge additional specifiers from the CODE_PATTERN. */
15368 }
15374 else
15378 }
15380 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
15381 substituted to get DECL. */
15383 tree
15385 {
15388 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
15389 for the instantiation. This is not always the most general
15390 template. Consider, for example:
15392 template <class T>
15393 struct S { template <class U> void f();
15394 template <> void f<int>(); };
15396 and an instantiation of S<double>::f<int>. We want TD to be the
15397 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
15399 more general template. */
15401 /* We must also deal with friend templates. Given:
15403 template <class T> struct S {
15404 template <class U> friend void f() {};
15405 };
15407 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
15408 so far as the language is concerned, but that's still
15409 where we get the pattern for the instantiation from. On
15410 other hand, if the definition comes outside the class, say:
15412 template <class T> struct S {
15413 template <class U> friend void f();
15414 };
15415 template <class U> friend void f() {}
15417 we don't need to look any further. That's what the check for
15418 DECL_INITIAL is for. */
15422 {
15423 /* The present template, TD, should not be a definition. If it
15424 were a definition, we should be using it! Note that we
15425 cannot restructure the loop to just keep going until we find
15426 a template with a definition, since that might go too far if
15427 a specialization was declared, but not defined. */
15431 /* Fetch the more general template. */
15433 }
15436 }
15438 /* Produce the definition of D, a _DECL generated from a template. If
15439 DEFER_OK is nonzero, then we don't have to actually do the
15440 instantiation now; we just have to do it sometime. Normally it is
15441 an error if this is an explicit instantiation but D is undefined.
15442 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
15443 explicitly instantiated class template. */
15445 tree
15448 {
15450 tree gen_args;
15451 tree args;
15452 tree td;
15453 tree code_pattern;
15454 tree spec;
15455 tree gen_tmpl;
15461 /* This function should only be used to instantiate templates for
15462 functions and static member variables. */
15466 /* Variables are never deferred; if instantiation is required, they
15467 are instantiated right away. That allows for better code in the
15468 case that an expression refers to the value of the variable --
15469 if the variable has a constant value the referring expression can
15470 take advantage of that fact. */
15474 /* Don't instantiate cloned functions. Instead, instantiate the
15475 functions they cloned. */
15480 /* D has already been instantiated. It might seem reasonable to
15481 check whether or not D is an explicit instantiation, and, if so,
15482 stop here. But when an explicit instantiation is deferred
15483 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
15484 is set, even though we still need to do the instantiation. */
15487 /* If we already have a specialization of this declaration, then
15488 there's no reason to instantiate it. Note that
15489 retrieve_specialization gives us both instantiations and
15490 specializations, so we must explicitly check
15491 DECL_TEMPLATE_SPECIALIZATION. */
15499 /* This needs to happen before any tsubsting. */
15505 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
15506 for the instantiation. */
15510 /* We should never be trying to instantiate a member of a class
15511 template or partial specialization. */
15516 /* In the case of a friend template whose definition is provided
15517 outside the class, we may have too many arguments. Drop the
15518 ones we don't need. The same is true for specializations. */
15519 args = get_innermost_template_args
15521 else
15526 else
15529 /* We may be in the middle of deferred access check. Disable it now. */
15532 /* Unless an explicit instantiation directive has already determined
15533 the linkage of D, remember that a definition is available for
15534 this entity. */
15542 /* If D is a member of an explicitly instantiated class template,
15543 and no definition is available, treat it like an implicit
15544 instantiation. */
15547 {
15551 }
15554 {
15555 /* Recheck the substitutions to obtain any warning messages
15556 about ignoring cv qualifiers. */
15560 /* Make sure that we can see identifiers, and compute access
15561 correctly. D is already the target FUNCTION_DECL with the
15562 right context. */
15566 {
15569 d);
15570 /* Don't simply tsubst the function type, as that will give
15571 duplicate warnings about poor parameter qualifications.
15572 The function arguments are the same as the decl_arguments
15573 without the top level cv qualifiers. */
15575 }
15579 }
15581 /* Check to see whether we know that this template will be
15582 instantiated in some other file, as with "extern template"
15583 extension. */
15585 /* In general, we do not instantiate such templates... */
15587 /* ... but we instantiate inline functions so that we can inline
15588 them. An explicit instantiation declaration prohibits implicit
15589 instantiation of non-inline functions. With high levels of
15590 optimization, we would normally inline non-inline functions
15591 -- but we're not allowed to do that for "extern template" functions.
15592 Therefore, we check DECL_DECLARED_INLINE_P, rather than
15593 possibly_inlined_p. And ... */
15596 /* ... we instantiate static data members whose values are
15597 needed in integral constant expressions. */
15601 /* Defer all other templates, unless we have been explicitly
15602 forbidden from doing so. */
15604 template. */
15605 ! pattern_defined
15606 /* If it's OK to postpone instantiation, do so. */
15607 || defer_ok
15608 /* If this is a static data member that will be defined
15609 elsewhere, we don't want to instantiate the entire data
15610 member, but we do want to instantiate the initializer so that
15611 we can substitute that elsewhere. */
15613 {
15614 /* The definition of the static data member is now required so
15615 we must substitute the initializer. */
15619 {
15620 tree ns;
15621 tree init;
15627 args,
15632 LOOKUP_ONLYCONVERTING);
15635 }
15637 /* We restore the source position here because it's used by
15638 add_pending_template. */
15644 /* [temp.explicit]
15646 The definition of a non-exported function template, a
15647 non-exported member function template, or a non-exported
15648 member function or static data member of a class template
15649 shall be present in every translation unit in which it is
15650 explicitly instantiated. */
15654 /* ??? Historically, we have instantiated inline functions, even
15655 when marked as "extern template". */
15659 }
15660 /* Tell the repository that D is available in this translation unit
15661 -- and see if it is supposed to be instantiated here. */
15663 {
15664 /* In a PCH file, despite the fact that the repository hasn't
15665 requested instantiation in the PCH it is still possible that
15666 an instantiation will be required in a file that includes the
15667 PCH. */
15670 /* Instantiate inline functions so that the inliner can do its
15671 job, even though we'll not be emitting a copy of this
15672 function. */
15675 }
15681 /* Mark D as instantiated so that recursive calls to
15682 instantiate_decl do not try to instantiate it again. */
15685 /* Regenerate the declaration in case the template has been modified
15686 by a subsequent redeclaration. */
15689 /* We already set the file and line above. Reset them now in case
15690 they changed as a result of calling regenerate_decl_from_template. */
15694 {
15695 tree init;
15697 /* Clear out DECL_RTL; whatever was there before may not be right
15698 since we've reset the type of the declaration. */
15702 /* The initializer is placed in DECL_INITIAL by
15703 regenerate_decl_from_template. Pull it out so that
15704 finish_decl can process it. */
15709 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
15710 initializer. That function will defer actual emission until
15711 we have a chance to determine linkage. */
15714 /* Enter the scope of D so that access-checking works correctly. */
15718 }
15720 {
15721 htab_t saved_local_specializations;
15722 tree subst_decl;
15723 tree tmpl_parm;
15724 tree spec_parm;
15726 /* Save away the current list, in case we are instantiating one
15727 template from within the body of another. */
15730 /* Set up the list of local specializations. */
15732 hash_local_specialization,
15733 eq_local_specializations,
15734 NULL);
15736 /* Set up context. */
15739 /* Create substitution entries for the parameters. */
15744 {
15748 }
15750 {
15754 }
15756 {
15757 /* Register the (value) argument pack as a specialization of
15758 TMPL_PARM, then move on. */
15763 }
15766 /* Substitute into the body of the function. */
15771 /* Set the current input_location to the end of the function
15772 so that finish_function knows where we are. */
15775 /* We don't need the local specializations any more. */
15779 /* Finish the function. */
15782 }
15784 /* We're not deferring instantiation any more. */
15790 out:
15798 }
15800 /* Run through the list of templates that we wish we could
15801 instantiate, and instantiate any we can. RETRIES is the
15802 number of times we retry pending template instantiation. */
15804 void
15806 {
15810 /* Instantiating templates may trigger vtable generation. This in turn
15811 may require further template instantiations. We place a limit here
15812 to avoid infinite loop. */
15814 {
15818 " instantiating %q+D, possibly from virtual table generation"
15822 /* Pretend that we defined it. */
15825 }
15827 do
15828 {
15833 {
15838 {
15839 tree fn;
15842 {
15846 fn;
15854 }
15857 }
15858 else
15859 {
15862 {
15863 instantiation
15869 }
15873 }
15876 /* If INSTANTIATION has been instantiated, then we don't
15877 need to consider it again in the future. */
15879 else
15880 {
15883 }
15886 }
15888 }
15892 }
15894 /* Substitute ARGVEC into T, which is a list of initializers for
15895 either base class or a non-static data member. The TREE_PURPOSEs
15896 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15897 instantiate_decl. */
15899 static tree
15901 {
15905 {
15906 tree decl;
15907 tree init;
15913 {
15914 tree expr;
15915 tree arg;
15917 /* Expand the base class expansion type into separate base
15918 classes. */
15920 tf_warning_or_error,
15921 NULL_TREE);
15925 /* We'll be building separate TREE_LISTs of arguments for
15926 each base. */
15932 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15933 expand each argument in the TREE_VALUE of t. */
15939 /* VOID_TYPE_NODE is used to indicate
15940 value-initialization. */
15941 {
15944 }
15945 else
15946 {
15947 /* Substitute parameter packs into each argument in the
15948 TREE_LIST. */
15951 {
15952 tree expanded_exprs;
15954 /* Expand the argument. */
15956 expanded_exprs
15958 tf_warning_or_error,
15959 NULL_TREE);
15963 /* Prepend each of the expanded expressions to the
15964 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15966 {
15971 }
15972 }
15975 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15976 since we built them backwards. */
15978 {
15981 }
15982 }
15983 }
15986 {
15988 {
15992 }
15993 else
15994 {
16006 }
16009 {
16013 }
16014 }
16015 }
16017 }
16019 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
16021 static void
16023 {
16028 else
16030 }
16032 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
16033 is the instantiation (which should have been created with
16034 start_enum) and ARGS are the template arguments to use. */
16036 static void
16038 {
16039 tree e;
16042 {
16043 tree value;
16044 tree decl;
16047 /* Note that in a template enum, the TREE_VALUE is the
16048 CONST_DECL, not the corresponding INTEGER_CST. */
16053 /* Give this enumeration constant the correct access. */
16056 /* Actually build the enumerator itself. */
16058 }
16063 }
16065 /* DECL is a FUNCTION_DECL that is a template specialization. Return
16066 its type -- but without substituting the innermost set of template
16067 arguments. So, innermost set of template parameters will appear in
16068 the type. */
16070 tree
16072 {
16073 tree fn_type;
16074 tree tmpl;
16075 tree targs;
16076 tree tparms;
16084 /* There should be as many levels of arguments as there are levels
16085 of parameters. */
16091 /* No substitution is necessary. */
16092 ;
16093 else
16094 {
16096 tree partial_args;
16098 /* Replace the innermost level of the TARGS with NULL_TREEs to
16099 let tsubst know not to substitute for those parameters. */
16108 /* Disable access control as this function is used only during
16109 name-mangling. */
16114 /* Now, do the (partial) substitution to figure out the
16115 appropriate function type. */
16119 /* Substitute into the template parameters to obtain the real
16120 innermost set of parameters. This step is important if the
16121 innermost set of template parameters contains value
16122 parameters whose types depend on outer template parameters. */
16127 }
16130 }
16132 /* Return truthvalue if we're processing a template different from
16133 the last one involved in diagnostics. */
16134 int
16136 {
16138 }
16140 /* Remember current template involved in diagnostics. */
16141 void
16143 {
16145 }
16149 {
16151 }
16153 /* [temp.param] Check that template non-type parm TYPE is of an allowable
16154 type. Return zero for ok, nonzero for disallowed. Issue error and
16155 warning messages under control of COMPLAIN. */
16157 static int
16159 {
16174 }
16176 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
16177 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
16179 static bool
16181 {
16182 tree scope;
16184 /* [temp.dep.type]
16186 A type is dependent if it is:
16188 -- a template parameter. Template template parameters are types
16189 for us (since TYPE_P holds true for them) so we handle
16190 them here. */
16194 /* -- a qualified-id with a nested-name-specifier which contains a
16195 class-name that names a dependent type or whose unqualified-id
16196 names a dependent type. */
16199 /* -- a cv-qualified type where the cv-unqualified type is
16200 dependent. */
16202 /* -- a compound type constructed from any dependent type. */
16212 {
16213 tree arg_type;
16218 arg_type;
16223 }
16224 /* -- an array type constructed from any dependent type or whose
16225 size is specified by a constant expression that is
16226 value-dependent. */
16228 {
16233 }
16236 {
16237 /* If this is the TYPE_DOMAIN of an array type, consider it
16238 dependent. We already checked for value-dependence in
16239 compute_array_index_type. */
16241 }
16243 /* -- a template-id in which either the template name is a template
16244 parameter ... */
16247 /* ... or any of the template arguments is a dependent type or
16248 an expression that is type-dependent or value-dependent. */
16250 && (any_dependent_template_arguments_p
16254 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
16255 argument of the `typeof' expression is not type-dependent, then
16256 it should already been have resolved. */
16261 /* A template argument pack is dependent if any of its packed
16262 arguments are. */
16264 {
16270 }
16272 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
16273 be template parameters. */
16277 /* The standard does not specifically mention types that are local
16278 to template functions or local classes, but they should be
16279 considered dependent too. For example:
16281 template <int I> void f() {
16282 enum E { a = I };
16283 S<sizeof (E)> s;
16284 }
16286 The size of `E' cannot be known until the value of `I' has been
16287 determined. Therefore, `E' must be considered dependent. */
16294 /* Other types are non-dependent. */
16296 }
16298 /* Returns TRUE if TYPE is dependent, in the sense of
16299 [temp.dep.type]. */
16301 bool
16303 {
16304 /* If there are no template parameters in scope, then there can't be
16305 any dependent types. */
16307 {
16308 /* If we are not processing a template, then nobody should be
16309 providing us with a dependent type. */
16313 }
16315 /* If the type is NULL, we have not computed a type for the entity
16316 in question; in that case, the type is dependent. */
16320 /* Erroneous types can be considered non-dependent. */
16324 /* If we have not already computed the appropriate value for TYPE,
16325 do so now. */
16327 {
16330 }
16333 }
16335 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
16336 lookup. In other words, a dependent type that is not the current
16337 instantiation. */
16339 bool
16341 {
16344 }
16346 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
16348 static bool
16350 {
16351 tree scope;
16352 tree name;
16362 /* [temp.dep.expr]
16364 An id-expression is type-dependent if it contains a
16365 nested-name-specifier that contains a class-name that names a
16366 dependent type. */
16367 /* The suggested resolution to Core Issue 224 implies that if the
16368 qualifying type is the current class, then we must peek
16369 inside it. */
16378 }
16380 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
16381 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
16382 expression. */
16384 bool
16386 {
16390 /* A name declared with a dependent type. */
16395 {
16397 /* A name that has not been looked up -- must be dependent. */
16401 /* A non-type template parm. */
16405 /* A non-type template parm. */
16411 /* A constant with integral or enumeration type and is initialized
16412 with an expression that is value-dependent. */
16424 /* These expressions are value-dependent if the type to which
16425 the cast occurs is dependent or the expression being casted
16426 is value-dependent. */
16427 {
16433 /* A functional cast has a list of operands. */
16436 {
16437 /* If there are no operands, it must be an expression such
16438 as "int()". This should not happen for aggregate types
16439 because it would form non-constant expressions. */
16443 }
16449 }
16453 /* A `sizeof' expression is value-dependent if the operand is
16454 type-dependent or is a pack expansion. */
16470 /* A CALL_EXPR may appear in a constant expression if it is a
16471 call to a builtin function, e.g., __builtin_constant_p. All
16472 such calls are value-dependent. */
16476 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
16477 is value-dependent. */
16478 {
16487 }
16490 {
16494 }
16501 /* A constant expression is value-dependent if any subexpression is
16502 value-dependent. */
16504 {
16514 || (value_dependent_expression_p
16519 {
16522 /* In some cases, some of the operands may be missing.
16523 (For example, in the case of PREDECREMENT_EXPR, the
16524 amount to increment by may be missing.) That doesn't
16525 make the expression dependent. */
16527 && (value_dependent_expression_p
16531 }
16535 }
16536 }
16538 /* The expression is not value-dependent. */
16540 }
16542 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
16543 [temp.dep.expr]. */
16545 bool
16547 {
16554 /* An unresolved name is always dependent. */
16559 /* Some expression forms are never type-dependent. */
16570 /* The types of these expressions depends only on the type to which
16571 the cast occurs. */
16579 /* The types of these expressions depends only on the type created
16580 by the expression. */
16583 {
16584 /* For NEW_EXPR tree nodes created inside a template, either
16585 the object type itself or a TREE_LIST may appear as the
16586 operand 1. */
16589 /* This is an array type. We need to check array dimensions
16590 as well. */
16592 || value_dependent_expression_p
16594 else
16596 }
16600 type_dependent_expression_p))
16606 && (any_dependent_template_arguments_p
16618 {
16619 tree elt;
16623 {
16626 }
16628 }
16631 {
16636 {
16642 }
16643 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
16651 {
16656 }
16661 {
16665 }
16667 }
16672 }
16674 /* Like type_dependent_expression_p, but it also works while not processing
16675 a template definition, i.e. during substitution or mangling. */
16677 bool
16679 {
16685 }
16687 /* Returns TRUE if ARGS contains a type-dependent expression. */
16689 bool
16691 {
16693 tree arg;
16696 {
16699 }
16701 }
16703 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
16704 expressions) contains any value-dependent expressions. */
16706 bool
16708 {
16714 }
16716 /* Returns TRUE if the ARG (a template argument) is dependent. */
16718 bool
16720 {
16728 {
16732 {
16735 }
16738 }
16741 else
16744 }
16746 /* Returns true if ARGS (a collection of template arguments) contains
16747 any types that require structural equality testing. */
16749 bool
16751 {
16761 {
16764 {
16770 {
16771 /* Look inside the argument pack. */
16774 }
16777 {
16791 }
16792 }
16793 }
16796 }
16798 /* Returns true if ARGS (a collection of template arguments) contains
16799 any dependent arguments. */
16801 bool
16803 {
16813 {
16818 }
16821 }
16823 /* Returns TRUE if the template TMPL is dependent. */
16825 bool
16827 {
16829 {
16831 {
16835 }
16837 }
16839 /* Template template parameters are dependent. */
16843 /* So are names that have not been looked up. */
16847 /* So are member templates of dependent classes. */
16851 }
16853 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16855 bool
16857 {
16860 }
16862 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
16863 is dependent. */
16865 bool
16867 {
16874 {
16895 {
16899 }
16903 {
16907 {
16912 }
16913 }
16914 }
16917 }
16919 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16920 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16921 no such TYPE can be found. Note that this function peers inside
16922 uninstantiated templates and therefore should be used only in
16923 extremely limited situations. ONLY_CURRENT_P restricts this
16924 peering to the currently open classes hierarchy (which is required
16925 when comparing types). */
16927 tree
16929 {
16930 tree scope;
16931 tree name;
16932 tree decl;
16934 tree pushed_scope;
16935 tree result;
16940 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
16941 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
16942 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
16943 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
16944 identifier of the TYPENAME_TYPE anymore.
16945 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
16946 TYPENAME_TYPE instead, we avoid messing up with a possible
16947 typedef variant case. */
16950 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16951 it first before we can figure out what NAME refers to. */
16954 /* If we don't know what SCOPE refers to, then we cannot resolve the
16955 TYPENAME_TYPE. */
16958 /* If the SCOPE is a template type parameter, we have no way of
16959 resolving the name. */
16962 /* If the SCOPE is not the current instantiation, there's no reason
16963 to look inside it. */
16966 /* If SCOPE isn't the template itself, it will not have a valid
16967 TYPE_FIELDS list. */
16969 /* scope is either the template itself or a compatible instantiation
16970 like X<T>, so look up the name in the original template. */
16972 else
16973 /* scope is a partial instantiation, so we can't do the lookup or we
16974 will lose the template arguments. */
16976 /* Enter the SCOPE so that name lookup will be resolved as if we
16977 were in the class definition. In particular, SCOPE will no
16978 longer be considered a dependent type. */
16980 /* Look up the declaration. */
16985 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16986 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16991 {
16995 }
16998 {
16999 tree tmpl;
17000 tree args;
17001 /* Obtain the template and the arguments. */
17004 /* Instantiate the template. */
17010 }
17012 /* Leave the SCOPE. */
17016 /* If we failed to resolve it, return the original typename. */
17020 /* If lookup found a typename type, resolve that too. */
17022 {
17023 /* Ill-formed programs can cause infinite recursion here, so we
17024 must catch that. */
17028 }
17030 /* Qualify the resulting type. */
17036 }
17038 /* EXPR is an expression which is not type-dependent. Return a proxy
17039 for EXPR that can be used to compute the types of larger
17040 expressions containing EXPR. */
17042 tree
17044 {
17045 tree inner_expr;
17047 /* Preserve null pointer constants so that the type of things like
17048 "p == 0" where "p" is a pointer can be determined. */
17051 /* Preserve OVERLOADs; the functions must be available to resolve
17052 types. */
17063 /* There is no need to return a proxy for a variable. */
17066 /* Preserve string constants; conversions from string constants to
17067 "char *" are allowed, even though normally a "const char *"
17068 cannot be used to initialize a "char *". */
17071 /* Preserve arithmetic constants, as an optimization -- there is no
17072 reason to create a new node. */
17075 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
17076 There is at least one place where we want to know that a
17077 particular expression is a throw-expression: when checking a ?:
17078 expression, there are special rules if the second or third
17079 argument is a throw-expression. */
17098 /* If the type is unknown, it can't really be non-dependent */
17101 /* Otherwise, build a NON_DEPENDENT_EXPR.
17103 REFERENCE_TYPEs are not stripped for expressions in templates
17104 because doing so would play havoc with mangling. Consider, for
17105 example:
17107 template <typename T> void f<T& g>() { g(); }
17109 In the body of "f", the expression for "g" will have
17110 REFERENCE_TYPE, even though the standard says that it should
17111 not. The reason is that we must preserve the syntactic form of
17112 the expression so that mangling (say) "f<g>" inside the body of
17113 "f" works out correctly. Therefore, the REFERENCE_TYPE is
17114 stripped here. */
17116 }
17118 /* ARGS is a vector of expressions as arguments to a function call.
17119 Replace the arguments with equivalent non-dependent expressions.
17120 This modifies ARGS in place. */
17122 void
17124 {
17126 tree arg;
17129 {
17133 }
17134 }
17136 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
17137 with a level one deeper than the actual template parms. */
17139 tree
17141 {
17142 tree au;
17144 /* ??? Is it worth caching this for multiple autos at the same level? */
17156 }
17158 /* Replace auto in TYPE with std::initializer_list<auto>. */
17160 static tree
17162 {
17163 tree std_init_list = namespace_binding
17165 tree argvec;
17166 tree init_auto;
17168 {
17172 }
17182 }
17184 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
17185 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
17187 tree
17189 {
17194 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
17195 with either a new invented type template parameter U or, if the
17196 initializer is a braced-init-list (8.5.4), with
17197 std::initializer_list<U>. */
17210 {
17213 }
17218 }
17220 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
17221 result. */
17223 tree
17225 {
17226 tree argvec;
17235 }
17237 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
17239 bool
17241 {
17245 else
17247 }
17249 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
17250 appear as a type-specifier for the declaration in question, we don't
17251 have to look through the whole type. */
17253 tree
17255 {
17272 }
17274 /* For a given template T, return the list of typedefs referenced
17275 in T for which access check is needed at T instantiation time.
17276 T is either a FUNCTION_DECL or a RECORD_TYPE.
17277 Those typedefs were added to T by the function
17278 append_type_to_template_for_access_check. */
17280 tree
17282 {
17292 {
17297 }
17300 }
17302 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
17303 tied to T. That list of typedefs will be access checked at
17304 T instantiation time.
17305 T is either a FUNCTION_DECL or a RECORD_TYPE.
17306 TYPE_DECL is a TYPE_DECL node representing a typedef.
17307 SCOPE is the scope through which TYPE_DECL is accessed.
17309 This function is a subroutine of
17310 append_type_to_template_for_access_check. */
17312 static void
17314 tree type_decl,
17315 tree scope)
17316 {
17317 tree ti;
17324 && type_decl
17335 }
17337 /* Append TYPE_DECL to the template TEMPL.
17338 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
17339 At TEMPL instanciation time, TYPE_DECL will be checked to see
17340 if it can be accessed through SCOPE.
17342 e.g. consider the following code snippet:
17344 class C
17345 {
17346 typedef int myint;
17347 };
17349 template<class U> struct S
17350 {
17351 C::myint mi;
17352 };
17354 S<char> s;
17356 At S<char> instantiation time, we need to check the access of C::myint
17357 In other words, we need to check the access of the myint typedef through
17358 the C scope. For that purpose, this function will add the myint typedef
17359 and the scope C through which its being accessed to a list of typedefs
17360 tied to the template S. That list will be walked at template instantiation
17361 time and access check performed on each typedefs it contains.
17362 Note that this particular code snippet should yield an error because
17363 myint is private to C. */
17365 void
17367 tree type_decl,
17368 tree scope)
17369 {
17370 tree node;
17374 /* Make sure we don't append the type to the template twice. */
17376 node;
17378 {
17384 }
17387 }