| blob | 8fc9f743e1e033bc41d03b2da24900bf36a106cb |
1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
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". */
46 /* The type of functions taking a tree, and some additional data, and
47 returning an int. */
52 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
53 instantiations have been deferred, either because their definitions
54 were not yet available, or because we were putting off doing the
55 work. The TREE_PURPOSE of each entry is a SRCLOC indicating where
56 the instantiate request occurred; the TREE_VALUE is a either a DECL
57 (for a function or static data member), or a TYPE (for a class)
58 indicating what we are hoping to instantiate. */
71 /* A map from local variable declarations in the body of the template
72 presently being instantiated to the corresponding instantiated
73 local variables. */
76 #define obstack_chunk_alloc xmalloc
77 #define obstack_chunk_free free
79 #define UNIFY_ALLOW_NONE 0
80 #define UNIFY_ALLOW_MORE_CV_QUAL 1
81 #define UNIFY_ALLOW_LESS_CV_QUAL 2
82 #define UNIFY_ALLOW_DERIVED 4
83 #define UNIFY_ALLOW_INTEGER 8
84 #define UNIFY_ALLOW_OUTER_LEVEL 16
85 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
86 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
87 #define UNIFY_ALLOW_MAX_CORRECTION 128
90 virtual, or a base class of a virtual
91 base. */
93 type with the desired type. */
114 tree*));
173 /* Called once to initialize pt.c. */
175 void
177 {
181 }
183 /* Do any processing required when DECL (a member template declaration
184 using TEMPLATE_PARAMETERS as its innermost parameter list) is
185 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
186 it is a specialization, in which case the DECL itself is returned. */
188 tree
190 tree decl;
191 {
195 /* By returning NULL_TREE, the parser will just ignore this
196 declaration. We have already issued the error. */
199 {
200 /* Assume that the class is the only declspec. */
204 {
208 }
210 }
214 {
216 {
219 }
220 else
222 }
223 else
227 }
229 /* Returns the template nesting level of the indicated class TYPE.
231 For example, in:
232 template <class T>
233 struct A
234 {
235 template <class U>
236 struct B {};
237 };
239 A<T>::B<U> has depth two, while A<T> has depth one.
240 Both A<T>::B<int> and A<int>::B<U> have depth one, if
241 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
242 specializations.
244 This function is guaranteed to return 0 if passed NULL_TREE so
245 that, for example, `template_class_depth (current_class_type)' is
246 always safe. */
248 static int
250 tree type;
252 {
259 {
261 {
264 && ((count_specializations
268 }
269 else
270 {
273 && ((count_specializations
277 }
278 }
281 }
283 /* Returns the template nesting level of the indicated class TYPE.
284 Like template_class_depth_real, but instantiations do not count in
285 the depth. */
287 int
289 tree type;
290 {
292 }
294 /* Returns 1 if processing DECL as part of do_pending_inlines
295 needs us to push template parms. */
297 static int
299 tree decl;
300 {
306 }
308 /* Subroutine of maybe_begin_member_template_processing.
309 Push the template parms in PARMS, starting from LEVELS steps into the
310 chain, and ending at the beginning, since template parms are listed
311 innermost first. */
313 static void
315 tree parmlist;
317 {
325 current_template_parms
332 {
337 {
344 {
345 /* Make a CONST_DECL as is done in process_template_parm.
346 It is ugly that we recreate this here; the original
347 version built in process_template_parm is no longer
348 available. */
355 }
360 }
361 }
362 }
364 /* Restore the template parameter context for a member template or
365 a friend template defined in a class definition. */
367 void
369 tree decl;
370 {
371 tree parms;
375 {
380 {
383 }
386 }
388 /* Remember how many levels of template parameters we pushed so that
389 we can pop them later. */
396 }
398 /* Undo the effects of begin_member_template_processing. */
400 void
402 {
412 {
416 }
417 }
419 /* Returns non-zero iff T is a member template function. We must be
420 careful as in
422 template <class T> class C { void f(); }
424 Here, f is a template function, and a member, but not a member
425 template. This function does not concern itself with the origin of
426 T, only its present state. So if we have
428 template <class T> class C { template <class U> void f(U); }
430 then neither C<int>::f<char> nor C<T>::f<double> is considered
431 to be a member template. But, `template <class U> void
432 C<int>::f(U)' is considered a member template. */
434 int
436 tree t;
437 {
439 /* Anything that isn't a function or a template function is
440 certainly not a member template. */
443 /* A local class can't have member templates. */
448 /* If there are more levels of template parameters than
449 there are template classes surrounding the declaration,
450 then we have a member template. */
453 }
456 /* Returns non-zero iff T is a member template class. See
457 is_member_template for a description of what precisely constitutes
458 a member template. */
460 int
462 tree t;
463 {
465 /* Anything that isn't a class template, is certainly not a member
466 template. */
470 /* Anything whose context isn't a class type is surely not a
471 member template. */
474 /* If there are more levels of template parameters than there are
475 template classes surrounding the declaration, then we have a
476 member template. */
479 }
480 #endif
482 /* Return a new template argument vector which contains all of ARGS,
483 but has as its innermost set of arguments the EXTRA_ARGS. */
485 static tree
487 tree args;
488 tree extra_args;
489 {
490 tree new_args;
505 }
507 /* Like add_to_template_args, but only the outermost ARGS are added to
508 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
509 (EXTRA_ARGS) levels are added. This function is used to combine
510 the template arguments from a partial instantiation with the
511 template arguments used to attain the full instantiation from the
512 partial instantiation. */
514 static tree
516 tree args;
517 tree extra_args;
518 {
519 tree new_args;
521 /* If there are more levels of EXTRA_ARGS than there are ARGS,
522 something very fishy is going on. */
526 /* If *all* the new arguments will be the EXTRA_ARGS, just return
527 them. */
531 /* For the moment, we make ARGS look like it contains fewer levels. */
536 /* Now, we restore ARGS to its full dimensions. */
540 }
542 /* Return the N levels of innermost template arguments from the ARGS. */
544 tree
546 tree args;
548 {
549 tree new_args;
555 /* If N is 1, just return the innermost set of template arguments. */
559 /* If we're not removing anything, just return the arguments we were
560 given. */
566 /* Make a new set of arguments, not containing the outer arguments. */
573 }
575 /* We've got a template header coming up; push to a new level for storing
576 the parms. */
578 void
580 {
581 /* We use a non-tag-transparent scope here, which causes pushtag to
582 put tags in this scope, rather than in the enclosing class or
583 namespace scope. This is the right thing, since we want
584 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
585 global template class, push_template_decl handles putting the
586 TEMPLATE_DECL into top-level scope. For a nested template class,
587 e.g.:
589 template <class T> struct S1 {
590 template <class T> struct S2 {};
591 };
593 pushtag contains special code to call pushdecl_with_scope on the
594 TEMPLATE_DECL for S2. */
599 }
601 /* This routine is called when a specialization is declared. If it is
602 illegal to declare a specialization here, an error is reported. */
604 static void
606 {
609 /* [temp.expl.spec]
611 An explicit specialization shall be declared in the namespace of
612 which the template is a member, or, for member templates, in the
613 namespace of which the enclosing class or enclosing class
614 template is a member. An explicit specialization of a member
615 function, member class or static data member of a class template
616 shall be declared in the namespace of which the class template
617 is a member. */
620 scope);
622 /* [temp.expl.spec]
624 In an explicit specialization declaration for a member of a class
625 template or a member template that appears in namespace scope,
626 the member template and some of its enclosing class templates may
627 remain unspecialized, except that the declaration shall not
628 explicitly specialize a class member template if its enclosing
629 class templates are not explicitly specialized as well. */
632 }
634 /* We've just seen template <>. */
636 void
638 {
642 }
644 /* Called at then end of processing a declaration preceded by
645 template<>. */
647 void
649 {
652 }
654 /* Any template <>'s that we have seen thus far are not referring to a
655 function specialization. */
657 void
659 {
662 }
664 /* We've just seen a template header. If SPECIALIZATION is non-zero,
665 it was of the form template <>. */
667 static void
670 {
672 template_header_count++;
673 }
675 /* We're beginning an explicit instantiation. */
677 void
679 {
681 }
684 void
686 {
689 }
691 /* The TYPE is being declared. If it is a template type, that means it
692 is a partial specialization. Do appropriate error-checking. */
694 void
696 tree type;
697 {
699 {
702 {
705 {
709 }
713 }
716 }
719 }
721 /* Retrieve the specialization (in the sense of [temp.spec] - a
722 specialization is either an instantiation or an explicit
723 specialization) of TMPL for the given template ARGS. If there is
724 no such specialization, return NULL_TREE. The ARGS are a vector of
725 arguments, or a vector of vectors of arguments, in the case of
726 templates with more than one level of parameters. */
728 static tree
730 tree tmpl;
731 tree args;
732 {
733 tree s;
737 /* There should be as many levels of arguments as there are
738 levels of parameters. */
750 }
752 /* Like retrieve_specialization, but for local declarations. */
754 static tree
756 tree tmpl;
757 {
759 }
761 /* Returns non-zero iff DECL is a specialization of TMPL. */
763 int
765 tree decl;
766 tree tmpl;
767 {
768 tree t;
771 {
777 }
778 else
779 {
788 }
791 }
793 /* Register the specialization SPEC as a specialization of TMPL with
794 the indicated ARGS. Returns SPEC, or an equivalent prior
795 declaration, if available. */
797 static tree
799 tree spec;
800 tree tmpl;
801 tree args;
802 {
803 tree s;
809 /* This is the FUNCTION_DECL for a partial instantiation. Don't
810 register it; we want the corresponding TEMPLATE_DECL instead.
811 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
812 the more obvious `uses_template_parms (spec)' to avoid problems
813 with default function arguments. In particular, given
814 something like this:
816 template <class T> void f(T t1, T t = T())
818 the default argument expression is not substituted for in an
819 instantiation unless and until it is actually needed. */
822 /* There should be as many levels of arguments as there are
823 levels of parameters. */
831 {
834 /* We can sometimes try to re-register a specialization that we've
835 already got. In particular, regenerate_decl_from_template
836 calls duplicate_decls which will update the specialization
837 list. But, we'll still get called again here anyhow. It's
838 more convenient to simply allow this than to try to prevent it. */
842 {
844 {
846 {
849 {
851 fn);
853 }
854 else
855 {
856 /* This situation should occur only if the first
857 specialization is an implicit instantiation,
858 the second is an explicit specialization, and
859 the implicit instantiation has not yet been
860 used. That situation can occur if we have
861 implicitly instantiated a member function and
862 then specialized it later.
864 We can also wind up here if a friend
865 declaration that looked like an instantiation
866 turns out to be a specialization:
868 template <class T> void foo(T);
869 class S { friend void foo<>(int) };
870 template <> void foo(int);
872 We transform the existing DECL in place so that
873 any pointers to it become pointers to the
874 updated declaration.
876 If there was a definition for the template, but
877 not for the specialization, we want this to
878 look as if there is no definition, and vice
879 versa. */
884 }
885 }
887 {
890 }
891 }
892 }
893 }
899 }
901 /* Unregister the specialization SPEC as a specialization of TMPL.
902 Returns nonzero if the SPEC was listed as a specialization of
903 TMPL. */
905 static int
907 tree spec;
908 tree tmpl;
909 {
916 {
919 }
922 }
924 /* Like register_specialization, but for local declarations. We are
925 registering SPEC, an instantiation of TMPL. */
927 static void
929 tree spec;
930 tree tmpl;
931 {
936 }
938 /* Print the list of candidate FNS in an error message. */
940 void
942 tree fns;
943 {
944 tree fn;
949 {
950 tree f;
955 }
956 }
958 /* Returns the template (one of the functions given by TEMPLATE_ID)
959 which can be specialized to match the indicated DECL with the
960 explicit template args given in TEMPLATE_ID. The DECL may be
961 NULL_TREE if none is available. In that case, the functions in
962 TEMPLATE_ID are non-members.
964 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
965 specialization of a member template.
967 The template args (those explicitly specified and those deduced)
968 are output in a newly created vector *TARGS_OUT.
970 If it is impossible to determine the result, an error message is
971 issued. The error_mark_node is returned to indicate failure. */
973 static tree
975 need_member_template)
976 tree template_id;
977 tree decl;
980 {
981 tree fns;
982 tree targs;
983 tree explicit_targs;
998 /* Check for baselinks. */
1003 {
1006 }
1009 {
1010 tree tmpl;
1015 /* DECL might be a specialization of FN. */
1018 /* FN is an ordinary member function, and we need a
1019 specialization of a member template. */
1022 /* We can get IDENTIFIER_NODEs here in certain erroneous
1023 cases. */
1026 /* This is just an ordinary non-member function. Nothing can
1027 be a specialization of that. */
1030 /* Cannot specialize functions that are created implicitly. */
1032 else
1033 {
1034 tree decl_arg_types;
1036 /* This is an ordinary member function. However, since
1037 we're here, we can assume it's enclosing class is a
1038 template class. For example,
1040 template <typename T> struct S { void f(); };
1041 template <> void S<int>::f() {}
1043 Here, S<int>::f is a non-template, but S<int> is a
1044 template class. If FN has the same type as DECL, we
1045 might be in business. */
1048 /* Its enclosing class is an explicit specialization
1049 of a template class. This is not a candidate. */
1054 /* The return types differ. */
1057 /* Adjust the type of DECL in case FN is a static member. */
1064 decl_arg_types))
1065 /* They match! */
1069 }
1071 /* See whether this function might be a specialization of this
1072 template. */
1076 /* We cannot deduce template arguments that when used to
1077 specialize TMPL will produce DECL. */
1080 /* Save this template, and the arguments deduced. */
1082 }
1085 {
1086 /* We have:
1088 [temp.expl.spec]
1090 It is possible for a specialization with a given function
1091 signature to be instantiated from more than one function
1092 template. In such cases, explicit specification of the
1093 template arguments must be used to uniquely identify the
1094 function template specialization being specialized.
1096 Note that here, there's no suggestion that we're supposed to
1097 determine which of the candidate templates is most
1098 specialized. However, we, also have:
1100 [temp.func.order]
1102 Partial ordering of overloaded function template
1103 declarations is used in the following contexts to select
1104 the function template to which a function template
1105 specialization refers:
1107 -- when an explicit specialization refers to a function
1108 template.
1110 So, we do use the partial ordering rules, at least for now.
1111 This extension can only serve to make illegal programs legal,
1112 so it's safe. And, there is strong anecdotal evidence that
1113 the committee intended the partial ordering rules to apply;
1114 the EDG front-end has that behavior, and John Spicer claims
1115 that the committee simply forgot to delete the wording in
1116 [temp.expl.spec]. */
1119 {
1122 }
1123 }
1126 {
1130 }
1134 {
1140 }
1142 /* We have one, and exactly one, match. */
1144 {
1145 /* It was a specialization of an ordinary member function in a
1146 template class. */
1149 }
1151 /* It was a specialization of a template. */
1154 {
1159 }
1160 else
1163 }
1165 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1166 but with the default argument values filled in from those in the
1167 TMPL_TYPES. */
1169 static tree
1171 tmpl_types)
1172 tree spec_types;
1173 tree tmpl_types;
1174 {
1175 tree new_spec_types;
1183 /* Substitute into the rest of the list. */
1184 new_spec_types =
1188 /* Add the default argument for this parameter. */
1191 new_spec_types);
1192 }
1194 /* DECL is an explicit specialization. Replicate default arguments
1195 from the template it specializes. (That way, code like:
1197 template <class T> void f(T = 3);
1198 template <> void f(double);
1199 void g () { f (); }
1201 works, as required.) An alternative approach would be to look up
1202 the correct default arguments at the call-site, but this approach
1203 is consistent with how implicit instantiations are handled. */
1205 static void
1207 tree decl;
1208 {
1209 tree tmpl;
1210 tree spec_types;
1211 tree tmpl_types;
1212 tree new_spec_types;
1213 tree old_type;
1214 tree new_type;
1215 tree t;
1220 /* See if there's anything we need to do. */
1233 {
1234 /* Remove the this pointer, but remember the object's type for
1235 CV quals. */
1241 {
1242 /* DECL may contain more parameters than TMPL due to the extra
1243 in-charge parameter in constructors and destructors. */
1246 }
1248 {
1251 }
1252 }
1254 /* Compute the merged default arguments. */
1255 new_spec_types =
1258 /* Compute the new FUNCTION_TYPE. */
1260 {
1264 new_spec_types);
1267 /* Put the in-charge parameter back. */
1270 new_spec_types);
1274 new_spec_types);
1275 }
1276 else
1278 new_spec_types);
1284 }
1286 /* Check to see if the function just declared, as indicated in
1287 DECLARATOR, and in DECL, is a specialization of a function
1288 template. We may also discover that the declaration is an explicit
1289 instantiation at this point.
1291 Returns DECL, or an equivalent declaration that should be used
1292 instead if all goes well. Issues an error message if something is
1293 amiss. Returns error_mark_node if the error is not easily
1294 recoverable.
1296 FLAGS is a bitmask consisting of the following flags:
1298 2: The function has a definition.
1299 4: The function is a friend.
1301 The TEMPLATE_COUNT is the number of references to qualifying
1302 template classes that appeared in the name of the function. For
1303 example, in
1305 template <class T> struct S { void f(); };
1306 void S<int>::f();
1308 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1309 classes are not counted in the TEMPLATE_COUNT, so that in
1311 template <class T> struct S {};
1312 template <> struct S<int> { void f(); }
1313 template <> void S<int>::f();
1315 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1316 illegal; there should be no template <>.)
1318 If the function is a specialization, it is marked as such via
1319 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1320 is set up correctly, and it is added to the list of specializations
1321 for that template. */
1323 tree
1325 tree declarator;
1326 tree decl;
1329 {
1337 tmpl_spec_kind tsk;
1342 {
1345 {
1348 }
1350 {
1352 /* This could be something like:
1354 template <class T> void f(T);
1355 class S { friend void f<>(int); } */
1357 else
1358 {
1359 /* This case handles bogus declarations like template <>
1360 template <class T> void f<int>(); */
1363 declarator);
1365 }
1366 }
1370 /* The error has already been reported in
1371 check_specialization_scope. */
1377 /* Fall through. */
1388 decl);
1391 /* Fall through. */
1396 else
1402 {
1404 decl);
1406 }
1411 {
1412 /* For backwards compatibility, we accept:
1414 template <class T> struct S { void f(); };
1415 void S<int>::f() {} // Missing template <>
1417 That used to be legal C++. */
1419 pedwarn
1423 }
1428 {
1429 /* This case handles bogus declarations like template <>
1430 template <class T> void f<int>(); */
1434 declarator);
1435 else
1437 declarator);
1439 }
1442 /* This is a specialization of a member template, without
1443 specialization the containing class. Something like:
1445 template <class T> struct S {
1446 template <class U> void f (U);
1447 };
1448 template <> template <class U> void S<int>::f(U) {}
1450 That's a specialization -- but of the entire template. */
1456 }
1459 {
1463 {
1464 pedwarn
1467 }
1470 }
1473 {
1477 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1479 {
1480 tree fns;
1486 else
1489 declarator =
1491 }
1497 {
1499 /* A specialization in class scope. This is illegal,
1500 but the error will already have been flagged by
1501 check_specialization_scope. */
1503 else
1504 {
1505 /* It's not legal to write an explicit instantiation in
1506 class scope, e.g.:
1508 class C { template void f(); }
1510 This case is caught by the parser. However, on
1511 something like:
1513 template class C { void f(); };
1515 (which is illegal) we can get here. The error will be
1516 issued later. */
1517 ;
1518 }
1521 }
1523 {
1524 /* A friend declaration. We can't do much, because we don't
1525 know what this resolves to, yet. */
1530 }
1533 IDENTIFIER_NODE))
1534 {
1535 /* Find the list of functions in ctype that have the same
1536 name as the declared function. */
1543 {
1548 {
1549 /* From [temp.expl.spec]:
1551 If such an explicit specialization for the member
1552 of a class template names an implicitly-declared
1553 special member function (clause _special_), the
1554 program is ill-formed.
1556 Similar language is found in [temp.explicit]. */
1559 }
1562 }
1565 {
1569 }
1570 else
1571 {
1572 tree methods;
1574 /* For a type-conversion operator, we cannot do a
1575 name-based lookup. We might be looking for `operator
1576 int' which will be a specialization of `operator T'.
1577 So, we find *all* the conversion operators, and then
1578 select from them. */
1584 {
1588 /* There are no more conversion functions. */
1591 /* Glue all these conversion functions together
1592 with those we already have. */
1595 }
1596 }
1599 {
1603 }
1604 else
1606 }
1608 /* Figure out what exactly is being specialized at this point.
1609 Note that for an explicit instantiation, even one for a
1610 member function, we cannot tell apriori whether the
1611 instantiation is for a member template, or just a member
1612 function of a template class. Even if a member template is
1613 being instantiated, the member template arguments may be
1614 elided if they can be deduced from the rest of the
1615 declaration. */
1618 member_specialization);
1621 /* We couldn't figure out what this declaration was
1622 specializing. */
1624 else
1625 {
1629 {
1630 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1631 is done by do_decl_instantiation later. */
1637 {
1638 /* If TMPL is not the most general template (for
1639 example, if TMPL is a friend template that is
1640 injected into namespace scope), then there will
1641 be too many levels of TARGS. Remove some of them
1642 here. */
1644 tree new_targs;
1651 }
1654 }
1656 /* If this is a specialization of a member template of a
1657 template class. In we want to return the TEMPLATE_DECL,
1658 not the specialization of it. */
1660 {
1664 }
1666 /* If we thought that the DECL was a member function, but it
1667 turns out to be specializing a static member function,
1668 make DECL a static member function as well. */
1671 {
1674 }
1676 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1679 /* Inherit default function arguments from the template
1680 DECL is specializing. */
1683 /* This specialization has the same protection as the
1684 template it specializes. */
1689 /* This is not really a declaration of a specialization.
1690 It's just the name of an instantiation. But, it's not
1691 a request for an instantiation, either. */
1694 /* This is indeed a specialization. In case of constructors
1695 and destructors, we need in-charge and not-in-charge
1696 versions in V3 ABI. */
1699 /* Register this specialization so that we can find it
1700 again. */
1702 }
1703 }
1706 }
1708 /* TYPE is being declared. Verify that the use of template headers
1709 and such is reasonable. Issue error messages if not. */
1711 void
1713 tree type;
1714 {
1716 {
1717 /* We are in the scope of some `template <...>' header. */
1719 int context_depth
1724 /* This is OK; the template headers are for the context. We
1725 are actually too lenient here; like
1726 check_explicit_specialization we should consider the number
1727 of template types included in the actual declaration. For
1728 example,
1730 template <class T> struct S {
1731 template <class U> template <class V>
1732 struct I {};
1733 };
1735 is illegal, but:
1737 template <class T> struct S {
1738 template <class U> struct I;
1739 };
1741 template <class T> template <class U.
1742 struct S<T>::I {};
1744 is not. */
1745 ;
1747 /* There are two many template parameter lists. */
1749 }
1750 }
1752 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1753 parameters. These are represented in the same format used for
1754 DECL_TEMPLATE_PARMS. */
1757 tree parms1;
1758 tree parms2;
1759 {
1760 tree p1;
1761 tree p2;
1769 {
1781 {
1792 }
1793 }
1796 /* One set of parameters has more parameters lists than the
1797 other. */
1801 }
1803 /* Complain if DECL shadows a template parameter.
1805 [temp.local]: A template-parameter shall not be redeclared within its
1806 scope (including nested scopes). */
1808 void
1810 tree decl;
1811 {
1812 tree olddecl;
1814 /* If we're not in a template, we can't possibly shadow a template
1815 parameter. */
1819 /* Figure out what we're shadowing. */
1824 /* If there's no previous binding for this name, we're not shadowing
1825 anything, let alone a template parameter. */
1829 /* If we're not shadowing a template parameter, we're done. Note
1830 that OLDDECL might be an OVERLOAD (or perhaps even an
1831 ERROR_MARK), so we can't just blithely assume it to be a _DECL
1832 node. */
1836 /* We check for decl != olddecl to avoid bogus errors for using a
1837 name inside a class. We check TPFI to avoid duplicate errors for
1838 inline member templates. */
1845 }
1847 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1848 ORIG_LEVEL, DECL, and TYPE. */
1850 static tree
1855 tree decl;
1856 tree type;
1857 {
1866 }
1868 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1869 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1870 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1871 new one is created. */
1873 static tree
1875 tree index;
1876 tree type;
1878 {
1882 {
1883 tree decl
1886 type);
1887 tree t
1897 /* Template template parameters need this. */
1900 }
1903 }
1905 /* Process information from new template parameter NEXT and append it to the
1906 LIST being built. */
1908 tree
1911 {
1912 tree parm;
1914 tree defval;
1924 {
1929 else
1932 }
1933 else
1937 {
1939 /* is a const-param */
1944 /* [temp.param]
1946 The top-level cv-qualifiers on the template-parameter are
1947 ignored when determining its type. */
1950 /* A template parameter is not modifiable. */
1957 processing_template_decl,
1959 }
1960 else
1961 {
1962 tree t;
1966 {
1968 /* This is for distinguishing between real templates and template
1969 template parameters */
1973 }
1974 else
1975 {
1977 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1979 }
1986 processing_template_decl,
1988 }
1994 }
1996 /* The end of a template parameter list has been reached. Process the
1997 tree list into a parameter vector, converting each parameter into a more
1998 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1999 as PARM_DECLs. */
2001 tree
2003 tree parms;
2004 {
2009 current_template_parms
2014 {
2018 }
2023 }
2025 /* end_template_decl is called after a template declaration is seen. */
2027 void
2029 {
2035 /* This matches the pushlevel in begin_template_parm_list. */
2040 }
2042 /* Given a template argument vector containing the template PARMS.
2043 The innermost PARMS are given first. */
2045 tree
2047 {
2048 tree header;
2053 /* If there is only one level of template parameters, we do not
2054 create a TREE_VEC of TREE_VECs. Instead, we return a single
2055 TREE_VEC containing the arguments. */
2060 {
2066 {
2069 /* T will be a list if we are called from within a
2070 begin/end_template_parm_list pair, but a vector directly
2071 if within a begin/end_member_template_processing pair. */
2073 {
2079 else
2082 }
2083 }
2087 else
2089 }
2092 }
2094 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2095 template PARMS. Used by push_template_decl below. */
2097 static tree
2099 tree decl;
2100 tree parms;
2101 {
2106 {
2116 }
2119 }
2121 struct template_parm_data
2122 {
2123 /* The level of the template parameters we are currently
2124 processing. */
2127 /* The index of the specialization argument we are currently
2128 processing. */
2131 /* An array whose size is the number of template parameters. The
2132 elements are non-zero if the parameter has been used in any one
2133 of the arguments processed so far. */
2136 /* An array whose size is the number of template arguments. The
2137 elements are non-zero if the argument makes use of template
2138 parameters of this level. */
2140 };
2142 /* Subroutine of push_template_decl used to see if each template
2143 parameter in a partial specialization is used in the explicit
2144 argument list. If T is of the LEVEL given in DATA (which is
2145 treated as a template_parm_data*), then DATA->PARMS is marked
2146 appropriately. */
2148 static int
2150 tree t;
2152 {
2158 {
2161 }
2162 else
2163 {
2166 }
2169 {
2172 }
2174 /* Return zero so that for_each_template_parm will continue the
2175 traversal of the tree; we want to mark *every* template parm. */
2177 }
2179 /* Process the partial specialization DECL. */
2181 static tree
2183 tree decl;
2184 {
2198 /* We check that each of the template parameters given in the
2199 partial specialization is used in the argument list to the
2200 specialization. For example:
2202 template <class T> struct S;
2203 template <class T> struct S<T*>;
2205 The second declaration is OK because `T*' uses the template
2206 parameter T, whereas
2208 template <class T> struct S<int>;
2210 is no good. Even trickier is:
2212 template <class T>
2213 struct S1
2214 {
2215 template <class U>
2216 struct S2;
2217 template <class U>
2218 struct S2<T>;
2219 };
2221 The S2<T> declaration is actually illegal; it is a
2222 full-specialization. Of course,
2224 template <class U>
2225 struct S2<T (*)(U)>;
2227 or some such would have been OK. */
2235 {
2240 }
2243 {
2244 /* One of the template parms was not used in the
2245 specialization. */
2247 {
2250 }
2254 }
2256 /* [temp.class.spec]
2258 The argument list of the specialization shall not be identical to
2259 the implicit argument list of the primary template. */
2266 /* [temp.class.spec]
2268 A partially specialized non-type argument expression shall not
2269 involve template parameters of the partial specialization except
2270 when the argument expression is a simple identifier.
2272 The type of a template parameter corresponding to a specialized
2273 non-type argument shall not be dependent on a parameter of the
2274 specialization. */
2278 {
2283 /* This next line is the `argument expression is not just a
2284 simple identifier' condition and also the `specialized
2285 non-type argument' bit. */
2287 {
2290 else
2291 {
2292 /* Look at the corresponding template parameter,
2293 marking which template parameters its type depends
2294 upon. */
2295 tree type =
2297 i)));
2300 {
2301 /* We haven't yet initialized TPD2. Do so now. */
2302 tpd2.arg_uses_template_parms
2304 /* The number of parameters here is the number in the
2305 main template, which, as checked in the assertion
2306 above, is NARGS. */
2310 }
2312 /* Mark the template parameters. But this time, we're
2313 looking for the template parameters of the main
2314 template, not in the specialization. */
2323 {
2324 /* The type depended on some template parameters.
2325 If they are fully specialized in the
2326 specialization, that's OK. */
2331 {
2333 type,
2334 arg);
2336 }
2337 }
2338 }
2339 }
2340 }
2343 /* We've already got this specialization. */
2351 }
2353 /* Check that a template declaration's use of default arguments is not
2354 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2355 non-zero if DECL is the thing declared by a primary template.
2356 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2358 static void
2360 tree decl;
2361 tree parms;
2364 {
2367 tree parm_level;
2369 /* [temp.param]
2371 A default template-argument shall not be specified in a
2372 function template declaration or a function template definition, nor
2373 in the template-parameter-list of the definition of a member of a
2374 class template. */
2377 /* You can't have a function template declaration in a local
2378 scope, nor you can you define a member of a class template in a
2379 local scope. */
2385 /* If this is either a friend defined in the scope of the class
2386 or a member function. */
2391 current_class_type)))
2392 /* And, if it was a member function, it really was defined in
2393 the scope of the class. */
2395 /* We already checked these parameters when the template was
2396 declared, so there's no need to do it again now. This function
2397 was defined in class scope, but we're processing it's body now
2398 that the class is complete. */
2401 /* [temp.param]
2403 If a template-parameter has a default template-argument, all
2404 subsequent template-parameters shall have a default
2405 template-argument supplied. */
2407 {
2414 {
2419 {
2421 /* For better subsequent error-recovery, we indicate that
2422 there should have been a default argument. */
2424 }
2425 }
2426 }
2429 /* For an ordinary class template, default template arguments are
2430 allowed at the innermost level, e.g.:
2431 template <class T = int>
2432 struct S {};
2433 but, in a partial specialization, they're not allowed even
2434 there, as we have in [temp.class.spec]:
2436 The template parameter list of a specialization shall not
2437 contain default template argument values.
2439 So, for a partial specialization, or for a function template,
2440 we look at all of them. */
2441 ;
2442 else
2443 /* But, for a primary class template that is not a partial
2444 specialization we look at all template parameters except the
2445 innermost ones. */
2448 /* Figure out what error message to issue. */
2453 else
2457 /* If we're inside a class definition, there's no need to
2458 examine the parameters to the class itself. On the one
2459 hand, they will be checked when the class is defined, and,
2460 on the other, default arguments are legal in things like:
2461 template <class T = double>
2462 struct S { template <class U> void f(U); };
2463 Here the default argument for `S' has no bearing on the
2464 declaration of `f'. */
2466 else
2467 /* Check everything. */
2473 {
2481 {
2483 {
2486 }
2488 /* Clear out the default argument so that we are not
2489 confused later. */
2491 }
2493 /* At this point, if we're still interested in issuing messages,
2494 they must apply to classes surrounding the object declared. */
2497 }
2498 }
2500 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2501 parameters given by current_template_args, or reuses a
2502 previously existing one, if appropriate. Returns the DECL, or an
2503 equivalent one, if it is replaced via a call to duplicate_decls.
2505 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2507 tree
2509 tree decl;
2511 {
2512 tree tmpl;
2513 tree args;
2514 tree info;
2515 tree ctx;
2520 /* See if this is a partial specialization. */
2528 /* For a friend, we want the context of the friend function, not
2529 the type of which it is a friend. */
2533 /* In the case of a virtual function, we want the class in which
2534 it is defined. */
2536 else
2537 /* Otherwise, if we're currently defining some class, the DECL
2538 is assumed to be a member of the class. */
2547 /* See if this is a primary template. */
2551 {
2562 else
2564 }
2566 /* Check to see that the rules regarding the use of default
2567 arguments are not being violated. */
2582 {
2587 /* If DECL is a TYPE_DECL for a class-template, then there won't
2588 be DECL_LANG_SPECIFIC. The information equivalent to
2589 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2593 {
2594 /* Since a template declaration already existed for this
2595 class-type, we must be redeclaring it here. Make sure
2596 that the redeclaration is legal. */
2598 current_template_parms);
2599 /* We don't need to create a new TEMPLATE_DECL; just use the
2600 one we already had. */
2602 }
2603 else
2604 {
2610 {
2611 /* A specialization of a member template of a template
2612 class. */
2616 }
2617 }
2618 }
2619 else
2620 {
2625 {
2631 else
2632 {
2635 }
2636 }
2638 {
2641 }
2642 else
2649 {
2650 tree new_tmpl;
2652 /* The declaration is a specialization of a member
2653 template, declared outside the class. Therefore, the
2654 innermost template arguments will be NULL, so we
2655 replace them with the arguments determined by the
2656 earlier call to check_explicit_specialization. */
2659 new_tmpl
2670 args);
2672 }
2674 /* Make sure the template headers we got make sense. */
2679 {
2682 }
2683 else
2685 {
2690 {
2694 else
2698 }
2700 /* Perhaps we should also check that the parms are used in the
2701 appropriate qualifying scopes in the declarator? */
2705 else
2707 }
2708 }
2713 /* Push template declarations for global functions and types. Note
2714 that we do not try to push a global template friend declared in a
2715 template class; such a thing may well depend on the template
2716 parameters of the class. */
2727 {
2731 /* Don't change the name if we've already set it up. */
2734 }
2739 }
2741 tree
2743 tree decl;
2744 {
2746 }
2748 /* Called when a class template TYPE is redeclared with the indicated
2749 template PARMS, e.g.:
2751 template <class T> struct S;
2752 template <class T> struct S {}; */
2754 void
2756 tree type;
2757 tree parms;
2758 {
2759 tree tmpl;
2760 tree tmpl_parms;
2764 {
2767 }
2771 /* The type is nested in some template class. Nothing to worry
2772 about here; there are no new template parameters for the nested
2773 type. */
2780 {
2787 }
2790 {
2797 {
2801 }
2804 {
2805 /* We have in [temp.param]:
2807 A template-parameter may not be given default arguments
2808 by two different declarations in the same scope. */
2812 }
2815 /* Update the previous template parameters (which are the ones
2816 that will really count) with the new default value. */
2819 /* Update the new parameters, too; they'll be used as the
2820 parameters for any members. */
2822 }
2823 }
2825 /* Attempt to convert the non-type template parameter EXPR to the
2826 indicated TYPE. If the conversion is successful, return the
2827 converted value. If the conversion is unsuccessful, return
2828 NULL_TREE if we issued an error message, or error_mark_node if we
2829 did not. We issue error messages for out-and-out bad template
2830 parameters, but not simply because the conversion failed, since we
2831 might be just trying to do argument deduction. By the time this
2832 function is called, neither TYPE nor EXPR may make use of template
2833 parameters. */
2835 static tree
2837 tree type;
2838 tree expr;
2839 {
2842 /* A template-argument for a non-type, non-template
2843 template-parameter shall be one of:
2845 --an integral constant-expression of integral or enumeration
2846 type; or
2848 --the name of a non-type template-parameter; or
2850 --the name of an object or function with external linkage,
2851 including function templates and function template-ids but
2852 excluding non-static class members, expressed as id-expression;
2853 or
2855 --the address of an object or function with external linkage,
2856 including function templates and function template-ids but
2857 excluding non-static class members, expressed as & id-expression
2858 where the & is optional if the name refers to a function or
2859 array; or
2861 --a pointer to member expressed as described in _expr.unary.op_. */
2863 /* An integral constant-expression can include const variables or
2864 enumerators. Simplify things by folding them to their values,
2865 unless we're about to bind the declaration to a reference
2866 parameter. */
2872 /* OK for now. We'll check that it has external linkage later.
2873 Check this first since if expr_type is the unknown_type_node
2874 we would otherwise complain below. */
2875 ;
2878 {
2881 }
2886 /* If expr is the address of an overloaded function, we
2887 will get the unknown_type_node at this point. */
2889 {
2890 tree referent;
2898 else
2899 {
2901 {
2902 bad_argument:
2905 {
2908 else
2910 }
2916 }
2920 }
2923 {
2924 error ("string literal %E is not a valid template argument because it is the address of an object with static linkage",
2925 referent);
2927 }
2930 /* We'll check that it has external linkage later. */
2931 ;
2935 {
2938 }
2939 }
2943 {
2945 {
2946 non_constant:
2948 expr);
2950 }
2951 }
2952 else
2953 {
2956 }
2959 {
2963 /* For a non-type template-parameter of integral or enumeration
2964 type, integral promotions (_conv.prom_) and integral
2965 conversions (_conv.integral_) are applied. */
2969 /* It's safe to call digest_init in this case; we know we're
2970 just converting one integral constant expression to another. */
2974 /* Curiously, some TREE_CONSTANT integral expressions do not
2975 simplify to integer constants. For example, `3 % 0',
2976 remains a TRUNC_MOD_EXPR. */
2982 {
2986 {
2987 tree e;
2989 /* For a non-type template-parameter of type pointer to data
2990 member, qualification conversions (_conv.qual_) are
2991 applied. */
2994 /* The call to perform_qualification_conversions will
2995 insert a NOP_EXPR over EXPR to do express conversion,
2996 if necessary. But, that will confuse us if we use
2997 this (converted) template parameter to instantiate
2998 another template; then the thing will not look like a
2999 valid template argument. So, just make a new
3000 constant, of the appropriate type. */
3003 }
3005 {
3006 /* For a non-type template-parameter of type pointer to
3007 function, only the function-to-pointer conversion
3008 (_conv.func_) is applied. If the template-argument
3009 represents a set of overloaded functions (or a pointer to
3010 such), the matching function is selected from the set
3011 (_over.over_). */
3012 tree fns;
3013 tree fn;
3017 else
3026 {
3029 else
3031 }
3038 }
3039 else
3040 {
3041 /* For a non-type template-parameter of type pointer to
3042 object, qualification conversions (_conv.qual_) and the
3043 array-to-pointer conversion (_conv.array_) are applied.
3044 [Note: In particular, neither the null pointer conversion
3045 (_conv.ptr_) nor the derived-to-base conversion
3046 (_conv.ptr_) are applied. Although 0 is a valid
3047 template-argument for a non-type template-parameter of
3048 integral type, it is not a valid template-argument for a
3049 non-type template-parameter of pointer type.]
3051 The call to decay_conversion performs the
3052 array-to-pointer conversion, if appropriate. */
3057 else
3059 }
3060 }
3064 {
3067 /* If this expression already has reference type, get the
3068 underling object. */
3070 {
3074 }
3077 {
3078 /* For a non-type template-parameter of type reference to
3079 function, no conversions apply. If the
3080 template-argument represents a set of overloaded
3081 functions, the matching function is selected from the
3082 set (_over.over_). */
3083 tree fn;
3091 {
3093 /* Don't issue an error here; we might get a different
3094 function if the overloading had worked out
3095 differently. */
3097 else
3099 }
3106 }
3107 else
3108 {
3109 /* For a non-type template-parameter of type reference to
3110 object, no conversions apply. The type referred to by the
3111 reference may be more cv-qualified than the (otherwise
3112 identical) type of the template-argument. The
3113 template-parameter is bound directly to the
3114 template-argument, which must be an lvalue. */
3118 expr_type)
3121 }
3125 }
3129 {
3132 /* For a non-type template-parameter of type pointer to member
3133 function, no conversions apply. If the template-argument
3134 represents a set of overloaded member functions, the
3135 matching member function is selected from the set
3136 (_over.over_). */
3143 {
3144 /* A ptr-to-member constant. */
3147 else
3149 }
3162 }
3166 /* All non-type parameters must have one of these types. */
3169 }
3172 }
3174 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3175 template template parameters. Both PARM_PARMS and ARG_PARMS are
3176 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3177 or PARM_DECL.
3179 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3180 the case, then extra parameters must have default arguments.
3182 Consider the example:
3183 template <class T, class Allocator = allocator> class vector;
3184 template<template <class U> class TT> class C;
3186 C<vector> is a valid instantiation. PARM_PARMS for the above code
3187 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3188 T and Allocator) and OUTER_ARGS contains the argument that is used to
3189 substitute the TT parameter. */
3191 static int
3195 tsubst_flags_t complain;
3197 {
3207 /* The rule here is opposite of coerce_template_parms. */
3214 {
3226 {
3231 /* We encounter instantiations of templates like
3232 template <template <template <class> class> class TT>
3233 class C; */
3234 {
3240 outer_args))
3242 }
3246 /* The tsubst call is used to handle cases such as
3247 template <class T, template <T> class TT> class D;
3248 i.e. the parameter list of TT depends on earlier parameters. */
3257 }
3258 }
3260 }
3262 /* Convert the indicated template ARG as necessary to match the
3263 indicated template PARM. Returns the converted ARG, or
3264 error_mark_node if the conversion was unsuccessful. Error and
3265 warning messages are issued under control of COMPLAIN. This
3266 conversion is for the Ith parameter in the parameter list. ARGS is
3267 the full set of template arguments deduced so far. */
3269 static tree
3271 tree parm;
3272 tree arg;
3273 tree args;
3274 tsubst_flags_t complain;
3276 tree in_decl;
3277 {
3278 tree val;
3279 tree inner_args;
3287 {
3288 /* The template argument was the name of some
3289 member function. That's usually
3290 illegal, but static members are OK. In any
3291 case, grab the underlying fields/functions
3292 and issue an error later if required. */
3295 }
3308 {
3310 /* This is a template name used within the scope of the
3311 template. It could be the template, or it could be the
3312 instantiation. Choose whichever makes sense. */
3314 else
3316 }
3317 else
3318 /* It is a non-template class, or a specialization of a template
3319 class, or a non-template member of a template class. */
3333 {
3340 }
3342 {
3344 {
3346 {
3353 else
3355 }
3356 }
3358 }
3360 {
3362 {
3367 else
3369 }
3371 }
3374 {
3376 {
3378 /* The number of argument required is not known yet.
3379 Just accept it for now. */
3381 else
3382 {
3388 inner_args))
3389 {
3392 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3393 TEMPLATE_DECL. */
3397 }
3398 else
3399 {
3401 {
3405 }
3408 }
3409 }
3410 }
3411 else
3412 {
3415 {
3416 /* [basic.link]: A name with no linkage (notably, the
3417 name of a class or enumeration declared in a local
3418 scope) shall not be used to declare an entity with
3419 linkage. This implies that names with no linkage
3420 cannot be used as template arguments. */
3423 {
3425 pedwarn
3427 else
3428 error
3432 }
3433 }
3434 }
3435 }
3436 else
3437 {
3447 /* We used to call digest_init here. However, digest_init
3448 will report errors, which we don't want when complain
3449 is zero. More importantly, digest_init will try too
3450 hard to convert things: for example, `0' should not be
3451 converted to pointer type at this point according to
3452 the standard. Accepting this is not merely an
3453 extension, since deciding whether or not these
3454 conversions can occur is part of determining which
3455 function template to call, or whether a given explicit
3456 argument specification is legal. */
3458 else
3466 }
3469 }
3471 /* Convert all template arguments to their appropriate types, and
3472 return a vector containing the innermost resulting template
3473 arguments. If any error occurs, return error_mark_node. Error and
3474 warning messages are issued under control of COMPLAIN. Some error
3475 messages are issued even if COMPLAIN is zero; for instance, if a
3476 template argument is composed from a local class.
3478 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3479 provided in ARGLIST, or else trailing parameters must have default
3480 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3481 deduction for any unspecified trailing arguments. */
3483 static tree
3485 complain,
3486 require_all_arguments)
3488 tree in_decl;
3489 tsubst_flags_t complain;
3491 {
3493 tree inner_args;
3494 tree new_args;
3495 tree new_inner_args;
3503 && require_all_arguments
3505 {
3507 {
3513 }
3516 }
3521 {
3522 tree arg;
3523 tree parm;
3525 /* Get the Ith template parameter. */
3528 /* Calculate the Ith argument. */
3530 {
3533 }
3536 /* If no template argument was supplied, look for a default
3537 value. */
3539 {
3540 /* There was no default value. */
3543 }
3546 else
3548 in_decl);
3550 /* Now, convert the Ith argument, as necessary. */
3552 /* We're out of arguments. */
3553 {
3556 }
3558 {
3561 }
3562 else
3565 in_decl);
3568 lost++;
3570 }
3576 }
3578 /* Returns 1 if template args OT and NT are equivalent. */
3580 static int
3583 {
3588 /* For member templates */
3594 else
3596 }
3598 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3599 of template arguments. Returns 0 otherwise. */
3601 int
3604 {
3611 {
3617 }
3619 }
3621 /* Given class template name and parameter list, produce a user-friendly name
3622 for the instantiation. */
3628 {
3635 else
3639 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
3640 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
3648 {
3656 {
3659 }
3661 {
3663 {
3664 /* Already substituted with real template. Just output
3665 the template name here */
3668 {
3669 /* The template may be defined in a namespace, or
3670 may be a member template. */
3676 }
3678 }
3679 else
3680 /* Output the parameter declaration */
3683 }
3684 else
3688 {
3689 /* New list cell was built because old chain link was in
3690 use. */
3693 }
3694 /* No need to check arglist against parmlist here; we did that
3695 in coerce_template_parms, called from lookup_template_class. */
3697 }
3698 {
3702 offset--;
3705 /* B<C<char> >, not B<C<char>> */
3708 }
3712 }
3714 static tree
3716 tree t;
3717 {
3719 /* Specializations have already had their names set up in
3720 lookup_template_class. */
3722 {
3725 /* For non-primary templates, the template parameters are
3726 implicit from their surrounding context. */
3728 {
3737 }
3738 }
3741 }
3743 static void
3745 tree d;
3746 {
3750 tree pt;
3756 /* We are called both from instantiate_decl, where we've already had a
3757 tinst_level pushed, and instantiate_template, where we haven't.
3758 Compensate. */
3767 else
3776 }
3779 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3780 may be either a _DECL or an overloaded function or an
3781 IDENTIFIER_NODE), and ARGLIST. */
3783 tree
3786 {
3787 tree type;
3790 {
3793 }
3801 else
3803 }
3805 /* Within the scope of a template class S<T>, the name S gets bound
3806 (in build_self_reference) to a TYPE_DECL for the class, not a
3807 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3808 or one of its enclosing classes, and that type is a template,
3809 return the associated TEMPLATE_DECL. Otherwise, the original
3810 DECL is returned. */
3812 static tree
3814 tree decl;
3815 {
3822 }
3824 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3825 parameters, find the desired type.
3827 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3828 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3829 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3830 otherwise.)
3832 IN_DECL, if non-NULL, is the template declaration we are trying to
3833 instantiate.
3835 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3836 the class we are looking up.
3838 Issue error and warning messages under control of COMPLAIN.
3840 If the template class is really a local class in a template
3841 function, then the FUNCTION_CONTEXT is the function in which it is
3842 being instantiated. */
3844 tree
3847 tree in_decl;
3848 tree context;
3850 tsubst_flags_t complain;
3851 {
3853 tree t;
3856 {
3860 else
3861 {
3868 }
3871 }
3873 {
3876 /* If we are declaring a constructor, say A<T>::A<T>, we will get
3877 an implicit typename for the second A. Deal with it. */
3882 {
3885 }
3886 }
3889 {
3892 }
3895 {
3899 }
3901 /* With something like `template <class T> class X class X { ... };'
3902 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3903 We don't want to do that, but we have to deal with the situation,
3904 so let's give them some syntax errors to chew on instead of a
3905 crash. Alternatively D1 might not be a template type at all. */
3907 {
3911 }
3914 /* If we're called from the parser, make sure it's a user visible
3915 template. */
3919 {
3921 {
3925 }
3927 }
3930 {
3931 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3932 template arguments */
3934 tree parm;
3935 tree arglist2;
3939 /* Consider an example where a template template parameter declared as
3941 template <class T, class U = std::allocator<T> > class TT
3943 The template parameter level of T and U are one level larger than
3944 of TT. To proper process the default argument of U, say when an
3945 instantiation `TT<int>' is seen, we need to build the full
3946 arguments containing {int} as the innermost level. Outer levels,
3947 available when not appearing as default template argument, can be
3948 obtained from `current_template_args ()'.
3950 Suppose that TT is later substituted with std::vector. The above
3951 instantiation is `TT<int, std::allocator<T> >' with TT at
3952 level 1, and T at level 2, while the template arguments at level 1
3953 becomes {std::vector} and the inner level 2 is {int}. */
3965 }
3966 else
3967 {
3969 tree gen_tmpl;
3970 tree type_decl;
3983 {
3984 /* We've been given an incomplete set of template arguments.
3985 For example, given:
3987 template <class T> struct S1 {
3988 template <class U> struct S2 {};
3989 template <class U> struct S2<U*> {};
3990 };
3992 we will be called with an ARGLIST of `U*', but the
3993 TEMPLATE will be `template <class T> template
3994 <class U> struct S1<T>::S2'. We must fill in the missing
3995 arguments. */
3996 arglist
3998 arglist);
4000 }
4002 /* Now we should have enough arguments. */
4005 /* From here on, we're only interested in the most general
4006 template. */
4009 /* Calculate the BOUND_ARGS. These will be the args that are
4010 actually tsubst'd into the definition to create the
4011 instantiation. */
4013 {
4014 /* We have multiple levels of arguments to coerce, at once. */
4024 {
4030 /* We temporarily reduce the length of the ARGLIST so
4031 that coerce_template_parms will see only the arguments
4032 corresponding to the template parameters it is
4033 examining. */
4035 }
4037 /* Restore the ARGLIST to its full size. */
4041 }
4042 else
4043 arglist
4050 /* We were unable to bind the arguments. */
4053 /* In the scope of a template class, explicit references to the
4054 template class refer to the type of the template, not any
4055 instantiation of it. For example, in:
4057 template <class T> class C { void f(C<T>); }
4059 the `C<T>' is just the same as `C'. Outside of the
4060 class, however, such a reference is an instantiation. */
4062 arglist))
4063 {
4067 {
4068 tree ctx;
4070 /* Note that we use DECL_CONTEXT, rather than
4071 CP_DECL_CONTEXT, so that the termination test is
4072 always just `ctx'. We're not interested in namespace
4073 scopes. */
4075 ctx;
4081 /* We're not in the scope of the class, so the
4082 TEMPLATE_TYPE is not the type we want after
4083 all. */
4085 }
4086 }
4094 {
4097 /* Use the move-to-front heuristic to speed up future
4098 searches. */
4105 }
4107 /* This type is a "partial instantiation" if any of the template
4108 arguments still involve template parameters. Note that we set
4109 IS_PARTIAL_INSTANTIATION for partial specializations as
4110 well. */
4116 {
4121 }
4128 /* Create the type. */
4130 {
4132 {
4135 }
4136 else
4137 /* We don't want to call start_enum for this type, since
4138 the values for the enumeration constants may involve
4139 template parameters. And, no one should be interested
4140 in the enumeration constants for such a type. */
4142 }
4143 else
4144 {
4152 /* A local class. Make sure the decl gets registered properly. */
4155 }
4157 /* If we called start_enum or pushtag above, this information
4158 will already be set up. */
4160 {
4170 }
4171 else
4174 /* Set up the template information. We have to figure out which
4175 template is the immediate parent if this is a full
4176 instantiation. */
4179 /* This case is easy; there are no member templates involved. */
4181 else
4182 {
4183 /* This is a full instantiation of a member template. Look
4184 for a partial instantiation of which this is an instance. */
4188 {
4192 /* We only want partial instantiations, here, not
4193 specializations or full instantiations. */
4198 /* Temporarily reduce by one the number of levels in the
4199 ARGLIST and in FOUND so as to avoid comparing the
4200 last set of arguments. */
4204 /* See if the arguments match. If they do, then TMPL is
4205 the partial instantiation we want. */
4208 /* Restore the argument vectors to their full size. */
4213 {
4216 }
4217 }
4220 {
4221 /* There was no partial instantiation. This happens
4222 where C<T> is a member template of A<T> and it's used
4223 in something like
4225 template <typename T> struct B { A<T>::C<int> m; };
4226 B<float>;
4228 Create the partial instantiation.
4229 */
4233 }
4234 }
4243 /* Now that the type has been registered on the instantiations
4244 list, we set up the enumerators. Because the enumeration
4245 constants may involve the enumeration type itself, we make
4246 sure to register the type first, and then create the
4247 constants. That way, doing tsubst_expr for the enumeration
4248 constants won't result in recursive calls here; we'll find
4249 the instantiation and exit above. */
4252 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4253 is set up. */
4257 {
4258 /* For backwards compatibility; code that uses
4259 -fexternal-templates expects looking up a template to
4260 instantiate it. I think DDD still relies on this.
4261 (jason 8/20/1998) */
4263 && flag_external_templates
4267 }
4268 else
4269 /* If the type makes use of template parameters, the
4270 code that generates debugging information will crash. */
4274 }
4275 }
4276 \f
4277 struct pair_fn_data
4278 {
4279 tree_fn_t fn;
4281 };
4283 /* Called from for_each_template_parm via walk_tree. */
4285 static tree
4290 {
4301 {
4305 /* Fall through. */
4317 /* Since we're not going to walk subtrees, we have to do this
4318 explicitly here. */
4321 /* Fall through. */
4324 /* Check the return type. */
4328 /* Check the parameter types. Since default arguments are not
4329 instantiated until they are needed, the TYPE_ARG_TYPES may
4330 contain expressions that involve template parameters. But,
4331 no-one should be looking at them yet. And, once they're
4332 instantiated, they don't contain template parameters, so
4333 there's no point in looking at them then, either. */
4334 {
4335 tree parm;
4341 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4342 want walk_tree walking into them itself. */
4344 }
4352 /* Fall through. */
4362 /* Record template parameters such as `T' inside `TT<T>'. */
4365 /* Fall through. */
4377 /* A template template parameter is encountered */
4382 /* Already substituted template template parameter */
4400 /* If there's no type, then this thing must be some expression
4401 involving template parameters. */
4423 }
4425 /* We didn't find any template parameters we liked. */
4427 }
4429 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4430 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4431 call FN with the parameter and the DATA.
4432 If FN returns non-zero, the iteration is terminated, and
4433 for_each_template_parm returns 1. Otherwise, the iteration
4434 continues. If FN never returns a non-zero value, the value
4435 returned by for_each_template_parm is 0. If FN is NULL, it is
4436 considered to be the function which always returns 1. */
4438 static int
4440 tree t;
4441 tree_fn_t fn;
4443 {
4446 /* Set up. */
4450 /* Walk the tree. (Conceptually, we would like to walk without
4451 duplicates, but for_each_template_parm_r recursively calls
4452 for_each_template_parm, so we would need to reorganize a fair
4453 bit to use walk_tree_without_duplicates.) */
4455 for_each_template_parm_r,
4458 }
4460 int
4462 tree t;
4463 {
4465 }
4469 #ifdef GATHER_STATISTICS
4471 #endif
4475 /* We're starting to instantiate D; record the template instantiation context
4476 for diagnostics and to restore it later. */
4478 int
4480 tree d;
4481 {
4485 {
4486 /* If the instantiation in question still has unbound template parms,
4487 we don't really care if we can't instantiate it, so just return.
4488 This happens with base instantiation for implicit `typename'. */
4493 error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
4499 }
4506 #ifdef GATHER_STATISTICS
4509 #endif
4513 }
4515 /* We're done instantiating this template; return to the instantiation
4516 context. */
4518 void
4520 {
4523 /* Restore the filename and line number stashed away when we started
4524 this instantiation. */
4532 }
4534 /* We're instantiating a deferred template; restore the template
4535 instantiation context in which the instantiation was requested, which
4536 is one step out from LEVEL. */
4538 static void
4540 tree level;
4541 {
4542 tree t;
4550 }
4552 /* Return the outermost template instantiation context, for use with
4553 -falt-external-templates. */
4555 tree
4557 {
4562 ;
4564 }
4566 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4567 vector of template arguments, as for tsubst.
4569 Returns an appropriate tsubst'd friend declaration. */
4571 static tree
4573 tree decl;
4574 tree args;
4575 {
4576 tree new_friend;
4586 /* This was a friend declared with an explicit template
4587 argument list, e.g.:
4589 friend void f<>(T);
4591 to indicate that f was a template instantiation, not a new
4592 function declaration. Now, we have to figure out what
4593 instantiation of what template. */
4594 {
4596 tree new_args;
4597 tree tmpl;
4600 /* Friend functions are looked up in the containing namespace scope.
4601 We must enter that scope, to avoid finding member functions of the
4602 current cless with same name. */
4617 }
4621 /* The NEW_FRIEND will look like an instantiation, to the
4622 compiler, but is not an instantiation from the point of view of
4623 the language. For example, we might have had:
4625 template <class T> struct S {
4626 template <class U> friend void f(T, U);
4627 };
4629 Then, in S<int>, template <class U> void f(int, U) is not an
4630 instantiation of anything. */
4633 {
4637 }
4639 /* The mangled name for the NEW_FRIEND is incorrect. The function
4640 is not a template instantiation and should not be mangled like
4641 one. Therefore, we forget the mangling here; we'll recompute it
4642 later if we need it. */
4644 {
4647 }
4650 {
4651 tree old_decl;
4652 tree new_friend_template_info;
4653 tree new_friend_result_template_info;
4654 tree ns;
4657 /* We must save some information from NEW_FRIEND before calling
4658 duplicate decls since that function will free NEW_FRIEND if
4659 possible. */
4662 {
4663 /* This declaration is a `primary' template. */
4666 new_friend_is_defn
4668 new_friend_result_template_info
4670 }
4671 else
4672 {
4675 }
4677 /* Inside pushdecl_namespace_level, we will push into the
4678 current namespace. However, the friend function should go
4679 into the namespace of the template. */
4686 {
4687 /* This new friend declaration matched an existing
4688 declaration. For example, given:
4690 template <class T> void f(T);
4691 template <class U> class C {
4692 template <class T> friend void f(T) {}
4693 };
4695 the friend declaration actually provides the definition
4696 of `f', once C has been instantiated for some type. So,
4697 old_decl will be the out-of-class template declaration,
4698 while new_friend is the in-class definition.
4700 But, if `f' was called before this point, the
4701 instantiation of `f' will have DECL_TI_ARGS corresponding
4702 to `T' but not to `U', references to which might appear
4703 in the definition of `f'. Previously, the most general
4704 template for an instantiation of `f' was the out-of-class
4705 version; now it is the in-class version. Therefore, we
4706 run through all specialization of `f', adding to their
4707 DECL_TI_ARGS appropriately. In particular, they need a
4708 new set of outer arguments, corresponding to the
4709 arguments for this class instantiation.
4711 The same situation can arise with something like this:
4713 friend void f(int);
4714 template <class T> class C {
4715 friend void f(T) {}
4716 };
4718 when `C<int>' is instantiated. Now, `f(int)' is defined
4719 in the class. */
4722 /* On the other hand, if the in-class declaration does
4723 *not* provide a definition, then we don't want to alter
4724 existing definitions. We can just leave everything
4725 alone. */
4726 ;
4727 else
4728 {
4729 /* Overwrite whatever template info was there before, if
4730 any, with the new template information pertaining to
4731 the declaration. */
4735 /* duplicate_decls will take care of this case. */
4736 ;
4737 else
4738 {
4739 tree t;
4740 tree new_friend_args;
4749 {
4755 }
4757 /* Now, since specializations are always supposed to
4758 hang off of the most general template, we must move
4759 them. */
4762 {
4767 }
4768 }
4769 }
4771 /* The information from NEW_FRIEND has been merged into OLD_DECL
4772 by duplicate_decls. */
4774 }
4775 }
4777 {
4778 /* Check to see that the declaration is really present, and,
4779 possibly obtain an improved declaration. */
4781 new_friend);
4785 }
4787 done:
4791 }
4793 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4794 template arguments, as for tsubst.
4796 Returns an appropriate tsubst'd friend type or error_mark_node on
4797 failure. */
4799 static tree
4801 tree friend_tmpl;
4802 tree args;
4803 {
4804 tree friend_type;
4805 tree tmpl;
4806 tree context;
4811 {
4814 else
4816 }
4818 /* First, we look for a class template. */
4821 /* But, if we don't find one, it might be because we're in a
4822 situation like this:
4824 template <class T>
4825 struct S {
4826 template <class U>
4827 friend struct S;
4828 };
4830 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
4831 for `S<int>', not the TEMPLATE_DECL. */
4833 {
4836 }
4839 {
4840 /* The friend template has already been declared. Just
4841 check to see that the declarations match, and install any new
4842 default parameters. We must tsubst the default parameters,
4843 of course. We only need the innermost template parameters
4844 because that is all that redeclare_class_template will look
4845 at. */
4848 {
4849 tree parms;
4853 }
4856 }
4857 else
4858 {
4859 /* The friend template has not already been declared. In this
4860 case, the instantiation of the template class will cause the
4861 injection of this template into the global scope. */
4864 /* The new TMPL is not an instantiation of anything, so we
4865 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4866 the new type because that is supposed to be the corresponding
4867 template decl, i.e., TMPL. */
4872 /* Inject this template into the global scope. */
4874 }
4877 {
4880 else
4882 }
4885 }
4887 /* Returns zero if TYPE cannot be completed later due to circularity.
4888 Otherwise returns one. */
4890 static int
4892 tree type;
4893 {
4902 else
4904 }
4906 tree
4908 tree type;
4909 {
4911 tree typedecl;
4919 /* Figure out which template is being instantiated. */
4923 /* Figure out which arguments are being used to do the
4924 instantiation. */
4929 /* If this is a partial instantiation, then we can't instantiate
4930 the type; there's no telling whether or not one of the
4931 template parameters might eventually be instantiated to some
4932 value that results in a specialization being used. For
4933 example, consider:
4935 template <class T>
4936 struct S {};
4938 template <class U>
4939 void f(S<U>);
4941 template <>
4942 struct S<int> {};
4944 Now, the `S<U>' in `f<int>' is the specialization, not an
4945 instantiation of the original template. */
4948 /* Determine what specialization of the original template to
4949 instantiate. */
4951 /* There's no telling which specialization is appropriate at this
4952 point. Since all peeking at the innards of this partial
4953 instantiation are extensions (like the "implicit typename"
4954 extension, which allows users to omit the keyword `typename' on
4955 names that are declared as types in template base classes), we
4956 are free to do what we please.
4958 Trying to figure out which partial instantiation to use can
4959 cause a crash. (Some of the template arguments don't even have
4960 types.) So, we just use the most general version. */
4962 else
4963 {
4967 {
4972 {
4974 args))
4975 {
4978 }
4979 }
4982 }
4983 }
4987 else
4990 /* If the template we're instantiating is incomplete, then clearly
4991 there's nothing we can do. */
4995 /* If this is a partial instantiation, don't tsubst anything. We will
4996 only use this type for implicit typename, so the actual contents don't
4997 matter. All that matters is whether a particular name is a type. */
4999 {
5000 /* The fields set here must be kept in sync with those cleared
5001 in begin_class_definition. */
5008 /* Pretend that the type is complete, so that we will look
5009 inside it during name lookup and such. */
5012 }
5014 /* If we've recursively instantiated too many templates, stop. */
5018 /* Now we're really doing the instantiation. Mark the type as in
5019 the process of being defined. */
5025 {
5026 /* This TYPE is actually a instantiation of of a partial
5027 specialization. We replace the innermost set of ARGS with
5028 the arguments appropriate for substitution. For example,
5029 given:
5031 template <class T> struct S {};
5032 template <class T> struct S<T*> {};
5034 and supposing that we are instantiating S<int*>, ARGS will
5035 present be {int*} but we need {int}. */
5036 tree inner_args
5038 args);
5040 /* If there were multiple levels in ARGS, replacing the
5041 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
5042 want, so we make a copy first. */
5044 {
5047 }
5048 else
5050 }
5053 {
5055 {
5058 }
5059 else
5060 {
5062 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
5064 }
5065 }
5066 else
5067 {
5069 }
5100 {
5105 /* Substitute into each of the bases to determine the actual
5106 basetypes. */
5108 {
5109 tree base;
5110 tree access;
5111 tree pbase;
5115 /* Substitute to figure out the base class. */
5120 /* Calculate the correct access node. */
5122 {
5127 else
5129 }
5130 else
5131 {
5136 else
5138 }
5141 }
5143 /* The list is now in reverse order; correct that. */
5146 /* Now call xref_basetypes to set up all the base-class
5147 information. */
5153 type,
5154 base_list);
5155 }
5157 /* Now that our base classes are set up, enter the scope of the
5158 class, so that name lookups into base classes, etc. will work
5159 correctly. This is precisely analogous to what we do in
5160 begin_class_definition when defining an ordinary non-template
5161 class. */
5165 {
5168 tree newtag;
5173 {
5175 /* Unfortunately, lookup_template_class sets
5176 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5177 instantiation (i.e., for the type of a member template
5178 class nested within a template class.) This behavior is
5179 required for maybe_process_partial_specialization to work
5180 correctly, but is not accurate in this case; the TAG is not
5181 an instantiation of anything. (The corresponding
5182 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
5185 /* Now, we call pushtag to put this NEWTAG into the scope of
5186 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5187 pushtag calling push_template_decl. We don't have to do
5188 this for enums because it will already have been done in
5189 tsubst_enum. */
5193 }
5194 }
5196 /* Don't replace enum constants here. */
5199 {
5200 tree r;
5202 /* The the file and line for this declaration, to assist in
5203 error message reporting. Since we called push_tinst_level
5204 above, we don't need to restore these. */
5210 {
5211 tree init;
5216 else
5225 }
5227 {
5228 /* Determine whether R has a valid type and can be
5229 completed later. If R is invalid, then it is replaced
5230 by error_mark_node so that it will not be added to
5231 TYPE_FIELDS. */
5234 {
5237 }
5238 }
5240 /* R will have a TREE_CHAIN if and only if it has already been
5241 processed by finish_member_declaration. This can happen
5242 if, for example, it is a TYPE_DECL for a class-scoped
5243 ENUMERAL_TYPE; such a thing will already have been added to
5244 the field list by tsubst_enum above. */
5246 {
5249 }
5250 }
5252 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
5253 for this instantiation. */
5255 {
5260 }
5262 /* Construct the DECL_FRIENDLIST for the new class type. */
5267 {
5268 tree friends;
5276 args));
5277 else
5279 }
5284 {
5286 tree new_friend_type;
5293 else
5294 {
5297 /* The call to xref_tag_from_type does injection for friend
5298 classes. */
5300 new_friend_type =
5303 }
5306 /* Trick make_friend_class into realizing that the friend
5307 we're adding is a template, not an ordinary class. It's
5308 important that we use make_friend_class since it will
5309 perform some error-checking and output cross-reference
5310 information. */
5318 }
5320 /* Now that TYPE_FIELDS and TYPE_METHODS are set up. We can
5321 instantiate templates used by this class. */
5324 {
5327 }
5329 /* Set the file and line number information to whatever is given for
5330 the class itself. This puts error messages involving generated
5331 implicit functions at a predictable point, and the same point
5332 that would be used for non-template classes. */
5340 /* Clear this now so repo_template_used is happy. */
5344 /* Now that the class is complete, instantiate default arguments for
5345 any member functions. We don't do this earlier because the
5346 default arguments may reference members of the class. */
5350 /* Implicitly generated member functions will not have template
5351 information; they are not instantiations, but instead are
5352 created "fresh" for each instantiation. */
5361 }
5363 static int
5366 {
5371 /* Don't care if one declares its arg const and the other doesn't -- the
5372 main variant of the arg type is all that matters. */
5377 }
5379 /* If arg is a non-type template parameter that does not depend on template
5380 arguments, fold it like we weren't in the body of a template. */
5382 static tree
5384 tree arg;
5385 {
5387 {
5388 /* Sometimes, one of the args was an expression involving a
5389 template constant parameter, like N - 1. Now that we've
5390 tsubst'd, we might have something like 2 - 1. This will
5391 confuse lookup_template_class, so we do constant folding
5392 here. We have to unset processing_template_decl, to
5393 fool build_expr_from_tree() into building an actual
5394 tree. */
5396 /* If the TREE_TYPE of ARG is not NULL_TREE, ARG is already
5397 as simple as it's going to get, and trying to reprocess
5398 the trees will break. */
5400 {
5405 }
5408 }
5410 }
5412 /* Substitute ARGS into the vector of template arguments T. */
5414 static tree
5416 tree t;
5417 tree args;
5418 tsubst_flags_t complain;
5419 {
5426 {
5431 else
5434 NULL_TREE));
5441 }
5451 }
5453 /* Return the result of substituting ARGS into the template parameters
5454 given by PARMS. If there are m levels of ARGS and m + n levels of
5455 PARMS, then the result will contain n levels of PARMS. For
5456 example, if PARMS is `template <class T> template <class U>
5457 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5458 result will be `template <int*, double, class V>'. */
5460 static tree
5462 tree parms;
5463 tree args;
5464 tsubst_flags_t complain;
5465 {
5473 {
5474 tree new_vec =
5479 {
5488 parm_decl);
5490 }
5496 }
5499 }
5501 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5502 type T. If T is not an aggregate or enumeration type, it is
5503 handled as if by tsubst. IN_DECL is as for tsubst. If
5504 ENTERING_SCOPE is non-zero, T is the context for a template which
5505 we are presently tsubst'ing. Return the substituted value. */
5507 static tree
5509 tree t;
5510 tree args;
5511 tsubst_flags_t complain;
5512 tree in_decl;
5514 {
5519 {
5524 /* else fall through */
5528 {
5529 tree argvec;
5530 tree context;
5531 tree r;
5533 /* First, determine the context for the type we are looking
5534 up. */
5537 complain,
5539 else
5542 /* Then, figure out what arguments are appropriate for the
5543 type we are trying to find. For example, given:
5545 template <class T> struct S;
5546 template <class T, class U> void f(T, U) { S<U> su; }
5548 and supposing that we are instantiating f<int, double>,
5549 then our ARGS will be {int, double}, but, when looking up
5550 S we only want {double}. */
5552 complain);
5560 }
5561 else
5562 /* This is not a template type, so there's nothing to do. */
5567 }
5568 }
5570 /* Substitute into the default argument ARG (a default argument for
5571 FN), which has the indicated TYPE. */
5573 tree
5575 tree fn;
5576 tree type;
5577 tree arg;
5578 {
5579 /* This default argument came from a template. Instantiate the
5580 default argument here, not in tsubst. In the case of
5581 something like:
5583 template <class T>
5584 struct S {
5585 static T t();
5586 void f(T = t());
5587 };
5589 we must be careful to do name lookup in the scope of S<T>,
5590 rather than in the current class. */
5600 /* Make sure the default argument is reasonable. */
5604 }
5606 /* Substitute into all the default arguments for FN. */
5608 static void
5610 tree fn;
5611 {
5612 tree arg;
5613 tree tmpl_args;
5617 /* If this function is not yet instantiated, we certainly don't need
5618 its default arguments. */
5623 arg;
5629 }
5631 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5632 (already computed) substitution of ARGS into TREE_TYPE (T), if
5633 appropriate. Return the result of the substitution. Issue error
5634 and warning messages under control of COMPLAIN. */
5636 static tree
5638 tree t;
5639 tree args;
5640 tree type;
5641 tsubst_flags_t complain;
5642 {
5650 /* Set the filename and linenumber to improve error-reporting. */
5657 {
5659 {
5660 /* We can get here when processing a member template function
5661 of a template class. */
5663 tree spec;
5667 {
5668 /* We might already have an instance of this template.
5669 The ARGS are for the surrounding class type, so the
5670 full args contain the tsubst'd args for the context,
5671 plus the innermost args from the template decl. */
5675 tree full_args;
5678 complain);
5680 /* tsubst_template_arg_vector doesn't copy the vector if
5681 nothing changed. But, *something* should have
5682 changed. */
5687 {
5690 }
5691 }
5693 /* Make a new template decl. It will be similar to the
5694 original, but will record the current template arguments.
5695 We also create a new function declaration, which is just
5696 like the old one, but points to this new template, rather
5697 than the old one. */
5703 {
5708 }
5721 {
5727 }
5728 else
5729 {
5736 }
5742 /* The template parameters for this new template are all the
5743 template parameters for the old template, except the
5744 outermost level of parameters. */
5747 complain);
5752 /* We don't partially instantiate partial specializations. */
5756 /* Record this partial instantiation. */
5760 }
5764 {
5765 tree ctx;
5768 tree gen_tmpl;
5773 /* Nobody should be tsubst'ing into non-template functions. */
5777 {
5778 tree spec;
5780 /* Calculate the most general template of which R is a
5781 specialization, and the complete set of arguments used to
5782 specialize R. */
5784 argvec
5789 /* Check to see if we already have this specialization. */
5793 {
5796 }
5798 /* We can see more levels of arguments than parameters if
5799 there was a specialization of a member template, like
5800 this:
5802 template <class T> struct S { template <class U> void f(); }
5803 template <> template <class U> void S<int>::f(U);
5805 Here, we'll be substituting into the specialization,
5806 because that's where we can find the code we actually
5807 want to generate, but we'll have enough arguments for
5808 the most general template.
5810 We also deal with the peculiar case:
5812 template <class T> struct S {
5813 template <class U> friend void f();
5814 };
5815 template <class U> void f() {}
5816 template S<int>;
5817 template void f<double>();
5819 Here, the ARGS for the instantiation of will be {int,
5820 double}. But, we only need as many ARGS as there are
5821 levels of template parameters in CODE_PATTERN. We are
5822 careful not to get fooled into reducing the ARGS in
5823 situations like:
5825 template <class T> struct S { template <class U> void f(U); }
5826 template <class T> template <> void S<T>::f(int) {}
5828 which we can spot because the pattern will be a
5829 specialization in this case. */
5831 parms_depth =
5836 }
5837 else
5838 {
5839 /* This special case arises when we have something like this:
5841 template <class T> struct S {
5842 friend void f<int>(int, double);
5843 };
5845 Here, the DECL_TI_TEMPLATE for the friend declaration
5846 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5847 being called from tsubst_friend_function, and we want
5848 only to create a new decl (R) with appropriate types so
5849 that we can call determine_specialization. */
5855 }
5858 {
5861 else
5866 }
5867 else
5868 {
5871 }
5876 /* We do NOT check for matching decls pushed separately at this
5877 point, as they may not represent instantiations of this
5878 template, and in any case are considered separate under the
5879 discrete model. */
5883 /* Clear out the mangled name and RTL for the instantiation. */
5894 /* Type-conversion operator. Reconstruct the name, in
5895 case it's the name of one of the template's parameters. */
5913 {
5918 }
5920 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
5921 this in the special friend case mentioned above where
5922 GEN_TMPL is NULL. */
5924 {
5930 /* We're not supposed to instantiate default arguments
5931 until they are called, for a template. But, for a
5932 declaration like:
5934 template <class T> void f ()
5935 { extern void g(int i = T()); }
5937 we should do the substitution when the template is
5938 instantiated. We handle the member function case in
5939 instantiate_class_template since the default arguments
5940 might refer to other members of the class. */
5945 }
5947 /* Copy the list of befriending classes. */
5951 {
5955 in_decl);
5956 }
5959 {
5963 /* If this is an instantiation of a member template, clone it.
5964 If it isn't, that'll be handled by
5965 clone_constructors_and_destructors. */
5968 }
5971 }
5975 {
5985 else
5997 }
6001 {
6006 /* We don't have to set DECL_CONTEXT here; it is set by
6007 finish_member_declaration. */
6013 }
6017 {
6022 }
6028 {
6029 /* If this is the canonical decl, we don't have to mess with
6030 instantiations, and often we can't (for typename, template
6031 type parms and such). Note that TYPE_NAME is not correct for
6032 the above test if we've copied the type for a typedef. */
6035 }
6037 /* Fall through. */
6040 {
6043 tree spec;
6045 tree ctx;
6048 /* Assume this is a non-local variable. */
6053 complain,
6057 else
6058 {
6059 /* Subsequent calls to pushdecl will fill this in. */
6062 }
6064 /* Check to see if we already have this specialization. */
6066 {
6071 }
6072 else
6076 {
6079 }
6087 /* Clear out the mangled name and RTL for the instantiation. */
6091 /* Don't try to expand the initializer until someone tries to use
6092 this variable; otherwise we run into circular dependencies. */
6097 /* Even if the original location is out of scope, the newly
6098 substituted one is not. */
6103 {
6104 /* A static data member declaration is always marked
6105 external when it is declared in-class, even if an
6106 initializer is present. We mimic the non-template
6107 processing here. */
6113 }
6114 else
6120 /* Compute the size, alignment, etc. of R. */
6122 }
6127 }
6129 /* Restore the file and line information. */
6134 }
6136 /* Substitue into the ARG_TYPES of a function type. */
6138 static tree
6140 tree arg_types;
6141 tree args;
6142 tsubst_flags_t complain;
6143 tree in_decl;
6144 {
6145 tree remaining_arg_types;
6146 tree type;
6160 {
6162 {
6166 }
6168 }
6170 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6171 top-level qualifiers as required. */
6174 /* Note that we do not substitute into default arguments here. The
6175 standard mandates that they be instantiated only when needed,
6176 which is done in build_over_call. */
6178 remaining_arg_types);
6180 }
6182 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6183 *not* handle the exception-specification for FNTYPE, because the
6184 initial substitution of explicitly provided template parameters
6185 during argument deduction forbids substitution into the
6186 exception-specification:
6188 [temp.deduct]
6190 All references in the function type of the function template to the
6191 corresponding template parameters are replaced by the specified tem-
6192 plate argument values. If a substitution in a template parameter or
6193 in the function type of the function template results in an invalid
6194 type, type deduction fails. [Note: The equivalent substitution in
6195 exception specifications is done only when the function is instanti-
6196 ated, at which point a program is ill-formed if the substitution
6197 results in an invalid type.] */
6199 static tree
6201 tree t;
6202 tree args;
6203 tsubst_flags_t complain;
6204 tree in_decl;
6205 {
6206 tree return_type;
6207 tree arg_types;
6208 tree fntype;
6210 /* The TYPE_CONTEXT is not used for function/method types. */
6213 /* Substitute the return type. */
6218 /* Substitue the argument types. */
6224 /* Construct a new type node and return it. */
6227 else
6228 {
6231 {
6232 /* [temp.deduct]
6234 Type deduction may fail for any of the following
6235 reasons:
6237 -- Attempting to create "pointer to member of T" when T
6238 is not a class type. */
6241 r);
6243 }
6247 }
6252 }
6254 /* Substitute into the PARMS of a call-declarator. */
6256 static tree
6258 tree parms;
6259 tree args;
6260 tsubst_flags_t complain;
6261 tree in_decl;
6262 {
6263 tree new_parms;
6264 tree type;
6265 tree defarg;
6273 /* Figure out the type of this parameter. */
6276 /* Figure out the default argument as well. Note that we use
6277 tsubst_expr since the default argument is really an expression. */
6280 /* Chain this parameter on to the front of those we have already
6281 processed. We don't use hash_tree_cons because that function
6282 doesn't check TREE_PARMLIST. */
6285 /* And note that these are parameters. */
6289 }
6291 /* Take the tree structure T and replace template parameters used
6292 therein with the argument vector ARGS. IN_DECL is an associated
6293 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6294 Issue error and warning messages under control of COMPLAIN. Note
6295 that we must be relatively non-tolerant of extensions here, in
6296 order to preserve conformance; if we allow substitutions that
6297 should not be allowed, we may allow argument deductions that should
6298 not succeed, and therefore report ambiguous overload situations
6299 where there are none. In theory, we could allow the substitution,
6300 but indicate that it should have failed, and allow our caller to
6301 make sure that the right thing happens, but we don't try to do this
6302 yet.
6304 This function is used for dealing with types, decls and the like;
6305 for expressions, use tsubst_expr or tsubst_copy. */
6307 tree
6310 tsubst_flags_t complain;
6311 tree in_decl;
6312 {
6324 else
6343 {
6370 {
6377 /* See if we can reduce this expression to something simpler. */
6383 /* When providing explicit arguments to a template
6384 function, but leaving some arguments for subsequent
6385 deduction, MAX may be template-dependent even if we're
6386 not PROCESSING_TEMPLATE_DECL. We still need to check for
6387 template parms, though; MAX won't be an INTEGER_CST for
6388 dynamic arrays, either. */
6391 {
6395 integer_one_node);
6397 }
6400 {
6401 /* Still allow an explicit array of size zero. */
6404 }
6408 {
6409 /* [temp.deduct]
6411 Type deduction may fail for any of the following
6412 reasons:
6414 Attempting to create an array with a size that is
6415 zero or negative. */
6420 }
6423 }
6429 {
6439 {
6442 }
6443 else
6444 {
6447 }
6450 {
6460 {
6462 {
6464 return cp_build_qualified_type_real
6467 }
6469 {
6470 /* We are processing a type constructed from
6471 a template template parameter */
6477 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6478 we are resolving nested-types in the signature of
6479 a member function templates.
6480 Otherwise ARG is a TEMPLATE_DECL and is the real
6481 template to be instantiated. */
6489 complain);
6490 return cp_build_qualified_type_real
6492 }
6493 else
6494 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
6496 }
6497 }
6498 else
6502 /* This can happen during the attempted tsubst'ing in
6503 unify. This means that we don't yet have any information
6504 about the template parameter in question. */
6507 /* If we get here, we must have been looking at a parm for a
6508 more deeply nested template. Make a new version of this
6509 template parameter, but with a lower level. */
6511 {
6516 {
6518 r = cp_build_qualified_type_real
6522 }
6523 else
6524 {
6535 {
6543 }
6544 }
6553 }
6556 }
6559 {
6567 {
6571 }
6574 {
6578 }
6581 {
6585 }
6591 {
6594 }
6595 else
6598 }
6601 {
6602 /* A binfo node. We always need to make a copy, of the node
6603 itself and of its BINFO_BASETYPES. */
6607 /* Make sure type isn't a typedef copy. */
6612 {
6617 }
6619 }
6621 /* Otherwise, a vector of template arguments. */
6626 {
6635 /* [temp.deduct]
6637 Type deduction may fail for any of the following
6638 reasons:
6640 -- Attempting to create a pointer to reference type.
6641 -- Attempting to create a reference to a reference type or
6642 a reference to void. */
6645 {
6649 /* We keep track of the last time we issued this error
6650 message to avoid spewing a ton of messages during a
6651 single bad template instantiation. */
6654 {
6657 else
6660 type);
6663 }
6666 }
6668 {
6672 }
6673 else
6678 /* Will this ever be needed for TYPE_..._TO values? */
6682 }
6684 {
6687 {
6688 /* [temp.deduct]
6690 Type deduction may fail for any of the following
6691 reasons:
6693 -- Attempting to create "pointer to member of T" when T
6694 is not a class type. */
6698 }
6700 {
6705 }
6708 /* This is really a method type. The cv qualifiers of the
6709 this pointer should _not_ be determined by the cv
6710 qualifiers of the class type. They should be held
6711 somewhere in the FUNCTION_TYPE, but we don't do that at
6712 the moment. Consider
6713 typedef void (Func) () const;
6715 template <typename T1> void Foo (Func T1::*);
6717 */
6721 else
6723 }
6726 {
6727 tree fntype;
6728 tree raises;
6734 /* Substitue the exception specification. */
6737 {
6742 else
6744 {
6751 }
6753 }
6755 }
6757 {
6762 /* As an optimization, we avoid regenerating the array type if
6763 it will obviously be the same as T. */
6767 /* These checks should match the ones in grokdeclarator.
6769 [temp.deduct]
6771 The deduction may fail for any of the following reasons:
6773 -- Attempting to create an array with an element type that
6774 is void, a function type, or a reference type. */
6778 {
6782 }
6786 }
6790 {
6798 }
6802 {
6808 }
6811 {
6821 {
6824 ctx);
6826 }
6828 {
6829 /* Normally, make_typename_type does not require that the CTX
6830 have complete type in order to allow things like:
6832 template <class T> struct S { typename S<T>::X Y; };
6834 But, such constructs have already been resolved by this
6835 point, so here CTX really should have complete type, unless
6836 it's a partial instantiation. */
6839 {
6843 }
6844 }
6851 {
6854 }
6856 return cp_build_qualified_type_real
6858 }
6861 {
6870 }
6873 {
6878 }
6881 {
6886 }
6889 {
6896 }
6899 {
6901 tree e2 = (tsubst_call_declarator_parms
6911 }
6914 {
6921 }
6924 {
6930 }
6936 }
6937 }
6939 /* Like tsubst, but deals with expressions. This function just replaces
6940 template parms; to finish processing the resultant expression, use
6941 tsubst_expr. */
6943 tree
6946 tsubst_flags_t complain;
6947 tree in_decl;
6948 {
6950 tree r;
6958 {
6963 {
6964 tree enum_type;
6965 tree v;
6968 /* This is a global enumeration constant. */
6971 /* Unfortunately, we cannot just call lookup_name here.
6972 Consider:
6974 template <int I> int f() {
6975 enum E { a = I };
6976 struct S { void g() { E e = a; } };
6977 };
6979 When we instantiate f<7>::S::g(), say, lookup_name is not
6980 clever enough to find f<7>::a. */
6981 enum_type
6991 /* We didn't find the name. That should never happen; if
6992 name-lookup found it during preliminary parsing, we
6993 should find it again here during instantiation. */
6995 }
7000 {
7001 tree ctx;
7007 }
7020 else
7024 {
7025 /* We must tsubst into a LOOKUP_EXPR in case the names to
7026 which it refers is a conversion operator; in that case the
7027 name will change. We avoid making unnecessary copies,
7028 however. */
7033 {
7037 }
7040 }
7048 return build1
7065 return build1
7109 return build_nt
7114 {
7118 else
7119 /* Sometimes FN is a LOOKUP_EXPR. */
7121 return build_nt
7123 in_decl),
7124 NULL_TREE);
7125 }
7128 {
7131 {
7135 }
7138 {
7146 }
7147 else
7149 return build_nt
7153 NULL_TREE);
7154 }
7157 /* This processing should really occur in tsubst_expr, However,
7158 tsubst_expr does not recurse into expressions, since it
7159 assumes that there aren't any statements inside them.
7160 Instead, it simply calls build_expr_from_tree. So, we need
7161 to expand the STMT_EXPR here. */
7163 {
7167 }
7174 {
7175 r = build_nt
7180 }
7183 {
7184 r = build_nt
7190 }
7193 {
7194 r = build_nt
7200 }
7203 {
7204 /* Substituted template arguments */
7206 in_decl);
7209 {
7210 tree chain;
7213 }
7215 {
7220 }
7222 return lookup_template_function
7224 }
7227 {
7247 }
7271 {
7274 }
7275 else
7279 {
7280 r = build
7286 }
7290 in_decl),
7295 }
7296 }
7298 /* Like tsubst_copy, but also does semantic processing. */
7300 tree
7303 tsubst_flags_t complain;
7304 tree in_decl;
7305 {
7318 {
7321 finish_named_return_value
7327 {
7328 tree member_init_list;
7329 tree base_init_list;
7332 member_init_list
7334 base_init_list
7338 }
7359 {
7360 tree decl;
7361 tree init;
7368 {
7374 }
7375 else
7376 {
7380 {
7383 /* By marking the declaration as instantiated, we avoid
7384 trying to instantiate it. Since instantiate_decl can't
7385 handle local variables, and since we've already done
7386 all that needs to be done, that's the right thing to
7387 do. */
7392 /* Anonymous aggregates are a special case. */
7394 else
7395 {
7398 {
7399 /* For __PRETTY_FUNCTION__ we have to adjust the
7400 initializer. */
7405 }
7406 else
7409 }
7410 }
7411 }
7413 /* A DECL_STMT can also be used as an expression, in the condition
7414 clause of a if/for/while construct. If we aren't followed by
7415 another statement, return our decl. */
7418 }
7422 {
7430 stmt);
7435 }
7439 {
7444 stmt);
7447 }
7451 {
7458 stmt);
7459 }
7463 {
7468 stmt);
7471 {
7474 }
7477 {
7481 }
7484 }
7488 {
7492 else
7499 else
7501 }
7515 {
7516 tree val;
7524 }
7531 in_decl));
7548 /* Computed goto's must be tsubst'd into. On the other hand,
7549 non-computed gotos must not be; the identifier in question
7550 will have no binding. */
7552 else
7559 tmp = finish_asm_stmt
7571 {
7577 stmt);
7578 }
7579 else
7580 {
7583 else
7590 else
7596 else
7598 }
7602 {
7603 tree decl;
7608 {
7611 /* Prevent instantiate_decl from trying to instantiate
7612 this variable. We've already done all that needs to be
7613 done. */
7615 }
7616 else
7621 }
7635 }
7638 }
7640 /* Instantiate the indicated variable or function template TMPL with
7641 the template arguments in TARG_PTR. */
7643 tree
7646 {
7647 tree fndecl;
7648 tree gen_tmpl;
7649 tree spec;
7651 tree inner_args;
7658 /* If this function is a clone, handle it specially. */
7660 {
7662 tree clone;
7664 /* Look for the clone. */
7670 /* We should always have found the clone by now. */
7673 }
7675 /* Check to see if we already have this specialization. */
7682 {
7683 /* The TMPL is a partial instantiation. To get a full set of
7684 arguments we must add the arguments used to perform the
7685 partial instantiation. */
7687 targ_ptr);
7689 /* Check to see if we already have this specialization. */
7693 }
7699 {
7702 {
7705 {
7709 }
7710 }
7711 }
7713 /* substitute template parameters */
7716 /* The DECL_TI_TEMPLATE should always be the immediate parent
7717 template, not the most general template. */
7723 /* If we've just instantiated the main entry point for a function,
7724 instantiate all the alternate entry points as well. We do this
7725 by cloning the instantiation of the main entry point, not by
7726 instantiating the template clones. */
7731 }
7733 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
7734 arguments that are being used when calling it. TARGS is a vector
7735 into which the deduced template arguments are placed.
7737 Return zero for success, 2 for an incomplete match that doesn't resolve
7738 all the types, and 1 for complete failure. An error message will be
7739 printed only for an incomplete match.
7741 If FN is a conversion operator, or we are trying to produce a specific
7742 specialization, RETURN_TYPE is the return type desired.
7744 The EXPLICIT_TARGS are explicit template arguments provided via a
7745 template-id.
7747 The parameter STRICT is one of:
7749 DEDUCE_CALL:
7750 We are deducing arguments for a function call, as in
7751 [temp.deduct.call].
7753 DEDUCE_CONV:
7754 We are deducing arguments for a conversion function, as in
7755 [temp.deduct.conv].
7757 DEDUCE_EXACT:
7758 We are deducing arguments when doing an explicit instantiation
7759 as in [temp.explicit], when determining an explicit specialization
7760 as in [temp.expl.spec], or when taking the address of a function
7761 template, as in [temp.deduct.funcaddr].
7763 DEDUCE_ORDER:
7764 We are deducing arguments when calculating the partial
7765 ordering between specializations of function or class
7766 templates, as in [temp.func.order] and [temp.class.order].
7768 LEN is the number of parms to consider before returning success, or -1
7769 for all. This is used in partial ordering to avoid comparing parms for
7770 which no actual argument was passed, since they are not considered in
7771 overload resolution (and are explicitly excluded from consideration in
7772 partial ordering in [temp.func.order]/6). */
7774 int
7778 unification_kind_t strict;
7780 {
7781 tree parms;
7782 tree fntype;
7789 {
7790 /* [temp.deduct]
7792 The specified template arguments must match the template
7793 parameters in kind (i.e., type, nontype, template), and there
7794 must not be more arguments than there are parameters;
7795 otherwise type deduction fails.
7797 Nontype arguments must match the types of the corresponding
7798 nontype template parameters, or must be convertible to the
7799 types of the corresponding nontype parameters as specified in
7800 _temp.arg.nontype_, otherwise type deduction fails.
7802 All references in the function type of the function template
7803 to the corresponding template parameters are replaced by the
7804 specified template argument values. If a substitution in a
7805 template parameter or in the function type of the function
7806 template results in an invalid type, type deduction fails. */
7808 tree converted_args;
7810 converted_args
7821 /* Place the explicitly specified arguments in TARGS. */
7824 }
7827 /* Never do unification on the 'this' parameter. */
7832 {
7833 /* We've been given a return type to match, prepend it. */
7838 }
7840 /* We allow incomplete unification without an error message here
7841 because the standard doesn't seem to explicitly prohibit it. Our
7842 callers must be ready to deal with unification failures in any
7843 event. */
7849 /* All is well so far. Now, check:
7851 [temp.deduct]
7853 When all template arguments have been deduced, all uses of
7854 template parameters in nondeduced contexts are replaced with
7855 the corresponding deduced argument values. If the
7856 substitution results in an invalid type, as described above,
7857 type deduction fails. */
7863 }
7865 /* Adjust types before performing type deduction, as described in
7866 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
7867 sections are symmetric. PARM is the type of a function parameter
7868 or the return type of the conversion function. ARG is the type of
7869 the argument passed to the call, or the type of the value
7870 initialized with the result of the conversion function. */
7872 static int
7874 unification_kind_t strict;
7877 {
7881 {
7886 {
7887 /* Swap PARM and ARG throughout the remainder of this
7888 function; the handling is precisely symmetric since PARM
7889 will initialize ARG rather than vice versa. */
7894 }
7897 /* There is nothing to do in this case. */
7901 /* DR 214. [temp.func.order] is underspecified, and leads to no
7902 ordering between things like `T *' and `T const &' for `U *'.
7903 The former has T=U and the latter T=U*. The former looks more
7904 specialized and John Spicer considers it well-formed (the EDG
7905 compiler accepts it).
7907 John also confirms that deduction should proceed as in a function
7908 call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL.
7909 However, in ordering, ARG can have REFERENCE_TYPE, but no argument
7910 to an actual call can have such a type.
7912 If both ARG and PARM are REFERENCE_TYPE, we change neither.
7913 If only ARG is a REFERENCE_TYPE, we look through that and then
7914 proceed as with DEDUCE_CALL (which could further convert it). */
7916 {
7920 }
7924 }
7927 {
7928 /* [temp.deduct.call]
7930 If P is not a reference type:
7932 --If A is an array type, the pointer type produced by the
7933 array-to-pointer standard conversion (_conv.array_) is
7934 used in place of A for type deduction; otherwise,
7936 --If A is a function type, the pointer type produced by
7937 the function-to-pointer standard conversion
7938 (_conv.func_) is used in place of A for type deduction;
7939 otherwise,
7941 --If A is a cv-qualified type, the top level
7942 cv-qualifiers of A's type are ignored for type
7943 deduction. */
7948 else
7950 }
7952 /* [temp.deduct.call]
7954 If P is a cv-qualified type, the top level cv-qualifiers
7955 of P's type are ignored for type deduction. If P is a
7956 reference type, the type referred to by P is used for
7957 type deduction. */
7960 {
7963 }
7965 }
7967 /* Most parms like fn_type_unification.
7969 If SUBR is 1, we're being called recursively (to unify the
7970 arguments of a function or method parameter of a function
7971 template). */
7973 static int
7978 unification_kind_t strict;
7980 {
7992 /* ARGS could be NULL (via a call from parse.y to
7993 build_x_function_call). */
7999 {
8019 }
8024 again:
8031 && args
8033 {
8042 /* We can't deduce anything from this, but we might get all the
8043 template args from other function args. */
8046 /* Conversions will be performed on a function argument that
8047 corresponds with a function parameter that contains only
8048 non-deducible template parameters and explicitly specified
8049 template parameters. */
8051 {
8052 tree type;
8056 else
8057 {
8060 }
8063 {
8066 }
8067 else
8068 /* It might work; we shouldn't check now, because we might
8069 get into infinite recursion. Overload resolution will
8070 handle it. */
8074 }
8077 {
8080 {
8081 /* [temp.deduct.type] A template-argument can be deduced from
8082 a pointer to function or pointer to member function
8083 argument if the set of overloaded functions does not
8084 contain function templates and at most one of a set of
8085 overloaded functions provides a unique match. */
8092 }
8094 }
8096 {
8104 }
8106 /* Are we done with the interesting parms? */
8109 }
8110 /* Fail if we've reached the end of the parm list, and more args
8111 are present, and the parm list isn't variadic. */
8114 /* Fail if parms are left and they don't have default values. */
8120 done:
8124 {
8127 /* If this is an undeduced nontype parameter that depends on
8128 a type parameter, try another pass; its type may have been
8129 deduced from a later argument than the one from which
8130 this parameter can be deduced. */
8139 }
8141 }
8143 /* Subroutine of type_unification_real. Args are like the variables at the
8144 call site. ARG is an overloaded function (or template-id); we try
8145 deducing template args from each of the overloads, and if only one
8146 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
8148 static int
8150 sub_strict)
8152 unification_kind_t strict;
8154 {
8162 /* Handle `&x' where `x' is some static or non-static member
8163 function name. */
8169 /* Strip baselink information. */
8174 {
8175 /* If we got some explicit template args, we need to plug them into
8176 the affected templates before we try to unify, in case the
8177 explicit args will completely resolve the templates in question. */
8183 {
8191 expl_subargs);
8193 {
8199 }
8200 }
8201 }
8203 {
8205 {
8210 type,
8212 }
8213 }
8214 else
8217 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8218 to function or pointer to member function argument if the set of
8219 overloaded functions does not contain function templates and at most
8220 one of a set of overloaded functions provides a unique match.
8222 So if we found multiple possibilities, we return success but don't
8223 deduce anything. */
8226 {
8231 }
8236 }
8238 /* Subroutine of resolve_overloaded_unification; does deduction for a single
8239 overload. Fills TARGS with any deduced arguments, or error_mark_node if
8240 different overloads deduce different arguments for a given parm.
8241 Returns 1 on success. */
8243 static int
8245 sub_strict)
8247 unification_kind_t strict;
8249 {
8251 tree tempargs;
8254 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8255 to function or pointer to member function argument if the set of
8256 overloaded functions does not contain function templates and at most
8257 one of a set of overloaded functions provides a unique match.
8259 So if this is a template, just return success. */
8266 /* We don't copy orig_targs for this because if we have already deduced
8267 some template args from previous args, unify would complain when we
8268 try to deduce a template parameter for the same argument, even though
8269 there isn't really a conflict. */
8276 /* First make sure we didn't deduce anything that conflicts with
8277 explicitly specified args. */
8279 {
8286 {
8287 /* Since we're unifying against ourselves, we will fill in template
8288 args used in the function parm list with our own template parms.
8289 Discard them. */
8292 }
8295 }
8298 {
8303 }
8306 }
8308 /* Verify that nondeduce template argument agrees with the type
8309 obtained from argument deduction. Return nonzero if the
8310 verification fails.
8312 For example:
8314 struct A { typedef int X; };
8315 template <class T, class U> struct C {};
8316 template <class T> struct C<T, typename T::X> {};
8318 Then with the instantiation `C<A, int>', we can deduce that
8319 `T' is `A' but unify () does not check whether `typename T::X'
8320 is `int'. This function ensure that they agree.
8322 TARGS, PARMS are the same as the arguments of unify.
8323 ARGS contains template arguments from all levels. */
8325 static int
8328 {
8339 {
8343 /* In case we are deducing from a function argument of a function
8344 templates, some parameters may not be deduced yet. So we
8345 make sure that only fully substituted elements of PARM are
8346 compared below. */
8350 }
8352 }
8354 /* PARM is a template class (perhaps with unbound template
8355 parameters). ARG is a fully instantiated type. If ARG can be
8356 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
8357 TARGS are as for unify. */
8359 static tree
8361 tree tparms;
8362 tree targs;
8363 tree parm;
8364 tree arg;
8365 {
8366 tree copy_of_targs;
8372 /* We need to make a new template argument vector for the call to
8373 unify. If we used TARGS, we'd clutter it up with the result of
8374 the attempted unification, even if this class didn't work out.
8375 We also don't want to commit ourselves to all the unifications
8376 we've already done, since unification is supposed to be done on
8377 an argument-by-argument basis. In other words, consider the
8378 following pathological case:
8380 template <int I, int J, int K>
8381 struct S {};
8383 template <int I, int J>
8384 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
8386 template <int I, int J, int K>
8387 void f(S<I, J, K>, S<I, I, I>);
8389 void g() {
8390 S<0, 0, 0> s0;
8391 S<0, 1, 2> s2;
8393 f(s0, s2);
8394 }
8396 Now, by the time we consider the unification involving `s2', we
8397 already know that we must have `f<0, 0, 0>'. But, even though
8398 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal
8399 because there are two ways to unify base classes of S<0, 1, 2>
8400 with S<I, I, I>. If we kept the already deduced knowledge, we
8401 would reject the possibility I=1. */
8404 /* If unification failed, we're done. */
8410 }
8412 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
8413 have already discovered to be satisfactory. ARG_BINFO is the binfo
8414 for the base class of ARG that we are currently examining. */
8416 static tree
8419 tree tparms;
8420 tree targs;
8421 tree arg_binfo;
8422 tree rval;
8423 tree parm;
8425 {
8426 tree binfos;
8431 {
8435 /* If there is more than one satisfactory baseclass, then:
8437 [temp.deduct.call]
8439 If they yield more than one possible deduced A, the type
8440 deduction fails.
8442 applies. */
8447 }
8452 /* Process base types. */
8454 {
8458 /* Skip this base, if we've already seen it. */
8462 this_virtual =
8465 /* When searching for a non-virtual, we cannot mark virtually
8466 found binfos. */
8471 parm,
8472 base_binfo,
8473 rval,
8476 /* If we discovered more than one matching base class, we can
8477 stop now. */
8480 }
8483 }
8485 /* Given a template type PARM and a class type ARG, find the unique
8486 base type in ARG that is an instance of PARM. We do not examine
8487 ARG itself; only its base-classes. If there is no appropriate base
8488 class, return NULL_TREE. If there is more than one, return
8489 error_mark_node. PARM may be the type of a partial specialization,
8490 as well as a plain template type. Used by unify. */
8492 static tree
8494 tree tparms;
8495 tree targs;
8496 tree parm;
8497 tree arg;
8498 {
8499 tree rval;
8500 tree arg_binfo;
8507 NULL_TREE,
8508 GTB_IGNORE_TYPE);
8510 /* Since get_template_base_recursive marks the bases classes, we
8511 must unmark them here. */
8515 }
8517 /* Returns the level of DECL, which declares a template parameter. */
8519 static int
8521 tree decl;
8522 {
8524 {
8535 }
8536 }
8538 /* Decide whether ARG can be unified with PARM, considering only the
8539 cv-qualifiers of each type, given STRICT as documented for unify.
8540 Returns non-zero iff the unification is OK on that basis.*/
8542 static int
8545 tree arg;
8546 tree parm;
8547 {
8552 {
8553 /* If the cvr quals of parm will not unify with ARG, they'll be
8554 ignored in instantiation, so we have to do the same here. */
8562 }
8573 }
8575 /* Takes parameters as for type_unification. Returns 0 if the
8576 type deduction succeeds, 1 otherwise. The parameter STRICT is a
8577 bitwise or of the following flags:
8579 UNIFY_ALLOW_NONE:
8580 Require an exact match between PARM and ARG.
8581 UNIFY_ALLOW_MORE_CV_QUAL:
8582 Allow the deduced ARG to be more cv-qualified (by qualification
8583 conversion) than ARG.
8584 UNIFY_ALLOW_LESS_CV_QUAL:
8585 Allow the deduced ARG to be less cv-qualified than ARG.
8586 UNIFY_ALLOW_DERIVED:
8587 Allow the deduced ARG to be a template base class of ARG,
8588 or a pointer to a template base class of the type pointed to by
8589 ARG.
8590 UNIFY_ALLOW_INTEGER:
8591 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
8592 case for more information.
8593 UNIFY_ALLOW_OUTER_LEVEL:
8594 This is the outermost level of a deduction. Used to determine validity
8595 of qualification conversions. A valid qualification conversion must
8596 have const qualified pointers leading up to the inner type which
8597 requires additional CV quals, except at the outer level, where const
8598 is not required [conv.qual]. It would be normal to set this flag in
8599 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
8600 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
8601 This is the outermost level of a deduction, and PARM can be more CV
8602 qualified at this point.
8603 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
8604 This is the outermost level of a deduction, and PARM can be less CV
8605 qualified at this point.
8606 UNIFY_ALLOW_MAX_CORRECTION:
8607 This is an INTEGER_TYPE's maximum value. Used if the range may
8608 have been derived from a size specification, such as an array size.
8609 If the size was given by a nontype template parameter N, the maximum
8610 value will have the form N-1. The flag says that we can (and indeed
8611 must) unify N with (ARG + 1), an exception to the normal rules on
8612 folding PARM. */
8614 static int
8618 {
8620 tree targ;
8621 tree tparm;
8624 /* I don't think this will do the right thing with respect to types.
8625 But the only case I've seen it in so far has been array bounds, where
8626 signedness is the only information lost, and I think that will be
8627 okay. */
8634 /* We can't deduce anything from this, but we might get all the
8635 template args from other function args. */
8638 /* If PARM uses template parameters, then we can't bail out here,
8639 even if ARG == PARM, since we won't record unifications for the
8640 template parameters. We might need them if we're trying to
8641 figure out which of two things is more specialized. */
8645 /* Immediately reject some pairs that won't unify because of
8646 cv-qualification mismatches. */
8649 /* It is the elements of the array which hold the cv quals of an array
8650 type, and the elements might be template type parms. We'll check
8651 when we recurse. */
8653 /* We check the cv-qualifiers when unifying with template type
8654 parameters below. We want to allow ARG `const T' to unify with
8655 PARM `T' for example, when computing which of two templates
8656 is more specialized, for example. */
8671 {
8675 /* In a type which contains a nested-name-specifier, template
8676 argument values cannot be deduced for template parameters used
8677 within the nested-name-specifier. */
8687 /* The PARM is not one we're trying to unify. Just check
8688 to see if it matches ARG. */
8695 /* Check for mixed types and values. */
8703 {
8704 /* ARG must be constructed from a template class or a template
8705 template parameter. */
8710 {
8714 tree argtmplvec
8718 /* The parameter and argument roles have to be switched here
8719 in order to handle default arguments properly. For example,
8720 template<template <class> class TT> void f(TT<int>)
8721 should be able to accept vector<int> which comes from
8722 template <class T, class Allocator = allocator>
8723 class vector. */
8729 /* Deduce arguments T, i from TT<T> or TT<i>.
8730 We check each element of PARMVEC and ARGVEC individually
8731 rather than the whole TREE_VEC since they can have
8732 different number of elements. */
8735 {
8740 UNIFY_ALLOW_NONE))
8742 }
8743 }
8746 /* Fall through to deduce template name. */
8747 }
8751 {
8752 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
8754 /* Simple cases: Value already set, does match or doesn't. */
8759 }
8760 else
8761 {
8762 /* If PARM is `const T' and ARG is only `int', we don't have
8763 a match unless we are allowing additional qualification.
8764 If ARG is `const int' and PARM is just `T' that's OK;
8765 that binds `const int' to `T'. */
8770 /* Consider the case where ARG is `const volatile int' and
8771 PARM is `const T'. Then, T should be `volatile int'. */
8772 arg = cp_build_qualified_type_real
8777 /* Simple cases: Value already set, does match or doesn't. */
8782 }
8784 /* Make sure that ARG is not a variable-sized array. (Note that
8785 were talking about variable-sized arrays (like `int[n]'),
8786 rather than arrays of unknown size (like `int[]').) We'll
8787 get very confused by such a type since the bound of the array
8788 will not be computable in an instantiation. Besides, such
8789 types are not allowed in ISO C++, so we can do as we please
8790 here. */
8806 /* The PARM is not one we're trying to unify. Just check
8807 to see if it matches ARG. */
8815 {
8821 else
8823 }
8825 /* [temp.deduct.type] If, in the declaration of a function template
8826 with a non-type template-parameter, the non-type
8827 template-parameter is used in an expression in the function
8828 parameter-list and, if the corresponding template-argument is
8829 deduced, the template-argument type shall match the type of the
8830 template-parameter exactly, except that a template-argument
8831 deduced from an array bound may be of any integral type.
8832 The non-type parameter might use already deduced type parameters. */
8841 /* We haven't deduced the type of this parameter yet. Try again
8842 later. */
8844 else
8851 {
8855 /* [temp.deduct.call]
8857 A can be another pointer or pointer to member type that can
8858 be converted to the deduced A via a qualification
8859 conversion (_conv.qual_).
8861 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
8862 This will allow for additional cv-qualification of the
8863 pointed-to types if appropriate. */
8866 /* The derived-to-base conversion only persists through one
8867 level of pointers. */
8872 {
8873 /* Avoid getting confused about cv-quals; don't recurse here.
8874 Pointers to members should really be just OFFSET_TYPE, not
8875 this two-level nonsense... */
8880 }
8884 }
8903 UNIFY_ALLOW_NONE);
8916 {
8926 }
8927 /* We have already checked cv-qualification at the top of the
8928 function. */
8932 /* As far as unification is concerned, this wins. Later checks
8933 will invalidate it if necessary. */
8936 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
8937 /* Type INTEGER_CST can come from ordinary constant template args. */
8947 {
8956 UNIFY_ALLOW_NONE))
8959 }
8967 {
8974 strict);
8975 }
8978 {
8982 {
8983 /* First, we try to unify the PARM and ARG directly. */
8988 {
8989 /* Fallback to the special case allowed in
8990 [temp.deduct.call]:
8992 If P is a class, and P has the form
8993 template-id, then A can be a derived class of
8994 the deduced A. Likewise, if P is a pointer to
8995 a class of the form template-id, A can be a
8996 pointer to a derived class pointed to by the
8997 deduced A. */
9003 }
9004 }
9008 /* Perhaps PARM is something like S<U> and ARG is S<int>.
9009 Then, we should unify `int' and `U'. */
9011 else
9012 /* There's no chance of unification succeeding. */
9017 }
9035 offset:
9042 strict);
9050 /* Matched cases are handled by the ARG == PARM test above. */
9056 {
9057 /* We handle this case specially, since it comes up with
9058 arrays. In particular, something like:
9060 template <int N> void f(int (&x)[N]);
9062 Here, we are trying to unify the range type, which
9063 looks like [0 ... (N - 1)]. */
9071 }
9072 /* else fall through */
9076 {
9078 /* We're looking at an expression. This can happen with
9079 something like:
9081 template <int I>
9082 void foo(S<I>, S<I + 2>);
9084 This is a "nondeduced context":
9086 [deduct.type]
9088 The nondeduced contexts are:
9090 --A type that is a template-id in which one or more of
9091 the template-arguments is an expression that references
9092 a template-parameter.
9094 In these cases, we assume deduction succeeded, but don't
9095 actually infer any unifications. */
9100 else
9102 }
9103 else
9108 }
9109 }
9110 \f
9111 /* Called if RESULT is explicitly instantiated, or is a member of an
9112 explicitly instantiated class, or if using -frepo and the
9113 instantiation of RESULT has been assigned to this file. */
9115 void
9117 tree result;
9119 {
9121 /* The TREE_PUBLIC flag for function declarations will have been
9122 set correctly by tsubst. */
9125 /* We used to set this unconditionally; we moved that to
9126 do_decl_instantiation so it wouldn't get set on members of
9127 explicit class template instantiations. But we still need to set
9128 it here for the 'extern template' case in order to suppress
9129 implicit instantiations. */
9134 {
9138 /* Always make artificials weak. */
9141 /* For WIN32 we also want to put explicit instantiations in
9142 linkonce sections. */
9145 }
9148 }
9150 /* Given two function templates PAT1 and PAT2, return:
9152 DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER.
9154 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
9155 -1 if PAT2 is more specialized than PAT1.
9156 0 if neither is more specialized.
9158 LEN is passed through to fn_type_unification. */
9160 int
9165 {
9166 tree targs;
9180 }
9182 /* Given two class template specialization list nodes PAT1 and PAT2, return:
9184 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
9185 -1 if PAT2 is more specialized than PAT1.
9186 0 if neither is more specialized. */
9188 int
9191 {
9192 tree targs;
9206 }
9208 /* Return the template arguments that will produce the function signature
9209 DECL from the function template FN, with the explicit template
9210 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
9211 also match. Return NULL_TREE if no satisfactory arguments could be
9212 found. DEDUCE and LEN are passed through to fn_type_unification. */
9214 static tree
9218 {
9221 tree decl_type;
9222 tree decl_arg_types;
9225 /* Substitute the explicit template arguments into the type of DECL.
9226 The call to fn_type_unification will handle substitution into the
9227 FN. */
9230 {
9231 tree tmpl;
9232 tree converted_args;
9236 else
9237 /* We can get here for some illegal specializations. */
9240 converted_args
9250 }
9253 /* Never do unification on the 'this' parameter. */
9258 decl_arg_types,
9267 }
9269 /* For most uses, we want to check the return type. */
9271 tree
9274 {
9276 }
9278 /* But for resolve_overloaded_unification, we only care about the parameter
9279 types. */
9281 static tree
9284 {
9286 }
9288 /* Return the innermost template arguments that, when applied to a
9289 template specialization whose innermost template parameters are
9290 TPARMS, and whose specialization arguments are PARMS, yield the
9291 ARGS.
9293 For example, suppose we have:
9295 template <class T, class U> struct S {};
9296 template <class T> struct S<T*, int> {};
9298 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
9299 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
9300 int}. The resulting vector will be {double}, indicating that `T'
9301 is bound to `double'. */
9303 static tree
9306 {
9311 UNIFY_ALLOW_NONE))
9322 }
9324 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
9325 Pick the most specialized template, and return the corresponding
9326 instantiation, or if there is no corresponding instantiation, the
9327 template itself. If there is no most specialized template,
9328 error_mark_node is returned. If there are no templates at all,
9329 NULL_TREE is returned. */
9331 tree
9333 tree instantiations;
9334 {
9343 {
9347 ;
9348 else
9349 {
9351 {
9355 }
9357 }
9358 }
9361 {
9366 }
9369 }
9371 /* Return the most specialized of the list of templates in FNS that can
9372 produce an instantiation matching DECL, given the explicit template
9373 arguments EXPLICIT_ARGS. */
9375 static tree
9378 {
9383 {
9389 }
9392 }
9394 /* If DECL is a specialization of some template, return the most
9395 general such template. Otherwise, returns NULL_TREE.
9397 For example, given:
9399 template <class T> struct S { template <class U> void f(U); };
9401 if TMPL is `template <class U> void S<int>::f(U)' this will return
9402 the full template. This function will not trace past partial
9403 specializations, however. For example, given in addition:
9405 template <class T> struct S<T*> { template <class U> void f(U); };
9407 if TMPL is `template <class U> void S<int*>::f(U)' this will return
9408 `template <class T> template <class U> S<T*>::f(U)'. */
9410 tree
9412 tree decl;
9413 {
9414 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
9415 an immediate specialization. */
9417 {
9421 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
9422 template friend. */
9427 }
9429 /* Look for more and more general templates. */
9431 {
9432 /* The DECL_TI_TEMPLATE can be a LOOKUP_EXPR or IDENTIFIER_NODE
9433 in some cases. (See cp-tree.h for details.) */
9437 /* Stop if we run into an explicitly specialized class template. */
9444 }
9447 }
9449 /* Return the most specialized of the class template specializations
9450 of TMPL which can produce an instantiation matching ARGS, or
9451 error_mark_node if the choice is ambiguous. */
9453 static tree
9455 tree tmpl;
9456 tree args;
9457 {
9459 tree t;
9460 tree champ;
9465 {
9466 tree spec_args
9469 {
9472 }
9473 }
9482 {
9485 ;
9486 else
9487 {
9489 {
9493 }
9495 }
9496 }
9499 {
9503 }
9506 }
9508 /* called from the parser. */
9510 void
9513 {
9519 /* An error occurred, for which grokdeclarator has already issued
9520 an appropriate message. */
9523 {
9526 }
9528 {
9529 /* There is an asymmetry here in the way VAR_DECLs and
9530 FUNCTION_DECLs are handled by grokdeclarator. In the case of
9531 the latter, the DECL we get back will be marked as a
9532 template instantiation, and the appropriate
9533 DECL_TEMPLATE_INFO will be set up. This does not happen for
9534 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
9535 should handle VAR_DECLs as it currently handles
9536 FUNCTION_DECLs. */
9539 {
9542 }
9543 }
9545 {
9548 }
9549 else
9552 /* Check for various error cases. Note that if the explicit
9553 instantiation is legal the RESULT will currently be marked as an
9554 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
9555 until we get here. */
9558 {
9559 /* DR 259 [temp.spec].
9561 Both an explicit instantiation and a declaration of an explicit
9562 specialization shall not appear in a program unless the explicit
9563 instantiation follows a declaration of the explicit specialization.
9565 For a given set of template parameters, if an explicit
9566 instantiation of a template appears after a declaration of an
9567 explicit specialization for that template, the explicit
9568 instantiation has no effect. */
9570 }
9572 {
9573 /* [temp.spec]
9575 No program shall explicitly instantiate any template more
9576 than once.
9578 We check DECL_INTERFACE_KNOWN so as not to complain when the first
9579 instantiation was `extern' and the second is not, and EXTERN_P for
9580 the opposite case. If -frepo, chances are we already got marked
9581 as an explicit instantiation because of the repo file. */
9585 /* If we've already instantiated the template, just return now. */
9588 }
9590 {
9593 }
9595 {
9598 }
9604 ;
9606 {
9610 }
9611 else
9613 storage);
9620 }
9622 void
9624 tree t;
9626 {
9632 {
9635 }
9636 }
9638 /* Perform an explicit instantiation of template class T. STORAGE, if
9639 non-null, is the RID for extern, inline or static. COMPLAIN is
9640 non-zero if this is called from the parser, zero if called recursively,
9641 since the standard is unclear (as detailed below). */
9643 void
9646 tsubst_flags_t complain;
9647 {
9656 {
9659 }
9663 /* With -fexternal-templates, explicit instantiations are treated the same
9664 as implicit ones. */
9669 {
9672 t);
9674 }
9677 {
9688 else
9689 {
9691 storage);
9693 }
9694 }
9697 {
9698 /* DR 259 [temp.spec].
9700 Both an explicit instantiation and a declaration of an explicit
9701 specialization shall not appear in a program unless the explicit
9702 instantiation follows a declaration of the explicit specialization.
9704 For a given set of template parameters, if an explicit
9705 instantiation of a template appears after a declaration of an
9706 explicit specialization for that template, the explicit
9707 instantiation has no effect. */
9709 }
9711 {
9712 /* [temp.spec]
9714 No program shall explicitly instantiate any template more
9715 than once.
9717 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
9718 was `extern'. If EXTERN_P then the second is. If -frepo, chances
9719 are we already got marked as an explicit instantiation because of the
9720 repo file. All these cases are OK. */
9725 /* If we've already instantiated the template, just return now. */
9728 }
9736 {
9737 tree tmp;
9739 /* In contrast to implicit instantiation, where only the
9740 declarations, and not the definitions, of members are
9741 instantiated, we have here:
9743 [temp.explicit]
9745 The explicit instantiation of a class template specialization
9746 implies the instantiation of all of its members not
9747 previously explicitly specialized in the translation unit
9748 containing the explicit instantiation.
9750 Of course, we can't instantiate member template classes, since
9751 we don't have any arguments for them. Note that the standard
9752 is unclear on whether the instantiation of the members are
9753 *explicit* instantiations or not. We choose to be generous,
9754 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
9755 the explicit instantiation of a class where some of the members
9756 have no definition in the current translation unit. */
9762 {
9767 }
9771 {
9776 }
9782 }
9783 }
9785 /* Given a function DECL, which is a specialization of TMPL, modify
9786 DECL to be a re-instantiation of TMPL with the same template
9787 arguments. TMPL should be the template into which tsubst'ing
9788 should occur for DECL, not the most general template.
9790 One reason for doing this is a scenario like this:
9792 template <class T>
9793 void f(const T&, int i);
9795 void g() { f(3, 7); }
9797 template <class T>
9798 void f(const T& t, const int i) { }
9800 Note that when the template is first instantiated, with
9801 instantiate_template, the resulting DECL will have no name for the
9802 first parameter, and the wrong type for the second. So, when we go
9803 to instantiate the DECL, we regenerate it. */
9805 static void
9807 tree decl;
9808 tree tmpl;
9809 {
9810 /* The most general version of TMPL. */
9811 tree gen_tmpl;
9812 /* The arguments used to instantiate DECL, from the most general
9813 template. */
9814 tree args;
9815 tree code_pattern;
9816 tree new_decl;
9822 /* Unregister the specialization so that when we tsubst we will not
9823 just return DECL. We don't have to unregister DECL from TMPL
9824 because if would only be registered there if it were a partial
9825 instantiation of a specialization, which it isn't: it's a full
9826 instantiation. */
9830 /* If the DECL was not unregistered then something peculiar is
9831 happening: we created a specialization but did not call
9832 register_specialization for it. */
9836 /* Make sure that we can see identifiers, and compute access
9837 correctly, for the class members used in the declaration of
9838 this static variable. */
9841 /* Do the substitution to get the new declaration. */
9845 {
9846 /* Set up DECL_INITIAL, since tsubst doesn't. */
9850 /* Pop the class context we pushed above. */
9852 }
9854 {
9855 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
9856 new decl. */
9858 /* And don't complain about a duplicate definition. */
9860 }
9862 /* The immediate parent of the new template is still whatever it was
9863 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
9864 general template. We also reset the DECL_ASSEMBLER_NAME since
9865 tsubst always calculates the name as if the function in question
9866 were really a template instance, and sometimes, with friend
9867 functions, this is not so. See tsubst_friend_function for
9868 details. */
9874 /* Call duplicate decls to merge the old and new declarations. */
9877 /* Now, re-register the specialization. */
9879 }
9881 /* Produce the definition of D, a _DECL generated from a template. If
9882 DEFER_OK is non-zero, then we don't have to actually do the
9883 instantiation now; we just have to do it sometime. */
9885 tree
9887 tree d;
9889 {
9892 tree td;
9893 tree code_pattern;
9894 tree spec;
9895 tree gen_tmpl;
9901 /* This function should only be used to instantiate templates for
9902 functions and static member variables. */
9906 /* Don't instantiate cloned functions. Instead, instantiate the
9907 functions they cloned. */
9912 /* D has already been instantiated. It might seem reasonable to
9913 check whether or not D is an explicit instantiation, and, if so,
9914 stop here. But when an explicit instantiation is deferred
9915 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
9916 is set, even though we still need to do the instantiation. */
9919 /* If we already have a specialization of this declaration, then
9920 there's no reason to instantiate it. Note that
9921 retrieve_specialization gives us both instantiations and
9922 specializations, so we must explicitly check
9923 DECL_TEMPLATE_SPECIALIZATION. */
9929 /* This needs to happen before any tsubsting. */
9935 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
9936 for the instantiation. This is not always the most general
9937 template. Consider, for example:
9939 template <class T>
9940 struct S { template <class U> void f();
9941 template <> void f<int>(); };
9943 and an instantiation of S<double>::f<int>. We want TD to be the
9944 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
9947 more general template. */
9949 /* We must also deal with friend templates. Given:
9951 template <class T> struct S {
9952 template <class U> friend void f() {};
9953 };
9955 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
9956 so far as the language is concerned, but that's still
9957 where we get the pattern for the instantiation from. On
9958 other hand, if the definition comes outside the class, say:
9960 template <class T> struct S {
9961 template <class U> friend void f();
9962 };
9963 template <class U> friend void f() {}
9965 we don't need to look any further. That's what the check for
9966 DECL_INITIAL is for. */
9970 {
9971 /* The present template, TD, should not be a definition. If it
9972 were a definition, we should be using it! Note that we
9973 cannot restructure the loop to just keep going until we find
9974 a template with a definition, since that might go too far if
9975 a specialization was declared, but not defined. */
9980 /* Fetch the more general template. */
9982 }
9988 else
9995 {
9996 /* Let the repository code that this template definition is
9997 available.
9999 The repository doesn't need to know about cloned functions
10000 because they never actually show up in the object file. It
10001 does need to know about the clones; those are the symbols
10002 that the linker will be emitting error messages about. */
10005 {
10006 tree t;
10012 }
10013 else
10017 {
10019 {
10022 }
10024 {
10027 }
10028 else
10030 }
10034 }
10037 {
10038 /* Recheck the substitutions to obtain any warning messages
10039 about ignoring cv qualifiers. */
10044 {
10048 /* Don't simply tsubst the function type, as that will give
10049 duplicate warnings about poor parameter qualifications.
10050 The function arguments are the same as the decl_arguments
10051 without the top level cv qualifiers. */
10053 }
10055 }
10059 /* We should have set up DECL_INITIAL in instantiate_class_template. */
10061 /* Reject all external templates except inline functions. */
10067 /* Defer all other templates, unless we have been explicitly
10068 forbidden from doing so. We restore the source position here
10069 because it's used by add_pending_template. */
10071 {
10077 /* [temp.explicit]
10079 The definition of a non-exported function template, a
10080 non-exported member function template, or a non-exported
10081 member function or static data member of a class template
10082 shall be present in every translation unit in which it is
10083 explicitly instantiated. */
10084 pedwarn
10089 }
10095 /* We're now committed to instantiating this template. Mark it as
10096 instantiated so that recursive calls to instantiate_decl do not
10097 try to instantiate it again. */
10100 /* Regenerate the declaration in case the template has been modified
10101 by a subsequent redeclaration. */
10104 /* We already set the file and line above. Reset them now in case
10105 they changed as a result of calling regenerate_decl_from_template. */
10110 {
10114 else
10115 {
10118 }
10120 }
10122 {
10123 htab_t saved_local_specializations;
10125 /* Save away the current list, in case we are instantiating one
10126 template from within the body of another. */
10129 /* Set up the list of local specializations. */
10131 htab_hash_pointer,
10132 htab_eq_pointer,
10133 NULL);
10135 /* Set up context. */
10138 /* Substitute into the body of the function. */
10142 /* We don't need the local specializations any more. */
10146 /* Finish the function. */
10148 }
10150 /* We're not deferring instantiation any more. */
10156 out:
10165 }
10167 /* Run through the list of templates that we wish we could
10168 instantiate, and instantiate any we can. */
10170 int
10172 {
10178 do
10179 {
10184 {
10190 {
10191 tree fn;
10194 {
10198 fn;
10203 {
10206 }
10207 }
10210 /* If INSTANTIATION has been instantiated, then we don't
10211 need to consider it again in the future. */
10213 else
10214 {
10217 }
10218 }
10219 else
10220 {
10223 {
10227 {
10230 }
10231 }
10235 /* If INSTANTIATION has been instantiated, then we don't
10236 need to consider it again in the future. */
10238 else
10239 {
10242 }
10243 }
10246 }
10248 }
10252 }
10254 /* Substitute ARGVEC into T, which is a list of initializers for
10255 either base class or a non-static data member. The TREE_PURPOSEs
10256 are DECLs, and the TREE_VALUEs are the initializer values. Used by
10257 instantiate_decl. */
10259 static tree
10262 {
10267 {
10268 tree decl;
10269 tree init;
10270 tree val;
10273 NULL_TREE);
10275 NULL_TREE);
10278 ;
10282 else
10289 }
10291 }
10293 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
10295 static void
10297 tree decl;
10298 {
10303 else
10305 }
10307 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
10308 is the instantiation (which should have been created with
10309 start_enum) and ARGS are the template arguments to use. */
10311 static void
10313 tree tag;
10314 tree newtag;
10315 tree args;
10316 {
10317 tree e;
10320 {
10321 tree value;
10323 /* Note that in a template enum, the TREE_VALUE is the
10324 CONST_DECL, not the corresponding INTEGER_CST. */
10327 NULL_TREE);
10329 /* Give this enumeration constant the correct access. */
10332 /* Actually build the enumerator itself. */
10334 }
10339 }
10341 /* DECL is a FUNCTION_DECL that is a template specialization. Return
10342 its type -- but without substituting the innermost set of template
10343 arguments. So, innermost set of template parameters will appear in
10344 the type. If CONTEXTP is non-NULL, then the partially substituted
10345 DECL_CONTEXT (if any) will also be filled in. Similarly, TPARMSP
10346 will be filled in with the substituted template parameters, if it
10347 is non-NULL. */
10349 tree
10351 tree decl;
10354 {
10356 tree fn_type;
10357 tree tmpl;
10358 tree targs;
10359 tree tparms;
10367 /* There should be as many levels of arguments as there are levels
10368 of parameters. */
10376 /* No substitution is necessary. */
10377 ;
10378 else
10379 {
10381 tree partial_args;
10383 /* Replace the innermost level of the TARGS with NULL_TREEs to
10384 let tsubst know not to substitute for those parameters. */
10393 /* Now, do the (partial) substitution to figure out the
10394 appropriate function type. */
10399 /* Substitute into the template parameters to obtain the real
10400 innermost set of parameters. This step is important if the
10401 innermost set of template parameters contains value
10402 parameters whose types depend on outer template parameters. */
10405 }
10413 }
10415 /* Return truthvalue if we're processing a template different from
10416 the last one involved in diagnostics. */
10417 int
10419 {
10421 }
10423 /* Remember current template involved in diagnostics. */
10424 void
10426 {
10428 }
10430 tree
10432 {
10434 }
10436 /* [temp.param] Check that template non-type parm TYPE is of an allowable
10437 type. Return zero for ok, non-zero for disallowed. Issue error and
10438 warning messages under control of COMPLAIN. */
10440 static int
10442 tree type;
10443 tsubst_flags_t complain;
10444 {
10460 type);
10462 }