| blob | 9455e976074c5baa012e46b496b140ade6dc9be1 |
2 /* Compiler implementation of the D programming language
3 * Copyright (C) 1999-2018 by The D Language Foundation, All Rights Reserved
4 * written by Walter Bright
5 * http://www.digitalmars.com
6 * Distributed under the Boost Software License, Version 1.0.
7 * http://www.boost.org/LICENSE_1_0.txt
8 * https://github.com/D-Programming-Language/dmd/blob/master/src/template.c
9 */
11 // Handle template implementation
53 /********************************************
54 * These functions substitute for dynamic_cast. dynamic_cast does not work
55 * on earlier versions of gcc.
56 */
59 {
60 //return dynamic_cast<Expression *>(o);
64 }
67 {
68 //return dynamic_cast<Dsymbol *>(o);
72 }
75 {
76 //return dynamic_cast<Type *>(o);
80 }
83 {
84 //return dynamic_cast<Tuple *>(o);
88 }
91 {
92 //return dynamic_cast<Parameter *>(o);
96 }
98 /**************************************
99 * Is this Object an error?
100 */
102 {
117 }
119 /**************************************
120 * Are any of the Objects an error?
121 */
123 {
125 {
129 }
131 }
133 /***********************
134 * Try to get arg as a type.
135 */
138 {
141 {
145 }
147 }
150 {
151 //printf("getDsymbol()\n");
152 //printf("e %p s %p t %p v %p\n", isExpression(oarg), isDsymbol(oarg), isType(oarg), isTuple(oarg));
157 {
158 // Try to convert Expression to symbol
162 {
165 else
167 }
170 else
172 }
173 else
174 {
175 // Try to convert Type to symbol
179 else
181 }
183 }
185 /***********************
186 * Try to get value from manifest constant
187 */
190 {
192 {
195 {
197 }
198 }
200 }
203 {
206 {
209 {
211 }
212 }
214 }
216 /**********************************
217 * Return true if e could be valid only as a template value parameter.
218 * Return false if it might be an alias or tuple.
219 * (Note that even in this case, it could still turn out to be a value).
220 */
222 {
223 // None of these can be value parameters
234 /* Template instantiations involving a DotVar expression are difficult.
235 * In most cases, they should be treated as a value parameter, and interpreted.
236 * But they might also just be a fully qualified name, which should be treated
237 * as an alias.
238 */
240 // x.y.f cannot be a value
246 {
248 }
249 // this.x.y and super.x.y couldn't possibly be valid values.
253 // e.type.x could be an alias
257 // var.x.y is the only other possible form of alias
263 // func.x.y is not an alias
267 // TODO: Should we force CTFE if it is a global constant?
270 }
273 {
276 }
278 /******************************
279 * If o1 matches o2, return true.
280 * Else, return false.
281 */
284 {
285 //printf("match() o1 = %p %s (%d), o2 = %p %s (%d)\n",
286 // o1, o1->toChars(), o1->dyncast(), o2, o2->toChars(), o2->dyncast());
288 /* A proper implementation of the various equals() overrides
289 * should make it possible to just do o1->equals(o2), but
290 * we'll do that another day.
291 */
293 /* Manifest constants should be compared by their values,
294 * at least in template arguments.
295 */
298 {
303 //printf("\tt1 = %s\n", t1->toChars());
304 //printf("\tt2 = %s\n", t2->toChars());
309 }
311 {
316 //printf("\te1 = %s %s %s\n", e1->type->toChars(), Token::toChars(e1->op), e1->toChars());
317 //printf("\te2 = %s %s %s\n", e2->type->toChars(), Token::toChars(e2->op), e2->toChars());
319 // two expressions can be equal although they do not have the same
320 // type; that happens when they have the same value. So check type
321 // as well as expression equality to ensure templates are properly
322 // matched.
327 }
329 {
334 //printf("\ts1 = %s\n", s1->toChars());
335 //printf("\ts2 = %s\n", s2->toChars());
342 }
344 {
349 //printf("\tu1 = %s\n", u1->toChars());
350 //printf("\tu2 = %s\n", u2->toChars());
355 }
356 Lmatch:
357 //printf("\t-> match\n");
360 Lnomatch:
361 //printf("\t-> nomatch\n");
363 }
366 /************************************
367 * Match an array of them.
368 */
370 {
376 {
380 {
382 }
383 }
385 }
388 /************************************
389 * Computes hash of expression.
390 * Handles all Expression classes and MUST match their equals method,
391 * i.e. e1->equals(e2) implies expressionHash(e1) == expressionHash(e2).
392 */
394 {
396 {
404 {
407 }
416 {
419 }
422 {
427 {
430 }
432 }
435 {
441 }
444 {
448 // reduction needs associative op as keys are unsorted (use XOR)
451 }
454 {
458 {
461 }
463 }
472 // no custom equals for this expression
473 // equals based on identity
475 }
476 }
479 /************************************
480 * Return hash of Objects.
481 */
483 {
486 {
487 /* Must follow the logic of match()
488 */
495 {
500 }
503 }
505 }
508 {
516 }
519 /* ======================== TemplateDeclaration ============================= */
522 TemplateParameters *parameters, Expression *constraint, Dsymbols *decldefs, bool ismixin, bool literal)
524 {
541 // Compute in advance for Ddoc's use
542 // Bugzilla 11153: ident could be NULL if parsing fails.
544 {
547 {
550 }
551 }
552 }
555 {
556 //printf("TemplateDeclaration::syntaxCopy()\n");
559 {
564 }
568 }
571 {
575 // Remember templates defined in module object that we need to know about
577 {
580 }
582 /* Remember Scope for later instantiations, but make
583 * a copy since attributes can change.
584 */
586 {
589 }
598 {
601 }
603 // Set up scope for parameters
610 {
614 {
617 }
618 }
621 {
625 {
628 }
630 {
632 }
634 {
637 }
638 }
640 /* Calculate TemplateParameter::dependent
641 */
642 TemplateParameters tparams;
645 {
650 {
651 // Skip cases like: X(T : T)
656 {
659 }
661 {
664 {
666 }
667 }
668 }
669 }
673 // Compute again
676 {
679 {
682 }
683 }
685 /* BUG: should check:
686 * o no virtual functions or non-static data members of classes
687 */
688 }
691 {
695 }
697 /**********************************
698 * Overload existing TemplateDeclaration 'this' with the new one 's'.
699 * Return true if successful; i.e. no conflict.
700 */
703 {
706 {
711 }
720 {
721 }
726 }
728 /****************************
729 * Check to see if constraint is satisfied.
730 */
734 {
735 /* Detect recursive attempts to instantiate this template declaration,
736 * Bugzilla 4072
737 * void foo(T)(T x) if (is(typeof(foo(x)))) { }
738 * static assert(!is(typeof(foo(7))));
739 * Recursive attempts are regarded as a constraint failure.
740 */
741 /* There's a chicken-and-egg problem here. We don't know yet if this template
742 * instantiation will be a local one (enclosing is set), and we won't know until
743 * after selecting the correct template. Thus, function we're nesting inside
744 * is not on the sc scope chain, and this can cause errors in FuncDeclaration::getLevel().
745 * Workaround the problem by setting a flag to relax the checking on frame errors.
746 */
749 {
751 {
752 //printf("recursive, no match p->sc=%p %p %s\n", p->sc, this, this->toChars());
753 /* It must be a subscope of p->sc, other scope chains are not recursive
754 * instantiations.
755 */
757 {
760 }
761 }
762 /* BUG: should also check for ref param differences
763 */
764 }
766 TemplatePrevious pr;
779 {
780 /* Declare all the function parameters as variables and add them to the scope
781 * Making parameters is similar to FuncDeclaration::semantic3
782 */
793 {
795 fparam->storageClass &= (STCin | STCout | STCref | STClazy | STCfinal | STC_TYPECTOR | STCnodtor);
799 }
801 {
812 else
814 }
819 }
836 }
838 /***************************************
839 * Given that ti is an instance of this TemplateDeclaration,
840 * deduce the types of the parameters to this, and store
841 * those deduced types in dedtypes[].
842 * Input:
843 * flag 1: don't do semantic() because of dummy types
844 * 2: don't change types in matchArg()
845 * Output:
846 * dedtypes deduced arguments
847 * Return match level.
848 */
852 {
853 MATCH m;
864 // If more arguments than parameters, no match
866 {
868 }
875 // Set up scope for template parameters
884 // Attempt type deduction
887 {
888 MATCH m2;
892 //printf("\targument [%d]\n", i);
894 //printf("\tm2 = %d\n", m2);
897 {
899 }
908 // then we don't need to make sparam if flags == 0
909 }
912 {
913 /* Any parameter left without a type gets the type of
914 * its corresponding arg
915 */
917 {
919 {
922 }
923 }
924 }
927 {
930 else
933 // Similar to doHeaderInstantiation
936 {
944 // Shouldn't run semantic on default arguments and return type.
949 // Resolve parameter types and 'auto ref's.
954 {
957 }
960 }
962 // TODO: dedtypes => ti->tiargs ?
965 }
969 Lnomatch:
972 Lret:
975 }
977 /********************************************
978 * Determine partial specialization order of 'this' vs td2.
979 * Returns:
980 * match this is at least as specialized as td2
981 * 0 td2 is more specialized than this
982 */
984 MATCH TemplateDeclaration::leastAsSpecialized(Scope *sc, TemplateDeclaration *td2, Expressions *fargs)
985 {
986 /* This works by taking the template parameters to this template
987 * declaration and feeding them to td2 as if it were a template
988 * instance.
989 * If it works, then this template is at least as specialized
990 * as td2.
991 */
994 // Set type arguments to dummy template instance to be types
995 // generated from the parameters to this template declaration
999 {
1008 }
1010 // Temporary Array to hold deduced types
1011 Objects dedtypes;
1014 // Attempt a type deduction
1017 {
1018 /* A non-variadic template is more specialized than a
1019 * variadic one.
1020 */
1026 }
1027 L1:
1029 }
1034 {
1042 {
1046 }
1049 {
1050 }
1053 {
1056 }
1058 {
1062 }
1064 {
1067 {
1080 }
1082 }
1083 };
1085 /*************************************************
1086 * Match function arguments against a specific template function.
1087 * Input:
1088 * ti
1089 * sc instantiation scope
1090 * fd
1091 * tthis 'this' argument if !NULL
1092 * fargs arguments to function
1093 * Output:
1094 * fd Partially instantiated function declaration
1095 * ti->tdtypes Expression/Type deduced template arguments
1096 * Returns:
1097 * match level
1098 * bit 0-3 Match template parameters by inferred template arguments
1099 * bit 4-7 Match template parameters by initial template arguments
1100 */
1105 {
1133 // Set up scope for parameters
1147 {
1148 // Set initial template arguments
1152 n--;
1154 {
1158 /* The extra initial template arguments
1159 * now form the tuple argument.
1160 */
1167 {
1169 }
1172 }
1173 else
1179 {
1182 MATCH m = (*parameters)[i]->matchArg(instLoc, paramscope, dedargs, i, parameters, dedtypes, &sparam);
1183 //printf("\tdeduceType m = %d\n", m);
1192 }
1194 {
1196 }
1197 else
1199 //printf("tiargs matchTiargs = %d\n", matchTiargs);
1200 }
1206 /* Check for match of function arguments with variadic template
1207 * parameter, such as:
1208 *
1209 * void foo(T, A...)(T t, A a);
1210 * void main() { foo(1,2,3); }
1211 */
1213 {
1214 // TemplateTupleParameter always makes most lesser matching.
1218 {
1220 {
1222 //printf("t = %p\n", t);
1226 }
1227 }
1228 else
1229 {
1230 /* Figure out which of the function parameters matches
1231 * the tuple template parameter. Do this by matching
1232 * type identifiers.
1233 * Set the index of this function parameter to fptupindex.
1234 */
1236 {
1248 }
1250 L1:
1251 ;
1252 }
1253 }
1258 {
1261 // Match 'tthis' to any TemplateThisParameter's
1263 {
1266 {
1275 }
1276 }
1278 // Match attributes of tthis against attributes of fd
1280 {
1282 // Propagate parent storage class (see bug 5504)
1293 else
1294 {
1301 }
1311 }
1312 }
1314 // Loop through the function parameters
1315 {
1316 //printf("%s\n\tnfargs = %d, nfparams = %d, tuple_dim = %d\n", toChars(), nfargs, nfparams, declaredTuple ? declaredTuple->objects.dim : 0);
1317 //printf("\ttp = %p, fptupindex = %d, found = %d, declaredTuple = %s\n", tp, fptupindex, fptupindex != IDX_NOTFOUND, declaredTuple ? declaredTuple->toChars() : NULL);
1321 {
1324 // Apply function parameter storage classes to parameter types
1329 /* See function parameters which wound up
1330 * as part of a template tuple parameter.
1331 */
1333 {
1337 {
1338 /* The types of the function arguments
1339 * now form the tuple argument.
1340 */
1344 /* Count function parameters following a tuple parameter.
1345 * void foo(U, T...)(int y, T, U, int) {} // rem == 2 (U, int)
1346 */
1349 {
1352 {
1355 }
1356 else
1357 {
1359 }
1360 }
1366 {
1369 // Check invalid arguments to detect errors early.
1377 MATCH m;
1379 {
1382 }
1383 else
1384 {
1386 }
1392 /* Remove top const for dynamic array types and pointer types
1393 */
1398 {
1400 }
1402 }
1404 }
1405 else
1406 {
1407 // Bugzilla 6810: If declared tuple is not a type tuple,
1408 // it cannot be function parameter types.
1410 {
1413 }
1414 }
1418 }
1420 // If parameter type doesn't depend on inferred template parameters,
1421 // semantic it to get actual type.
1423 {
1424 // should copy prmtype to avoid affecting semantic result
1428 {
1432 {
1435 {
1438 }
1440 {
1444 }
1448 }
1450 }
1451 }
1454 {
1458 /* Bugzilla 2803: Before the starting of type deduction from the function
1459 * default arguments, set the already deduced parameters into paramscope.
1460 * It's necessary to avoid breaking existing acceptable code. Cases:
1461 *
1462 * 1. Already deduced template parameters can appear in fparam->defaultArg:
1463 * auto foo(A, B)(A a, B b = A.stringof);
1464 * foo(1);
1465 * // at fparam == 'B b = A.string', A is equivalent with the deduced type 'int'
1466 *
1467 * 2. If prmtype depends on default-specified template parameter, the
1468 * default type should be preferred.
1469 * auto foo(N = size_t, R)(R r, N start = 0)
1470 * foo([1,2,3]);
1471 * // at fparam `N start = 0`, N should be 'size_t' before
1472 * // the deduction result from fparam->defaultArg.
1473 */
1475 {
1477 {
1480 {
1484 }
1485 }
1487 {
1493 {
1495 {
1497 {
1498 /* The specialization can work as long as afterwards
1499 * the oded == oarg
1500 */
1503 //printf("m2 = %d\n", m2);
1510 }
1511 else
1512 {
1515 }
1517 }
1518 else
1519 {
1523 }
1524 }
1525 }
1526 }
1529 /* If prmtype does not depend on any template parameters:
1530 *
1531 * auto foo(T)(T v, double x = 0);
1532 * foo("str");
1533 * // at fparam == 'double x = 0'
1534 *
1535 * or, if all template parameters in the prmtype are already deduced:
1536 *
1537 * auto foo(R)(R range, ElementType!R sum = 0);
1538 * foo([1,2,3]);
1539 * // at fparam == 'ElementType!R sum = 0'
1540 *
1541 * Deducing prmtype from fparam->defaultArg is not necessary.
1542 */
1545 {
1548 }
1550 // Deduce prmtype from the defaultArg.
1554 }
1555 else
1556 {
1558 }
1559 {
1560 // Check invalid arguments to detect errors early.
1565 Lretry:
1571 // Bugzilla 12876: optimize arugument to allow CT-known length matching
1573 //printf("farg = %s %s\n", farg->type->toChars(), farg->toChars());
1578 {
1579 /* Allow expressions that have CT-known boundaries and type [] to match with [dim]
1580 */
1586 {
1588 {
1591 }
1593 {
1596 }
1598 {
1602 }
1603 }
1606 }
1611 {
1612 /* The farg passing to the prmtype always make a copy. Therefore,
1613 * we can shrink the set of the deduced type arguments for prmtype
1614 * by adjusting top-qualifier of the argtype.
1615 *
1616 * prmtype argtype ta
1617 * T <- const(E)[] const(E)[]
1618 * T <- const(E[]) const(E)[]
1619 * qualifier(T) <- const(E)[] const(E[])
1620 * qualifier(T) <- const(E[]) const(E[])
1621 */
1624 {
1628 }
1629 }
1636 //printf("\tL%d deduceType m = %d, wm = x%x, wildmatch = x%x\n", __LINE__, m, wm, wildmatch);
1639 /* If no match, see if the argument can be matched by using
1640 * implicit conversions.
1641 */
1646 {
1649 {
1653 /* If a semantic error occurs while doing alias this,
1654 * eg purity(bug 7295), just regard it as not a match.
1655 */
1657 {
1660 }
1661 }
1662 }
1665 {
1667 {
1670 {
1671 // Allow conversion from T[lwr .. upr] to ref T[upr-lwr]
1672 }
1673 else
1675 }
1676 }
1678 {
1683 }
1689 {
1692 argi++;
1694 }
1695 }
1697 Lvarargs:
1698 /* The following code for variadic arguments closely
1699 * matches TypeFunction::callMatch()
1700 */
1704 /* Check for match with function parameter T...
1705 */
1708 {
1709 // 6764 fix - TypeAArray may be TypeSArray have not yet run semantic().
1712 // Perhaps we can do better with this, see TypeFunction::callMatch()
1714 {
1719 }
1721 {
1727 {
1734 /* ref: https://issues.dlang.org/show_bug.cgi?id=11118
1735 * The parameter isn't part of the template
1736 * ones, let's try to find it in the
1737 * instantiation scope 'sc' and the one
1738 * belonging to the template itself. */
1742 {
1745 }
1749 {
1751 }
1758 }
1759 else
1760 {
1761 // This code matches code in TypeInstance::deduceType()
1768 {
1771 }
1772 else
1773 {
1779 }
1780 }
1781 }
1782 /* fall through */
1784 {
1788 {
1792 MATCH m;
1793 /* If lazy array of delegates,
1794 * convert arg(s) to delegate(s)
1795 */
1797 {
1799 {
1801 }
1802 else
1803 {
1806 {
1809 }
1810 }
1811 }
1812 else
1813 {
1817 }
1822 }
1824 }
1831 }
1833 }
1834 //printf("-> argi = %d, nfargs = %d, nfargs2 = %d\n", argi, nfargs, nfargs2);
1837 }
1839 Lmatch:
1842 {
1845 {
1847 {
1851 }
1853 }
1854 }
1856 {
1858 //printf("tparam[%d] = %s\n", i, tparam->ident->toChars());
1859 /* For T:T*, the dedargs is the T*, dedtypes is the T
1860 * But for function templates, we really need them to match
1861 */
1864 //printf("1dedargs[%d] = %p, dedtypes[%d] = %p\n", i, oarg, i, oded);
1865 //if (oarg) printf("oarg: %s\n", oarg->toChars());
1866 //if (oded) printf("oded: %s\n", oded->toChars());
1868 {
1870 {
1872 {
1873 /* The specialization can work as long as afterwards
1874 * the oded == oarg
1875 */
1878 //printf("m2 = %d\n", m2);
1885 }
1886 else
1887 {
1890 }
1891 }
1892 else
1893 {
1896 {
1897 // if tuple parameter and
1898 // tuple parameter was not in function parameter list and
1899 // we're one or more arguments short (i.e. no tuple argument)
1903 {
1904 // make tuple argument an empty tuple
1906 }
1907 else
1909 }
1912 ntargs++;
1914 /* At the template parameter T, the picked default template argument
1915 * X!int should be matched to T in order to deduce dependent
1916 * template parameter A.
1917 * auto foo(T : X!A = X!int, A...)() { ... }
1918 * foo(); // T <-- X!int, A <-- (int)
1919 */
1921 {
1924 //printf("m2 = %d\n", m2);
1931 }
1932 }
1935 }
1936 }
1938 /* Bugzilla 7469: As same as the code for 7469 in findBestMatch,
1939 * expand a Tuple in dedargs to normalize template arguments.
1940 */
1942 {
1944 {
1946 {
1949 }
1950 }
1951 }
1954 // Partially instantiate function for constraint and fd->leastAsSpecialized()
1955 {
1971 }
1974 {
1977 }
1980 //printf("\tmatch %d\n", match);
1983 Lnomatch:
1985 //printf("\tnomatch\n");
1990 //printf("\terror\n");
1992 }
1994 /**************************************************
1995 * Declare template parameter tp with value o, and install it in the scope sc.
1996 */
1998 RootObject *TemplateDeclaration::declareParameter(Scope *sc, TemplateParameter *tp, RootObject *o)
1999 {
2000 //printf("TemplateDeclaration::declareParameter('%s', o = %p)\n", tp->ident->toChars(), o);
2017 {
2020 else
2022 }
2025 {
2026 //printf("type %s\n", ta->toChars());
2028 }
2030 {
2031 //printf("Alias %s %s;\n", sa->ident->toChars(), tp->ident->toChars());
2033 }
2035 {
2036 // tdtypes.data[i] always matches ea here
2045 }
2047 {
2048 //printf("\ttuple\n");
2050 }
2051 else
2052 {
2054 }
2058 {
2060 // consistent with Type::checkDeprecated()
2062 {
2065 }
2067 {
2070 }
2071 }
2073 {
2076 }
2082 /* So the caller's o gets updated with the result of semantic() being run on o
2083 */
2087 }
2089 /**************************************
2090 * Determine if TemplateDeclaration is variadic.
2091 */
2094 {
2101 }
2104 {
2106 }
2108 /***********************************
2109 * We can overload templates.
2110 */
2113 {
2115 }
2117 /*************************************************
2118 * Given function arguments, figure out which template function
2119 * to expand, and return matching result.
2120 * Input:
2121 * m matching result
2122 * dstart the root of overloaded function templates
2123 * loc instantiation location
2124 * sc instantiation scope
2125 * tiargs initial list of template arguments
2126 * tthis if !NULL, the 'this' pointer argument
2127 * fargs arguments to function
2128 */
2132 {
2133 struct ParamDeduce
2134 {
2135 // context
2136 Loc loc;
2141 // result
2144 // 1: seen @property
2145 // 2: not @property
2149 MATCH ta_last;
2153 {
2161 }
2164 {
2165 // skip duplicates
2168 // explicitly specified tiargs never match to non template function
2173 {
2176 }
2178 {
2181 }
2182 //printf("fd = %s %s, fargs = %s\n", fd->toChars(), fd->type->toChars(), fargs->toChars());
2192 /* For constructors, qualifier check will be opposite direction.
2193 * Qualified constructor always makes qualified object, then will be checked
2194 * that it is implicitly convertible to tthis.
2195 */
2199 {
2200 //printf("%s tf->mod = x%x tthis_fd->mod = x%x %d\n", tf->toChars(),
2201 // tf->mod, tthis_fd->mod, fd->isolateReturn());
2205 {
2206 /* && tf->isShared() == tthis_fd->isShared()*/
2207 // Uniquely constructed object can ignore shared qualifier.
2208 // TODO: Is this appropriate?
2210 }
2211 else
2213 }
2215 //printf("test1: mfa = %d\n", mfa);
2217 {
2221 /* See if one of the matches overrides the other.
2222 */
2227 /* Try to disambiguate using template-style partial ordering rules.
2228 * In essence, if f() and g() are ambiguous, if f() can call g(),
2229 * but g() cannot call f(), then pick f().
2230 * This is because f() is "more specialized."
2231 */
2232 {
2235 //printf("c1 = %d, c2 = %d\n", c1, c2);
2238 }
2240 /* The 'overrides' check above does covariant checking only
2241 * for virtual member functions. It should do it for all functions,
2242 * but in order to not risk breaking code we put it after
2243 * the 'leastAsSpecialized' check.
2244 * In the future try moving it before.
2245 * I.e. a not-the-same-but-covariant match is preferred,
2246 * as it is more restrictive.
2247 */
2249 {
2250 //printf("cov: %d %d\n", m->lastf->type->covariant(fd->type), fd->type->covariant(m->lastf->type));
2253 }
2255 /* If the two functions are the same function, like:
2256 * int foo(int);
2257 * int foo(int x) { ... }
2258 * then pick the one with the body.
2259 */
2265 {
2268 }
2270 // Bugzilla 14450: Prefer exact qualified constructor for the creating object type
2272 {
2275 }
2281 LlastIsBetter:
2284 LfIsBetter:
2294 }
2296 }
2299 {
2300 //printf("applyTemplate()\n");
2301 // skip duplicates
2309 {
2310 // Try to fix forward reference. Ungag errors while doing so.
2313 }
2315 {
2317 Lerror:
2322 }
2323 //printf("td = %s\n", td->toChars());
2328 {
2332 Objects dedtypes;
2336 //printf("matchWithInstance = %d\n", mta);
2347 {
2350 // Bugzilla 11553: Check for recursive instantiation of tdx.
2352 {
2354 {
2355 //printf("recursive, no match p->sc=%p %p %s\n", p->sc, this, this->toChars());
2356 /* It must be a subscope of p->sc, other scope chains are not recursive
2357 * instantiations.
2358 */
2360 {
2362 {
2363 error(loc, "recursive template expansion while looking for %s.%s", ti->toChars(), tdx->toChars());
2365 }
2366 }
2367 }
2368 /* BUG: should also check for ref param differences
2369 */
2370 }
2372 TemplatePrevious pr;
2381 }
2383 {
2385 }
2386 else
2393 {
2398 }
2413 //printf("Lambig2\n");
2418 Ltd_best2:
2421 Ltd2:
2422 // td is the new best match
2435 }
2437 //printf("td = %s\n", td->toChars());
2439 {
2443 /* This is a 'dummy' instance to evaluate constraint properly.
2444 */
2452 //printf("match:t/f = %d/%d\n", mta, mfa);
2460 {
2461 // Constructor call requires additional check.
2468 {
2470 }
2471 else
2473 }
2482 {
2483 // Disambiguate by picking the most specialized TemplateDeclaration
2486 //printf("1: c1 = %d, c2 = %d\n", c1, c2);
2489 }
2491 {
2492 // Disambiguate by tf->callMatch
2499 //printf("2: c1 = %d, c2 = %d\n", c1, c2);
2502 }
2503 {
2504 // Disambiguate by picking the most specialized FunctionDeclaration
2507 //printf("3: c1 = %d, c2 = %d\n", c1, c2);
2510 }
2512 // Bugzilla 14450: Prefer exact qualified constructor for the creating object type
2514 {
2517 }
2524 //printf("Ltd_best\n");
2528 //printf("Ltd\n");
2541 }
2543 }
2544 };
2545 ParamDeduce p;
2546 // context
2553 // result
2568 //printf("td_best = %p, m->lastf = %p\n", p.td_best, m->lastf);
2570 {
2571 // Matches to template function
2574 /* The best match is td_best with arguments tdargs.
2575 * Now instantiate the template.
2576 */
2588 {
2589 Lerror:
2594 }
2596 // look forward instantiated overload function
2597 // Dsymbol::oneMembers is alredy called in TemplateInstance::semantic.
2598 // it has filled overnext0d
2600 {
2603 }
2614 /* As Bugzilla 3682 shows, a template instance can be matched while instantiating
2615 * that same template. Thus, the function type can be incomplete. Complete it.
2616 *
2617 * Bugzilla 9208: For auto function, completion should be deferred to the end of
2618 * its semantic3. Should not complete it in here.
2619 */
2621 {
2623 }
2624 }
2626 {
2627 // Matches to non template function,
2628 // or found matches were ambiguous.
2630 }
2631 else
2632 {
2633 Lnomatch:
2637 }
2638 }
2640 /*************************************************
2641 * Limited function template instantiation for using fd->leastAsSpecialized()
2642 */
2646 {
2649 // function body and contracts are not need
2652 else
2653 fd = new FuncDeclaration(fd->loc, fd->endloc, fd->ident, fd->storage_class, fd->type->syntaxCopy());
2661 {
2662 // Match 'tthis' to any TemplateThisParameter's
2665 {
2670 }
2672 {
2675 }
2676 }
2680 // Shouldn't run semantic on default arguments and return type.
2684 {
2685 // For constructors, emitting return type is necessary for
2686 // isolateReturn() in functionResolve.
2693 {
2695 }
2696 else
2697 {
2702 }
2706 //printf("tf = %s\n", tf->toChars());
2707 }
2708 else
2719 //printf("\t[%s] fd->type = %s, mod = %x, ", loc.toChars(), fd->type->toChars(), fd->type->mod);
2720 //printf("fd->needThis() = %d\n", fd->needThis());
2723 }
2726 {
2728 }
2731 {
2735 OutBuffer buf;
2736 HdrGenState hgs;
2741 {
2746 }
2750 {
2753 {
2756 }
2757 }
2760 {
2764 }
2766 }
2769 {
2771 }
2773 /****************************************************
2774 * Given a new instance tithis of this TemplateDeclaration,
2775 * see if there already exists an instance.
2776 * If so, return that existing instance.
2777 */
2779 TemplateInstance *TemplateDeclaration::findExistingInstance(TemplateInstance *tithis, Expressions *fargs)
2780 {
2781 //printf("findExistingInstance(%p)\n", tithis);
2783 TemplateInstances *tinstances = (TemplateInstances *)dmd_aaGetRvalue((AA *)instances, (void *)tithis->toHash());
2785 {
2787 {
2791 }
2792 }
2794 }
2796 /********************************************
2797 * Add instance ti to TemplateDeclaration's table of instances.
2798 * Return a handle we can use to later remove it if it fails instantiation.
2799 */
2802 {
2803 //printf("addInstance() %p %p\n", instances, ti);
2804 TemplateInstances **ptinstances = (TemplateInstances **)dmd_aaGet((AA **)&instances, (void *)ti->toHash());
2809 }
2811 /*******************************************
2812 * Remove TemplateInstance from table of instances.
2813 * Input:
2814 * handle returned by addInstance()
2815 */
2818 {
2819 //printf("removeInstance()\n");
2820 TemplateInstances *tinstances = (TemplateInstances *)dmd_aaGetRvalue((AA *)instances, (void *)handle->toHash());
2822 {
2824 {
2827 {
2830 }
2831 }
2832 }
2833 }
2835 /* ======================== Type ============================================ */
2837 /****
2838 * Given an identifier, figure out which TemplateParameter it is.
2839 * Return IDX_NOTFOUND if not found.
2840 */
2843 {
2845 {
2849 }
2851 }
2854 {
2856 {
2858 //printf("\ttident = '%s'\n", tident->toChars());
2860 }
2862 }
2865 {
2871 #define X(U,T) ((U) << 4) | (T)
2873 {
2890 {
2897 }
2911 {
2914 }
2918 }
2919 #undef X
2920 }
2923 {
2924 // 9*9 == 81 cases
2926 #define X(U,T) ((U) << 4) | (T)
2928 {
2938 // foo(U) T => T
2939 // foo(U) const(T) => const(T)
2940 // foo(U) inout(T) => inout(T)
2941 // foo(U) inout(const(T)) => inout(const(T))
2942 // foo(U) shared(T) => shared(T)
2943 // foo(U) shared(const(T)) => shared(const(T))
2944 // foo(U) shared(inout(T)) => shared(inout(T))
2945 // foo(U) shared(inout(const(T))) => shared(inout(const(T)))
2946 // foo(U) immutable(T) => immutable(T)
2947 {
2950 }
2960 // foo(const(U)) const(T) => T
2961 // foo(inout(U)) inout(T) => T
2962 // foo(inout(const(U))) inout(const(T)) => T
2963 // foo(shared(U)) shared(T) => T
2964 // foo(shared(const(U))) shared(const(T)) => T
2965 // foo(shared(inout(U))) shared(inout(T)) => T
2966 // foo(shared(inout(const(U)))) shared(inout(const(T))) => T
2967 // foo(immutable(U)) immutable(T) => T
2968 {
2971 }
2983 // foo(const(U)) T => T
2984 // foo(const(U)) inout(T) => T
2985 // foo(const(U)) inout(const(T)) => T
2986 // foo(const(U)) shared(const(T)) => shared(T)
2987 // foo(const(U)) shared(inout(T)) => shared(T)
2988 // foo(const(U)) shared(inout(const(T))) => shared(T)
2989 // foo(const(U)) immutable(T) => T
2990 // foo(inout(U)) shared(inout(T)) => shared(T)
2991 // foo(inout(const(U))) shared(inout(const(T))) => shared(T)
2992 // foo(shared(const(U))) immutable(T) => T
2993 {
2996 }
2999 // foo(const(U)) shared(T) => shared(T)
3000 {
3003 }
3009 // foo(shared(U)) shared(const(T)) => const(T)
3010 // foo(shared(U)) shared(inout(T)) => inout(T)
3011 // foo(shared(U)) shared(inout(const(T))) => inout(const(T))
3012 // foo(shared(const(U))) shared(T) => T
3013 {
3016 }
3022 // foo(inout(const(U))) immutable(T) => T
3023 // foo(shared(const(U))) shared(inout(const(T))) => T
3024 // foo(shared(inout(const(U)))) immutable(T) => T
3025 // foo(shared(inout(const(U)))) shared(inout(T)) => T
3026 {
3029 }
3032 // foo(shared(const(U))) shared(inout(T)) => T
3033 {
3036 }
3082 // foo(inout(U)) T => nomatch
3083 // foo(inout(U)) const(T) => nomatch
3084 // foo(inout(U)) inout(const(T)) => nomatch
3085 // foo(inout(U)) immutable(T) => nomatch
3086 // foo(inout(U)) shared(T) => nomatch
3087 // foo(inout(U)) shared(const(T)) => nomatch
3088 // foo(inout(U)) shared(inout(const(T))) => nomatch
3089 // foo(inout(const(U))) T => nomatch
3090 // foo(inout(const(U))) const(T) => nomatch
3091 // foo(inout(const(U))) inout(T) => nomatch
3092 // foo(inout(const(U))) shared(T) => nomatch
3093 // foo(inout(const(U))) shared(const(T)) => nomatch
3094 // foo(inout(const(U))) shared(inout(T)) => nomatch
3095 // foo(shared(U)) T => nomatch
3096 // foo(shared(U)) const(T) => nomatch
3097 // foo(shared(U)) inout(T) => nomatch
3098 // foo(shared(U)) inout(const(T)) => nomatch
3099 // foo(shared(U)) immutable(T) => nomatch
3100 // foo(shared(const(U))) T => nomatch
3101 // foo(shared(const(U))) const(T) => nomatch
3102 // foo(shared(const(U))) inout(T) => nomatch
3103 // foo(shared(const(U))) inout(const(T)) => nomatch
3104 // foo(shared(inout(U))) T => nomatch
3105 // foo(shared(inout(U))) const(T) => nomatch
3106 // foo(shared(inout(U))) inout(T) => nomatch
3107 // foo(shared(inout(U))) inout(const(T)) => nomatch
3108 // foo(shared(inout(U))) immutable(T) => nomatch
3109 // foo(shared(inout(U))) shared(T) => nomatch
3110 // foo(shared(inout(U))) shared(const(T)) => nomatch
3111 // foo(shared(inout(U))) shared(inout(const(T))) => nomatch
3112 // foo(shared(inout(const(U)))) T => nomatch
3113 // foo(shared(inout(const(U)))) const(T) => nomatch
3114 // foo(shared(inout(const(U)))) inout(T) => nomatch
3115 // foo(shared(inout(const(U)))) inout(const(T)) => nomatch
3116 // foo(shared(inout(const(U)))) shared(T) => nomatch
3117 // foo(shared(inout(const(U)))) shared(const(T)) => nomatch
3118 // foo(immutable(U)) T => nomatch
3119 // foo(immutable(U)) const(T) => nomatch
3120 // foo(immutable(U)) inout(T) => nomatch
3121 // foo(immutable(U)) inout(const(T)) => nomatch
3122 // foo(immutable(U)) shared(T) => nomatch
3123 // foo(immutable(U)) shared(const(T)) => nomatch
3124 // foo(immutable(U)) shared(inout(T)) => nomatch
3125 // foo(immutable(U)) shared(inout(const(T))) => nomatch
3131 }
3132 #undef X
3133 }
3135 /* These form the heart of template argument deduction.
3136 * Given 'this' being the type argument to the template instance,
3137 * it is matched against the template declaration parameter specialization
3138 * 'tparam' to determine the type to be used for the parameter.
3139 * Example:
3140 * template Foo(T:T*) // template declaration
3141 * Foo!(int*) // template instantiation
3142 * Input:
3143 * this = int*
3144 * tparam = T*
3145 * parameters = [ T:T* ] // Array of TemplateParameter's
3146 * Output:
3147 * dedtypes = [ int ] // Array of Expression/Type's
3148 */
3151 {
3153 {
3161 MATCH result;
3163 DeduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wm, size_t inferStart)
3164 : sc(sc), tparam(tparam), parameters(parameters), dedtypes(dedtypes), wm(wm), inferStart(inferStart)
3165 {
3167 }
3170 {
3178 {
3179 // Determine which parameter tparam is
3182 {
3186 /* Need a loc to go with the semantic routine.
3187 */
3188 Loc loc;
3190 {
3193 }
3195 /* BUG: what if tparam is a template instance, that
3196 * has as an argument another Tident?
3197 */
3202 }
3208 {
3209 //printf("matching %s to %s\n", tparam->toChars(), t->toChars());
3212 {
3215 {
3222 //printf("[%d] s = %s %s, s2 = %s %s\n", j, s->kind(), s->toChars(), s2->kind(), s2->toChars());
3224 {
3226 {
3229 }
3230 else
3232 }
3234 }
3235 else
3237 }
3238 //printf("[e] s = %s\n", s?s->toChars():"(null)");
3240 {
3248 {
3251 }
3252 }
3254 {
3257 {
3260 }
3261 }
3263 }
3265 // Found the corresponding parameter tp
3272 {
3273 // type vs (none)
3275 {
3280 }
3282 // type vs expressions
3284 {
3288 {
3293 }
3295 }
3297 // type vs type
3299 {
3302 }
3304 {
3308 }
3310 {
3314 }
3316 }
3318 {
3319 // type vs (none)
3321 {
3325 }
3327 // type vs expressions
3329 {
3333 {
3336 }
3338 }
3340 // type vs type
3342 {
3344 }
3346 {
3349 }
3352 {
3354 }
3355 }
3357 }
3360 {
3361 /* Need a loc to go with the semantic routine.
3362 */
3363 Loc loc;
3365 {
3368 }
3371 }
3373 {
3375 {
3378 }
3382 {
3384 {
3387 {
3391 }
3392 }
3394 {
3397 {
3401 }
3402 }
3403 }
3406 }
3409 {
3411 {
3414 }
3418 {
3419 // Bugzilla 12403: In IFTI, stop inout matching on transitive part of AA types.
3421 }
3425 }
3427 Lexact:
3431 Lnomatch:
3435 Lconst:
3437 }
3440 {
3442 {
3446 }
3448 }
3451 {
3453 }
3456 {
3457 // Extra check that array dimensions must match
3459 {
3461 {
3465 }
3471 {
3475 {
3480 }
3481 else
3483 }
3485 {
3490 else
3491 {
3497 }
3498 }
3501 {
3504 }
3505 }
3510 }
3513 {
3514 // Extra check that index type must match
3516 {
3519 {
3522 }
3523 }
3525 }
3528 {
3529 //printf("TypeFunction::deduceType()\n");
3530 //printf("\tthis = %d, ", t->ty); t->print();
3531 //printf("\ttparam = %d, ", tparam->ty); tparam->print();
3533 // Extra check that function characteristics must match
3535 {
3539 {
3542 }
3547 // bug 2579 fix: Apply function parameter storage classes to parameter types
3549 {
3553 }
3554 //printf("\t-> this = %d, ", t->ty); t->print();
3555 //printf("\t-> tparam = %d, ", tparam->ty); tparam->print();
3557 /* See if tuple match
3558 */
3560 {
3561 /* See if 'A' of the template parameter matches 'A'
3562 * of the type of the last function parameter.
3563 */
3573 /* Look through parameters to find tuple matching tid->ident
3574 */
3577 {
3584 }
3586 /* The types of the function arguments [nfparams - 1 .. nfargs]
3587 * now form the tuple argument.
3588 */
3591 /* See if existing tuple, and whether it matches or not
3592 */
3595 {
3596 // Existing deduced argument must be a tuple, and must match
3599 {
3602 }
3604 {
3607 {
3610 }
3611 }
3612 }
3613 else
3614 {
3615 // Create new tuple
3619 {
3622 }
3624 }
3627 }
3629 L1:
3631 {
3634 }
3635 L2:
3637 {
3643 {
3646 }
3647 }
3648 }
3650 }
3653 {
3654 // Extra check
3656 {
3660 {
3665 {
3668 }
3669 }
3670 }
3672 }
3675 {
3676 // Extra check
3678 {
3684 //printf("tempinst->tempdecl = %p\n", tempdecl);
3685 //printf("tp->tempinst->tempdecl = %p\n", tp->tempinst->tempdecl);
3687 {
3688 //printf("tp->tempinst->name = '%s'\n", tp->tempinst->name->toChars());
3690 /* Handle case of:
3691 * template Foo(T : sa!(T), alias sa)
3692 */
3695 {
3696 /* Didn't find it as a parameter identifier. Try looking
3697 * it up and seeing if is an alias. See Bugzilla 1454
3698 */
3705 {
3708 {
3709 // Bugzilla 14290: Try to match with ti->tempecl,
3710 // only when ti is an enclosing instance.
3716 }
3717 }
3719 {
3723 {
3727 {
3730 }
3731 }
3732 }
3734 }
3738 }
3742 L2:
3745 {
3746 //printf("\ttest: tempinst->tiargs[%d]\n", i);
3751 {
3752 // Pick up default arg
3754 }
3759 {
3763 {
3764 i++;
3765 }
3769 }
3778 {
3779 /* Given:
3780 * struct A(B...) {}
3781 * alias A!(int, float) X;
3782 * static if (is(X Y == A!(Z), Z...)) {}
3783 * deduce that Z is a tuple(int, float)
3784 */
3786 /* Create tuple from remaining args
3787 */
3793 {
3800 }
3804 {
3807 }
3808 else
3811 }
3822 {
3825 }
3827 {
3828 Le:
3831 /* If it is one of the template parameters for this template,
3832 * we should not attempt to interpret it. It already has a value.
3833 */
3836 {
3837 /*
3838 * (T:Number!(e2), int e2)
3839 */
3843 // The template parameter was not from this template
3844 // (it may be from a parent template, for example)
3845 }
3850 //printf("e1 = %s, type = %s %d\n", e1->toChars(), e1->type->toChars(), e1->type->ty);
3851 //printf("e2 = %s, type = %s %d\n", e2->toChars(), e2->type->toChars(), e2->type->ty);
3853 {
3861 }
3862 }
3864 {
3866 L1:
3868 {
3873 }
3876 }
3878 {
3879 Ls:
3882 }
3884 {
3887 {
3892 }
3895 }
3896 else
3898 }
3899 }
3903 Lnomatch:
3904 //printf("no match\n");
3906 }
3909 {
3910 /* If this struct is a template struct, and we're matching
3911 * it against a template instance, convert the struct type
3912 * to a template instance, too, and try again.
3913 */
3917 {
3919 {
3923 }
3925 /* Match things like:
3926 * S!(T).foo
3927 */
3930 {
3933 {
3936 {
3937 /* Slice off the .foo in S!(T).foo
3938 */
3943 }
3944 }
3945 }
3946 }
3948 // Extra check
3950 {
3953 //printf("\t%d\n", (MATCH) t->implicitConvTo(tp));
3955 {
3958 }
3961 }
3963 }
3966 {
3967 // Extra check
3969 {
3973 else
3976 }
3980 {
3983 }
3985 }
3987 /* Helper for TypeClass::deduceType().
3988 * Classes can match with implicit conversion to a base class or interface.
3989 * This is complicated, because there may be more than one base class which
3990 * matches. In such cases, one or more parameters remain ambiguous.
3991 * For example,
3992 *
3993 * interface I(X, Y) {}
3994 * class C : I(uint, double), I(char, double) {}
3995 * C x;
3996 * foo(T, U)( I!(T, U) x)
3997 *
3998 * deduces that U is double, but T remains ambiguous (could be char or uint).
3999 *
4000 * Given a baseclass b, and initial deduced types 'dedtypes', this function
4001 * tries to match tparam with b, and also tries all base interfaces of b.
4002 * If a match occurs, numBaseClassMatches is incremented, and the new deduced
4003 * types are ANDed with the current 'best' estimate for dedtypes.
4004 */
4008 {
4011 {
4012 // Make a temporary copy of dedtypes so we don't destroy it
4020 {
4021 // If this is the first ever match, it becomes our best estimate
4025 {
4026 // If we've found more than one possible type for a parameter,
4027 // mark it as unknown.
4030 }
4032 }
4033 }
4034 // Now recursively test the inherited interfaces
4036 {
4041 }
4043 }
4046 {
4047 //printf("TypeClass::deduceType(this = %s)\n", t->toChars());
4049 /* If this class is a template class, and we're matching
4050 * it against a template instance, convert the class type
4051 * to a template instance, too, and try again.
4052 */
4056 {
4058 {
4061 // Even if the match fails, there is still a chance it could match
4062 // a base class.
4064 {
4067 }
4068 }
4070 /* Match things like:
4071 * S!(T).foo
4072 */
4075 {
4078 {
4081 {
4082 /* Slice off the .foo in S!(T).foo
4083 */
4088 }
4089 }
4090 }
4092 // If it matches exactly or via implicit conversion, we're done
4097 /* There is still a chance to match via implicit conversion to
4098 * a base class or interface. Because there could be more than one such
4099 * match, we need to check them all.
4100 */
4104 // Our best guess at dedtypes
4110 {
4111 // Test the base class
4116 // Test the interfaces inherited by the base class
4118 {
4122 }
4124 }
4127 {
4130 }
4132 // If we got at least one match, copy the known types into dedtypes
4136 }
4138 // Extra check
4140 {
4143 //printf("\t%d\n", (MATCH) t->implicitConvTo(tp));
4145 {
4148 }
4151 }
4153 }
4156 {
4157 //printf("Expression::deduceType(e = %s)\n", e->toChars());
4160 {
4162 {
4166 }
4169 }
4176 {
4178 {
4181 }
4183 {
4186 }
4187 }
4192 {
4195 }
4197 {
4199 }
4200 else
4203 // expression vs (none)
4205 {
4208 }
4212 {
4215 }
4217 // From previous matched expressions to current deduced type
4220 // From current expresssion to previous deduced type
4227 {
4233 {
4237 {
4240 else
4242 }
4244 {
4247 else
4249 }
4250 //printf("tt = %s, at = %s\n", tt->toChars(), at->toChars());
4251 }
4252 else
4253 {
4256 }
4257 }
4259 {
4260 // Prefer current match: tt
4263 else
4267 }
4269 {
4270 // Prefer previous match: (*dedtypes)[i]
4275 }
4277 /* Deduce common type
4278 */
4280 {
4283 else
4291 }
4294 }
4297 {
4299 {
4302 }
4307 }
4310 {
4312 {
4313 // tparam:T[] <- e:null (void[])
4316 }
4318 }
4321 {
4327 {
4328 // Consider compile-time known boundaries
4331 }
4333 }
4336 {
4340 {
4341 // tparam:T[] <- e:[] (void[])
4344 }
4347 {
4351 {
4355 }
4357 {
4366 }
4368 }
4375 {
4376 // Consider compile-time known boundaries
4379 }
4381 }
4384 {
4386 {
4390 {
4401 }
4403 }
4405 }
4408 {
4409 //printf("e->type = %s, tparam = %s\n", e->type->toChars(), tparam->toChars());
4411 {
4417 // Parameter types inference from 'tof'
4420 //printf("\ttof = %s\n", tof->toChars());
4421 //printf("\ttf = %s\n", tf->toChars());
4432 {
4436 {
4440 {
4442 }
4443 }
4455 }
4457 // Set target of return type inference
4465 // Reset inference target for the later re-semantic
4474 }
4481 // Allow conversion from implicit function pointer to delegate
4484 {
4487 }
4488 //printf("tparam = %s <= e->type = %s, t = %s\n", tparam->toChars(), e->type->toChars(), t->toChars());
4490 }
4493 {
4499 {
4500 // Consider compile-time known boundaries
4502 {
4505 }
4506 }
4508 }
4511 {
4513 }
4514 };
4519 else
4520 {
4523 }
4525 }
4527 /*******************************
4528 * Input:
4529 * t Tested type, if NULL, returns NULL.
4530 * tparams Optional template parameters.
4531 * == NULL:
4532 * If one of the subtypes of this type is a TypeIdentifier,
4533 * i.e. it's an unresolved type, return that type.
4534 * != NULL:
4535 * Only when the TypeIdentifier is one of template parameters,
4536 * return that type.
4537 */
4540 {
4542 {
4550 {
4552 }
4555 {
4556 }
4559 {
4561 }
4564 {
4566 }
4569 {
4573 }
4576 {
4579 {
4584 }
4587 }
4590 {
4592 {
4595 }
4598 {
4601 {
4604 }
4605 }
4606 }
4609 {
4614 {
4617 {
4620 }
4621 }
4625 {
4628 {
4632 }
4633 }
4634 }
4637 {
4638 //printf("TypeTypeof::reliesOnTident('%s')\n", t->toChars());
4640 }
4643 {
4645 {
4647 {
4652 }
4653 }
4654 }
4657 {
4658 //printf("Expression::reliesOnTident('%s')\n", e->toChars());
4659 }
4662 {
4663 //printf("IdentifierExp::reliesOnTident('%s')\n", e->toChars());
4665 {
4668 {
4671 }
4672 }
4673 }
4676 {
4677 //printf("TupleExp::reliesOnTident('%s')\n", e->toChars());
4679 {
4681 {
4686 }
4687 }
4688 }
4691 {
4692 //printf("ArrayLiteralExp::reliesOnTident('%s')\n", e->toChars());
4694 {
4696 {
4701 }
4702 }
4703 }
4706 {
4707 //printf("AssocArrayLiteralExp::reliesOnTident('%s')\n", e->toChars());
4709 {
4714 }
4716 {
4721 }
4722 }
4725 {
4726 //printf("StructLiteralExp::reliesOnTident('%s')\n", e->toChars());
4728 {
4730 {
4735 }
4736 }
4737 }
4740 {
4741 //printf("TypeExp::reliesOnTident('%s')\n", e->toChars());
4743 }
4746 {
4747 //printf("NewExp::reliesOnTident('%s')\n", e->toChars());
4751 {
4753 {
4758 }
4759 }
4762 {
4764 {
4769 }
4770 }
4771 }
4774 {
4775 //printf("NewAnonClassExp::reliesOnTident('%s')\n", e->toChars());
4777 }
4780 {
4781 //printf("FuncExp::reliesOnTident('%s')\n", e->toChars());
4783 }
4786 {
4787 //printf("TypeidExp::reliesOnTident('%s')\n", e->toChars());
4792 }
4795 {
4796 //printf("TraitsExp::reliesOnTident('%s')\n", e->toChars());
4798 {
4800 {
4808 }
4809 }
4810 }
4813 {
4814 //printf("IsExp::reliesOnTident('%s')\n", e->toChars());
4816 }
4819 {
4820 //printf("UnaExp::reliesOnTident('%s')\n", e->toChars());
4822 }
4825 {
4826 //printf("DotTemplateInstanceExp::reliesOnTident('%s')\n", e->toChars());
4829 {
4831 {
4839 }
4840 }
4841 }
4844 {
4845 //printf("CallExp::reliesOnTident('%s')\n", e->toChars());
4848 {
4850 {
4855 }
4856 }
4857 }
4860 {
4861 //printf("CastExp::reliesOnTident('%s')\n", e->toChars());
4863 // e.to can be null for cast() with no type
4866 }
4869 {
4870 //printf("SliceExp::reliesOnTident('%s')\n", e->toChars());
4876 }
4879 {
4880 //printf("IntervalExp::reliesOnTident('%s')\n", e->toChars());
4884 }
4887 {
4888 //printf("ArrayExp::reliesOnTident('%s')\n", e->toChars());
4891 {
4893 {
4896 }
4897 }
4898 }
4901 {
4902 //printf("BinExp::reliesOnTident('%s')\n", e->toChars());
4906 }
4909 {
4910 //printf("BinExp::reliesOnTident('%s')\n", e->toChars());
4914 }
4915 };
4923 }
4925 /* ======================== TemplateParameter =============================== */
4928 {
4932 }
4935 {
4937 }
4940 {
4942 }
4945 {
4947 }
4950 {
4952 }
4955 {
4957 }
4959 /*******************************************
4960 * Match to a particular TemplateParameter.
4961 * Input:
4962 * instLoc location that the template is instantiated.
4963 * tiargs[] actual arguments to template instance
4964 * i i'th argument
4965 * parameters[] template parameters
4966 * dedtypes[] deduced arguments to template instance
4967 * *psparam set to symbol declared and initialized to dedtypes[i]
4968 */
4972 {
4977 else
4978 {
4979 // Get default argument instead
4982 {
4984 // It might have already been deduced
4988 }
4989 }
4992 Lnomatch:
4996 }
4998 /* ======================== TemplateTypeParameter =========================== */
5000 // type-parameter
5007 {
5011 }
5014 {
5016 }
5019 {
5023 }
5026 {
5027 //printf("TemplateTypeParameter::declareParameter('%s')\n", ident->toChars());
5031 }
5034 {
5035 //printf("TemplateTypeParameter::semantic('%s')\n", ident->toChars());
5037 {
5039 }
5041 }
5046 {
5047 //printf("TemplateTypeParameter::matchArg('%s')\n", ident->toChars());
5051 {
5052 //printf("%s %p %p %p\n", oarg->toChars(), isExpression(oarg), isDsymbol(oarg), isTuple(oarg));
5054 }
5055 //printf("ta is %s\n", ta->toChars());
5058 {
5062 //printf("\tcalling deduceType(): ta is %s, specType is %s\n", ta->toChars(), specType->toChars());
5065 {
5066 //printf("\tfailed deduceType\n");
5068 }
5073 {
5079 /* This is a self-dependent parameter. For example:
5080 * template X(T : T*) {}
5081 * template X(T : S!T, alias S) {}
5082 */
5083 //printf("t = %s ta = %s\n", t->toChars(), ta->toChars());
5085 }
5086 }
5087 else
5088 {
5090 {
5091 // Must match already deduced type
5095 {
5096 //printf("t = %s ta = %s\n", t->toChars(), ta->toChars());
5098 }
5099 }
5100 else
5101 {
5102 // So that matches with specializations are better
5104 }
5105 }
5110 //printf("\tm = %d\n", m);
5113 Lnomatch:
5116 //printf("\tm = %d\n", MATCHnomatch);
5118 }
5122 {
5136 }
5139 {
5142 {
5143 // Use this for alias-parameter's too (?)
5147 }
5149 }
5153 {
5155 }
5158 {
5161 {
5164 }
5166 }
5169 {
5171 }
5173 /* ======================== TemplateThisParameter =========================== */
5175 // this-parameter
5181 {
5182 }
5185 {
5187 }
5190 {
5194 }
5196 /* ======================== TemplateAliasParameter ========================== */
5198 // alias-parameter
5205 {
5210 }
5213 {
5215 }
5218 {
5223 }
5226 {
5230 }
5232 static RootObject *aliasParameterSemantic(Loc loc, Scope *sc, RootObject *o, TemplateParameters *parameters)
5233 {
5235 {
5239 {
5243 else
5245 }
5247 {
5252 }
5253 }
5255 }
5258 {
5260 {
5262 }
5266 }
5271 {
5272 //printf("TemplateAliasParameter::matchArg('%s')\n", ident->toChars());
5282 {
5286 /* specType means the alias must be a declaration with a type
5287 * that matches specType.
5288 */
5290 {
5296 }
5297 }
5298 else
5299 {
5302 {
5304 {
5307 }
5308 }
5310 {
5311 /* Bugzilla xxxxx: Specialized parameter should be prefeerd
5312 * match to the template type parameter.
5313 * template X(alias a) {} // a == this
5314 * template X(alias a : B!A, alias B, A...) {} // B!A => ta
5315 */
5316 }
5318 {
5319 /* Bugzilla 2025: Aggregate Types should preferentially
5320 * match to the template type parameter.
5321 * template X(alias a) {} // a == this
5322 * template X(T) {} // T => sa
5323 */
5324 }
5325 else
5327 }
5330 {
5335 {
5342 {
5346 }
5354 }
5355 }
5357 {
5358 // Must match already deduced symbol
5362 }
5366 {
5368 {
5370 }
5372 {
5374 }
5375 else
5376 {
5379 // Declare manifest constant
5385 }
5386 }
5389 Lnomatch:
5392 //printf("\tm = %d\n", MATCHnomatch);
5394 }
5398 {
5405 }
5408 {
5411 {
5415 }
5417 }
5421 {
5423 }
5426 {
5430 {
5432 {
5433 // If the default arg is a template, instantiate for each type
5435 }
5436 }
5440 }
5443 {
5445 }
5447 /* ======================== TemplateValueParameter ========================== */
5449 // value-parameter
5456 {
5461 }
5464 {
5466 }
5469 {
5474 }
5477 {
5481 }
5484 {
5488 }
5492 {
5493 //printf("TemplateValueParameter::matchArg('%s')\n", ident->toChars());
5501 {
5510 /* If a function is really property-like, and then
5511 * it's CTFEable, ei will be a literal expression.
5512 */
5519 /* Bugzilla 14520: A property-like function can match to both
5520 * TemplateAlias and ValueParameter. But for template overloads,
5521 * it should always prefer alias parameter to be consistent
5522 * template match result.
5523 *
5524 * template X(alias f) { enum X = 1; }
5525 * template X(int val) { enum X = 2; }
5526 * int f1() { return 0; } // CTFEable
5527 * int f2(); // body-less function is not CTFEable
5528 * enum x1 = X!f1; // should be 1
5529 * enum x2 = X!f2; // should be 1
5530 *
5531 * e.g. The x1 value must be same even if the f1 definition will be moved
5532 * into di while stripping body code.
5533 */
5535 }
5538 {
5539 // Resolve const variables that we had skipped earlier
5541 }
5543 //printf("\tvalType: %s, ty = %d\n", valType->toChars(), valType->ty);
5545 //printf("ei: %s, ei->type: %s\n", ei->toChars(), ei->type->toChars());
5546 //printf("vt = %s\n", vt->toChars());
5549 {
5551 //printf("m: %d\n", m);
5558 }
5561 {
5580 //printf("\tei: %s, %s\n", ei->toChars(), ei->type->toChars());
5581 //printf("\te : %s, %s\n", e->toChars(), e->type->toChars());
5584 }
5585 else
5586 {
5588 {
5589 // Must match already deduced value
5594 }
5595 }
5599 {
5604 }
5607 Lnomatch:
5608 //printf("\tno match\n");
5612 }
5616 {
5624 }
5627 {
5630 {
5631 // Create a dummy value
5636 }
5638 }
5642 {
5644 }
5647 {
5650 {
5658 }
5660 }
5663 {
5665 }
5667 /* ======================== TemplateTupleParameter ========================== */
5669 // variadic-parameter
5673 {
5675 }
5678 {
5680 }
5683 {
5685 }
5688 {
5692 }
5695 {
5697 }
5702 {
5703 /* The rest of the actual arguments (tiargs[]) form the match
5704 * for the variadic parameter.
5705 */
5710 {
5711 // It has already been deduced
5713 }
5716 else
5717 {
5719 //printf("ovar = %p\n", ovar);
5721 {
5722 //printf("i = %d, tiargs->dim = %d\n", i, tiargs->dim);
5726 }
5727 }
5729 }
5733 {
5734 //printf("TemplateTupleParameter::matchArg('%s')\n", ident->toChars());
5739 {
5745 }
5751 }
5755 {
5760 //printf("|%d| ", v->objects.dim);
5762 {
5781 }
5784 }
5787 {
5789 }
5793 {
5795 }
5798 {
5800 }
5803 {
5805 }
5807 /* ======================== TemplateInstance ================================ */
5811 {
5832 }
5834 /*****************
5835 * This constructor is only called when we figured out which function
5836 * template to instantiate.
5837 */
5841 {
5864 }
5868 {
5871 {
5876 }
5878 }
5881 {
5889 else
5892 }
5895 {
5897 }
5900 {
5902 {
5905 }
5908 {
5911 }
5914 {
5916 //printf("\t[%d] semantic on '%s' %p kind %s in '%s'\n", i, s->toChars(), s, s->kind(), this->toChars());
5917 //printf("test: enclosing = %d, sc2->parent = %s\n", enclosing, sc2->parent->toChars());
5918 // if (enclosing)
5919 // s->parent = sc->parent;
5920 //printf("test3: enclosing = %d, s->parent = %s\n", enclosing, s->parent->toChars());
5922 //printf("test4: enclosing = %d, s->parent = %s\n", enclosing, s->parent->toChars());
5924 }
5925 }
5928 {
5930 // extracted to a function to allow windows SEH to work without destructors in the same function
5931 //printf("%d\n", nest);
5933 {
5937 }
5941 nest--;
5942 }
5945 {
5946 // extracted to a function to allow windows SEH to work without destructors in the same function
5948 //printf("%d\n", nest);
5950 {
5954 }
5958 }
5961 {
5962 //printf("[%s] TemplateInstance::semantic('%s', this=%p, gag = %d, sc = %p)\n", loc.toChars(), toChars(), this, global.gag, sc);
5964 {
5966 }
5968 {
5975 else
5979 }
5981 // Get the enclosing template instance from the scope tinst
5984 // Get the instantiating module from the scope minst
5986 // Bugzilla 10920: If the enclosing function is non-root symbol,
5987 // this instance should be speculative.
5989 {
5991 }
5997 /* Find template declaration first,
5998 * then run semantic on each argument (place results in tiargs[]),
5999 * last find most specialized template from overload list/set.
6000 */
6004 {
6005 Lerror:
6007 {
6008 // Bugzilla 13220: Rollback status for later semantic re-running.
6010 }
6011 else
6015 }
6019 // If tempdecl is a mixin, disallow it
6021 {
6024 }
6030 /* See if there is an existing TemplateInstantiation that already
6031 * implements the typeargs. If so, just refer to that one instead.
6032 */
6036 {
6037 // So, we need to implement 'this' instance.
6038 }
6040 {
6041 // If the first instantiation had failed, re-run semantic,
6042 // so that error messages are shown.
6044 }
6045 else
6046 {
6047 // It's a match
6051 // If both this and the previous instantiation were gagged,
6052 // use the number of errors that happened last time.
6056 // If the first instantiation was gagged, but this is not:
6058 {
6059 // It had succeeded, mark it is a non-gagged instantiation,
6060 // and reuse it.
6062 }
6067 /* A module can have explicit template instance and its alias
6068 * in module scope (e,g, `alias Base64 = Base64Impl!('+', '/');`).
6069 * If the first instantiation 'inst' had happened in non-root module,
6070 * compiler can assume that its instantiated code would be included
6071 * in the separately compiled obj/lib file (e.g. phobos.lib).
6072 *
6073 * However, if 'this' second instantiation happened in root module,
6074 * compiler might need to invoke its codegen (Bugzilla 2500 & 2644).
6075 * But whole import graph is not determined until all semantic pass finished,
6076 * so 'inst' should conservatively finish the semantic3 pass for the codegen.
6077 */
6079 {
6080 /* Swap the position of 'inst' and 'this' in the instantiation graph.
6081 * Then, the primary instance `inst` will be changed to a root instance.
6082 *
6083 * Before:
6084 * non-root -> A!() -> B!()[inst] -> C!()
6085 * |
6086 * root -> D!() -> B!()[this]
6087 *
6088 * After:
6089 * non-root -> A!() -> B!()[this]
6090 * |
6091 * root -> D!() -> B!()[inst] -> C!()
6092 */
6101 {
6102 /* Add 'inst' once again to the root module members[], then the
6103 * instance members will get codegen chances.
6104 */
6106 }
6107 }
6110 }
6115 //printf("parent = '%s'\n", parent->kind());
6119 //getIdent();
6121 // Store the place we added it to in target_symbol_list(_idx) so we can
6122 // remove it later if we encounter an error.
6126 // Copy the syntax trees from the TemplateDeclaration
6129 // resolve TemplateThisParameter
6131 {
6137 {
6138 //printf("t = %s, stc = x%llx\n", t->toChars(), stc);
6142 }
6144 }
6146 // Create our own scope for the template parameters
6149 {
6150 error("template instantiation %s forward references template declaration %s", toChars(), tempdecl->toChars());
6152 }
6159 //scope->stc = 0;
6161 // Declare each template parameter as an alias for the argument type
6164 paramscope->protection = Prot(PROTpublic); // Bugzilla 14169: template parameters should be public
6168 // Add members of template instance to template instance symbol table
6169 // parent = scope->scopesym;
6172 {
6175 }
6177 /* See if there is only one member of template instance, and that
6178 * member has the same name as the template instance.
6179 * If so, this template instance becomes an alias for that member.
6180 */
6181 //printf("members->dim = %d\n", members->dim);
6183 {
6186 {
6187 //printf("tempdecl->ident = %s, s = '%s'\n", tempdecl->ident->toChars(), s->kind(), s->toPrettyChars());
6188 //printf("setting aliasdecl\n");
6190 }
6191 }
6193 /* If function template declaration
6194 */
6196 {
6199 {
6200 /* Transmit fargs to type so that TypeFunction::semantic() can
6201 * resolve any "auto ref" storage classes.
6202 */
6206 }
6207 }
6209 // Do semantic() analysis on template instance members
6212 //printf("enclosing = %d, sc->parent = %s\n", enclosing, sc->parent->toChars());
6221 /* ConditionalDeclaration may introduce eponymous declaration,
6222 * so we should find it once again after semantic.
6223 */
6225 {
6228 {
6230 {
6231 //printf("tempdecl->ident = %s, s = '%s'\n", tempdecl->ident->toChars(), s->kind(), s->toPrettyChars());
6232 //printf("setting aliasdecl 2\n");
6234 }
6235 }
6236 }
6241 /* If any of the instantiation members didn't get semantic() run
6242 * on them due to forward references, we cannot run semantic2()
6243 * or semantic3() yet.
6244 */
6245 {
6248 {
6252 {
6253 //printf("deferred template aggregate: %s %s\n",
6254 // sd->parent->toChars(), sd->toChars());
6257 {
6260 }
6261 }
6262 }
6265 }
6267 /* The problem is when to parse the initializer for a variable.
6268 * Perhaps VarDeclaration::semantic() should do it like it does
6269 * for initializers inside a function.
6270 */
6271 //if (sc->parent->isFuncDeclaration())
6272 {
6273 /* BUG 782: this has problems if the classes this depends on
6274 * are forward referenced. Find a way to defer semantic()
6275 * on this template.
6276 */
6278 }
6283 {
6284 /* If a template is instantiated inside function, the whole instantiation
6285 * should be done at that position. But, immediate running semantic3 of
6286 * dependent templates may cause unresolved forward reference (Bugzilla 9050).
6287 * To avoid the issue, don't run semantic3 until semantic and semantic2 done.
6288 */
6289 TemplateInstances deferred;
6292 //printf("Run semantic3 on %s\n", toChars());
6296 {
6297 //printf("+ run deferred semantic3 on %s\n", deferred[i]->toChars());
6299 }
6302 }
6304 {
6307 {
6308 /* Template function instantiation should run semantic3 immediately
6309 * for attribute inference.
6310 */
6312 }
6314 {
6315 /* A lambda function in template arguments might capture the
6316 * instantiated scope context. For the correct context inference,
6317 * all instantiated functions should run the semantic3 immediately.
6318 * See also compilable/test14973.d
6319 */
6321 {
6328 {
6333 }
6335 {
6337 {
6340 }
6341 }
6342 }
6343 //printf("[%s] %s doSemantic3 = %d\n", loc.toChars(), toChars(), doSemantic3);
6344 }
6351 {
6354 {
6358 }
6359 }
6361 {
6362 //printf("deferred semantic3 of %p %s, ti = %s, ti->deferred = %p\n", this, toChars(), ti->toChars());
6364 {
6366 {
6369 }
6372 }
6373 }
6374 }
6377 {
6378 /* Bugzilla 13816: AliasDeclaration tries to resolve forward reference
6379 * twice (See inuse check in AliasDeclaration::toAlias()). It's
6380 * necessary to resolve mutual references of instantiated symbols, but
6381 * it will left a true recursive alias in tuple declaration - an
6382 * AliasDeclaration A refers TupleDeclaration B, and B contains A
6383 * in its elements. To correctly make it an error, we strictly need to
6384 * resolve the alias of eponymous member.
6385 */
6387 }
6389 Laftersemantic:
6394 // Give additional context info if error occurred during instantiation
6396 {
6398 {
6403 }
6406 {
6407 // Errors are gagged, so remove the template instance from the
6408 // instance/symbol lists we added it to and reset our state to
6409 // finish clean and so we can try to instantiate it again later
6410 // (see bugzilla 4302 and 6602).
6413 {
6414 // Because we added 'this' in the last position above, we
6415 // should be able to remove it without messing other indices up.
6419 }
6423 }
6424 }
6426 {
6427 /* Bugzilla 14541: If the previous gagged instance had failed by
6428 * circular references, currrent "error reproduction instantiation"
6429 * might succeed, because of the difference of instantiated context.
6430 * On such case, the cached error instance needs to be overridden by the
6431 * succeeded instance.
6432 */
6433 //printf("replaceInstance()\n");
6434 TemplateInstances *tinstances = (TemplateInstances *)dmd_aaGetRvalue((AA *)tempdecl->instances, (void *)hash);
6437 {
6440 {
6443 }
6444 }
6445 }
6446 }
6449 /**********************************************
6450 * Find template declaration corresponding to template instance.
6451 *
6452 * Returns:
6453 * false if finding fails.
6454 * Note:
6455 * This function is reentrant against error occurrence. If returns false,
6456 * any members of this object won't be modified, and repetition call will
6457 * reproduce same error.
6458 */
6461 {
6468 //printf("TemplateInstance::findTempDecl() %s\n", toChars());
6470 {
6471 /* Given:
6472 * foo!( ... )
6473 * figure out which TemplateDeclaration foo refers to.
6474 */
6479 {
6483 else
6486 }
6491 /* We might have found an alias within a template when
6492 * we really want the template.
6493 */
6497 {
6499 {
6500 /* This is so that one can refer to the enclosing
6501 * template, even if it has the same name as a member
6502 * of the template, if it has a !(arguments)
6503 */
6509 }
6510 }
6513 {
6515 }
6516 }
6519 struct ParamFwdTi
6520 {
6522 {
6529 {
6531 {
6532 // Try to fix forward reference. Ungag errors while doing so.
6535 }
6537 {
6540 }
6541 }
6543 }
6544 };
6545 // Look for forward references
6549 {
6552 }
6554 }
6556 /**********************************************
6557 * Confirm s is a valid template, then store it.
6558 * Input:
6559 * sc
6560 * s candidate symbol of template. It may be:
6561 * TemplateDeclaration
6562 * FuncDeclaration with findTemplateDeclRoot() != NULL
6563 * OverloadSet which contains candidates
6564 * Returns:
6565 * true if updating succeeds.
6566 */
6569 {
6571 {
6575 /* If an OverloadSet, look for a unique member that is a template declaration
6576 */
6579 {
6582 {
6586 else
6589 {
6591 {
6594 }
6596 }
6597 }
6599 {
6602 }
6603 }
6607 {
6610 }
6612 /* It should be a TemplateDeclaration, not some other symbol
6613 */
6616 else
6619 {
6623 {
6626 {
6629 }
6631 }
6632 //assert(s->parent);
6637 &&
6639 {
6640 /* This is so that one can refer to the enclosing
6641 * template, even if it has the same name as a member
6642 * of the template, if it has a !(arguments)
6643 */
6649 }
6650 else
6651 {
6654 }
6655 }
6656 }
6658 }
6660 /**********************************
6661 * Run semantic on the elements of tiargs.
6662 * Input:
6663 * sc
6664 * Returns:
6665 * false if one or more arguments have errors.
6666 * Note:
6667 * This function is reentrant against error occurrence. If returns false,
6668 * all elements of tiargs won't be modified.
6669 */
6672 {
6673 //printf("+TemplateInstance::semanticTiargs() %s\n", toChars());
6677 {
6678 // cache the result iff semantic analysis succeeded entirely
6681 }
6683 }
6685 /**********************************
6686 * Run semantic of tiargs as arguments of template.
6687 * Input:
6688 * loc
6689 * sc
6690 * tiargs array of template arguments
6691 * flags 1: replace const variables with their initializers
6692 * 2: don't devolve Parameter to Type
6693 * Returns:
6694 * false if one or more arguments have errors.
6695 */
6698 {
6699 // Run semantic on each argument, place results in tiargs[]
6700 //printf("+TemplateInstance::semanticTiargs()\n");
6705 {
6711 //printf("1: (*tiargs)[%d] = %p, s=%p, v=%p, ea=%p, ta=%p\n", j, o, isDsymbol(o), isTuple(o), ea, ta);
6713 {
6714 //printf("type %s\n", ta->toChars());
6715 // It might really be an Expression or an Alias
6720 {
6723 }
6725 Ltype:
6727 {
6728 // Expand tuple
6733 {
6736 {
6740 else
6742 }
6743 }
6744 j--;
6746 }
6748 {
6751 }
6753 }
6755 {
6756 Lexpr:
6757 //printf("+[%d] ea = %s %s\n", j, Token::toChars(ea->op), ea->toChars());
6759 {
6762 // must not interpret the args, excepting template parameters
6765 {
6767 }
6768 }
6769 else
6770 {
6776 {
6777 /* This test is to skip substituting a const var with
6778 * its initializer. The problem is the initializer won't
6779 * match with an 'alias' parameter. Instead, do the
6780 * const substitution in TemplateValueParameter::matchArg().
6781 */
6782 }
6784 {
6791 }
6792 }
6793 //printf("-[%d] ea = %s %s\n", j, Token::toChars(ea->op), ea->toChars());
6795 {
6796 // Expand tuple
6801 {
6805 }
6806 j--;
6808 }
6810 {
6813 }
6817 {
6820 }
6822 {
6825 }
6827 {
6829 /* A function literal, that is passed to template and
6830 * already semanticed as function pointer, never requires
6831 * outer frame. So convert it to global function is valid.
6832 */
6834 {
6835 // change to non-nested
6838 }
6840 {
6841 /* If template argument is a template lambda,
6842 * get template declaration itself. */
6843 //sa = fe->td;
6844 //goto Ldsym;
6845 }
6846 }
6848 {
6849 // translate expression to dsymbol.
6852 }
6854 {
6857 }
6859 {
6860 // translate expression to dsymbol.
6863 }
6864 }
6866 {
6867 Ldsym:
6868 //printf("dsym %s %s\n", sa->kind(), sa->toChars());
6870 {
6873 }
6877 {
6878 // Expand tuple
6881 j--;
6883 }
6885 {
6888 {
6889 // Strip FuncAlias only when the aliased function
6890 // does not have any overloads.
6892 }
6893 }
6898 {
6900 }
6904 }
6906 {
6907 }
6908 else
6909 {
6911 }
6912 //printf("1: (*tiargs)[%d] = %p\n", j, (*tiargs)[j]);
6913 }
6915 }
6918 {
6920 {
6924 // Deduce tdtypes
6927 {
6930 }
6931 // TODO: Normalizing tiargs for bugzilla 7469 is necessary?
6933 }
6937 struct ParamBest
6938 {
6939 // context
6942 Objects dedtypes;
6943 // result
6946 MATCH m_best;
6949 {
6951 }
6953 {
6961 //printf("td = %s\n", td->toPrettyChars());
6963 // If more arguments than parameters,
6964 // then this is no match.
6966 {
6969 }
6975 //printf("matchWithInstance = %d\n", m);
6982 {
6983 // Disambiguate by picking the most specialized TemplateDeclaration
6986 //printf("c1 = %d, c2 = %d\n", c1, c2);
6989 }
7005 }
7006 };
7007 ParamBest p;
7008 // context
7012 /* Since there can be multiple TemplateDeclaration's with the same
7013 * name, look for the best match.
7014 */
7020 {
7021 // result
7028 {
7034 }
7036 {
7040 {
7043 }
7044 }
7045 }
7048 {
7049 /* Bugzilla 7469: Normalize tiargs by using corresponding deduced
7050 * template value parameters and tuples for the correct mangling.
7051 *
7052 * By doing this before hasNestedArgs, CTFEable local variable will be
7053 * accepted as a value parameter. For example:
7054 *
7055 * void foo() {
7056 * struct S(int n) {} // non-global template
7057 * const int num = 1; // CTFEable local variable
7058 * S!num s; // S!1 is instantiated, not S!num
7059 * }
7060 */
7063 {
7072 // tdtypes[i] is already normalized to the required type in matchArg
7075 }
7077 {
7082 }
7083 }
7085 {
7086 // instantiation was failed with error reporting
7089 }
7090 else
7091 {
7097 {
7098 // Only one template, so we can give better error message
7100 }
7101 else
7105 }
7107 /* The best match is td_last
7108 */
7112 }
7114 /*****************************************************
7115 * Determine if template instance is really a template function,
7116 * and that template function needs to infer types from the function
7117 * arguments.
7118 *
7119 * Like findBestMatch, iterate possible template candidates,
7120 * but just looks only the necessity of type inference.
7121 */
7124 {
7125 //printf("TemplateInstance::needsTypeInference() %s\n", toChars());
7129 struct ParamNeedsInf
7130 {
7131 // context
7135 // result
7136 Objects dedtypes;
7140 {
7142 }
7144 {
7147 {
7149 }
7151 /* If any of the overloaded template declarations need inference,
7152 * then return true
7153 */
7158 {
7164 }
7167 {
7169 }
7172 {
7175 }
7177 /* Determine if the instance arguments, tiargs, are all that is necessary
7178 * to instantiate the template.
7179 */
7180 //printf("tp = %p, td->parameters->dim = %d, tiargs->dim = %d\n", tp, td->parameters->dim, ti->tiargs->dim);
7183 {
7189 {
7190 // Can remain tiargs be filled by default arguments?
7192 {
7195 }
7196 }
7199 {
7200 // 'auto ref' needs inference.
7203 }
7204 }
7207 {
7208 /* Calculate the need for overload resolution.
7209 * When only one template can match with tiargs, inference is not necessary.
7210 */
7214 {
7216 {
7217 // Try to fix forward reference. Ungag errors while doing so.
7220 }
7222 {
7225 }
7226 }
7231 }
7233 /* If there is more than one function template which matches, we may
7234 * need type inference (see Bugzilla 4430)
7235 */
7240 }
7241 };
7242 ParamNeedsInf p;
7243 // context
7247 // result
7254 {
7257 }
7259 {
7261 {
7265 }
7267 }
7268 //printf("false\n");
7270 }
7273 /*****************************************
7274 * Determines if a TemplateInstance will need a nested
7275 * generation of the TemplateDeclaration.
7276 * Sets enclosing property if so, and returns != 0;
7277 */
7280 {
7282 //printf("TemplateInstance::hasNestedArgs('%s')\n", tempdecl->ident->toChars());
7284 /* A nested instance happens when an argument references a local
7285 * symbol that is on the stack.
7286 */
7288 {
7294 {
7296 {
7299 }
7301 {
7304 }
7306 {
7309 else
7312 }
7313 // Emulate Expression::toMangleBuffer call that had exist in TemplateInstance::genIdent.
7322 {
7325 }
7326 }
7328 {
7329 Lsa:
7333 {
7337 }
7346 ))
7347 {
7348 // if module level template
7350 {
7355 {
7356 /* Select the more deeply nested of the two.
7357 * Error if one is not nested inside the other.
7358 */
7360 {
7363 }
7365 {
7367 {
7370 }
7371 }
7375 }
7376 L1:
7377 //printf("\tnested inside %s\n", enclosing->toChars());
7379 }
7380 else
7381 {
7382 error("cannot use local '%s' as parameter to non-global template %s", sa->toChars(), tempdecl->toChars());
7384 }
7385 }
7386 }
7388 {
7390 }
7391 }
7392 //printf("-TemplateInstance::hasNestedArgs('%s') = %d\n", tempdecl->ident->toChars(), nested);
7394 }
7396 /*****************************************
7397 * Append 'this' to the specific module members[]
7398 */
7400 {
7405 {
7406 // Turn all non-root instances to speculative
7409 }
7411 //printf("%s->appendToModuleMember() enclosing = %s mi = %s\n",
7412 // toPrettyChars(),
7413 // enclosing ? enclosing->toPrettyChars() : NULL,
7414 // mi ? mi->toPrettyChars() : NULL);
7416 {
7417 /* If the instantiated module is speculative or root, insert to the
7418 * member of a root module. Then:
7419 * - semantic3 pass will get called on the instance members.
7420 * - codegen pass will get a selection chance to do/skip it.
7421 */
7423 struct N
7424 {
7426 {
7427 do
7428 {
7432 }
7435 }
7436 };
7439 // insert target is made stable by using the module
7440 // where tempdecl is declared.
7445 }
7446 else
7447 {
7448 /* If the instantiated module is non-root, insert to the member of the
7449 * non-root module. Then:
7450 * - semantic3 pass won't be called on the instance.
7451 * - codegen pass won't reach to the instance.
7452 */
7453 }
7454 //printf("\t--> mi = %s\n", mi->toPrettyChars());
7457 {
7459 }
7469 }
7471 /****************************************
7472 * This instance needs an identifier for name mangling purposes.
7473 * Create one by taking the template declaration name and adding
7474 * the type signature for it.
7475 */
7478 {
7482 //printf("TemplateInstance::genIdent('%s')\n", tempdecl->ident->toChars());
7483 OutBuffer buf;
7486 {
7487 // Use "__U" for the symbols declared inside template constraint.
7489 }
7490 else
7494 {
7500 //printf("\to [%d] %p ta %p ea %p sa %p va %p\n", i, o, ta, ea, sa, va);
7504 {
7508 else
7509 {
7511 }
7512 }
7514 {
7515 // Don't interpret it yet, it might actually be an alias template parameter.
7516 // Only constfold manifest constants, not const/immutable lvalues, see https://issues.dlang.org/show_bug.cgi?id=17339.
7520 {
7524 }
7526 {
7530 }
7532 {
7535 else
7539 }
7542 {
7545 }
7546 // Now that we know it is not an alias, we MUST obtain a value
7552 /* Use deco that matches what it would be for a function parameter
7553 */
7556 }
7558 {
7559 Lsa:
7564 {
7567 }
7569 OutBuffer bufsa;
7573 /* Bugzilla 3043: if the first character of s is a digit this
7574 * causes ambiguity issues because the digits of the two numbers are adjacent.
7575 * Current demanglers resolve this by trying various places to separate the
7576 * numbers until one gets a successful demangle.
7577 * Unfortunately, fixing this ambiguity will break existing binary
7578 * compatibility and the demanglers, so we'll leave it as is.
7579 */
7581 }
7583 {
7587 }
7588 else
7590 }
7593 //printf("\tgenIdent = %s\n", id);
7595 }
7597 /*************************************
7598 * Lazily generate identifier for template instance.
7599 * This is because 75% of the ident's are never needed.
7600 */
7603 {
7607 }
7609 /****************************************************
7610 * Declare parameters of template instance, initialize them with the
7611 * template instance arguments.
7612 */
7615 {
7619 //printf("TemplateInstance::declareParameters()\n");
7621 {
7623 //RootObject *o = (*tiargs)[i];
7626 //printf("\ttdtypes[%d] = %p\n", i, o);
7628 }
7629 }
7632 {
7637 {
7655 {
7660 }
7663 {
7665 {
7670 }
7672 }
7678 }
7679 }
7682 {
7683 //if (toChars()[0] == 'D') *(char*)0=0;
7688 {
7701 /* If this is a gagged instantiation, gag errors.
7702 * Future optimisation: If the results are actually needed, errors
7703 * would already be gagged, so we don't really need to run semantic
7704 * on the members.
7705 */
7710 {
7715 }
7718 {
7720 {
7725 }
7727 }
7733 }
7734 }
7736 /**************************************
7737 * Given an error instantiating the TemplateInstance,
7738 * give the nested TemplateInstance instantiations that got
7739 * us here. Those are a list threaded into the nested scopes.
7740 */
7742 {
7749 // determine instantiation depth and number of recursive instantiations
7753 {
7755 // If two instantiations use the same declaration, they are recursive.
7756 // (this works even if they are instantiated from different places in the
7757 // same template).
7758 // In principle, we could also check for multiple-template recursion, but it's
7759 // probably not worthwhile.
7763 }
7765 // show full trace only if it's short or verbose is on
7767 {
7769 {
7772 }
7773 }
7775 {
7776 // By collapsing recursive instantiations into a single line,
7777 // we can stay under the limit.
7780 {
7784 {
7786 }
7787 else
7788 {
7790 errorSupplemental(cur->loc, "%d recursive instantiations from here: %s", recursionDepth+2, cur->toChars());
7791 else
7794 }
7795 }
7796 }
7797 else
7798 {
7799 // Even after collapsing the recursions, the depth is too deep.
7800 // Just display the first few and last few instantiations.
7803 {
7807 errorSupplemental(cur->loc, "... (%d instantiations, -v to show) ...", n_instantiations - max_shown);
7813 }
7814 }
7815 }
7818 {
7820 {
7821 // Maybe we can resolve it
7823 {
7825 }
7827 {
7831 }
7832 }
7838 {
7840 }
7843 }
7846 {
7848 }
7851 {
7854 }
7857 {
7858 OutBuffer buf;
7861 }
7864 {
7865 OutBuffer buf;
7868 }
7870 /*************************************
7871 * Compare proposed template instantiation with existing template instantiation.
7872 * Note that this is not commutative because of the auto ref check.
7873 * Params:
7874 * this = proposed template instantiation
7875 * o = existing template instantiation
7876 * Returns:
7877 * 0 for match, 1 for no match
7878 */
7880 {
7883 //printf("this = %p, ti = %p\n", this, ti);
7886 // Nesting must match
7888 {
7889 //printf("test2 enclosing %s ti->enclosing %s\n", enclosing ? enclosing->toChars() : "", ti->enclosing ? ti->enclosing->toChars() : "");
7891 }
7892 //printf("parent = %s, ti->parent = %s\n", parent->toPrettyChars(), ti->parent->toPrettyChars());
7897 /* Template functions may have different instantiations based on
7898 * "auto ref" parameters.
7899 */
7901 {
7903 {
7907 {
7910 {
7917 {
7920 }
7921 else
7922 {
7925 }
7926 }
7927 }
7928 }
7929 }
7932 Lnotequals:
7934 }
7937 {
7939 {
7943 }
7945 }
7947 /**************************************
7948 * IsExpression can evaluate the specified type speculatively, and even if
7949 * it instantiates any symbols, they are normally unnecessary for the
7950 * final executable.
7951 * However, if those symbols leak to the actual code, compiler should remark
7952 * them as non-speculative to generate their code and link to the final executable.
7953 */
7955 {
7960 {
7962 {
7964 }
7966 }
7973 {
7977 {
7981 }
7982 else
7988 }
7991 {
7992 // If the instance is already non-speculative,
7993 // or it is leaked to the speculative scope.
7997 // Remark as non-speculative instance.
8003 }
8007 }
8009 /***********************************************
8010 * Returns true if this is not instantiated in non-root module, and
8011 * is a part of non-speculative instantiatiation.
8012 *
8013 * Note: minst does not stabilize until semantic analysis is completed,
8014 * so don't call this function during semantic analysis to return precise result.
8015 */
8017 {
8018 // Now -allInst is just for the backward compatibility.
8020 {
8021 //printf("%s minst = %s, enclosing (%s)->isNonRoot = %d\n",
8022 // toPrettyChars(), minst ? minst->toChars() : NULL,
8023 // enclosing ? enclosing->toPrettyChars() : NULL, enclosing && enclosing->inNonRoot());
8025 {
8026 // Bugzilla 14588: If the captured context is not a function
8027 // (e.g. class), the instance layout determination is guaranteed,
8028 // because the semantic/semantic2 pass will be executed
8029 // even for non-root instances.
8033 // Bugzilla 14834: If the captured context is a function,
8034 // this excessive instantiation may cause ODR violation, because
8035 // -allInst and others doesn't guarantee the semantic3 execution
8036 // for that function.
8038 // If the enclosing is also an instantiated function,
8039 // we have to rely on the ancestor's needsCodegen() result.
8043 // Bugzilla 13415: If and only if the enclosing scope needs codegen,
8044 // this nested templates would also need code generation.
8046 }
8048 }
8051 {
8052 // If this is a speculative instantiation,
8053 // 1. do codegen if ancestors really needs codegen.
8054 // 2. become non-speculative if siblings are not speculative
8058 // At first, disconnect chain first to prevent infinite recursion.
8062 // Determine necessity of tinst before tnext.
8064 {
8069 }
8071 {
8075 }
8077 // Elide codegen because this is really speculative.
8079 }
8081 /* Even when this is reached to the codegen pass,
8082 * a non-root nested template should not generate code,
8083 * due to avoid ODR violation.
8084 */
8086 {
8088 {
8092 }
8094 {
8098 }
8100 }
8102 /* The issue is that if the importee is compiled with a different -debug
8103 * setting than the importer, the importer may believe it exists
8104 * in the compiled importee when it does not, when the instantiation
8105 * is behind a conditional debug declaration.
8106 */
8107 // workaround for Bugzilla 11239
8110 {
8111 // Prefer instantiations from root modules, to maximize link-ability.
8121 {
8126 }
8128 {
8133 }
8135 // Bugzilla 2500 case
8139 // Elide codegen because this is not included in root instances.
8141 }
8142 else
8143 {
8144 // Prefer instantiations from non-root module, to minimize object code size.
8146 /* If a TemplateInstance is ever instantiated by non-root modules,
8147 * we do not have to generate code for it,
8148 * because it will be generated when the non-root module is compiled.
8149 *
8150 * But, if the non-root 'minst' imports any root modules, it might still need codegen.
8151 *
8152 * The problem is if A imports B, and B imports A, and both A
8153 * and B instantiate the same template, does the compilation of A
8154 * or the compilation of B do the actual instantiation?
8155 *
8156 * See Bugzilla 2500.
8157 */
8165 {
8169 }
8171 // Do codegen because this is not included in non-root instances.
8173 }
8174 }
8176 /* ======================== TemplateMixin ================================ */
8178 TemplateMixin::TemplateMixin(Loc loc, Identifier *ident, TypeQualified *tqual, Objects *tiargs)
8181 {
8182 //printf("TemplateMixin(ident = '%s')\n", ident ? ident->toChars() : "");
8186 }
8189 {
8193 }
8196 {
8197 // Follow qualifications to find the TemplateDeclaration
8199 {
8205 {
8208 }
8213 /* If an OverloadSet, look for a unique member that is a template declaration
8214 */
8216 {
8219 {
8222 {
8224 {
8227 }
8229 }
8230 }
8231 }
8233 {
8236 }
8237 }
8240 struct ParamFwdResTm
8241 {
8243 {
8250 {
8253 else
8254 {
8257 }
8258 }
8260 }
8261 };
8262 // Look for forward references
8266 {
8269 }
8271 }
8274 {
8276 {
8277 // When a class/struct contains mixin members, and is done over
8278 // because of forward references, never reach here so semanticRun
8279 // has been reset to PASSinit.
8281 }
8286 {
8290 }
8292 /* Run semantic on each argument, place results in tiargs[],
8293 * then find best match template with tiargs
8294 */
8298 {
8300 {
8301 //printf("forward reference - deferring\n");
8306 }
8311 }
8316 {
8317 /* Assign scope local unique identifier, as same as lambdas.
8318 */
8323 {
8326 {
8327 // Inside template constraint, symtab is not set yet.
8329 }
8330 }
8331 else
8332 {
8334 L1:
8339 }
8340 }
8345 /* Detect recursive mixin instantiations.
8346 */
8348 {
8349 //printf("\ts = '%s'\n", s->toChars());
8354 /* Different argument list lengths happen with variadic args
8355 */
8360 {
8367 {
8373 }
8375 {
8379 }
8381 {
8385 }
8386 else
8388 }
8392 Lcontinue:
8394 }
8396 // Copy the syntax trees from the TemplateDeclaration
8404 {
8407 {
8410 }
8411 }
8422 // Declare each template parameter as an alias for the argument type
8425 // Add members to enclosing scope, as well as this scope
8427 {
8430 //printf("sc->parent = %p, sc->scopesym = %p\n", sc->parent, sc->scopesym);
8431 //printf("s->parent = %s\n", s->parent->toChars());
8432 }
8434 // Do semantic() analysis on template instance members
8436 //size_t deferred_dim = Module::deferred.dim;
8439 //printf("%d\n", nest);
8441 {
8445 }
8448 {
8451 }
8454 {
8457 }
8460 {
8463 }
8465 nest--;
8467 /* In DeclDefs scope, TemplateMixin does not have to handle deferred symbols.
8468 * Because the members would already call Module::addDeferredSemantic() for themselves.
8469 * See Struct, Class, Interface, and EnumDeclaration::semantic().
8470 */
8471 //if (!sc->func && Module::deferred.dim > deferred_dim) {}
8475 {
8478 }
8480 // Give additional context info if error occurred during instantiation
8482 {
8485 }
8490 }
8493 {
8498 {
8503 {
8506 }
8509 }
8510 }
8513 {
8518 {
8522 {
8525 }
8528 }
8529 }
8532 {
8534 }
8537 {
8539 }
8542 {
8546 {
8548 {
8551 {
8554 }
8555 }
8556 }
8558 }
8561 {
8562 //printf("TemplateMixin::hasPointers() %s\n", toChars());
8565 {
8567 {
8569 //printf(" s = %s %s\n", s->kind(), s->toChars());
8571 {
8573 }
8574 }
8575 }
8577 }
8580 {
8581 //printf("TemplateMixin::setFieldOffset() %s\n", toChars());
8585 {
8587 {
8589 //printf("\t%s\n", s->toChars());
8591 }
8592 }
8593 }
8596 {
8597 OutBuffer buf;
8600 }