Struct erg_compiler::error::CompileError
source · pub struct CompileError {
pub core: Box<ErrorCore>,
pub input: Input,
pub caused_by: String,
pub theme: Theme,
}Fields§
§core: Box<ErrorCore>§input: Input§caused_by: String§theme: ThemeImplementations§
source§impl CompileError
impl CompileError
sourcepub fn new(core: ErrorCore, input: Input, caused_by: String) -> Self
pub fn new(core: ErrorCore, input: Input, caused_by: String) -> Self
Examples found in repository?
context/inquire.rs (line 839)
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
fn append_loc_info(&self, e: TyCheckError, loc: Location) -> TyCheckError {
if e.core.loc == Location::Unknown {
let mut sub_msges = Vec::new();
for sub_msg in e.core.sub_messages {
sub_msges.push(SubMessage::ambiguous_new(loc, sub_msg.msg, sub_msg.hint));
}
let core = ErrorCore::new(
sub_msges,
e.core.main_message,
e.core.errno,
e.core.kind,
e.core.loc,
);
TyCheckError::new(core, self.cfg.input.clone(), e.caused_by)
} else {
e
}
}More examples
context/eval.rs (lines 283-287)
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
fn call(&self, subr: ConstSubr, args: ValueArgs, loc: Location) -> EvalResult<ValueObj> {
match subr {
ConstSubr::User(_user) => {
feature_error!(self, loc, "calling user-defined subroutines").map_err(Into::into)
}
ConstSubr::Builtin(builtin) => builtin.call(args, self).map_err(|mut e| {
if e.0.loc.is_unknown() {
e.0.loc = loc;
}
EvalErrors::from(EvalError::new(
*e.0,
self.cfg.input.clone(),
self.caused_by(),
))
}),
}
}error.rs (lines 235-250)
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
pub fn compiler_bug(
errno: usize,
input: Input,
loc: Location,
fn_name: &str,
line: u32,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("これはErg compilerのバグです、開発者に報告して下さい ({URL})\n\n{fn_name}:{line}より発生"),
"simplified_chinese" => format!("这是Erg编译器的错误，请报告给{URL}\n\n原因来自: {fn_name}:{line}"),
"traditional_chinese" => format!("這是Erg編譯器的錯誤，請報告給{URL}\n\n原因來自: {fn_name}:{line}"),
"english" => format!("this is a bug of the Erg compiler, please report it to {URL}\n\ncaused from: {fn_name}:{line}"),
),
errno,
CompilerSystemError,
loc,
),
input,
"".to_owned(),
)
}
pub fn stack_bug(
input: Input,
loc: Location,
stack_len: u32,
block_id: usize,
fn_name: &str,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("\
スタックの要素数が異常です (要素数: {stack_len}, ブロックID: {block_id})
これはコンパイラのバグです、開発者に報告して下さい ({URL})
{fn_name}より発生"),
"simplified_chinese" => format!("\
堆栈中的元素数无效（元素数: {stack_len}，块id: {block_id}）
这是 Erg 编译器的一个错误，请报告它 ({URL})
起因于: {fn_name}"),
"traditional_chinese" => format!("\
堆棧中的元素數無效（元素數: {stack_len}，塊id: {block_id}）\n
這是 Erg 編譯器的一個錯誤，請報告它 ({URL})
起因於: {fn_name}"),
"english" => format!("\
the number of elements in the stack is invalid (num of elems: {stack_len}, block id: {block_id})\n
this is a bug of the Erg compiler, please report it to {URL}
caused from: {fn_name}"),
),
0,
CompilerSystemError,
loc,
),
input,
"".to_owned(),
)
}
pub fn feature_error(input: Input, loc: Location, name: &str, caused_by: String) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("この機能({name})はまだ正式に提供されていません"),
"simplified_chinese" => format!("此功能（{name}）尚未实现"),
"traditional_chinese" => format!("此功能（{name}）尚未實現"),
"english" => format!("this feature({name}) is not implemented yet"),
),
0,
FeatureError,
loc,
),
input,
caused_by,
)
}
pub fn system_exit() -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(Location::Unknown)],
switch_lang!(
"japanese" => "システムを終了します",
"simplified_chinese" => "系统正在退出",
"traditional_chinese" => "系統正在退出",
"english" => "system is exiting",
),
0,
SystemExit,
Location::Unknown,
),
Input::Dummy,
"".to_owned(),
)
}
}
pub type TyCheckError = CompileError;
impl TyCheckError {
pub fn dummy(input: Input, errno: usize) -> Self {
Self::new(ErrorCore::dummy(errno), input, "".to_string())
}
pub fn unreachable(input: Input, fn_name: &str, line: u32) -> Self {
Self::new(ErrorCore::unreachable(fn_name, line), input, "".to_string())
}
pub fn checker_bug(
input: Input,
errno: usize,
loc: Location,
fn_name: &str,
line: u32,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("これはErg compilerのバグです、開発者に報告して下さい ({URL})\n\n{fn_name}:{line}より発生"),
"simplified_chinese" => format!("这是Erg编译器的错误，请报告给{URL}\n\n原因来自: {fn_name}:{line}"),
"traditional_chinese" => format!("這是Erg編譯器的錯誤，請報告給{URL}\n\n原因來自: {fn_name}:{line}"),
"english" => format!("this is a bug of the Erg compiler, please report it to {URL}\n\ncaused from: {fn_name}:{line}"),
),
errno,
CompilerSystemError,
loc,
),
input,
"".to_string(),
)
}
pub fn no_type_spec_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
) -> Self {
let name = readable_name(name);
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}の型が指定されていません"),
"simplified_chinese" => format!("{name}的类型未指定"),
"traditional_chinese" => format!("{name}的類型未指定"),
"english" => format!("the type of {name} is not specified"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn callable_impl_error<'a, C: Locational + Display>(
input: Input,
errno: usize,
callee: &C,
param_ts: impl Iterator<Item = &'a Type>,
caused_by: String,
) -> Self {
let param_ts = fmt_iter(param_ts);
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(callee.loc())],
switch_lang!(
"japanese" => format!(
"{callee}は{param_ts}を引数に取る呼び出し可能オブジェクトではありません"
),
"simplified_chinese" => format!("{callee}不是以{param_ts}作为参数的可调用对象"),
"traditional_chinese" => format!("{callee}不是以{param_ts}作為參數的可調用對象"),
"english" => format!(
"{callee} is not a Callable object that takes {param_ts} as an argument"
),
),
errno,
NotImplementedError,
callee.loc(),
),
input,
caused_by,
)
}
#[allow(clippy::too_many_arguments)]
pub fn type_mismatch_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
nth_param: Option<usize>,
expect: &Type,
found: &Type,
candidates: Option<Set<Type>>,
hint: Option<String>,
) -> Self {
let ord = match nth_param {
Some(pos) => switch_lang!(
"japanese" => format!("({pos}番目の引数)"),
"simplified_chinese" => format!("(第{pos}个参数)"),
"traditional_chinese" => format!("(第{pos}個參數)"),
"english" => format!(" (the {} argument)", ordinal_num(pos)),
),
None => "".to_owned(),
};
let name = StyledString::new(format!("{}{}", name, ord), Some(WARN), Some(ATTR));
let mut expct = StyledStrings::default();
switch_lang!(
"japanese" => expct.push_str("予期した型: "),
"simplified_chinese" =>expct.push_str("预期: "),
"traditional_chinese" => expct.push_str("預期: "),
"english" => expct.push_str("expected: "),
);
expct.push_str_with_color_and_attribute(format!("{}", expect), HINT, ATTR);
let mut fnd = StyledStrings::default();
switch_lang!(
"japanese" => fnd.push_str("与えられた型: "),
"simplified_chinese" => fnd.push_str("但找到: "),
"traditional_chinese" => fnd.push_str("但找到: "),
"english" =>fnd.push_str("but found: "),
);
fnd.push_str_with_color_and_attribute(format!("{}", found), ERR, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![expct.to_string(), fnd.to_string()],
hint,
)],
switch_lang!(
"japanese" => format!("{name}の型が違います{}", fmt_option_map!(pre "\n与えられた型の単一化候補: ", candidates, |x: &Set<Type>| x.folded_display())),
"simplified_chinese" => format!("{name}的类型不匹配{}", fmt_option_map!(pre "\n某一类型的统一候选: ", candidates, |x: &Set<Type>| x.folded_display())),
"traditional_chinese" => format!("{name}的類型不匹配{}", fmt_option_map!(pre "\n某一類型的統一候選: ", candidates, |x: &Set<Type>| x.folded_display())),
"english" => format!("the type of {name} is mismatched{}", fmt_option_map!(pre "\nunification candidates of a given type: ", candidates, |x: &Set<Type>| x.folded_display())),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn return_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
expect: &Type,
found: &Type,
) -> Self {
let mut expct = StyledStrings::default();
switch_lang!(
"japanese" => expct.push_str("予期した型: "),
"simplified_chinese" =>expct.push_str("预期: "),
"traditional_chinese" => expct.push_str("預期: "),
"english" => expct.push_str("expected: "),
);
expct.push_str_with_color_and_attribute(format!("{}", expect), HINT, ATTR);
let mut fnd = StyledStrings::default();
switch_lang!(
"japanese" => fnd.push_str("与えられた型: "),
"simplified_chinese" => fnd.push_str("但找到: "),
"traditional_chinese" => fnd.push_str("但找到: "),
"english" =>fnd.push_str("but found: "),
);
fnd.push_str_with_color_and_attribute(format!("{}", found), ERR, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![expct.to_string(), fnd.to_string()],
None,
)],
switch_lang!(
"japanese" => format!("{name}の戻り値の型が違います"),
"simplified_chinese" => format!("{name}的返回类型不匹配"),
"traditional_chinese" => format!("{name}的返回類型不匹配"),
"english" => format!("the return type of {name} is mismatched"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn uninitialized_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
t: &Type,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}: {t}は宣言されましたが初期化されていません"),
"simplified_chinese" => format!("{name}: {t}已声明但未初始化"),
"traditional_chinese" => format!("{name}: {t}已宣告但未初始化"),
"english" => format!("{name}: {t} is declared but not initialized"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn argument_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expect: usize,
found: usize,
) -> Self {
let mut expct = StyledStrings::default();
switch_lang!(
"japanese" => expct.push_str("予期した個数: "),
"simplified_chinese" =>expct.push_str("预期: "),
"traditional_chinese" => expct.push_str("預期: "),
"english" => expct.push_str("expected: "),
);
expct.push_str_with_color_and_attribute(format!("{}", expect), HINT, ATTR);
let mut fnd = StyledStrings::default();
switch_lang!(
"japanese" => fnd.push_str("与えられた個数: "),
"simplified_chinese" => fnd.push_str("但找到: "),
"traditional_chinese" => fnd.push_str("但找到: "),
"english" =>fnd.push_str("but found: "),
);
fnd.push_str_with_color_and_attribute(format!("{}", found), ERR, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![expct.to_string(), fnd.to_string()],
None,
)],
switch_lang!(
"japanese" => format!("ポジショナル引数の数が違います"),
"simplified_chinese" => format!("正则参数的数量不匹配"),
"traditional_chinese" => format!("正則參數的數量不匹配"),
"english" => format!("the number of positional arguments is mismatched"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn param_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expect: usize,
found: usize,
) -> Self {
let mut expct = StyledStrings::default();
switch_lang!(
"japanese" => expct.push_str("予期した個数: "),
"simplified_chinese" =>expct.push_str("预期: "),
"traditional_chinese" => expct.push_str("預期: "),
"english" => expct.push_str("expected: "),
);
expct.push_str_with_color_and_attribute(format!("{}", expect), HINT, ATTR);
let mut fnd = StyledStrings::default();
switch_lang!(
"japanese" => fnd.push_str("与えられた個数: "),
"simplified_chinese" => fnd.push_str("但找到: "),
"traditional_chinese" => fnd.push_str("但找到: "),
"english" =>fnd.push_str("but found: "),
);
fnd.push_str_with_color_and_attribute(format!("{}", found), ERR, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![expct.to_string(), fnd.to_string()],
None,
)],
switch_lang!(
"japanese" => format!("引数の数が違います"),
"simplified_chinese" => format!("参数的数量不匹配"),
"traditional_chinese" => format!("參數的數量不匹配"),
"english" => format!("the number of parameters is mismatched"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn default_param_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
) -> Self {
Self::new(
ErrorCore::new(
vec![],
switch_lang!(
"japanese" => format!("{name}はデフォルト引数を受け取りません"),
"simplified_chinese" => format!("{name}不接受默认参数"),
"traditional_chinese" => format!("{name}不接受預設參數"),
"english" => format!("{name} does not accept default parameters"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn match_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expr_t: &Type,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{expr_t}型の全パターンを網羅していません"),
"simplified_chinese" => format!("并非所有{expr_t}类型的模式都被涵盖"),
"traditional_chinese" => format!("並非所有{expr_t}類型的模式都被涵蓋"),
"english" => format!("not all patterns of type {expr_t} are covered"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn infer_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expr: &str,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{expr}の型が推論できません"),
"simplified_chinese" => format!("无法推断{expr}的类型"),
"traditional_chinese" => format!("無法推斷{expr}的類型"),
"english" => format!("failed to infer the type of {expr}"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn dummy_infer_error(input: Input, fn_name: &str, line: u32) -> Self {
Self::new(ErrorCore::unreachable(fn_name, line), input, "".to_owned())
}
pub fn not_relation(input: Input, fn_name: &str, line: u32) -> Self {
Self::new(ErrorCore::unreachable(fn_name, line), input, "".to_owned())
}
#[allow(clippy::too_many_arguments)]
pub fn too_many_args_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
params_len: usize,
pos_args_len: usize,
kw_args_len: usize,
) -> Self {
let name = readable_name(callee_name);
let expect = StyledString::new(format!("{}", params_len), Some(HINT), Some(ATTR));
let pos_args_len = StyledString::new(format!("{}", pos_args_len), Some(ERR), Some(ATTR));
let kw_args_len = StyledString::new(format!("{}", kw_args_len), Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!(
"{name}に渡された引数の数が多すぎます
必要な引数の合計数: {expect}個
渡された引数の数: {pos_args_len}個
キーワード引数の数: {kw_args_len}個"
),
"simplified_chinese" => format!("传递给{name}的参数过多
总的预期参数: {expect}
通过的位置参数: {pos_args_len}
通过了关键字参数: {kw_args_len}"
),
"traditional_chinese" => format!("傳遞給{name}的參數過多
所需參數總數: {expect}
遞的參數數量: {pos_args_len}
字參數的數量: {kw_args_len}"
),
"english" => format!(
"too many arguments for {name}
total expected params: {expect}
passed positional args: {pos_args_len}
passed keyword args: {kw_args_len}"
),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn args_missing_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
missing_params: Vec<Str>,
) -> Self {
let name = StyledStr::new(readable_name(callee_name), Some(WARN), Some(ATTR));
let vec_cxt = StyledString::new(fmt_vec(&missing_params), Some(WARN), Some(ATTR));
let missing_len = missing_params.len();
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}に渡された引数が{missing_len}個足りません\n不足している引数: {vec_cxt}" ),
"simplified_chinese" => format!("{name}的{missing_len}个位置参数不被传递\n缺少的参数: {vec_cxt}" ),
"traditional_chinese" => format!("{name}的{missing_len}個位置參數不被傳遞\n缺少的參數: {vec_cxt}" ),
"english" => format!("missing {missing_len} positional argument(s) for {name}\nmissing: {vec_cxt}"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn multiple_args_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
arg_name: &str,
) -> Self {
let name = StyledStr::new(readable_name(callee_name), Some(WARN), Some(ATTR));
let found = StyledString::new(arg_name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}の引数{found}が複数回渡されています"),
"simplified_chinese" => format!("{name}的参数{found}被多次传递"),
"traditional_chinese" => format!("{name}的參數{found}被多次傳遞"),
"english" => format!("{name}'s argument {found} is passed multiple times"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn unexpected_kw_arg_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
param_name: &str,
) -> Self {
let name = StyledStr::new(readable_name(callee_name), Some(WARN), Some(ATTR));
let found = StyledString::new(param_name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}には予期しないキーワード引数{found}が渡されています"),
"simplified_chinese" => format!("{name}得到了意外的关键字参数{found}"),
"traditional_chinese" => format!("{name}得到了意外的關鍵字參數{found}"),
"english" => format!("{name} got unexpected keyword argument {found}"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn unification_error(
input: Input,
errno: usize,
lhs_t: &Type,
rhs_t: &Type,
loc: Location,
caused_by: String,
) -> Self {
let mut lhs_typ = StyledStrings::default();
switch_lang!(
"japanese" => lhs_typ.push_str("左辺: "),
"simplified_chinese" => lhs_typ.push_str("左边: "),
"traditional_chinese" => lhs_typ.push_str("左邊: "),
"english" => lhs_typ.push_str("lhs: "),
);
lhs_typ.push_str_with_color_and_attribute(format!("{}", lhs_t), WARN, ATTR);
let mut rhs_typ = StyledStrings::default();
switch_lang!(
"japanese" => rhs_typ.push_str("右辺: "),
"simplified_chinese" => rhs_typ.push_str("右边: "),
"traditional_chinese" => rhs_typ.push_str("右邊: "),
"english" => rhs_typ.push_str("rhs: "),
);
rhs_typ.push_str_with_color_and_attribute(format!("{}", rhs_t), WARN, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![lhs_typ.to_string(), rhs_typ.to_string()],
None,
)],
switch_lang!(
"japanese" => format!("型の単一化に失敗しました"),
"simplified_chinese" => format!("类型统一失败"),
"traditional_chinese" => format!("類型統一失敗"),
"english" => format!("unification failed"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn re_unification_error(
input: Input,
errno: usize,
lhs_t: &Type,
rhs_t: &Type,
loc: Location,
caused_by: String,
) -> Self {
let mut lhs_typ = StyledStrings::default();
switch_lang!(
"japanese" => lhs_typ.push_str("左辺: "),
"simplified_chinese" => lhs_typ.push_str("左边: "),
"traditional_chinese" => lhs_typ.push_str("左邊: "),
"english" => lhs_typ.push_str("lhs: "),
);
lhs_typ.push_str_with_color_and_attribute(format!("{}", lhs_t), WARN, ATTR);
let mut rhs_typ = StyledStrings::default();
switch_lang!(
"japanese" => rhs_typ.push_str("右辺: "),
"simplified_chinese" => rhs_typ.push_str("右边: "),
"traditional_chinese" => rhs_typ.push_str("右邊: "),
"english" => rhs_typ.push_str("rhs: "),
);
rhs_typ.push_str_with_color_and_attribute(format!("{}", rhs_t), WARN, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![lhs_typ.to_string(), rhs_typ.to_string()],
None,
)],
switch_lang!(
"japanese" => format!("型の再単一化に失敗しました"),
"simplified_chinese" => format!("重新统一类型失败"),
"traditional_chinese" => format!("重新統一類型失敗"),
"english" => format!("re-unification failed"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn subtyping_error(
input: Input,
errno: usize,
sub_t: &Type,
sup_t: &Type,
loc: Location,
caused_by: String,
) -> Self {
let mut sub_type = StyledStrings::default();
switch_lang!(
"japanese" => sub_type.push_str("部分型: "),
"simplified_chinese" => sub_type.push_str("超类型: "),
"simplified_chinese" =>sub_type.push_str("超類型: "),
"english" => sub_type.push_str("subtype: "),
);
sub_type.push_str_with_color_and_attribute(format!("{}", sub_t), HINT, ATTR);
let mut sup_type = StyledStrings::default();
switch_lang!(
"japanese" => sup_type.push_str("汎化型: "),
"simplified_chinese" => sup_type.push_str("超类型: "),
"simplified_chinese" => sup_type.push_str("超類型: "),
"english" =>sup_type.push_str("supertype: "),
);
sup_type.push_str_with_color_and_attribute(format!("{}", sup_t), ERR, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![sub_type.to_string(), sup_type.to_string()],
None,
)],
switch_lang!(
"japanese" => format!("この式の部分型制約を満たせません"),
"simplified_chinese" => format!("无法满足此表达式中的子类型约束"),
"traditional_chinese" => format!("無法滿足此表達式中的子類型約束"),
"english" => format!("the subtype constraint in this expression cannot be satisfied"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn pred_unification_error(
input: Input,
errno: usize,
lhs: &Predicate,
rhs: &Predicate,
caused_by: String,
) -> Self {
let mut lhs_uni = StyledStrings::default();
switch_lang!(
"japanese" => lhs_uni.push_str("左辺: "),
"simplified_chinese" => lhs_uni.push_str("左边: "),
"traditional_chinese" => lhs_uni.push_str("左邊: "),
"english" => lhs_uni.push_str("lhs: "),
);
lhs_uni.push_str_with_color_and_attribute(format!("{}", lhs), HINT, ATTR);
let mut rhs_uni = StyledStrings::default();
switch_lang!(
"japanese" => rhs_uni.push_str("右辺: "),
"simplified_chinese" => rhs_uni.push_str("右边: "),
"traditional_chinese" => rhs_uni.push_str("右邊: "),
"english" => rhs_uni.push_str("rhs: "),
);
rhs_uni.push_str_with_color_and_attribute(format!("{}", rhs), ERR, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
Location::Unknown,
vec![lhs_uni.to_string(), rhs_uni.to_string()],
None,
)],
switch_lang!(
"japanese" => format!("述語式の単一化に失敗しました"),
"simplified_chinese" => format!("无法统一谓词表达式"),
"traditional_chinese" => format!("無法統一謂詞表達式"),
"english" => format!("predicate unification failed"),
),
errno,
TypeError,
Location::Unknown,
),
input,
caused_by,
)
}
pub fn no_candidate_error(
input: Input,
errno: usize,
proj: &Type,
loc: Location,
caused_by: String,
hint: Option<String>,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{proj}の候補がありません"),
"simplified_chinese" => format!("{proj}没有候选项"),
"traditional_chinese" => format!("{proj}沒有候選項"),
"english" => format!("no candidate for {proj}"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn no_trait_impl_error(
input: Input,
errno: usize,
class: &Type,
trait_: &Type,
loc: Location,
caused_by: String,
hint: Option<String>,
) -> Self {
let hint = hint.or_else(|| Context::get_simple_type_mismatch_hint(trait_, class));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{class}は{trait_}を実装していません"),
"simplified_chinese" => format!("{class}没有实现{trait_}"),
"traditional_chinese" => format!("{class}沒有實現{trait_}"),
"english" => format!("{class} does not implement {trait_}"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn method_definition_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
hint: Option<String>,
) -> Self {
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!(
"{found}にメソッドを定義することはできません",
),
"simplified_chinese" => format!(
"{found}不可定义方法",
),
"traditional_chinese" => format!(
"{found}不可定義方法",
),
"english" => format!(
"cannot define methods for {found}",
),
),
errno,
MethodError,
loc,
),
input,
caused_by,
)
}
#[allow(clippy::too_many_arguments)]
pub fn trait_member_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
member_name: &str,
trait_type: &Type,
expect: &Type,
found: &Type,
hint: Option<String>,
) -> Self {
let mut expct = StyledStrings::default();
switch_lang!(
"japanese" => {
expct.push_str_with_color_and_attribute(format!("{}", trait_type), ACCENT, ATTR);
expct.push_str("で宣言された型: ");
},
"simplified_chinese" => {
expct.push_str_with_color_and_attribute(format!("{}", trait_type), ACCENT, ATTR);
expct.push_str("中声明的类型: ");
},
"traditional_chinese" => {
expct.push_str_with_color_and_attribute(format!("{}", trait_type), ACCENT, ATTR);
expct.push_str("中聲明的類型: ");
},
"english" => {
expct.push_str("declared in ");
expct.push_str_with_color(format!("{}: ", trait_type), ACCENT);
},
);
expct.push_str_with_color(format!("{}", expect), HINT);
let mut fnd = StyledStrings::default();
switch_lang!(
"japanese" => fnd.push_str("与えられた型: "),
"simplified_chinese" => fnd.push_str("但找到: "),
"traditional_chinese" => fnd.push_str("但找到: "),
"english" => fnd.push_str("but found: "),
);
fnd.push_str_with_color(format!("{}", found), ERR);
let member_name = StyledStr::new(member_name, Some(WARN), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
loc,
vec![expct.to_string(), fnd.to_string()],
hint,
)],
switch_lang!(
"japanese" => format!("{member_name}の型が違います"),
"simplified_chinese" => format!("{member_name}的类型不匹配"),
"traditional_chinese" => format!("{member_name}的類型不匹配"),
"english" => format!("the type of {member_name} is mismatched"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
#[allow(clippy::too_many_arguments)]
pub fn trait_member_not_defined_error(
input: Input,
errno: usize,
caused_by: String,
member_name: &str,
trait_type: &Type,
class_type: &Type,
hint: Option<String>,
) -> Self {
let member_name = StyledString::new(member_name, Some(WARN), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(Location::Unknown, vec![], hint)],
switch_lang!(
"japanese" => format!("{trait_type}の{member_name}が{class_type}で実装されていません"),
"simplified_chinese" => format!("{trait_type}中的{member_name}没有在{class_type}中实现"),
"traditional_chinese" => format!("{trait_type}中的{member_name}沒有在{class_type}中實現"),
"english" => format!("{member_name} of {trait_type} is not implemented in {class_type}"),
),
errno,
TypeError,
Location::Unknown,
),
input,
caused_by,
)
}
#[allow(clippy::too_many_arguments)]
pub fn not_in_trait_error(
input: Input,
errno: usize,
caused_by: String,
member_name: &str,
trait_type: &Type,
class_type: &Type,
hint: Option<String>,
) -> Self {
let member_name = StyledString::new(member_name, Some(WARN), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(Location::Unknown, vec![], hint)],
switch_lang!(
"japanese" => format!("{class_type}の{member_name}は{trait_type}で宣言されていません"),
"simplified_chinese" => format!("{class_type}中的{member_name}没有在{trait_type}中声明"),
"traditional_chinese" => format!("{class_type}中的{member_name}沒有在{trait_type}中聲明"),
"english" => format!("{member_name} of {class_type} is not declared in {trait_type}"),
),
errno,
TypeError,
Location::Unknown,
),
input,
caused_by,
)
}
pub fn tyvar_not_defined_error(
input: Input,
errno: usize,
name: &str,
loc: Location,
caused_by: String,
) -> Self {
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("型変数{found}が定義されていません"),
"simplified_chinese" => format!("类型变量{found}没有定义"),
"traditional_chinese" => format!("類型變量{found}沒有定義"),
"english" => format!("type variable {found} is not defined"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn ambiguous_type_error(
input: Input,
errno: usize,
expr: &(impl Locational + Display),
candidates: &[Type],
caused_by: String,
) -> Self {
let hint = Some(
switch_lang!(
"japanese" => {
let mut s = StyledStrings::default();
s.push_str("多相関数の場合は");
s.push_str_with_color_and_attribute("f|T := Int|", ACCENT, ATTR);
s.push_str(", \n型属性の場合は");
s.push_str_with_color_and_attribute("f|T := Trait|.X", ACCENT, ATTR);
s
},
"simplified_chinese" => {
let mut s = StyledStrings::default();
s.push_str("如果是多态函数，请使用");
s.push_str_with_color_and_attribute("f|T := Int|", ACCENT, ATTR);
s.push_str("，\n如果是类型属性，请使用");
s.push_str_with_color_and_attribute("f|T := Trait|.X", ACCENT, ATTR);
s
},
"traditional_chinese" => {
let mut s = StyledStrings::default();
s.push_str("如果是多型函數，請使用");
s.push_str_with_color_and_attribute("f|T := Int|", ACCENT, ATTR);
s.push_str("，\n如果是類型屬性，請使用");
s.push_str_with_color_and_attribute("f|T := Trait|.X", ACCENT, ATTR);
s
},
"english" => {
let mut s = StyledStrings::default();
s.push_str("if it is a polymorphic function, like ");
s.push_str_with_color_and_attribute("f|T := Int|", ACCENT, ATTR);
s.push_str("\nif it is a type attribute, like ");
s.push_str_with_color_and_attribute("f|T := Trait|.X ", ACCENT, ATTR);
s
},
)
.to_string(),
);
let sub_msg = switch_lang!(
"japanese" => "型を指定してください",
"simplified_chinese" => "方式指定类型",
"traditional_chinese" => "specify the type",
"english" => "specify the type",
);
let mut candidate = StyledStrings::default();
switch_lang!(
"japanese" => candidate.push_str("候補: "),
"simplified_chinese" => candidate.push_str("候选: "),
"traditional_chinese" => candidate.push_str("候選: "),
"english" => candidate.push_str("candidates: "),
);
candidate.push_str_with_color_and_attribute(&fmt_vec(candidates), WARN, ATTR);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
expr.loc(),
vec![sub_msg.to_string(), candidate.to_string()],
hint,
)],
switch_lang!(
"japanese" => format!("{expr}の型を一意に決定できませんでした"),
"simplified_chinese" => format!("无法确定{expr}的类型"),
"traditional_chinese" => format!("無法確定{expr}的類型"),
"english" => format!("cannot determine the type of {expr}"),
),
errno,
TypeError,
expr.loc(),
),
input,
caused_by,
)
}
}
pub type TyCheckErrors = CompileErrors;
pub type SingleTyCheckResult<T> = Result<T, TyCheckError>;
pub type TyCheckResult<T> = Result<T, TyCheckErrors>;
pub type TyCheckWarning = TyCheckError;
pub type TyCheckWarnings = TyCheckErrors;
pub type EvalError = TyCheckError;
pub type EvalErrors = TyCheckErrors;
pub type EvalResult<T> = TyCheckResult<T>;
pub type SingleEvalResult<T> = SingleTyCheckResult<T>;
impl EvalError {
pub fn not_const_expr(input: Input, errno: usize, loc: Location, caused_by: String) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => "定数式ではありません",
"simplified_chinese" => "不是常量表达式",
"traditional_chinese" => "不是常量表達式",
"english" => "not a constant expression",
),
errno,
NotConstExpr,
loc,
),
input,
caused_by,
)
}
pub fn invalid_literal(input: Input, errno: usize, loc: Location, caused_by: String) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => "リテラルが不正です",
"simplified_chinese" => "字面量不合法",
"traditional_chinese" => "字面量不合法",
"english" => "invalid literal",
),
errno,
SyntaxError,
loc,
),
input,
caused_by,
)
}
}
pub type EffectError = TyCheckError;
pub type EffectErrors = TyCheckErrors;
impl EffectError {
pub fn has_effect(input: Input, errno: usize, expr: &Expr, caused_by: String) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(expr.loc())],
switch_lang!(
"japanese" => "この式には副作用があります",
"simplified_chinese" => "此表达式会产生副作用",
"traditional_chinese" => "此表達式會產生副作用",
"english" => "this expression causes a side-effect",
),
errno,
HasEffect,
expr.loc(),
),
input,
caused_by,
)
}
pub fn proc_assign_error(input: Input, errno: usize, loc: Location, caused_by: String) -> Self {
let hint = Some(
switch_lang!(
"japanese" => {
let mut s = StyledStrings::default();
s.push_str("変数の末尾に");
s.push_str_with_color_and_attribute("!", WARN, ATTR);
s.push_str("をつけてください");
s
},
"simplified_chinese" => {
let mut s = StyledStrings::default();
s.push_str("请在变量名后加上");
s.push_str_with_color_and_attribute("!", WARN, ATTR);
s
},
"traditional_chinese" => {
let mut s = StyledStrings::default();
s.push_str("請在變量名後加上");
s.push_str_with_color_and_attribute("!", WARN, ATTR);
s
},
"english" => {
let mut s = StyledStrings::default();
s.push_str("add ");
s.push_str_with_color_and_attribute("!", WARN, ATTR);
s.push_str(" to the end of the variable name");
s
},
)
.to_string(),
);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => "プロシージャを通常の変数に代入することはできません",
"simplified_chinese" => "不能将过程赋值给普通变量",
"traditional_chinese" => "不能將過程賦值給普通變量",
"english" => "cannot assign a procedure to a normal variable",
),
errno,
HasEffect,
loc,
),
input,
caused_by,
)
}
pub fn touch_mut_error(input: Input, errno: usize, expr: &Expr, caused_by: String) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(expr.loc())],
switch_lang!(
"japanese" => "関数中で可変オブジェクトにアクセスすることは出来ません",
"simplified_chinese" => "函数中不能访问可变对象",
"traditional_chinese" => "函數中不能訪問可變對象",
"english" => "cannot access a mutable object in a function",
),
errno,
HasEffect,
expr.loc(),
),
input,
caused_by,
)
}
}
pub type OwnershipError = TyCheckError;
pub type OwnershipErrors = TyCheckErrors;
impl OwnershipError {
pub fn move_error(
input: Input,
errno: usize,
name: &str,
name_loc: Location,
moved_loc: Location,
caused_by: String,
) -> Self {
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(name_loc)],
switch_lang!(
"japanese" => format!(
"{found}は{}行目ですでに移動されています",
moved_loc.ln_begin().unwrap_or(0)
),
"simplified_chinese" => format!(
"{found}已移至第{}行",
moved_loc.ln_begin().unwrap_or(0)
),
"traditional_chinese" => format!(
"{found}已移至第{}行",
moved_loc.ln_begin().unwrap_or(0)
),
"english" => format!(
"{found} was moved in line {}",
moved_loc.ln_begin().unwrap_or(0)
),
),
errno,
MoveError,
name_loc,
),
input,
caused_by,
)
}
}
pub type LowerError = TyCheckError;
pub type LowerWarning = LowerError;
pub type LowerErrors = TyCheckErrors;
pub type LowerWarnings = LowerErrors;
pub type LowerResult<T> = TyCheckResult<T>;
pub type SingleLowerResult<T> = SingleTyCheckResult<T>;
impl LowerError {
pub fn syntax_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
desc: String,
hint: Option<String>,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
desc,
errno,
SyntaxError,
loc,
),
input,
caused_by,
)
}
pub fn unused_expr_warning(input: Input, errno: usize, expr: &Expr, caused_by: String) -> Self {
let desc = switch_lang!(
"japanese" => format!("式の評価結果(: {})が使われていません", expr.ref_t()),
"simplified_chinese" => format!("表达式评估结果(: {})未使用", expr.ref_t()),
"traditional_chinese" => format!("表達式評估結果(: {})未使用", expr.ref_t()),
"english" => format!("the evaluation result of the expression (: {}) is not used", expr.ref_t()),
);
let discard = StyledString::new("discard", Some(HINT), Some(ATTR));
let hint = switch_lang!(
"japanese" => format!("値を使わない場合は、{discard}関数を使用してください"),
"simplified_chinese" => format!("如果您不想使用该值，请使用{discard}函数"),
"traditional_chinese" => format!("如果您不想使用該值，請使用{discard}函數"),
"english" => format!("if you don't use the value, use {discard} function"),
);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(expr.loc(), vec![], Some(hint))],
desc,
errno,
UnusedWarning,
expr.loc(),
),
input,
caused_by,
)
}
pub fn duplicate_decl_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
) -> Self {
let name = readable_name(name);
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}は既に宣言されています"),
"simplified_chinese" => format!("{name}已声明"),
"traditional_chinese" => format!("{name}已聲明"),
"english" => format!("{name} is already declared"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn duplicate_definition_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
) -> Self {
let name = readable_name(name);
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}は既に定義されています"),
"simplified_chinese" => format!("{name}已定义"),
"traditional_chinese" => format!("{name}已定義"),
"english" => format!("{name} is already defined"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn violate_decl_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
spec_t: &Type,
found_t: &Type,
) -> Self {
let name = StyledString::new(readable_name(name), Some(WARN), None);
let expect = StyledString::new(format!("{}", spec_t), Some(HINT), Some(ATTR));
let found = StyledString::new(format!("{}", found_t), Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}は{expect}型として宣言されましたが、{found}型のオブジェクトが代入されています"),
"simplified_chinese" => format!("{name}被声明为{expect}，但分配了一个{found}对象"),
"traditional_chinese" => format!("{name}被聲明為{expect}，但分配了一個{found}對象"),
"english" => format!("{name} was declared as {expect}, but an {found} object is assigned"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn no_var_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
similar_name: Option<&str>,
) -> Self {
let name = readable_name(name);
let hint = similar_name.map(|n| {
let n = StyledStr::new(n, Some(HINT), Some(ATTR));
switch_lang!(
"japanese" => format!("似た名前の変数があります: {n}"),
"simplified_chinese" => format!("存在相同名称变量: {n}"),
"traditional_chinese" => format!("存在相同名稱變量: {n}"),
"english" => format!("exists a similar name variable: {n}"),
)
});
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{found}という変数は定義されていません"),
"simplified_chinese" => format!("{found}未定义"),
"traditional_chinese" => format!("{found}未定義"),
"english" => format!("{found} is not defined"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn access_before_def_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
defined_line: usize,
similar_name: Option<&str>,
) -> Self {
let name = readable_name(name);
let hint = similar_name.map(|n| {
let n = StyledStr::new(n, Some(HINT), Some(ATTR));
switch_lang!(
"japanese" => format!("似た名前の変数があります: {n}"),
"simplified_chinese" => format!("存在相同名称变量: {n}"),
"traditional_chinese" => format!("存在相同名稱變量: {n}"),
"english" => format!("exists a similar name variable: {n}"),
)
});
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("定義({defined_line}行目)より前で{found}を参照することは出来ません"),
"simplified_chinese" => format!("在{found}定义({defined_line}行)之前引用是不允许的"),
"traditional_chinese" => format!("在{found}定義({defined_line}行)之前引用是不允許的"),
"english" => format!("cannot access {found} before its definition (line {defined_line})"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn access_deleted_var_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
del_line: usize,
similar_name: Option<&str>,
) -> Self {
let name = readable_name(name);
let hint = similar_name.map(|n| {
let n = StyledStr::new(n, Some(HINT), Some(ATTR));
switch_lang!(
"japanese" => format!("似た名前の変数があります: {n}"),
"simplified_chinese" => format!("存在相同名称变量: {n}"),
"traditional_chinese" => format!("存在相同名稱變量: {n}"),
"english" => format!("exists a similar name variable: {n}"),
)
});
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("削除された変数{found}を参照することは出来ません({del_line}行目で削除)"),
"simplified_chinese" => format!("不能引用已删除的变量{found}({del_line}行)"),
"traditional_chinese" => format!("不能引用已刪除的變量{found}({del_line}行)"),
"english" => format!("cannot access deleted variable {found} (deleted at line {del_line})"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn no_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
similar_name: Option<&str>,
) -> Self {
let name = readable_name(name);
let hint = similar_name.map(|n| {
let n = StyledStr::new(n, Some(HINT), Some(ATTR));
switch_lang!(
"japanese" => format!("似た名前の型があります: {n}"),
"simplified_chinese" => format!("存在相同名称类型: {n}"),
"traditional_chinese" => format!("存在相同名稱類型: {n}"),
"english" => format!("exists a similar name type: {n}"),
)
});
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{found}という型は定義されていません"),
"simplified_chinese" => format!("{found}未定义"),
"traditional_chinese" => format!("{found}未定義"),
"english" => format!("Type {found} is not defined"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn type_not_found(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
typ: &Type,
) -> Self {
let typ = StyledString::new(typ.to_string(), Some(ERR), Some(ATTR));
let hint = Some(switch_lang!(
"japanese" => format!("恐らくこれはErgコンパイラのバグです、{URL}へ報告してください"),
"simplified_chinese" => format!("这可能是Erg编译器的错误，请报告给{URL}"),
"traditional_chinese" => format!("這可能是Erg編譯器的錯誤，請報告給{URL}"),
"english" => format!("This may be a bug of Erg compiler, please report to {URL}"),
));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{typ}という型は定義されていません"),
"simplified_chinese" => format!("{typ}未定义"),
"traditional_chinese" => format!("{typ}未定義"),
"english" => format!("Type {typ} is not defined"),
),
errno,
NameError,
loc,
),
input,
caused_by,
)
}
pub fn no_attr_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
obj_t: &Type,
name: &str,
similar_name: Option<&str>,
) -> Self {
let hint = similar_name.map(|n| {
switch_lang!(
"japanese" => format!("似た名前の属性があります: {n}"),
"simplified_chinese" => format!("具有相同名称的属性: {n}"),
"traditional_chinese" => format!("具有相同名稱的屬性: {n}"),
"english" => format!("has a similar name attribute: {n}"),
)
});
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{obj_t}型オブジェクトに{found}という属性はありません"),
"simplified_chinese" => format!("{obj_t}对象没有属性{found}"),
"traditional_chinese" => format!("{obj_t}對像沒有屬性{found}"),
"english" => format!("{obj_t} object has no attribute {found}"),
),
errno,
AttributeError,
loc,
),
input,
caused_by,
)
}
#[allow(clippy::too_many_arguments)]
pub fn singular_no_attr_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
obj_name: &str,
obj_t: &Type,
name: &str,
similar_name: Option<&str>,
) -> Self {
let hint = similar_name.map(|n| {
let n = StyledStr::new(n, Some(HINT), Some(ATTR));
switch_lang!(
"japanese" => format!("似た名前の属性があります: {n}"),
"simplified_chinese" => format!("具有相同名称的属性: {n}"),
"traditional_chinese" => format!("具有相同名稱的屬性: {n}"),
"english" => format!("has a similar name attribute: {n}"),
)
});
let found = StyledString::new(name, Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{obj_name}(: {obj_t})に{found}という属性はありません"),
"simplified_chinese" => format!("{obj_name}(: {obj_t})没有属性{found}"),
"traditional_chinese" => format!("{obj_name}(: {obj_t})沒有屬性{found}"),
"english" => format!("{obj_name}(: {obj_t}) has no attribute {found}"),
),
errno,
AttributeError,
loc,
),
input,
caused_by,
)
}
pub fn reassign_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
) -> Self {
let name = StyledStr::new(readable_name(name), Some(WARN), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("変数{name}に複数回代入することはできません"),
"simplified_chinese" => format!("不能为变量{name}分配多次"),
"traditional_chinese" => format!("不能為變量{name}分配多次"),
"english" => format!("variable {name} cannot be assigned more than once"),
),
errno,
AssignError,
loc,
),
input,
caused_by,
)
}
pub fn unused_warning(
input: Input,
errno: usize,
loc: Location,
name: &str,
caused_by: String,
) -> Self {
let name = StyledString::new(readable_name(name), Some(WARN), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{name}は使用されていません"),
"simplified_chinese" => format!("{name}未使用"),
"traditional_chinese" => format!("{name}未使用"),
"english" => format!("{name} is not used"),
),
errno,
UnusedWarning,
loc,
),
input,
caused_by,
)
}
pub fn union_return_type_warning(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
fn_name: &str,
typ: &Type,
) -> Self {
let hint = switch_lang!(
"japanese" => format!("`{fn_name}(...): {typ} = ...`など明示的に戻り値型を指定してください"),
"simplified_chinese" => format!("请明确指定函数{fn_name}的返回类型，例如`{fn_name}(...): {typ} = ...`"),
"traditional_chinese" => format!("請明確指定函數{fn_name}的返回類型，例如`{fn_name}(...): {typ} = ...`"),
"english" => format!("please explicitly specify the return type of function {fn_name}, for example `{fn_name}(...): {typ} = ...`"),
);
LowerError::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], Some(hint))],
switch_lang!(
"japanese" => format!("関数{fn_name}の戻り値型が単一ではありません"),
"simplified_chinese" => format!("函数{fn_name}的返回类型不是单一的"),
"traditional_chinese" => format!("函數{fn_name}的返回類型不是單一的"),
"english" => format!("the return type of function {fn_name} is not single"),
),
errno,
TypeWarning,
loc,
),
input,
caused_by,
)
}
pub fn del_error(input: Input, errno: usize, ident: &Identifier, caused_by: String) -> Self {
let name = StyledString::new(readable_name(ident.inspect()), Some(WARN), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(ident.loc())],
switch_lang!(
"japanese" => format!("{name}は削除できません"),
"simplified_chinese" => format!("{name}不能删除"),
"traditional_chinese" => format!("{name}不能刪除"),
"english" => format!("{name} cannot be deleted"),
),
errno,
NameError,
ident.loc(),
),
input,
caused_by,
)
}
pub fn visibility_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
vis: Visibility,
) -> Self {
let visibility = if vis.is_private() {
switch_lang!(
"japanese" => "非公開",
"simplified_chinese" => "私有",
"traditional_chinese" => "私有",
"english" => "private",
)
} else {
switch_lang!(
"japanese" => "公開",
"simplified_chinese" => "公有",
"traditional_chinese" => "公有",
"english" => "public",
)
};
let found = StyledString::new(readable_name(name), Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{found}は{visibility}変数です"),
"simplified_chinese" => format!("{found}是{visibility}变量",),
"traditional_chinese" => format!("{found}是{visibility}變量",),
"english" => format!("{found} is {visibility} variable",),
),
errno,
VisibilityError,
loc,
),
input,
caused_by,
)
}
pub fn override_error<S: Into<String>>(
input: Input,
errno: usize,
name: &str,
name_loc: Location,
superclass: &Type,
caused_by: S,
) -> Self {
let name = StyledString::new(name, Some(ERR), Some(ATTR));
let superclass = StyledString::new(format!("{}", superclass), Some(WARN), Some(ATTR));
let hint = Some(
switch_lang!(
"japanese" => {
let mut ovr = StyledStrings::default();
ovr.push_str_with_color_and_attribute("@Override", HINT, ATTR);
ovr.push_str("デコレータを使用してください");
ovr
},
"simplified_chinese" => {
let mut ovr = StyledStrings::default();
ovr.push_str("请使用");
ovr.push_str_with_color_and_attribute("@Override", HINT, ATTR);
ovr.push_str("装饰器");
ovr
},
"traditional_chinese" => {
let mut ovr = StyledStrings::default();
ovr.push_str("請使用");
ovr.push_str_with_color_and_attribute("@Override", HINT, ATTR);
ovr.push_str("裝飾器");
ovr
},
"english" => {
let mut ovr = StyledStrings::default();
ovr.push_str("use ");
ovr.push_str_with_color_and_attribute("@Override", HINT, ATTR);
ovr.push_str(" decorator");
ovr
},
)
.to_string(),
);
let sub_msg = switch_lang!(
"japanese" => "デフォルトでオーバーライドはできません",
"simplified_chinese" => "默认不可重写",
"simplified_chinese" => "默認不可重寫",
"english" => "cannot override by default",
);
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(
name_loc,
vec![sub_msg.to_string()],
hint,
)],
switch_lang!(
"japanese" => format!(
"{name}は{superclass}で既に定義されています",
),
"simplified_chinese" => format!(
"{name}已在{superclass}中定义",
),
"traditional_chinese" => format!(
"{name}已在{superclass}中定義",
),
"english" => format!(
"{name} is already defined in {superclass}",
),
),
errno,
NameError,
name_loc,
),
input,
caused_by.into(),
)
}
pub fn inheritance_error(
input: Input,
errno: usize,
class: String,
loc: Location,
caused_by: String,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("{class}は継承できません"),
"simplified_chinese" => format!("{class}不可继承"),
"traditional_chinese" => format!("{class}不可繼承"),
"english" => format!("{class} is not inheritable"),
),
errno,
InheritanceError,
loc,
),
input,
caused_by,
)
}
pub fn file_error(
input: Input,
errno: usize,
desc: String,
loc: Location,
caused_by: String,
hint: Option<String>,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
desc,
errno,
IoError,
loc,
),
input,
caused_by,
)
}
pub fn module_env_error(
input: Input,
errno: usize,
mod_name: &str,
loc: Location,
caused_by: String,
) -> Self {
let desc = switch_lang!(
"japanese" => format!("{mod_name}モジュールはお使いの環境をサポートしていません"),
"simplified_chinese" => format!("{mod_name}模块不支持您的环境"),
"traditional_chinese" => format!("{mod_name}模塊不支持您的環境"),
"english" => format!("module {mod_name} is not supported in your environment"),
);
Self::file_error(input, errno, desc, loc, caused_by, None)
}
pub fn import_error(
input: Input,
errno: usize,
desc: String,
loc: Location,
caused_by: String,
similar_erg_mod: Option<Str>,
similar_py_mod: Option<Str>,
) -> Self {
let mut erg_str = StyledStrings::default();
let mut py_str = StyledStrings::default();
let hint = switch_lang!(
"japanese" => {
match (similar_erg_mod, similar_py_mod) {
(Some(erg), Some(py)) => {
erg_str.push_str("似た名前のergモジュールが存在します: ");
erg_str.push_str_with_color_and_attribute(erg, HINT, ATTR);
py_str.push_str("似た名前のpythonモジュールが存在します: ");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("pythonのモジュールをインポートするためには");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
hint.push_str("を使用してください");
Some(hint.to_string())
}
(Some(erg), None) => {
erg_str.push_str("似た名前のergモジュールが存在します");
erg_str.push_str_with_color_and_attribute(erg, ACCENT, ATTR);
None
}
(None, Some(py)) => {
py_str.push_str("似た名前のpythonモジュールが存在します");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("pythonのモジュールをインポートするためには");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
hint.push_str("を使用してください");
Some(hint.to_string())
}
(None, None) => None,
}
},
"simplified_chinese" => {
match (similar_erg_mod, similar_py_mod) {
(Some(erg), Some(py)) => {
erg_str.push_str("存在相似名称的erg模块: ");
erg_str.push_str_with_color_and_attribute(erg, HINT, ATTR);
py_str.push_str("存在相似名称的python模块: ");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("要导入python模块,请使用");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
Some(hint.to_string())
}
(Some(erg), None) => {
erg_str.push_str("存在相似名称的erg模块: ");
erg_str.push_str_with_color_and_attribute(erg, HINT, ATTR);
None
}
(None, Some(py)) => {
py_str.push_str("存在相似名称的python模块: ");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("要导入python模块,请使用");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
Some(hint.to_string())
}
(None, None) => None,
}
},
"traditional_chinese" => {
match (similar_erg_mod, similar_py_mod) {
(Some(erg), Some(py)) => {
erg_str.push_str("存在類似名稱的erg模塊: ");
erg_str.push_str_with_color_and_attribute(erg, HINT, ATTR);
py_str.push_str("存在類似名稱的python模塊: ");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("要導入python模塊, 請使用");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
Some(hint.to_string())
}
(Some(erg), None) => {
erg_str.push_str("存在類似名稱的erg模塊: ");
erg_str.push_str_with_color_and_attribute(erg, HINT, ATTR);
None
}
(None, Some(py)) => {
py_str.push_str("存在類似名稱的python模塊: ");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("要導入python模塊, 請使用");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
Some(hint.to_string())
}
(None, None) => None,
}
},
"english" => {
match (similar_erg_mod, similar_py_mod) {
(Some(erg), Some(py)) => {
erg_str.push_str("similar name erg module exists: ");
erg_str.push_str_with_color_and_attribute(erg, HINT, ATTR);
py_str.push_str("similar name python module exists: ");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("to import python modules, use ");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
Some(hint.to_string())
}
(Some(erg), None) => {
erg_str.push_str("similar name erg module exists: ");
erg_str.push_str_with_color_and_attribute(erg, HINT, ATTR);
None
}
(None, Some(py)) => {
py_str.push_str("similar name python module exits: ");
py_str.push_str_with_color_and_attribute(py, HINT, ATTR);
let mut hint = StyledStrings::default();
hint.push_str("to import python modules, use ");
hint.push_str_with_color_and_attribute("pyimport", ACCENT, ATTR);
Some(hint.to_string())
}
(None, None) => None,
}
},
);
// .to_string().is_empty() is not necessarily empty because there are Color or Attribute that are not displayed
let msg = match (erg_str.is_empty(), py_str.is_empty()) {
(false, false) => vec![erg_str.to_string(), py_str.to_string()],
(false, true) => vec![erg_str.to_string()],
(true, false) => vec![py_str.to_string()],
(true, true) => vec![],
};
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, msg, hint)],
desc,
errno,
ImportError,
loc,
),
input,
caused_by,
)
}
pub fn inner_typedef_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("型はトップレベルで定義されなければなりません"),
"simplified_chinese" => format!("类型必须在顶层定义"),
"traditional_chinese" => format!("類型必須在頂層定義"),
"english" => format!("types must be defined at the top level"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}
pub fn declare_error(input: Input, errno: usize, loc: Location, caused_by: String) -> Self {
Self::new(
ErrorCore::new(
vec![SubMessage::only_loc(loc)],
switch_lang!(
"japanese" => format!("d.erファイル内では宣言、別名定義のみが許可されています"),
"simplified_chinese" => format!("在d.er文件中只允许声明和别名定义"),
"traditional_chinese" => format!("在d.er文件中只允許聲明和別名定義"),
"english" => format!("declarations and alias definitions are only allowed in d.er files"),
),
errno,
SyntaxError,
loc,
),
input,
caused_by,
)
}
#[allow(clippy::too_many_arguments)]
pub fn invalid_type_cast_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
cast_to: &Type,
hint: Option<String>,
) -> Self {
let name = StyledString::new(name, Some(WARN), Some(ATTR));
let found = StyledString::new(format!("{}", cast_to), Some(ERR), Some(ATTR));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],
switch_lang!(
"japanese" => format!("{name}の型を{found}にキャストすることはできません"),
"simplified_chinese" => format!("{name}的类型无法转换为{found}"),
"traditional_chinese" => format!("{name}的類型無法轉換為{found}"),
"english" => format!("the type of {name} cannot be cast to {found}"),
),
errno,
TypeError,
loc,
),
input,
caused_by,
)
}lower.rs (line 798)
792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
pub(crate) fn lower_call(&mut self, call: ast::Call) -> LowerResult<hir::Call> {
log!(info "entered {}({}{}(...))", fn_name!(), call.obj, fmt_option!(call.attr_name));
let mut errs = LowerErrors::empty();
let opt_cast_to = if call.is_assert_cast() {
if let Some(typ) = call.assert_cast_target_type() {
Some(Parser::expr_to_type_spec(typ.clone()).map_err(|e| {
let e = LowerError::new(e.into(), self.input().clone(), self.ctx.caused_by());
LowerErrors::from(e)
})?)
} else {
return Err(LowerErrors::from(LowerError::syntax_error(
self.input().clone(),
line!() as usize,
call.args.loc(),
self.ctx.caused_by(),
"invalid assert casting type".to_owned(),
None,
)));
}
} else {
None
};
let (pos_args, kw_args, paren) = call.args.deconstruct();
let mut hir_args = hir::Args::new(
Vec::with_capacity(pos_args.len()),
None,
Vec::with_capacity(kw_args.len()),
paren,
);
for arg in pos_args.into_iter() {
match self.lower_expr(arg.expr) {
Ok(expr) => hir_args.pos_args.push(hir::PosArg::new(expr)),
Err(es) => errs.extend(es),
}
}
for arg in kw_args.into_iter() {
match self.lower_expr(arg.expr) {
Ok(expr) => hir_args.push_kw(hir::KwArg::new(arg.keyword, expr)),
Err(es) => errs.extend(es),
}
}
let mut obj = match self.lower_expr(*call.obj) {
Ok(obj) => obj,
Err(es) => {
errs.extend(es);
return Err(errs);
}
};
// Calling get_call_t with incorrect arguments does not provide meaningful information
if !errs.is_empty() {
return Err(errs);
}
let vi = match self.ctx.get_call_t(
&obj,
&call.attr_name,
&hir_args.pos_args,
&hir_args.kw_args,
&self.cfg.input,
&self.ctx.name,
) {
Ok(vi) => vi,
Err(es) => {
errs.extend(es);
return Err(errs);
}
};
let attr_name = if let Some(attr_name) = call.attr_name {
Some(hir::Identifier::new(
attr_name.dot,
attr_name.name,
None,
vi,
))
} else {
*obj.ref_mut_t() = vi.t;
None
};
let mut call = hir::Call::new(obj, attr_name, hir_args);
match call.additional_operation() {
Some(kind @ (OperationKind::Import | OperationKind::PyImport)) => {
let mod_name =
enum_unwrap!(call.args.get_left_or_key("Path").unwrap(), hir::Expr::Lit);
if let Err(errs) = self.ctx.import_mod(kind, mod_name) {
self.errs.extend(errs);
};
}
Some(OperationKind::Del) => match call.args.get_left_or_key("obj").unwrap() {
hir::Expr::Accessor(hir::Accessor::Ident(ident)) => {
self.ctx.del(ident)?;
}
other => {
return Err(LowerErrors::from(LowerError::syntax_error(
self.input().clone(),
line!() as usize,
other.loc(),
self.ctx.caused_by(),
"".to_owned(),
None,
)))
}
},
Some(OperationKind::Return | OperationKind::Yield) => {
// (f: ?T -> ?U).return: (self: GenericCallable, arg: Obj) -> Never
let callable_t = call.obj.ref_t();
let ret_t = match callable_t {
Type::Subr(subr) => *subr.return_t.clone(),
Type::FreeVar(fv) if fv.is_unbound() => {
fv.get_sub().unwrap().return_t().unwrap().clone()
}
other => todo!("{other:?}"),
};
let arg_t = call.args.get(0).unwrap().ref_t();
self.ctx.sub_unify(arg_t, &ret_t, call.loc(), None)?;
}
_ => {
if let Some(type_spec) = opt_cast_to {
self.ctx.cast(type_spec, &mut call)?;
}
}
}
if errs.is_empty() {
Ok(call)
} else {
Err(errs)
}
}sourcepub fn compiler_bug(
errno: usize,
input: Input,
loc: Location,
fn_name: &str,
line: u32
) -> Self
pub fn compiler_bug(
errno: usize,
input: Input,
loc: Location,
fn_name: &str,
line: u32
) -> Self
Examples found in repository?
codegen.rs (lines 2523-2529)
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635
fn emit_expr(&mut self, expr: Expr) {
log!(info "entered {} ({expr})", fn_name!());
if expr.ln_begin().unwrap_or_else(|| panic!("{expr}")) > self.cur_block().prev_lineno {
let sd = self.lasti() - self.cur_block().prev_lasti;
let ld = expr.ln_begin().unwrap() - self.cur_block().prev_lineno;
if ld != 0 {
if sd != 0 {
self.mut_cur_block_codeobj().lnotab.push(sd as u8);
self.mut_cur_block_codeobj().lnotab.push(ld as u8);
} else {
// empty lines
if let Some(last_ld) = self.mut_cur_block_codeobj().lnotab.last_mut() {
*last_ld += ld as u8;
} else {
// a block starts with an empty line
self.mut_cur_block_codeobj().lnotab.push(0);
self.mut_cur_block_codeobj().lnotab.push(ld as u8);
}
}
self.mut_cur_block().prev_lineno += ld;
self.mut_cur_block().prev_lasti = self.lasti();
} else {
CompileError::compiler_bug(
0,
self.cfg.input.clone(),
expr.loc(),
fn_name_full!(),
line!(),
)
.write_to_stderr();
self.crash("codegen failed: invalid bytecode format");
}
}
match expr {
Expr::Lit(lit) => self.emit_load_const(lit.value),
Expr::Accessor(acc) => self.emit_acc(acc),
Expr::Def(def) => self.emit_def(def),
Expr::ClassDef(class) => self.emit_class_def(class),
Expr::PatchDef(patch) => self.emit_patch_def(patch),
Expr::AttrDef(attr) => self.emit_attr_def(attr),
Expr::Lambda(lambda) => self.emit_lambda(lambda),
Expr::UnaryOp(unary) => self.emit_unaryop(unary),
Expr::BinOp(bin) => self.emit_binop(bin),
Expr::Call(call) => self.emit_call(call),
Expr::Array(arr) => self.emit_array(arr),
// TODO: tuple comprehension
// TODO: tuples can be const
Expr::Tuple(tup) => match tup {
Tuple::Normal(mut tup) => {
let len = tup.elems.len();
while let Some(arg) = tup.elems.try_remove_pos(0) {
self.emit_expr(arg.expr);
}
self.write_instr(BUILD_TUPLE);
self.write_arg(len);
if len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(len - 1);
}
}
},
Expr::Set(set) => match set {
crate::hir::Set::Normal(mut set) => {
let len = set.elems.len();
while let Some(arg) = set.elems.try_remove_pos(0) {
self.emit_expr(arg.expr);
}
self.write_instr(BUILD_SET);
self.write_arg(len);
if len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(len - 1);
}
}
crate::hir::Set::WithLength(st) => {
self.emit_expr(*st.elem);
self.write_instr(BUILD_SET);
self.write_arg(1);
}
},
Expr::Dict(dict) => match dict {
crate::hir::Dict::Normal(dic) => {
let len = dic.kvs.len();
for kv in dic.kvs.into_iter() {
self.emit_expr(kv.key);
self.emit_expr(kv.value);
}
self.write_instr(BUILD_MAP);
self.write_arg(len);
if len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(2 * len - 1);
}
}
other => todo!("{other}"),
},
Expr::Record(rec) => self.emit_record(rec),
Expr::Code(code) => {
let code = self.emit_block(code, None, vec![]);
self.emit_load_const(code);
}
Expr::Compound(chunks) => {
let is_module_loading_chunks = chunks
.get(2)
.map(|chunk| {
option_enum_unwrap!(chunk, Expr::Call)
.map(|call| {
call.obj.show_acc().as_ref().map(|s| &s[..]) == Some("exec")
})
.unwrap_or(false)
})
.unwrap_or(false);
if !self.module_type_loaded && is_module_loading_chunks {
self.load_module_type();
self.module_type_loaded = true;
}
let init_stack_len = self.stack_len();
for expr in chunks.into_iter() {
self.emit_expr(expr);
if self.stack_len() == init_stack_len + 1 {
self.emit_pop_top();
}
}
self.cancel_if_pop_top();
}
Expr::TypeAsc(tasc) => {
self.emit_expr(*tasc.expr);
}
Expr::Import(acc) => self.emit_import(acc),
Expr::Dummy(_) => {}
}
}sourcepub fn stack_bug(
input: Input,
loc: Location,
stack_len: u32,
block_id: usize,
fn_name: &str
) -> Self
pub fn stack_bug(
input: Input,
loc: Location,
stack_len: u32,
block_id: usize,
fn_name: &str
) -> Self
Examples found in repository?
codegen.rs (lines 1064-1070)
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093
fn emit_trait_block(&mut self, kind: DefKind, sig: &Signature, mut block: Block) -> CodeObj {
let name = sig.ident().inspect().clone();
let mut trait_call = enum_unwrap!(block.remove(0), Expr::Call);
let req = if kind == DefKind::Trait {
enum_unwrap!(
trait_call.args.remove_left_or_key("Requirement").unwrap(),
Expr::Record
)
} else {
todo!()
};
self.unit_size += 1;
let firstlineno = block
.get(0)
.and_then(|def| def.ln_begin())
.unwrap_or_else(|| sig.ln_begin().unwrap());
self.units.push(PyCodeGenUnit::new(
self.unit_size,
self.py_version,
vec![],
Str::rc(self.cfg.input.enclosed_name()),
&name,
firstlineno,
));
let mod_name = self.toplevel_block_codeobj().name.clone();
self.emit_load_const(mod_name);
self.emit_store_instr(Identifier::public("__module__"), Name);
self.emit_load_const(name);
self.emit_store_instr(Identifier::public("__qualname__"), Name);
for def in req.attrs.into_iter() {
self.emit_empty_func(
Some(sig.ident().inspect()),
def.sig.into_ident(),
Some(Identifier::private("#abstractmethod")),
);
}
self.emit_load_const(ValueObj::None);
self.write_instr(RETURN_VALUE);
self.write_arg(0);
if self.stack_len() > 1 {
let block_id = self.cur_block().id;
let stack_len = self.stack_len();
CompileError::stack_bug(
self.input().clone(),
Location::Unknown,
stack_len,
block_id,
fn_name_full!(),
)
.write_to_stderr();
self.crash("error in emit_trait_block: invalid stack size");
}
// flagging
if !self.cur_block_codeobj().varnames.is_empty() {
self.mut_cur_block_codeobj().flags += CodeObjFlags::NewLocals as u32;
}
// end of flagging
let unit = self.units.pop().unwrap();
if !self.units.is_empty() {
let ld = unit.prev_lineno - self.cur_block().prev_lineno;
if ld != 0 {
if let Some(l) = self.mut_cur_block_codeobj().lnotab.last_mut() {
*l += ld as u8;
}
self.mut_cur_block().prev_lineno += ld;
}
}
unit.codeobj
}
fn emit_empty_func(
&mut self,
class_name: Option<&str>,
ident: Identifier,
deco: Option<Identifier>,
) {
log!(info "entered {} ({ident})", fn_name!());
self.emit_push_null();
let deco_is_some = deco.is_some();
if let Some(deco) = deco {
self.emit_load_name_instr(deco);
}
let code = {
self.unit_size += 1;
self.units.push(PyCodeGenUnit::new(
self.unit_size,
self.py_version,
vec![],
Str::rc(self.cfg.input.enclosed_name()),
ident.inspect(),
ident.ln_begin().unwrap(),
));
self.emit_load_const(ValueObj::None);
self.write_instr(RETURN_VALUE);
self.write_arg(0);
let unit = self.units.pop().unwrap();
if !self.units.is_empty() {
let ld = unit
.prev_lineno
.saturating_sub(self.cur_block().prev_lineno);
if ld != 0 {
if let Some(l) = self.mut_cur_block_codeobj().lnotab.last_mut() {
*l += ld as u8;
}
self.mut_cur_block().prev_lineno += ld;
}
}
unit.codeobj
};
self.emit_load_const(code);
if self.py_version.minor < Some(11) {
if let Some(class) = class_name {
self.emit_load_const(Str::from(format!("{class}.{}", ident.name.inspect())));
} else {
self.emit_load_const(ident.name.inspect().clone());
}
} else {
self.stack_inc();
}
self.write_instr(MAKE_FUNCTION);
self.write_arg(0);
if deco_is_some {
self.emit_call_instr(1, Name);
self.stack_dec();
}
// stack_dec: (<abstractmethod>) + <code obj> + <name> -> <function>
self.stack_dec();
self.emit_store_instr(ident, Name);
}
fn emit_class_def(&mut self, class_def: ClassDef) {
log!(info "entered {} ({})", fn_name!(), class_def.sig);
self.emit_push_null();
let ident = class_def.sig.ident().clone();
let require_or_sup = class_def.require_or_sup.clone();
let obj = class_def.obj.clone();
self.write_instr(LOAD_BUILD_CLASS);
self.write_arg(0);
self.stack_inc();
let code = self.emit_class_block(class_def);
self.emit_load_const(code);
if self.py_version.minor < Some(11) {
self.emit_load_const(ident.inspect().clone());
} else {
self.stack_inc();
}
self.write_instr(MAKE_FUNCTION);
self.write_arg(0);
self.emit_load_const(ident.inspect().clone());
// LOAD subclasses
let subclasses_len = self.emit_require_type(obj, *require_or_sup);
self.emit_call_instr(2 + subclasses_len, Name);
self.stack_dec_n((1 + 2 + subclasses_len) - 1);
self.emit_store_instr(ident, Name);
self.stack_dec();
}
fn emit_patch_def(&mut self, patch_def: PatchDef) {
log!(info "entered {} ({})", fn_name!(), patch_def.sig);
for def in patch_def.methods {
// Invert.
// invert self = ...
// ↓
// def Invert::invert(self): ...
let Expr::Def(mut def) = def else { todo!() };
let namespace = self.cur_block_codeobj().name.trim_start_matches("::");
let name = format!(
"{}{}{}",
namespace,
patch_def.sig.ident().to_string_without_type(),
def.sig.ident().to_string_without_type()
);
def.sig.ident_mut().name = VarName::from_str(Str::from(name));
def.sig.ident_mut().dot = None;
self.emit_def(def);
}
}
// NOTE: use `TypeVar`, `Generic` in `typing` module
// fn emit_poly_type_def(&mut self, sig: SubrSignature, body: DefBody) {}
/// Y = Inherit X => class Y(X): ...
fn emit_require_type(&mut self, obj: GenTypeObj, require_or_sup: Expr) -> usize {
log!(info "entered {} ({obj}, {require_or_sup})", fn_name!());
match obj {
GenTypeObj::Class(_) => 0,
GenTypeObj::Subclass(_) => {
self.emit_expr(require_or_sup);
1 // TODO: not always 1
}
_ => todo!(),
}
}
fn emit_attr_def(&mut self, attr_def: AttrDef) {
log!(info "entered {} ({attr_def})", fn_name!());
self.emit_frameless_block(attr_def.block, vec![]);
self.store_acc(attr_def.attr);
}
fn emit_var_def(&mut self, sig: VarSignature, mut body: DefBody) {
log!(info "entered {} ({sig} = {})", fn_name!(), body.block);
if body.block.len() == 1 {
self.emit_expr(body.block.remove(0));
} else {
self.emit_frameless_block(body.block, vec![]);
}
self.emit_store_instr(sig.ident, Name);
}
fn emit_subr_def(&mut self, class_name: Option<&str>, sig: SubrSignature, body: DefBody) {
log!(info "entered {} ({sig} = {})", fn_name!(), body.block);
let name = sig.ident.inspect().clone();
let mut make_function_flag = 0;
let params = self.gen_param_names(&sig.params);
if !sig.params.defaults.is_empty() {
let defaults_len = sig.params.defaults.len();
sig.params
.defaults
.into_iter()
.for_each(|default| self.emit_expr(default.default_val));
self.write_instr(BUILD_TUPLE);
self.write_arg(defaults_len);
self.stack_dec_n(defaults_len - 1);
make_function_flag += MakeFunctionFlags::Defaults as usize;
}
let code = self.emit_block(body.block, Some(name.clone()), params);
// code.flags += CodeObjFlags::Optimized as u32;
self.register_cellvars(&mut make_function_flag);
self.emit_load_const(code);
if self.py_version.minor < Some(11) {
if let Some(class) = class_name {
self.emit_load_const(Str::from(format!("{class}.{name}")));
} else {
self.emit_load_const(name);
}
} else {
self.stack_inc();
}
self.write_instr(MAKE_FUNCTION);
self.write_arg(make_function_flag);
// stack_dec: <code obj> + <name> -> <function>
self.stack_dec();
if make_function_flag & MakeFunctionFlags::Defaults as usize != 0 {
self.stack_dec();
}
self.emit_store_instr(sig.ident, Name);
}
fn emit_lambda(&mut self, lambda: Lambda) {
log!(info "entered {} ({lambda})", fn_name!());
let mut make_function_flag = 0;
let params = self.gen_param_names(&lambda.params);
if !lambda.params.defaults.is_empty() {
let defaults_len = lambda.params.defaults.len();
lambda
.params
.defaults
.into_iter()
.for_each(|default| self.emit_expr(default.default_val));
self.write_instr(BUILD_TUPLE);
self.write_arg(defaults_len);
self.stack_dec_n(defaults_len - 1);
make_function_flag += MakeFunctionFlags::Defaults as usize;
}
let code = self.emit_block(lambda.body, Some("<lambda>".into()), params);
self.register_cellvars(&mut make_function_flag);
self.emit_load_const(code);
if self.py_version.minor < Some(11) {
self.emit_load_const("<lambda>");
} else {
self.stack_inc();
}
self.write_instr(MAKE_FUNCTION);
self.write_arg(make_function_flag);
// stack_dec: <lambda code obj> + <name "<lambda>"> -> <function>
self.stack_dec();
if make_function_flag & MakeFunctionFlags::Defaults as usize != 0 {
self.stack_dec();
}
}
fn register_cellvars(&mut self, flag: &mut usize) {
if !self.cur_block_codeobj().cellvars.is_empty() {
let cellvars_len = self.cur_block_codeobj().cellvars.len();
for i in 0..cellvars_len {
if self.py_version.minor >= Some(11) {
self.write_instr(Opcode311::MAKE_CELL);
self.write_arg(i);
self.write_instr(Opcode311::LOAD_CLOSURE);
} else {
self.write_instr(Opcode310::LOAD_CLOSURE);
}
self.write_arg(i);
}
self.write_instr(BUILD_TUPLE);
self.write_arg(cellvars_len);
*flag += MakeFunctionFlags::Closure as usize;
}
}
fn emit_unaryop(&mut self, unary: UnaryOp) {
log!(info "entered {} ({unary})", fn_name!());
let tycode = TypeCode::from(unary.lhs_t());
let instr = match &unary.op.kind {
// TODO:
TokenKind::PrePlus => UNARY_POSITIVE,
TokenKind::PreMinus => UNARY_NEGATIVE,
TokenKind::Mutate => {
if !self.mutate_op_loaded {
self.load_mutate_op();
}
if self.py_version.minor >= Some(11) {
self.emit_push_null();
}
self.emit_load_name_instr(Identifier::private("#mutate_operator"));
NOP // ERG_MUTATE,
}
_ => {
CompileError::feature_error(
self.cfg.input.clone(),
unary.op.loc(),
&unary.op.inspect().clone(),
String::from(unary.op.content),
)
.write_to_stderr();
NOT_IMPLEMENTED
}
};
self.emit_expr(*unary.expr);
if instr != NOP {
self.write_instr(instr);
self.write_arg(tycode as usize);
} else {
if self.py_version.minor >= Some(11) {
self.emit_precall_and_call(1);
} else {
self.write_instr(Opcode310::CALL_FUNCTION);
self.write_arg(1);
}
self.stack_dec();
}
}
fn emit_binop(&mut self, bin: BinOp) {
log!(info "entered {} ({bin})", fn_name!());
// TODO: and/orのプリミティブ命令の実装
// Range operators are not operators in Python
match &bin.op.kind {
// l..<r == range(l, r)
TokenKind::RightOpen => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("RightOpenRange"));
}
TokenKind::LeftOpen => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("LeftOpenRange"));
}
TokenKind::Closed => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("ClosedRange"));
}
TokenKind::Open => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("OpenRange"));
}
TokenKind::InOp => {
// if no-std, always `x in y == True`
if self.cfg.no_std {
self.emit_load_const(true);
return;
}
if !self.in_op_loaded {
self.load_in_op();
}
self.emit_push_null();
self.emit_load_name_instr(Identifier::private("#in_operator"));
}
_ => {}
}
let type_pair = TypePair::new(bin.lhs_t(), bin.rhs_t());
self.emit_expr(*bin.lhs);
self.emit_expr(*bin.rhs);
if self.py_version.minor >= Some(11) {
self.emit_binop_instr_311(bin.op, type_pair);
} else {
self.emit_binop_instr_310(bin.op, type_pair);
}
}
fn emit_binop_instr_310(&mut self, binop: Token, type_pair: TypePair) {
let instr = match &binop.kind {
TokenKind::Plus => Opcode310::BINARY_ADD,
TokenKind::Minus => Opcode310::BINARY_SUBTRACT,
TokenKind::Star => Opcode310::BINARY_MULTIPLY,
TokenKind::Slash => Opcode310::BINARY_TRUE_DIVIDE,
TokenKind::FloorDiv => Opcode310::BINARY_FLOOR_DIVIDE,
TokenKind::Pow => Opcode310::BINARY_POWER,
TokenKind::Mod => Opcode310::BINARY_MODULO,
TokenKind::AndOp => Opcode310::BINARY_AND,
TokenKind::OrOp => Opcode310::BINARY_OR,
TokenKind::Less
| TokenKind::LessEq
| TokenKind::DblEq
| TokenKind::NotEq
| TokenKind::Gre
| TokenKind::GreEq => Opcode310::COMPARE_OP,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => Opcode310::CALL_FUNCTION, // ERG_BINARY_RANGE,
_ => {
CompileError::feature_error(
self.cfg.input.clone(),
binop.loc(),
&binop.inspect().clone(),
String::from(binop.content),
)
.write_to_stderr();
Opcode310::NOT_IMPLEMENTED
}
};
let arg = match &binop.kind {
TokenKind::Less => 0,
TokenKind::LessEq => 1,
TokenKind::DblEq => 2,
TokenKind::NotEq => 3,
TokenKind::Gre => 4,
TokenKind::GreEq => 5,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => 2,
_ => type_pair as usize,
};
self.write_instr(instr);
self.write_arg(arg);
self.stack_dec();
match &binop.kind {
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Open
| TokenKind::Closed
| TokenKind::InOp => {
self.stack_dec();
}
_ => {}
}
}
fn emit_binop_instr_311(&mut self, binop: Token, type_pair: TypePair) {
let instr = match &binop.kind {
TokenKind::Plus
| TokenKind::Minus
| TokenKind::Star
| TokenKind::Slash
| TokenKind::FloorDiv
| TokenKind::Pow
| TokenKind::Mod
| TokenKind::AndOp
| TokenKind::OrOp => Opcode311::BINARY_OP,
TokenKind::Less
| TokenKind::LessEq
| TokenKind::DblEq
| TokenKind::NotEq
| TokenKind::Gre
| TokenKind::GreEq => Opcode311::COMPARE_OP,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => {
self.write_instr(Opcode311::PRECALL);
self.write_arg(2);
self.write_arg(0);
self.write_arg(0);
Opcode311::CALL
}
_ => {
CompileError::feature_error(
self.cfg.input.clone(),
binop.loc(),
&binop.inspect().clone(),
String::from(binop.content),
)
.write_to_stderr();
Opcode311::NOT_IMPLEMENTED
}
};
let arg = match &binop.kind {
TokenKind::Plus => BinOpCode::Add as usize,
TokenKind::Minus => BinOpCode::Subtract as usize,
TokenKind::Star => BinOpCode::Multiply as usize,
TokenKind::Slash => BinOpCode::TrueDivide as usize,
TokenKind::FloorDiv => BinOpCode::FloorDiv as usize,
TokenKind::Pow => BinOpCode::Power as usize,
TokenKind::Mod => BinOpCode::Remainder as usize,
TokenKind::AndOp => BinOpCode::And as usize,
TokenKind::OrOp => BinOpCode::Or as usize,
TokenKind::Less => 0,
TokenKind::LessEq => 1,
TokenKind::DblEq => 2,
TokenKind::NotEq => 3,
TokenKind::Gre => 4,
TokenKind::GreEq => 5,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => 2,
_ => type_pair as usize,
};
self.write_instr(instr);
self.write_arg(arg);
match instr {
Opcode311::CALL => {
self.write_bytes(&[0; 8]);
}
Opcode311::BINARY_OP => {
self.write_bytes(&[0; 2]);
}
Opcode311::COMPARE_OP => {
self.write_bytes(&[0; 4]);
}
_ => {}
}
self.stack_dec();
match &binop.kind {
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Open
| TokenKind::Closed
| TokenKind::InOp => {
self.stack_dec();
if self.py_version.minor >= Some(11) {
self.stack_dec();
}
}
_ => {}
}
}
fn emit_del_instr(&mut self, mut args: Args) {
let ident = enum_unwrap!(args.remove_left_or_key("obj").unwrap(), Expr::Accessor:(Accessor::Ident:(_)));
log!(info "entered {} ({ident})", fn_name!());
let escaped = escape_ident(ident);
let name = self
.local_search(&escaped, Name)
.unwrap_or_else(|| self.register_name(escaped));
self.write_instr(DELETE_NAME);
self.write_arg(name.idx);
self.emit_load_const(ValueObj::None);
}
fn emit_not_instr(&mut self, mut args: Args) {
log!(info "entered {}", fn_name!());
let expr = args.remove_left_or_key("b").unwrap();
self.emit_expr(expr);
self.write_instr(UNARY_NOT);
self.write_arg(0);
}
fn emit_discard_instr(&mut self, mut args: Args) {
log!(info "entered {}", fn_name!());
while let Some(arg) = args.try_remove(0) {
self.emit_expr(arg);
self.emit_pop_top();
}
self.emit_load_const(ValueObj::None);
}
fn emit_if_instr(&mut self, mut args: Args) {
log!(info "entered {}", fn_name!());
let init_stack_len = self.stack_len();
let cond = args.remove(0);
self.emit_expr(cond);
let idx_pop_jump_if_false = self.lasti();
// Opcode310::POP_JUMP_IF_FALSE == Opcode311::POP_JUMP_FORWARD_IF_FALSE
self.write_instr(Opcode310::POP_JUMP_IF_FALSE);
// cannot detect where to jump to at this moment, so put as 0
self.write_arg(0);
match args.remove(0) {
// then block
Expr::Lambda(lambda) => {
// let params = self.gen_param_names(&lambda.params);
self.emit_frameless_block(lambda.body, vec![]);
}
other => {
self.emit_expr(other);
}
}
if args.get(0).is_some() {
let idx_jump_forward = self.lasti();
self.write_instr(JUMP_FORWARD); // jump to end
self.write_arg(0);
// else block
let idx_else_begin = if self.py_version.minor >= Some(11) {
self.lasti() - idx_pop_jump_if_false - 2
} else {
self.lasti()
};
self.calc_edit_jump(idx_pop_jump_if_false + 1, idx_else_begin);
match args.remove(0) {
Expr::Lambda(lambda) => {
// let params = self.gen_param_names(&lambda.params);
self.emit_frameless_block(lambda.body, vec![]);
}
other => {
self.emit_expr(other);
}
}
let idx_end = self.lasti();
self.calc_edit_jump(idx_jump_forward + 1, idx_end - idx_jump_forward - 2);
// FIXME: this is a hack to make sure the stack is balanced
while self.stack_len() != init_stack_len + 1 {
self.stack_dec();
}
} else {
self.write_instr(JUMP_FORWARD);
self.write_arg(1);
// no else block
let idx_end = if self.py_version.minor >= Some(11) {
self.lasti() - idx_pop_jump_if_false - 1
} else {
self.lasti()
};
self.calc_edit_jump(idx_pop_jump_if_false + 1, idx_end);
self.emit_load_const(ValueObj::None);
while self.stack_len() != init_stack_len + 1 {
self.stack_dec();
}
}
debug_assert_eq!(self.stack_len(), init_stack_len + 1);
}
fn emit_for_instr(&mut self, mut args: Args) {
log!(info "entered {} ({})", fn_name!(), args);
let _init_stack_len = self.stack_len();
let iterable = args.remove(0);
self.emit_expr(iterable);
self.write_instr(GET_ITER);
self.write_arg(0);
let idx_for_iter = self.lasti();
self.write_instr(FOR_ITER);
self.stack_inc();
// FOR_ITER pushes a value onto the stack, but we can't know how many
// but after executing this instruction, stack_len should be 1
// cannot detect where to jump to at this moment, so put as 0
self.write_arg(0);
let lambda = enum_unwrap!(args.remove(0), Expr::Lambda);
// If there is nothing on the stack at the start, init_stack_len == 2 (an iterator and the first iterator value)
let init_stack_len = self.stack_len();
let params = self.gen_param_names(&lambda.params);
// store the iterator value, stack_len == 1 or 2 in the end
self.emit_frameless_block(lambda.body, params);
if self.stack_len() > init_stack_len - 1 {
self.emit_pop_top();
}
debug_assert_eq!(self.stack_len(), init_stack_len - 1); // the iterator is remained
match self.py_version.minor {
Some(11) => {
self.write_instr(Opcode311::JUMP_BACKWARD);
self.write_arg((self.lasti() - idx_for_iter + 2) / 2);
}
Some(10) => {
self.write_instr(Opcode310::JUMP_ABSOLUTE);
self.write_arg(idx_for_iter / 2);
}
Some(8) => {
self.write_instr(Opcode308::JUMP_ABSOLUTE);
self.write_arg(idx_for_iter);
}
_ => todo!(),
}
let idx_end = self.lasti();
self.calc_edit_jump(idx_for_iter + 1, idx_end - idx_for_iter - 2);
self.stack_dec();
self.emit_load_const(ValueObj::None);
debug_assert_eq!(self.stack_len(), _init_stack_len + 1);
}
fn emit_while_instr(&mut self, mut args: Args) {
log!(info "entered {} ({})", fn_name!(), args);
let _init_stack_len = self.stack_len();
// e.g. is_foo!: () => Bool, do!(is_bar)
let cond_block = args.remove(0);
let cond = match cond_block {
Expr::Lambda(mut lambda) => lambda.body.remove(0),
Expr::Accessor(acc) => Expr::Accessor(acc).call_expr(Args::empty()),
_ => todo!(),
};
self.emit_expr(cond.clone());
let idx_while = self.lasti();
self.write_instr(Opcode310::POP_JUMP_IF_FALSE);
self.write_arg(0);
self.stack_dec();
let lambda = enum_unwrap!(args.remove(0), Expr::Lambda);
let init_stack_len = self.stack_len();
let params = self.gen_param_names(&lambda.params);
self.emit_frameless_block(lambda.body, params);
if self.stack_len() > init_stack_len {
self.emit_pop_top();
}
self.emit_expr(cond);
let arg = if self.py_version.minor >= Some(11) {
let arg = self.lasti() - (idx_while + 2);
self.write_instr(Opcode311::POP_JUMP_BACKWARD_IF_TRUE);
arg / 2 + 1
} else {
self.write_instr(Opcode310::POP_JUMP_IF_TRUE);
if self.py_version.minor >= Some(10) {
(idx_while + 2) / 2
} else {
idx_while + 2
}
};
self.write_arg(arg);
self.stack_dec();
let idx_end = if self.py_version.minor >= Some(11) {
self.lasti() - idx_while - 1
} else {
self.lasti()
};
self.calc_edit_jump(idx_while + 1, idx_end);
self.emit_load_const(ValueObj::None);
debug_assert_eq!(self.stack_len(), _init_stack_len + 1);
}
fn emit_match_instr(&mut self, mut args: Args, _use_erg_specific: bool) {
log!(info "entered {}", fn_name!());
let init_stack_len = self.stack_len();
let expr = args.remove(0);
self.emit_expr(expr);
let len = args.len();
let mut jump_forward_points = vec![];
while let Some(expr) = args.try_remove(0) {
if len > 1 && !args.is_empty() {
self.dup_top();
}
// compilerで型チェック済み(可読性が下がるため、matchでNamedは使えない)
let mut lambda = enum_unwrap!(expr, Expr::Lambda);
debug_power_assert!(lambda.params.len(), ==, 1);
if !lambda.params.defaults.is_empty() {
todo!("default values in match expression are not supported yet")
}
let param = lambda.params.non_defaults.remove(0);
let pop_jump_points = self.emit_match_pattern(param, args.is_empty());
self.emit_frameless_block(lambda.body, Vec::new());
// If we move on to the next arm, the stack size will increase
// so `self.stack_dec();` for now (+1 at the end).
self.stack_dec();
for pop_jump_point in pop_jump_points.into_iter() {
let idx = if self.py_version.minor >= Some(11) {
self.lasti() - pop_jump_point // - 2
} else {
self.lasti() + 2
};
self.calc_edit_jump(pop_jump_point + 1, idx); // jump to POP_TOP
jump_forward_points.push(self.lasti());
self.write_instr(JUMP_FORWARD); // jump to the end
self.write_arg(0);
}
}
let lasti = self.lasti();
for jump_point in jump_forward_points.into_iter() {
self.calc_edit_jump(jump_point + 1, lasti - jump_point - 1);
}
self.stack_inc();
debug_assert_eq!(self.stack_len(), init_stack_len + 1);
}
fn emit_match_pattern(
&mut self,
param: NonDefaultParamSignature,
is_last_arm: bool,
) -> Vec<usize> {
log!(info "entered {}", fn_name!());
let mut pop_jump_points = vec![];
if let Some(t_spec) = param.t_spec.map(|spec| spec.t_spec) {
// If it's the last arm, there's no need to inspect it
if !is_last_arm {
if self.py_version.minor >= Some(11) {
self.emit_match_guard_311(t_spec, &mut pop_jump_points);
} else {
self.emit_match_guard_310(t_spec, &mut pop_jump_points);
}
}
}
match param.pat {
ParamPattern::VarName(name) => {
let ident = Identifier::bare(None, name);
self.emit_store_instr(ident, AccessKind::Name);
}
ParamPattern::Discard(_) => {
self.emit_pop_top();
}
_other => unreachable!(),
}
pop_jump_points
}
fn emit_match_guard_311(&mut self, t_spec: TypeSpec, pop_jump_points: &mut Vec<usize>) {
log!(info "entered {} ({t_spec})", fn_name!());
match t_spec {
TypeSpec::Enum(enum_t) => {
let elems = ValueObj::vec_from_const_args(enum_t);
self.emit_load_const(elems);
self.write_instr(CONTAINS_OP);
self.write_arg(0);
self.stack_dec();
pop_jump_points.push(self.lasti());
// in 3.11, POP_JUMP_IF_FALSE is replaced with POP_JUMP_FORWARD_IF_FALSE
// but the numbers are the same, only the way the jumping points are calculated is different.
self.write_instr(Opcode310::POP_JUMP_IF_FALSE); // jump to the next case
self.write_arg(0);
// self.stack_dec();
}
TypeSpec::PreDeclTy(PreDeclTypeSpec::Simple(simple)) if simple.args.is_empty() => {
// arg null
// ↓ SWAP 1
// null arg
// ↓ LOAD_NAME(in_operator)
// null arg in_operator
// ↓ SWAP 1
// null in_operator arg
// ↓ LOAD_NAME(typ)
// null in_operator arg typ
self.emit_push_null();
self.rot2();
if !self.in_op_loaded {
self.load_in_op();
}
self.emit_load_name_instr(Identifier::private("#in_operator"));
self.rot2();
// TODO: DOT/not
let mut typ = Identifier::bare(Some(DOT), simple.ident.name);
// TODO:
typ.vi.py_name = match &typ.name.inspect()[..] {
"Int" => Some("int".into()),
"Float" => Some("float".into()),
_ => None,
};
self.emit_load_name_instr(typ);
self.emit_precall_and_call(2);
self.stack_dec();
pop_jump_points.push(self.lasti());
// in 3.11, POP_JUMP_IF_FALSE is replaced with POP_JUMP_FORWARD_IF_FALSE
// but the numbers are the same, only the way the jumping points are calculated is different.
self.write_instr(Opcode310::POP_JUMP_IF_FALSE); // jump to the next case
self.write_arg(0);
self.stack_dec();
}
// _: (Int, Str)
TypeSpec::Tuple(tup) => {
let len = tup.tys.len();
for (i, t_spec) in tup.tys.into_iter().enumerate() {
if i != 0 && i != len - 1 {
self.dup_top();
}
self.emit_load_const(i);
self.write_instr(Opcode311::BINARY_SUBSCR);
self.write_arg(0);
self.stack_dec();
self.emit_match_guard_311(t_spec, pop_jump_points);
}
}
// TODO: consider ordering (e.g. both [1, 2] and [2, 1] is type of [{1, 2}; 2])
TypeSpec::Array(arr) => {
let ValueObj::Nat(len) = ValueObj::from_const_expr(arr.len) else { todo!() };
for i in 0..=(len - 1) {
if i != 0 && i != len - 1 {
self.dup_top();
}
self.emit_load_const(i);
self.write_instr(Opcode311::BINARY_SUBSCR);
self.write_arg(0);
self.stack_dec();
self.emit_match_guard_311(*arr.ty.clone(), pop_jump_points);
}
}
/*TypeSpec::Interval { op, lhs, rhs } => {
let binop = BinOp::new(op, lhs.downcast(), rhs.downcast(), VarInfo::default());
self.emit_binop(binop);
}*/
// TODO:
TypeSpec::Infer(_) => unreachable!(),
// TODO:
other => log!(err "{other}"),
}
}
fn emit_match_guard_310(&mut self, t_spec: TypeSpec, pop_jump_points: &mut Vec<usize>) {
log!(info "entered {} ({t_spec})", fn_name!());
match t_spec {
TypeSpec::Enum(enum_t) => {
let elems = ValueObj::vec_from_const_args(enum_t);
self.emit_load_const(elems);
self.write_instr(Opcode310::CONTAINS_OP);
self.write_arg(0);
self.stack_dec();
pop_jump_points.push(self.lasti());
// in 3.11, POP_JUMP_IF_FALSE is replaced with POP_JUMP_FORWARD_IF_FALSE
// but the numbers are the same, only the way the jumping points are calculated is different.
self.write_instr(Opcode310::POP_JUMP_IF_FALSE); // jump to the next case
self.write_arg(0);
// self.stack_dec();
}
TypeSpec::PreDeclTy(PreDeclTypeSpec::Simple(simple)) if simple.args.is_empty() => {
// arg
// ↓ LOAD_NAME(in_operator)
// arg in_operator
// ↓ ROT 2
// in_operator arg
// ↓ LOAD_NAME(typ)
// in_operator arg typ
self.emit_load_name_instr(Identifier::private("#in_operator"));
self.rot2();
// TODO: DOT/not
let mut typ = Identifier::bare(Some(DOT), simple.ident.name);
// TODO:
typ.vi.py_name = match &typ.name.inspect()[..] {
"Int" => Some("int".into()),
"Float" => Some("float".into()),
_ => None,
};
self.emit_load_name_instr(typ);
self.write_instr(Opcode310::CALL_FUNCTION);
self.write_arg(2);
self.stack_dec();
pop_jump_points.push(self.lasti());
// in 3.11, POP_JUMP_IF_FALSE is replaced with POP_JUMP_FORWARD_IF_FALSE
// but the numbers are the same, only the way the jumping points are calculated is different.
self.write_instr(Opcode310::POP_JUMP_IF_FALSE); // jump to the next case
self.write_arg(0);
self.stack_dec();
}
// _: (Int, Str)
TypeSpec::Tuple(tup) => {
let len = tup.tys.len();
for (i, t_spec) in tup.tys.into_iter().enumerate() {
if i != 0 && i != len - 1 {
self.dup_top();
}
self.emit_load_const(i);
self.write_instr(Opcode310::BINARY_SUBSCR);
self.write_arg(0);
self.stack_dec();
self.emit_match_guard_310(t_spec, pop_jump_points);
}
}
// TODO: consider ordering (e.g. both [1, 2] and [2, 1] is type of [{1, 2}; 2])
TypeSpec::Array(arr) => {
let ValueObj::Nat(len) = ValueObj::from_const_expr(arr.len) else { todo!() };
for i in 0..=(len - 1) {
if i != 0 && i != len - 1 {
self.dup_top();
}
self.emit_load_const(i);
self.write_instr(Opcode310::BINARY_SUBSCR);
self.write_arg(0);
self.stack_dec();
self.emit_match_guard_310(*arr.ty.clone(), pop_jump_points);
}
}
/*TypeSpec::Interval { op, lhs, rhs } => {
let binop = BinOp::new(op, lhs.downcast(), rhs.downcast(), VarInfo::default());
self.emit_binop(binop);
}*/
// TODO:
TypeSpec::Infer(_) => unreachable!(),
// TODO:
other => log!(err "{other}"),
}
}
fn emit_with_instr_311(&mut self, args: Args) {
log!(info "entered {}", fn_name!());
let mut args = args;
let expr = args.remove(0);
let lambda = enum_unwrap!(args.remove(0), Expr::Lambda);
let params = self.gen_param_names(&lambda.params);
self.emit_expr(expr);
self.write_instr(Opcode311::BEFORE_WITH);
self.write_arg(0);
// push __exit__, __enter__() to the stack
self.stack_inc_n(2);
let lambda_line = lambda.body.last().unwrap().ln_begin().unwrap_or(0);
self.emit_with_block(lambda.body, params);
let stash = Identifier::private_with_line(Str::from(fresh_varname()), lambda_line);
self.emit_store_instr(stash.clone(), Name);
self.emit_load_const(ValueObj::None);
self.emit_load_const(ValueObj::None);
self.emit_load_const(ValueObj::None);
self.emit_precall_and_call(2);
self.emit_pop_top();
let idx_jump_forward = self.lasti();
self.write_instr(Opcode311::JUMP_FORWARD);
self.write_arg(0);
self.write_instr(Opcode311::PUSH_EXC_INFO);
self.write_arg(0);
self.write_instr(Opcode308::WITH_EXCEPT_START);
self.write_arg(0);
self.write_instr(Opcode311::POP_JUMP_FORWARD_IF_TRUE);
self.write_arg(4);
self.write_instr(Opcode311::RERAISE);
self.write_arg(0);
self.write_instr(Opcode311::COPY);
self.write_arg(3);
self.write_instr(Opcode311::POP_EXCEPT);
self.write_arg(0);
self.write_instr(Opcode311::RERAISE);
self.write_arg(1);
self.emit_pop_top();
self.write_instr(Opcode311::POP_EXCEPT);
self.write_arg(0);
self.emit_pop_top();
self.emit_pop_top();
self.calc_edit_jump(idx_jump_forward + 1, self.lasti() - idx_jump_forward - 2);
self.emit_load_name_instr(stash);
}
fn emit_with_instr_310(&mut self, args: Args) {
log!(info "entered {}", fn_name!());
let mut args = args;
let expr = args.remove(0);
let lambda = enum_unwrap!(args.remove(0), Expr::Lambda);
let params = self.gen_param_names(&lambda.params);
self.emit_expr(expr);
let idx_setup_with = self.lasti();
self.write_instr(Opcode310::SETUP_WITH);
self.write_arg(0);
// push __exit__, __enter__() to the stack
self.stack_inc_n(2);
let lambda_line = lambda.body.last().unwrap().ln_begin().unwrap_or(0);
self.emit_with_block(lambda.body, params);
let stash = Identifier::private_with_line(Str::from(fresh_varname()), lambda_line);
self.emit_store_instr(stash.clone(), Name);
self.write_instr(POP_BLOCK);
self.write_arg(0);
self.emit_load_const(ValueObj::None);
self.write_instr(Opcode310::DUP_TOP);
self.write_arg(0);
self.stack_inc();
self.write_instr(Opcode310::DUP_TOP);
self.write_arg(0);
self.stack_inc();
self.write_instr(Opcode310::CALL_FUNCTION);
self.write_arg(3);
self.stack_dec_n((1 + 3) - 1);
self.emit_pop_top();
let idx_jump_forward = self.lasti();
self.write_instr(JUMP_FORWARD);
self.write_arg(0);
self.edit_code(idx_setup_with + 1, (self.lasti() - idx_setup_with - 2) / 2);
self.write_instr(Opcode310::WITH_EXCEPT_START);
self.write_arg(0);
let idx_pop_jump_if_true = self.lasti();
self.write_instr(Opcode310::POP_JUMP_IF_TRUE);
self.write_arg(0);
self.write_instr(Opcode310::RERAISE);
self.write_arg(1);
self.edit_code(idx_pop_jump_if_true + 1, self.lasti() / 2);
// self.emit_pop_top();
// self.emit_pop_top();
self.emit_pop_top();
self.write_instr(Opcode310::POP_EXCEPT);
self.write_arg(0);
let idx_end = self.lasti();
self.edit_code(idx_jump_forward + 1, (idx_end - idx_jump_forward - 2) / 2);
self.emit_load_name_instr(stash);
}
fn emit_with_instr_308(&mut self, args: Args) {
log!(info "entered {}", fn_name!());
let mut args = args;
let expr = args.remove(0);
let lambda = enum_unwrap!(args.remove(0), Expr::Lambda);
let params = self.gen_param_names(&lambda.params);
self.emit_expr(expr);
let idx_setup_with = self.lasti();
self.write_instr(Opcode308::SETUP_WITH);
self.write_arg(0);
// push __exit__, __enter__() to the stack
// self.stack_inc_n(2);
let lambda_line = lambda.body.last().unwrap().ln_begin().unwrap_or(0);
self.emit_with_block(lambda.body, params);
let stash = Identifier::private_with_line(Str::from(fresh_varname()), lambda_line);
self.emit_store_instr(stash.clone(), Name);
self.write_instr(POP_BLOCK);
self.write_arg(0);
self.write_instr(Opcode308::BEGIN_FINALLY);
self.write_arg(0);
self.write_instr(Opcode308::WITH_CLEANUP_START);
self.write_arg(0);
self.edit_code(idx_setup_with + 1, (self.lasti() - idx_setup_with - 2) / 2);
self.write_instr(Opcode308::WITH_CLEANUP_FINISH);
self.write_arg(0);
self.write_instr(Opcode308::END_FINALLY);
self.write_arg(0);
self.emit_load_name_instr(stash);
}
fn emit_call(&mut self, call: Call) {
log!(info "entered {} ({call})", fn_name!());
let init_stack_len = self.stack_len();
// Python cannot distinguish at compile time between a method call and a attribute call
if let Some(attr_name) = call.attr_name {
self.emit_call_method(*call.obj, attr_name, call.args);
} else {
match *call.obj {
Expr::Accessor(Accessor::Ident(ident)) if ident.vis().is_private() => {
self.emit_call_local(ident, call.args)
}
other => {
let is_py_api = other.is_py_api();
self.emit_push_null();
self.emit_expr(other);
self.emit_args_311(call.args, Name, is_py_api);
}
}
}
debug_assert_eq!(self.stack_len(), init_stack_len + 1);
}
fn emit_call_local(&mut self, local: Identifier, args: Args) {
log!(info "entered {}", fn_name!());
match &local.inspect()[..] {
"assert" => self.emit_assert_instr(args),
"Del" => self.emit_del_instr(args),
"not" => self.emit_not_instr(args),
"discard" => self.emit_discard_instr(args),
"for" | "for!" => self.emit_for_instr(args),
"while!" => self.emit_while_instr(args),
"if" | "if!" => self.emit_if_instr(args),
"match" | "match!" => self.emit_match_instr(args, true),
"with!" => match self.py_version.minor {
Some(11) => self.emit_with_instr_311(args),
Some(10) => self.emit_with_instr_310(args),
Some(8) => self.emit_with_instr_308(args),
_ => todo!(),
},
// "pyimport" | "py" are here
_ => {
let is_py_api = local.is_py_api();
self.emit_push_null();
self.emit_load_name_instr(local);
self.emit_args_311(args, Name, is_py_api);
}
}
}
fn emit_call_method(&mut self, obj: Expr, method_name: Identifier, args: Args) {
log!(info "entered {}", fn_name!());
match &method_name.inspect()[..] {
"update!" => {
if self.py_version.minor >= Some(11) {
return self.emit_call_update_311(obj, args);
} else {
return self.emit_call_update_310(obj, args);
}
}
"return" if obj.ref_t().is_callable() => {
return self.emit_return_instr(args);
}
// TODO: create `Generator` type
"yield" /* if obj.ref_t().is_callable() */ => {
return self.emit_yield_instr(args);
}
_ => {}
}
if let Some(func_name) = debind(&method_name) {
return self.emit_call_fake_method(obj, func_name, method_name, args);
}
let is_py_api = method_name.is_py_api();
self.emit_expr(obj);
self.emit_load_method_instr(method_name);
self.emit_args_311(args, Method, is_py_api);
}
fn emit_var_args_311(&mut self, pos_len: usize, var_args: &PosArg) {
if pos_len > 0 {
self.write_instr(BUILD_LIST);
self.write_arg(pos_len);
}
self.emit_expr(var_args.expr.clone());
if pos_len > 0 {
self.write_instr(Opcode310::LIST_EXTEND);
self.write_arg(1);
self.write_instr(Opcode310::LIST_TO_TUPLE);
self.write_arg(0);
}
}
fn emit_var_args_38(&mut self, pos_len: usize, var_args: &PosArg) {
if pos_len > 0 {
self.write_instr(BUILD_TUPLE);
self.write_arg(pos_len);
}
self.emit_expr(var_args.expr.clone());
if pos_len > 0 {
self.write_instr(Opcode308::BUILD_TUPLE_UNPACK_WITH_CALL);
self.write_arg(2);
}
}
fn emit_args_311(&mut self, mut args: Args, kind: AccessKind, is_py_api: bool) {
let argc = args.len();
let pos_len = args.pos_args.len();
let mut kws = Vec::with_capacity(args.kw_len());
while let Some(arg) = args.try_remove_pos(0) {
self.emit_expr(arg.expr);
}
if let Some(var_args) = &args.var_args {
if self.py_version.minor >= Some(10) {
self.emit_var_args_311(pos_len, var_args);
} else {
self.emit_var_args_38(pos_len, var_args);
}
}
while let Some(arg) = args.try_remove_kw(0) {
let kw = if is_py_api {
arg.keyword.content
} else {
escape_name(&arg.keyword.content, Visibility::Private)
};
kws.push(ValueObj::Str(kw));
self.emit_expr(arg.expr);
}
let kwsc = if !kws.is_empty() {
self.emit_call_kw_instr(argc, kws);
#[allow(clippy::bool_to_int_with_if)]
if self.py_version.minor >= Some(11) {
0
} else {
1
}
} else {
if args.var_args.is_some() {
self.write_instr(CALL_FUNCTION_EX);
if kws.is_empty() {
self.write_arg(0);
} else {
self.write_arg(1);
}
} else {
self.emit_call_instr(argc, kind);
}
0
};
// (1 (subroutine) + argc + kwsc) input objects -> 1 return object
self.stack_dec_n((1 + argc + kwsc) - 1);
}
/// X.update! x -> x + 1
/// X = (x -> x + 1)(X)
/// X = X + 1
fn emit_call_update_311(&mut self, obj: Expr, mut args: Args) {
log!(info "entered {}", fn_name!());
let acc = enum_unwrap!(obj, Expr::Accessor);
let func = args.remove_left_or_key("f").unwrap();
self.emit_push_null();
self.emit_expr(func);
self.emit_acc(acc.clone());
self.emit_precall_and_call(1);
// (1 (subroutine) + argc) input objects -> 1 return object
// self.stack_dec_n((1 + 1) - 1);
self.stack_dec();
self.store_acc(acc);
self.emit_load_const(ValueObj::None);
}
/// X.update! x -> x + 1
/// X = (x -> x + 1)(X)
/// X = X + 1
fn emit_call_update_310(&mut self, obj: Expr, mut args: Args) {
log!(info "entered {}", fn_name!());
let acc = enum_unwrap!(obj, Expr::Accessor);
let func = args.remove_left_or_key("f").unwrap();
self.emit_expr(func);
self.emit_acc(acc.clone());
self.write_instr(Opcode310::CALL_FUNCTION);
self.write_arg(1);
// (1 (subroutine) + argc) input objects -> 1 return object
self.stack_dec_n((1 + 1) - 1);
self.store_acc(acc);
self.emit_load_const(ValueObj::None);
}
// TODO: use exception
fn emit_return_instr(&mut self, mut args: Args) {
log!(info "entered {}", fn_name!());
if args.is_empty() {
self.emit_load_const(ValueObj::None);
} else {
self.emit_expr(args.remove(0));
}
self.write_instr(RETURN_VALUE);
self.write_arg(0);
}
fn emit_yield_instr(&mut self, mut args: Args) {
log!(info "entered {}", fn_name!());
if args.is_empty() {
self.emit_load_const(ValueObj::None);
} else {
self.emit_expr(args.remove(0));
}
self.write_instr(YIELD_VALUE);
self.write_arg(0);
}
/// 1.abs() => abs(1)
fn emit_call_fake_method(
&mut self,
obj: Expr,
func_name: Str,
mut method_name: Identifier,
mut args: Args,
) {
log!(info "entered {}", fn_name!());
method_name.dot = None;
method_name.vi.py_name = Some(func_name);
self.emit_push_null();
self.emit_load_name_instr(method_name);
args.insert_pos(0, PosArg::new(obj));
self.emit_args_311(args, Name, true);
}
// assert takes 1 or 2 arguments (0: cond, 1: message)
fn emit_assert_instr(&mut self, mut args: Args) {
log!(info "entered {}", fn_name!());
let init_stack_len = self.stack_len();
self.emit_expr(args.remove(0));
let pop_jump_point = self.lasti();
self.write_instr(Opcode310::POP_JUMP_IF_TRUE);
self.write_arg(0);
self.stack_dec();
if self.py_version.minor >= Some(10) {
self.write_instr(Opcode310::LOAD_ASSERTION_ERROR);
self.write_arg(0);
self.stack_inc();
} else {
self.emit_load_global_instr(Identifier::public("AssertionError"));
}
if let Some(expr) = args.try_remove(0) {
self.emit_expr(expr);
if self.py_version.minor >= Some(11) {
self.emit_precall_and_call(0);
} else {
self.write_instr(Opcode310::CALL_FUNCTION);
self.write_arg(1);
}
}
self.write_instr(RAISE_VARARGS);
self.write_arg(1);
self.stack_dec();
let idx = match self.py_version.minor {
Some(11) => (self.lasti() - pop_jump_point - 2) / 2,
Some(10) => self.lasti() / 2,
Some(_) => self.lasti(),
_ => todo!(),
};
self.edit_code(pop_jump_point + 1, idx);
self.emit_load_const(ValueObj::None);
debug_assert_eq!(self.stack_len(), init_stack_len + 1);
}
// TODO: list comprehension
fn emit_array(&mut self, array: Array) {
let init_stack_len = self.stack_len();
if !self.cfg.no_std {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("Array"));
}
match array {
Array::Normal(mut arr) => {
let len = arr.elems.len();
while let Some(arg) = arr.elems.try_remove_pos(0) {
self.emit_expr(arg.expr);
}
self.write_instr(BUILD_LIST);
self.write_arg(len);
if len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(len - 1);
}
}
Array::WithLength(arr) => {
self.emit_expr(*arr.elem);
self.write_instr(BUILD_LIST);
self.write_arg(1);
self.emit_expr(*arr.len);
if self.py_version.minor >= Some(11) {
self.write_instr(Opcode311::BINARY_OP);
self.write_arg(BinOpCode::Multiply as usize);
} else {
self.write_instr(Opcode310::BINARY_MULTIPLY);
self.write_arg(0);
}
self.stack_dec();
}
other => todo!("{other}"),
}
if !self.cfg.no_std {
self.emit_call_instr(1, Name);
self.stack_dec();
}
debug_assert_eq!(self.stack_len(), init_stack_len + 1);
}
#[allow(clippy::identity_op)]
fn emit_record(&mut self, rec: Record) {
log!(info "entered {} ({rec})", fn_name!());
let init_stack_len = self.stack_len();
let attrs_len = rec.attrs.len();
self.emit_push_null();
// making record type
let ident = Identifier::private("#NamedTuple");
self.emit_load_name_instr(ident);
// record name, let it be anonymous
self.emit_load_const("Record");
for field in rec.attrs.iter() {
self.emit_load_const(ValueObj::Str(field.sig.ident().inspect().clone()));
}
self.write_instr(BUILD_LIST);
self.write_arg(attrs_len);
if attrs_len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(attrs_len - 1);
}
self.emit_call_instr(2, Name);
// (1 (subroutine) + argc + kwsc) input objects -> 1 return object
self.stack_dec_n((1 + 2 + 0) - 1);
let ident = Identifier::private("#rec");
self.emit_store_instr(ident, Name);
// making record instance
let ident = Identifier::private("#rec");
self.emit_push_null();
self.emit_load_name_instr(ident);
for field in rec.attrs.into_iter() {
self.emit_frameless_block(field.body.block, vec![]);
}
self.emit_call_instr(attrs_len, Name);
// (1 (subroutine) + argc + kwsc) input objects -> 1 return object
self.stack_dec_n((1 + attrs_len + 0) - 1);
debug_assert_eq!(self.stack_len(), init_stack_len + 1);
}
pub(crate) fn get_root(acc: &Accessor) -> Identifier {
match acc {
Accessor::Ident(ident) => ident.clone(),
Accessor::Attr(attr) => {
if let Expr::Accessor(acc) = attr.obj.as_ref() {
Self::get_root(acc)
} else {
todo!("{:?}", attr.obj)
}
}
}
}
fn emit_import(&mut self, acc: Accessor) {
self.emit_load_const(0i32);
self.emit_load_const(ValueObj::None);
let full_name = Str::from(acc.show());
let name = self
.local_search(&full_name, Name)
.unwrap_or_else(|| self.register_name(full_name));
self.write_instr(IMPORT_NAME);
self.write_arg(name.idx);
let root = Self::get_root(&acc);
self.emit_store_instr(root, Name);
self.stack_dec();
}
fn emit_expr(&mut self, expr: Expr) {
log!(info "entered {} ({expr})", fn_name!());
if expr.ln_begin().unwrap_or_else(|| panic!("{expr}")) > self.cur_block().prev_lineno {
let sd = self.lasti() - self.cur_block().prev_lasti;
let ld = expr.ln_begin().unwrap() - self.cur_block().prev_lineno;
if ld != 0 {
if sd != 0 {
self.mut_cur_block_codeobj().lnotab.push(sd as u8);
self.mut_cur_block_codeobj().lnotab.push(ld as u8);
} else {
// empty lines
if let Some(last_ld) = self.mut_cur_block_codeobj().lnotab.last_mut() {
*last_ld += ld as u8;
} else {
// a block starts with an empty line
self.mut_cur_block_codeobj().lnotab.push(0);
self.mut_cur_block_codeobj().lnotab.push(ld as u8);
}
}
self.mut_cur_block().prev_lineno += ld;
self.mut_cur_block().prev_lasti = self.lasti();
} else {
CompileError::compiler_bug(
0,
self.cfg.input.clone(),
expr.loc(),
fn_name_full!(),
line!(),
)
.write_to_stderr();
self.crash("codegen failed: invalid bytecode format");
}
}
match expr {
Expr::Lit(lit) => self.emit_load_const(lit.value),
Expr::Accessor(acc) => self.emit_acc(acc),
Expr::Def(def) => self.emit_def(def),
Expr::ClassDef(class) => self.emit_class_def(class),
Expr::PatchDef(patch) => self.emit_patch_def(patch),
Expr::AttrDef(attr) => self.emit_attr_def(attr),
Expr::Lambda(lambda) => self.emit_lambda(lambda),
Expr::UnaryOp(unary) => self.emit_unaryop(unary),
Expr::BinOp(bin) => self.emit_binop(bin),
Expr::Call(call) => self.emit_call(call),
Expr::Array(arr) => self.emit_array(arr),
// TODO: tuple comprehension
// TODO: tuples can be const
Expr::Tuple(tup) => match tup {
Tuple::Normal(mut tup) => {
let len = tup.elems.len();
while let Some(arg) = tup.elems.try_remove_pos(0) {
self.emit_expr(arg.expr);
}
self.write_instr(BUILD_TUPLE);
self.write_arg(len);
if len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(len - 1);
}
}
},
Expr::Set(set) => match set {
crate::hir::Set::Normal(mut set) => {
let len = set.elems.len();
while let Some(arg) = set.elems.try_remove_pos(0) {
self.emit_expr(arg.expr);
}
self.write_instr(BUILD_SET);
self.write_arg(len);
if len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(len - 1);
}
}
crate::hir::Set::WithLength(st) => {
self.emit_expr(*st.elem);
self.write_instr(BUILD_SET);
self.write_arg(1);
}
},
Expr::Dict(dict) => match dict {
crate::hir::Dict::Normal(dic) => {
let len = dic.kvs.len();
for kv in dic.kvs.into_iter() {
self.emit_expr(kv.key);
self.emit_expr(kv.value);
}
self.write_instr(BUILD_MAP);
self.write_arg(len);
if len == 0 {
self.stack_inc();
} else {
self.stack_dec_n(2 * len - 1);
}
}
other => todo!("{other}"),
},
Expr::Record(rec) => self.emit_record(rec),
Expr::Code(code) => {
let code = self.emit_block(code, None, vec![]);
self.emit_load_const(code);
}
Expr::Compound(chunks) => {
let is_module_loading_chunks = chunks
.get(2)
.map(|chunk| {
option_enum_unwrap!(chunk, Expr::Call)
.map(|call| {
call.obj.show_acc().as_ref().map(|s| &s[..]) == Some("exec")
})
.unwrap_or(false)
})
.unwrap_or(false);
if !self.module_type_loaded && is_module_loading_chunks {
self.load_module_type();
self.module_type_loaded = true;
}
let init_stack_len = self.stack_len();
for expr in chunks.into_iter() {
self.emit_expr(expr);
if self.stack_len() == init_stack_len + 1 {
self.emit_pop_top();
}
}
self.cancel_if_pop_top();
}
Expr::TypeAsc(tasc) => {
self.emit_expr(*tasc.expr);
}
Expr::Import(acc) => self.emit_import(acc),
Expr::Dummy(_) => {}
}
}
/// forブロックなどで使う
fn emit_frameless_block(&mut self, block: Block, params: Vec<Str>) {
log!(info "entered {}", fn_name!());
let line = block.ln_begin().unwrap_or(0);
for param in params {
self.emit_store_instr(Identifier::public_with_line(DOT, param, line), Name);
}
let init_stack_len = self.stack_len();
for expr in block.into_iter() {
self.emit_expr(expr);
if self.stack_len() > init_stack_len {
self.emit_pop_top();
}
}
self.cancel_if_pop_top();
}
fn emit_with_block(&mut self, block: Block, params: Vec<Str>) {
log!(info "entered {}", fn_name!());
let line = block.ln_begin().unwrap_or(0);
for param in params {
self.emit_store_instr(Identifier::public_with_line(DOT, param, line), Name);
}
let init_stack_len = self.stack_len();
for expr in block.into_iter() {
self.emit_expr(expr);
// __exit__, __enter__() are on the stack
if self.stack_len() > init_stack_len {
self.emit_pop_top();
}
}
self.cancel_if_pop_top();
}
fn emit_class_block(&mut self, class: ClassDef) -> CodeObj {
log!(info "entered {}", fn_name!());
let name = class.sig.ident().inspect().clone();
self.unit_size += 1;
let firstlineno = match class.methods.get(0).and_then(|def| def.ln_begin()) {
Some(l) => l,
None => class.sig.ln_begin().unwrap(),
};
self.units.push(PyCodeGenUnit::new(
self.unit_size,
self.py_version,
vec![],
Str::rc(self.cfg.input.enclosed_name()),
&name,
firstlineno,
));
let init_stack_len = self.stack_len();
let mod_name = self.toplevel_block_codeobj().name.clone();
self.emit_load_const(mod_name);
self.emit_store_instr(Identifier::public("__module__"), Name);
self.emit_load_const(name);
self.emit_store_instr(Identifier::public("__qualname__"), Name);
self.emit_init_method(&class.sig, class.__new__.clone());
if class.need_to_gen_new {
self.emit_new_func(&class.sig, class.__new__);
}
if !class.methods.is_empty() {
self.emit_frameless_block(class.methods, vec![]);
}
if self.stack_len() == init_stack_len {
self.emit_load_const(ValueObj::None);
}
self.write_instr(RETURN_VALUE);
self.write_arg(0);
if self.stack_len() > 1 {
let block_id = self.cur_block().id;
let stack_len = self.stack_len();
CompileError::stack_bug(
self.input().clone(),
Location::Unknown,
stack_len,
block_id,
fn_name_full!(),
)
.write_to_stderr();
self.crash("error in emit_class_block: invalid stack size");
}
// flagging
if !self.cur_block_codeobj().varnames.is_empty() {
self.mut_cur_block_codeobj().flags += CodeObjFlags::NewLocals as u32;
}
// end of flagging
let unit = self.units.pop().unwrap();
if !self.units.is_empty() {
let ld = unit.prev_lineno - self.cur_block().prev_lineno;
if ld != 0 {
if let Some(l) = self.mut_cur_block_codeobj().lnotab.last_mut() {
*l += ld as u8;
}
self.mut_cur_block().prev_lineno += ld;
}
}
unit.codeobj
}
fn emit_init_method(&mut self, sig: &Signature, __new__: Type) {
log!(info "entered {}", fn_name!());
let line = sig.ln_begin().unwrap();
let class_name = sig.ident().inspect();
let mut ident = Identifier::public_with_line(DOT, Str::ever("__init__"), line);
ident.vi.t = __new__.clone();
let param_name = fresh_varname();
let param = VarName::from_str_and_line(Str::from(param_name.clone()), line);
let param = NonDefaultParamSignature::new(ParamPattern::VarName(param), None);
let self_param = VarName::from_str_and_line(Str::ever("self"), line);
let self_param = NonDefaultParamSignature::new(ParamPattern::VarName(self_param), None);
let params = Params::new(vec![self_param, param], None, vec![], None);
let subr_sig = SubrSignature::new(ident, params);
let mut attrs = vec![];
match __new__.non_default_params().unwrap()[0].typ() {
// namedtupleは仕様上::xなどの名前を使えない
// {x = Int; y = Int}
// => self::x = %x.x; self::y = %x.y
// {.x = Int; .y = Int}
// => self.x = %x.x; self.y = %x.y
Type::Record(rec) => {
for field in rec.keys() {
let obj =
Expr::Accessor(Accessor::private_with_line(Str::from(¶m_name), line));
let expr = obj.attr_expr(Identifier::bare(
Some(DOT),
VarName::from_str(field.symbol.clone()),
));
let obj = Expr::Accessor(Accessor::private_with_line(Str::ever("self"), line));
let dot = if field.vis.is_private() {
None
} else {
Some(DOT)
};
let attr = obj.attr(Identifier::bare(
dot,
VarName::from_str(field.symbol.clone()),
));
let attr_def = AttrDef::new(attr, Block::new(vec![expr]));
attrs.push(Expr::AttrDef(attr_def));
}
let none = Token::new(TokenKind::NoneLit, "None", line, 0);
attrs.push(Expr::Lit(Literal::try_from(none).unwrap()));
}
other => todo!("{other}"),
}
let block = Block::new(attrs);
let body = DefBody::new(EQUAL, block, DefId(0));
self.emit_subr_def(Some(class_name), subr_sig, body);
}
/// ```python
/// class C:
/// # __new__ => __call__
/// def new(x): return C.__call__(x)
/// ```
fn emit_new_func(&mut self, sig: &Signature, __new__: Type) {
log!(info "entered {}", fn_name!());
let class_ident = sig.ident();
let line = sig.ln_begin().unwrap();
let mut ident = Identifier::public_with_line(DOT, Str::ever("new"), line);
ident.vi.t = __new__;
let param_name = fresh_varname();
let param = VarName::from_str_and_line(Str::from(param_name.clone()), line);
let param = NonDefaultParamSignature::new(ParamPattern::VarName(param), None);
let sig = SubrSignature::new(ident, Params::new(vec![param], None, vec![], None));
let arg = PosArg::new(Expr::Accessor(Accessor::private_with_line(
Str::from(param_name),
line,
)));
let class = Expr::Accessor(Accessor::Ident(class_ident.clone()));
let mut new_ident =
Identifier::bare(None, VarName::from_str_and_line(Str::ever("__new__"), line));
new_ident.vi.py_name = Some(Str::ever("__call__"));
let class_new = class.attr_expr(new_ident);
let call = class_new.call_expr(Args::new(vec![arg], None, vec![], None));
let block = Block::new(vec![call]);
let body = DefBody::new(EQUAL, block, DefId(0));
self.emit_subr_def(Some(class_ident.inspect()), sig, body);
}
fn emit_block(&mut self, block: Block, opt_name: Option<Str>, params: Vec<Str>) -> CodeObj {
log!(info "entered {}", fn_name!());
self.unit_size += 1;
let name = if let Some(name) = opt_name {
name
} else {
"<block>".into()
};
let firstlineno = block
.first()
.and_then(|first| first.ln_begin())
.unwrap_or(0);
self.units.push(PyCodeGenUnit::new(
self.unit_size,
self.py_version,
params,
Str::rc(self.cfg.input.enclosed_name()),
name,
firstlineno,
));
let idx_copy_free_vars = if self.py_version.minor >= Some(11) {
let idx_copy_free_vars = self.lasti();
self.write_instr(Opcode311::COPY_FREE_VARS);
self.write_arg(0);
self.write_instr(Opcode311::RESUME);
self.write_arg(0);
idx_copy_free_vars
} else {
0
};
let init_stack_len = self.stack_len();
for expr in block.into_iter() {
self.emit_expr(expr);
// NOTE: 各行のトップレベルでは0個または1個のオブジェクトが残っている
// Pythonの場合使わなかったオブジェクトはそのまま捨てられるが、Ergではdiscardを使う必要がある
// TODO: discard
if self.stack_len() > init_stack_len {
self.emit_pop_top();
}
}
self.cancel_if_pop_top(); // 最後の値は戻り値として取っておく
if self.stack_len() == init_stack_len {
self.emit_load_const(ValueObj::None);
} else if self.stack_len() > init_stack_len + 1 {
let block_id = self.cur_block().id;
let stack_len = self.stack_len();
CompileError::stack_bug(
self.input().clone(),
Location::Unknown,
stack_len,
block_id,
fn_name_full!(),
)
.write_to_stderr();
self.crash("error in emit_block: invalid stack size");
}
self.write_instr(RETURN_VALUE);
self.write_arg(0);
// flagging
if !self.cur_block_codeobj().varnames.is_empty() {
self.mut_cur_block_codeobj().flags += CodeObjFlags::NewLocals as u32;
}
let freevars_len = self.cur_block_codeobj().freevars.len();
if freevars_len > 0 {
self.mut_cur_block_codeobj().flags += CodeObjFlags::Nested as u32;
self.edit_code(idx_copy_free_vars + 1, freevars_len);
} else if self.py_version.minor >= Some(11) {
let code = self.cur_block_codeobj().code.get(idx_copy_free_vars);
debug_assert_eq!(code, Some(&(Opcode311::COPY_FREE_VARS as u8)));
self.edit_code(idx_copy_free_vars, CommonOpcode::NOP as usize);
}
// end of flagging
let unit = self.units.pop().unwrap();
// increase lineno
if !self.units.is_empty() {
let ld = unit
.prev_lineno
.saturating_sub(self.cur_block().prev_lineno);
if ld != 0 {
if let Some(l) = self.mut_cur_block_codeobj().lnotab.last_mut() {
*l += ld as u8;
}
self.mut_cur_block().prev_lineno += ld;
}
}
unit.codeobj
}
fn load_prelude(&mut self) {
// NOTE: Integers need to be used in IMPORT_NAME
// but `Int` are called before importing it, so they need to be no_std mode
let no_std = self.cfg.no_std;
self.cfg.no_std = true;
self.load_record_type();
self.load_prelude_py();
self.prelude_loaded = true;
self.record_type_loaded = true;
self.cfg.no_std = no_std;
}
fn load_in_op(&mut self) {
let mod_name = if self.py_version.minor >= Some(10) {
Identifier::public("_erg_std_prelude")
} else {
Identifier::public("_erg_std_prelude_old")
};
self.emit_global_import_items(
mod_name,
vec![(
Identifier::public("in_operator"),
Some(Identifier::private("#in_operator")),
)],
);
self.in_op_loaded = true;
}
fn load_mutate_op(&mut self) {
let mod_name = if self.py_version.minor >= Some(10) {
Identifier::public("_erg_std_prelude")
} else {
Identifier::public("_erg_std_prelude_old")
};
self.emit_global_import_items(
mod_name,
vec![(
Identifier::public("mutate_operator"),
Some(Identifier::private("#mutate_operator")),
)],
);
self.mutate_op_loaded = true;
}
fn load_control(&mut self) {
let mod_name = Identifier::public("_erg_control");
self.emit_import_all_instr(mod_name);
self.control_loaded = true;
}
fn load_convertors(&mut self) {
let mod_name = Identifier::public("_erg_convertors");
self.emit_import_all_instr(mod_name);
self.convertors_loaded = true;
}
fn load_prelude_py(&mut self) {
self.emit_global_import_items(
Identifier::public("sys"),
vec![(
Identifier::public("path"),
Some(Identifier::private("#path")),
)],
);
self.emit_load_name_instr(Identifier::private("#path"));
self.emit_load_method_instr(Identifier::public("append"));
self.emit_load_const(erg_std_path().to_str().unwrap());
self.emit_call_instr(1, Method);
self.stack_dec();
self.emit_pop_top();
let erg_std_mod = if self.py_version.minor >= Some(10) {
Identifier::public("_erg_std_prelude")
} else {
Identifier::public("_erg_std_prelude_old")
};
// escaping
self.emit_global_import_items(
erg_std_mod.clone(),
vec![(
Identifier::public("in_operator"),
Some(Identifier::private("#in_operator")),
)],
);
self.emit_import_all_instr(erg_std_mod);
}
fn load_record_type(&mut self) {
self.emit_global_import_items(
Identifier::public("collections"),
vec![(
Identifier::public("namedtuple"),
Some(Identifier::private("#NamedTuple")),
)],
);
}
fn load_abc(&mut self) {
self.emit_global_import_items(
Identifier::public("abc"),
vec![
(
Identifier::public("ABCMeta"),
Some(Identifier::private("#ABCMeta")),
),
(
Identifier::public("abstractmethod"),
Some(Identifier::private("#abstractmethod")),
),
],
);
}
fn load_module_type(&mut self) {
self.emit_global_import_items(
Identifier::public("types"),
vec![(
Identifier::public("ModuleType"),
Some(Identifier::private("#ModuleType")),
)],
);
}
pub fn emit(&mut self, hir: HIR) -> CodeObj {
log!(info "the code-generating process has started.{RESET}");
self.unit_size += 1;
self.units.push(PyCodeGenUnit::new(
self.unit_size,
self.py_version,
vec![],
Str::rc(self.cfg.input.enclosed_name()),
"<module>",
1,
));
if self.py_version.minor >= Some(11) {
self.write_instr(Opcode311::RESUME);
self.write_arg(0);
}
if !self.cfg.no_std && !self.prelude_loaded {
self.load_prelude();
}
for expr in hir.module.into_iter() {
self.emit_expr(expr);
// TODO: discard
if self.stack_len() == 1 {
self.emit_pop_top();
}
}
self.cancel_if_pop_top(); // 最後の値は戻り値として取っておく
if self.input().is_repl() {
if self.stack_len() == 1 {
self.emit_print_expr();
}
self.stack_dec_n(self.stack_len() as usize);
}
if self.stack_len() == 0 {
self.emit_load_const(ValueObj::None);
} else if self.stack_len() > 1 {
let block_id = self.cur_block().id;
let stack_len = self.stack_len();
CompileError::stack_bug(
self.input().clone(),
Location::Unknown,
stack_len,
block_id,
fn_name_full!(),
)
.write_to_stderr();
self.crash("error in emit: invalid stack size");
}
self.write_instr(RETURN_VALUE);
self.write_arg(0);
// flagging
if !self.cur_block_codeobj().varnames.is_empty() {
self.mut_cur_block_codeobj().flags += CodeObjFlags::NewLocals as u32;
}
// end of flagging
let unit = self.units.pop().unwrap();
if !self.units.is_empty() {
let ld = unit.prev_lineno - self.cur_block().prev_lineno;
if ld != 0 {
if let Some(l) = self.mut_cur_block_codeobj().lnotab.last_mut() {
*l += ld as u8;
}
self.mut_cur_block().prev_lineno += ld;
}
}
log!(info "the code-generating process has completed.{RESET}");
unit.codeobj
}sourcepub fn feature_error(
input: Input,
loc: Location,
name: &str,
caused_by: String
) -> Self
pub fn feature_error(
input: Input,
loc: Location,
name: &str,
caused_by: String
) -> Self
Examples found in repository?
context/register.rs (lines 1505-1510)
1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
fn change_var_type(&mut self, acc: &hir::Accessor, t: Type) -> TyCheckResult<()> {
#[allow(clippy::single_match)]
match acc {
hir::Accessor::Ident(ident) => {
if let Some(vi) = self.get_mut_current_scope_var(ident.inspect()) {
vi.t = t;
} else {
return Err(TyCheckErrors::from(TyCheckError::feature_error(
self.cfg.input.clone(),
acc.loc(),
&format!("casting {acc}"),
self.caused_by(),
)));
}
}
_ => {
// TODO: support other accessors
}
}
Ok(())
}More examples
codegen.rs (lines 1341-1346)
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
fn emit_unaryop(&mut self, unary: UnaryOp) {
log!(info "entered {} ({unary})", fn_name!());
let tycode = TypeCode::from(unary.lhs_t());
let instr = match &unary.op.kind {
// TODO:
TokenKind::PrePlus => UNARY_POSITIVE,
TokenKind::PreMinus => UNARY_NEGATIVE,
TokenKind::Mutate => {
if !self.mutate_op_loaded {
self.load_mutate_op();
}
if self.py_version.minor >= Some(11) {
self.emit_push_null();
}
self.emit_load_name_instr(Identifier::private("#mutate_operator"));
NOP // ERG_MUTATE,
}
_ => {
CompileError::feature_error(
self.cfg.input.clone(),
unary.op.loc(),
&unary.op.inspect().clone(),
String::from(unary.op.content),
)
.write_to_stderr();
NOT_IMPLEMENTED
}
};
self.emit_expr(*unary.expr);
if instr != NOP {
self.write_instr(instr);
self.write_arg(tycode as usize);
} else {
if self.py_version.minor >= Some(11) {
self.emit_precall_and_call(1);
} else {
self.write_instr(Opcode310::CALL_FUNCTION);
self.write_arg(1);
}
self.stack_dec();
}
}
fn emit_binop(&mut self, bin: BinOp) {
log!(info "entered {} ({bin})", fn_name!());
// TODO: and/orのプリミティブ命令の実装
// Range operators are not operators in Python
match &bin.op.kind {
// l..<r == range(l, r)
TokenKind::RightOpen => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("RightOpenRange"));
}
TokenKind::LeftOpen => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("LeftOpenRange"));
}
TokenKind::Closed => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("ClosedRange"));
}
TokenKind::Open => {
self.emit_push_null();
self.emit_load_name_instr(Identifier::public("OpenRange"));
}
TokenKind::InOp => {
// if no-std, always `x in y == True`
if self.cfg.no_std {
self.emit_load_const(true);
return;
}
if !self.in_op_loaded {
self.load_in_op();
}
self.emit_push_null();
self.emit_load_name_instr(Identifier::private("#in_operator"));
}
_ => {}
}
let type_pair = TypePair::new(bin.lhs_t(), bin.rhs_t());
self.emit_expr(*bin.lhs);
self.emit_expr(*bin.rhs);
if self.py_version.minor >= Some(11) {
self.emit_binop_instr_311(bin.op, type_pair);
} else {
self.emit_binop_instr_310(bin.op, type_pair);
}
}
fn emit_binop_instr_310(&mut self, binop: Token, type_pair: TypePair) {
let instr = match &binop.kind {
TokenKind::Plus => Opcode310::BINARY_ADD,
TokenKind::Minus => Opcode310::BINARY_SUBTRACT,
TokenKind::Star => Opcode310::BINARY_MULTIPLY,
TokenKind::Slash => Opcode310::BINARY_TRUE_DIVIDE,
TokenKind::FloorDiv => Opcode310::BINARY_FLOOR_DIVIDE,
TokenKind::Pow => Opcode310::BINARY_POWER,
TokenKind::Mod => Opcode310::BINARY_MODULO,
TokenKind::AndOp => Opcode310::BINARY_AND,
TokenKind::OrOp => Opcode310::BINARY_OR,
TokenKind::Less
| TokenKind::LessEq
| TokenKind::DblEq
| TokenKind::NotEq
| TokenKind::Gre
| TokenKind::GreEq => Opcode310::COMPARE_OP,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => Opcode310::CALL_FUNCTION, // ERG_BINARY_RANGE,
_ => {
CompileError::feature_error(
self.cfg.input.clone(),
binop.loc(),
&binop.inspect().clone(),
String::from(binop.content),
)
.write_to_stderr();
Opcode310::NOT_IMPLEMENTED
}
};
let arg = match &binop.kind {
TokenKind::Less => 0,
TokenKind::LessEq => 1,
TokenKind::DblEq => 2,
TokenKind::NotEq => 3,
TokenKind::Gre => 4,
TokenKind::GreEq => 5,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => 2,
_ => type_pair as usize,
};
self.write_instr(instr);
self.write_arg(arg);
self.stack_dec();
match &binop.kind {
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Open
| TokenKind::Closed
| TokenKind::InOp => {
self.stack_dec();
}
_ => {}
}
}
fn emit_binop_instr_311(&mut self, binop: Token, type_pair: TypePair) {
let instr = match &binop.kind {
TokenKind::Plus
| TokenKind::Minus
| TokenKind::Star
| TokenKind::Slash
| TokenKind::FloorDiv
| TokenKind::Pow
| TokenKind::Mod
| TokenKind::AndOp
| TokenKind::OrOp => Opcode311::BINARY_OP,
TokenKind::Less
| TokenKind::LessEq
| TokenKind::DblEq
| TokenKind::NotEq
| TokenKind::Gre
| TokenKind::GreEq => Opcode311::COMPARE_OP,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => {
self.write_instr(Opcode311::PRECALL);
self.write_arg(2);
self.write_arg(0);
self.write_arg(0);
Opcode311::CALL
}
_ => {
CompileError::feature_error(
self.cfg.input.clone(),
binop.loc(),
&binop.inspect().clone(),
String::from(binop.content),
)
.write_to_stderr();
Opcode311::NOT_IMPLEMENTED
}
};
let arg = match &binop.kind {
TokenKind::Plus => BinOpCode::Add as usize,
TokenKind::Minus => BinOpCode::Subtract as usize,
TokenKind::Star => BinOpCode::Multiply as usize,
TokenKind::Slash => BinOpCode::TrueDivide as usize,
TokenKind::FloorDiv => BinOpCode::FloorDiv as usize,
TokenKind::Pow => BinOpCode::Power as usize,
TokenKind::Mod => BinOpCode::Remainder as usize,
TokenKind::AndOp => BinOpCode::And as usize,
TokenKind::OrOp => BinOpCode::Or as usize,
TokenKind::Less => 0,
TokenKind::LessEq => 1,
TokenKind::DblEq => 2,
TokenKind::NotEq => 3,
TokenKind::Gre => 4,
TokenKind::GreEq => 5,
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Closed
| TokenKind::Open
| TokenKind::InOp => 2,
_ => type_pair as usize,
};
self.write_instr(instr);
self.write_arg(arg);
match instr {
Opcode311::CALL => {
self.write_bytes(&[0; 8]);
}
Opcode311::BINARY_OP => {
self.write_bytes(&[0; 2]);
}
Opcode311::COMPARE_OP => {
self.write_bytes(&[0; 4]);
}
_ => {}
}
self.stack_dec();
match &binop.kind {
TokenKind::LeftOpen
| TokenKind::RightOpen
| TokenKind::Open
| TokenKind::Closed
| TokenKind::InOp => {
self.stack_dec();
if self.py_version.minor >= Some(11) {
self.stack_dec();
}
}
_ => {}
}
}pub fn system_exit() -> Self
source§impl CompileError
impl CompileError
sourcepub fn dummy(input: Input, errno: usize) -> Self
pub fn dummy(input: Input, errno: usize) -> Self
Examples found in repository?
context/inquire.rs (lines 402-405)
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
pub(crate) fn rec_get_var_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.get_current_scope_var(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
} else if let Some((name, _vi)) = self
.future_defined_locals
.get_key_value(&ident.inspect()[..])
{
return Err(TyCheckError::access_before_def_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
} else if let Some((name, _vi)) = self.deleted_locals.get_key_value(&ident.inspect()[..]) {
return Err(TyCheckError::access_deleted_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
match parent.rec_get_var_info(ident, acc_kind, input, namespace) {
Ok(vi) => Ok(vi),
Err(err) if err.core.kind == ErrorKind::DummyError => {
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
Err(err) => Err(err),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
pub(crate) fn rec_get_decl_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.decls.get(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
return parent.rec_get_decl_info(ident, acc_kind, input, namespace);
}
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
pub(crate) fn rec_get_attr_info(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
let name = ident.name.token();
match self.get_attr_info_from_attributive(&self_t, ident, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
match singular_ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
match self.get_attr_from_nominal_t(obj, ident, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(ident.inspect())
.or_else(|| patch.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(ident.inspect())
.or_else(|| methods_ctx.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
// TODO: dependent type widening
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
parent.rec_get_attr_info(obj, ident, input, namespace)
} else {
Err(TyCheckError::no_attr_error(
input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
&self_t,
name.inspect(),
self.get_similar_attr(&self_t, name.inspect()),
))
}
}
fn get_attr_from_nominal_t(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
if let Some(sups) = self.get_nominal_super_type_ctxs(&self_t) {
for ctx in sups {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
let coerced = self
.deref_tyvar(obj.t(), Variance::Covariant, Location::Unknown)
.map_err(|mut es| es.remove(0))?;
if obj.ref_t() != &coerced {
for ctx in self.get_nominal_super_type_ctxs(&coerced).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&coerced,
)
})? {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
self.coerce(obj.ref_t());
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
Err(TyCheckError::dummy(input.clone(), line!() as usize))
}
/// get type from given attributive type (Record).
/// not ModuleType or ClassType etc.
fn get_attr_info_from_attributive(
&self,
t: &Type,
ident: &Identifier,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
match t {
// (obj: Never).foo: Never
Type::Never => Ok(VarInfo::ILLEGAL.clone()),
Type::FreeVar(fv) if fv.is_linked() => {
self.get_attr_info_from_attributive(&fv.crack(), ident, namespace)
}
Type::FreeVar(fv) /* if fv.is_unbound() */ => {
let sup = fv.get_super().unwrap();
self.get_attr_info_from_attributive(&sup, ident, namespace)
}
Type::Ref(t) => self.get_attr_info_from_attributive(t, ident, namespace),
Type::RefMut { before, .. } => {
self.get_attr_info_from_attributive(before, ident, namespace)
}
Type::Refinement(refine) => {
self.get_attr_info_from_attributive(&refine.t, ident, namespace)
}
Type::Record(record) => {
if let Some(attr_t) = record.get(ident.inspect()) {
let muty = Mutability::from(&ident.inspect()[..]);
let vi = VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
);
Ok(vi)
} else {
let t = Type::Record(record.clone());
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
&t,
ident.inspect(),
self.get_similar_attr(&t, ident.inspect()),
))
}
}
other => {
if let Some(v) = self.rec_get_const_obj(&other.local_name()) {
match v {
ValueObj::Type(TypeObj::Generated(gen)) => self
.get_gen_t_require_attr_t(gen, &ident.inspect()[..])
.map(|attr_t| {
let muty = Mutability::from(&ident.inspect()[..]);
VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
)
})
.ok_or_else(|| {
TyCheckError::dummy(self.cfg.input.clone(), line!() as usize)
}),
ValueObj::Type(TypeObj::Builtin(_t)) => {
// FIXME:
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
_other => Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
)),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
}
}sourcepub fn unreachable(input: Input, fn_name: &str, line: u32) -> Self
pub fn unreachable(input: Input, fn_name: &str, line: u32) -> Self
Examples found in repository?
context/register.rs (lines 566-570)
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
pub(crate) fn fake_subr_assign(
&mut self,
ident: &Identifier,
decorators: &Set<Decorator>,
failure_t: Type,
) -> TyCheckResult<()> {
// already defined as const
if ident.is_const() {
let Some(vi) = self.decls.remove(ident.inspect()) else {
return Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)));
};
self.locals.insert(ident.name.clone(), vi);
}
let muty = if ident.is_const() {
Mutability::Const
} else {
Mutability::Immutable
};
let name = &ident.name;
self.decls.remove(name);
let comptime_decos = decorators
.iter()
.filter_map(|deco| match &deco.0 {
ast::Expr::Accessor(ast::Accessor::Ident(local)) if local.is_const() => {
Some(local.inspect().clone())
}
_ => None,
})
.collect();
let vi = VarInfo::new(
failure_t,
muty,
ident.vis(),
VarKind::DoesNotExist,
Some(comptime_decos),
self.impl_of(),
None,
);
log!(info "Registered {}::{name}: {}", self.name, &vi.t);
self.locals.insert(name.clone(), vi);
Ok(())
}More examples
context/eval.rs (lines 579-583)
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
fn eval_bin(&self, op: OpKind, lhs: ValueObj, rhs: ValueObj) -> EvalResult<ValueObj> {
match op {
Add => lhs.try_add(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Sub => lhs.try_sub(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Mul => lhs.try_mul(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Div => lhs.try_div(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
FloorDiv => lhs.try_floordiv(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Gt => lhs.try_gt(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Ge => lhs.try_ge(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Lt => lhs.try_lt(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Le => lhs.try_le(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Eq => lhs.try_eq(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Ne => lhs.try_ne(rhs).ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
Or => match (lhs, rhs) {
(ValueObj::Bool(l), ValueObj::Bool(r)) => Ok(ValueObj::Bool(l || r)),
(ValueObj::Type(lhs), ValueObj::Type(rhs)) => Ok(self.eval_or_type(lhs, rhs)),
_ => Err(EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))),
},
And => match (lhs, rhs) {
(ValueObj::Bool(l), ValueObj::Bool(r)) => Ok(ValueObj::Bool(l && r)),
(ValueObj::Type(lhs), ValueObj::Type(rhs)) => Ok(self.eval_and_type(lhs, rhs)),
_ => Err(EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))),
},
_other => Err(EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))),
}
}
fn eval_or_type(&self, lhs: TypeObj, rhs: TypeObj) -> ValueObj {
match (lhs, rhs) {
(TypeObj::Builtin(l), TypeObj::Builtin(r)) => ValueObj::builtin_t(self.union(&l, &r)),
(lhs, rhs) => ValueObj::gen_t(GenTypeObj::union(
self.union(lhs.typ(), rhs.typ()),
lhs,
rhs,
)),
}
}
fn eval_and_type(&self, lhs: TypeObj, rhs: TypeObj) -> ValueObj {
match (lhs, rhs) {
(TypeObj::Builtin(l), TypeObj::Builtin(r)) => {
ValueObj::builtin_t(self.intersection(&l, &r))
}
(lhs, rhs) => ValueObj::gen_t(GenTypeObj::intersection(
self.intersection(lhs.typ(), rhs.typ()),
lhs,
rhs,
)),
}
}
pub(crate) fn eval_bin_tp(
&self,
op: OpKind,
lhs: TyParam,
rhs: TyParam,
) -> EvalResult<TyParam> {
match (lhs, rhs) {
(TyParam::Value(ValueObj::Mut(lhs)), TyParam::Value(rhs)) => self
.eval_bin(op, lhs.borrow().clone(), rhs)
.map(|v| TyParam::Value(ValueObj::Mut(Shared::new(v)))),
(TyParam::Value(lhs), TyParam::Value(rhs)) => {
self.eval_bin(op, lhs, rhs).map(TyParam::value)
}
(TyParam::FreeVar(fv), r) if fv.is_linked() => {
self.eval_bin_tp(op, fv.crack().clone(), r)
}
(TyParam::FreeVar(_), _) if op.is_comparison() => Ok(TyParam::value(true)),
// _: Nat <= 10 => true
// TODO: maybe this is wrong, we should do the type-checking of `<=`
(TyParam::Erased(t), rhs)
if op.is_comparison() && self.supertype_of(&t, &self.get_tp_t(&rhs).unwrap()) =>
{
Ok(TyParam::value(true))
}
(l, TyParam::FreeVar(fv)) if fv.is_linked() => {
self.eval_bin_tp(op, l, fv.crack().clone())
}
(_, TyParam::FreeVar(_)) if op.is_comparison() => Ok(TyParam::value(true)),
// 10 <= _: Nat => true
(lhs, TyParam::Erased(t))
if op.is_comparison() && self.supertype_of(&self.get_tp_t(&lhs).unwrap(), &t) =>
{
Ok(TyParam::value(true))
}
(lhs @ TyParam::FreeVar(_), rhs) => Ok(TyParam::bin(op, lhs, rhs)),
(lhs, rhs @ TyParam::FreeVar(_)) => Ok(TyParam::bin(op, lhs, rhs)),
(e @ TyParam::Erased(_), _) | (_, e @ TyParam::Erased(_)) => Ok(e),
(l, r) => feature_error!(self, Location::Unknown, &format!("{l:?} {op} {r:?}"))
.map_err(Into::into),
}
}
fn eval_unary_val(&self, op: OpKind, val: ValueObj) -> EvalResult<ValueObj> {
match op {
Pos => Err(EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))),
Neg => Err(EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))),
Invert => Err(EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))),
Mutate => Ok(ValueObj::Mut(Shared::new(val))),
_other => unreachable_error!(self),
}
}
fn eval_unary_tp(&self, op: OpKind, val: TyParam) -> EvalResult<TyParam> {
match val {
TyParam::Value(c) => self.eval_unary_val(op, c).map(TyParam::Value),
TyParam::FreeVar(fv) if fv.is_linked() => self.eval_unary_tp(op, fv.crack().clone()),
e @ TyParam::Erased(_) => Ok(e),
TyParam::FreeVar(fv) if fv.is_unbound() => {
let t = fv.get_type().unwrap();
if op == OpKind::Mutate {
let constr = Constraint::new_type_of(t.mutate());
fv.update_constraint(constr);
let tp = TyParam::FreeVar(fv);
Ok(tp)
} else {
feature_error!(self, Location::Unknown, &format!("{op} {fv}"))
}
}
other => feature_error!(self, Location::Unknown, &format!("{op} {other}")),
}
}
fn eval_app(&self, name: Str, args: Vec<TyParam>) -> EvalResult<TyParam> {
feature_error!(
self,
Location::Unknown,
&format!("{name}({})", fmt_vec(&args))
)
}
/// 量化変数などはそのまま返す
pub(crate) fn eval_tp(&self, p: TyParam) -> EvalResult<TyParam> {
match p {
TyParam::FreeVar(fv) if fv.is_linked() => self.eval_tp(fv.crack().clone()),
TyParam::FreeVar(_) => Ok(p),
TyParam::Mono(name) => self
.rec_get_const_obj(&name)
.map(|v| TyParam::value(v.clone()))
.ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
TyParam::BinOp { op, lhs, rhs } => self.eval_bin_tp(op, *lhs, *rhs),
TyParam::UnaryOp { op, val } => self.eval_unary_tp(op, *val),
TyParam::App { name, args } => self.eval_app(name, args),
TyParam::Array(tps) => {
let mut new_tps = Vec::with_capacity(tps.len());
for tp in tps {
new_tps.push(self.eval_tp(tp)?);
}
Ok(TyParam::Array(new_tps))
}
TyParam::Tuple(tps) => {
let mut new_tps = Vec::with_capacity(tps.len());
for tp in tps {
new_tps.push(self.eval_tp(tp)?);
}
Ok(TyParam::Tuple(new_tps))
}
TyParam::Dict(dic) => {
let mut new_dic = dict! {};
for (k, v) in dic.into_iter() {
new_dic.insert(self.eval_tp(k)?, self.eval_tp(v)?);
}
Ok(TyParam::Dict(new_dic))
}
TyParam::Type(_) | TyParam::Erased(_) | TyParam::Value(_) => Ok(p.clone()),
_other => feature_error!(self, Location::Unknown, "???"),
}
}
pub(crate) fn eval_t_params(
&self,
substituted: Type,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
match substituted {
Type::FreeVar(fv) if fv.is_linked() => {
self.eval_t_params(fv.crack().clone(), level, t_loc)
}
Type::Subr(mut subr) => {
for pt in subr.non_default_params.iter_mut() {
*pt.typ_mut() = self.eval_t_params(mem::take(pt.typ_mut()), level, t_loc)?;
}
if let Some(var_args) = subr.var_params.as_mut() {
*var_args.typ_mut() =
self.eval_t_params(mem::take(var_args.typ_mut()), level, t_loc)?;
}
for pt in subr.default_params.iter_mut() {
*pt.typ_mut() = self.eval_t_params(mem::take(pt.typ_mut()), level, t_loc)?;
}
let return_t = self.eval_t_params(*subr.return_t, level, t_loc)?;
Ok(subr_t(
subr.kind,
subr.non_default_params,
subr.var_params.map(|v| *v),
subr.default_params,
return_t,
))
}
Type::Refinement(refine) => {
let mut preds = Set::with_capacity(refine.preds.len());
for pred in refine.preds.into_iter() {
preds.insert(self.eval_pred(pred)?);
}
Ok(refinement(refine.var, *refine.t, preds))
}
// [?T; 0].MutType! == [?T; !0]
// ?T(<: Add(?R(:> Int))).Output == ?T(<: Add(?R)).Output
// ?T(:> Int, <: Add(?R(:> Int))).Output == Int
Type::Proj { lhs, rhs } => self.eval_proj(*lhs, rhs, level, t_loc),
Type::ProjCall {
lhs,
attr_name,
args,
} => self.eval_proj_call(*lhs, attr_name, args, level, t_loc),
Type::Ref(l) => Ok(ref_(self.eval_t_params(*l, level, t_loc)?)),
Type::RefMut { before, after } => {
let before = self.eval_t_params(*before, level, t_loc)?;
let after = if let Some(after) = after {
Some(self.eval_t_params(*after, level, t_loc)?)
} else {
None
};
Ok(ref_mut(before, after))
}
Type::Poly { name, mut params } => {
for p in params.iter_mut() {
*p = self.eval_tp(mem::take(p))?;
}
Ok(poly(name, params))
}
Type::And(l, r) => {
let l = self.eval_t_params(*l, level, t_loc)?;
let r = self.eval_t_params(*r, level, t_loc)?;
Ok(self.intersection(&l, &r))
}
Type::Or(l, r) => {
let l = self.eval_t_params(*l, level, t_loc)?;
let r = self.eval_t_params(*r, level, t_loc)?;
Ok(self.union(&l, &r))
}
Type::Not(l, r) => {
let l = self.eval_t_params(*l, level, t_loc)?;
let r = self.eval_t_params(*r, level, t_loc)?;
Ok(not(l, r))
}
other if other.is_monomorphic() => Ok(other),
_other => feature_error!(self, t_loc, "???"),
}
}
pub(crate) fn eval_proj(
&self,
lhs: Type,
rhs: Str,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
// Currently Erg does not allow projection-types to be evaluated with type variables included.
// All type variables will be dereferenced or fail.
let (sub, opt_sup) = match lhs.clone() {
Type::FreeVar(fv) if fv.is_linked() => {
return self.eval_t_params(proj(fv.crack().clone(), rhs), level, t_loc)
}
Type::FreeVar(fv) if fv.is_unbound() => {
let (sub, sup) = fv.get_subsup().unwrap();
(sub, Some(sup))
}
other => (other, None),
};
// cannot determine at this point
if sub == Type::Never {
return Ok(proj(lhs, rhs));
}
// in Methods
if self.name == sub.qual_name() {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, self, level, t_loc)
{
return Ok(t);
}
}
for ty_ctx in self.get_nominal_super_type_ctxs(&sub).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&sub,
)
})? {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, ty_ctx, level, t_loc)
{
return Ok(t);
}
for (class, methods) in ty_ctx.methods_list.iter() {
match (&class, &opt_sup) {
(ClassDefType::ImplTrait { impl_trait, .. }, Some(sup)) => {
if !self.supertype_of(impl_trait, sup) {
continue;
}
}
(ClassDefType::ImplTrait { impl_trait, .. }, None) => {
if !self.supertype_of(impl_trait, &sub) {
continue;
}
}
_ => {}
}
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, methods, level, t_loc)
{
return Ok(t);
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, Type::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tyvar(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj(coerced, rhs);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce(&lhs);
t
})
} else {
let proj = proj(lhs, rhs);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}
pub(crate) fn convert_tp_into_ty(&self, tp: TyParam) -> Result<Type, ()> {
match tp {
TyParam::Array(tps) => {
let len = tps.len();
let mut t = Type::Never;
for elem_tp in tps {
let elem_t = self.convert_tp_into_ty(elem_tp)?;
// not union
t = self.union(&t, &elem_t);
}
Ok(array_t(t, TyParam::value(len)))
}
TyParam::FreeVar(fv) if fv.is_linked() => self.convert_tp_into_ty(fv.crack().clone()),
TyParam::Type(t) => Ok(t.as_ref().clone()),
TyParam::Value(v) => Type::try_from(v),
// TODO: Array, Dict, Set
_ => Err(()),
}
}
fn _convert_type_to_dict_type(&self, ty: Type) -> Result<Dict<Type, Type>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Dict" => {
let dict = Dict::try_from(params[0].clone())?;
let mut new_dict = dict! {};
for (k, v) in dict.into_iter() {
let k = self.convert_tp_into_ty(k)?;
let v = self.convert_tp_into_ty(v)?;
new_dict.insert(k, v);
}
Ok(new_dict)
}
_ => Err(()),
}
}
fn convert_type_to_array(&self, ty: Type) -> Result<Vec<ValueObj>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Array" || &name[..] == "Array!" => {
let t = self.convert_tp_into_ty(params[0].clone())?;
let len = enum_unwrap!(params[1], TyParam::Value:(ValueObj::Nat:(_)));
Ok(vec![ValueObj::builtin_t(t); len as usize])
}
_ => Err(()),
}
}
pub(crate) fn convert_value_into_array(&self, val: ValueObj) -> Result<Vec<ValueObj>, ()> {
match val {
ValueObj::Array(arr) => Ok(arr.to_vec()),
ValueObj::Type(t) => self.convert_type_to_array(t.into_typ()),
_ => Err(()),
}
}
fn validate_and_project(
&self,
sub: &Type,
opt_sup: Option<&Type>,
rhs: &str,
methods: &Context,
level: usize,
t_loc: Location,
) -> Option<Type> {
// e.g. sub: Int, opt_sup: Add(?T), rhs: Output, methods: Int.methods
// sub: [Int; 4], opt_sup: Add([Int; 2]), rhs: Output, methods: [T; N].methods
if let Ok(obj) = methods.get_const_local(&Token::symbol(rhs), &self.name) {
#[allow(clippy::single_match)]
// opt_sup: Add(?T), methods.impl_of(): Add(Int)
// opt_sup: Add([Int; 2]), methods.impl_of(): Add([T; M])
match (&opt_sup, methods.impl_of()) {
(Some(sup), Some(trait_)) => {
if !self.supertype_of(&trait_, sup) {
return None;
}
}
_ => {}
}
// obj: Int|<: Add(Int)|.Output == ValueObj::Type(<type Int>)
// obj: [T; N]|<: Add([T; M])|.Output == ValueObj::Type(<type [T; M+N]>)
if let ValueObj::Type(quant_projected_t) = obj {
let projected_t = quant_projected_t.into_typ();
let (quant_sub, _) = self.rec_get_type(&sub.local_name()).unwrap();
if let Some(sup) = opt_sup {
if let Some(quant_sup) = methods.impl_of() {
// T -> Int, M -> 2
self.substitute_typarams(&quant_sup, sup);
}
}
// T -> Int, N -> 4
self.substitute_typarams(quant_sub, sub);
// [T; M+N] -> [Int; 4+2] -> [Int; 6]
let res = self.eval_t_params(projected_t, level, t_loc).ok();
if let Some(t) = res {
let mut tv_cache = TyVarCache::new(self.level, self);
let t = self.detach(t, &mut tv_cache);
// Int -> T, 2 -> M, 4 -> N
self.undo_substitute_typarams(quant_sub);
if let Some(quant_sup) = methods.impl_of() {
self.undo_substitute_typarams(&quant_sup);
}
return Some(t);
}
} else {
todo!()
}
}
None
}
/// e.g.
/// F((Int), 3) => F(Int, 3)
/// F(?T, ?T) => F(?1, ?1)
fn detach(&self, ty: Type, tv_cache: &mut TyVarCache) -> Type {
match ty {
Type::FreeVar(fv) if fv.is_linked() => self.detach(fv.crack().clone(), tv_cache),
Type::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(t) = tv_cache.get_tyvar(&name) {
t.clone()
} else {
let tv = Type::FreeVar(new_fv);
tv_cache.push_or_init_tyvar(&name, &tv);
tv
}
}
Type::Poly { name, params } => {
let mut new_params = vec![];
for param in params {
new_params.push(self.detach_tp(param, tv_cache));
}
poly(name, new_params)
}
_ => ty,
}
}
fn detach_tp(&self, tp: TyParam, tv_cache: &mut TyVarCache) -> TyParam {
match tp {
TyParam::FreeVar(fv) if fv.is_linked() => self.detach_tp(fv.crack().clone(), tv_cache),
TyParam::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(tp) = tv_cache.get_typaram(&name) {
tp.clone()
} else {
let tp = TyParam::FreeVar(new_fv);
tv_cache.push_or_init_typaram(&name, &tp);
tp
}
}
TyParam::Type(t) => TyParam::t(self.detach(*t, tv_cache)),
_ => tp,
}
}
#[allow(clippy::only_used_in_recursion)]
/// e.g. qt: Array(T, N), st: Array(Int, 3)
pub(crate) fn substitute_typarams(&self, qt: &Type, st: &Type) {
let qtps = qt.typarams();
let stps = st.typarams();
if qtps.len() != stps.len() {
log!(err "{} {}", erg_common::fmt_vec(&qtps), erg_common::fmt_vec(&stps));
return; // TODO: e.g. Sub(Int) / Eq and Sub(?T)
}
for (qtp, stp) in qtps.into_iter().zip(stps.into_iter()) {
match qtp {
TyParam::FreeVar(fv) if fv.is_generalized() => {
if !stp.is_generalized() {
fv.undoable_link(&stp);
}
}
TyParam::Type(t) if t.is_generalized() => {
let qt = enum_unwrap!(t.as_ref(), Type::FreeVar);
let st = enum_unwrap!(stp, TyParam::Type);
if !st.is_generalized() {
qt.undoable_link(&st);
}
}
TyParam::Type(qt) => {
let st = enum_unwrap!(stp, TyParam::Type);
let st = if st.typarams_len() != qt.typarams_len() {
let st = enum_unwrap!(*st, Type::FreeVar);
st.get_sub().unwrap()
} else {
*st
};
if !st.is_generalized() {
self.substitute_typarams(&qt, &st);
}
self.sub_unify(&st, &qt, Location::Unknown, None).unwrap();
}
_ => {}
}
}
}
#[allow(clippy::only_used_in_recursion)]
pub(crate) fn undo_substitute_typarams(&self, substituted: &Type) {
for tp in substituted.typarams().into_iter() {
match tp {
TyParam::FreeVar(fv) if fv.is_undoable_linked() => fv.undo(),
TyParam::Type(t) if t.is_free_var() => {
let subst = enum_unwrap!(t.as_ref(), Type::FreeVar);
if subst.is_undoable_linked() {
subst.undo();
}
}
TyParam::Type(t) => {
self.undo_substitute_typarams(&t);
}
_ => {}
}
}
}
pub(crate) fn eval_proj_call(
&self,
lhs: TyParam,
attr_name: Str,
args: Vec<TyParam>,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
let t = self.get_tp_t(&lhs)?;
for ty_ctx in self.get_nominal_super_type_ctxs(&t).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&t,
)
})? {
if let Ok(obj) = ty_ctx.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let is_method = subr.sig_t().self_t().is_some();
let mut pos_args = vec![];
if is_method {
match ValueObj::try_from(lhs) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
for (_class, methods) in ty_ctx.methods_list.iter() {
if let Ok(obj) = methods.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let mut pos_args = vec![];
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, TyParam::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tp(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj_call(coerced, attr_name, args);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce_tp(&lhs);
t
})
} else {
let proj = proj_call(lhs, attr_name, args);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}
pub(crate) fn eval_pred(&self, p: Predicate) -> EvalResult<Predicate> {
match p {
Predicate::Value(_) | Predicate::Const(_) => Ok(p),
Predicate::Equal { lhs, rhs } => Ok(Predicate::eq(lhs, self.eval_tp(rhs)?)),
Predicate::NotEqual { lhs, rhs } => Ok(Predicate::ne(lhs, self.eval_tp(rhs)?)),
Predicate::LessEqual { lhs, rhs } => Ok(Predicate::le(lhs, self.eval_tp(rhs)?)),
Predicate::GreaterEqual { lhs, rhs } => Ok(Predicate::ge(lhs, self.eval_tp(rhs)?)),
Predicate::And(l, r) => Ok(Predicate::and(self.eval_pred(*l)?, self.eval_pred(*r)?)),
Predicate::Or(l, r) => Ok(Predicate::or(self.eval_pred(*l)?, self.eval_pred(*r)?)),
Predicate::Not(l, r) => Ok(Predicate::not(self.eval_pred(*l)?, self.eval_pred(*r)?)),
}
}
pub(crate) fn get_tp_t(&self, p: &TyParam) -> EvalResult<Type> {
let p = self.eval_tp(p.clone())?;
match p {
TyParam::Value(ValueObj::Mut(v)) => Ok(v.borrow().class().mutate()),
TyParam::Value(v) => Ok(v_enum(set![v])),
TyParam::Erased(t) => Ok((*t).clone()),
TyParam::FreeVar(fv) if fv.is_linked() => self.get_tp_t(&fv.crack()),
TyParam::FreeVar(fv) => {
if let Some(t) = fv.get_type() {
Ok(t)
} else {
feature_error!(self, Location::Unknown, "??")
}
}
TyParam::Type(typ) => Ok(self.meta_type(&typ)),
TyParam::Mono(name) => self
.rec_get_const_obj(&name)
.map(|v| v_enum(set![v.clone()]))
.ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
}),
TyParam::Array(tps) => {
let tp_t = self.get_tp_t(&tps[0])?;
let t = array_t(tp_t, TyParam::value(tps.len()));
Ok(t)
}
TyParam::Tuple(tps) => {
let mut tps_t = vec![];
for tp in tps {
tps_t.push(self.get_tp_t(&tp)?);
}
Ok(tuple_t(tps_t))
}
dict @ TyParam::Dict(_) => Ok(dict_t(dict)),
TyParam::UnaryOp { op, val } => match op {
OpKind::Mutate => Ok(self.get_tp_t(&val)?.mutate()),
_ => feature_error!(self, Location::Unknown, "??"),
},
TyParam::BinOp { op, lhs, rhs } => {
let op_name = op_to_name(op);
feature_error!(
self,
Location::Unknown,
&format!("get type: {op_name}({lhs}, {rhs})")
)
}
other => feature_error!(
self,
Location::Unknown,
&format!("getting the type of {other}")
),
}
}
pub(crate) fn _get_tp_class(&self, p: &TyParam) -> EvalResult<Type> {
let p = self.eval_tp(p.clone())?;
match p {
TyParam::Value(v) => Ok(v.class()),
TyParam::Erased(t) => Ok((*t).clone()),
TyParam::FreeVar(fv) => {
if let Some(t) = fv.get_type() {
Ok(t)
} else {
feature_error!(self, Location::Unknown, "??")
}
}
TyParam::Type(_) => Ok(Type::Type),
TyParam::Mono(name) => {
self.rec_get_const_obj(&name)
.map(|v| v.class())
.ok_or_else(|| {
EvalErrors::from(EvalError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
))
})
}
other => feature_error!(
self,
Location::Unknown,
&format!("getting the class of {other}")
),
}
}context/instantiate.rs (lines 473-477)
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
pub(crate) fn instantiate_simple_t(
&self,
simple: &SimpleTypeSpec,
opt_decl_t: Option<&ParamTy>,
tmp_tv_cache: &mut TyVarCache,
not_found_is_qvar: bool,
) -> TyCheckResult<Type> {
match &simple.ident.inspect()[..] {
"_" | "Obj" => Ok(Type::Obj),
"Nat" => Ok(Type::Nat),
"Int" => Ok(Type::Int),
"Ratio" => Ok(Type::Ratio),
"Float" => Ok(Type::Float),
"Str" => Ok(Type::Str),
"Bool" => Ok(Type::Bool),
"NoneType" => Ok(Type::NoneType),
"Ellipsis" => Ok(Type::Ellipsis),
"NotImplemented" => Ok(Type::NotImplemented),
"Inf" => Ok(Type::Inf),
"NegInf" => Ok(Type::NegInf),
"Never" => Ok(Type::Never),
"ClassType" => Ok(Type::ClassType),
"TraitType" => Ok(Type::TraitType),
"Type" => Ok(Type::Type),
"Array" => {
// TODO: kw
let mut args = simple.args.pos_args();
if let Some(first) = args.next() {
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
let len = if let Some(len) = args.next() {
self.instantiate_const_expr(&len.expr, None, tmp_tv_cache)?
} else {
TyParam::erased(Nat)
};
Ok(array_t(t, len))
} else {
Ok(mono("GenericArray"))
}
}
"Ref" => {
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"Ref",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_(t))
}
"RefMut" => {
// TODO after
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"RefMut",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_mut(t, None))
}
"Self" => self.rec_get_self_t().ok_or_else(|| {
TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
erg_common::fn_name_full!(),
line!(),
))
}),
other if simple.args.is_empty() => {
if let Some(t) = tmp_tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tmp_tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
if let Some(tv_cache) = &self.tv_cache {
if let Some(t) = tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
}
if let Some(outer) = &self.outer {
if let Ok(t) = outer.instantiate_simple_t(
simple,
opt_decl_t,
tmp_tv_cache,
not_found_is_qvar,
) {
return Ok(t);
}
}
if let Some(decl_t) = opt_decl_t {
return Ok(decl_t.typ().clone());
}
if let Some((typ, _)) = self.rec_get_type(other) {
Ok(typ.clone())
} else if not_found_is_qvar {
let tyvar = named_free_var(Str::rc(other), self.level, Constraint::Uninited);
tmp_tv_cache.push_or_init_tyvar(&Str::rc(other), &tyvar);
Ok(tyvar)
} else {
Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)))
}
}
other => {
let ctx = if let Some((_, ctx)) = self.rec_get_type(other) {
ctx
} else {
return Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.ident.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)));
};
// FIXME: kw args
let mut new_params = vec![];
for (i, arg) in simple.args.pos_args().enumerate() {
let params =
self.instantiate_const_expr(&arg.expr, Some((ctx, i)), tmp_tv_cache);
let params = params.or_else(|e| {
if not_found_is_qvar {
let name = Str::from(arg.expr.to_string());
let tp = TyParam::named_free_var(
name.clone(),
self.level,
Constraint::Uninited,
);
tmp_tv_cache.push_or_init_typaram(&name, &tp);
Ok(tp)
} else {
Err(e)
}
})?;
new_params.push(params);
}
// FIXME: non-builtin
Ok(poly(Str::rc(other), new_params))
}
}
}context/tyvar.rs (lines 1046-1050)
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
pub(crate) fn sub_unify_tp(
&self,
maybe_sub: &TyParam,
maybe_sup: &TyParam,
_variance: Option<Variance>,
loc: Location,
allow_divergence: bool,
) -> TyCheckResult<()> {
if maybe_sub.has_no_unbound_var()
&& maybe_sup.has_no_unbound_var()
&& maybe_sub == maybe_sup
{
return Ok(());
}
match (maybe_sub, maybe_sup) {
(TyParam::Type(maybe_sub), TyParam::Type(maybe_sup)) => {
self.sub_unify(maybe_sub, maybe_sup, loc, None)
}
(TyParam::FreeVar(lfv), TyParam::FreeVar(rfv))
if lfv.is_unbound() && rfv.is_unbound() =>
{
if lfv.level().unwrap() > rfv.level().unwrap() {
lfv.link(maybe_sup);
} else {
rfv.link(maybe_sub);
}
Ok(())
}
(TyParam::FreeVar(fv), tp) => {
match &*fv.borrow() {
FreeKind::Linked(l) | FreeKind::UndoableLinked { t: l, .. } => {
return self.sub_unify_tp(l, tp, _variance, loc, allow_divergence);
}
FreeKind::Unbound { .. } | FreeKind::NamedUnbound { .. } => {}
} // &fv is dropped
let fv_t = fv.constraint().unwrap().get_type().unwrap().clone(); // fvを参照しないよいにcloneする(あとでborrow_mutするため)
let tp_t = self.get_tp_t(tp)?;
if self.supertype_of(&fv_t, &tp_t) {
// 外部未連携型変数の場合、linkしないで制約を弱めるだけにする(see compiler/inference.md)
if fv.level() < Some(self.level) {
let new_constraint = Constraint::new_subtype_of(tp_t);
if self.is_sub_constraint_of(&fv.constraint().unwrap(), &new_constraint)
|| fv.constraint().unwrap().get_type() == Some(&Type)
{
fv.update_constraint(new_constraint);
}
} else {
fv.link(tp);
}
Ok(())
} else if allow_divergence
&& (self.eq_tp(tp, &TyParam::value(Inf))
|| self.eq_tp(tp, &TyParam::value(NegInf)))
&& self.subtype_of(&fv_t, &mono("Num"))
{
fv.link(tp);
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)))
}
}
(tp, TyParam::FreeVar(fv)) => {
match &*fv.borrow() {
FreeKind::Linked(l) | FreeKind::UndoableLinked { t: l, .. } => {
return self.sub_unify_tp(l, tp, _variance, loc, allow_divergence);
}
FreeKind::Unbound { .. } | FreeKind::NamedUnbound { .. } => {}
} // &fv is dropped
let fv_t = fv.constraint().unwrap().get_type().unwrap().clone(); // fvを参照しないよいにcloneする(あとでborrow_mutするため)
let tp_t = self.get_tp_t(tp)?;
if self.supertype_of(&fv_t, &tp_t) {
// 外部未連携型変数の場合、linkしないで制約を弱めるだけにする(see compiler/inference.md)
if fv.level() < Some(self.level) {
let new_constraint = Constraint::new_subtype_of(tp_t);
if self.is_sub_constraint_of(&fv.constraint().unwrap(), &new_constraint)
|| fv.constraint().unwrap().get_type() == Some(&Type)
{
fv.update_constraint(new_constraint);
}
} else {
fv.link(tp);
}
Ok(())
} else if allow_divergence
&& (self.eq_tp(tp, &TyParam::value(Inf))
|| self.eq_tp(tp, &TyParam::value(NegInf)))
&& self.subtype_of(&fv_t, &mono("Num"))
{
fv.link(tp);
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)))
}
}
(TyParam::UnaryOp { op: lop, val: lval }, TyParam::UnaryOp { op: rop, val: rval })
if lop == rop =>
{
self.sub_unify_tp(lval, rval, _variance, loc, allow_divergence)
}
(
TyParam::BinOp { op: lop, lhs, rhs },
TyParam::BinOp {
op: rop,
lhs: lhs2,
rhs: rhs2,
},
) if lop == rop => {
self.sub_unify_tp(lhs, lhs2, _variance, loc, allow_divergence)?;
self.sub_unify_tp(rhs, rhs2, _variance, loc, allow_divergence)
}
(l, TyParam::Erased(t)) => {
let sub_t = self.get_tp_t(l)?;
if self.subtype_of(&sub_t, t) {
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&sub_t,
t,
loc,
self.caused_by(),
)))
}
}
(l, TyParam::Type(r)) => {
let l = self
.convert_tp_into_ty(l.clone())
.unwrap_or_else(|_| todo!("{l} cannot be a type"));
self.sub_unify(&l, r, loc, None)?;
Ok(())
}
(TyParam::Type(l), r) => {
let r = self
.convert_tp_into_ty(r.clone())
.unwrap_or_else(|_| todo!("{r} cannot be a type"));
self.sub_unify(l, &r, loc, None)?;
Ok(())
}
(TyParam::Array(ls), TyParam::Array(rs)) | (TyParam::Tuple(ls), TyParam::Tuple(rs)) => {
for (l, r) in ls.iter().zip(rs.iter()) {
self.sub_unify_tp(l, r, _variance, loc, allow_divergence)?;
}
Ok(())
}
(TyParam::Dict(ls), TyParam::Dict(rs)) => {
for (lk, lv) in ls.iter() {
if let Some(rv) = rs.get(lk) {
self.sub_unify_tp(lv, rv, _variance, loc, allow_divergence)?;
} else {
// TODO:
return Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)));
}
}
Ok(())
}
(l, r) => panic!("type-parameter unification failed:\nl:{l}\nr: {r}"),
}
}pub fn checker_bug(
input: Input,
errno: usize,
loc: Location,
fn_name: &str,
line: u32
) -> Self
pub fn no_type_spec_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
pub fn callable_impl_error<'a, C: Locational + Display>(
input: Input,
errno: usize,
callee: &C,
param_ts: impl Iterator<Item = &'a Type>,
caused_by: String
) -> Self
sourcepub fn type_mismatch_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
nth_param: Option<usize>,
expect: &Type,
found: &Type,
candidates: Option<Set<Type>>,
hint: Option<String>
) -> Self
pub fn type_mismatch_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
nth_param: Option<usize>,
expect: &Type,
found: &Type,
candidates: Option<Set<Type>>,
hint: Option<String>
) -> Self
Examples found in repository?
lower.rs (lines 165-176)
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
fn var_result_t_check(
&self,
loc: Location,
name: &Str,
expect: &Type,
found: &Type,
) -> SingleLowerResult<()> {
self.ctx
.sub_unify(found, expect, loc, Some(name))
.map_err(|_| {
LowerError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
name,
None,
expect,
found,
self.ctx.get_candidates(found),
Context::get_simple_type_mismatch_hint(expect, found),
)
})
}
/// OK: exec `i: Int`
/// OK: exec `i: Int = 1`
/// NG: exec `1 + 2`
/// OK: exec `None`
fn use_check(&self, expr: &hir::Expr, mode: &str) -> LowerResult<()> {
if mode != "eval" && !expr.ref_t().is_nonelike() && !expr.is_type_asc() {
Err(LowerWarnings::from(LowerWarning::unused_expr_warning(
self.cfg.input.clone(),
line!() as usize,
expr,
String::from(&self.ctx.name[..]),
)))
} else {
self.block_use_check(expr, mode)
}
}
fn block_use_check(&self, expr: &hir::Expr, mode: &str) -> LowerResult<()> {
let mut warns = LowerWarnings::empty();
match expr {
hir::Expr::Def(def) => {
let last = def.body.block.len() - 1;
for (i, chunk) in def.body.block.iter().enumerate() {
if i == last {
if let Err(ws) = self.block_use_check(chunk, mode) {
warns.extend(ws);
}
break;
}
if let Err(ws) = self.use_check(chunk, mode) {
warns.extend(ws);
}
}
}
hir::Expr::Lambda(lambda) => {
let last = lambda.body.len() - 1;
for (i, chunk) in lambda.body.iter().enumerate() {
if i == last {
if let Err(ws) = self.block_use_check(chunk, mode) {
warns.extend(ws);
}
break;
}
if let Err(ws) = self.use_check(chunk, mode) {
warns.extend(ws);
}
}
}
hir::Expr::ClassDef(class_def) => {
for chunk in class_def.methods.iter() {
if let Err(ws) = self.use_check(chunk, mode) {
warns.extend(ws);
}
}
}
hir::Expr::PatchDef(patch_def) => {
for chunk in patch_def.methods.iter() {
if let Err(ws) = self.use_check(chunk, mode) {
warns.extend(ws);
}
}
}
hir::Expr::Call(call) => {
for arg in call.args.pos_args.iter() {
if let Err(ws) = self.block_use_check(&arg.expr, mode) {
warns.extend(ws);
}
}
if let Some(var_args) = &call.args.var_args {
if let Err(ws) = self.block_use_check(&var_args.expr, mode) {
warns.extend(ws);
}
}
for arg in call.args.kw_args.iter() {
if let Err(ws) = self.block_use_check(&arg.expr, mode) {
warns.extend(ws);
}
}
}
// TODO: unary, binary, array, ...
_ => {}
}
if warns.is_empty() {
Ok(())
} else {
Err(warns)
}
}
fn pop_append_errs(&mut self) {
if let Err(mut errs) = self.ctx.check_decls_and_pop() {
self.errs.append(&mut errs);
}
}
pub fn pop_mod_ctx(&mut self) -> Option<Context> {
self.ctx.pop_mod()
}
pub fn pop_mod_ctx_or_default(&mut self) -> Context {
std::mem::take(&mut self.ctx)
}
pub fn get_mod_ctx(&self) -> &Context {
&self.ctx
}
pub fn dir(&self) -> Vec<(&VarName, &VarInfo)> {
ContextProvider::dir(self)
}
pub fn get_receiver_ctx(&self, receiver_name: &str) -> Option<&Context> {
ContextProvider::get_receiver_ctx(self, receiver_name)
}
pub fn get_var_info(&self, name: &str) -> Option<(&VarName, &VarInfo)> {
ContextProvider::get_var_info(self, name)
}
}
impl ASTLowerer {
fn lower_literal(&self, lit: ast::Literal) -> LowerResult<hir::Literal> {
let loc = lit.loc();
let lit = hir::Literal::try_from(lit.token).map_err(|_| {
LowerError::invalid_literal(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
)
})?;
Ok(lit)
}
fn lower_array(&mut self, array: ast::Array) -> LowerResult<hir::Array> {
log!(info "entered {}({array})", fn_name!());
match array {
ast::Array::Normal(arr) => Ok(hir::Array::Normal(self.lower_normal_array(arr)?)),
ast::Array::WithLength(arr) => {
Ok(hir::Array::WithLength(self.lower_array_with_length(arr)?))
}
other => feature_error!(
LowerErrors,
LowerError,
self.ctx,
other.loc(),
"array comprehension"
),
}
}
fn elem_err(&self, l: &Type, r: &Type, elem: &hir::Expr) -> LowerErrors {
let elem_disp_notype = elem.to_string_notype();
let l = Context::readable_type(l);
let r = Context::readable_type(r);
LowerErrors::from(LowerError::syntax_error(
self.cfg.input.clone(),
line!() as usize,
elem.loc(),
String::from(&self.ctx.name[..]),
switch_lang!(
"japanese" => "配列の要素は全て同じ型である必要があります",
"simplified_chinese" => "数组元素必须全部是相同类型",
"traditional_chinese" => "數組元素必須全部是相同類型",
"english" => "all elements of an array must be of the same type",
)
.to_owned(),
Some(switch_lang!(
"japanese" => format!("[..., {elem_disp_notype}: {l} or {r}]など明示的に型を指定してください"),
"simplified_chinese" => format!("请明确指定类型，例如: [..., {elem_disp_notype}: {l} or {r}]"),
"traditional_chinese" => format!("請明確指定類型，例如: [..., {elem_disp_notype}: {l} or {r}]"),
"english" => format!("please specify the type explicitly, e.g. [..., {elem_disp_notype}: {l} or {r}]"),
)),
))
}
fn lower_normal_array(&mut self, array: ast::NormalArray) -> LowerResult<hir::NormalArray> {
log!(info "entered {}({array})", fn_name!());
let mut new_array = vec![];
let (elems, _) = array.elems.into_iters();
let mut union = Type::Never;
for elem in elems {
let elem = self.lower_expr(elem.expr)?;
union = self.ctx.union(&union, elem.ref_t());
if let Some((l, r)) = union.union_types() {
match (l.is_unbound_var(), r.is_unbound_var()) {
(false, false) => {
return Err(self.elem_err(&l, &r, &elem));
}
// TODO: check if the type is compatible with the other type
(true, false) => {}
(false, true) => {}
(true, true) => {}
}
}
new_array.push(elem);
}
let elem_t = if union == Type::Never {
free_var(self.ctx.level, Constraint::new_type_of(Type::Type))
} else {
union
};
Ok(hir::NormalArray::new(
array.l_sqbr,
array.r_sqbr,
elem_t,
hir::Args::values(new_array, None),
))
}
fn lower_array_with_length(
&mut self,
array: ast::ArrayWithLength,
) -> LowerResult<hir::ArrayWithLength> {
log!(info "entered {}({array})", fn_name!());
let elem = self.lower_expr(array.elem.expr)?;
let array_t = self.gen_array_with_length_type(&elem, &array.len);
let len = self.lower_expr(*array.len)?;
let hir_array = hir::ArrayWithLength::new(array.l_sqbr, array.r_sqbr, array_t, elem, len);
Ok(hir_array)
}
fn gen_array_with_length_type(&self, elem: &hir::Expr, len: &ast::Expr) -> Type {
let maybe_len = self.ctx.eval_const_expr(len);
match maybe_len {
Ok(v @ ValueObj::Nat(_)) => {
if elem.ref_t().is_mut_type() {
poly(
"ArrayWithMutType!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else {
array_t(elem.t(), TyParam::Value(v))
}
}
Ok(v @ ValueObj::Mut(_)) if v.class() == mono("Nat!") => {
if elem.ref_t().is_mut_type() {
poly(
"ArrayWithMutTypeAndLength!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else {
array_mut(elem.t(), TyParam::Value(v))
}
}
Ok(other) => todo!("{other} is not a Nat object"),
// REVIEW: is it ok to ignore the error?
Err(_e) => {
if elem.ref_t().is_mut_type() {
poly(
"ArrayWithMutType!",
vec![TyParam::t(elem.t()), TyParam::erased(Type::Nat)],
)
} else {
array_t(elem.t(), TyParam::erased(Type::Nat))
}
}
}
}
fn lower_tuple(&mut self, tuple: ast::Tuple) -> LowerResult<hir::Tuple> {
log!(info "entered {}({tuple})", fn_name!());
match tuple {
ast::Tuple::Normal(tup) => Ok(hir::Tuple::Normal(self.lower_normal_tuple(tup)?)),
}
}
fn lower_normal_tuple(&mut self, tuple: ast::NormalTuple) -> LowerResult<hir::NormalTuple> {
log!(info "entered {}({tuple})", fn_name!());
let mut new_tuple = vec![];
let (elems, .., paren) = tuple.elems.deconstruct();
for elem in elems {
let elem = self.lower_expr(elem.expr)?;
new_tuple.push(elem);
}
Ok(hir::NormalTuple::new(hir::Args::values(new_tuple, paren)))
}
fn lower_record(&mut self, record: ast::Record) -> LowerResult<hir::Record> {
log!(info "entered {}({record})", fn_name!());
match record {
ast::Record::Normal(rec) => self.lower_normal_record(rec),
ast::Record::Mixed(_rec) => unreachable!(), // should be desugared
}
}
fn lower_normal_record(&mut self, record: ast::NormalRecord) -> LowerResult<hir::Record> {
log!(info "entered {}({record})", fn_name!());
let mut hir_record =
hir::Record::new(record.l_brace, record.r_brace, hir::RecordAttrs::empty());
self.ctx.grow("<record>", ContextKind::Dummy, Private, None);
for attr in record.attrs.into_iter() {
let attr = self.lower_def(attr).map_err(|e| {
self.pop_append_errs();
e
})?;
hir_record.push(attr);
}
self.pop_append_errs();
Ok(hir_record)
}
fn lower_set(&mut self, set: ast::Set) -> LowerResult<hir::Set> {
log!(info "enter {}({set})", fn_name!());
match set {
ast::Set::Normal(set) => Ok(hir::Set::Normal(self.lower_normal_set(set)?)),
ast::Set::WithLength(set) => Ok(hir::Set::WithLength(self.lower_set_with_length(set)?)),
}
}
fn lower_normal_set(&mut self, set: ast::NormalSet) -> LowerResult<hir::NormalSet> {
log!(info "entered {}({set})", fn_name!());
let (elems, _) = set.elems.into_iters();
let mut union = Type::Never;
let mut new_set = vec![];
for elem in elems {
let elem = self.lower_expr(elem.expr)?;
union = self.ctx.union(&union, elem.ref_t());
if union.is_intersection_type() {
return Err(LowerErrors::from(LowerError::syntax_error(
self.cfg.input.clone(),
line!() as usize,
elem.loc(),
String::from(&self.ctx.name[..]),
switch_lang!(
"japanese" => "集合の要素は全て同じ型である必要があります",
"simplified_chinese" => "集合元素必须全部是相同类型",
"traditional_chinese" => "集合元素必須全部是相同類型",
"english" => "all elements of a set must be of the same type",
)
.to_owned(),
Some(
switch_lang!(
"japanese" => "Int or Strなど明示的に型を指定してください",
"simplified_chinese" => "明确指定类型，例如: Int or Str",
"traditional_chinese" => "明確指定類型，例如: Int or Str",
"english" => "please specify the type explicitly, e.g. Int or Str",
)
.to_owned(),
),
)));
}
new_set.push(elem);
}
let elem_t = if union == Type::Never {
free_var(self.ctx.level, Constraint::new_type_of(Type::Type))
} else {
union
};
// TODO: lint
/*
if is_duplicated {
self.warns.push(LowerWarning::syntax_error(
self.cfg.input.clone(),
line!() as usize,
normal_set.loc(),
String::arc(&self.ctx.name[..]),
switch_lang!(
"japanese" => "要素が重複しています",
"simplified_chinese" => "元素重复",
"traditional_chinese" => "元素重複",
"english" => "Elements are duplicated",
),
None,
));
}
Ok(normal_set)
*/
let elems = hir::Args::values(new_set, None);
// check if elem_t is Eq
if let Err(errs) = self.ctx.sub_unify(&elem_t, &mono("Eq"), elems.loc(), None) {
self.errs.extend(errs);
}
Ok(hir::NormalSet::new(set.l_brace, set.r_brace, elem_t, elems))
}
/// This (e.g. {"a"; 3}) is meaningless as an object, but makes sense as a type (e.g. {Int; 3}).
fn lower_set_with_length(
&mut self,
set: ast::SetWithLength,
) -> LowerResult<hir::SetWithLength> {
log!("entered {}({set})", fn_name!());
let elem = self.lower_expr(set.elem.expr)?;
let set_t = self.gen_set_with_length_type(&elem, &set.len);
let len = self.lower_expr(*set.len)?;
let hir_set = hir::SetWithLength::new(set.l_brace, set.r_brace, set_t, elem, len);
Ok(hir_set)
}
fn gen_set_with_length_type(&mut self, elem: &hir::Expr, len: &ast::Expr) -> Type {
let maybe_len = self.ctx.eval_const_expr(len);
match maybe_len {
Ok(v @ ValueObj::Nat(_)) => {
if elem.ref_t().is_mut_type() {
poly(
"SetWithMutType!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else if self.ctx.subtype_of(&elem.t(), &Type::Type) {
poly("SetType", vec![TyParam::t(elem.t()), TyParam::Value(v)])
} else {
set_t(elem.t(), TyParam::Value(v))
}
}
Ok(v @ ValueObj::Mut(_)) if v.class() == mono("Nat!") => {
if elem.ref_t().is_mut_type() {
poly(
"SetWithMutTypeAndLength!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else {
set_mut(elem.t(), TyParam::Value(v))
}
}
Ok(other) => todo!("{other} is not a Nat object"),
Err(_e) => {
if elem.ref_t().is_mut_type() {
poly(
"SetWithMutType!",
vec![TyParam::t(elem.t()), TyParam::erased(Type::Nat)],
)
} else {
set_t(elem.t(), TyParam::erased(Type::Nat))
}
}
}
}
fn lower_dict(&mut self, dict: ast::Dict) -> LowerResult<hir::Dict> {
log!(info "enter {}({dict})", fn_name!());
match dict {
ast::Dict::Normal(set) => Ok(hir::Dict::Normal(self.lower_normal_dict(set)?)),
other => feature_error!(
LowerErrors,
LowerError,
self.ctx,
other.loc(),
"dict comprehension"
),
// ast::Dict::WithLength(set) => Ok(hir::Dict::WithLength(self.lower_dict_with_length(set)?)),
}
}
fn lower_normal_dict(&mut self, dict: ast::NormalDict) -> LowerResult<hir::NormalDict> {
log!(info "enter {}({dict})", fn_name!());
let mut union = dict! {};
let mut new_kvs = vec![];
for kv in dict.kvs {
let loc = kv.loc();
let key = self.lower_expr(kv.key)?;
let value = self.lower_expr(kv.value)?;
if union.insert(key.t(), value.t()).is_some() {
return Err(LowerErrors::from(LowerError::syntax_error(
self.cfg.input.clone(),
line!() as usize,
loc,
String::from(&self.ctx.name[..]),
switch_lang!(
"japanese" => "Dictの値は全て同じ型である必要があります",
"simplified_chinese" => "Dict的值必须是同一类型",
"traditional_chinese" => "Dict的值必須是同一類型",
"english" => "Values of Dict must be the same type",
)
.to_owned(),
Some(
switch_lang!(
"japanese" => "Int or Strなど明示的に型を指定してください",
"simplified_chinese" => "明确指定类型，例如: Int or Str",
"traditional_chinese" => "明確指定類型，例如: Int or Str",
"english" => "please specify the type explicitly, e.g. Int or Str",
)
.to_owned(),
),
)));
}
new_kvs.push(hir::KeyValue::new(key, value));
}
for key_t in union.keys() {
let loc = Location::concat(&dict.l_brace, &dict.r_brace);
// check if key_t is Eq
if let Err(errs) = self.ctx.sub_unify(key_t, &mono("Eq"), loc, None) {
self.errs.extend(errs);
}
}
let kv_ts = if union.is_empty() {
dict! {
ty_tp(free_var(self.ctx.level, Constraint::new_type_of(Type::Type))) =>
ty_tp(free_var(self.ctx.level, Constraint::new_type_of(Type::Type)))
}
} else {
union
.into_iter()
.map(|(k, v)| (TyParam::t(k), TyParam::t(v)))
.collect()
};
// TODO: lint
/*
if is_duplicated {
self.warns.push(LowerWarning::syntax_error(
self.cfg.input.clone(),
line!() as usize,
normal_set.loc(),
String::arc(&self.ctx.name[..]),
switch_lang!(
"japanese" => "要素が重複しています",
"simplified_chinese" => "元素重复",
"traditional_chinese" => "元素重複",
"english" => "Elements are duplicated",
),
None,
));
}
Ok(normal_set)
*/
Ok(hir::NormalDict::new(
dict.l_brace,
dict.r_brace,
kv_ts,
new_kvs,
))
}
fn lower_acc(&mut self, acc: ast::Accessor) -> LowerResult<hir::Accessor> {
log!(info "entered {}({acc})", fn_name!());
match acc {
ast::Accessor::Ident(ident) => {
let ident = self.lower_ident(ident)?;
let acc = hir::Accessor::Ident(ident);
Ok(acc)
}
ast::Accessor::Attr(attr) => {
let obj = self.lower_expr(*attr.obj)?;
let vi = self.ctx.rec_get_attr_info(
&obj,
&attr.ident,
&self.cfg.input,
&self.ctx.name,
)?;
let ident = hir::Identifier::new(attr.ident.dot, attr.ident.name, None, vi);
let acc = hir::Accessor::Attr(hir::Attribute::new(obj, ident));
Ok(acc)
}
ast::Accessor::TypeApp(t_app) => feature_error!(
LowerErrors,
LowerError,
self.ctx,
t_app.loc(),
"type application"
),
// TupleAttr, Subscr are desugared
_ => unreachable_error!(LowerErrors, LowerError, self.ctx),
}
}
fn lower_ident(&self, ident: ast::Identifier) -> LowerResult<hir::Identifier> {
// `match` is a special form, typing is magic
let (vi, __name__) = if ident.vis().is_private()
&& (&ident.inspect()[..] == "match" || &ident.inspect()[..] == "match!")
{
(
VarInfo {
t: mono("GenericCallable"),
..VarInfo::default()
},
None,
)
} else {
(
self.ctx.rec_get_var_info(
&ident,
AccessKind::Name,
&self.cfg.input,
&self.ctx.name,
)?,
self.ctx
.get_singular_ctx_by_ident(&ident, &self.ctx.name)
.ok()
.map(|ctx| ctx.name.clone()),
)
};
let ident = hir::Identifier::new(ident.dot, ident.name, __name__, vi);
Ok(ident)
}
fn lower_bin(&mut self, bin: ast::BinOp) -> LowerResult<hir::BinOp> {
log!(info "entered {}({bin})", fn_name!());
let mut args = bin.args.into_iter();
let lhs = hir::PosArg::new(self.lower_expr(*args.next().unwrap())?);
let rhs = hir::PosArg::new(self.lower_expr(*args.next().unwrap())?);
let args = [lhs, rhs];
let t = self
.ctx
.get_binop_t(&bin.op, &args, &self.cfg.input, &self.ctx.name)?;
let mut args = args.into_iter();
let lhs = args.next().unwrap().expr;
let rhs = args.next().unwrap().expr;
Ok(hir::BinOp::new(bin.op, lhs, rhs, t))
}
fn lower_unary(&mut self, unary: ast::UnaryOp) -> LowerResult<hir::UnaryOp> {
log!(info "entered {}({unary})", fn_name!());
let mut args = unary.args.into_iter();
let arg = hir::PosArg::new(self.lower_expr(*args.next().unwrap())?);
let args = [arg];
let t = self
.ctx
.get_unaryop_t(&unary.op, &args, &self.cfg.input, &self.ctx.name)?;
let mut args = args.into_iter();
let expr = args.next().unwrap().expr;
Ok(hir::UnaryOp::new(unary.op, expr, t))
}
pub(crate) fn lower_call(&mut self, call: ast::Call) -> LowerResult<hir::Call> {
log!(info "entered {}({}{}(...))", fn_name!(), call.obj, fmt_option!(call.attr_name));
let mut errs = LowerErrors::empty();
let opt_cast_to = if call.is_assert_cast() {
if let Some(typ) = call.assert_cast_target_type() {
Some(Parser::expr_to_type_spec(typ.clone()).map_err(|e| {
let e = LowerError::new(e.into(), self.input().clone(), self.ctx.caused_by());
LowerErrors::from(e)
})?)
} else {
return Err(LowerErrors::from(LowerError::syntax_error(
self.input().clone(),
line!() as usize,
call.args.loc(),
self.ctx.caused_by(),
"invalid assert casting type".to_owned(),
None,
)));
}
} else {
None
};
let (pos_args, kw_args, paren) = call.args.deconstruct();
let mut hir_args = hir::Args::new(
Vec::with_capacity(pos_args.len()),
None,
Vec::with_capacity(kw_args.len()),
paren,
);
for arg in pos_args.into_iter() {
match self.lower_expr(arg.expr) {
Ok(expr) => hir_args.pos_args.push(hir::PosArg::new(expr)),
Err(es) => errs.extend(es),
}
}
for arg in kw_args.into_iter() {
match self.lower_expr(arg.expr) {
Ok(expr) => hir_args.push_kw(hir::KwArg::new(arg.keyword, expr)),
Err(es) => errs.extend(es),
}
}
let mut obj = match self.lower_expr(*call.obj) {
Ok(obj) => obj,
Err(es) => {
errs.extend(es);
return Err(errs);
}
};
// Calling get_call_t with incorrect arguments does not provide meaningful information
if !errs.is_empty() {
return Err(errs);
}
let vi = match self.ctx.get_call_t(
&obj,
&call.attr_name,
&hir_args.pos_args,
&hir_args.kw_args,
&self.cfg.input,
&self.ctx.name,
) {
Ok(vi) => vi,
Err(es) => {
errs.extend(es);
return Err(errs);
}
};
let attr_name = if let Some(attr_name) = call.attr_name {
Some(hir::Identifier::new(
attr_name.dot,
attr_name.name,
None,
vi,
))
} else {
*obj.ref_mut_t() = vi.t;
None
};
let mut call = hir::Call::new(obj, attr_name, hir_args);
match call.additional_operation() {
Some(kind @ (OperationKind::Import | OperationKind::PyImport)) => {
let mod_name =
enum_unwrap!(call.args.get_left_or_key("Path").unwrap(), hir::Expr::Lit);
if let Err(errs) = self.ctx.import_mod(kind, mod_name) {
self.errs.extend(errs);
};
}
Some(OperationKind::Del) => match call.args.get_left_or_key("obj").unwrap() {
hir::Expr::Accessor(hir::Accessor::Ident(ident)) => {
self.ctx.del(ident)?;
}
other => {
return Err(LowerErrors::from(LowerError::syntax_error(
self.input().clone(),
line!() as usize,
other.loc(),
self.ctx.caused_by(),
"".to_owned(),
None,
)))
}
},
Some(OperationKind::Return | OperationKind::Yield) => {
// (f: ?T -> ?U).return: (self: GenericCallable, arg: Obj) -> Never
let callable_t = call.obj.ref_t();
let ret_t = match callable_t {
Type::Subr(subr) => *subr.return_t.clone(),
Type::FreeVar(fv) if fv.is_unbound() => {
fv.get_sub().unwrap().return_t().unwrap().clone()
}
other => todo!("{other:?}"),
};
let arg_t = call.args.get(0).unwrap().ref_t();
self.ctx.sub_unify(arg_t, &ret_t, call.loc(), None)?;
}
_ => {
if let Some(type_spec) = opt_cast_to {
self.ctx.cast(type_spec, &mut call)?;
}
}
}
if errs.is_empty() {
Ok(call)
} else {
Err(errs)
}
}
fn lower_pack(&mut self, pack: ast::DataPack) -> LowerResult<hir::Call> {
log!(info "entered {}({pack})", fn_name!());
let class = self.lower_expr(*pack.class)?;
let args = self.lower_record(pack.args)?;
let args = vec![hir::PosArg::new(hir::Expr::Record(args))];
let attr_name = ast::Identifier::new(
Some(Token::new(
TokenKind::Dot,
Str::ever("."),
pack.connector.lineno,
pack.connector.col_begin,
)),
ast::VarName::new(Token::new(
TokenKind::Symbol,
Str::ever("new"),
pack.connector.lineno,
pack.connector.col_begin,
)),
);
let vi = self.ctx.get_call_t(
&class,
&Some(attr_name.clone()),
&args,
&[],
&self.cfg.input,
&self.ctx.name,
)?;
let args = hir::Args::new(args, None, vec![], None);
let attr_name = hir::Identifier::new(attr_name.dot, attr_name.name, None, vi);
Ok(hir::Call::new(class, Some(attr_name), args))
}
fn lower_params(&mut self, params: ast::Params) -> LowerResult<hir::Params> {
log!(info "entered {}({})", fn_name!(), params);
let mut errs = LowerErrors::empty();
let mut hir_defaults = vec![];
for default in params.defaults.into_iter() {
match self.lower_expr(default.default_val) {
Ok(default_val) => {
hir_defaults.push(hir::DefaultParamSignature::new(default.sig, default_val));
}
Err(es) => errs.extend(es),
}
}
if !errs.is_empty() {
Err(errs)
} else {
let hir_params = hir::Params::new(
params.non_defaults,
params.var_args,
hir_defaults,
params.parens,
);
Ok(hir_params)
}
}
/// TODO: varargs
fn lower_lambda(&mut self, lambda: ast::Lambda) -> LowerResult<hir::Lambda> {
log!(info "entered {}({lambda})", fn_name!());
let is_procedural = lambda.is_procedural();
let id = get_hash(&lambda.sig);
let name = format!("<lambda_{id}>");
let kind = if is_procedural {
ContextKind::Proc
} else {
ContextKind::Func
};
let tv_cache = self
.ctx
.instantiate_ty_bounds(&lambda.sig.bounds, RegistrationMode::Normal)?;
self.ctx.grow(&name, kind, Private, Some(tv_cache));
let params = self.lower_params(lambda.sig.params).map_err(|errs| {
self.pop_append_errs();
errs
})?;
if let Err(errs) = self.ctx.assign_params(¶ms, None) {
self.errs.extend(errs);
}
if let Err(errs) = self.ctx.preregister(&lambda.body) {
self.errs.extend(errs);
}
let body = self.lower_block(lambda.body).map_err(|e| {
self.pop_append_errs();
e
})?;
let (non_default_params, default_params): (Vec<_>, Vec<_>) = self
.ctx
.params
.iter()
.partition(|(_, v)| !v.kind.has_default());
let non_default_params = non_default_params
.into_iter()
.map(|(name, vi)| {
ParamTy::pos(name.as_ref().map(|n| n.inspect().clone()), vi.t.clone())
})
.collect();
let default_params = default_params
.into_iter()
.map(|(name, vi)| ParamTy::kw(name.as_ref().unwrap().inspect().clone(), vi.t.clone()))
.collect();
self.pop_append_errs();
let t = if is_procedural {
proc(non_default_params, None, default_params, body.t())
} else {
func(non_default_params, None, default_params, body.t())
};
let t = if t.has_qvar() { t.quantify() } else { t };
Ok(hir::Lambda::new(id, params, lambda.op, body, t))
}
fn lower_def(&mut self, def: ast::Def) -> LowerResult<hir::Def> {
log!(info "entered {}({})", fn_name!(), def.sig);
if def.def_kind().is_class_or_trait() && self.ctx.kind != ContextKind::Module {
self.ctx.decls.remove(def.sig.ident().unwrap().inspect());
return Err(LowerErrors::from(LowerError::inner_typedef_error(
self.cfg.input.clone(),
line!() as usize,
def.loc(),
self.ctx.caused_by(),
)));
}
let name = if let Some(name) = def.sig.name_as_str() {
name.clone()
} else {
Str::ever("<lambda>")
};
if self
.ctx
.registered_info(&name, def.sig.is_const())
.is_some()
&& def.sig.vis().is_private()
{
return Err(LowerErrors::from(LowerError::reassign_error(
self.cfg.input.clone(),
line!() as usize,
def.sig.loc(),
self.ctx.caused_by(),
&name,
)));
}
let kind = ContextKind::from(def.def_kind());
let vis = def.sig.vis();
let res = match def.sig {
ast::Signature::Subr(sig) => {
let tv_cache = self
.ctx
.instantiate_ty_bounds(&sig.bounds, RegistrationMode::Normal)?;
self.ctx.grow(&name, kind, vis, Some(tv_cache));
self.lower_subr_def(sig, def.body)
}
ast::Signature::Var(sig) => {
self.ctx.grow(&name, kind, vis, None);
self.lower_var_def(sig, def.body)
}
};
// TODO: Context上の関数に型境界情報を追加
self.pop_append_errs();
// remove from decls regardless of success or failure to lower
self.ctx.decls.remove(&name);
res
}
fn lower_var_def(
&mut self,
sig: ast::VarSignature,
body: ast::DefBody,
) -> LowerResult<hir::Def> {
log!(info "entered {}({sig})", fn_name!());
if let Err(errs) = self.ctx.preregister(&body.block) {
self.errs.extend(errs);
}
match self.lower_block(body.block) {
Ok(block) => {
let found_body_t = block.ref_t();
let outer = self.ctx.outer.as_ref().unwrap();
let opt_expect_body_t = sig
.inspect()
.and_then(|name| outer.get_current_scope_var(name).map(|vi| vi.t.clone()));
let ident = match &sig.pat {
ast::VarPattern::Ident(ident) => ident,
ast::VarPattern::Discard(_) => ast::Identifier::UBAR,
_ => unreachable!(),
};
if let Some(expect_body_t) = opt_expect_body_t {
// TODO: expect_body_t is smaller for constants
// TODO: 定数の場合、expect_body_tのほうが小さくなってしまう
if !sig.is_const() {
if let Err(e) = self.var_result_t_check(
sig.loc(),
ident.inspect(),
&expect_body_t,
found_body_t,
) {
self.errs.push(e);
}
}
}
self.ctx.outer.as_mut().unwrap().assign_var_sig(
&sig,
found_body_t,
body.id,
None,
)?;
let mut ident = hir::Identifier::bare(ident.dot.clone(), ident.name.clone());
ident.vi.t = found_body_t.clone();
let sig = hir::VarSignature::new(ident);
let body = hir::DefBody::new(body.op, block, body.id);
Ok(hir::Def::new(hir::Signature::Var(sig), body))
}
Err(errs) => {
self.ctx.outer.as_mut().unwrap().assign_var_sig(
&sig,
&Type::Failure,
ast::DefId(0),
None,
)?;
Err(errs)
}
}
}
// NOTE: 呼ばれている間はinner scopeなので注意
fn lower_subr_def(
&mut self,
sig: ast::SubrSignature,
body: ast::DefBody,
) -> LowerResult<hir::Def> {
log!(info "entered {}({sig})", fn_name!());
let t = self
.ctx
.outer
.as_ref()
.unwrap()
.get_current_scope_var(sig.ident.inspect())
.map(|vi| vi.t.clone())
.unwrap_or(Type::Failure);
match t {
Type::Subr(subr_t) => {
let params = self.lower_params(sig.params.clone())?;
if let Err(errs) = self.ctx.assign_params(¶ms, Some(subr_t)) {
self.errs.extend(errs);
}
if let Err(errs) = self.ctx.preregister(&body.block) {
self.errs.extend(errs);
}
match self.lower_block(body.block) {
Ok(block) => {
let found_body_t = block.ref_t();
let t = self.ctx.outer.as_mut().unwrap().assign_subr(
&sig,
body.id,
found_body_t,
)?;
let return_t = t.return_t().unwrap();
if return_t.union_types().is_some() && sig.return_t_spec.is_none() {
let warn = LowerWarning::union_return_type_warning(
self.input().clone(),
line!() as usize,
sig.loc(),
self.ctx.caused_by(),
sig.ident.inspect(),
&Context::readable_type(return_t),
);
self.warns.push(warn);
}
let mut ident = hir::Identifier::bare(sig.ident.dot, sig.ident.name);
ident.vi.t = t;
let sig = hir::SubrSignature::new(ident, params);
let body = hir::DefBody::new(body.op, block, body.id);
Ok(hir::Def::new(hir::Signature::Subr(sig), body))
}
Err(errs) => {
self.ctx.outer.as_mut().unwrap().assign_subr(
&sig,
ast::DefId(0),
&Type::Failure,
)?;
Err(errs)
}
}
}
Type::Failure => {
let params = self.lower_params(sig.params)?;
if let Err(errs) = self.ctx.assign_params(¶ms, None) {
self.errs.extend(errs);
}
if let Err(errs) = self.ctx.preregister(&body.block) {
self.errs.extend(errs);
}
self.ctx.outer.as_mut().unwrap().fake_subr_assign(
&sig.ident,
&sig.decorators,
Type::Failure,
)?;
let block = self.lower_block(body.block)?;
let ident = hir::Identifier::bare(sig.ident.dot, sig.ident.name);
let sig = hir::SubrSignature::new(ident, params);
let body = hir::DefBody::new(body.op, block, body.id);
Ok(hir::Def::new(hir::Signature::Subr(sig), body))
}
_ => unreachable_error!(LowerErrors, LowerError, self),
}
}
fn lower_class_def(&mut self, class_def: ast::ClassDef) -> LowerResult<hir::ClassDef> {
log!(info "entered {}({class_def})", fn_name!());
let mut hir_def = self.lower_def(class_def.def)?;
let mut hir_methods = hir::Block::empty();
let mut dummy_tv_cache = TyVarCache::new(self.ctx.level, &self.ctx);
for mut methods in class_def.methods_list.into_iter() {
let (class, impl_trait) = match &methods.class {
ast::TypeSpec::TypeApp { spec, args } => {
let (impl_trait, loc) = match &args.args.pos_args().first().unwrap().expr {
// TODO: check `tasc.op`
ast::Expr::TypeAsc(tasc) => (
self.ctx.instantiate_typespec(
&tasc.t_spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
tasc.t_spec.loc(),
),
_ => return unreachable_error!(LowerErrors, LowerError, self),
};
(
self.ctx.instantiate_typespec(
spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
Some((impl_trait, loc)),
)
}
other => (
self.ctx.instantiate_typespec(
other,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
None,
),
};
// assume the class has implemented the trait, regardless of whether the implementation is correct
if let Some((trait_, trait_loc)) = &impl_trait {
self.register_trait_impl(&class, trait_, *trait_loc)?;
}
if let Some((_, class_root)) = self.ctx.get_nominal_type_ctx(&class) {
if !class_root.kind.is_class() {
return Err(LowerErrors::from(LowerError::method_definition_error(
self.cfg.input.clone(),
line!() as usize,
methods.loc(),
self.ctx.caused_by(),
&class.qual_name(),
None,
)));
}
} else {
return Err(LowerErrors::from(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
methods.class.loc(),
self.ctx.caused_by(),
&class.qual_name(),
self.ctx.get_similar_name(&class.local_name()),
)));
}
let kind = ContextKind::MethodDefs(impl_trait.as_ref().map(|(t, _)| t.clone()));
let vis = if self.cfg.python_compatible_mode {
Public
} else {
Private
};
self.ctx.grow(&class.local_name(), kind, vis, None);
for attr in methods.attrs.iter_mut() {
match attr {
ast::ClassAttr::Def(def) => {
if methods.vis.is(TokenKind::Dot) {
def.sig.ident_mut().unwrap().dot = Some(Token::new(
TokenKind::Dot,
".",
def.sig.ln_begin().unwrap_or(0),
def.sig.col_begin().unwrap_or(0),
));
}
self.ctx.preregister_def(def).map_err(|errs| {
self.pop_append_errs();
errs
})?;
}
ast::ClassAttr::Decl(_decl) => {}
}
}
for attr in methods.attrs.into_iter() {
match attr {
ast::ClassAttr::Def(def) => match self.lower_def(def) {
Ok(def) => {
hir_methods.push(hir::Expr::Def(def));
}
Err(errs) => {
self.errs.extend(errs);
}
},
ast::ClassAttr::Decl(decl) => {
let decl = self.lower_type_asc(decl)?;
hir_methods.push(hir::Expr::TypeAsc(decl));
}
}
}
if let Err(mut errs) = self.ctx.check_decls() {
self.errs.append(&mut errs);
}
if let Some((trait_, _)) = &impl_trait {
self.check_override(&class, Some(trait_));
} else {
self.check_override(&class, None);
}
if let Err(err) = self.check_trait_impl(impl_trait, &class) {
self.errs.push(err);
}
self.check_collision_and_push(class);
}
let class = mono(hir_def.sig.ident().inspect());
let Some((_, class_ctx)) = self.ctx.get_nominal_type_ctx(&class) else {
return Err(LowerErrors::from(LowerError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
hir_def.sig.loc(),
self.ctx.caused_by(),
&class,
)));
};
let type_obj = enum_unwrap!(self.ctx.rec_get_const_obj(hir_def.sig.ident().inspect()).unwrap(), ValueObj::Type:(TypeObj::Generated:(_)));
let sup_type = enum_unwrap!(&hir_def.body.block.first().unwrap(), hir::Expr::Call)
.args
.get_left_or_key("Super")
.unwrap();
Self::check_inheritable(&self.cfg, &mut self.errs, type_obj, sup_type, &hir_def.sig);
// vi.t.non_default_params().unwrap()[0].typ().clone()
let (__new__, need_to_gen_new) = if let (Some(dunder_new_vi), Some(new_vi)) = (
class_ctx.get_current_scope_var("__new__"),
class_ctx.get_current_scope_var("new"),
) {
(dunder_new_vi.t.clone(), new_vi.kind == VarKind::Auto)
} else {
return unreachable_error!(LowerErrors, LowerError, self);
};
let require_or_sup = self.get_require_or_sup_or_base(hir_def.body.block.remove(0));
Ok(hir::ClassDef::new(
type_obj.clone(),
hir_def.sig,
require_or_sup,
need_to_gen_new,
__new__,
hir_methods,
))
}
fn lower_patch_def(&mut self, class_def: ast::PatchDef) -> LowerResult<hir::PatchDef> {
log!(info "entered {}({class_def})", fn_name!());
let base_t = {
let base_t_expr =
enum_unwrap!(class_def.def.body.block.get(0).unwrap(), ast::Expr::Call)
.args
.get_left_or_key("Base")
.unwrap();
let spec = Parser::expr_to_type_spec(base_t_expr.clone()).unwrap();
let mut dummy_tv_cache = TyVarCache::new(self.ctx.level, &self.ctx);
self.ctx.instantiate_typespec(
&spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?
};
let mut hir_def = self.lower_def(class_def.def)?;
let base = self.get_require_or_sup_or_base(hir_def.body.block.remove(0));
let mut hir_methods = hir::Block::empty();
for mut methods in class_def.methods_list.into_iter() {
let kind = ContextKind::PatchMethodDefs(base_t.clone());
self.ctx
.grow(hir_def.sig.ident().inspect(), kind, hir_def.sig.vis(), None);
for attr in methods.attrs.iter_mut() {
match attr {
ast::ClassAttr::Def(def) => {
if methods.vis.is(TokenKind::Dot) {
def.sig.ident_mut().unwrap().dot = Some(Token::new(
TokenKind::Dot,
".",
def.sig.ln_begin().unwrap(),
def.sig.col_begin().unwrap(),
));
}
self.ctx.preregister_def(def).map_err(|errs| {
self.pop_append_errs();
errs
})?;
}
ast::ClassAttr::Decl(_decl) => {}
}
}
for attr in methods.attrs.into_iter() {
match attr {
ast::ClassAttr::Def(def) => match self.lower_def(def) {
Ok(def) => {
hir_methods.push(hir::Expr::Def(def));
}
Err(errs) => {
self.errs.extend(errs);
}
},
ast::ClassAttr::Decl(decl) => {
let decl = self.lower_type_asc(decl)?;
hir_methods.push(hir::Expr::TypeAsc(decl));
}
}
}
if let Err(mut errs) = self.ctx.check_decls() {
self.errs.append(&mut errs);
}
self.push_patch();
}
Ok(hir::PatchDef::new(hir_def.sig, base, hir_methods))
}
fn lower_attr_def(&mut self, attr_def: ast::AttrDef) -> LowerResult<hir::AttrDef> {
log!(info "entered {}({attr_def})", fn_name!());
let attr = self.lower_acc(attr_def.attr)?;
let expr = self.lower_expr(*attr_def.expr)?;
if let Err(err) = self.var_result_t_check(
attr.loc(),
&Str::from(attr.show()),
attr.ref_t(),
expr.ref_t(),
) {
self.errs.push(err);
}
Ok(hir::AttrDef::new(attr, hir::Block::new(vec![expr])))
}
fn register_trait_impl(
&mut self,
class: &Type,
trait_: &Type,
trait_loc: Location,
) -> LowerResult<()> {
// TODO: polymorphic trait
if let Some(impls) = self.ctx.trait_impls.get_mut(&trait_.qual_name()) {
impls.insert(TypeRelationInstance::new(class.clone(), trait_.clone()));
} else {
self.ctx.trait_impls.insert(
trait_.qual_name(),
set! {TypeRelationInstance::new(class.clone(), trait_.clone())},
);
}
let trait_ctx = if let Some((_, trait_ctx)) = self.ctx.get_nominal_type_ctx(trait_) {
trait_ctx.clone()
} else {
// TODO: maybe parameters are wrong
return Err(LowerErrors::from(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
trait_loc,
self.ctx.caused_by(),
&trait_.local_name(),
None,
)));
};
let Some((_, class_ctx)) = self.ctx.get_mut_nominal_type_ctx(class) else {
return Err(LowerErrors::from(LowerError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
trait_loc,
self.ctx.caused_by(),
class,
)));
};
class_ctx.register_supertrait(trait_.clone(), &trait_ctx);
Ok(())
}
/// HACK: Cannot be methodized this because `&self` has been taken immediately before.
fn check_inheritable(
cfg: &ErgConfig,
errs: &mut LowerErrors,
type_obj: &GenTypeObj,
sup_class: &hir::Expr,
sub_sig: &hir::Signature,
) {
if let TypeObj::Generated(gen) = type_obj.require_or_sup().unwrap() {
if let Some(impls) = gen.impls() {
if !impls.contains_intersec(&mono("InheritableType")) {
errs.push(LowerError::inheritance_error(
cfg.input.clone(),
line!() as usize,
sup_class.to_string(),
sup_class.loc(),
sub_sig.ident().inspect().into(),
));
}
} else {
errs.push(LowerError::inheritance_error(
cfg.input.clone(),
line!() as usize,
sup_class.to_string(),
sup_class.loc(),
sub_sig.ident().inspect().into(),
));
}
}
}
fn check_override(&mut self, class: &Type, impl_trait: Option<&Type>) {
if let Some(sups) = self.ctx.get_nominal_super_type_ctxs(class) {
// exclude the first one because it is the class itself
for sup in sups.into_iter().skip(1) {
for (method_name, vi) in self.ctx.locals.iter().chain(
self.ctx
.methods_list
.iter()
.flat_map(|(_, c)| c.locals.iter()),
) {
if let Some(sup_vi) = sup.get_current_scope_var(method_name.inspect()) {
// must `@Override`
if let Some(decos) = &vi.comptime_decos {
if decos.contains("Override") {
continue;
}
}
if sup_vi.impl_of.as_ref() != impl_trait {
continue;
}
self.errs.push(LowerError::override_error(
self.cfg.input.clone(),
line!() as usize,
method_name.inspect(),
method_name.loc(),
&mono(&sup.name), // TODO: get super type
self.ctx.caused_by(),
));
}
}
}
}
}
/// Inspect the Trait implementation for correctness,
/// i.e., check that all required attributes are defined and that no extra attributes are defined
fn check_trait_impl(
&mut self,
impl_trait: Option<(Type, Location)>,
class: &Type,
) -> SingleLowerResult<()> {
if let Some((impl_trait, loc)) = impl_trait {
let mut unverified_names = self.ctx.locals.keys().collect::<Set<_>>();
if let Some(trait_obj) = self.ctx.rec_get_const_obj(&impl_trait.local_name()) {
if let ValueObj::Type(typ) = trait_obj {
match typ {
TypeObj::Generated(gen) => match gen.require_or_sup().unwrap().typ() {
Type::Record(attrs) => {
for (field, decl_t) in attrs.iter() {
if let Some((name, vi)) = self.ctx.get_local_kv(&field.symbol) {
let def_t = &vi.t;
// A(<: Add(R)), R -> A.Output
// => A(<: Int), R -> A.Output
let replaced_decl_t =
decl_t.clone().replace(&impl_trait, class);
unverified_names.remove(name);
// def_t must be subtype of decl_t
if !self.ctx.supertype_of(&replaced_decl_t, def_t) {
self.errs.push(LowerError::trait_member_type_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.ctx.caused_by(),
name.inspect(),
&impl_trait,
decl_t,
&vi.t,
None,
));
}
} else {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
&field.symbol,
&impl_trait,
class,
None,
));
}
}
}
other => {
return feature_error!(
LowerError,
self.ctx,
Location::Unknown,
&format!("Impl {other}")
);
}
},
TypeObj::Builtin(_typ) => {
let (_, ctx) = self.ctx.get_nominal_type_ctx(_typ).unwrap();
for (decl_name, decl_vi) in ctx.decls.iter() {
if let Some((name, vi)) = self.ctx.get_local_kv(decl_name.inspect())
{
let def_t = &vi.t;
let replaced_decl_t =
decl_vi.t.clone().replace(&impl_trait, class);
unverified_names.remove(name);
if !self.ctx.supertype_of(&replaced_decl_t, def_t) {
self.errs.push(LowerError::trait_member_type_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.ctx.caused_by(),
name.inspect(),
&impl_trait,
&decl_vi.t,
&vi.t,
None,
));
}
} else {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
decl_name.inspect(),
&impl_trait,
class,
None,
));
}
}
}
}
} else {
return Err(LowerError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
&impl_trait.qual_name(),
None,
&Type::TraitType,
&trait_obj.t(),
None,
None,
));
}
} else {
return Err(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
&impl_trait.qual_name(),
self.ctx.get_similar_name(&impl_trait.local_name()),
));
}
for unverified in unverified_names {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
unverified.inspect(),
&impl_trait,
class,
None,
));
}
}
Ok(())
}More examples
context/inquire.rs (lines 50-61)
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
pub(crate) fn validate_var_sig_t(
&self,
ident: &ast::Identifier,
t_spec: Option<&ast::TypeSpec>,
body_t: &Type,
mode: RegistrationMode,
) -> TyCheckResult<()> {
let spec_t = self.instantiate_var_sig_t(t_spec, None, mode)?;
if self.sub_unify(body_t, &spec_t, ident.loc(), None).is_err() {
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
None,
&spec_t,
body_t,
self.get_candidates(body_t),
Self::get_simple_type_mismatch_hint(&spec_t, body_t),
)));
}
Ok(())
}
pub(crate) fn get_current_scope_var(&self, name: &str) -> Option<&VarInfo> {
self.locals
.get(name)
.or_else(|| self.decls.get(name))
.or_else(|| {
self.params
.iter()
.find(|(opt_name, _)| {
opt_name
.as_ref()
.map(|n| &n.inspect()[..] == name)
.unwrap_or(false)
})
.map(|(_, vi)| vi)
})
.or_else(|| {
for (_, methods) in self.methods_list.iter() {
if let Some(vi) = methods.get_current_scope_var(name) {
return Some(vi);
}
}
None
})
}
pub(crate) fn get_mut_current_scope_var(&mut self, name: &str) -> Option<&mut VarInfo> {
self.locals
.get_mut(name)
.or_else(|| self.decls.get_mut(name))
.or_else(|| {
self.params
.iter_mut()
.find(|(opt_name, _)| {
opt_name
.as_ref()
.map(|n| &n.inspect()[..] == name)
.unwrap_or(false)
})
.map(|(_, vi)| vi)
})
.or_else(|| {
for (_, methods) in self.methods_list.iter_mut() {
if let Some(vi) = methods.get_mut_current_scope_var(name) {
return Some(vi);
}
}
None
})
}
pub(crate) fn get_local_kv(&self, name: &str) -> Option<(&VarName, &VarInfo)> {
self.locals.get_key_value(name)
}
pub(crate) fn get_singular_ctx_by_hir_expr(
&self,
obj: &hir::Expr,
namespace: &Str,
) -> SingleTyCheckResult<&Context> {
match obj {
hir::Expr::Accessor(hir::Accessor::Ident(ident)) => {
self.get_singular_ctx_by_ident(&ident.clone().downcast(), namespace)
}
hir::Expr::Accessor(hir::Accessor::Attr(attr)) => {
// REVIEW: 両方singularとは限らない?
let ctx = self.get_singular_ctx_by_hir_expr(&attr.obj, namespace)?;
let attr = hir::Expr::Accessor(hir::Accessor::Ident(attr.ident.clone()));
ctx.get_singular_ctx_by_hir_expr(&attr, namespace)
}
// TODO: change error
_ => Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&obj.to_string(),
None,
)),
}
}
pub(crate) fn get_singular_ctx_by_ident(
&self,
ident: &ast::Identifier,
namespace: &Str,
) -> SingleTyCheckResult<&Context> {
self.get_mod(ident.inspect())
.or_else(|| self.rec_get_type(ident.inspect()).map(|(_, ctx)| ctx))
.or_else(|| self.rec_get_patch(ident.inspect()))
.ok_or_else(|| {
TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)
})
}
pub(crate) fn get_mut_singular_ctx_by_ident(
&mut self,
ident: &ast::Identifier,
namespace: &Str,
) -> SingleTyCheckResult<&mut Context> {
let err = TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
);
self.get_mut_type(ident.inspect())
.map(|(_, ctx)| ctx)
.ok_or(err)
}
pub(crate) fn get_singular_ctx(
&self,
obj: &ast::Expr,
namespace: &Str,
) -> SingleTyCheckResult<&Context> {
match obj {
ast::Expr::Accessor(ast::Accessor::Ident(ident)) => {
self.get_singular_ctx_by_ident(ident, namespace)
}
ast::Expr::Accessor(ast::Accessor::Attr(attr)) => {
// REVIEW: 両方singularとは限らない?
let ctx = self.get_singular_ctx(&attr.obj, namespace)?;
let attr = ast::Expr::Accessor(ast::Accessor::Ident(attr.ident.clone()));
ctx.get_singular_ctx(&attr, namespace)
}
_ => Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&obj.to_string(),
None,
)),
}
}
pub(crate) fn get_mut_singular_ctx(
&mut self,
obj: &ast::Expr,
namespace: &Str,
) -> SingleTyCheckResult<&mut Context> {
match obj {
ast::Expr::Accessor(ast::Accessor::Ident(ident)) => {
self.get_mut_singular_ctx_by_ident(ident, namespace)
}
ast::Expr::Accessor(ast::Accessor::Attr(attr)) => {
// REVIEW: 両方singularとは限らない?
let ctx = self.get_mut_singular_ctx(&attr.obj, namespace)?;
let attr = ast::Expr::Accessor(ast::Accessor::Ident(attr.ident.clone()));
ctx.get_mut_singular_ctx(&attr, namespace)
}
_ => Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&obj.to_string(),
None,
)),
}
}
fn get_match_call_t(
&self,
kind: SubrKind,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<VarInfo> {
if !kw_args.is_empty() {
// TODO: this error desc is not good
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
kw_args[0].loc(),
self.caused_by(),
"match",
)));
}
for pos_arg in pos_args.iter().skip(1) {
let t = pos_arg.expr.ref_t();
// Allow only anonymous functions to be passed as match arguments (for aesthetic reasons)
if !matches!(&pos_arg.expr, hir::Expr::Lambda(_)) {
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
pos_arg.loc(),
self.caused_by(),
"match",
None,
&mono("LambdaFunc"),
t,
self.get_candidates(t),
Self::get_simple_type_mismatch_hint(&mono("LambdaFunc"), t),
)));
}
}
let match_target_expr_t = pos_args[0].expr.ref_t();
// Never or T => T
let mut union_pat_t = Type::Never;
for (i, pos_arg) in pos_args.iter().skip(1).enumerate() {
let lambda = erg_common::enum_unwrap!(&pos_arg.expr, hir::Expr::Lambda); // already checked
if !lambda.params.defaults.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
"match",
)));
}
if lambda.params.len() != 1 {
return Err(TyCheckErrors::from(TyCheckError::param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
1,
lambda.params.len(),
)));
}
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let rhs = self.instantiate_param_sig_t(
&lambda.params.non_defaults[0],
None,
&mut dummy_tv_cache,
Normal,
)?;
union_pat_t = self.union(&union_pat_t, &rhs);
}
// NG: expr_t: Nat, union_pat_t: {1, 2}
// OK: expr_t: Int, union_pat_t: {1} or 'T
if self
.sub_unify(match_target_expr_t, &union_pat_t, pos_args[0].loc(), None)
.is_err()
{
return Err(TyCheckErrors::from(TyCheckError::match_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[0].loc(),
self.caused_by(),
match_target_expr_t,
)));
}
let branch_ts = pos_args
.iter()
.skip(1)
.map(|a| ParamTy::anonymous(a.expr.ref_t().clone()))
.collect::<Vec<_>>();
let mut return_t = branch_ts[0]
.typ()
.return_t()
.unwrap_or_else(|| todo!("{}", branch_ts[0]))
.clone();
for arg_t in branch_ts.iter().skip(1) {
return_t = self.union(&return_t, arg_t.typ().return_t().unwrap());
}
let param_ty = ParamTy::anonymous(match_target_expr_t.clone());
let param_ts = [vec![param_ty], branch_ts.to_vec()].concat();
let t = if kind.is_func() {
func(param_ts, None, vec![], return_t)
} else {
proc(param_ts, None, vec![], return_t)
};
Ok(VarInfo {
t,
..VarInfo::default()
})
}
pub(crate) fn rec_get_var_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.get_current_scope_var(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
} else if let Some((name, _vi)) = self
.future_defined_locals
.get_key_value(&ident.inspect()[..])
{
return Err(TyCheckError::access_before_def_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
} else if let Some((name, _vi)) = self.deleted_locals.get_key_value(&ident.inspect()[..]) {
return Err(TyCheckError::access_deleted_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
match parent.rec_get_var_info(ident, acc_kind, input, namespace) {
Ok(vi) => Ok(vi),
Err(err) if err.core.kind == ErrorKind::DummyError => {
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
Err(err) => Err(err),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
pub(crate) fn rec_get_decl_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.decls.get(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
return parent.rec_get_decl_info(ident, acc_kind, input, namespace);
}
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
pub(crate) fn rec_get_attr_info(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
let name = ident.name.token();
match self.get_attr_info_from_attributive(&self_t, ident, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
match singular_ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
match self.get_attr_from_nominal_t(obj, ident, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(ident.inspect())
.or_else(|| patch.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(ident.inspect())
.or_else(|| methods_ctx.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
// TODO: dependent type widening
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
parent.rec_get_attr_info(obj, ident, input, namespace)
} else {
Err(TyCheckError::no_attr_error(
input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
&self_t,
name.inspect(),
self.get_similar_attr(&self_t, name.inspect()),
))
}
}
fn get_attr_from_nominal_t(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
if let Some(sups) = self.get_nominal_super_type_ctxs(&self_t) {
for ctx in sups {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
let coerced = self
.deref_tyvar(obj.t(), Variance::Covariant, Location::Unknown)
.map_err(|mut es| es.remove(0))?;
if obj.ref_t() != &coerced {
for ctx in self.get_nominal_super_type_ctxs(&coerced).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&coerced,
)
})? {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
self.coerce(obj.ref_t());
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
Err(TyCheckError::dummy(input.clone(), line!() as usize))
}
/// get type from given attributive type (Record).
/// not ModuleType or ClassType etc.
fn get_attr_info_from_attributive(
&self,
t: &Type,
ident: &Identifier,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
match t {
// (obj: Never).foo: Never
Type::Never => Ok(VarInfo::ILLEGAL.clone()),
Type::FreeVar(fv) if fv.is_linked() => {
self.get_attr_info_from_attributive(&fv.crack(), ident, namespace)
}
Type::FreeVar(fv) /* if fv.is_unbound() */ => {
let sup = fv.get_super().unwrap();
self.get_attr_info_from_attributive(&sup, ident, namespace)
}
Type::Ref(t) => self.get_attr_info_from_attributive(t, ident, namespace),
Type::RefMut { before, .. } => {
self.get_attr_info_from_attributive(before, ident, namespace)
}
Type::Refinement(refine) => {
self.get_attr_info_from_attributive(&refine.t, ident, namespace)
}
Type::Record(record) => {
if let Some(attr_t) = record.get(ident.inspect()) {
let muty = Mutability::from(&ident.inspect()[..]);
let vi = VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
);
Ok(vi)
} else {
let t = Type::Record(record.clone());
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
&t,
ident.inspect(),
self.get_similar_attr(&t, ident.inspect()),
))
}
}
other => {
if let Some(v) = self.rec_get_const_obj(&other.local_name()) {
match v {
ValueObj::Type(TypeObj::Generated(gen)) => self
.get_gen_t_require_attr_t(gen, &ident.inspect()[..])
.map(|attr_t| {
let muty = Mutability::from(&ident.inspect()[..]);
VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
)
})
.ok_or_else(|| {
TyCheckError::dummy(self.cfg.input.clone(), line!() as usize)
}),
ValueObj::Type(TypeObj::Builtin(_t)) => {
// FIXME:
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
_other => Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
)),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
}
}
// returns callee's type, not the return type
fn search_callee_info(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if obj.ref_t() == Type::FAILURE {
// (...Obj) -> Failure
return Ok(VarInfo {
t: Type::Subr(SubrType::new(
SubrKind::Func,
vec![],
Some(ParamTy::pos(None, ref_(Obj))),
vec![],
Failure,
)),
..VarInfo::default()
});
}
if let Some(attr_name) = attr_name.as_ref() {
for ctx in self
.get_nominal_super_type_ctxs(obj.ref_t())
.ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
obj.ref_t(),
)
})?
{
if let Some(vi) = ctx
.locals
.get(attr_name.inspect())
.or_else(|| ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in ctx.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
if let Some(vi) = singular_ctx
.locals
.get(attr_name.inspect())
.or_else(|| singular_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, method_ctx) in singular_ctx.methods_list.iter() {
if let Some(vi) = method_ctx
.locals
.get(attr_name.inspect())
.or_else(|| method_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
return Err(TyCheckError::singular_no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.qual_name().unwrap_or("?"),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr_from_singular(obj, attr_name.inspect()),
));
}
match self.get_method_type_by_name(attr_name) {
Ok(method) => {
self.sub_unify(obj.ref_t(), &method.definition_type, obj.loc(), None)
// HACK: change this func's return type to TyCheckResult<Type>
.map_err(|mut errs| errs.remove(0))?;
return Ok(method.method_type.clone());
}
Err(err) if err.core.kind == ErrorKind::TypeError => {
return Err(err);
}
_ => {}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(attr_name.inspect())
.or_else(|| patch.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr(obj.ref_t(), attr_name.inspect()),
))
} else {
Ok(VarInfo {
t: obj.t(),
..VarInfo::default()
})
}
}
fn validate_visibility(
&self,
ident: &Identifier,
vi: &VarInfo,
input: &Input,
namespace: &str,
) -> SingleTyCheckResult<()> {
if ident.vis() != vi.vis {
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
vi.vis,
))
// check if the private variable is loaded from the other scope
} else if vi.vis.is_private()
&& &self.name[..] != "<builtins>"
&& &self.name[..] != namespace
&& !namespace.contains(&self.name[..])
{
log!(err "{namespace}/{}", self.name);
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
Private,
))
} else {
Ok(())
}
}
// HACK: dname.loc()はダミーLocationしか返さないので、エラーならop.loc()で上書きする
fn append_loc_info(&self, e: TyCheckError, loc: Location) -> TyCheckError {
if e.core.loc == Location::Unknown {
let mut sub_msges = Vec::new();
for sub_msg in e.core.sub_messages {
sub_msges.push(SubMessage::ambiguous_new(loc, sub_msg.msg, sub_msg.hint));
}
let core = ErrorCore::new(
sub_msges,
e.core.main_message,
e.core.errno,
e.core.kind,
e.core.loc,
);
TyCheckError::new(core, self.cfg.input.clone(), e.caused_by)
} else {
e
}
}
pub(crate) fn get_binop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 2);
let cont = binop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let t = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, t));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let lhs = args[0].expr.clone();
let rhs = args[1].expr.clone();
let bin = hir::BinOp::new(op_ident.name.into_token(), lhs, rhs, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, bin.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
pub(crate) fn get_unaryop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 1);
let cont = unaryop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let vi = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, vi));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let expr = args[0].expr.clone();
let unary = hir::UnaryOp::new(op_ident.name.into_token(), expr, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, unary.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
/// 可変依存型の変更を伝搬させる
fn propagate(&self, t: &Type, callee: &hir::Expr) -> TyCheckResult<()> {
if let Type::Subr(subr) = t {
if let Some(after) = subr.self_t().and_then(|self_t| {
if let RefMut { after, .. } = self_t {
after.as_ref()
} else {
None
}
}) {
self.reunify(callee.ref_t(), after, callee.loc())?;
}
}
Ok(())
}
fn not_callable_error(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
other: &Type,
hint: Option<String>,
) -> TyCheckErrors {
let (loc, name) = if let Some(attr_name) = attr_name {
(
Location::concat(obj, attr_name),
(obj.to_string() + &attr_name.to_string()),
)
} else {
(obj.loc(), obj.to_string())
};
TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&name,
None,
&mono("Callable"),
other,
self.get_candidates(other),
hint,
))
}
/// if `obj` has `__call__` method, then the return value is `Some(call_instance)`
///
/// e.g.
/// ```python
/// substitute_call(instance: ((?T, ?U) -> ?T), [Int, Str], []) => instance: (Int, Str) -> Int
/// substitute_call(instance: ((?T, Int) -> ?T), [Int, Nat], []) => instance: (Int, Int) -> Str
/// substitute_call(instance: ((?M(: Nat)..?N(: Nat)) -> ?M+?N), [1..2], []) => instance: (1..2) -> {3}
/// substitute_call(instance: ((?L(: Add(?R, ?O)), ?R) -> ?O), [1, 2], []) => instance: (Nat, Nat) -> Nat
/// substitute_call(instance: ((Failure, ?T) -> ?T), [Int, Int]) => instance: (Failure, Int) -> Int
/// ```
fn substitute_call(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
instance: &Type,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<Option<Type>> {
match instance {
Type::FreeVar(fv) if fv.is_linked() => {
self.substitute_call(obj, attr_name, &fv.crack(), pos_args, kw_args)
}
Type::FreeVar(fv) => {
if let Some(sub) = fv.get_sub() {
if !self.subtype_of(&sub, &mono("GenericCallable")) {
return Err(self.not_callable_error(obj, attr_name, instance, None));
}
}
if let Some(attr_name) = attr_name {
feature_error!(TyCheckErrors, TyCheckError, self, attr_name.loc(), "")
} else {
let is_procedural = obj
.show_acc()
.map(|acc| acc.ends_with('!'))
.unwrap_or(false);
let kind = if is_procedural {
SubrKind::Proc
} else {
SubrKind::Func
};
let ret_t = free_var(self.level, Constraint::new_type_of(Type));
let non_default_params = pos_args.iter().map(|a| anon(a.expr.t())).collect();
let subr_t = subr_t(kind, non_default_params, None, vec![], ret_t);
fv.link(&subr_t);
Ok(None)
}
}
Type::Refinement(refine) => {
self.substitute_call(obj, attr_name, &refine.t, pos_args, kw_args)
}
Type::Subr(subr) => {
let mut errs = TyCheckErrors::empty();
let is_method = subr.self_t().is_some();
let callee = if let Some(ident) = attr_name {
if is_method {
obj.clone()
} else {
let attr = hir::Attribute::new(
obj.clone(),
hir::Identifier::bare(ident.dot.clone(), ident.name.clone()),
);
hir::Expr::Accessor(hir::Accessor::Attr(attr))
}
} else {
obj.clone()
};
let params_len = subr.non_default_params.len() + subr.default_params.len();
if (params_len < pos_args.len() || params_len < pos_args.len() + kw_args.len())
&& subr.var_params.is_none()
{
return Err(self.gen_too_many_args_error(&callee, subr, pos_args, kw_args));
}
let mut passed_params = set! {};
let non_default_params = if is_method {
let mut non_default_params = subr.non_default_params.iter();
let self_pt = non_default_params.next().unwrap();
if let Err(mut es) =
self.sub_unify(obj.ref_t(), self_pt.typ(), obj.loc(), self_pt.name())
{
errs.append(&mut es);
}
non_default_params
} else {
subr.non_default_params.iter()
};
let non_default_params_len = non_default_params.len();
let mut nth = 1;
if pos_args.len() >= non_default_params_len {
let (non_default_args, var_args) = pos_args.split_at(non_default_params_len);
for (nd_arg, nd_param) in non_default_args.iter().zip(non_default_params) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&nd_arg.expr,
nth,
nd_param,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
if let Some(var_param) = subr.var_params.as_ref() {
for var_arg in var_args.iter() {
if let Err(mut es) = self.substitute_var_arg(
&callee,
attr_name,
&var_arg.expr,
nth,
var_param,
) {
errs.append(&mut es);
}
nth += 1;
}
} else {
for (arg, pt) in var_args.iter().zip(subr.default_params.iter()) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&arg.expr,
nth,
pt,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for not_passed in subr
.default_params
.iter()
.filter(|pt| !passed_params.contains(pt.name().unwrap()))
{
if let ParamTy::KwWithDefault { ty, default, .. } = ¬_passed {
if let Err(mut es) =
self.sub_unify(default, ty, obj.loc(), not_passed.name())
{
errs.append(&mut es);
}
}
}
} else {
// pos_args.len() < non_default_params_len
let mut params = non_default_params.chain(subr.default_params.iter());
for pos_arg in pos_args.iter() {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&pos_arg.expr,
nth,
params.next().unwrap(),
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
let missing_params = subr
.non_default_params
.iter()
.map(|pt| pt.name().cloned().unwrap_or(Str::ever("_")))
.filter(|pt| !passed_params.contains(pt))
.collect::<Vec<_>>();
if !missing_params.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
missing_params,
)));
}
}
if errs.is_empty() {
Ok(None)
} else {
Err(errs)
}
}
other => {
if let Ok(typ_ctx) = self.get_singular_ctx_by_hir_expr(obj, &self.name) {
if let Some(call_vi) = typ_ctx.get_current_scope_var("__call__") {
let mut dummy = TyVarCache::new(self.level, self);
let instance =
self.instantiate_t_inner(call_vi.t.clone(), &mut dummy, obj.loc())?;
self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
return Ok(Some(instance));
}
}
let hint = if other == &ClassType {
Some(switch_lang! {
"japanese" => format!("インスタンスを生成したい場合は、{}.newを使用してください", obj.to_string_notype()),
"simplified_chinese" => format!("如果要生成实例，请使用 {}.new", obj.to_string_notype()),
"traditional_chinese" => format!("如果要生成實例，請使用 {}.new", obj.to_string_notype()),
"english" => format!("If you want to generate an instance, use {}.new", obj.to_string_notype()),
})
} else {
None
};
Err(self.not_callable_error(obj, attr_name, other, hint))
}
}
}
fn gen_too_many_args_error(
&self,
callee: &hir::Expr,
subr_ty: &SubrType,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckErrors {
let mut unknown_args = vec![];
let mut passed_args: Vec<&hir::KwArg> = vec![];
let mut duplicated_args = vec![];
for kw_arg in kw_args.iter() {
if subr_ty
.non_default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
&& subr_ty
.var_params
.as_ref()
.map(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
.unwrap_or(true)
&& subr_ty
.default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
{
unknown_args.push(kw_arg);
}
if passed_args.iter().any(|a| a.keyword == kw_arg.keyword) {
duplicated_args.push(kw_arg);
} else {
passed_args.push(kw_arg);
}
}
if unknown_args.is_empty() && duplicated_args.is_empty() {
let params_len = subr_ty.non_default_params.len() + subr_ty.default_params.len();
TyCheckErrors::from(TyCheckError::too_many_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
params_len,
pos_args.len(),
kw_args.len(),
))
} else {
let unknown_arg_errors = unknown_args.into_iter().map(|arg| {
TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
let duplicated_arg_errors = duplicated_args.into_iter().map(|arg| {
TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
unknown_arg_errors.chain(duplicated_arg_errors).collect()
}
}
fn substitute_pos_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
if let Some(name) = param.name() {
if passed_params.contains(name) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
name,
)));
} else {
passed_params.insert(name.clone());
}
}
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
let mut hint = Self::get_call_type_mismatch_hint(
callee.ref_t(),
attr_name.as_ref().map(|i| &i.inspect()[..]),
nth,
param_t,
arg_t,
);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
std::mem::take(&mut hint),
)
})
.collect(),
)
})?;
Ok(())
}
fn substitute_var_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
)
})
}
fn substitute_kw_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::KwArg,
nth: usize,
subr_ty: &SubrType,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.expr.ref_t();
let kw_name = arg.keyword.inspect();
if passed_params.contains(&kw_name[..]) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)));
}
if let Some(pt) = subr_ty
.non_default_params
.iter()
.chain(subr_ty.default_params.iter())
.find(|pt| pt.name().as_ref() == Some(&kw_name))
{
passed_params.insert(kw_name.clone());
self.sub_unify(arg_t, pt.typ(), arg.loc(), Some(kw_name))
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {}", pt.typ());
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + readable_name(kw_name);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
pt.typ(),
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(pt.typ(), arg_t),
)
})
.collect(),
)
})?;
} else {
return Err(TyCheckErrors::from(TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.keyword.loc(),
&callee.to_string(),
self.caused_by(),
kw_name,
)));
}
Ok(())
}context/eval.rs (lines 231-242)
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
fn eval_const_call(&self, call: &Call) -> EvalResult<ValueObj> {
if let Expr::Accessor(acc) = call.obj.as_ref() {
match acc {
Accessor::Ident(ident) => {
let obj = self.rec_get_const_obj(ident.inspect()).ok_or_else(|| {
EvalError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)
})?;
let subr = option_enum_unwrap!(obj, ValueObj::Subr)
.ok_or_else(|| {
EvalError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
None,
&mono("Subroutine"),
&obj.t(),
self.get_candidates(&obj.t()),
None,
)
})?
.clone();
let args = self.eval_args(&call.args)?;
self.call(subr, args, call.loc())
}
// TODO: eval attr
Accessor::Attr(_attr) => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
))),
// TODO: eval type app
Accessor::TypeApp(_type_app) => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
))),
_ => unreachable!(),
}
} else {
Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
)))
}
}context/tyvar.rs (lines 1403-1414)
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
pub(crate) fn sub_unify(
&self,
maybe_sub: &Type,
maybe_sup: &Type,
loc: Location,
param_name: Option<&Str>,
) -> TyCheckResult<()> {
log!(info "trying sub_unify:\nmaybe_sub: {maybe_sub}\nmaybe_sup: {maybe_sup}");
// In this case, there is no new information to be gained
// この場合、特に新しく得られる情報はない
if maybe_sub == &Type::Never || maybe_sup == &Type::Obj || maybe_sup == maybe_sub {
return Ok(());
}
// API definition was failed and inspection is useless after this
if maybe_sub == &Type::Failure || maybe_sup == &Type::Failure {
return Ok(());
}
self.occur(maybe_sub, maybe_sup, loc)?;
let maybe_sub_is_sub = self.subtype_of(maybe_sub, maybe_sup);
if maybe_sub.has_no_unbound_var() && maybe_sup.has_no_unbound_var() && maybe_sub_is_sub {
return Ok(());
}
if !maybe_sub_is_sub {
log!(err "{maybe_sub} !<: {maybe_sup}");
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
param_name.unwrap_or(&Str::ever("_")),
None,
maybe_sup,
maybe_sub,
self.get_candidates(maybe_sub),
Self::get_simple_type_mismatch_hint(maybe_sup, maybe_sub),
)));
}
match (maybe_sub, maybe_sup) {
/*
(Type::FreeVar(fv), _) if fv.is_generalized() => todo!("{maybe_sub}, {maybe_sup}"),
(_, Type::FreeVar(fv)) if fv.is_generalized() => todo!("{maybe_sub}, {maybe_sup}"),
*/
// lfv's sup can be shrunk (take min), rfv's sub can be expanded (take union)
// lfvのsupは縮小可能(minを取る)、rfvのsubは拡大可能(unionを取る)
// sub_unify(?T[0](:> Never, <: Int), ?U[1](:> Never, <: Nat)): (/* ?U[1] --> ?T[0](:> Never, <: Nat))
// sub_unify(?T[1](:> Never, <: Nat), ?U[0](:> Never, <: Int)): (/* ?T[1] --> ?U[0](:> Never, <: Nat))
// sub_unify(?T[0](:> Never, <: Str), ?U[1](:> Never, <: Int)): (?T[0](:> Never, <: Str and Int) --> Error!)
// sub_unify(?T[0](:> Int, <: Add()), ?U[1](:> Never, <: Mul())): (?T[0](:> Int, <: Add() and Mul()))
// sub_unify(?T[0](:> Str, <: Obj), ?U[1](:> Int, <: Obj)): (/* ?U[1] --> ?T[0](:> Str or Int) */)
(Type::FreeVar(lfv), Type::FreeVar(rfv))
if lfv.constraint_is_sandwiched() && rfv.constraint_is_sandwiched() =>
{
let (lsub, lsup) = lfv.get_subsup().unwrap();
let (rsub, rsup) = rfv.get_subsup().unwrap();
let intersec = self.intersection(&lsup, &rsup);
let new_constraint = if intersec != Type::Never {
Constraint::new_sandwiched(self.union(&lsub, &rsub), intersec)
} else {
return Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)));
};
if lfv.level().unwrap() <= rfv.level().unwrap() {
lfv.update_constraint(new_constraint);
rfv.link(maybe_sub);
} else {
rfv.update_constraint(new_constraint);
lfv.link(maybe_sup);
}
Ok(())
}
(Type::FreeVar(lfv), _) if lfv.is_linked() => {
self.sub_unify(&lfv.crack(), maybe_sup, loc, param_name)
}
(_, Type::FreeVar(rfv)) if rfv.is_linked() => {
self.sub_unify(maybe_sub, &rfv.crack(), loc, param_name)
}
(_, Type::FreeVar(rfv)) if rfv.is_unbound() => {
// NOTE: cannot `borrow_mut` because of cycle reference
let rfv_ref = unsafe { rfv.as_ptr().as_mut().unwrap() };
match rfv_ref {
FreeKind::NamedUnbound { constraint, .. }
| FreeKind::Unbound { constraint, .. } => match constraint {
// * sub_unify(Nat, ?E(<: Eq(?E)))
// sub !<: l => OK (sub will widen)
// sup !:> l => Error
// * sub_unify(Str, ?T(:> _, <: Int)): (/* Error */)
// * sub_unify(Ratio, ?T(:> _, <: Int)): (/* Error */)
// sub = max(l, sub) if max exists
// * sub_unify(Nat, ?T(:> Int, <: _)): (/* OK */)
// * sub_unify(Int, ?T(:> Nat, <: Obj)): (?T(:> Int, <: Obj))
// * sub_unify(Nat, ?T(:> Never, <: Add(?R))): (?T(:> Nat, <: Add(?R))
// sub = union(l, sub) if max does not exist
// * sub_unify(Str, ?T(:> Int, <: Obj)): (?T(:> Str or Int, <: Obj))
// * sub_unify({0}, ?T(:> {1}, <: Nat)): (?T(:> {0, 1}, <: Nat))
// * sub_unify(Bool, ?T(<: Bool or Y)): (?T == Bool)
Constraint::Sandwiched { sub, sup } => {
/*if let Some(new_sub) = self.max(maybe_sub, sub) {
*constraint =
Constraint::new_sandwiched(new_sub.clone(), mem::take(sup), *cyclicity);
} else {*/
let new_sub = self.union(maybe_sub, sub);
if sup.contains_union(&new_sub) {
rfv.link(&new_sub); // Bool <: ?T <: Bool or Y ==> ?T == Bool
} else {
*constraint = Constraint::new_sandwiched(new_sub, mem::take(sup));
}
// }
}
// sub_unify(Nat, ?T(: Type)): (/* ?T(:> Nat) */)
Constraint::TypeOf(ty) => {
if self.supertype_of(&Type, ty) {
*constraint = Constraint::new_supertype_of(maybe_sub.clone());
} else {
todo!()
}
}
_ => unreachable!(),
},
_ => {}
}
Ok(())
}
(Type::FreeVar(lfv), _) if lfv.is_unbound() => {
let lfv_ref = unsafe { lfv.as_ptr().as_mut().unwrap() };
match lfv_ref {
FreeKind::NamedUnbound { constraint, .. }
| FreeKind::Unbound { constraint, .. } => match constraint {
// sub !<: r => Error
// * sub_unify(?T(:> Int, <: _), Nat): (/* Error */)
// * sub_unify(?T(:> Nat, <: _), Str): (/* Error */)
// sup !:> r => Error
// * sub_unify(?T(:> _, <: Str), Int): (/* Error */)
// * sub_unify(?T(:> _, <: Int), Nat): (/* Error */)
// sub <: r, sup :> r => sup = min(sup, r) if min exists
// * sub_unify(?T(:> Never, <: Nat), Int): (/* OK */)
// * sub_unify(?T(:> Nat, <: Obj), Int): (?T(:> Nat, <: Int))
// sup = union(sup, r) if min does not exist
// * sub_unify(?T(:> Never, <: {1}), {0}): (?T(:> Never, <: {0, 1}))
Constraint::Sandwiched { sub, sup } => {
// REVIEW: correct?
if let Some(new_sup) = self.min(sup, maybe_sup) {
*constraint =
Constraint::new_sandwiched(mem::take(sub), new_sup.clone());
} else {
let new_sup = self.union(sup, maybe_sup);
*constraint = Constraint::new_sandwiched(mem::take(sub), new_sup);
}
}
// sub_unify(?T(: Type), Int): (?T(<: Int))
Constraint::TypeOf(ty) => {
if self.supertype_of(&Type, ty) {
*constraint = Constraint::new_subtype_of(maybe_sup.clone());
} else {
todo!()
}
}
_ => unreachable!(),
},
_ => {}
}
Ok(())
}
(Type::FreeVar(_fv), _r) => todo!(),
(Type::Record(lrec), Type::Record(rrec)) => {
for (k, l) in lrec.iter() {
if let Some(r) = rrec.get(k) {
self.sub_unify(l, r, loc, param_name)?;
} else {
return Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)));
}
}
Ok(())
}
(Type::Subr(lsub), Type::Subr(rsub)) => {
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
// contravariant
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
// contravariant
self.sub_unify(r.typ(), l.typ(), loc, param_name)
})?;
// covariant
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
Ok(())
}
(Type::Quantified(lsub), Type::Subr(rsub)) => {
let Type::Subr(lsub) = lsub.as_ref() else { unreachable!() };
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
if lpt.typ().is_generalized() {
continue;
}
// contravariant
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
if l.typ().is_generalized() {
Ok(())
}
// contravariant
else {
self.sub_unify(r.typ(), l.typ(), loc, param_name)
}
})?;
// covariant
if !lsub.return_t.is_generalized() {
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
}
Ok(())
}
(Type::Subr(lsub), Type::Quantified(rsub)) => {
let Type::Subr(rsub) = rsub.as_ref() else { unreachable!() };
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
// contravariant
if rpt.typ().is_generalized() {
continue;
}
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
// contravariant
if r.typ().is_generalized() {
Ok(())
} else {
self.sub_unify(r.typ(), l.typ(), loc, param_name)
}
})?;
// covariant
if !rsub.return_t.is_generalized() {
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
}
Ok(())
}
(
Type::Poly {
name: ln,
params: lps,
},
Type::Poly {
name: rn,
params: rps,
},
) => {
// e.g. Set(?T) <: Eq(Set(?T))
// Array(Str) <: Iterable(Str)
if ln != rn {
if let Some((sub_def_t, sub_ctx)) = self.get_nominal_type_ctx(maybe_sub) {
self.substitute_typarams(sub_def_t, maybe_sub);
for sup_trait in sub_ctx.super_traits.iter() {
if self.supertype_of(maybe_sup, sup_trait) {
for (l_maybe_sub, r_maybe_sup) in
sup_trait.typarams().iter().zip(rps.iter())
{
self.sub_unify_tp(l_maybe_sub, r_maybe_sup, None, loc, false)
.map_err(|e| {
self.undo_substitute_typarams(sub_def_t);
e
})?;
}
self.undo_substitute_typarams(sub_def_t);
return Ok(());
}
}
}
Err(TyCheckErrors::from(TyCheckError::unification_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)))
} else {
for (l_maybe_sub, r_maybe_sup) in lps.iter().zip(rps.iter()) {
self.sub_unify_tp(l_maybe_sub, r_maybe_sup, None, loc, false)?;
}
Ok(())
}
}
// (X or Y) <: Z is valid when X <: Z and Y <: Z
(Type::Or(l, r), _) => {
self.sub_unify(l, maybe_sup, loc, param_name)?;
self.sub_unify(r, maybe_sup, loc, param_name)
}
// X <: (Y and Z) is valid when X <: Y and X <: Z
(_, Type::And(l, r)) => {
self.sub_unify(maybe_sub, l, loc, param_name)?;
self.sub_unify(maybe_sub, r, loc, param_name)
}
// (X and Y) <: Z is valid when X <: Z or Y <: Z
(Type::And(l, r), _) => self
.sub_unify(l, maybe_sup, loc, param_name)
.or_else(|_e| self.sub_unify(r, maybe_sup, loc, param_name)),
// X <: (Y or Z) is valid when X <: Y or X <: Z
(_, Type::Or(l, r)) => self
.sub_unify(maybe_sub, l, loc, param_name)
.or_else(|_e| self.sub_unify(maybe_sub, r, loc, param_name)),
(_, Type::Ref(t)) => self.sub_unify(maybe_sub, t, loc, param_name),
(_, Type::RefMut { before, .. }) => self.sub_unify(maybe_sub, before, loc, param_name),
(Type::Proj { .. }, _) => todo!(),
(_, Type::Proj { .. }) => todo!(),
// TODO: Judgment for any number of preds
(Refinement(sub), Refinement(sup)) => {
// {I: Int or Str | I == 0} <: {I: Int}
if self.subtype_of(&sub.t, &sup.t) {
self.sub_unify(&sub.t, &sup.t, loc, param_name)?;
}
if sup.preds.is_empty() {
self.sub_unify(&sub.t, &sup.t, loc, param_name)?;
return Ok(());
}
if sub.preds.len() == 1 && sup.preds.len() == 1 {
let sub_first = sub.preds.iter().next().unwrap();
let sup_first = sup.preds.iter().next().unwrap();
self.sub_unify_pred(sub_first, sup_first, loc)?;
return Ok(());
}
todo!("{sub}, {sup}")
}
// {I: Int | I >= 1} <: Nat == {I: Int | I >= 0}
(Type::Refinement(_), sup) => {
let sup = sup.clone().into_refinement();
self.sub_unify(maybe_sub, &Type::Refinement(sup), loc, param_name)
}
(Type::Subr(_) | Type::Record(_), Type) => Ok(()),
// REVIEW: correct?
(Type::Poly { name, .. }, Type) if &name[..] == "Array" || &name[..] == "Tuple" => {
Ok(())
}
(Type::Subr(_), Mono(name)) if &name[..] == "GenericCallable" => Ok(()),
_ => type_feature_error!(
self,
loc,
&format!("{maybe_sub} can be a subtype of {maybe_sup}, but failed to semi-unify")
),
}
}sourcepub fn return_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
expect: &Type,
found: &Type
) -> Self
pub fn return_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
expect: &Type,
found: &Type
) -> Self
Examples found in repository?
context/register.rs (lines 468-476)
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
pub(crate) fn assign_subr(
&mut self,
sig: &ast::SubrSignature,
id: DefId,
body_t: &Type,
) -> TyCheckResult<Type> {
// already defined as const
if sig.ident.is_const() {
let vi = self.decls.remove(sig.ident.inspect()).unwrap();
let t = vi.t.clone();
self.locals.insert(sig.ident.name.clone(), vi);
return Ok(t);
}
let muty = if sig.ident.is_const() {
Mutability::Const
} else {
Mutability::Immutable
};
let name = &sig.ident.name;
// FIXME: constでない関数
let t = self
.get_current_scope_var(name.inspect())
.map(|v| &v.t)
.unwrap();
let non_default_params = t.non_default_params().unwrap();
let var_args = t.var_args();
let default_params = t.default_params().unwrap();
let mut errs = if let Some(spec_ret_t) = t.return_t() {
let return_t_loc = sig
.return_t_spec
.as_ref()
.map(|t_spec| t_spec.loc())
.unwrap_or_else(|| sig.loc());
self.sub_unify(body_t, spec_ret_t, return_t_loc, None)
.map_err(|errs| {
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::return_type_error(
self.cfg.input.clone(),
line!() as usize,
e.core.get_loc_with_fallback(),
e.caused_by,
readable_name(name.inspect()),
spec_ret_t,
body_t,
)
})
.collect(),
)
})
} else {
Ok(())
};
let return_t = if errs.is_err() {
Type::Failure
} else {
// NOTE: not `body_t.clone()` because the body may contain `return`
t.return_t().unwrap().clone()
};
let sub_t = if sig.ident.is_procedural() {
proc(
non_default_params.clone(),
var_args.cloned(),
default_params.clone(),
return_t,
)
} else {
func(
non_default_params.clone(),
var_args.cloned(),
default_params.clone(),
return_t,
)
};
sub_t.lift();
let found_t = self.generalize_t(sub_t);
let py_name = if let Some(vi) = self.decls.remove(name) {
if !self.supertype_of(&vi.t, &found_t) {
let err = TyCheckError::violate_decl_error(
self.cfg.input.clone(),
line!() as usize,
sig.ident.loc(),
self.caused_by(),
name.inspect(),
&vi.t,
&found_t,
);
match errs {
Ok(()) => {
errs = Err(TyCheckErrors::from(err));
}
Err(ref mut es) => {
es.push(err);
}
}
}
vi.py_name
} else {
None
};
let comptime_decos = sig
.decorators
.iter()
.filter_map(|deco| match &deco.0 {
ast::Expr::Accessor(ast::Accessor::Ident(local)) if local.is_const() => {
Some(local.inspect().clone())
}
_ => None,
})
.collect();
let vi = VarInfo::new(
found_t,
muty,
sig.ident.vis(),
VarKind::Defined(id),
Some(comptime_decos),
self.impl_of(),
py_name,
);
let t = vi.t.clone();
log!(info "Registered {}::{name}: {t}", self.name);
self.locals.insert(name.clone(), vi);
errs?;
Ok(t)
}sourcepub fn uninitialized_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
t: &Type
) -> Self
pub fn uninitialized_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
t: &Type
) -> Self
Examples found in repository?
context/mod.rs (lines 1046-1053)
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
pub(crate) fn check_decls(&mut self) -> Result<(), TyCheckErrors> {
let mut uninited_errs = TyCheckErrors::empty();
for (name, vi) in self.decls.iter() {
uninited_errs.push(TyCheckError::uninitialized_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
name.inspect(),
&vi.t,
));
}
if !uninited_errs.is_empty() {
Err(uninited_errs)
} else {
Ok(())
}
}pub fn argument_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expect: usize,
found: usize
) -> Self
sourcepub fn param_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expect: usize,
found: usize
) -> Self
pub fn param_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expect: usize,
found: usize
) -> Self
Examples found in repository?
context/inquire.rs (lines 286-293)
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
fn get_match_call_t(
&self,
kind: SubrKind,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<VarInfo> {
if !kw_args.is_empty() {
// TODO: this error desc is not good
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
kw_args[0].loc(),
self.caused_by(),
"match",
)));
}
for pos_arg in pos_args.iter().skip(1) {
let t = pos_arg.expr.ref_t();
// Allow only anonymous functions to be passed as match arguments (for aesthetic reasons)
if !matches!(&pos_arg.expr, hir::Expr::Lambda(_)) {
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
pos_arg.loc(),
self.caused_by(),
"match",
None,
&mono("LambdaFunc"),
t,
self.get_candidates(t),
Self::get_simple_type_mismatch_hint(&mono("LambdaFunc"), t),
)));
}
}
let match_target_expr_t = pos_args[0].expr.ref_t();
// Never or T => T
let mut union_pat_t = Type::Never;
for (i, pos_arg) in pos_args.iter().skip(1).enumerate() {
let lambda = erg_common::enum_unwrap!(&pos_arg.expr, hir::Expr::Lambda); // already checked
if !lambda.params.defaults.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
"match",
)));
}
if lambda.params.len() != 1 {
return Err(TyCheckErrors::from(TyCheckError::param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
1,
lambda.params.len(),
)));
}
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let rhs = self.instantiate_param_sig_t(
&lambda.params.non_defaults[0],
None,
&mut dummy_tv_cache,
Normal,
)?;
union_pat_t = self.union(&union_pat_t, &rhs);
}
// NG: expr_t: Nat, union_pat_t: {1, 2}
// OK: expr_t: Int, union_pat_t: {1} or 'T
if self
.sub_unify(match_target_expr_t, &union_pat_t, pos_args[0].loc(), None)
.is_err()
{
return Err(TyCheckErrors::from(TyCheckError::match_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[0].loc(),
self.caused_by(),
match_target_expr_t,
)));
}
let branch_ts = pos_args
.iter()
.skip(1)
.map(|a| ParamTy::anonymous(a.expr.ref_t().clone()))
.collect::<Vec<_>>();
let mut return_t = branch_ts[0]
.typ()
.return_t()
.unwrap_or_else(|| todo!("{}", branch_ts[0]))
.clone();
for arg_t in branch_ts.iter().skip(1) {
return_t = self.union(&return_t, arg_t.typ().return_t().unwrap());
}
let param_ty = ParamTy::anonymous(match_target_expr_t.clone());
let param_ts = [vec![param_ty], branch_ts.to_vec()].concat();
let t = if kind.is_func() {
func(param_ts, None, vec![], return_t)
} else {
proc(param_ts, None, vec![], return_t)
};
Ok(VarInfo {
t,
..VarInfo::default()
})
}sourcepub fn default_param_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
pub fn default_param_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
Examples found in repository?
context/inquire.rs (lines 245-251)
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
fn get_match_call_t(
&self,
kind: SubrKind,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<VarInfo> {
if !kw_args.is_empty() {
// TODO: this error desc is not good
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
kw_args[0].loc(),
self.caused_by(),
"match",
)));
}
for pos_arg in pos_args.iter().skip(1) {
let t = pos_arg.expr.ref_t();
// Allow only anonymous functions to be passed as match arguments (for aesthetic reasons)
if !matches!(&pos_arg.expr, hir::Expr::Lambda(_)) {
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
pos_arg.loc(),
self.caused_by(),
"match",
None,
&mono("LambdaFunc"),
t,
self.get_candidates(t),
Self::get_simple_type_mismatch_hint(&mono("LambdaFunc"), t),
)));
}
}
let match_target_expr_t = pos_args[0].expr.ref_t();
// Never or T => T
let mut union_pat_t = Type::Never;
for (i, pos_arg) in pos_args.iter().skip(1).enumerate() {
let lambda = erg_common::enum_unwrap!(&pos_arg.expr, hir::Expr::Lambda); // already checked
if !lambda.params.defaults.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
"match",
)));
}
if lambda.params.len() != 1 {
return Err(TyCheckErrors::from(TyCheckError::param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
1,
lambda.params.len(),
)));
}
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let rhs = self.instantiate_param_sig_t(
&lambda.params.non_defaults[0],
None,
&mut dummy_tv_cache,
Normal,
)?;
union_pat_t = self.union(&union_pat_t, &rhs);
}
// NG: expr_t: Nat, union_pat_t: {1, 2}
// OK: expr_t: Int, union_pat_t: {1} or 'T
if self
.sub_unify(match_target_expr_t, &union_pat_t, pos_args[0].loc(), None)
.is_err()
{
return Err(TyCheckErrors::from(TyCheckError::match_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[0].loc(),
self.caused_by(),
match_target_expr_t,
)));
}
let branch_ts = pos_args
.iter()
.skip(1)
.map(|a| ParamTy::anonymous(a.expr.ref_t().clone()))
.collect::<Vec<_>>();
let mut return_t = branch_ts[0]
.typ()
.return_t()
.unwrap_or_else(|| todo!("{}", branch_ts[0]))
.clone();
for arg_t in branch_ts.iter().skip(1) {
return_t = self.union(&return_t, arg_t.typ().return_t().unwrap());
}
let param_ty = ParamTy::anonymous(match_target_expr_t.clone());
let param_ts = [vec![param_ty], branch_ts.to_vec()].concat();
let t = if kind.is_func() {
func(param_ts, None, vec![], return_t)
} else {
proc(param_ts, None, vec![], return_t)
};
Ok(VarInfo {
t,
..VarInfo::default()
})
}sourcepub fn match_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expr_t: &Type
) -> Self
pub fn match_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expr_t: &Type
) -> Self
Examples found in repository?
context/inquire.rs (lines 310-316)
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
fn get_match_call_t(
&self,
kind: SubrKind,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<VarInfo> {
if !kw_args.is_empty() {
// TODO: this error desc is not good
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
kw_args[0].loc(),
self.caused_by(),
"match",
)));
}
for pos_arg in pos_args.iter().skip(1) {
let t = pos_arg.expr.ref_t();
// Allow only anonymous functions to be passed as match arguments (for aesthetic reasons)
if !matches!(&pos_arg.expr, hir::Expr::Lambda(_)) {
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
pos_arg.loc(),
self.caused_by(),
"match",
None,
&mono("LambdaFunc"),
t,
self.get_candidates(t),
Self::get_simple_type_mismatch_hint(&mono("LambdaFunc"), t),
)));
}
}
let match_target_expr_t = pos_args[0].expr.ref_t();
// Never or T => T
let mut union_pat_t = Type::Never;
for (i, pos_arg) in pos_args.iter().skip(1).enumerate() {
let lambda = erg_common::enum_unwrap!(&pos_arg.expr, hir::Expr::Lambda); // already checked
if !lambda.params.defaults.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
"match",
)));
}
if lambda.params.len() != 1 {
return Err(TyCheckErrors::from(TyCheckError::param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
1,
lambda.params.len(),
)));
}
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let rhs = self.instantiate_param_sig_t(
&lambda.params.non_defaults[0],
None,
&mut dummy_tv_cache,
Normal,
)?;
union_pat_t = self.union(&union_pat_t, &rhs);
}
// NG: expr_t: Nat, union_pat_t: {1, 2}
// OK: expr_t: Int, union_pat_t: {1} or 'T
if self
.sub_unify(match_target_expr_t, &union_pat_t, pos_args[0].loc(), None)
.is_err()
{
return Err(TyCheckErrors::from(TyCheckError::match_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[0].loc(),
self.caused_by(),
match_target_expr_t,
)));
}
let branch_ts = pos_args
.iter()
.skip(1)
.map(|a| ParamTy::anonymous(a.expr.ref_t().clone()))
.collect::<Vec<_>>();
let mut return_t = branch_ts[0]
.typ()
.return_t()
.unwrap_or_else(|| todo!("{}", branch_ts[0]))
.clone();
for arg_t in branch_ts.iter().skip(1) {
return_t = self.union(&return_t, arg_t.typ().return_t().unwrap());
}
let param_ty = ParamTy::anonymous(match_target_expr_t.clone());
let param_ts = [vec![param_ty], branch_ts.to_vec()].concat();
let t = if kind.is_func() {
func(param_ts, None, vec![], return_t)
} else {
proc(param_ts, None, vec![], return_t)
};
Ok(VarInfo {
t,
..VarInfo::default()
})
}pub fn infer_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
expr: &str
) -> Self
sourcepub fn dummy_infer_error(input: Input, fn_name: &str, line: u32) -> Self
pub fn dummy_infer_error(input: Input, fn_name: &str, line: u32) -> Self
Examples found in repository?
context/tyvar.rs (line 266)
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
pub(crate) fn deref_tp(
&self,
tp: TyParam,
variance: Variance,
loc: Location,
) -> TyCheckResult<TyParam> {
match tp {
TyParam::FreeVar(fv) if fv.is_linked() => {
let inner = fv.unwrap_linked();
self.deref_tp(inner, variance, loc)
}
TyParam::FreeVar(_fv) if self.level == 0 => Err(TyCheckErrors::from(
TyCheckError::dummy_infer_error(self.cfg.input.clone(), fn_name!(), line!()),
)),
TyParam::Type(t) => Ok(TyParam::t(self.deref_tyvar(*t, variance, loc)?)),
TyParam::App { name, mut args } => {
for param in args.iter_mut() {
*param = self.deref_tp(mem::take(param), variance, loc)?;
}
Ok(TyParam::App { name, args })
}
TyParam::BinOp { op, lhs, rhs } => {
let lhs = self.deref_tp(*lhs, variance, loc)?;
let rhs = self.deref_tp(*rhs, variance, loc)?;
Ok(TyParam::BinOp {
op,
lhs: Box::new(lhs),
rhs: Box::new(rhs),
})
}
TyParam::UnaryOp { op, val } => {
let val = self.deref_tp(*val, variance, loc)?;
Ok(TyParam::UnaryOp {
op,
val: Box::new(val),
})
}
TyParam::Array(tps) => {
let mut new_tps = vec![];
for tp in tps {
new_tps.push(self.deref_tp(tp, variance, loc)?);
}
Ok(TyParam::Array(new_tps))
}
TyParam::Tuple(tps) => {
let mut new_tps = vec![];
for tp in tps {
new_tps.push(self.deref_tp(tp, variance, loc)?);
}
Ok(TyParam::Tuple(new_tps))
}
TyParam::Dict(dic) => {
let mut new_dic = dict! {};
for (k, v) in dic.into_iter() {
new_dic.insert(
self.deref_tp(k, variance, loc)?,
self.deref_tp(v, variance, loc)?,
);
}
Ok(TyParam::Dict(new_dic))
}
TyParam::Set(set) => {
let mut new_set = set! {};
for v in set.into_iter() {
new_set.insert(self.deref_tp(v, variance, loc)?);
}
Ok(TyParam::Set(new_set))
}
TyParam::Proj { .. } | TyParam::Failure if self.level == 0 => Err(TyCheckErrors::from(
TyCheckError::dummy_infer_error(self.cfg.input.clone(), fn_name!(), line!()),
)),
t => Ok(t),
}
}
fn deref_constraint(
&self,
constraint: Constraint,
variance: Variance,
loc: Location,
) -> TyCheckResult<Constraint> {
match constraint {
Constraint::Sandwiched { sub, sup } => Ok(Constraint::new_sandwiched(
self.deref_tyvar(sub, variance, loc)?,
self.deref_tyvar(sup, variance, loc)?,
)),
Constraint::TypeOf(t) => {
Ok(Constraint::new_type_of(self.deref_tyvar(t, variance, loc)?))
}
_ => unreachable!(),
}
}
fn validate_subsup(
&self,
sub_t: Type,
super_t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
// TODO: Subr, ...
match (sub_t, super_t) {
// See tests\should_err\subtyping.er:8~13
(
Type::Poly {
name: ln,
params: lps,
},
Type::Poly {
name: rn,
params: rps,
},
) if ln == rn => {
let typ = poly(ln, lps.clone());
let (_, ctx) = self.get_nominal_type_ctx(&typ).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&typ,
)
})?;
let variances = ctx.type_params_variance();
let mut tps = vec![];
for ((lp, rp), variance) in lps
.into_iter()
.zip(rps.into_iter())
.zip(variances.into_iter())
{
self.sub_unify_tp(&lp, &rp, Some(variance), loc, false)?;
let param = if variance == Covariant { lp } else { rp };
tps.push(param);
}
Ok(poly(rn, tps))
}
(sub_t, super_t) => self.validate_simple_subsup(sub_t, super_t, variance, loc),
}
}
fn validate_simple_subsup(
&self,
sub_t: Type,
super_t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
if self.is_trait(&super_t) {
self.check_trait_impl(&sub_t, &super_t, loc)?;
}
// REVIEW: Even if type constraints can be satisfied, implementation may not exist
if self.subtype_of(&sub_t, &super_t) {
match variance {
Variance::Covariant => {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
Ok(sub_t)
}
Variance::Contravariant => {
let super_t = if cfg!(feature = "debug") {
super_t
} else {
self.deref_tyvar(super_t, variance, loc)?
};
Ok(super_t)
}
Variance::Invariant => {
// need to check if sub_t == super_t
if self.supertype_of(&sub_t, &super_t) {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
Ok(sub_t)
} else {
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&self.deref_tyvar(sub_t, variance, loc)?,
&self.deref_tyvar(super_t, variance, loc)?,
loc,
self.caused_by(),
)))
}
}
}
} else {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
let super_t = if cfg!(feature = "debug") {
super_t
} else {
self.deref_tyvar(super_t, variance, loc)?
};
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&sub_t,
&super_t,
loc,
self.caused_by(),
)))
}
}
/// e.g.
/// ```python
// ?T(:> Nat, <: Int)[n] ==> Nat (self.level <= n)
// ?T(:> Nat, <: Sub(?U(:> {1}))) ==> Nat
// ?T(:> Nat, <: Sub(?U(:> {1}))) -> ?U ==> |U: Type, T <: Sub(U)| T -> U
// ?T(:> Nat, <: Sub(Str)) ==> Error!
// ?T(:> {1, "a"}, <: Eq(?T(:> {1, "a"}, ...)) ==> Error!
// ```
pub(crate) fn deref_tyvar(
&self,
t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
match t {
// ?T(:> Nat, <: Int)[n] ==> Nat (self.level <= n)
// ?T(:> Nat, <: Sub ?U(:> {1}))[n] ==> Nat
// ?T(:> Nat, <: Sub(Str)) ==> Error!
// ?T(:> {1, "a"}, <: Eq(?T(:> {1, "a"}, ...)) ==> Error!
Type::FreeVar(fv) if fv.constraint_is_sandwiched() => {
let (sub_t, super_t) = fv.get_subsup().unwrap();
if self.level <= fv.level().unwrap() {
self.validate_subsup(sub_t, super_t, variance, loc)
} else {
// no dereference at this point
// drop(constraint);
Ok(Type::FreeVar(fv))
}
}
Type::FreeVar(fv) if fv.is_unbound() => {
if self.level == 0 {
match &*fv.crack_constraint() {
Constraint::TypeOf(_) => {
Err(TyCheckErrors::from(TyCheckError::dummy_infer_error(
self.cfg.input.clone(),
fn_name!(),
line!(),
)))
}
_ => unreachable!(),
}
} else {
let new_constraint = fv.crack_constraint().clone();
let new_constraint = self.deref_constraint(new_constraint, variance, loc)?;
fv.update_constraint(new_constraint);
Ok(Type::FreeVar(fv))
}
}
Type::FreeVar(fv) if fv.is_linked() => {
let t = fv.unwrap_linked();
self.deref_tyvar(t, variance, loc)
}
Type::Poly { name, mut params } => {
let typ = poly(&name, params.clone());
let (_, ctx) = self.get_nominal_type_ctx(&typ).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&typ,
)
})?;
let variances = ctx.type_params_variance();
for (param, variance) in params.iter_mut().zip(variances.into_iter()) {
*param = self.deref_tp(mem::take(param), variance, loc)?;
}
Ok(Type::Poly { name, params })
}
Type::Subr(mut subr) => {
for param in subr.non_default_params.iter_mut() {
*param.typ_mut() =
self.deref_tyvar(mem::take(param.typ_mut()), Contravariant, loc)?;
}
if let Some(var_args) = &mut subr.var_params {
*var_args.typ_mut() =
self.deref_tyvar(mem::take(var_args.typ_mut()), Contravariant, loc)?;
}
for d_param in subr.default_params.iter_mut() {
*d_param.typ_mut() =
self.deref_tyvar(mem::take(d_param.typ_mut()), Contravariant, loc)?;
}
subr.return_t =
Box::new(self.deref_tyvar(mem::take(&mut subr.return_t), Covariant, loc)?);
Ok(Type::Subr(subr))
}
Type::Ref(t) => {
let t = self.deref_tyvar(*t, variance, loc)?;
Ok(ref_(t))
}
Type::RefMut { before, after } => {
let before = self.deref_tyvar(*before, variance, loc)?;
let after = if let Some(after) = after {
Some(self.deref_tyvar(*after, variance, loc)?)
} else {
None
};
Ok(ref_mut(before, after))
}
// Type::Callable { .. } => todo!(),
Type::Record(mut rec) => {
for (_, field) in rec.iter_mut() {
*field = self.deref_tyvar(mem::take(field), variance, loc)?;
}
Ok(Type::Record(rec))
}
Type::Refinement(refine) => {
let t = self.deref_tyvar(*refine.t, variance, loc)?;
// TODO: deref_predicate
Ok(refinement(refine.var, t, refine.preds))
}
Type::And(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
Ok(self.intersection(&l, &r))
}
Type::Or(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
Ok(self.union(&l, &r))
}
Type::Not(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
// TODO: complement
Ok(not(l, r))
}
Type::Proj { lhs, rhs } => {
let lhs = self.deref_tyvar(*lhs, variance, loc)?;
self.eval_proj(lhs, rhs, self.level, loc)
}
Type::ProjCall {
lhs,
attr_name,
args,
} => {
let lhs = self.deref_tp(*lhs, variance, loc)?;
let mut new_args = vec![];
for arg in args.into_iter() {
new_args.push(self.deref_tp(arg, variance, loc)?);
}
self.eval_proj_call(lhs, attr_name, new_args, self.level, loc)
}
t => Ok(t),
}
}pub fn not_relation(input: Input, fn_name: &str, line: u32) -> Self
sourcepub fn too_many_args_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
params_len: usize,
pos_args_len: usize,
kw_args_len: usize
) -> Self
pub fn too_many_args_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
params_len: usize,
pos_args_len: usize,
kw_args_len: usize
) -> Self
Examples found in repository?
context/inquire.rs (lines 1221-1230)
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
fn gen_too_many_args_error(
&self,
callee: &hir::Expr,
subr_ty: &SubrType,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckErrors {
let mut unknown_args = vec![];
let mut passed_args: Vec<&hir::KwArg> = vec![];
let mut duplicated_args = vec![];
for kw_arg in kw_args.iter() {
if subr_ty
.non_default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
&& subr_ty
.var_params
.as_ref()
.map(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
.unwrap_or(true)
&& subr_ty
.default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
{
unknown_args.push(kw_arg);
}
if passed_args.iter().any(|a| a.keyword == kw_arg.keyword) {
duplicated_args.push(kw_arg);
} else {
passed_args.push(kw_arg);
}
}
if unknown_args.is_empty() && duplicated_args.is_empty() {
let params_len = subr_ty.non_default_params.len() + subr_ty.default_params.len();
TyCheckErrors::from(TyCheckError::too_many_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
params_len,
pos_args.len(),
kw_args.len(),
))
} else {
let unknown_arg_errors = unknown_args.into_iter().map(|arg| {
TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
let duplicated_arg_errors = duplicated_args.into_iter().map(|arg| {
TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
unknown_arg_errors.chain(duplicated_arg_errors).collect()
}
}sourcepub fn args_missing_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
missing_params: Vec<Str>
) -> Self
pub fn args_missing_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
missing_params: Vec<Str>
) -> Self
Examples found in repository?
context/instantiate.rs (lines 444-451)
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
pub(crate) fn instantiate_simple_t(
&self,
simple: &SimpleTypeSpec,
opt_decl_t: Option<&ParamTy>,
tmp_tv_cache: &mut TyVarCache,
not_found_is_qvar: bool,
) -> TyCheckResult<Type> {
match &simple.ident.inspect()[..] {
"_" | "Obj" => Ok(Type::Obj),
"Nat" => Ok(Type::Nat),
"Int" => Ok(Type::Int),
"Ratio" => Ok(Type::Ratio),
"Float" => Ok(Type::Float),
"Str" => Ok(Type::Str),
"Bool" => Ok(Type::Bool),
"NoneType" => Ok(Type::NoneType),
"Ellipsis" => Ok(Type::Ellipsis),
"NotImplemented" => Ok(Type::NotImplemented),
"Inf" => Ok(Type::Inf),
"NegInf" => Ok(Type::NegInf),
"Never" => Ok(Type::Never),
"ClassType" => Ok(Type::ClassType),
"TraitType" => Ok(Type::TraitType),
"Type" => Ok(Type::Type),
"Array" => {
// TODO: kw
let mut args = simple.args.pos_args();
if let Some(first) = args.next() {
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
let len = if let Some(len) = args.next() {
self.instantiate_const_expr(&len.expr, None, tmp_tv_cache)?
} else {
TyParam::erased(Nat)
};
Ok(array_t(t, len))
} else {
Ok(mono("GenericArray"))
}
}
"Ref" => {
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"Ref",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_(t))
}
"RefMut" => {
// TODO after
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"RefMut",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_mut(t, None))
}
"Self" => self.rec_get_self_t().ok_or_else(|| {
TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
erg_common::fn_name_full!(),
line!(),
))
}),
other if simple.args.is_empty() => {
if let Some(t) = tmp_tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tmp_tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
if let Some(tv_cache) = &self.tv_cache {
if let Some(t) = tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
}
if let Some(outer) = &self.outer {
if let Ok(t) = outer.instantiate_simple_t(
simple,
opt_decl_t,
tmp_tv_cache,
not_found_is_qvar,
) {
return Ok(t);
}
}
if let Some(decl_t) = opt_decl_t {
return Ok(decl_t.typ().clone());
}
if let Some((typ, _)) = self.rec_get_type(other) {
Ok(typ.clone())
} else if not_found_is_qvar {
let tyvar = named_free_var(Str::rc(other), self.level, Constraint::Uninited);
tmp_tv_cache.push_or_init_tyvar(&Str::rc(other), &tyvar);
Ok(tyvar)
} else {
Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)))
}
}
other => {
let ctx = if let Some((_, ctx)) = self.rec_get_type(other) {
ctx
} else {
return Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.ident.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)));
};
// FIXME: kw args
let mut new_params = vec![];
for (i, arg) in simple.args.pos_args().enumerate() {
let params =
self.instantiate_const_expr(&arg.expr, Some((ctx, i)), tmp_tv_cache);
let params = params.or_else(|e| {
if not_found_is_qvar {
let name = Str::from(arg.expr.to_string());
let tp = TyParam::named_free_var(
name.clone(),
self.level,
Constraint::Uninited,
);
tmp_tv_cache.push_or_init_typaram(&name, &tp);
Ok(tp)
} else {
Err(e)
}
})?;
new_params.push(params);
}
// FIXME: non-builtin
Ok(poly(Str::rc(other), new_params))
}
}
}More examples
context/inquire.rs (lines 1145-1152)
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
fn substitute_call(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
instance: &Type,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<Option<Type>> {
match instance {
Type::FreeVar(fv) if fv.is_linked() => {
self.substitute_call(obj, attr_name, &fv.crack(), pos_args, kw_args)
}
Type::FreeVar(fv) => {
if let Some(sub) = fv.get_sub() {
if !self.subtype_of(&sub, &mono("GenericCallable")) {
return Err(self.not_callable_error(obj, attr_name, instance, None));
}
}
if let Some(attr_name) = attr_name {
feature_error!(TyCheckErrors, TyCheckError, self, attr_name.loc(), "")
} else {
let is_procedural = obj
.show_acc()
.map(|acc| acc.ends_with('!'))
.unwrap_or(false);
let kind = if is_procedural {
SubrKind::Proc
} else {
SubrKind::Func
};
let ret_t = free_var(self.level, Constraint::new_type_of(Type));
let non_default_params = pos_args.iter().map(|a| anon(a.expr.t())).collect();
let subr_t = subr_t(kind, non_default_params, None, vec![], ret_t);
fv.link(&subr_t);
Ok(None)
}
}
Type::Refinement(refine) => {
self.substitute_call(obj, attr_name, &refine.t, pos_args, kw_args)
}
Type::Subr(subr) => {
let mut errs = TyCheckErrors::empty();
let is_method = subr.self_t().is_some();
let callee = if let Some(ident) = attr_name {
if is_method {
obj.clone()
} else {
let attr = hir::Attribute::new(
obj.clone(),
hir::Identifier::bare(ident.dot.clone(), ident.name.clone()),
);
hir::Expr::Accessor(hir::Accessor::Attr(attr))
}
} else {
obj.clone()
};
let params_len = subr.non_default_params.len() + subr.default_params.len();
if (params_len < pos_args.len() || params_len < pos_args.len() + kw_args.len())
&& subr.var_params.is_none()
{
return Err(self.gen_too_many_args_error(&callee, subr, pos_args, kw_args));
}
let mut passed_params = set! {};
let non_default_params = if is_method {
let mut non_default_params = subr.non_default_params.iter();
let self_pt = non_default_params.next().unwrap();
if let Err(mut es) =
self.sub_unify(obj.ref_t(), self_pt.typ(), obj.loc(), self_pt.name())
{
errs.append(&mut es);
}
non_default_params
} else {
subr.non_default_params.iter()
};
let non_default_params_len = non_default_params.len();
let mut nth = 1;
if pos_args.len() >= non_default_params_len {
let (non_default_args, var_args) = pos_args.split_at(non_default_params_len);
for (nd_arg, nd_param) in non_default_args.iter().zip(non_default_params) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&nd_arg.expr,
nth,
nd_param,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
if let Some(var_param) = subr.var_params.as_ref() {
for var_arg in var_args.iter() {
if let Err(mut es) = self.substitute_var_arg(
&callee,
attr_name,
&var_arg.expr,
nth,
var_param,
) {
errs.append(&mut es);
}
nth += 1;
}
} else {
for (arg, pt) in var_args.iter().zip(subr.default_params.iter()) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&arg.expr,
nth,
pt,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for not_passed in subr
.default_params
.iter()
.filter(|pt| !passed_params.contains(pt.name().unwrap()))
{
if let ParamTy::KwWithDefault { ty, default, .. } = ¬_passed {
if let Err(mut es) =
self.sub_unify(default, ty, obj.loc(), not_passed.name())
{
errs.append(&mut es);
}
}
}
} else {
// pos_args.len() < non_default_params_len
let mut params = non_default_params.chain(subr.default_params.iter());
for pos_arg in pos_args.iter() {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&pos_arg.expr,
nth,
params.next().unwrap(),
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
let missing_params = subr
.non_default_params
.iter()
.map(|pt| pt.name().cloned().unwrap_or(Str::ever("_")))
.filter(|pt| !passed_params.contains(pt))
.collect::<Vec<_>>();
if !missing_params.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
missing_params,
)));
}
}
if errs.is_empty() {
Ok(None)
} else {
Err(errs)
}
}
other => {
if let Ok(typ_ctx) = self.get_singular_ctx_by_hir_expr(obj, &self.name) {
if let Some(call_vi) = typ_ctx.get_current_scope_var("__call__") {
let mut dummy = TyVarCache::new(self.level, self);
let instance =
self.instantiate_t_inner(call_vi.t.clone(), &mut dummy, obj.loc())?;
self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
return Ok(Some(instance));
}
}
let hint = if other == &ClassType {
Some(switch_lang! {
"japanese" => format!("インスタンスを生成したい場合は、{}.newを使用してください", obj.to_string_notype()),
"simplified_chinese" => format!("如果要生成实例，请使用 {}.new", obj.to_string_notype()),
"traditional_chinese" => format!("如果要生成實例，請使用 {}.new", obj.to_string_notype()),
"english" => format!("If you want to generate an instance, use {}.new", obj.to_string_notype()),
})
} else {
None
};
Err(self.not_callable_error(obj, attr_name, other, hint))
}
}
}sourcepub fn multiple_args_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
arg_name: &str
) -> Self
pub fn multiple_args_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
arg_name: &str
) -> Self
Examples found in repository?
context/inquire.rs (lines 1243-1250)
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
fn gen_too_many_args_error(
&self,
callee: &hir::Expr,
subr_ty: &SubrType,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckErrors {
let mut unknown_args = vec![];
let mut passed_args: Vec<&hir::KwArg> = vec![];
let mut duplicated_args = vec![];
for kw_arg in kw_args.iter() {
if subr_ty
.non_default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
&& subr_ty
.var_params
.as_ref()
.map(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
.unwrap_or(true)
&& subr_ty
.default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
{
unknown_args.push(kw_arg);
}
if passed_args.iter().any(|a| a.keyword == kw_arg.keyword) {
duplicated_args.push(kw_arg);
} else {
passed_args.push(kw_arg);
}
}
if unknown_args.is_empty() && duplicated_args.is_empty() {
let params_len = subr_ty.non_default_params.len() + subr_ty.default_params.len();
TyCheckErrors::from(TyCheckError::too_many_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
params_len,
pos_args.len(),
kw_args.len(),
))
} else {
let unknown_arg_errors = unknown_args.into_iter().map(|arg| {
TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
let duplicated_arg_errors = duplicated_args.into_iter().map(|arg| {
TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
unknown_arg_errors.chain(duplicated_arg_errors).collect()
}
}
fn substitute_pos_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
if let Some(name) = param.name() {
if passed_params.contains(name) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
name,
)));
} else {
passed_params.insert(name.clone());
}
}
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
let mut hint = Self::get_call_type_mismatch_hint(
callee.ref_t(),
attr_name.as_ref().map(|i| &i.inspect()[..]),
nth,
param_t,
arg_t,
);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
std::mem::take(&mut hint),
)
})
.collect(),
)
})?;
Ok(())
}
fn substitute_var_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
)
})
}
fn substitute_kw_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::KwArg,
nth: usize,
subr_ty: &SubrType,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.expr.ref_t();
let kw_name = arg.keyword.inspect();
if passed_params.contains(&kw_name[..]) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)));
}
if let Some(pt) = subr_ty
.non_default_params
.iter()
.chain(subr_ty.default_params.iter())
.find(|pt| pt.name().as_ref() == Some(&kw_name))
{
passed_params.insert(kw_name.clone());
self.sub_unify(arg_t, pt.typ(), arg.loc(), Some(kw_name))
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {}", pt.typ());
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + readable_name(kw_name);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
pt.typ(),
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(pt.typ(), arg_t),
)
})
.collect(),
)
})?;
} else {
return Err(TyCheckErrors::from(TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.keyword.loc(),
&callee.to_string(),
self.caused_by(),
kw_name,
)));
}
Ok(())
}sourcepub fn unexpected_kw_arg_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
param_name: &str
) -> Self
pub fn unexpected_kw_arg_error(
input: Input,
errno: usize,
loc: Location,
callee_name: &str,
caused_by: String,
param_name: &str
) -> Self
Examples found in repository?
context/inquire.rs (lines 1233-1240)
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
fn gen_too_many_args_error(
&self,
callee: &hir::Expr,
subr_ty: &SubrType,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckErrors {
let mut unknown_args = vec![];
let mut passed_args: Vec<&hir::KwArg> = vec![];
let mut duplicated_args = vec![];
for kw_arg in kw_args.iter() {
if subr_ty
.non_default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
&& subr_ty
.var_params
.as_ref()
.map(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
.unwrap_or(true)
&& subr_ty
.default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
{
unknown_args.push(kw_arg);
}
if passed_args.iter().any(|a| a.keyword == kw_arg.keyword) {
duplicated_args.push(kw_arg);
} else {
passed_args.push(kw_arg);
}
}
if unknown_args.is_empty() && duplicated_args.is_empty() {
let params_len = subr_ty.non_default_params.len() + subr_ty.default_params.len();
TyCheckErrors::from(TyCheckError::too_many_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
params_len,
pos_args.len(),
kw_args.len(),
))
} else {
let unknown_arg_errors = unknown_args.into_iter().map(|arg| {
TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
let duplicated_arg_errors = duplicated_args.into_iter().map(|arg| {
TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
unknown_arg_errors.chain(duplicated_arg_errors).collect()
}
}
fn substitute_pos_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
if let Some(name) = param.name() {
if passed_params.contains(name) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
name,
)));
} else {
passed_params.insert(name.clone());
}
}
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
let mut hint = Self::get_call_type_mismatch_hint(
callee.ref_t(),
attr_name.as_ref().map(|i| &i.inspect()[..]),
nth,
param_t,
arg_t,
);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
std::mem::take(&mut hint),
)
})
.collect(),
)
})?;
Ok(())
}
fn substitute_var_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
)
})
}
fn substitute_kw_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::KwArg,
nth: usize,
subr_ty: &SubrType,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.expr.ref_t();
let kw_name = arg.keyword.inspect();
if passed_params.contains(&kw_name[..]) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)));
}
if let Some(pt) = subr_ty
.non_default_params
.iter()
.chain(subr_ty.default_params.iter())
.find(|pt| pt.name().as_ref() == Some(&kw_name))
{
passed_params.insert(kw_name.clone());
self.sub_unify(arg_t, pt.typ(), arg.loc(), Some(kw_name))
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {}", pt.typ());
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + readable_name(kw_name);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
pt.typ(),
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(pt.typ(), arg_t),
)
})
.collect(),
)
})?;
} else {
return Err(TyCheckErrors::from(TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.keyword.loc(),
&callee.to_string(),
self.caused_by(),
kw_name,
)));
}
Ok(())
}sourcepub fn unification_error(
input: Input,
errno: usize,
lhs_t: &Type,
rhs_t: &Type,
loc: Location,
caused_by: String
) -> Self
pub fn unification_error(
input: Input,
errno: usize,
lhs_t: &Type,
rhs_t: &Type,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
context/tyvar.rs (lines 1689-1696)
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
pub(crate) fn sub_unify(
&self,
maybe_sub: &Type,
maybe_sup: &Type,
loc: Location,
param_name: Option<&Str>,
) -> TyCheckResult<()> {
log!(info "trying sub_unify:\nmaybe_sub: {maybe_sub}\nmaybe_sup: {maybe_sup}");
// In this case, there is no new information to be gained
// この場合、特に新しく得られる情報はない
if maybe_sub == &Type::Never || maybe_sup == &Type::Obj || maybe_sup == maybe_sub {
return Ok(());
}
// API definition was failed and inspection is useless after this
if maybe_sub == &Type::Failure || maybe_sup == &Type::Failure {
return Ok(());
}
self.occur(maybe_sub, maybe_sup, loc)?;
let maybe_sub_is_sub = self.subtype_of(maybe_sub, maybe_sup);
if maybe_sub.has_no_unbound_var() && maybe_sup.has_no_unbound_var() && maybe_sub_is_sub {
return Ok(());
}
if !maybe_sub_is_sub {
log!(err "{maybe_sub} !<: {maybe_sup}");
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
param_name.unwrap_or(&Str::ever("_")),
None,
maybe_sup,
maybe_sub,
self.get_candidates(maybe_sub),
Self::get_simple_type_mismatch_hint(maybe_sup, maybe_sub),
)));
}
match (maybe_sub, maybe_sup) {
/*
(Type::FreeVar(fv), _) if fv.is_generalized() => todo!("{maybe_sub}, {maybe_sup}"),
(_, Type::FreeVar(fv)) if fv.is_generalized() => todo!("{maybe_sub}, {maybe_sup}"),
*/
// lfv's sup can be shrunk (take min), rfv's sub can be expanded (take union)
// lfvのsupは縮小可能(minを取る)、rfvのsubは拡大可能(unionを取る)
// sub_unify(?T[0](:> Never, <: Int), ?U[1](:> Never, <: Nat)): (/* ?U[1] --> ?T[0](:> Never, <: Nat))
// sub_unify(?T[1](:> Never, <: Nat), ?U[0](:> Never, <: Int)): (/* ?T[1] --> ?U[0](:> Never, <: Nat))
// sub_unify(?T[0](:> Never, <: Str), ?U[1](:> Never, <: Int)): (?T[0](:> Never, <: Str and Int) --> Error!)
// sub_unify(?T[0](:> Int, <: Add()), ?U[1](:> Never, <: Mul())): (?T[0](:> Int, <: Add() and Mul()))
// sub_unify(?T[0](:> Str, <: Obj), ?U[1](:> Int, <: Obj)): (/* ?U[1] --> ?T[0](:> Str or Int) */)
(Type::FreeVar(lfv), Type::FreeVar(rfv))
if lfv.constraint_is_sandwiched() && rfv.constraint_is_sandwiched() =>
{
let (lsub, lsup) = lfv.get_subsup().unwrap();
let (rsub, rsup) = rfv.get_subsup().unwrap();
let intersec = self.intersection(&lsup, &rsup);
let new_constraint = if intersec != Type::Never {
Constraint::new_sandwiched(self.union(&lsub, &rsub), intersec)
} else {
return Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)));
};
if lfv.level().unwrap() <= rfv.level().unwrap() {
lfv.update_constraint(new_constraint);
rfv.link(maybe_sub);
} else {
rfv.update_constraint(new_constraint);
lfv.link(maybe_sup);
}
Ok(())
}
(Type::FreeVar(lfv), _) if lfv.is_linked() => {
self.sub_unify(&lfv.crack(), maybe_sup, loc, param_name)
}
(_, Type::FreeVar(rfv)) if rfv.is_linked() => {
self.sub_unify(maybe_sub, &rfv.crack(), loc, param_name)
}
(_, Type::FreeVar(rfv)) if rfv.is_unbound() => {
// NOTE: cannot `borrow_mut` because of cycle reference
let rfv_ref = unsafe { rfv.as_ptr().as_mut().unwrap() };
match rfv_ref {
FreeKind::NamedUnbound { constraint, .. }
| FreeKind::Unbound { constraint, .. } => match constraint {
// * sub_unify(Nat, ?E(<: Eq(?E)))
// sub !<: l => OK (sub will widen)
// sup !:> l => Error
// * sub_unify(Str, ?T(:> _, <: Int)): (/* Error */)
// * sub_unify(Ratio, ?T(:> _, <: Int)): (/* Error */)
// sub = max(l, sub) if max exists
// * sub_unify(Nat, ?T(:> Int, <: _)): (/* OK */)
// * sub_unify(Int, ?T(:> Nat, <: Obj)): (?T(:> Int, <: Obj))
// * sub_unify(Nat, ?T(:> Never, <: Add(?R))): (?T(:> Nat, <: Add(?R))
// sub = union(l, sub) if max does not exist
// * sub_unify(Str, ?T(:> Int, <: Obj)): (?T(:> Str or Int, <: Obj))
// * sub_unify({0}, ?T(:> {1}, <: Nat)): (?T(:> {0, 1}, <: Nat))
// * sub_unify(Bool, ?T(<: Bool or Y)): (?T == Bool)
Constraint::Sandwiched { sub, sup } => {
/*if let Some(new_sub) = self.max(maybe_sub, sub) {
*constraint =
Constraint::new_sandwiched(new_sub.clone(), mem::take(sup), *cyclicity);
} else {*/
let new_sub = self.union(maybe_sub, sub);
if sup.contains_union(&new_sub) {
rfv.link(&new_sub); // Bool <: ?T <: Bool or Y ==> ?T == Bool
} else {
*constraint = Constraint::new_sandwiched(new_sub, mem::take(sup));
}
// }
}
// sub_unify(Nat, ?T(: Type)): (/* ?T(:> Nat) */)
Constraint::TypeOf(ty) => {
if self.supertype_of(&Type, ty) {
*constraint = Constraint::new_supertype_of(maybe_sub.clone());
} else {
todo!()
}
}
_ => unreachable!(),
},
_ => {}
}
Ok(())
}
(Type::FreeVar(lfv), _) if lfv.is_unbound() => {
let lfv_ref = unsafe { lfv.as_ptr().as_mut().unwrap() };
match lfv_ref {
FreeKind::NamedUnbound { constraint, .. }
| FreeKind::Unbound { constraint, .. } => match constraint {
// sub !<: r => Error
// * sub_unify(?T(:> Int, <: _), Nat): (/* Error */)
// * sub_unify(?T(:> Nat, <: _), Str): (/* Error */)
// sup !:> r => Error
// * sub_unify(?T(:> _, <: Str), Int): (/* Error */)
// * sub_unify(?T(:> _, <: Int), Nat): (/* Error */)
// sub <: r, sup :> r => sup = min(sup, r) if min exists
// * sub_unify(?T(:> Never, <: Nat), Int): (/* OK */)
// * sub_unify(?T(:> Nat, <: Obj), Int): (?T(:> Nat, <: Int))
// sup = union(sup, r) if min does not exist
// * sub_unify(?T(:> Never, <: {1}), {0}): (?T(:> Never, <: {0, 1}))
Constraint::Sandwiched { sub, sup } => {
// REVIEW: correct?
if let Some(new_sup) = self.min(sup, maybe_sup) {
*constraint =
Constraint::new_sandwiched(mem::take(sub), new_sup.clone());
} else {
let new_sup = self.union(sup, maybe_sup);
*constraint = Constraint::new_sandwiched(mem::take(sub), new_sup);
}
}
// sub_unify(?T(: Type), Int): (?T(<: Int))
Constraint::TypeOf(ty) => {
if self.supertype_of(&Type, ty) {
*constraint = Constraint::new_subtype_of(maybe_sup.clone());
} else {
todo!()
}
}
_ => unreachable!(),
},
_ => {}
}
Ok(())
}
(Type::FreeVar(_fv), _r) => todo!(),
(Type::Record(lrec), Type::Record(rrec)) => {
for (k, l) in lrec.iter() {
if let Some(r) = rrec.get(k) {
self.sub_unify(l, r, loc, param_name)?;
} else {
return Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)));
}
}
Ok(())
}
(Type::Subr(lsub), Type::Subr(rsub)) => {
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
// contravariant
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
// contravariant
self.sub_unify(r.typ(), l.typ(), loc, param_name)
})?;
// covariant
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
Ok(())
}
(Type::Quantified(lsub), Type::Subr(rsub)) => {
let Type::Subr(lsub) = lsub.as_ref() else { unreachable!() };
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
if lpt.typ().is_generalized() {
continue;
}
// contravariant
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
if l.typ().is_generalized() {
Ok(())
}
// contravariant
else {
self.sub_unify(r.typ(), l.typ(), loc, param_name)
}
})?;
// covariant
if !lsub.return_t.is_generalized() {
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
}
Ok(())
}
(Type::Subr(lsub), Type::Quantified(rsub)) => {
let Type::Subr(rsub) = rsub.as_ref() else { unreachable!() };
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
// contravariant
if rpt.typ().is_generalized() {
continue;
}
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
// contravariant
if r.typ().is_generalized() {
Ok(())
} else {
self.sub_unify(r.typ(), l.typ(), loc, param_name)
}
})?;
// covariant
if !rsub.return_t.is_generalized() {
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
}
Ok(())
}
(
Type::Poly {
name: ln,
params: lps,
},
Type::Poly {
name: rn,
params: rps,
},
) => {
// e.g. Set(?T) <: Eq(Set(?T))
// Array(Str) <: Iterable(Str)
if ln != rn {
if let Some((sub_def_t, sub_ctx)) = self.get_nominal_type_ctx(maybe_sub) {
self.substitute_typarams(sub_def_t, maybe_sub);
for sup_trait in sub_ctx.super_traits.iter() {
if self.supertype_of(maybe_sup, sup_trait) {
for (l_maybe_sub, r_maybe_sup) in
sup_trait.typarams().iter().zip(rps.iter())
{
self.sub_unify_tp(l_maybe_sub, r_maybe_sup, None, loc, false)
.map_err(|e| {
self.undo_substitute_typarams(sub_def_t);
e
})?;
}
self.undo_substitute_typarams(sub_def_t);
return Ok(());
}
}
}
Err(TyCheckErrors::from(TyCheckError::unification_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)))
} else {
for (l_maybe_sub, r_maybe_sup) in lps.iter().zip(rps.iter()) {
self.sub_unify_tp(l_maybe_sub, r_maybe_sup, None, loc, false)?;
}
Ok(())
}
}
// (X or Y) <: Z is valid when X <: Z and Y <: Z
(Type::Or(l, r), _) => {
self.sub_unify(l, maybe_sup, loc, param_name)?;
self.sub_unify(r, maybe_sup, loc, param_name)
}
// X <: (Y and Z) is valid when X <: Y and X <: Z
(_, Type::And(l, r)) => {
self.sub_unify(maybe_sub, l, loc, param_name)?;
self.sub_unify(maybe_sub, r, loc, param_name)
}
// (X and Y) <: Z is valid when X <: Z or Y <: Z
(Type::And(l, r), _) => self
.sub_unify(l, maybe_sup, loc, param_name)
.or_else(|_e| self.sub_unify(r, maybe_sup, loc, param_name)),
// X <: (Y or Z) is valid when X <: Y or X <: Z
(_, Type::Or(l, r)) => self
.sub_unify(maybe_sub, l, loc, param_name)
.or_else(|_e| self.sub_unify(maybe_sub, r, loc, param_name)),
(_, Type::Ref(t)) => self.sub_unify(maybe_sub, t, loc, param_name),
(_, Type::RefMut { before, .. }) => self.sub_unify(maybe_sub, before, loc, param_name),
(Type::Proj { .. }, _) => todo!(),
(_, Type::Proj { .. }) => todo!(),
// TODO: Judgment for any number of preds
(Refinement(sub), Refinement(sup)) => {
// {I: Int or Str | I == 0} <: {I: Int}
if self.subtype_of(&sub.t, &sup.t) {
self.sub_unify(&sub.t, &sup.t, loc, param_name)?;
}
if sup.preds.is_empty() {
self.sub_unify(&sub.t, &sup.t, loc, param_name)?;
return Ok(());
}
if sub.preds.len() == 1 && sup.preds.len() == 1 {
let sub_first = sub.preds.iter().next().unwrap();
let sup_first = sup.preds.iter().next().unwrap();
self.sub_unify_pred(sub_first, sup_first, loc)?;
return Ok(());
}
todo!("{sub}, {sup}")
}
// {I: Int | I >= 1} <: Nat == {I: Int | I >= 0}
(Type::Refinement(_), sup) => {
let sup = sup.clone().into_refinement();
self.sub_unify(maybe_sub, &Type::Refinement(sup), loc, param_name)
}
(Type::Subr(_) | Type::Record(_), Type) => Ok(()),
// REVIEW: correct?
(Type::Poly { name, .. }, Type) if &name[..] == "Array" || &name[..] == "Tuple" => {
Ok(())
}
(Type::Subr(_), Mono(name)) if &name[..] == "GenericCallable" => Ok(()),
_ => type_feature_error!(
self,
loc,
&format!("{maybe_sub} can be a subtype of {maybe_sup}, but failed to semi-unify")
),
}
}sourcepub fn re_unification_error(
input: Input,
errno: usize,
lhs_t: &Type,
rhs_t: &Type,
loc: Location,
caused_by: String
) -> Self
pub fn re_unification_error(
input: Input,
errno: usize,
lhs_t: &Type,
rhs_t: &Type,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
context/tyvar.rs (lines 1341-1348)
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
pub(crate) fn reunify(
&self,
before_t: &Type,
after_t: &Type,
loc: Location,
) -> SingleTyCheckResult<()> {
match (before_t, after_t) {
(Type::FreeVar(fv), r) if fv.is_linked() => self.reunify(&fv.crack(), r, loc),
(l, Type::FreeVar(fv)) if fv.is_linked() => self.reunify(l, &fv.crack(), loc),
(Type::Ref(l), Type::Ref(r)) => self.reunify(l, r, loc),
(
Type::RefMut {
before: lbefore,
after: lafter,
},
Type::RefMut {
before: rbefore,
after: rafter,
},
) => {
self.reunify(lbefore, rbefore, loc)?;
match (lafter, rafter) {
(Some(lafter), Some(rafter)) => {
self.reunify(lafter, rafter, loc)?;
}
(None, None) => {}
_ => todo!(),
}
Ok(())
}
(Type::Ref(l), r) => self.reunify(l, r, loc),
// REVIEW:
(Type::RefMut { before, .. }, r) => self.reunify(before, r, loc),
(l, Type::Ref(r)) => self.reunify(l, r, loc),
(l, Type::RefMut { before, .. }) => self.reunify(l, before, loc),
(
Type::Poly {
name: ln,
params: lps,
},
Type::Poly {
name: rn,
params: rps,
},
) => {
if ln != rn {
let before_t = poly(ln.clone(), lps.clone());
return Err(TyCheckError::re_unification_error(
self.cfg.input.clone(),
line!() as usize,
&before_t,
after_t,
loc,
self.caused_by(),
));
}
for (l, r) in lps.iter().zip(rps.iter()) {
self.reunify_tp(l, r, loc)?;
}
Ok(())
}
(l, r) if self.same_type_of(l, r) => Ok(()),
(l, r) => Err(TyCheckError::re_unification_error(
self.cfg.input.clone(),
line!() as usize,
l,
r,
loc,
self.caused_by(),
)),
}
}sourcepub fn subtyping_error(
input: Input,
errno: usize,
sub_t: &Type,
sup_t: &Type,
loc: Location,
caused_by: String
) -> Self
pub fn subtyping_error(
input: Input,
errno: usize,
sub_t: &Type,
sup_t: &Type,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
lower.rs (lines 1826-1833)
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837
fn lower_type_asc(&mut self, tasc: ast::TypeAscription) -> LowerResult<hir::TypeAscription> {
log!(info "entered {}({tasc})", fn_name!());
let is_instance_ascription = tasc.is_instance_ascription();
let mut dummy_tv_cache = TyVarCache::new(self.ctx.level, &self.ctx);
let t = self.ctx.instantiate_typespec(
&tasc.t_spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?;
let loc = tasc.loc();
let expr = self.lower_expr(*tasc.expr)?;
if is_instance_ascription {
self.ctx.sub_unify(
expr.ref_t(),
&t,
expr.loc(),
Some(&Str::from(expr.to_string())),
)?;
} else {
let ctx = self
.ctx
.get_singular_ctx_by_hir_expr(&expr, &self.ctx.name)?;
// REVIEW: need to use subtype_of?
if ctx.super_traits.iter().all(|trait_| trait_ != &t)
&& ctx.super_classes.iter().all(|class| class != &t)
{
return Err(LowerErrors::from(LowerError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
expr.ref_t(), // FIXME:
&t,
loc,
self.ctx.caused_by(),
)));
}
}
Ok(expr.type_asc(tasc.t_spec))
}More examples
context/tyvar.rs (lines 433-440)
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
fn validate_simple_subsup(
&self,
sub_t: Type,
super_t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
if self.is_trait(&super_t) {
self.check_trait_impl(&sub_t, &super_t, loc)?;
}
// REVIEW: Even if type constraints can be satisfied, implementation may not exist
if self.subtype_of(&sub_t, &super_t) {
match variance {
Variance::Covariant => {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
Ok(sub_t)
}
Variance::Contravariant => {
let super_t = if cfg!(feature = "debug") {
super_t
} else {
self.deref_tyvar(super_t, variance, loc)?
};
Ok(super_t)
}
Variance::Invariant => {
// need to check if sub_t == super_t
if self.supertype_of(&sub_t, &super_t) {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
Ok(sub_t)
} else {
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&self.deref_tyvar(sub_t, variance, loc)?,
&self.deref_tyvar(super_t, variance, loc)?,
loc,
self.caused_by(),
)))
}
}
}
} else {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
let super_t = if cfg!(feature = "debug") {
super_t
} else {
self.deref_tyvar(super_t, variance, loc)?
};
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&sub_t,
&super_t,
loc,
self.caused_by(),
)))
}
}
/// e.g.
/// ```python
// ?T(:> Nat, <: Int)[n] ==> Nat (self.level <= n)
// ?T(:> Nat, <: Sub(?U(:> {1}))) ==> Nat
// ?T(:> Nat, <: Sub(?U(:> {1}))) -> ?U ==> |U: Type, T <: Sub(U)| T -> U
// ?T(:> Nat, <: Sub(Str)) ==> Error!
// ?T(:> {1, "a"}, <: Eq(?T(:> {1, "a"}, ...)) ==> Error!
// ```
pub(crate) fn deref_tyvar(
&self,
t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
match t {
// ?T(:> Nat, <: Int)[n] ==> Nat (self.level <= n)
// ?T(:> Nat, <: Sub ?U(:> {1}))[n] ==> Nat
// ?T(:> Nat, <: Sub(Str)) ==> Error!
// ?T(:> {1, "a"}, <: Eq(?T(:> {1, "a"}, ...)) ==> Error!
Type::FreeVar(fv) if fv.constraint_is_sandwiched() => {
let (sub_t, super_t) = fv.get_subsup().unwrap();
if self.level <= fv.level().unwrap() {
self.validate_subsup(sub_t, super_t, variance, loc)
} else {
// no dereference at this point
// drop(constraint);
Ok(Type::FreeVar(fv))
}
}
Type::FreeVar(fv) if fv.is_unbound() => {
if self.level == 0 {
match &*fv.crack_constraint() {
Constraint::TypeOf(_) => {
Err(TyCheckErrors::from(TyCheckError::dummy_infer_error(
self.cfg.input.clone(),
fn_name!(),
line!(),
)))
}
_ => unreachable!(),
}
} else {
let new_constraint = fv.crack_constraint().clone();
let new_constraint = self.deref_constraint(new_constraint, variance, loc)?;
fv.update_constraint(new_constraint);
Ok(Type::FreeVar(fv))
}
}
Type::FreeVar(fv) if fv.is_linked() => {
let t = fv.unwrap_linked();
self.deref_tyvar(t, variance, loc)
}
Type::Poly { name, mut params } => {
let typ = poly(&name, params.clone());
let (_, ctx) = self.get_nominal_type_ctx(&typ).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&typ,
)
})?;
let variances = ctx.type_params_variance();
for (param, variance) in params.iter_mut().zip(variances.into_iter()) {
*param = self.deref_tp(mem::take(param), variance, loc)?;
}
Ok(Type::Poly { name, params })
}
Type::Subr(mut subr) => {
for param in subr.non_default_params.iter_mut() {
*param.typ_mut() =
self.deref_tyvar(mem::take(param.typ_mut()), Contravariant, loc)?;
}
if let Some(var_args) = &mut subr.var_params {
*var_args.typ_mut() =
self.deref_tyvar(mem::take(var_args.typ_mut()), Contravariant, loc)?;
}
for d_param in subr.default_params.iter_mut() {
*d_param.typ_mut() =
self.deref_tyvar(mem::take(d_param.typ_mut()), Contravariant, loc)?;
}
subr.return_t =
Box::new(self.deref_tyvar(mem::take(&mut subr.return_t), Covariant, loc)?);
Ok(Type::Subr(subr))
}
Type::Ref(t) => {
let t = self.deref_tyvar(*t, variance, loc)?;
Ok(ref_(t))
}
Type::RefMut { before, after } => {
let before = self.deref_tyvar(*before, variance, loc)?;
let after = if let Some(after) = after {
Some(self.deref_tyvar(*after, variance, loc)?)
} else {
None
};
Ok(ref_mut(before, after))
}
// Type::Callable { .. } => todo!(),
Type::Record(mut rec) => {
for (_, field) in rec.iter_mut() {
*field = self.deref_tyvar(mem::take(field), variance, loc)?;
}
Ok(Type::Record(rec))
}
Type::Refinement(refine) => {
let t = self.deref_tyvar(*refine.t, variance, loc)?;
// TODO: deref_predicate
Ok(refinement(refine.var, t, refine.preds))
}
Type::And(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
Ok(self.intersection(&l, &r))
}
Type::Or(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
Ok(self.union(&l, &r))
}
Type::Not(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
// TODO: complement
Ok(not(l, r))
}
Type::Proj { lhs, rhs } => {
let lhs = self.deref_tyvar(*lhs, variance, loc)?;
self.eval_proj(lhs, rhs, self.level, loc)
}
Type::ProjCall {
lhs,
attr_name,
args,
} => {
let lhs = self.deref_tp(*lhs, variance, loc)?;
let mut new_args = vec![];
for arg in args.into_iter() {
new_args.push(self.deref_tp(arg, variance, loc)?);
}
self.eval_proj_call(lhs, attr_name, new_args, self.level, loc)
}
t => Ok(t),
}
}
pub(crate) fn trait_impl_exists(&self, class: &Type, trait_: &Type) -> bool {
if class.is_monomorphic() {
self.mono_class_trait_impl_exist(class, trait_)
} else {
self.poly_class_trait_impl_exists(class, trait_)
}
}
fn mono_class_trait_impl_exist(&self, class: &Type, trait_: &Type) -> bool {
let mut super_exists = false;
for inst in self.get_trait_impls(trait_).into_iter() {
if self.supertype_of(&inst.sub_type, class)
&& self.supertype_of(&inst.sup_trait, trait_)
{
super_exists = true;
break;
}
}
super_exists
}
fn poly_class_trait_impl_exists(&self, class: &Type, trait_: &Type) -> bool {
let mut super_exists = false;
for inst in self.get_trait_impls(trait_).into_iter() {
if self.supertype_of(&inst.sub_type, class)
&& self.supertype_of(&inst.sup_trait, trait_)
{
super_exists = true;
break;
}
}
super_exists
}
fn check_trait_impl(
&self,
class: &Type,
trait_: &Type,
loc: Location,
) -> SingleTyCheckResult<()> {
if !self.trait_impl_exists(class, trait_) {
Err(TyCheckError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
class,
trait_,
loc,
self.caused_by(),
None,
))
} else {
Ok(())
}
}
#[allow(clippy::only_used_in_recursion)]
/// Fix type variables at their lower bound
/// ```erg
/// i: ?T(:> Int)
/// assert i.Real == 1
/// i: (Int)
/// ```
pub(crate) fn coerce(&self, t: &Type) {
match t {
Type::FreeVar(fv) if fv.is_linked() => {
self.coerce(&fv.crack());
}
Type::FreeVar(fv) if fv.is_unbound() => {
let (sub, _sup) = fv.get_subsup().unwrap();
fv.link(&sub);
}
Type::And(l, r) | Type::Or(l, r) | Type::Not(l, r) => {
self.coerce(l);
self.coerce(r);
}
_ => {}
}
}
pub(crate) fn coerce_tp(&self, tp: &TyParam) {
match tp {
TyParam::FreeVar(fv) if fv.is_linked() => {
self.coerce_tp(&fv.crack());
}
TyParam::Type(t) => self.coerce(t),
_ => {}
}
}
/// Check if all types are resolvable (if traits, check if an implementation exists)
/// And replace them if resolvable
pub(crate) fn resolve(
&mut self,
mut hir: hir::HIR,
) -> Result<hir::HIR, (hir::HIR, TyCheckErrors)> {
self.level = 0;
let mut errs = TyCheckErrors::empty();
for chunk in hir.module.iter_mut() {
if let Err(es) = self.resolve_expr_t(chunk) {
errs.extend(es);
}
}
if errs.is_empty() {
Ok(hir)
} else {
Err((hir, errs))
}
}
fn resolve_expr_t(&self, expr: &mut hir::Expr) -> TyCheckResult<()> {
match expr {
hir::Expr::Lit(_) | hir::Expr::Dummy(_) => Ok(()),
hir::Expr::Accessor(acc) => {
let loc = acc.loc();
let t = acc.ref_mut_t();
*t = self.deref_tyvar(mem::take(t), Covariant, loc)?;
if let hir::Accessor::Attr(attr) = acc {
self.resolve_expr_t(&mut attr.obj)?;
}
Ok(())
}
hir::Expr::Array(array) => match array {
hir::Array::Normal(arr) => {
let loc = arr.loc();
arr.t = self.deref_tyvar(mem::take(&mut arr.t), Covariant, loc)?;
for elem in arr.elems.pos_args.iter_mut() {
self.resolve_expr_t(&mut elem.expr)?;
}
Ok(())
}
hir::Array::WithLength(arr) => {
let loc = arr.loc();
arr.t = self.deref_tyvar(mem::take(&mut arr.t), Covariant, loc)?;
self.resolve_expr_t(&mut arr.elem)?;
self.resolve_expr_t(&mut arr.len)?;
Ok(())
}
other => feature_error!(
TyCheckErrors,
TyCheckError,
self,
other.loc(),
"resolve types of array comprehension"
),
},
hir::Expr::Tuple(tuple) => match tuple {
hir::Tuple::Normal(tup) => {
for elem in tup.elems.pos_args.iter_mut() {
self.resolve_expr_t(&mut elem.expr)?;
}
Ok(())
}
},
hir::Expr::Set(set) => match set {
hir::Set::Normal(st) => {
let loc = st.loc();
st.t = self.deref_tyvar(mem::take(&mut st.t), Covariant, loc)?;
for elem in st.elems.pos_args.iter_mut() {
self.resolve_expr_t(&mut elem.expr)?;
}
Ok(())
}
hir::Set::WithLength(st) => {
let loc = st.loc();
st.t = self.deref_tyvar(mem::take(&mut st.t), Covariant, loc)?;
self.resolve_expr_t(&mut st.elem)?;
self.resolve_expr_t(&mut st.len)?;
Ok(())
}
},
hir::Expr::Dict(dict) => match dict {
hir::Dict::Normal(dic) => {
let loc = dic.loc();
dic.t = self.deref_tyvar(mem::take(&mut dic.t), Covariant, loc)?;
for kv in dic.kvs.iter_mut() {
self.resolve_expr_t(&mut kv.key)?;
self.resolve_expr_t(&mut kv.value)?;
}
Ok(())
}
other => feature_error!(
TyCheckErrors,
TyCheckError,
self,
other.loc(),
"resolve types of dict comprehension"
),
},
hir::Expr::Record(record) => {
for attr in record.attrs.iter_mut() {
match &mut attr.sig {
hir::Signature::Var(var) => {
*var.ref_mut_t() =
self.deref_tyvar(mem::take(var.ref_mut_t()), Covariant, var.loc())?;
}
hir::Signature::Subr(subr) => {
*subr.ref_mut_t() = self.deref_tyvar(
mem::take(subr.ref_mut_t()),
Covariant,
subr.loc(),
)?;
}
}
for chunk in attr.body.block.iter_mut() {
self.resolve_expr_t(chunk)?;
}
}
Ok(())
}
hir::Expr::BinOp(binop) => {
let loc = binop.loc();
let t = binop.signature_mut_t().unwrap();
*t = self.deref_tyvar(mem::take(t), Covariant, loc)?;
self.resolve_expr_t(&mut binop.lhs)?;
self.resolve_expr_t(&mut binop.rhs)?;
Ok(())
}
hir::Expr::UnaryOp(unaryop) => {
let loc = unaryop.loc();
let t = unaryop.signature_mut_t().unwrap();
*t = self.deref_tyvar(mem::take(t), Covariant, loc)?;
self.resolve_expr_t(&mut unaryop.expr)?;
Ok(())
}
hir::Expr::Call(call) => {
let loc = call.loc();
if let Some(t) = call.signature_mut_t() {
*t = self.deref_tyvar(mem::take(t), Covariant, loc)?;
}
self.resolve_expr_t(&mut call.obj)?;
for arg in call.args.pos_args.iter_mut() {
self.resolve_expr_t(&mut arg.expr)?;
}
if let Some(var_args) = &mut call.args.var_args {
self.resolve_expr_t(&mut var_args.expr)?;
}
for arg in call.args.kw_args.iter_mut() {
self.resolve_expr_t(&mut arg.expr)?;
}
Ok(())
}
hir::Expr::Def(def) => {
// It is not possible to further dereference the quantified type.
// TODO: However, it is possible that there are external type variables within the quantified type.
if !def.sig.ref_t().is_quantified() {
match &mut def.sig {
hir::Signature::Var(var) => {
*var.ref_mut_t() =
self.deref_tyvar(mem::take(var.ref_mut_t()), Covariant, var.loc())?;
}
hir::Signature::Subr(subr) => {
*subr.ref_mut_t() = self.deref_tyvar(
mem::take(subr.ref_mut_t()),
Covariant,
subr.loc(),
)?;
}
}
for chunk in def.body.block.iter_mut() {
self.resolve_expr_t(chunk)?;
}
}
Ok(())
}
hir::Expr::Lambda(lambda) => {
lambda.t = self.deref_tyvar(mem::take(&mut lambda.t), Covariant, lambda.loc())?;
for chunk in lambda.body.iter_mut() {
self.resolve_expr_t(chunk)?;
}
Ok(())
}
hir::Expr::ClassDef(class_def) => {
for def in class_def.methods.iter_mut() {
self.resolve_expr_t(def)?;
}
Ok(())
}
hir::Expr::PatchDef(patch_def) => {
for def in patch_def.methods.iter_mut() {
self.resolve_expr_t(def)?;
}
Ok(())
}
hir::Expr::AttrDef(attr_def) => {
// REVIEW: attr_def.attr is not dereferenced
for chunk in attr_def.block.iter_mut() {
self.resolve_expr_t(chunk)?;
}
Ok(())
}
hir::Expr::TypeAsc(tasc) => self.resolve_expr_t(&mut tasc.expr),
hir::Expr::Code(chunks) | hir::Expr::Compound(chunks) => {
for chunk in chunks.iter_mut() {
self.resolve_expr_t(chunk)?;
}
Ok(())
}
hir::Expr::Import(_) => unreachable!(),
}
}
// occur(X -> ?T, ?T) ==> Error
// occur(?T, ?T -> X) ==> Error
// occur(?T, Option(?T)) ==> Error
fn occur(&self, maybe_sub: &Type, maybe_sup: &Type, loc: Location) -> TyCheckResult<()> {
match (maybe_sub, maybe_sup) {
(Type::FreeVar(sub), Type::FreeVar(sup)) => {
if sub.is_unbound() && sup.is_unbound() && sub == sup {
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)))
} else {
Ok(())
}
}
(Type::Subr(subr), Type::FreeVar(fv)) if fv.is_unbound() => {
for default_t in subr.default_params.iter().map(|pt| pt.typ()) {
self.occur(default_t, maybe_sup, loc)?;
}
if let Some(var_params) = subr.var_params.as_ref() {
self.occur(var_params.typ(), maybe_sup, loc)?;
}
for non_default_t in subr.non_default_params.iter().map(|pt| pt.typ()) {
self.occur(non_default_t, maybe_sup, loc)?;
}
self.occur(&subr.return_t, maybe_sup, loc)?;
Ok(())
}
(Type::FreeVar(fv), Type::Subr(subr)) if fv.is_unbound() => {
for default_t in subr.default_params.iter().map(|pt| pt.typ()) {
self.occur(maybe_sub, default_t, loc)?;
}
if let Some(var_params) = subr.var_params.as_ref() {
self.occur(maybe_sub, var_params.typ(), loc)?;
}
for non_default_t in subr.non_default_params.iter().map(|pt| pt.typ()) {
self.occur(maybe_sub, non_default_t, loc)?;
}
self.occur(maybe_sub, &subr.return_t, loc)?;
Ok(())
}
(Type::Poly { params, .. }, Type::FreeVar(fv)) if fv.is_unbound() => {
for param in params.iter().filter_map(|tp| {
if let TyParam::Type(t) = tp {
Some(t)
} else {
None
}
}) {
self.occur(param, maybe_sup, loc)?;
}
Ok(())
}
(Type::FreeVar(fv), Type::Poly { params, .. }) if fv.is_unbound() => {
for param in params.iter().filter_map(|tp| {
if let TyParam::Type(t) = tp {
Some(t)
} else {
None
}
}) {
self.occur(maybe_sub, param, loc)?;
}
Ok(())
}
_ => Ok(()),
}
}
/// allow_divergence = trueにすると、Num型変数と±Infの単一化を許す
pub(crate) fn sub_unify_tp(
&self,
maybe_sub: &TyParam,
maybe_sup: &TyParam,
_variance: Option<Variance>,
loc: Location,
allow_divergence: bool,
) -> TyCheckResult<()> {
if maybe_sub.has_no_unbound_var()
&& maybe_sup.has_no_unbound_var()
&& maybe_sub == maybe_sup
{
return Ok(());
}
match (maybe_sub, maybe_sup) {
(TyParam::Type(maybe_sub), TyParam::Type(maybe_sup)) => {
self.sub_unify(maybe_sub, maybe_sup, loc, None)
}
(TyParam::FreeVar(lfv), TyParam::FreeVar(rfv))
if lfv.is_unbound() && rfv.is_unbound() =>
{
if lfv.level().unwrap() > rfv.level().unwrap() {
lfv.link(maybe_sup);
} else {
rfv.link(maybe_sub);
}
Ok(())
}
(TyParam::FreeVar(fv), tp) => {
match &*fv.borrow() {
FreeKind::Linked(l) | FreeKind::UndoableLinked { t: l, .. } => {
return self.sub_unify_tp(l, tp, _variance, loc, allow_divergence);
}
FreeKind::Unbound { .. } | FreeKind::NamedUnbound { .. } => {}
} // &fv is dropped
let fv_t = fv.constraint().unwrap().get_type().unwrap().clone(); // fvを参照しないよいにcloneする(あとでborrow_mutするため)
let tp_t = self.get_tp_t(tp)?;
if self.supertype_of(&fv_t, &tp_t) {
// 外部未連携型変数の場合、linkしないで制約を弱めるだけにする(see compiler/inference.md)
if fv.level() < Some(self.level) {
let new_constraint = Constraint::new_subtype_of(tp_t);
if self.is_sub_constraint_of(&fv.constraint().unwrap(), &new_constraint)
|| fv.constraint().unwrap().get_type() == Some(&Type)
{
fv.update_constraint(new_constraint);
}
} else {
fv.link(tp);
}
Ok(())
} else if allow_divergence
&& (self.eq_tp(tp, &TyParam::value(Inf))
|| self.eq_tp(tp, &TyParam::value(NegInf)))
&& self.subtype_of(&fv_t, &mono("Num"))
{
fv.link(tp);
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)))
}
}
(tp, TyParam::FreeVar(fv)) => {
match &*fv.borrow() {
FreeKind::Linked(l) | FreeKind::UndoableLinked { t: l, .. } => {
return self.sub_unify_tp(l, tp, _variance, loc, allow_divergence);
}
FreeKind::Unbound { .. } | FreeKind::NamedUnbound { .. } => {}
} // &fv is dropped
let fv_t = fv.constraint().unwrap().get_type().unwrap().clone(); // fvを参照しないよいにcloneする(あとでborrow_mutするため)
let tp_t = self.get_tp_t(tp)?;
if self.supertype_of(&fv_t, &tp_t) {
// 外部未連携型変数の場合、linkしないで制約を弱めるだけにする(see compiler/inference.md)
if fv.level() < Some(self.level) {
let new_constraint = Constraint::new_subtype_of(tp_t);
if self.is_sub_constraint_of(&fv.constraint().unwrap(), &new_constraint)
|| fv.constraint().unwrap().get_type() == Some(&Type)
{
fv.update_constraint(new_constraint);
}
} else {
fv.link(tp);
}
Ok(())
} else if allow_divergence
&& (self.eq_tp(tp, &TyParam::value(Inf))
|| self.eq_tp(tp, &TyParam::value(NegInf)))
&& self.subtype_of(&fv_t, &mono("Num"))
{
fv.link(tp);
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)))
}
}
(TyParam::UnaryOp { op: lop, val: lval }, TyParam::UnaryOp { op: rop, val: rval })
if lop == rop =>
{
self.sub_unify_tp(lval, rval, _variance, loc, allow_divergence)
}
(
TyParam::BinOp { op: lop, lhs, rhs },
TyParam::BinOp {
op: rop,
lhs: lhs2,
rhs: rhs2,
},
) if lop == rop => {
self.sub_unify_tp(lhs, lhs2, _variance, loc, allow_divergence)?;
self.sub_unify_tp(rhs, rhs2, _variance, loc, allow_divergence)
}
(l, TyParam::Erased(t)) => {
let sub_t = self.get_tp_t(l)?;
if self.subtype_of(&sub_t, t) {
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&sub_t,
t,
loc,
self.caused_by(),
)))
}
}
(l, TyParam::Type(r)) => {
let l = self
.convert_tp_into_ty(l.clone())
.unwrap_or_else(|_| todo!("{l} cannot be a type"));
self.sub_unify(&l, r, loc, None)?;
Ok(())
}
(TyParam::Type(l), r) => {
let r = self
.convert_tp_into_ty(r.clone())
.unwrap_or_else(|_| todo!("{r} cannot be a type"));
self.sub_unify(l, &r, loc, None)?;
Ok(())
}
(TyParam::Array(ls), TyParam::Array(rs)) | (TyParam::Tuple(ls), TyParam::Tuple(rs)) => {
for (l, r) in ls.iter().zip(rs.iter()) {
self.sub_unify_tp(l, r, _variance, loc, allow_divergence)?;
}
Ok(())
}
(TyParam::Dict(ls), TyParam::Dict(rs)) => {
for (lk, lv) in ls.iter() {
if let Some(rv) = rs.get(lk) {
self.sub_unify_tp(lv, rv, _variance, loc, allow_divergence)?;
} else {
// TODO:
return Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)));
}
}
Ok(())
}
(l, r) => panic!("type-parameter unification failed:\nl:{l}\nr: {r}"),
}
}
fn reunify_tp(
&self,
before: &TyParam,
after: &TyParam,
loc: Location,
) -> SingleTyCheckResult<()> {
match (before, after) {
(TyParam::Value(ValueObj::Mut(l)), TyParam::Value(ValueObj::Mut(r))) => {
*l.borrow_mut() = r.borrow().clone();
Ok(())
}
(TyParam::Value(ValueObj::Mut(l)), TyParam::Value(r)) => {
*l.borrow_mut() = r.clone();
Ok(())
}
/*(TyParam::Value(ValueObj::Mut(l)), TyParam::Erased(_)) => {
*l.borrow_mut() = after.clone();
Ok(())
}*/
(TyParam::Type(l), TyParam::Type(r)) => self.reunify(l, r, loc),
(TyParam::UnaryOp { op: lop, val: lval }, TyParam::UnaryOp { op: rop, val: rval })
if lop == rop =>
{
self.reunify_tp(lval, rval, loc)
}
(
TyParam::BinOp { op: lop, lhs, rhs },
TyParam::BinOp {
op: rop,
lhs: lhs2,
rhs: rhs2,
},
) if lop == rop => {
self.reunify_tp(lhs, lhs2, loc)?;
self.reunify_tp(rhs, rhs2, loc)
}
(l, r) if self.eq_tp(l, r) => Ok(()),
(l, r) => panic!("type-parameter re-unification failed:\nl: {l}\nr: {r}"),
}
}
/// predは正規化されているとする
fn sub_unify_pred(
&self,
l_pred: &Predicate,
r_pred: &Predicate,
loc: Location,
) -> TyCheckResult<()> {
match (l_pred, r_pred) {
(Pred::Value(_), Pred::Value(_)) | (Pred::Const(_), Pred::Const(_)) => Ok(()),
(Pred::Equal { rhs, .. }, Pred::Equal { rhs: rhs2, .. })
| (Pred::GreaterEqual { rhs, .. }, Pred::GreaterEqual { rhs: rhs2, .. })
| (Pred::LessEqual { rhs, .. }, Pred::LessEqual { rhs: rhs2, .. })
| (Pred::NotEqual { rhs, .. }, Pred::NotEqual { rhs: rhs2, .. }) => {
self.sub_unify_tp(rhs, rhs2, None, loc, false)
}
(Pred::And(l1, r1), Pred::And(l2, r2))
| (Pred::Or(l1, r1), Pred::Or(l2, r2))
| (Pred::Not(l1, r1), Pred::Not(l2, r2)) => {
match (
self.sub_unify_pred(l1, l2, loc),
self.sub_unify_pred(r1, r2, loc),
) {
(Ok(()), Ok(())) => Ok(()),
(Ok(()), Err(e)) | (Err(e), Ok(())) | (Err(e), Err(_)) => Err(e),
}
}
// unify({I >= 0}, {I >= ?M and I <= ?N}): ?M => 0, ?N => Inf
(Pred::GreaterEqual { rhs, .. }, Pred::And(l, r))
| (Predicate::And(l, r), Pred::GreaterEqual { rhs, .. }) => {
match (l.as_ref(), r.as_ref()) {
(
Pred::GreaterEqual { rhs: ge_rhs, .. },
Pred::LessEqual { rhs: le_rhs, .. },
)
| (
Pred::LessEqual { rhs: le_rhs, .. },
Pred::GreaterEqual { rhs: ge_rhs, .. },
) => {
self.sub_unify_tp(rhs, ge_rhs, None, loc, false)?;
self.sub_unify_tp(le_rhs, &TyParam::value(Inf), None, loc, true)
}
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
}
}
(Pred::LessEqual { rhs, .. }, Pred::And(l, r))
| (Pred::And(l, r), Pred::LessEqual { rhs, .. }) => match (l.as_ref(), r.as_ref()) {
(Pred::GreaterEqual { rhs: ge_rhs, .. }, Pred::LessEqual { rhs: le_rhs, .. })
| (Pred::LessEqual { rhs: le_rhs, .. }, Pred::GreaterEqual { rhs: ge_rhs, .. }) => {
self.sub_unify_tp(rhs, le_rhs, None, loc, false)?;
self.sub_unify_tp(ge_rhs, &TyParam::value(NegInf), None, loc, true)
}
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
},
(Pred::Equal { rhs, .. }, Pred::And(l, r))
| (Pred::And(l, r), Pred::Equal { rhs, .. }) => match (l.as_ref(), r.as_ref()) {
(Pred::GreaterEqual { rhs: ge_rhs, .. }, Pred::LessEqual { rhs: le_rhs, .. })
| (Pred::LessEqual { rhs: le_rhs, .. }, Pred::GreaterEqual { rhs: ge_rhs, .. }) => {
self.sub_unify_tp(rhs, le_rhs, None, loc, false)?;
self.sub_unify_tp(rhs, ge_rhs, None, loc, false)
}
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
},
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
}
}
/// T: Array(Int, !0), U: Array(Int, !1)
/// reunify(T, U):
/// T: Array(Int, !1), U: Array(Int, !1)
pub(crate) fn reunify(
&self,
before_t: &Type,
after_t: &Type,
loc: Location,
) -> SingleTyCheckResult<()> {
match (before_t, after_t) {
(Type::FreeVar(fv), r) if fv.is_linked() => self.reunify(&fv.crack(), r, loc),
(l, Type::FreeVar(fv)) if fv.is_linked() => self.reunify(l, &fv.crack(), loc),
(Type::Ref(l), Type::Ref(r)) => self.reunify(l, r, loc),
(
Type::RefMut {
before: lbefore,
after: lafter,
},
Type::RefMut {
before: rbefore,
after: rafter,
},
) => {
self.reunify(lbefore, rbefore, loc)?;
match (lafter, rafter) {
(Some(lafter), Some(rafter)) => {
self.reunify(lafter, rafter, loc)?;
}
(None, None) => {}
_ => todo!(),
}
Ok(())
}
(Type::Ref(l), r) => self.reunify(l, r, loc),
// REVIEW:
(Type::RefMut { before, .. }, r) => self.reunify(before, r, loc),
(l, Type::Ref(r)) => self.reunify(l, r, loc),
(l, Type::RefMut { before, .. }) => self.reunify(l, before, loc),
(
Type::Poly {
name: ln,
params: lps,
},
Type::Poly {
name: rn,
params: rps,
},
) => {
if ln != rn {
let before_t = poly(ln.clone(), lps.clone());
return Err(TyCheckError::re_unification_error(
self.cfg.input.clone(),
line!() as usize,
&before_t,
after_t,
loc,
self.caused_by(),
));
}
for (l, r) in lps.iter().zip(rps.iter()) {
self.reunify_tp(l, r, loc)?;
}
Ok(())
}
(l, r) if self.same_type_of(l, r) => Ok(()),
(l, r) => Err(TyCheckError::re_unification_error(
self.cfg.input.clone(),
line!() as usize,
l,
r,
loc,
self.caused_by(),
)),
}
}
/// Assuming that `sub` is a subtype of `sup`, fill in the type variable to satisfy the assumption
///
/// When comparing arguments and parameter, the left side (`sub`) is the argument (found) and the right side (`sup`) is the parameter (expected)
///
/// The parameter type must be a supertype of the argument type
/// ```python
/// sub_unify({I: Int | I == 0}, ?T(<: Ord)): (/* OK */)
/// sub_unify(Int, ?T(:> Nat)): (?T :> Int)
/// sub_unify(Nat, ?T(:> Int)): (/* OK */)
/// sub_unify(Nat, Add(?R)): (?R => Nat, Nat.Output => Nat)
/// sub_unify([?T; 0], Mutate): (/* OK */)
/// ```
pub(crate) fn sub_unify(
&self,
maybe_sub: &Type,
maybe_sup: &Type,
loc: Location,
param_name: Option<&Str>,
) -> TyCheckResult<()> {
log!(info "trying sub_unify:\nmaybe_sub: {maybe_sub}\nmaybe_sup: {maybe_sup}");
// In this case, there is no new information to be gained
// この場合、特に新しく得られる情報はない
if maybe_sub == &Type::Never || maybe_sup == &Type::Obj || maybe_sup == maybe_sub {
return Ok(());
}
// API definition was failed and inspection is useless after this
if maybe_sub == &Type::Failure || maybe_sup == &Type::Failure {
return Ok(());
}
self.occur(maybe_sub, maybe_sup, loc)?;
let maybe_sub_is_sub = self.subtype_of(maybe_sub, maybe_sup);
if maybe_sub.has_no_unbound_var() && maybe_sup.has_no_unbound_var() && maybe_sub_is_sub {
return Ok(());
}
if !maybe_sub_is_sub {
log!(err "{maybe_sub} !<: {maybe_sup}");
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
param_name.unwrap_or(&Str::ever("_")),
None,
maybe_sup,
maybe_sub,
self.get_candidates(maybe_sub),
Self::get_simple_type_mismatch_hint(maybe_sup, maybe_sub),
)));
}
match (maybe_sub, maybe_sup) {
/*
(Type::FreeVar(fv), _) if fv.is_generalized() => todo!("{maybe_sub}, {maybe_sup}"),
(_, Type::FreeVar(fv)) if fv.is_generalized() => todo!("{maybe_sub}, {maybe_sup}"),
*/
// lfv's sup can be shrunk (take min), rfv's sub can be expanded (take union)
// lfvのsupは縮小可能(minを取る)、rfvのsubは拡大可能(unionを取る)
// sub_unify(?T[0](:> Never, <: Int), ?U[1](:> Never, <: Nat)): (/* ?U[1] --> ?T[0](:> Never, <: Nat))
// sub_unify(?T[1](:> Never, <: Nat), ?U[0](:> Never, <: Int)): (/* ?T[1] --> ?U[0](:> Never, <: Nat))
// sub_unify(?T[0](:> Never, <: Str), ?U[1](:> Never, <: Int)): (?T[0](:> Never, <: Str and Int) --> Error!)
// sub_unify(?T[0](:> Int, <: Add()), ?U[1](:> Never, <: Mul())): (?T[0](:> Int, <: Add() and Mul()))
// sub_unify(?T[0](:> Str, <: Obj), ?U[1](:> Int, <: Obj)): (/* ?U[1] --> ?T[0](:> Str or Int) */)
(Type::FreeVar(lfv), Type::FreeVar(rfv))
if lfv.constraint_is_sandwiched() && rfv.constraint_is_sandwiched() =>
{
let (lsub, lsup) = lfv.get_subsup().unwrap();
let (rsub, rsup) = rfv.get_subsup().unwrap();
let intersec = self.intersection(&lsup, &rsup);
let new_constraint = if intersec != Type::Never {
Constraint::new_sandwiched(self.union(&lsub, &rsub), intersec)
} else {
return Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)));
};
if lfv.level().unwrap() <= rfv.level().unwrap() {
lfv.update_constraint(new_constraint);
rfv.link(maybe_sub);
} else {
rfv.update_constraint(new_constraint);
lfv.link(maybe_sup);
}
Ok(())
}
(Type::FreeVar(lfv), _) if lfv.is_linked() => {
self.sub_unify(&lfv.crack(), maybe_sup, loc, param_name)
}
(_, Type::FreeVar(rfv)) if rfv.is_linked() => {
self.sub_unify(maybe_sub, &rfv.crack(), loc, param_name)
}
(_, Type::FreeVar(rfv)) if rfv.is_unbound() => {
// NOTE: cannot `borrow_mut` because of cycle reference
let rfv_ref = unsafe { rfv.as_ptr().as_mut().unwrap() };
match rfv_ref {
FreeKind::NamedUnbound { constraint, .. }
| FreeKind::Unbound { constraint, .. } => match constraint {
// * sub_unify(Nat, ?E(<: Eq(?E)))
// sub !<: l => OK (sub will widen)
// sup !:> l => Error
// * sub_unify(Str, ?T(:> _, <: Int)): (/* Error */)
// * sub_unify(Ratio, ?T(:> _, <: Int)): (/* Error */)
// sub = max(l, sub) if max exists
// * sub_unify(Nat, ?T(:> Int, <: _)): (/* OK */)
// * sub_unify(Int, ?T(:> Nat, <: Obj)): (?T(:> Int, <: Obj))
// * sub_unify(Nat, ?T(:> Never, <: Add(?R))): (?T(:> Nat, <: Add(?R))
// sub = union(l, sub) if max does not exist
// * sub_unify(Str, ?T(:> Int, <: Obj)): (?T(:> Str or Int, <: Obj))
// * sub_unify({0}, ?T(:> {1}, <: Nat)): (?T(:> {0, 1}, <: Nat))
// * sub_unify(Bool, ?T(<: Bool or Y)): (?T == Bool)
Constraint::Sandwiched { sub, sup } => {
/*if let Some(new_sub) = self.max(maybe_sub, sub) {
*constraint =
Constraint::new_sandwiched(new_sub.clone(), mem::take(sup), *cyclicity);
} else {*/
let new_sub = self.union(maybe_sub, sub);
if sup.contains_union(&new_sub) {
rfv.link(&new_sub); // Bool <: ?T <: Bool or Y ==> ?T == Bool
} else {
*constraint = Constraint::new_sandwiched(new_sub, mem::take(sup));
}
// }
}
// sub_unify(Nat, ?T(: Type)): (/* ?T(:> Nat) */)
Constraint::TypeOf(ty) => {
if self.supertype_of(&Type, ty) {
*constraint = Constraint::new_supertype_of(maybe_sub.clone());
} else {
todo!()
}
}
_ => unreachable!(),
},
_ => {}
}
Ok(())
}
(Type::FreeVar(lfv), _) if lfv.is_unbound() => {
let lfv_ref = unsafe { lfv.as_ptr().as_mut().unwrap() };
match lfv_ref {
FreeKind::NamedUnbound { constraint, .. }
| FreeKind::Unbound { constraint, .. } => match constraint {
// sub !<: r => Error
// * sub_unify(?T(:> Int, <: _), Nat): (/* Error */)
// * sub_unify(?T(:> Nat, <: _), Str): (/* Error */)
// sup !:> r => Error
// * sub_unify(?T(:> _, <: Str), Int): (/* Error */)
// * sub_unify(?T(:> _, <: Int), Nat): (/* Error */)
// sub <: r, sup :> r => sup = min(sup, r) if min exists
// * sub_unify(?T(:> Never, <: Nat), Int): (/* OK */)
// * sub_unify(?T(:> Nat, <: Obj), Int): (?T(:> Nat, <: Int))
// sup = union(sup, r) if min does not exist
// * sub_unify(?T(:> Never, <: {1}), {0}): (?T(:> Never, <: {0, 1}))
Constraint::Sandwiched { sub, sup } => {
// REVIEW: correct?
if let Some(new_sup) = self.min(sup, maybe_sup) {
*constraint =
Constraint::new_sandwiched(mem::take(sub), new_sup.clone());
} else {
let new_sup = self.union(sup, maybe_sup);
*constraint = Constraint::new_sandwiched(mem::take(sub), new_sup);
}
}
// sub_unify(?T(: Type), Int): (?T(<: Int))
Constraint::TypeOf(ty) => {
if self.supertype_of(&Type, ty) {
*constraint = Constraint::new_subtype_of(maybe_sup.clone());
} else {
todo!()
}
}
_ => unreachable!(),
},
_ => {}
}
Ok(())
}
(Type::FreeVar(_fv), _r) => todo!(),
(Type::Record(lrec), Type::Record(rrec)) => {
for (k, l) in lrec.iter() {
if let Some(r) = rrec.get(k) {
self.sub_unify(l, r, loc, param_name)?;
} else {
return Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)));
}
}
Ok(())
}
(Type::Subr(lsub), Type::Subr(rsub)) => {
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
// contravariant
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
// contravariant
self.sub_unify(r.typ(), l.typ(), loc, param_name)
})?;
// covariant
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
Ok(())
}
(Type::Quantified(lsub), Type::Subr(rsub)) => {
let Type::Subr(lsub) = lsub.as_ref() else { unreachable!() };
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
if lpt.typ().is_generalized() {
continue;
}
// contravariant
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
if l.typ().is_generalized() {
Ok(())
}
// contravariant
else {
self.sub_unify(r.typ(), l.typ(), loc, param_name)
}
})?;
// covariant
if !lsub.return_t.is_generalized() {
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
}
Ok(())
}
(Type::Subr(lsub), Type::Quantified(rsub)) => {
let Type::Subr(rsub) = rsub.as_ref() else { unreachable!() };
for lpt in lsub.default_params.iter() {
if let Some(rpt) = rsub
.default_params
.iter()
.find(|rpt| rpt.name() == lpt.name())
{
// contravariant
if rpt.typ().is_generalized() {
continue;
}
self.sub_unify(rpt.typ(), lpt.typ(), loc, param_name)?;
} else {
todo!()
}
}
lsub.non_default_params
.iter()
.zip(rsub.non_default_params.iter())
.try_for_each(|(l, r)| {
// contravariant
if r.typ().is_generalized() {
Ok(())
} else {
self.sub_unify(r.typ(), l.typ(), loc, param_name)
}
})?;
// covariant
if !rsub.return_t.is_generalized() {
self.sub_unify(&lsub.return_t, &rsub.return_t, loc, param_name)?;
}
Ok(())
}
(
Type::Poly {
name: ln,
params: lps,
},
Type::Poly {
name: rn,
params: rps,
},
) => {
// e.g. Set(?T) <: Eq(Set(?T))
// Array(Str) <: Iterable(Str)
if ln != rn {
if let Some((sub_def_t, sub_ctx)) = self.get_nominal_type_ctx(maybe_sub) {
self.substitute_typarams(sub_def_t, maybe_sub);
for sup_trait in sub_ctx.super_traits.iter() {
if self.supertype_of(maybe_sup, sup_trait) {
for (l_maybe_sub, r_maybe_sup) in
sup_trait.typarams().iter().zip(rps.iter())
{
self.sub_unify_tp(l_maybe_sub, r_maybe_sup, None, loc, false)
.map_err(|e| {
self.undo_substitute_typarams(sub_def_t);
e
})?;
}
self.undo_substitute_typarams(sub_def_t);
return Ok(());
}
}
}
Err(TyCheckErrors::from(TyCheckError::unification_error(
self.cfg.input.clone(),
line!() as usize,
maybe_sub,
maybe_sup,
loc,
self.caused_by(),
)))
} else {
for (l_maybe_sub, r_maybe_sup) in lps.iter().zip(rps.iter()) {
self.sub_unify_tp(l_maybe_sub, r_maybe_sup, None, loc, false)?;
}
Ok(())
}
}
// (X or Y) <: Z is valid when X <: Z and Y <: Z
(Type::Or(l, r), _) => {
self.sub_unify(l, maybe_sup, loc, param_name)?;
self.sub_unify(r, maybe_sup, loc, param_name)
}
// X <: (Y and Z) is valid when X <: Y and X <: Z
(_, Type::And(l, r)) => {
self.sub_unify(maybe_sub, l, loc, param_name)?;
self.sub_unify(maybe_sub, r, loc, param_name)
}
// (X and Y) <: Z is valid when X <: Z or Y <: Z
(Type::And(l, r), _) => self
.sub_unify(l, maybe_sup, loc, param_name)
.or_else(|_e| self.sub_unify(r, maybe_sup, loc, param_name)),
// X <: (Y or Z) is valid when X <: Y or X <: Z
(_, Type::Or(l, r)) => self
.sub_unify(maybe_sub, l, loc, param_name)
.or_else(|_e| self.sub_unify(maybe_sub, r, loc, param_name)),
(_, Type::Ref(t)) => self.sub_unify(maybe_sub, t, loc, param_name),
(_, Type::RefMut { before, .. }) => self.sub_unify(maybe_sub, before, loc, param_name),
(Type::Proj { .. }, _) => todo!(),
(_, Type::Proj { .. }) => todo!(),
// TODO: Judgment for any number of preds
(Refinement(sub), Refinement(sup)) => {
// {I: Int or Str | I == 0} <: {I: Int}
if self.subtype_of(&sub.t, &sup.t) {
self.sub_unify(&sub.t, &sup.t, loc, param_name)?;
}
if sup.preds.is_empty() {
self.sub_unify(&sub.t, &sup.t, loc, param_name)?;
return Ok(());
}
if sub.preds.len() == 1 && sup.preds.len() == 1 {
let sub_first = sub.preds.iter().next().unwrap();
let sup_first = sup.preds.iter().next().unwrap();
self.sub_unify_pred(sub_first, sup_first, loc)?;
return Ok(());
}
todo!("{sub}, {sup}")
}
// {I: Int | I >= 1} <: Nat == {I: Int | I >= 0}
(Type::Refinement(_), sup) => {
let sup = sup.clone().into_refinement();
self.sub_unify(maybe_sub, &Type::Refinement(sup), loc, param_name)
}
(Type::Subr(_) | Type::Record(_), Type) => Ok(()),
// REVIEW: correct?
(Type::Poly { name, .. }, Type) if &name[..] == "Array" || &name[..] == "Tuple" => {
Ok(())
}
(Type::Subr(_), Mono(name)) if &name[..] == "GenericCallable" => Ok(()),
_ => type_feature_error!(
self,
loc,
&format!("{maybe_sub} can be a subtype of {maybe_sup}, but failed to semi-unify")
),
}
}sourcepub fn pred_unification_error(
input: Input,
errno: usize,
lhs: &Predicate,
rhs: &Predicate,
caused_by: String
) -> Self
pub fn pred_unification_error(
input: Input,
errno: usize,
lhs: &Predicate,
rhs: &Predicate,
caused_by: String
) -> Self
Examples found in repository?
context/tyvar.rs (lines 1242-1248)
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
fn sub_unify_pred(
&self,
l_pred: &Predicate,
r_pred: &Predicate,
loc: Location,
) -> TyCheckResult<()> {
match (l_pred, r_pred) {
(Pred::Value(_), Pred::Value(_)) | (Pred::Const(_), Pred::Const(_)) => Ok(()),
(Pred::Equal { rhs, .. }, Pred::Equal { rhs: rhs2, .. })
| (Pred::GreaterEqual { rhs, .. }, Pred::GreaterEqual { rhs: rhs2, .. })
| (Pred::LessEqual { rhs, .. }, Pred::LessEqual { rhs: rhs2, .. })
| (Pred::NotEqual { rhs, .. }, Pred::NotEqual { rhs: rhs2, .. }) => {
self.sub_unify_tp(rhs, rhs2, None, loc, false)
}
(Pred::And(l1, r1), Pred::And(l2, r2))
| (Pred::Or(l1, r1), Pred::Or(l2, r2))
| (Pred::Not(l1, r1), Pred::Not(l2, r2)) => {
match (
self.sub_unify_pred(l1, l2, loc),
self.sub_unify_pred(r1, r2, loc),
) {
(Ok(()), Ok(())) => Ok(()),
(Ok(()), Err(e)) | (Err(e), Ok(())) | (Err(e), Err(_)) => Err(e),
}
}
// unify({I >= 0}, {I >= ?M and I <= ?N}): ?M => 0, ?N => Inf
(Pred::GreaterEqual { rhs, .. }, Pred::And(l, r))
| (Predicate::And(l, r), Pred::GreaterEqual { rhs, .. }) => {
match (l.as_ref(), r.as_ref()) {
(
Pred::GreaterEqual { rhs: ge_rhs, .. },
Pred::LessEqual { rhs: le_rhs, .. },
)
| (
Pred::LessEqual { rhs: le_rhs, .. },
Pred::GreaterEqual { rhs: ge_rhs, .. },
) => {
self.sub_unify_tp(rhs, ge_rhs, None, loc, false)?;
self.sub_unify_tp(le_rhs, &TyParam::value(Inf), None, loc, true)
}
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
}
}
(Pred::LessEqual { rhs, .. }, Pred::And(l, r))
| (Pred::And(l, r), Pred::LessEqual { rhs, .. }) => match (l.as_ref(), r.as_ref()) {
(Pred::GreaterEqual { rhs: ge_rhs, .. }, Pred::LessEqual { rhs: le_rhs, .. })
| (Pred::LessEqual { rhs: le_rhs, .. }, Pred::GreaterEqual { rhs: ge_rhs, .. }) => {
self.sub_unify_tp(rhs, le_rhs, None, loc, false)?;
self.sub_unify_tp(ge_rhs, &TyParam::value(NegInf), None, loc, true)
}
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
},
(Pred::Equal { rhs, .. }, Pred::And(l, r))
| (Pred::And(l, r), Pred::Equal { rhs, .. }) => match (l.as_ref(), r.as_ref()) {
(Pred::GreaterEqual { rhs: ge_rhs, .. }, Pred::LessEqual { rhs: le_rhs, .. })
| (Pred::LessEqual { rhs: le_rhs, .. }, Pred::GreaterEqual { rhs: ge_rhs, .. }) => {
self.sub_unify_tp(rhs, le_rhs, None, loc, false)?;
self.sub_unify_tp(rhs, ge_rhs, None, loc, false)
}
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
},
_ => Err(TyCheckErrors::from(TyCheckError::pred_unification_error(
self.cfg.input.clone(),
line!() as usize,
l_pred,
r_pred,
self.caused_by(),
))),
}
}sourcepub fn no_candidate_error(
input: Input,
errno: usize,
proj: &Type,
loc: Location,
caused_by: String,
hint: Option<String>
) -> Self
pub fn no_candidate_error(
input: Input,
errno: usize,
proj: &Type,
loc: Location,
caused_by: String,
hint: Option<String>
) -> Self
Examples found in repository?
context/eval.rs (lines 1014-1021)
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
pub(crate) fn eval_proj(
&self,
lhs: Type,
rhs: Str,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
// Currently Erg does not allow projection-types to be evaluated with type variables included.
// All type variables will be dereferenced or fail.
let (sub, opt_sup) = match lhs.clone() {
Type::FreeVar(fv) if fv.is_linked() => {
return self.eval_t_params(proj(fv.crack().clone(), rhs), level, t_loc)
}
Type::FreeVar(fv) if fv.is_unbound() => {
let (sub, sup) = fv.get_subsup().unwrap();
(sub, Some(sup))
}
other => (other, None),
};
// cannot determine at this point
if sub == Type::Never {
return Ok(proj(lhs, rhs));
}
// in Methods
if self.name == sub.qual_name() {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, self, level, t_loc)
{
return Ok(t);
}
}
for ty_ctx in self.get_nominal_super_type_ctxs(&sub).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&sub,
)
})? {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, ty_ctx, level, t_loc)
{
return Ok(t);
}
for (class, methods) in ty_ctx.methods_list.iter() {
match (&class, &opt_sup) {
(ClassDefType::ImplTrait { impl_trait, .. }, Some(sup)) => {
if !self.supertype_of(impl_trait, sup) {
continue;
}
}
(ClassDefType::ImplTrait { impl_trait, .. }, None) => {
if !self.supertype_of(impl_trait, &sub) {
continue;
}
}
_ => {}
}
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, methods, level, t_loc)
{
return Ok(t);
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, Type::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tyvar(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj(coerced, rhs);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce(&lhs);
t
})
} else {
let proj = proj(lhs, rhs);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}
pub(crate) fn convert_tp_into_ty(&self, tp: TyParam) -> Result<Type, ()> {
match tp {
TyParam::Array(tps) => {
let len = tps.len();
let mut t = Type::Never;
for elem_tp in tps {
let elem_t = self.convert_tp_into_ty(elem_tp)?;
// not union
t = self.union(&t, &elem_t);
}
Ok(array_t(t, TyParam::value(len)))
}
TyParam::FreeVar(fv) if fv.is_linked() => self.convert_tp_into_ty(fv.crack().clone()),
TyParam::Type(t) => Ok(t.as_ref().clone()),
TyParam::Value(v) => Type::try_from(v),
// TODO: Array, Dict, Set
_ => Err(()),
}
}
fn _convert_type_to_dict_type(&self, ty: Type) -> Result<Dict<Type, Type>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Dict" => {
let dict = Dict::try_from(params[0].clone())?;
let mut new_dict = dict! {};
for (k, v) in dict.into_iter() {
let k = self.convert_tp_into_ty(k)?;
let v = self.convert_tp_into_ty(v)?;
new_dict.insert(k, v);
}
Ok(new_dict)
}
_ => Err(()),
}
}
fn convert_type_to_array(&self, ty: Type) -> Result<Vec<ValueObj>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Array" || &name[..] == "Array!" => {
let t = self.convert_tp_into_ty(params[0].clone())?;
let len = enum_unwrap!(params[1], TyParam::Value:(ValueObj::Nat:(_)));
Ok(vec![ValueObj::builtin_t(t); len as usize])
}
_ => Err(()),
}
}
pub(crate) fn convert_value_into_array(&self, val: ValueObj) -> Result<Vec<ValueObj>, ()> {
match val {
ValueObj::Array(arr) => Ok(arr.to_vec()),
ValueObj::Type(t) => self.convert_type_to_array(t.into_typ()),
_ => Err(()),
}
}
fn validate_and_project(
&self,
sub: &Type,
opt_sup: Option<&Type>,
rhs: &str,
methods: &Context,
level: usize,
t_loc: Location,
) -> Option<Type> {
// e.g. sub: Int, opt_sup: Add(?T), rhs: Output, methods: Int.methods
// sub: [Int; 4], opt_sup: Add([Int; 2]), rhs: Output, methods: [T; N].methods
if let Ok(obj) = methods.get_const_local(&Token::symbol(rhs), &self.name) {
#[allow(clippy::single_match)]
// opt_sup: Add(?T), methods.impl_of(): Add(Int)
// opt_sup: Add([Int; 2]), methods.impl_of(): Add([T; M])
match (&opt_sup, methods.impl_of()) {
(Some(sup), Some(trait_)) => {
if !self.supertype_of(&trait_, sup) {
return None;
}
}
_ => {}
}
// obj: Int|<: Add(Int)|.Output == ValueObj::Type(<type Int>)
// obj: [T; N]|<: Add([T; M])|.Output == ValueObj::Type(<type [T; M+N]>)
if let ValueObj::Type(quant_projected_t) = obj {
let projected_t = quant_projected_t.into_typ();
let (quant_sub, _) = self.rec_get_type(&sub.local_name()).unwrap();
if let Some(sup) = opt_sup {
if let Some(quant_sup) = methods.impl_of() {
// T -> Int, M -> 2
self.substitute_typarams(&quant_sup, sup);
}
}
// T -> Int, N -> 4
self.substitute_typarams(quant_sub, sub);
// [T; M+N] -> [Int; 4+2] -> [Int; 6]
let res = self.eval_t_params(projected_t, level, t_loc).ok();
if let Some(t) = res {
let mut tv_cache = TyVarCache::new(self.level, self);
let t = self.detach(t, &mut tv_cache);
// Int -> T, 2 -> M, 4 -> N
self.undo_substitute_typarams(quant_sub);
if let Some(quant_sup) = methods.impl_of() {
self.undo_substitute_typarams(&quant_sup);
}
return Some(t);
}
} else {
todo!()
}
}
None
}
/// e.g.
/// F((Int), 3) => F(Int, 3)
/// F(?T, ?T) => F(?1, ?1)
fn detach(&self, ty: Type, tv_cache: &mut TyVarCache) -> Type {
match ty {
Type::FreeVar(fv) if fv.is_linked() => self.detach(fv.crack().clone(), tv_cache),
Type::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(t) = tv_cache.get_tyvar(&name) {
t.clone()
} else {
let tv = Type::FreeVar(new_fv);
tv_cache.push_or_init_tyvar(&name, &tv);
tv
}
}
Type::Poly { name, params } => {
let mut new_params = vec![];
for param in params {
new_params.push(self.detach_tp(param, tv_cache));
}
poly(name, new_params)
}
_ => ty,
}
}
fn detach_tp(&self, tp: TyParam, tv_cache: &mut TyVarCache) -> TyParam {
match tp {
TyParam::FreeVar(fv) if fv.is_linked() => self.detach_tp(fv.crack().clone(), tv_cache),
TyParam::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(tp) = tv_cache.get_typaram(&name) {
tp.clone()
} else {
let tp = TyParam::FreeVar(new_fv);
tv_cache.push_or_init_typaram(&name, &tp);
tp
}
}
TyParam::Type(t) => TyParam::t(self.detach(*t, tv_cache)),
_ => tp,
}
}
#[allow(clippy::only_used_in_recursion)]
/// e.g. qt: Array(T, N), st: Array(Int, 3)
pub(crate) fn substitute_typarams(&self, qt: &Type, st: &Type) {
let qtps = qt.typarams();
let stps = st.typarams();
if qtps.len() != stps.len() {
log!(err "{} {}", erg_common::fmt_vec(&qtps), erg_common::fmt_vec(&stps));
return; // TODO: e.g. Sub(Int) / Eq and Sub(?T)
}
for (qtp, stp) in qtps.into_iter().zip(stps.into_iter()) {
match qtp {
TyParam::FreeVar(fv) if fv.is_generalized() => {
if !stp.is_generalized() {
fv.undoable_link(&stp);
}
}
TyParam::Type(t) if t.is_generalized() => {
let qt = enum_unwrap!(t.as_ref(), Type::FreeVar);
let st = enum_unwrap!(stp, TyParam::Type);
if !st.is_generalized() {
qt.undoable_link(&st);
}
}
TyParam::Type(qt) => {
let st = enum_unwrap!(stp, TyParam::Type);
let st = if st.typarams_len() != qt.typarams_len() {
let st = enum_unwrap!(*st, Type::FreeVar);
st.get_sub().unwrap()
} else {
*st
};
if !st.is_generalized() {
self.substitute_typarams(&qt, &st);
}
self.sub_unify(&st, &qt, Location::Unknown, None).unwrap();
}
_ => {}
}
}
}
#[allow(clippy::only_used_in_recursion)]
pub(crate) fn undo_substitute_typarams(&self, substituted: &Type) {
for tp in substituted.typarams().into_iter() {
match tp {
TyParam::FreeVar(fv) if fv.is_undoable_linked() => fv.undo(),
TyParam::Type(t) if t.is_free_var() => {
let subst = enum_unwrap!(t.as_ref(), Type::FreeVar);
if subst.is_undoable_linked() {
subst.undo();
}
}
TyParam::Type(t) => {
self.undo_substitute_typarams(&t);
}
_ => {}
}
}
}
pub(crate) fn eval_proj_call(
&self,
lhs: TyParam,
attr_name: Str,
args: Vec<TyParam>,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
let t = self.get_tp_t(&lhs)?;
for ty_ctx in self.get_nominal_super_type_ctxs(&t).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&t,
)
})? {
if let Ok(obj) = ty_ctx.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let is_method = subr.sig_t().self_t().is_some();
let mut pos_args = vec![];
if is_method {
match ValueObj::try_from(lhs) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
for (_class, methods) in ty_ctx.methods_list.iter() {
if let Ok(obj) = methods.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let mut pos_args = vec![];
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, TyParam::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tp(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj_call(coerced, attr_name, args);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce_tp(&lhs);
t
})
} else {
let proj = proj_call(lhs, attr_name, args);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}sourcepub fn no_trait_impl_error(
input: Input,
errno: usize,
class: &Type,
trait_: &Type,
loc: Location,
caused_by: String,
hint: Option<String>
) -> Self
pub fn no_trait_impl_error(
input: Input,
errno: usize,
class: &Type,
trait_: &Type,
loc: Location,
caused_by: String,
hint: Option<String>
) -> Self
Examples found in repository?
context/tyvar.rs (lines 654-662)
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
fn check_trait_impl(
&self,
class: &Type,
trait_: &Type,
loc: Location,
) -> SingleTyCheckResult<()> {
if !self.trait_impl_exists(class, trait_) {
Err(TyCheckError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
class,
trait_,
loc,
self.caused_by(),
None,
))
} else {
Ok(())
}
}More examples
context/eval.rs (lines 992-1000)
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
pub(crate) fn eval_proj(
&self,
lhs: Type,
rhs: Str,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
// Currently Erg does not allow projection-types to be evaluated with type variables included.
// All type variables will be dereferenced or fail.
let (sub, opt_sup) = match lhs.clone() {
Type::FreeVar(fv) if fv.is_linked() => {
return self.eval_t_params(proj(fv.crack().clone(), rhs), level, t_loc)
}
Type::FreeVar(fv) if fv.is_unbound() => {
let (sub, sup) = fv.get_subsup().unwrap();
(sub, Some(sup))
}
other => (other, None),
};
// cannot determine at this point
if sub == Type::Never {
return Ok(proj(lhs, rhs));
}
// in Methods
if self.name == sub.qual_name() {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, self, level, t_loc)
{
return Ok(t);
}
}
for ty_ctx in self.get_nominal_super_type_ctxs(&sub).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&sub,
)
})? {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, ty_ctx, level, t_loc)
{
return Ok(t);
}
for (class, methods) in ty_ctx.methods_list.iter() {
match (&class, &opt_sup) {
(ClassDefType::ImplTrait { impl_trait, .. }, Some(sup)) => {
if !self.supertype_of(impl_trait, sup) {
continue;
}
}
(ClassDefType::ImplTrait { impl_trait, .. }, None) => {
if !self.supertype_of(impl_trait, &sub) {
continue;
}
}
_ => {}
}
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, methods, level, t_loc)
{
return Ok(t);
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, Type::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tyvar(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj(coerced, rhs);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce(&lhs);
t
})
} else {
let proj = proj(lhs, rhs);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}
pub(crate) fn convert_tp_into_ty(&self, tp: TyParam) -> Result<Type, ()> {
match tp {
TyParam::Array(tps) => {
let len = tps.len();
let mut t = Type::Never;
for elem_tp in tps {
let elem_t = self.convert_tp_into_ty(elem_tp)?;
// not union
t = self.union(&t, &elem_t);
}
Ok(array_t(t, TyParam::value(len)))
}
TyParam::FreeVar(fv) if fv.is_linked() => self.convert_tp_into_ty(fv.crack().clone()),
TyParam::Type(t) => Ok(t.as_ref().clone()),
TyParam::Value(v) => Type::try_from(v),
// TODO: Array, Dict, Set
_ => Err(()),
}
}
fn _convert_type_to_dict_type(&self, ty: Type) -> Result<Dict<Type, Type>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Dict" => {
let dict = Dict::try_from(params[0].clone())?;
let mut new_dict = dict! {};
for (k, v) in dict.into_iter() {
let k = self.convert_tp_into_ty(k)?;
let v = self.convert_tp_into_ty(v)?;
new_dict.insert(k, v);
}
Ok(new_dict)
}
_ => Err(()),
}
}
fn convert_type_to_array(&self, ty: Type) -> Result<Vec<ValueObj>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Array" || &name[..] == "Array!" => {
let t = self.convert_tp_into_ty(params[0].clone())?;
let len = enum_unwrap!(params[1], TyParam::Value:(ValueObj::Nat:(_)));
Ok(vec![ValueObj::builtin_t(t); len as usize])
}
_ => Err(()),
}
}
pub(crate) fn convert_value_into_array(&self, val: ValueObj) -> Result<Vec<ValueObj>, ()> {
match val {
ValueObj::Array(arr) => Ok(arr.to_vec()),
ValueObj::Type(t) => self.convert_type_to_array(t.into_typ()),
_ => Err(()),
}
}
fn validate_and_project(
&self,
sub: &Type,
opt_sup: Option<&Type>,
rhs: &str,
methods: &Context,
level: usize,
t_loc: Location,
) -> Option<Type> {
// e.g. sub: Int, opt_sup: Add(?T), rhs: Output, methods: Int.methods
// sub: [Int; 4], opt_sup: Add([Int; 2]), rhs: Output, methods: [T; N].methods
if let Ok(obj) = methods.get_const_local(&Token::symbol(rhs), &self.name) {
#[allow(clippy::single_match)]
// opt_sup: Add(?T), methods.impl_of(): Add(Int)
// opt_sup: Add([Int; 2]), methods.impl_of(): Add([T; M])
match (&opt_sup, methods.impl_of()) {
(Some(sup), Some(trait_)) => {
if !self.supertype_of(&trait_, sup) {
return None;
}
}
_ => {}
}
// obj: Int|<: Add(Int)|.Output == ValueObj::Type(<type Int>)
// obj: [T; N]|<: Add([T; M])|.Output == ValueObj::Type(<type [T; M+N]>)
if let ValueObj::Type(quant_projected_t) = obj {
let projected_t = quant_projected_t.into_typ();
let (quant_sub, _) = self.rec_get_type(&sub.local_name()).unwrap();
if let Some(sup) = opt_sup {
if let Some(quant_sup) = methods.impl_of() {
// T -> Int, M -> 2
self.substitute_typarams(&quant_sup, sup);
}
}
// T -> Int, N -> 4
self.substitute_typarams(quant_sub, sub);
// [T; M+N] -> [Int; 4+2] -> [Int; 6]
let res = self.eval_t_params(projected_t, level, t_loc).ok();
if let Some(t) = res {
let mut tv_cache = TyVarCache::new(self.level, self);
let t = self.detach(t, &mut tv_cache);
// Int -> T, 2 -> M, 4 -> N
self.undo_substitute_typarams(quant_sub);
if let Some(quant_sup) = methods.impl_of() {
self.undo_substitute_typarams(&quant_sup);
}
return Some(t);
}
} else {
todo!()
}
}
None
}
/// e.g.
/// F((Int), 3) => F(Int, 3)
/// F(?T, ?T) => F(?1, ?1)
fn detach(&self, ty: Type, tv_cache: &mut TyVarCache) -> Type {
match ty {
Type::FreeVar(fv) if fv.is_linked() => self.detach(fv.crack().clone(), tv_cache),
Type::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(t) = tv_cache.get_tyvar(&name) {
t.clone()
} else {
let tv = Type::FreeVar(new_fv);
tv_cache.push_or_init_tyvar(&name, &tv);
tv
}
}
Type::Poly { name, params } => {
let mut new_params = vec![];
for param in params {
new_params.push(self.detach_tp(param, tv_cache));
}
poly(name, new_params)
}
_ => ty,
}
}
fn detach_tp(&self, tp: TyParam, tv_cache: &mut TyVarCache) -> TyParam {
match tp {
TyParam::FreeVar(fv) if fv.is_linked() => self.detach_tp(fv.crack().clone(), tv_cache),
TyParam::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(tp) = tv_cache.get_typaram(&name) {
tp.clone()
} else {
let tp = TyParam::FreeVar(new_fv);
tv_cache.push_or_init_typaram(&name, &tp);
tp
}
}
TyParam::Type(t) => TyParam::t(self.detach(*t, tv_cache)),
_ => tp,
}
}
#[allow(clippy::only_used_in_recursion)]
/// e.g. qt: Array(T, N), st: Array(Int, 3)
pub(crate) fn substitute_typarams(&self, qt: &Type, st: &Type) {
let qtps = qt.typarams();
let stps = st.typarams();
if qtps.len() != stps.len() {
log!(err "{} {}", erg_common::fmt_vec(&qtps), erg_common::fmt_vec(&stps));
return; // TODO: e.g. Sub(Int) / Eq and Sub(?T)
}
for (qtp, stp) in qtps.into_iter().zip(stps.into_iter()) {
match qtp {
TyParam::FreeVar(fv) if fv.is_generalized() => {
if !stp.is_generalized() {
fv.undoable_link(&stp);
}
}
TyParam::Type(t) if t.is_generalized() => {
let qt = enum_unwrap!(t.as_ref(), Type::FreeVar);
let st = enum_unwrap!(stp, TyParam::Type);
if !st.is_generalized() {
qt.undoable_link(&st);
}
}
TyParam::Type(qt) => {
let st = enum_unwrap!(stp, TyParam::Type);
let st = if st.typarams_len() != qt.typarams_len() {
let st = enum_unwrap!(*st, Type::FreeVar);
st.get_sub().unwrap()
} else {
*st
};
if !st.is_generalized() {
self.substitute_typarams(&qt, &st);
}
self.sub_unify(&st, &qt, Location::Unknown, None).unwrap();
}
_ => {}
}
}
}
#[allow(clippy::only_used_in_recursion)]
pub(crate) fn undo_substitute_typarams(&self, substituted: &Type) {
for tp in substituted.typarams().into_iter() {
match tp {
TyParam::FreeVar(fv) if fv.is_undoable_linked() => fv.undo(),
TyParam::Type(t) if t.is_free_var() => {
let subst = enum_unwrap!(t.as_ref(), Type::FreeVar);
if subst.is_undoable_linked() {
subst.undo();
}
}
TyParam::Type(t) => {
self.undo_substitute_typarams(&t);
}
_ => {}
}
}
}
pub(crate) fn eval_proj_call(
&self,
lhs: TyParam,
attr_name: Str,
args: Vec<TyParam>,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
let t = self.get_tp_t(&lhs)?;
for ty_ctx in self.get_nominal_super_type_ctxs(&t).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&t,
)
})? {
if let Ok(obj) = ty_ctx.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let is_method = subr.sig_t().self_t().is_some();
let mut pos_args = vec![];
if is_method {
match ValueObj::try_from(lhs) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
for (_class, methods) in ty_ctx.methods_list.iter() {
if let Ok(obj) = methods.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let mut pos_args = vec![];
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, TyParam::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tp(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj_call(coerced, attr_name, args);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce_tp(&lhs);
t
})
} else {
let proj = proj_call(lhs, attr_name, args);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}sourcepub fn method_definition_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
hint: Option<String>
) -> Self
pub fn method_definition_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
hint: Option<String>
) -> Self
Examples found in repository?
lower.rs (lines 1274-1281)
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
fn lower_class_def(&mut self, class_def: ast::ClassDef) -> LowerResult<hir::ClassDef> {
log!(info "entered {}({class_def})", fn_name!());
let mut hir_def = self.lower_def(class_def.def)?;
let mut hir_methods = hir::Block::empty();
let mut dummy_tv_cache = TyVarCache::new(self.ctx.level, &self.ctx);
for mut methods in class_def.methods_list.into_iter() {
let (class, impl_trait) = match &methods.class {
ast::TypeSpec::TypeApp { spec, args } => {
let (impl_trait, loc) = match &args.args.pos_args().first().unwrap().expr {
// TODO: check `tasc.op`
ast::Expr::TypeAsc(tasc) => (
self.ctx.instantiate_typespec(
&tasc.t_spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
tasc.t_spec.loc(),
),
_ => return unreachable_error!(LowerErrors, LowerError, self),
};
(
self.ctx.instantiate_typespec(
spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
Some((impl_trait, loc)),
)
}
other => (
self.ctx.instantiate_typespec(
other,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
None,
),
};
// assume the class has implemented the trait, regardless of whether the implementation is correct
if let Some((trait_, trait_loc)) = &impl_trait {
self.register_trait_impl(&class, trait_, *trait_loc)?;
}
if let Some((_, class_root)) = self.ctx.get_nominal_type_ctx(&class) {
if !class_root.kind.is_class() {
return Err(LowerErrors::from(LowerError::method_definition_error(
self.cfg.input.clone(),
line!() as usize,
methods.loc(),
self.ctx.caused_by(),
&class.qual_name(),
None,
)));
}
} else {
return Err(LowerErrors::from(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
methods.class.loc(),
self.ctx.caused_by(),
&class.qual_name(),
self.ctx.get_similar_name(&class.local_name()),
)));
}
let kind = ContextKind::MethodDefs(impl_trait.as_ref().map(|(t, _)| t.clone()));
let vis = if self.cfg.python_compatible_mode {
Public
} else {
Private
};
self.ctx.grow(&class.local_name(), kind, vis, None);
for attr in methods.attrs.iter_mut() {
match attr {
ast::ClassAttr::Def(def) => {
if methods.vis.is(TokenKind::Dot) {
def.sig.ident_mut().unwrap().dot = Some(Token::new(
TokenKind::Dot,
".",
def.sig.ln_begin().unwrap_or(0),
def.sig.col_begin().unwrap_or(0),
));
}
self.ctx.preregister_def(def).map_err(|errs| {
self.pop_append_errs();
errs
})?;
}
ast::ClassAttr::Decl(_decl) => {}
}
}
for attr in methods.attrs.into_iter() {
match attr {
ast::ClassAttr::Def(def) => match self.lower_def(def) {
Ok(def) => {
hir_methods.push(hir::Expr::Def(def));
}
Err(errs) => {
self.errs.extend(errs);
}
},
ast::ClassAttr::Decl(decl) => {
let decl = self.lower_type_asc(decl)?;
hir_methods.push(hir::Expr::TypeAsc(decl));
}
}
}
if let Err(mut errs) = self.ctx.check_decls() {
self.errs.append(&mut errs);
}
if let Some((trait_, _)) = &impl_trait {
self.check_override(&class, Some(trait_));
} else {
self.check_override(&class, None);
}
if let Err(err) = self.check_trait_impl(impl_trait, &class) {
self.errs.push(err);
}
self.check_collision_and_push(class);
}
let class = mono(hir_def.sig.ident().inspect());
let Some((_, class_ctx)) = self.ctx.get_nominal_type_ctx(&class) else {
return Err(LowerErrors::from(LowerError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
hir_def.sig.loc(),
self.ctx.caused_by(),
&class,
)));
};
let type_obj = enum_unwrap!(self.ctx.rec_get_const_obj(hir_def.sig.ident().inspect()).unwrap(), ValueObj::Type:(TypeObj::Generated:(_)));
let sup_type = enum_unwrap!(&hir_def.body.block.first().unwrap(), hir::Expr::Call)
.args
.get_left_or_key("Super")
.unwrap();
Self::check_inheritable(&self.cfg, &mut self.errs, type_obj, sup_type, &hir_def.sig);
// vi.t.non_default_params().unwrap()[0].typ().clone()
let (__new__, need_to_gen_new) = if let (Some(dunder_new_vi), Some(new_vi)) = (
class_ctx.get_current_scope_var("__new__"),
class_ctx.get_current_scope_var("new"),
) {
(dunder_new_vi.t.clone(), new_vi.kind == VarKind::Auto)
} else {
return unreachable_error!(LowerErrors, LowerError, self);
};
let require_or_sup = self.get_require_or_sup_or_base(hir_def.body.block.remove(0));
Ok(hir::ClassDef::new(
type_obj.clone(),
hir_def.sig,
require_or_sup,
need_to_gen_new,
__new__,
hir_methods,
))
}sourcepub fn trait_member_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
member_name: &str,
trait_type: &Type,
expect: &Type,
found: &Type,
hint: Option<String>
) -> Self
pub fn trait_member_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
member_name: &str,
trait_type: &Type,
expect: &Type,
found: &Type,
hint: Option<String>
) -> Self
Examples found in repository?
lower.rs (lines 1597-1607)
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
fn check_trait_impl(
&mut self,
impl_trait: Option<(Type, Location)>,
class: &Type,
) -> SingleLowerResult<()> {
if let Some((impl_trait, loc)) = impl_trait {
let mut unverified_names = self.ctx.locals.keys().collect::<Set<_>>();
if let Some(trait_obj) = self.ctx.rec_get_const_obj(&impl_trait.local_name()) {
if let ValueObj::Type(typ) = trait_obj {
match typ {
TypeObj::Generated(gen) => match gen.require_or_sup().unwrap().typ() {
Type::Record(attrs) => {
for (field, decl_t) in attrs.iter() {
if let Some((name, vi)) = self.ctx.get_local_kv(&field.symbol) {
let def_t = &vi.t;
// A(<: Add(R)), R -> A.Output
// => A(<: Int), R -> A.Output
let replaced_decl_t =
decl_t.clone().replace(&impl_trait, class);
unverified_names.remove(name);
// def_t must be subtype of decl_t
if !self.ctx.supertype_of(&replaced_decl_t, def_t) {
self.errs.push(LowerError::trait_member_type_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.ctx.caused_by(),
name.inspect(),
&impl_trait,
decl_t,
&vi.t,
None,
));
}
} else {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
&field.symbol,
&impl_trait,
class,
None,
));
}
}
}
other => {
return feature_error!(
LowerError,
self.ctx,
Location::Unknown,
&format!("Impl {other}")
);
}
},
TypeObj::Builtin(_typ) => {
let (_, ctx) = self.ctx.get_nominal_type_ctx(_typ).unwrap();
for (decl_name, decl_vi) in ctx.decls.iter() {
if let Some((name, vi)) = self.ctx.get_local_kv(decl_name.inspect())
{
let def_t = &vi.t;
let replaced_decl_t =
decl_vi.t.clone().replace(&impl_trait, class);
unverified_names.remove(name);
if !self.ctx.supertype_of(&replaced_decl_t, def_t) {
self.errs.push(LowerError::trait_member_type_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.ctx.caused_by(),
name.inspect(),
&impl_trait,
&decl_vi.t,
&vi.t,
None,
));
}
} else {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
decl_name.inspect(),
&impl_trait,
class,
None,
));
}
}
}
}
} else {
return Err(LowerError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
&impl_trait.qual_name(),
None,
&Type::TraitType,
&trait_obj.t(),
None,
None,
));
}
} else {
return Err(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
&impl_trait.qual_name(),
self.ctx.get_similar_name(&impl_trait.local_name()),
));
}
for unverified in unverified_names {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
unverified.inspect(),
&impl_trait,
class,
None,
));
}
}
Ok(())
}sourcepub fn trait_member_not_defined_error(
input: Input,
errno: usize,
caused_by: String,
member_name: &str,
trait_type: &Type,
class_type: &Type,
hint: Option<String>
) -> Self
pub fn trait_member_not_defined_error(
input: Input,
errno: usize,
caused_by: String,
member_name: &str,
trait_type: &Type,
class_type: &Type,
hint: Option<String>
) -> Self
Examples found in repository?
lower.rs (lines 1610-1618)
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
fn check_trait_impl(
&mut self,
impl_trait: Option<(Type, Location)>,
class: &Type,
) -> SingleLowerResult<()> {
if let Some((impl_trait, loc)) = impl_trait {
let mut unverified_names = self.ctx.locals.keys().collect::<Set<_>>();
if let Some(trait_obj) = self.ctx.rec_get_const_obj(&impl_trait.local_name()) {
if let ValueObj::Type(typ) = trait_obj {
match typ {
TypeObj::Generated(gen) => match gen.require_or_sup().unwrap().typ() {
Type::Record(attrs) => {
for (field, decl_t) in attrs.iter() {
if let Some((name, vi)) = self.ctx.get_local_kv(&field.symbol) {
let def_t = &vi.t;
// A(<: Add(R)), R -> A.Output
// => A(<: Int), R -> A.Output
let replaced_decl_t =
decl_t.clone().replace(&impl_trait, class);
unverified_names.remove(name);
// def_t must be subtype of decl_t
if !self.ctx.supertype_of(&replaced_decl_t, def_t) {
self.errs.push(LowerError::trait_member_type_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.ctx.caused_by(),
name.inspect(),
&impl_trait,
decl_t,
&vi.t,
None,
));
}
} else {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
&field.symbol,
&impl_trait,
class,
None,
));
}
}
}
other => {
return feature_error!(
LowerError,
self.ctx,
Location::Unknown,
&format!("Impl {other}")
);
}
},
TypeObj::Builtin(_typ) => {
let (_, ctx) = self.ctx.get_nominal_type_ctx(_typ).unwrap();
for (decl_name, decl_vi) in ctx.decls.iter() {
if let Some((name, vi)) = self.ctx.get_local_kv(decl_name.inspect())
{
let def_t = &vi.t;
let replaced_decl_t =
decl_vi.t.clone().replace(&impl_trait, class);
unverified_names.remove(name);
if !self.ctx.supertype_of(&replaced_decl_t, def_t) {
self.errs.push(LowerError::trait_member_type_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.ctx.caused_by(),
name.inspect(),
&impl_trait,
&decl_vi.t,
&vi.t,
None,
));
}
} else {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
decl_name.inspect(),
&impl_trait,
class,
None,
));
}
}
}
}
} else {
return Err(LowerError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
&impl_trait.qual_name(),
None,
&Type::TraitType,
&trait_obj.t(),
None,
None,
));
}
} else {
return Err(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
&impl_trait.qual_name(),
self.ctx.get_similar_name(&impl_trait.local_name()),
));
}
for unverified in unverified_names {
self.errs.push(LowerError::trait_member_not_defined_error(
self.cfg.input.clone(),
line!() as usize,
self.ctx.caused_by(),
unverified.inspect(),
&impl_trait,
class,
None,
));
}
}
Ok(())
}pub fn not_in_trait_error(
input: Input,
errno: usize,
caused_by: String,
member_name: &str,
trait_type: &Type,
class_type: &Type,
hint: Option<String>
) -> Self
pub fn tyvar_not_defined_error(
input: Input,
errno: usize,
name: &str,
loc: Location,
caused_by: String
) -> Self
sourcepub fn ambiguous_type_error(
input: Input,
errno: usize,
expr: &impl Locational + Display,
candidates: &[Type],
caused_by: String
) -> Self
pub fn ambiguous_type_error(
input: Input,
errno: usize,
expr: &impl Locational + Display,
candidates: &[Type],
caused_by: String
) -> Self
Examples found in repository?
context/inquire.rs (lines 2189-2198)
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
fn get_method_type_by_name(&self, name: &Identifier) -> SingleTyCheckResult<&MethodInfo> {
// TODO: min_by
if let Some(candidates) = self.method_to_traits.get(name.inspect()) {
let first_method_type = &candidates.first().unwrap().method_type;
if candidates
.iter()
.skip(1)
.all(|t| &t.method_type == first_method_type)
{
return Ok(&candidates[0]);
} else {
return Err(TyCheckError::ambiguous_type_error(
self.cfg.input.clone(),
line!() as usize,
name,
&candidates
.iter()
.map(|t| t.definition_type.clone())
.collect::<Vec<_>>(),
self.caused_by(),
));
}
}
if let Some(candidates) = self.method_to_classes.get(name.inspect()) {
let first_method_type = &candidates.first().unwrap().method_type;
if candidates
.iter()
.skip(1)
.all(|t| &t.method_type == first_method_type)
{
return Ok(&candidates[0]);
} else {
return Err(TyCheckError::ambiguous_type_error(
self.cfg.input.clone(),
line!() as usize,
name,
&candidates
.iter()
.map(|t| t.definition_type.clone())
.collect::<Vec<_>>(),
self.caused_by(),
));
}
}
if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.get_method_type_by_name(name)
} else {
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
&Type::Failure,
name.inspect(),
None,
))
}
}source§impl CompileError
impl CompileError
sourcepub fn not_const_expr(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
pub fn not_const_expr(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
context/eval.rs (lines 141-146)
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
fn eval_const_acc(&self, acc: &Accessor) -> EvalResult<ValueObj> {
match acc {
Accessor::Ident(ident) => {
if let Some(val) = self.rec_get_const_obj(ident.inspect()) {
Ok(val.clone())
} else if ident.is_const() {
Err(EvalErrors::from(EvalError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)))
} else {
Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
acc.loc(),
self.caused_by(),
)))
}
}
Accessor::Attr(attr) => {
let obj = self.eval_const_expr(&attr.obj)?;
Ok(self.eval_attr(obj, &attr.ident)?)
}
other => {
feature_error!(self, other.loc(), &format!("eval {other}")).map_err(Into::into)
}
}
}
fn eval_attr(&self, obj: ValueObj, ident: &Identifier) -> SingleEvalResult<ValueObj> {
if let Some(val) = obj.try_get_attr(&Field::from(ident)) {
return Ok(val);
}
if let ValueObj::Type(t) = &obj {
if let Some(sups) = self.get_nominal_super_type_ctxs(t.typ()) {
for ctx in sups {
if let Some(val) = ctx.consts.get(ident.inspect()) {
return Ok(val.clone());
}
for (_, methods) in ctx.methods_list.iter() {
if let Some(v) = methods.consts.get(ident.inspect()) {
return Ok(v.clone());
}
}
}
}
}
Err(EvalError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
&obj.t(),
ident.inspect(),
None,
))
}
fn eval_const_bin(&self, bin: &BinOp) -> EvalResult<ValueObj> {
let lhs = self.eval_const_expr(&bin.args[0])?;
let rhs = self.eval_const_expr(&bin.args[1])?;
let op = try_get_op_kind_from_token(bin.op.kind)?;
self.eval_bin(op, lhs, rhs)
}
fn eval_const_unary(&self, unary: &UnaryOp) -> EvalResult<ValueObj> {
let val = self.eval_const_expr(&unary.args[0])?;
let op = try_get_op_kind_from_token(unary.op.kind)?;
self.eval_unary_val(op, val)
}
fn eval_args(&self, args: &Args) -> EvalResult<ValueArgs> {
let mut evaluated_pos_args = vec![];
for arg in args.pos_args().iter() {
let val = self.eval_const_expr(&arg.expr)?;
evaluated_pos_args.push(val);
}
let mut evaluated_kw_args = dict! {};
for arg in args.kw_args().iter() {
let val = self.eval_const_expr(&arg.expr)?;
evaluated_kw_args.insert(arg.keyword.inspect().clone(), val);
}
Ok(ValueArgs::new(evaluated_pos_args, evaluated_kw_args))
}
fn eval_const_call(&self, call: &Call) -> EvalResult<ValueObj> {
if let Expr::Accessor(acc) = call.obj.as_ref() {
match acc {
Accessor::Ident(ident) => {
let obj = self.rec_get_const_obj(ident.inspect()).ok_or_else(|| {
EvalError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)
})?;
let subr = option_enum_unwrap!(obj, ValueObj::Subr)
.ok_or_else(|| {
EvalError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
None,
&mono("Subroutine"),
&obj.t(),
self.get_candidates(&obj.t()),
None,
)
})?
.clone();
let args = self.eval_args(&call.args)?;
self.call(subr, args, call.loc())
}
// TODO: eval attr
Accessor::Attr(_attr) => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
))),
// TODO: eval type app
Accessor::TypeApp(_type_app) => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
))),
_ => unreachable!(),
}
} else {
Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
)))
}
}
fn call(&self, subr: ConstSubr, args: ValueArgs, loc: Location) -> EvalResult<ValueObj> {
match subr {
ConstSubr::User(_user) => {
feature_error!(self, loc, "calling user-defined subroutines").map_err(Into::into)
}
ConstSubr::Builtin(builtin) => builtin.call(args, self).map_err(|mut e| {
if e.0.loc.is_unknown() {
e.0.loc = loc;
}
EvalErrors::from(EvalError::new(
*e.0,
self.cfg.input.clone(),
self.caused_by(),
))
}),
}
}
fn eval_const_def(&mut self, def: &Def) -> EvalResult<ValueObj> {
if def.is_const() {
let __name__ = def.sig.ident().unwrap().inspect();
let vis = def.sig.vis();
let tv_cache = match &def.sig {
Signature::Subr(subr) => {
let ty_cache =
self.instantiate_ty_bounds(&subr.bounds, RegistrationMode::Normal)?;
Some(ty_cache)
}
Signature::Var(_) => None,
};
// TODO: set params
let kind = ContextKind::from(def.def_kind());
self.grow(__name__, kind, vis, tv_cache);
let obj = self.eval_const_block(&def.body.block).map_err(|errs| {
self.pop();
errs
})?;
match self.check_decls_and_pop() {
Ok(_) => {
self.register_gen_const(def.sig.ident().unwrap(), obj)?;
Ok(ValueObj::None)
}
Err(errs) => {
self.register_gen_const(def.sig.ident().unwrap(), obj)?;
Err(errs)
}
}
} else {
Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
def.body.block.loc(),
self.caused_by(),
)))
}
}
fn eval_const_array(&self, arr: &Array) -> EvalResult<ValueObj> {
let mut elems = vec![];
match arr {
Array::Normal(arr) => {
for elem in arr.elems.pos_args().iter() {
let elem = self.eval_const_expr(&elem.expr)?;
elems.push(elem);
}
Ok(ValueObj::Array(RcArray::from(elems)))
}
_ => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
arr.loc(),
self.caused_by(),
))),
}
}
fn eval_const_set(&self, set: &AstSet) -> EvalResult<ValueObj> {
let mut elems = vec![];
match set {
AstSet::Normal(arr) => {
for elem in arr.elems.pos_args().iter() {
let elem = self.eval_const_expr(&elem.expr)?;
elems.push(elem);
}
Ok(ValueObj::Set(Set::from(elems)))
}
_ => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
set.loc(),
self.caused_by(),
))),
}
}
fn eval_const_dict(&self, dict: &AstDict) -> EvalResult<ValueObj> {
let mut elems = dict! {};
match dict {
AstDict::Normal(dic) => {
for elem in dic.kvs.iter() {
let key = self.eval_const_expr(&elem.key)?;
let value = self.eval_const_expr(&elem.value)?;
elems.insert(key, value);
}
Ok(ValueObj::Dict(elems))
}
_ => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
dict.loc(),
self.caused_by(),
))),
}
}
fn eval_const_tuple(&self, tuple: &Tuple) -> EvalResult<ValueObj> {
let mut elems = vec![];
match tuple {
Tuple::Normal(arr) => {
for elem in arr.elems.pos_args().iter() {
let elem = self.eval_const_expr(&elem.expr)?;
elems.push(elem);
}
}
}
Ok(ValueObj::Tuple(RcArray::from(elems)))
}
fn eval_const_record(&self, record: &Record) -> EvalResult<ValueObj> {
match record {
Record::Normal(rec) => self.eval_const_normal_record(rec),
Record::Mixed(_rec) => unreachable_error!(self), // should be desugared
}
}
fn eval_const_normal_record(&self, record: &NormalRecord) -> EvalResult<ValueObj> {
let mut attrs = vec![];
// HACK: should avoid cloning
let mut record_ctx = Context::instant(
Str::ever("<unnamed record>"),
self.cfg.clone(),
2,
self.mod_cache.clone(),
self.py_mod_cache.clone(),
self.clone(),
);
for attr in record.attrs.iter() {
// let name = attr.sig.ident().map(|i| i.inspect());
let elem = record_ctx.eval_const_block(&attr.body.block)?;
let ident = match &attr.sig {
Signature::Var(var) => match &var.pat {
VarPattern::Ident(ident) => Field::new(ident.vis(), ident.inspect().clone()),
other => {
return feature_error!(self, other.loc(), &format!("record field: {other}"))
}
},
other => {
return feature_error!(self, other.loc(), &format!("record field: {other}"))
}
};
attrs.push((ident, elem));
}
Ok(ValueObj::Record(attrs.into_iter().collect()))
}
/// FIXME: grow
fn eval_const_lambda(&self, lambda: &Lambda) -> EvalResult<ValueObj> {
let mut tmp_tv_cache =
self.instantiate_ty_bounds(&lambda.sig.bounds, RegistrationMode::Normal)?;
let mut non_default_params = Vec::with_capacity(lambda.sig.params.non_defaults.len());
for sig in lambda.sig.params.non_defaults.iter() {
let pt = self.instantiate_param_ty(
sig,
None,
None,
&mut tmp_tv_cache,
RegistrationMode::Normal,
)?;
non_default_params.push(pt);
}
let var_params = if let Some(p) = lambda.sig.params.var_args.as_ref() {
let pt = self.instantiate_param_ty(
p,
None,
None,
&mut tmp_tv_cache,
RegistrationMode::Normal,
)?;
Some(pt)
} else {
None
};
let mut default_params = Vec::with_capacity(lambda.sig.params.defaults.len());
for sig in lambda.sig.params.defaults.iter() {
let expr = self.eval_const_expr(&sig.default_val)?;
let pt = self.instantiate_param_ty(
&sig.sig,
Some(expr.t()),
None,
&mut tmp_tv_cache,
RegistrationMode::Normal,
)?;
default_params.push(pt);
}
// HACK: should avoid cloning
let mut lambda_ctx = Context::instant(
Str::ever("<lambda>"),
self.cfg.clone(),
0,
self.mod_cache.clone(),
self.py_mod_cache.clone(),
self.clone(),
);
let return_t = v_enum(set! {lambda_ctx.eval_const_block(&lambda.body)?});
let sig_t = subr_t(
SubrKind::from(lambda.op.kind),
non_default_params.clone(),
var_params,
default_params.clone(),
return_t,
);
let sig_t = self.generalize_t(sig_t);
let subr = ConstSubr::User(UserConstSubr::new(
Str::ever("<lambda>"),
lambda.sig.params.clone(),
lambda.body.clone(),
sig_t,
));
Ok(ValueObj::Subr(subr))
}
pub(crate) fn eval_lit(&self, lit: &Literal) -> EvalResult<ValueObj> {
let t = type_from_token_kind(lit.token.kind);
ValueObj::from_str(t, lit.token.content.clone()).ok_or_else(|| {
EvalError::invalid_literal(
self.cfg.input.clone(),
line!() as usize,
lit.token.loc(),
self.caused_by(),
)
.into()
})
}
pub(crate) fn eval_const_expr(&self, expr: &Expr) -> EvalResult<ValueObj> {
match expr {
Expr::Lit(lit) => self.eval_lit(lit),
Expr::Accessor(acc) => self.eval_const_acc(acc),
Expr::BinOp(bin) => self.eval_const_bin(bin),
Expr::UnaryOp(unary) => self.eval_const_unary(unary),
Expr::Call(call) => self.eval_const_call(call),
Expr::Array(arr) => self.eval_const_array(arr),
Expr::Set(set) => self.eval_const_set(set),
Expr::Dict(dict) => self.eval_const_dict(dict),
Expr::Tuple(tuple) => self.eval_const_tuple(tuple),
Expr::Record(rec) => self.eval_const_record(rec),
Expr::Lambda(lambda) => self.eval_const_lambda(lambda),
// FIXME: type check
Expr::TypeAsc(tasc) => self.eval_const_expr(&tasc.expr),
other => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
other.loc(),
self.caused_by(),
))),
}
}
// ConstExprを評価するのではなく、コンパイル時関数の式(AST上ではただのExpr)を評価する
// コンパイル時評価できないならNoneを返す
pub(crate) fn eval_const_chunk(&mut self, expr: &Expr) -> EvalResult<ValueObj> {
match expr {
// TODO: ClassDef, PatchDef
Expr::Def(def) => self.eval_const_def(def),
Expr::Lit(lit) => self.eval_lit(lit),
Expr::Accessor(acc) => self.eval_const_acc(acc),
Expr::BinOp(bin) => self.eval_const_bin(bin),
Expr::UnaryOp(unary) => self.eval_const_unary(unary),
Expr::Call(call) => self.eval_const_call(call),
Expr::Array(arr) => self.eval_const_array(arr),
Expr::Set(set) => self.eval_const_set(set),
Expr::Dict(dict) => self.eval_const_dict(dict),
Expr::Tuple(tuple) => self.eval_const_tuple(tuple),
Expr::Record(rec) => self.eval_const_record(rec),
Expr::Lambda(lambda) => self.eval_const_lambda(lambda),
Expr::TypeAsc(tasc) => self.eval_const_expr(&tasc.expr),
other => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
other.loc(),
self.caused_by(),
))),
}
}sourcepub fn invalid_literal(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
pub fn invalid_literal(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
lower.rs (lines 304-309)
301 302 303 304 305 306 307 308 309 310 311 312
fn lower_literal(&self, lit: ast::Literal) -> LowerResult<hir::Literal> {
let loc = lit.loc();
let lit = hir::Literal::try_from(lit.token).map_err(|_| {
LowerError::invalid_literal(
self.cfg.input.clone(),
line!() as usize,
loc,
self.ctx.caused_by(),
)
})?;
Ok(lit)
}More examples
context/eval.rs (lines 508-513)
505 506 507 508 509 510 511 512 513 514 515 516
pub(crate) fn eval_lit(&self, lit: &Literal) -> EvalResult<ValueObj> {
let t = type_from_token_kind(lit.token.kind);
ValueObj::from_str(t, lit.token.content.clone()).ok_or_else(|| {
EvalError::invalid_literal(
self.cfg.input.clone(),
line!() as usize,
lit.token.loc(),
self.caused_by(),
)
.into()
})
}source§impl CompileError
impl CompileError
sourcepub fn has_effect(
input: Input,
errno: usize,
expr: &Expr,
caused_by: String
) -> Self
pub fn has_effect(
input: Input,
errno: usize,
expr: &Expr,
caused_by: String
) -> Self
Examples found in repository?
effectcheck.rs (lines 396-401)
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
fn check_expr(&mut self, expr: &Expr) {
match expr {
Expr::Lit(_) => {}
Expr::Def(def) => {
self.check_def(def);
}
Expr::ClassDef(class_def) => {
self.check_expr(class_def.require_or_sup.as_ref());
for def in class_def.methods.iter() {
self.check_expr(def);
}
}
Expr::PatchDef(patch_def) => {
self.check_expr(patch_def.base.as_ref());
for def in patch_def.methods.iter() {
self.check_expr(def);
}
}
Expr::Array(array) => match array {
Array::Normal(arr) => {
for elem in arr.elems.pos_args.iter() {
self.check_expr(&elem.expr);
}
}
Array::WithLength(arr) => {
self.check_expr(&arr.elem);
self.check_expr(&arr.len);
}
Array::Comprehension(arr) => {
self.check_expr(&arr.elem);
self.check_expr(&arr.guard);
}
},
Expr::Tuple(tuple) => match tuple {
Tuple::Normal(tup) => {
for arg in tup.elems.pos_args.iter() {
self.check_expr(&arg.expr);
}
}
},
Expr::Record(record) => {
self.path_stack.push((Str::ever("<record>"), Private));
self.block_stack.push(Instant);
for attr in record.attrs.iter() {
self.check_def(attr);
}
self.path_stack.pop();
self.block_stack.pop();
}
Expr::Set(set) => match set {
Set::Normal(set) => {
for elem in set.elems.pos_args.iter() {
self.check_expr(&elem.expr);
}
}
Set::WithLength(set) => {
self.check_expr(&set.elem);
self.check_expr(&set.len);
}
},
Expr::Dict(dict) => match dict {
Dict::Normal(dict) => {
for kv in dict.kvs.iter() {
self.check_expr(&kv.key);
self.check_expr(&kv.value);
}
}
other => todo!("{other}"),
},
Expr::Call(call) => {
if (call.obj.t().is_procedure()
|| call
.attr_name
.as_ref()
.map(|name| name.is_procedural())
.unwrap_or(false))
&& !self.in_context_effects_allowed()
{
self.errs.push(EffectError::has_effect(
self.cfg.input.clone(),
line!() as usize,
expr,
self.full_path(),
));
}
call.args
.pos_args
.iter()
.for_each(|parg| self.check_expr(&parg.expr));
call.args
.kw_args
.iter()
.for_each(|kwarg| self.check_expr(&kwarg.expr));
}
Expr::UnaryOp(unary) => {
self.check_expr(&unary.expr);
}
Expr::BinOp(bin) => {
self.check_expr(&bin.lhs);
self.check_expr(&bin.rhs);
}
Expr::Lambda(lambda) => {
let is_proc = lambda.is_procedural();
if is_proc {
self.path_stack.push((Str::ever("<lambda!>"), Private));
self.block_stack.push(Proc);
} else {
self.path_stack.push((Str::ever("<lambda>"), Private));
self.block_stack.push(Func);
}
lambda.body.iter().for_each(|chunk| self.check_expr(chunk));
self.path_stack.pop();
self.block_stack.pop();
}
Expr::TypeAsc(type_asc) => {
self.check_expr(&type_asc.expr);
}
Expr::Accessor(acc) => {
if !self.in_context_effects_allowed() && acc.ref_t().is_mut_type() {
self.errs.push(EffectError::touch_mut_error(
self.cfg.input.clone(),
line!() as usize,
expr,
self.full_path(),
));
}
}
Expr::AttrDef(_)
| Expr::Code(_)
| Expr::Compound(_)
| Expr::Import(_)
| Expr::Dummy(_) => {}
}
}sourcepub fn proc_assign_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
pub fn proc_assign_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
effectcheck.rs (lines 247-252)
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
fn check_def(&mut self, def: &Def) {
let name_and_vis = match &def.sig {
Signature::Var(var) => (var.inspect().clone(), var.vis()),
Signature::Subr(subr) => (subr.ident.inspect().clone(), subr.ident.vis()),
};
self.path_stack.push(name_and_vis);
let is_procedural = def.sig.is_procedural();
let is_subr = def.sig.is_subr();
let is_const = def.sig.is_const();
match (is_procedural, is_subr, is_const) {
(true, true, true) => {
panic!("user-defined constant procedures are not allowed");
}
(true, true, false) => {
self.block_stack.push(Proc);
}
(_, false, false) => {
self.block_stack.push(Instant);
}
(false, true, true) => {
self.block_stack.push(ConstFunc);
}
(false, true, false) => {
self.block_stack.push(Func);
}
(_, false, true) => {
self.block_stack.push(ConstInstant);
}
}
if let Signature::Subr(sig) = &def.sig {
let t = sig.ident.ref_t();
for (nd_param, nd_type) in sig
.params
.non_defaults
.iter()
.zip(t.non_default_params().unwrap())
{
if nd_type.typ().is_procedure() && !nd_param.inspect().unwrap().ends_with('!') {
self.errs.push(EffectError::proc_assign_error(
self.cfg.input.clone(),
line!() as usize,
nd_param.pat.loc(),
self.full_path(),
));
}
}
if let Some((var_arg, va_type)) = sig.params.var_args.as_ref().zip(t.var_args()) {
if va_type.typ().is_procedure() && !var_arg.inspect().unwrap().ends_with('!') {
self.errs.push(EffectError::proc_assign_error(
self.cfg.input.clone(),
line!() as usize,
var_arg.pat.loc(),
self.full_path(),
));
}
}
for (d_param, d_type) in sig.params.defaults.iter().zip(t.default_params().unwrap()) {
if d_type.typ().is_procedure() && !d_param.inspect().unwrap().ends_with('!') {
self.errs.push(EffectError::proc_assign_error(
self.cfg.input.clone(),
line!() as usize,
d_param.sig.pat.loc(),
self.full_path(),
));
}
}
}
let last_idx = def.body.block.len() - 1;
for (i, chunk) in def.body.block.iter().enumerate() {
self.check_expr(chunk);
// e.g. `echo = print!`
if i == last_idx
&& self.block_stack.last().unwrap() == &Instant
&& !def.sig.is_procedural()
&& chunk.t().is_procedure()
{
self.errs.push(EffectError::proc_assign_error(
self.cfg.input.clone(),
line!() as usize,
def.sig.loc(),
self.full_path(),
));
}
}
self.path_stack.pop();
self.block_stack.pop();
}sourcepub fn touch_mut_error(
input: Input,
errno: usize,
expr: &Expr,
caused_by: String
) -> Self
pub fn touch_mut_error(
input: Input,
errno: usize,
expr: &Expr,
caused_by: String
) -> Self
Examples found in repository?
effectcheck.rs (lines 437-442)
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
fn check_expr(&mut self, expr: &Expr) {
match expr {
Expr::Lit(_) => {}
Expr::Def(def) => {
self.check_def(def);
}
Expr::ClassDef(class_def) => {
self.check_expr(class_def.require_or_sup.as_ref());
for def in class_def.methods.iter() {
self.check_expr(def);
}
}
Expr::PatchDef(patch_def) => {
self.check_expr(patch_def.base.as_ref());
for def in patch_def.methods.iter() {
self.check_expr(def);
}
}
Expr::Array(array) => match array {
Array::Normal(arr) => {
for elem in arr.elems.pos_args.iter() {
self.check_expr(&elem.expr);
}
}
Array::WithLength(arr) => {
self.check_expr(&arr.elem);
self.check_expr(&arr.len);
}
Array::Comprehension(arr) => {
self.check_expr(&arr.elem);
self.check_expr(&arr.guard);
}
},
Expr::Tuple(tuple) => match tuple {
Tuple::Normal(tup) => {
for arg in tup.elems.pos_args.iter() {
self.check_expr(&arg.expr);
}
}
},
Expr::Record(record) => {
self.path_stack.push((Str::ever("<record>"), Private));
self.block_stack.push(Instant);
for attr in record.attrs.iter() {
self.check_def(attr);
}
self.path_stack.pop();
self.block_stack.pop();
}
Expr::Set(set) => match set {
Set::Normal(set) => {
for elem in set.elems.pos_args.iter() {
self.check_expr(&elem.expr);
}
}
Set::WithLength(set) => {
self.check_expr(&set.elem);
self.check_expr(&set.len);
}
},
Expr::Dict(dict) => match dict {
Dict::Normal(dict) => {
for kv in dict.kvs.iter() {
self.check_expr(&kv.key);
self.check_expr(&kv.value);
}
}
other => todo!("{other}"),
},
Expr::Call(call) => {
if (call.obj.t().is_procedure()
|| call
.attr_name
.as_ref()
.map(|name| name.is_procedural())
.unwrap_or(false))
&& !self.in_context_effects_allowed()
{
self.errs.push(EffectError::has_effect(
self.cfg.input.clone(),
line!() as usize,
expr,
self.full_path(),
));
}
call.args
.pos_args
.iter()
.for_each(|parg| self.check_expr(&parg.expr));
call.args
.kw_args
.iter()
.for_each(|kwarg| self.check_expr(&kwarg.expr));
}
Expr::UnaryOp(unary) => {
self.check_expr(&unary.expr);
}
Expr::BinOp(bin) => {
self.check_expr(&bin.lhs);
self.check_expr(&bin.rhs);
}
Expr::Lambda(lambda) => {
let is_proc = lambda.is_procedural();
if is_proc {
self.path_stack.push((Str::ever("<lambda!>"), Private));
self.block_stack.push(Proc);
} else {
self.path_stack.push((Str::ever("<lambda>"), Private));
self.block_stack.push(Func);
}
lambda.body.iter().for_each(|chunk| self.check_expr(chunk));
self.path_stack.pop();
self.block_stack.pop();
}
Expr::TypeAsc(type_asc) => {
self.check_expr(&type_asc.expr);
}
Expr::Accessor(acc) => {
if !self.in_context_effects_allowed() && acc.ref_t().is_mut_type() {
self.errs.push(EffectError::touch_mut_error(
self.cfg.input.clone(),
line!() as usize,
expr,
self.full_path(),
));
}
}
Expr::AttrDef(_)
| Expr::Code(_)
| Expr::Compound(_)
| Expr::Import(_)
| Expr::Dummy(_) => {}
}
}source§impl CompileError
impl CompileError
sourcepub fn move_error(
input: Input,
errno: usize,
name: &str,
name_loc: Location,
moved_loc: Location,
caused_by: String
) -> Self
pub fn move_error(
input: Input,
errno: usize,
name: &str,
name_loc: Location,
moved_loc: Location,
caused_by: String
) -> Self
Examples found in repository?
ownercheck.rs (lines 337-344)
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
fn check_if_dropped(&mut self, name: &Str, loc: Location) -> Result<(), OwnershipError> {
for n in 0..self.path_stack.len() {
if let Some(moved_loc) = self.nth_outer_scope(n).dropped_vars.get(name) {
let moved_loc = *moved_loc;
return Err(OwnershipError::move_error(
self.cfg.input.clone(),
line!() as usize,
name,
loc,
moved_loc,
self.full_path(),
));
}
}
Ok(())
}source§impl CompileError
impl CompileError
sourcepub fn syntax_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
desc: String,
hint: Option<String>
) -> Self
pub fn syntax_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
desc: String,
hint: Option<String>
) -> Self
Examples found in repository?
lower.rs (lines 335-353)
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
fn elem_err(&self, l: &Type, r: &Type, elem: &hir::Expr) -> LowerErrors {
let elem_disp_notype = elem.to_string_notype();
let l = Context::readable_type(l);
let r = Context::readable_type(r);
LowerErrors::from(LowerError::syntax_error(
self.cfg.input.clone(),
line!() as usize,
elem.loc(),
String::from(&self.ctx.name[..]),
switch_lang!(
"japanese" => "配列の要素は全て同じ型である必要があります",
"simplified_chinese" => "数组元素必须全部是相同类型",
"traditional_chinese" => "數組元素必須全部是相同類型",
"english" => "all elements of an array must be of the same type",
)
.to_owned(),
Some(switch_lang!(
"japanese" => format!("[..., {elem_disp_notype}: {l} or {r}]など明示的に型を指定してください"),
"simplified_chinese" => format!("请明确指定类型，例如: [..., {elem_disp_notype}: {l} or {r}]"),
"traditional_chinese" => format!("請明確指定類型，例如: [..., {elem_disp_notype}: {l} or {r}]"),
"english" => format!("please specify the type explicitly, e.g. [..., {elem_disp_notype}: {l} or {r}]"),
)),
))
}
fn lower_normal_array(&mut self, array: ast::NormalArray) -> LowerResult<hir::NormalArray> {
log!(info "entered {}({array})", fn_name!());
let mut new_array = vec![];
let (elems, _) = array.elems.into_iters();
let mut union = Type::Never;
for elem in elems {
let elem = self.lower_expr(elem.expr)?;
union = self.ctx.union(&union, elem.ref_t());
if let Some((l, r)) = union.union_types() {
match (l.is_unbound_var(), r.is_unbound_var()) {
(false, false) => {
return Err(self.elem_err(&l, &r, &elem));
}
// TODO: check if the type is compatible with the other type
(true, false) => {}
(false, true) => {}
(true, true) => {}
}
}
new_array.push(elem);
}
let elem_t = if union == Type::Never {
free_var(self.ctx.level, Constraint::new_type_of(Type::Type))
} else {
union
};
Ok(hir::NormalArray::new(
array.l_sqbr,
array.r_sqbr,
elem_t,
hir::Args::values(new_array, None),
))
}
fn lower_array_with_length(
&mut self,
array: ast::ArrayWithLength,
) -> LowerResult<hir::ArrayWithLength> {
log!(info "entered {}({array})", fn_name!());
let elem = self.lower_expr(array.elem.expr)?;
let array_t = self.gen_array_with_length_type(&elem, &array.len);
let len = self.lower_expr(*array.len)?;
let hir_array = hir::ArrayWithLength::new(array.l_sqbr, array.r_sqbr, array_t, elem, len);
Ok(hir_array)
}
fn gen_array_with_length_type(&self, elem: &hir::Expr, len: &ast::Expr) -> Type {
let maybe_len = self.ctx.eval_const_expr(len);
match maybe_len {
Ok(v @ ValueObj::Nat(_)) => {
if elem.ref_t().is_mut_type() {
poly(
"ArrayWithMutType!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else {
array_t(elem.t(), TyParam::Value(v))
}
}
Ok(v @ ValueObj::Mut(_)) if v.class() == mono("Nat!") => {
if elem.ref_t().is_mut_type() {
poly(
"ArrayWithMutTypeAndLength!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else {
array_mut(elem.t(), TyParam::Value(v))
}
}
Ok(other) => todo!("{other} is not a Nat object"),
// REVIEW: is it ok to ignore the error?
Err(_e) => {
if elem.ref_t().is_mut_type() {
poly(
"ArrayWithMutType!",
vec![TyParam::t(elem.t()), TyParam::erased(Type::Nat)],
)
} else {
array_t(elem.t(), TyParam::erased(Type::Nat))
}
}
}
}
fn lower_tuple(&mut self, tuple: ast::Tuple) -> LowerResult<hir::Tuple> {
log!(info "entered {}({tuple})", fn_name!());
match tuple {
ast::Tuple::Normal(tup) => Ok(hir::Tuple::Normal(self.lower_normal_tuple(tup)?)),
}
}
fn lower_normal_tuple(&mut self, tuple: ast::NormalTuple) -> LowerResult<hir::NormalTuple> {
log!(info "entered {}({tuple})", fn_name!());
let mut new_tuple = vec![];
let (elems, .., paren) = tuple.elems.deconstruct();
for elem in elems {
let elem = self.lower_expr(elem.expr)?;
new_tuple.push(elem);
}
Ok(hir::NormalTuple::new(hir::Args::values(new_tuple, paren)))
}
fn lower_record(&mut self, record: ast::Record) -> LowerResult<hir::Record> {
log!(info "entered {}({record})", fn_name!());
match record {
ast::Record::Normal(rec) => self.lower_normal_record(rec),
ast::Record::Mixed(_rec) => unreachable!(), // should be desugared
}
}
fn lower_normal_record(&mut self, record: ast::NormalRecord) -> LowerResult<hir::Record> {
log!(info "entered {}({record})", fn_name!());
let mut hir_record =
hir::Record::new(record.l_brace, record.r_brace, hir::RecordAttrs::empty());
self.ctx.grow("<record>", ContextKind::Dummy, Private, None);
for attr in record.attrs.into_iter() {
let attr = self.lower_def(attr).map_err(|e| {
self.pop_append_errs();
e
})?;
hir_record.push(attr);
}
self.pop_append_errs();
Ok(hir_record)
}
fn lower_set(&mut self, set: ast::Set) -> LowerResult<hir::Set> {
log!(info "enter {}({set})", fn_name!());
match set {
ast::Set::Normal(set) => Ok(hir::Set::Normal(self.lower_normal_set(set)?)),
ast::Set::WithLength(set) => Ok(hir::Set::WithLength(self.lower_set_with_length(set)?)),
}
}
fn lower_normal_set(&mut self, set: ast::NormalSet) -> LowerResult<hir::NormalSet> {
log!(info "entered {}({set})", fn_name!());
let (elems, _) = set.elems.into_iters();
let mut union = Type::Never;
let mut new_set = vec![];
for elem in elems {
let elem = self.lower_expr(elem.expr)?;
union = self.ctx.union(&union, elem.ref_t());
if union.is_intersection_type() {
return Err(LowerErrors::from(LowerError::syntax_error(
self.cfg.input.clone(),
line!() as usize,
elem.loc(),
String::from(&self.ctx.name[..]),
switch_lang!(
"japanese" => "集合の要素は全て同じ型である必要があります",
"simplified_chinese" => "集合元素必须全部是相同类型",
"traditional_chinese" => "集合元素必須全部是相同類型",
"english" => "all elements of a set must be of the same type",
)
.to_owned(),
Some(
switch_lang!(
"japanese" => "Int or Strなど明示的に型を指定してください",
"simplified_chinese" => "明确指定类型，例如: Int or Str",
"traditional_chinese" => "明確指定類型，例如: Int or Str",
"english" => "please specify the type explicitly, e.g. Int or Str",
)
.to_owned(),
),
)));
}
new_set.push(elem);
}
let elem_t = if union == Type::Never {
free_var(self.ctx.level, Constraint::new_type_of(Type::Type))
} else {
union
};
// TODO: lint
/*
if is_duplicated {
self.warns.push(LowerWarning::syntax_error(
self.cfg.input.clone(),
line!() as usize,
normal_set.loc(),
String::arc(&self.ctx.name[..]),
switch_lang!(
"japanese" => "要素が重複しています",
"simplified_chinese" => "元素重复",
"traditional_chinese" => "元素重複",
"english" => "Elements are duplicated",
),
None,
));
}
Ok(normal_set)
*/
let elems = hir::Args::values(new_set, None);
// check if elem_t is Eq
if let Err(errs) = self.ctx.sub_unify(&elem_t, &mono("Eq"), elems.loc(), None) {
self.errs.extend(errs);
}
Ok(hir::NormalSet::new(set.l_brace, set.r_brace, elem_t, elems))
}
/// This (e.g. {"a"; 3}) is meaningless as an object, but makes sense as a type (e.g. {Int; 3}).
fn lower_set_with_length(
&mut self,
set: ast::SetWithLength,
) -> LowerResult<hir::SetWithLength> {
log!("entered {}({set})", fn_name!());
let elem = self.lower_expr(set.elem.expr)?;
let set_t = self.gen_set_with_length_type(&elem, &set.len);
let len = self.lower_expr(*set.len)?;
let hir_set = hir::SetWithLength::new(set.l_brace, set.r_brace, set_t, elem, len);
Ok(hir_set)
}
fn gen_set_with_length_type(&mut self, elem: &hir::Expr, len: &ast::Expr) -> Type {
let maybe_len = self.ctx.eval_const_expr(len);
match maybe_len {
Ok(v @ ValueObj::Nat(_)) => {
if elem.ref_t().is_mut_type() {
poly(
"SetWithMutType!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else if self.ctx.subtype_of(&elem.t(), &Type::Type) {
poly("SetType", vec![TyParam::t(elem.t()), TyParam::Value(v)])
} else {
set_t(elem.t(), TyParam::Value(v))
}
}
Ok(v @ ValueObj::Mut(_)) if v.class() == mono("Nat!") => {
if elem.ref_t().is_mut_type() {
poly(
"SetWithMutTypeAndLength!",
vec![TyParam::t(elem.t()), TyParam::Value(v)],
)
} else {
set_mut(elem.t(), TyParam::Value(v))
}
}
Ok(other) => todo!("{other} is not a Nat object"),
Err(_e) => {
if elem.ref_t().is_mut_type() {
poly(
"SetWithMutType!",
vec![TyParam::t(elem.t()), TyParam::erased(Type::Nat)],
)
} else {
set_t(elem.t(), TyParam::erased(Type::Nat))
}
}
}
}
fn lower_dict(&mut self, dict: ast::Dict) -> LowerResult<hir::Dict> {
log!(info "enter {}({dict})", fn_name!());
match dict {
ast::Dict::Normal(set) => Ok(hir::Dict::Normal(self.lower_normal_dict(set)?)),
other => feature_error!(
LowerErrors,
LowerError,
self.ctx,
other.loc(),
"dict comprehension"
),
// ast::Dict::WithLength(set) => Ok(hir::Dict::WithLength(self.lower_dict_with_length(set)?)),
}
}
fn lower_normal_dict(&mut self, dict: ast::NormalDict) -> LowerResult<hir::NormalDict> {
log!(info "enter {}({dict})", fn_name!());
let mut union = dict! {};
let mut new_kvs = vec![];
for kv in dict.kvs {
let loc = kv.loc();
let key = self.lower_expr(kv.key)?;
let value = self.lower_expr(kv.value)?;
if union.insert(key.t(), value.t()).is_some() {
return Err(LowerErrors::from(LowerError::syntax_error(
self.cfg.input.clone(),
line!() as usize,
loc,
String::from(&self.ctx.name[..]),
switch_lang!(
"japanese" => "Dictの値は全て同じ型である必要があります",
"simplified_chinese" => "Dict的值必须是同一类型",
"traditional_chinese" => "Dict的值必須是同一類型",
"english" => "Values of Dict must be the same type",
)
.to_owned(),
Some(
switch_lang!(
"japanese" => "Int or Strなど明示的に型を指定してください",
"simplified_chinese" => "明确指定类型，例如: Int or Str",
"traditional_chinese" => "明確指定類型，例如: Int or Str",
"english" => "please specify the type explicitly, e.g. Int or Str",
)
.to_owned(),
),
)));
}
new_kvs.push(hir::KeyValue::new(key, value));
}
for key_t in union.keys() {
let loc = Location::concat(&dict.l_brace, &dict.r_brace);
// check if key_t is Eq
if let Err(errs) = self.ctx.sub_unify(key_t, &mono("Eq"), loc, None) {
self.errs.extend(errs);
}
}
let kv_ts = if union.is_empty() {
dict! {
ty_tp(free_var(self.ctx.level, Constraint::new_type_of(Type::Type))) =>
ty_tp(free_var(self.ctx.level, Constraint::new_type_of(Type::Type)))
}
} else {
union
.into_iter()
.map(|(k, v)| (TyParam::t(k), TyParam::t(v)))
.collect()
};
// TODO: lint
/*
if is_duplicated {
self.warns.push(LowerWarning::syntax_error(
self.cfg.input.clone(),
line!() as usize,
normal_set.loc(),
String::arc(&self.ctx.name[..]),
switch_lang!(
"japanese" => "要素が重複しています",
"simplified_chinese" => "元素重复",
"traditional_chinese" => "元素重複",
"english" => "Elements are duplicated",
),
None,
));
}
Ok(normal_set)
*/
Ok(hir::NormalDict::new(
dict.l_brace,
dict.r_brace,
kv_ts,
new_kvs,
))
}
fn lower_acc(&mut self, acc: ast::Accessor) -> LowerResult<hir::Accessor> {
log!(info "entered {}({acc})", fn_name!());
match acc {
ast::Accessor::Ident(ident) => {
let ident = self.lower_ident(ident)?;
let acc = hir::Accessor::Ident(ident);
Ok(acc)
}
ast::Accessor::Attr(attr) => {
let obj = self.lower_expr(*attr.obj)?;
let vi = self.ctx.rec_get_attr_info(
&obj,
&attr.ident,
&self.cfg.input,
&self.ctx.name,
)?;
let ident = hir::Identifier::new(attr.ident.dot, attr.ident.name, None, vi);
let acc = hir::Accessor::Attr(hir::Attribute::new(obj, ident));
Ok(acc)
}
ast::Accessor::TypeApp(t_app) => feature_error!(
LowerErrors,
LowerError,
self.ctx,
t_app.loc(),
"type application"
),
// TupleAttr, Subscr are desugared
_ => unreachable_error!(LowerErrors, LowerError, self.ctx),
}
}
fn lower_ident(&self, ident: ast::Identifier) -> LowerResult<hir::Identifier> {
// `match` is a special form, typing is magic
let (vi, __name__) = if ident.vis().is_private()
&& (&ident.inspect()[..] == "match" || &ident.inspect()[..] == "match!")
{
(
VarInfo {
t: mono("GenericCallable"),
..VarInfo::default()
},
None,
)
} else {
(
self.ctx.rec_get_var_info(
&ident,
AccessKind::Name,
&self.cfg.input,
&self.ctx.name,
)?,
self.ctx
.get_singular_ctx_by_ident(&ident, &self.ctx.name)
.ok()
.map(|ctx| ctx.name.clone()),
)
};
let ident = hir::Identifier::new(ident.dot, ident.name, __name__, vi);
Ok(ident)
}
fn lower_bin(&mut self, bin: ast::BinOp) -> LowerResult<hir::BinOp> {
log!(info "entered {}({bin})", fn_name!());
let mut args = bin.args.into_iter();
let lhs = hir::PosArg::new(self.lower_expr(*args.next().unwrap())?);
let rhs = hir::PosArg::new(self.lower_expr(*args.next().unwrap())?);
let args = [lhs, rhs];
let t = self
.ctx
.get_binop_t(&bin.op, &args, &self.cfg.input, &self.ctx.name)?;
let mut args = args.into_iter();
let lhs = args.next().unwrap().expr;
let rhs = args.next().unwrap().expr;
Ok(hir::BinOp::new(bin.op, lhs, rhs, t))
}
fn lower_unary(&mut self, unary: ast::UnaryOp) -> LowerResult<hir::UnaryOp> {
log!(info "entered {}({unary})", fn_name!());
let mut args = unary.args.into_iter();
let arg = hir::PosArg::new(self.lower_expr(*args.next().unwrap())?);
let args = [arg];
let t = self
.ctx
.get_unaryop_t(&unary.op, &args, &self.cfg.input, &self.ctx.name)?;
let mut args = args.into_iter();
let expr = args.next().unwrap().expr;
Ok(hir::UnaryOp::new(unary.op, expr, t))
}
pub(crate) fn lower_call(&mut self, call: ast::Call) -> LowerResult<hir::Call> {
log!(info "entered {}({}{}(...))", fn_name!(), call.obj, fmt_option!(call.attr_name));
let mut errs = LowerErrors::empty();
let opt_cast_to = if call.is_assert_cast() {
if let Some(typ) = call.assert_cast_target_type() {
Some(Parser::expr_to_type_spec(typ.clone()).map_err(|e| {
let e = LowerError::new(e.into(), self.input().clone(), self.ctx.caused_by());
LowerErrors::from(e)
})?)
} else {
return Err(LowerErrors::from(LowerError::syntax_error(
self.input().clone(),
line!() as usize,
call.args.loc(),
self.ctx.caused_by(),
"invalid assert casting type".to_owned(),
None,
)));
}
} else {
None
};
let (pos_args, kw_args, paren) = call.args.deconstruct();
let mut hir_args = hir::Args::new(
Vec::with_capacity(pos_args.len()),
None,
Vec::with_capacity(kw_args.len()),
paren,
);
for arg in pos_args.into_iter() {
match self.lower_expr(arg.expr) {
Ok(expr) => hir_args.pos_args.push(hir::PosArg::new(expr)),
Err(es) => errs.extend(es),
}
}
for arg in kw_args.into_iter() {
match self.lower_expr(arg.expr) {
Ok(expr) => hir_args.push_kw(hir::KwArg::new(arg.keyword, expr)),
Err(es) => errs.extend(es),
}
}
let mut obj = match self.lower_expr(*call.obj) {
Ok(obj) => obj,
Err(es) => {
errs.extend(es);
return Err(errs);
}
};
// Calling get_call_t with incorrect arguments does not provide meaningful information
if !errs.is_empty() {
return Err(errs);
}
let vi = match self.ctx.get_call_t(
&obj,
&call.attr_name,
&hir_args.pos_args,
&hir_args.kw_args,
&self.cfg.input,
&self.ctx.name,
) {
Ok(vi) => vi,
Err(es) => {
errs.extend(es);
return Err(errs);
}
};
let attr_name = if let Some(attr_name) = call.attr_name {
Some(hir::Identifier::new(
attr_name.dot,
attr_name.name,
None,
vi,
))
} else {
*obj.ref_mut_t() = vi.t;
None
};
let mut call = hir::Call::new(obj, attr_name, hir_args);
match call.additional_operation() {
Some(kind @ (OperationKind::Import | OperationKind::PyImport)) => {
let mod_name =
enum_unwrap!(call.args.get_left_or_key("Path").unwrap(), hir::Expr::Lit);
if let Err(errs) = self.ctx.import_mod(kind, mod_name) {
self.errs.extend(errs);
};
}
Some(OperationKind::Del) => match call.args.get_left_or_key("obj").unwrap() {
hir::Expr::Accessor(hir::Accessor::Ident(ident)) => {
self.ctx.del(ident)?;
}
other => {
return Err(LowerErrors::from(LowerError::syntax_error(
self.input().clone(),
line!() as usize,
other.loc(),
self.ctx.caused_by(),
"".to_owned(),
None,
)))
}
},
Some(OperationKind::Return | OperationKind::Yield) => {
// (f: ?T -> ?U).return: (self: GenericCallable, arg: Obj) -> Never
let callable_t = call.obj.ref_t();
let ret_t = match callable_t {
Type::Subr(subr) => *subr.return_t.clone(),
Type::FreeVar(fv) if fv.is_unbound() => {
fv.get_sub().unwrap().return_t().unwrap().clone()
}
other => todo!("{other:?}"),
};
let arg_t = call.args.get(0).unwrap().ref_t();
self.ctx.sub_unify(arg_t, &ret_t, call.loc(), None)?;
}
_ => {
if let Some(type_spec) = opt_cast_to {
self.ctx.cast(type_spec, &mut call)?;
}
}
}
if errs.is_empty() {
Ok(call)
} else {
Err(errs)
}
}sourcepub fn unused_expr_warning(
input: Input,
errno: usize,
expr: &Expr,
caused_by: String
) -> Self
pub fn unused_expr_warning(
input: Input,
errno: usize,
expr: &Expr,
caused_by: String
) -> Self
Examples found in repository?
lower.rs (lines 186-191)
184 185 186 187 188 189 190 191 192 193 194 195
fn use_check(&self, expr: &hir::Expr, mode: &str) -> LowerResult<()> {
if mode != "eval" && !expr.ref_t().is_nonelike() && !expr.is_type_asc() {
Err(LowerWarnings::from(LowerWarning::unused_expr_warning(
self.cfg.input.clone(),
line!() as usize,
expr,
String::from(&self.ctx.name[..]),
)))
} else {
self.block_use_check(expr, mode)
}
}sourcepub fn duplicate_decl_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
pub fn duplicate_decl_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
Examples found in repository?
context/register.rs (lines 90-96)
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
fn pre_define_var(
&mut self,
sig: &ast::VarSignature,
opt_t: Option<Type>,
id: Option<DefId>,
) -> TyCheckResult<()> {
let muty = Mutability::from(&sig.inspect().unwrap_or(UBAR)[..]);
let ident = match &sig.pat {
ast::VarPattern::Ident(ident) => ident,
ast::VarPattern::Discard(_) => {
return Ok(());
}
_ => todo!(),
};
let vis = ident.vis();
let kind = id.map_or(VarKind::Declared, VarKind::Defined);
let sig_t = self.instantiate_var_sig_t(sig.t_spec.as_ref(), opt_t, PreRegister)?;
let py_name = if let ContextKind::PatchMethodDefs(_base) = &self.kind {
Some(Str::from(format!("::{}{}", self.name, ident)))
} else {
None
};
if let Some(_decl) = self.decls.remove(&ident.name) {
Err(TyCheckErrors::from(TyCheckError::duplicate_decl_error(
self.cfg.input.clone(),
line!() as usize,
sig.loc(),
self.caused_by(),
ident.name.inspect(),
)))
} else {
let vi = VarInfo::new(sig_t, muty, vis, kind, None, self.impl_of(), py_name);
self.future_defined_locals.insert(ident.name.clone(), vi);
Ok(())
}
}
pub(crate) fn declare_sub(
&mut self,
sig: &ast::SubrSignature,
id: Option<DefId>,
) -> TyCheckResult<()> {
let name = sig.ident.inspect();
let vis = sig.ident.vis();
let muty = Mutability::from(&name[..]);
let kind = id.map_or(VarKind::Declared, VarKind::Defined);
let comptime_decos = sig
.decorators
.iter()
.filter_map(|deco| match &deco.0 {
ast::Expr::Accessor(ast::Accessor::Ident(local)) if local.is_const() => {
Some(local.inspect().clone())
}
_ => None,
})
.collect::<Set<_>>();
let default_ts =
vec![free_var(self.level, Constraint::new_type_of(Type::Type)); sig.params.len()];
let (errs, t) = match self.instantiate_sub_sig_t(sig, default_ts, PreRegister) {
Ok(t) => (TyCheckErrors::empty(), t),
Err((errs, t)) => (errs, t),
};
let py_name = if let ContextKind::PatchMethodDefs(_base) = &self.kind {
Some(Str::from(format!("::{}{}", self.name, sig.ident)))
} else {
None
};
let vi = VarInfo::new(
t,
muty,
vis,
kind,
Some(comptime_decos),
self.impl_of(),
py_name,
);
if let Some(_decl) = self.decls.remove(name) {
Err(TyCheckErrors::from(TyCheckError::duplicate_decl_error(
self.cfg.input.clone(),
line!() as usize,
sig.loc(),
self.caused_by(),
name,
)))
} else {
self.decls.insert(sig.ident.name.clone(), vi);
if errs.is_empty() {
Ok(())
} else {
Err(errs)
}
}
}sourcepub fn duplicate_definition_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
pub fn duplicate_definition_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
Examples found in repository?
lower.rs (lines 1722-1728)
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
fn check_collision_and_push(&mut self, class: Type) {
let methods = self.ctx.pop();
let (_, class_root) = self
.ctx
.get_mut_nominal_type_ctx(&class)
.unwrap_or_else(|| todo!("{class} not found"));
for (newly_defined_name, vi) in methods.locals.clone().into_iter() {
for (_, already_defined_methods) in class_root.methods_list.iter_mut() {
// TODO: 特殊化なら同じ名前でもOK
// TODO: 定義のメソッドもエラー表示
if let Some((_already_defined_name, already_defined_vi)) =
already_defined_methods.get_local_kv(newly_defined_name.inspect())
{
if already_defined_vi.kind != VarKind::Auto
&& already_defined_vi.impl_of == vi.impl_of
{
self.errs.push(LowerError::duplicate_definition_error(
self.cfg.input.clone(),
line!() as usize,
newly_defined_name.loc(),
methods.caused_by(),
newly_defined_name.inspect(),
));
} else {
already_defined_methods
.locals
.remove(&newly_defined_name.inspect()[..]);
}
}
}
}
class_root
.methods_list
.push((ClassDefType::Simple(class), methods));
}
fn push_patch(&mut self) {
let methods = self.ctx.pop();
let ContextKind::PatchMethodDefs(base) = &methods.kind else { unreachable!() };
let patch_name = *methods.name.split_with(&["::", "."]).last().unwrap();
let patch_root = self
.ctx
.patches
.get_mut(patch_name)
.unwrap_or_else(|| todo!("{} not found", methods.name));
for (newly_defined_name, vi) in methods.locals.clone().into_iter() {
for (_, already_defined_methods) in patch_root.methods_list.iter_mut() {
// TODO: 特殊化なら同じ名前でもOK
// TODO: 定義のメソッドもエラー表示
if let Some((_already_defined_name, already_defined_vi)) =
already_defined_methods.get_local_kv(newly_defined_name.inspect())
{
if already_defined_vi.kind != VarKind::Auto
&& already_defined_vi.impl_of == vi.impl_of
{
self.errs.push(LowerError::duplicate_definition_error(
self.cfg.input.clone(),
line!() as usize,
newly_defined_name.loc(),
methods.caused_by(),
newly_defined_name.inspect(),
));
} else {
already_defined_methods
.locals
.remove(&newly_defined_name.inspect()[..]);
}
}
}
}
patch_root
.methods_list
.push((ClassDefType::Simple(base.clone()), methods));
}sourcepub fn violate_decl_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
spec_t: &Type,
found_t: &Type
) -> Self
pub fn violate_decl_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
spec_t: &Type,
found_t: &Type
) -> Self
Examples found in repository?
context/register.rs (lines 509-517)
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
pub(crate) fn assign_subr(
&mut self,
sig: &ast::SubrSignature,
id: DefId,
body_t: &Type,
) -> TyCheckResult<Type> {
// already defined as const
if sig.ident.is_const() {
let vi = self.decls.remove(sig.ident.inspect()).unwrap();
let t = vi.t.clone();
self.locals.insert(sig.ident.name.clone(), vi);
return Ok(t);
}
let muty = if sig.ident.is_const() {
Mutability::Const
} else {
Mutability::Immutable
};
let name = &sig.ident.name;
// FIXME: constでない関数
let t = self
.get_current_scope_var(name.inspect())
.map(|v| &v.t)
.unwrap();
let non_default_params = t.non_default_params().unwrap();
let var_args = t.var_args();
let default_params = t.default_params().unwrap();
let mut errs = if let Some(spec_ret_t) = t.return_t() {
let return_t_loc = sig
.return_t_spec
.as_ref()
.map(|t_spec| t_spec.loc())
.unwrap_or_else(|| sig.loc());
self.sub_unify(body_t, spec_ret_t, return_t_loc, None)
.map_err(|errs| {
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::return_type_error(
self.cfg.input.clone(),
line!() as usize,
e.core.get_loc_with_fallback(),
e.caused_by,
readable_name(name.inspect()),
spec_ret_t,
body_t,
)
})
.collect(),
)
})
} else {
Ok(())
};
let return_t = if errs.is_err() {
Type::Failure
} else {
// NOTE: not `body_t.clone()` because the body may contain `return`
t.return_t().unwrap().clone()
};
let sub_t = if sig.ident.is_procedural() {
proc(
non_default_params.clone(),
var_args.cloned(),
default_params.clone(),
return_t,
)
} else {
func(
non_default_params.clone(),
var_args.cloned(),
default_params.clone(),
return_t,
)
};
sub_t.lift();
let found_t = self.generalize_t(sub_t);
let py_name = if let Some(vi) = self.decls.remove(name) {
if !self.supertype_of(&vi.t, &found_t) {
let err = TyCheckError::violate_decl_error(
self.cfg.input.clone(),
line!() as usize,
sig.ident.loc(),
self.caused_by(),
name.inspect(),
&vi.t,
&found_t,
);
match errs {
Ok(()) => {
errs = Err(TyCheckErrors::from(err));
}
Err(ref mut es) => {
es.push(err);
}
}
}
vi.py_name
} else {
None
};
let comptime_decos = sig
.decorators
.iter()
.filter_map(|deco| match &deco.0 {
ast::Expr::Accessor(ast::Accessor::Ident(local)) if local.is_const() => {
Some(local.inspect().clone())
}
_ => None,
})
.collect();
let vi = VarInfo::new(
found_t,
muty,
sig.ident.vis(),
VarKind::Defined(id),
Some(comptime_decos),
self.impl_of(),
py_name,
);
let t = vi.t.clone();
log!(info "Registered {}::{name}: {t}", self.name);
self.locals.insert(name.clone(), vi);
errs?;
Ok(t)
}sourcepub fn no_var_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
similar_name: Option<&str>
) -> Self
pub fn no_var_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
similar_name: Option<&str>
) -> Self
Examples found in repository?
declare.rs (lines 251-258)
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
fn declare_subtype(&mut self, ident: &ast::Identifier, trait_: &Type) -> LowerResult<()> {
if ident.is_raw() {
return Ok(());
}
if let Some((_, ctx)) = self.ctx.get_mut_type(ident.inspect()) {
ctx.register_marker_trait(trait_.clone());
Ok(())
} else {
Err(LowerErrors::from(LowerError::no_var_error(
self.cfg().input.clone(),
line!() as usize,
ident.loc(),
self.ctx.caused_by(),
ident.inspect(),
self.ctx.get_similar_name(ident.inspect()),
)))
}
}More examples
context/inquire.rs (lines 136-143)
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
pub(crate) fn get_singular_ctx_by_hir_expr(
&self,
obj: &hir::Expr,
namespace: &Str,
) -> SingleTyCheckResult<&Context> {
match obj {
hir::Expr::Accessor(hir::Accessor::Ident(ident)) => {
self.get_singular_ctx_by_ident(&ident.clone().downcast(), namespace)
}
hir::Expr::Accessor(hir::Accessor::Attr(attr)) => {
// REVIEW: 両方singularとは限らない?
let ctx = self.get_singular_ctx_by_hir_expr(&attr.obj, namespace)?;
let attr = hir::Expr::Accessor(hir::Accessor::Ident(attr.ident.clone()));
ctx.get_singular_ctx_by_hir_expr(&attr, namespace)
}
// TODO: change error
_ => Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&obj.to_string(),
None,
)),
}
}
pub(crate) fn get_singular_ctx_by_ident(
&self,
ident: &ast::Identifier,
namespace: &Str,
) -> SingleTyCheckResult<&Context> {
self.get_mod(ident.inspect())
.or_else(|| self.rec_get_type(ident.inspect()).map(|(_, ctx)| ctx))
.or_else(|| self.rec_get_patch(ident.inspect()))
.ok_or_else(|| {
TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)
})
}
pub(crate) fn get_mut_singular_ctx_by_ident(
&mut self,
ident: &ast::Identifier,
namespace: &Str,
) -> SingleTyCheckResult<&mut Context> {
let err = TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
);
self.get_mut_type(ident.inspect())
.map(|(_, ctx)| ctx)
.ok_or(err)
}
pub(crate) fn get_singular_ctx(
&self,
obj: &ast::Expr,
namespace: &Str,
) -> SingleTyCheckResult<&Context> {
match obj {
ast::Expr::Accessor(ast::Accessor::Ident(ident)) => {
self.get_singular_ctx_by_ident(ident, namespace)
}
ast::Expr::Accessor(ast::Accessor::Attr(attr)) => {
// REVIEW: 両方singularとは限らない?
let ctx = self.get_singular_ctx(&attr.obj, namespace)?;
let attr = ast::Expr::Accessor(ast::Accessor::Ident(attr.ident.clone()));
ctx.get_singular_ctx(&attr, namespace)
}
_ => Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&obj.to_string(),
None,
)),
}
}
pub(crate) fn get_mut_singular_ctx(
&mut self,
obj: &ast::Expr,
namespace: &Str,
) -> SingleTyCheckResult<&mut Context> {
match obj {
ast::Expr::Accessor(ast::Accessor::Ident(ident)) => {
self.get_mut_singular_ctx_by_ident(ident, namespace)
}
ast::Expr::Accessor(ast::Accessor::Attr(attr)) => {
// REVIEW: 両方singularとは限らない?
let ctx = self.get_mut_singular_ctx(&attr.obj, namespace)?;
let attr = ast::Expr::Accessor(ast::Accessor::Ident(attr.ident.clone()));
ctx.get_mut_singular_ctx(&attr, namespace)
}
_ => Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&obj.to_string(),
None,
)),
}
}
fn get_match_call_t(
&self,
kind: SubrKind,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<VarInfo> {
if !kw_args.is_empty() {
// TODO: this error desc is not good
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
kw_args[0].loc(),
self.caused_by(),
"match",
)));
}
for pos_arg in pos_args.iter().skip(1) {
let t = pos_arg.expr.ref_t();
// Allow only anonymous functions to be passed as match arguments (for aesthetic reasons)
if !matches!(&pos_arg.expr, hir::Expr::Lambda(_)) {
return Err(TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
pos_arg.loc(),
self.caused_by(),
"match",
None,
&mono("LambdaFunc"),
t,
self.get_candidates(t),
Self::get_simple_type_mismatch_hint(&mono("LambdaFunc"), t),
)));
}
}
let match_target_expr_t = pos_args[0].expr.ref_t();
// Never or T => T
let mut union_pat_t = Type::Never;
for (i, pos_arg) in pos_args.iter().skip(1).enumerate() {
let lambda = erg_common::enum_unwrap!(&pos_arg.expr, hir::Expr::Lambda); // already checked
if !lambda.params.defaults.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::default_param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
"match",
)));
}
if lambda.params.len() != 1 {
return Err(TyCheckErrors::from(TyCheckError::param_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[i + 1].loc(),
self.caused_by(),
1,
lambda.params.len(),
)));
}
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let rhs = self.instantiate_param_sig_t(
&lambda.params.non_defaults[0],
None,
&mut dummy_tv_cache,
Normal,
)?;
union_pat_t = self.union(&union_pat_t, &rhs);
}
// NG: expr_t: Nat, union_pat_t: {1, 2}
// OK: expr_t: Int, union_pat_t: {1} or 'T
if self
.sub_unify(match_target_expr_t, &union_pat_t, pos_args[0].loc(), None)
.is_err()
{
return Err(TyCheckErrors::from(TyCheckError::match_error(
self.cfg.input.clone(),
line!() as usize,
pos_args[0].loc(),
self.caused_by(),
match_target_expr_t,
)));
}
let branch_ts = pos_args
.iter()
.skip(1)
.map(|a| ParamTy::anonymous(a.expr.ref_t().clone()))
.collect::<Vec<_>>();
let mut return_t = branch_ts[0]
.typ()
.return_t()
.unwrap_or_else(|| todo!("{}", branch_ts[0]))
.clone();
for arg_t in branch_ts.iter().skip(1) {
return_t = self.union(&return_t, arg_t.typ().return_t().unwrap());
}
let param_ty = ParamTy::anonymous(match_target_expr_t.clone());
let param_ts = [vec![param_ty], branch_ts.to_vec()].concat();
let t = if kind.is_func() {
func(param_ts, None, vec![], return_t)
} else {
proc(param_ts, None, vec![], return_t)
};
Ok(VarInfo {
t,
..VarInfo::default()
})
}
pub(crate) fn rec_get_var_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.get_current_scope_var(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
} else if let Some((name, _vi)) = self
.future_defined_locals
.get_key_value(&ident.inspect()[..])
{
return Err(TyCheckError::access_before_def_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
} else if let Some((name, _vi)) = self.deleted_locals.get_key_value(&ident.inspect()[..]) {
return Err(TyCheckError::access_deleted_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
match parent.rec_get_var_info(ident, acc_kind, input, namespace) {
Ok(vi) => Ok(vi),
Err(err) if err.core.kind == ErrorKind::DummyError => {
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
Err(err) => Err(err),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
pub(crate) fn rec_get_decl_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.decls.get(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
return parent.rec_get_decl_info(ident, acc_kind, input, namespace);
}
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
pub(crate) fn rec_get_attr_info(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
let name = ident.name.token();
match self.get_attr_info_from_attributive(&self_t, ident, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
match singular_ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
match self.get_attr_from_nominal_t(obj, ident, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(ident.inspect())
.or_else(|| patch.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(ident.inspect())
.or_else(|| methods_ctx.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
// TODO: dependent type widening
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
parent.rec_get_attr_info(obj, ident, input, namespace)
} else {
Err(TyCheckError::no_attr_error(
input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
&self_t,
name.inspect(),
self.get_similar_attr(&self_t, name.inspect()),
))
}
}
fn get_attr_from_nominal_t(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
if let Some(sups) = self.get_nominal_super_type_ctxs(&self_t) {
for ctx in sups {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
let coerced = self
.deref_tyvar(obj.t(), Variance::Covariant, Location::Unknown)
.map_err(|mut es| es.remove(0))?;
if obj.ref_t() != &coerced {
for ctx in self.get_nominal_super_type_ctxs(&coerced).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&coerced,
)
})? {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
self.coerce(obj.ref_t());
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
Err(TyCheckError::dummy(input.clone(), line!() as usize))
}
/// get type from given attributive type (Record).
/// not ModuleType or ClassType etc.
fn get_attr_info_from_attributive(
&self,
t: &Type,
ident: &Identifier,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
match t {
// (obj: Never).foo: Never
Type::Never => Ok(VarInfo::ILLEGAL.clone()),
Type::FreeVar(fv) if fv.is_linked() => {
self.get_attr_info_from_attributive(&fv.crack(), ident, namespace)
}
Type::FreeVar(fv) /* if fv.is_unbound() */ => {
let sup = fv.get_super().unwrap();
self.get_attr_info_from_attributive(&sup, ident, namespace)
}
Type::Ref(t) => self.get_attr_info_from_attributive(t, ident, namespace),
Type::RefMut { before, .. } => {
self.get_attr_info_from_attributive(before, ident, namespace)
}
Type::Refinement(refine) => {
self.get_attr_info_from_attributive(&refine.t, ident, namespace)
}
Type::Record(record) => {
if let Some(attr_t) = record.get(ident.inspect()) {
let muty = Mutability::from(&ident.inspect()[..]);
let vi = VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
);
Ok(vi)
} else {
let t = Type::Record(record.clone());
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
&t,
ident.inspect(),
self.get_similar_attr(&t, ident.inspect()),
))
}
}
other => {
if let Some(v) = self.rec_get_const_obj(&other.local_name()) {
match v {
ValueObj::Type(TypeObj::Generated(gen)) => self
.get_gen_t_require_attr_t(gen, &ident.inspect()[..])
.map(|attr_t| {
let muty = Mutability::from(&ident.inspect()[..]);
VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
)
})
.ok_or_else(|| {
TyCheckError::dummy(self.cfg.input.clone(), line!() as usize)
}),
ValueObj::Type(TypeObj::Builtin(_t)) => {
// FIXME:
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
_other => Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
)),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
}
}
// returns callee's type, not the return type
fn search_callee_info(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if obj.ref_t() == Type::FAILURE {
// (...Obj) -> Failure
return Ok(VarInfo {
t: Type::Subr(SubrType::new(
SubrKind::Func,
vec![],
Some(ParamTy::pos(None, ref_(Obj))),
vec![],
Failure,
)),
..VarInfo::default()
});
}
if let Some(attr_name) = attr_name.as_ref() {
for ctx in self
.get_nominal_super_type_ctxs(obj.ref_t())
.ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
obj.ref_t(),
)
})?
{
if let Some(vi) = ctx
.locals
.get(attr_name.inspect())
.or_else(|| ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in ctx.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
if let Some(vi) = singular_ctx
.locals
.get(attr_name.inspect())
.or_else(|| singular_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, method_ctx) in singular_ctx.methods_list.iter() {
if let Some(vi) = method_ctx
.locals
.get(attr_name.inspect())
.or_else(|| method_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
return Err(TyCheckError::singular_no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.qual_name().unwrap_or("?"),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr_from_singular(obj, attr_name.inspect()),
));
}
match self.get_method_type_by_name(attr_name) {
Ok(method) => {
self.sub_unify(obj.ref_t(), &method.definition_type, obj.loc(), None)
// HACK: change this func's return type to TyCheckResult<Type>
.map_err(|mut errs| errs.remove(0))?;
return Ok(method.method_type.clone());
}
Err(err) if err.core.kind == ErrorKind::TypeError => {
return Err(err);
}
_ => {}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(attr_name.inspect())
.or_else(|| patch.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr(obj.ref_t(), attr_name.inspect()),
))
} else {
Ok(VarInfo {
t: obj.t(),
..VarInfo::default()
})
}
}
fn validate_visibility(
&self,
ident: &Identifier,
vi: &VarInfo,
input: &Input,
namespace: &str,
) -> SingleTyCheckResult<()> {
if ident.vis() != vi.vis {
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
vi.vis,
))
// check if the private variable is loaded from the other scope
} else if vi.vis.is_private()
&& &self.name[..] != "<builtins>"
&& &self.name[..] != namespace
&& !namespace.contains(&self.name[..])
{
log!(err "{namespace}/{}", self.name);
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
Private,
))
} else {
Ok(())
}
}
// HACK: dname.loc()はダミーLocationしか返さないので、エラーならop.loc()で上書きする
fn append_loc_info(&self, e: TyCheckError, loc: Location) -> TyCheckError {
if e.core.loc == Location::Unknown {
let mut sub_msges = Vec::new();
for sub_msg in e.core.sub_messages {
sub_msges.push(SubMessage::ambiguous_new(loc, sub_msg.msg, sub_msg.hint));
}
let core = ErrorCore::new(
sub_msges,
e.core.main_message,
e.core.errno,
e.core.kind,
e.core.loc,
);
TyCheckError::new(core, self.cfg.input.clone(), e.caused_by)
} else {
e
}
}
pub(crate) fn get_binop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 2);
let cont = binop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let t = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, t));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let lhs = args[0].expr.clone();
let rhs = args[1].expr.clone();
let bin = hir::BinOp::new(op_ident.name.into_token(), lhs, rhs, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, bin.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
pub(crate) fn get_unaryop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 1);
let cont = unaryop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let vi = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, vi));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let expr = args[0].expr.clone();
let unary = hir::UnaryOp::new(op_ident.name.into_token(), expr, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, unary.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
/// 可変依存型の変更を伝搬させる
fn propagate(&self, t: &Type, callee: &hir::Expr) -> TyCheckResult<()> {
if let Type::Subr(subr) = t {
if let Some(after) = subr.self_t().and_then(|self_t| {
if let RefMut { after, .. } = self_t {
after.as_ref()
} else {
None
}
}) {
self.reunify(callee.ref_t(), after, callee.loc())?;
}
}
Ok(())
}
fn not_callable_error(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
other: &Type,
hint: Option<String>,
) -> TyCheckErrors {
let (loc, name) = if let Some(attr_name) = attr_name {
(
Location::concat(obj, attr_name),
(obj.to_string() + &attr_name.to_string()),
)
} else {
(obj.loc(), obj.to_string())
};
TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&name,
None,
&mono("Callable"),
other,
self.get_candidates(other),
hint,
))
}
/// if `obj` has `__call__` method, then the return value is `Some(call_instance)`
///
/// e.g.
/// ```python
/// substitute_call(instance: ((?T, ?U) -> ?T), [Int, Str], []) => instance: (Int, Str) -> Int
/// substitute_call(instance: ((?T, Int) -> ?T), [Int, Nat], []) => instance: (Int, Int) -> Str
/// substitute_call(instance: ((?M(: Nat)..?N(: Nat)) -> ?M+?N), [1..2], []) => instance: (1..2) -> {3}
/// substitute_call(instance: ((?L(: Add(?R, ?O)), ?R) -> ?O), [1, 2], []) => instance: (Nat, Nat) -> Nat
/// substitute_call(instance: ((Failure, ?T) -> ?T), [Int, Int]) => instance: (Failure, Int) -> Int
/// ```
fn substitute_call(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
instance: &Type,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<Option<Type>> {
match instance {
Type::FreeVar(fv) if fv.is_linked() => {
self.substitute_call(obj, attr_name, &fv.crack(), pos_args, kw_args)
}
Type::FreeVar(fv) => {
if let Some(sub) = fv.get_sub() {
if !self.subtype_of(&sub, &mono("GenericCallable")) {
return Err(self.not_callable_error(obj, attr_name, instance, None));
}
}
if let Some(attr_name) = attr_name {
feature_error!(TyCheckErrors, TyCheckError, self, attr_name.loc(), "")
} else {
let is_procedural = obj
.show_acc()
.map(|acc| acc.ends_with('!'))
.unwrap_or(false);
let kind = if is_procedural {
SubrKind::Proc
} else {
SubrKind::Func
};
let ret_t = free_var(self.level, Constraint::new_type_of(Type));
let non_default_params = pos_args.iter().map(|a| anon(a.expr.t())).collect();
let subr_t = subr_t(kind, non_default_params, None, vec![], ret_t);
fv.link(&subr_t);
Ok(None)
}
}
Type::Refinement(refine) => {
self.substitute_call(obj, attr_name, &refine.t, pos_args, kw_args)
}
Type::Subr(subr) => {
let mut errs = TyCheckErrors::empty();
let is_method = subr.self_t().is_some();
let callee = if let Some(ident) = attr_name {
if is_method {
obj.clone()
} else {
let attr = hir::Attribute::new(
obj.clone(),
hir::Identifier::bare(ident.dot.clone(), ident.name.clone()),
);
hir::Expr::Accessor(hir::Accessor::Attr(attr))
}
} else {
obj.clone()
};
let params_len = subr.non_default_params.len() + subr.default_params.len();
if (params_len < pos_args.len() || params_len < pos_args.len() + kw_args.len())
&& subr.var_params.is_none()
{
return Err(self.gen_too_many_args_error(&callee, subr, pos_args, kw_args));
}
let mut passed_params = set! {};
let non_default_params = if is_method {
let mut non_default_params = subr.non_default_params.iter();
let self_pt = non_default_params.next().unwrap();
if let Err(mut es) =
self.sub_unify(obj.ref_t(), self_pt.typ(), obj.loc(), self_pt.name())
{
errs.append(&mut es);
}
non_default_params
} else {
subr.non_default_params.iter()
};
let non_default_params_len = non_default_params.len();
let mut nth = 1;
if pos_args.len() >= non_default_params_len {
let (non_default_args, var_args) = pos_args.split_at(non_default_params_len);
for (nd_arg, nd_param) in non_default_args.iter().zip(non_default_params) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&nd_arg.expr,
nth,
nd_param,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
if let Some(var_param) = subr.var_params.as_ref() {
for var_arg in var_args.iter() {
if let Err(mut es) = self.substitute_var_arg(
&callee,
attr_name,
&var_arg.expr,
nth,
var_param,
) {
errs.append(&mut es);
}
nth += 1;
}
} else {
for (arg, pt) in var_args.iter().zip(subr.default_params.iter()) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&arg.expr,
nth,
pt,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for not_passed in subr
.default_params
.iter()
.filter(|pt| !passed_params.contains(pt.name().unwrap()))
{
if let ParamTy::KwWithDefault { ty, default, .. } = ¬_passed {
if let Err(mut es) =
self.sub_unify(default, ty, obj.loc(), not_passed.name())
{
errs.append(&mut es);
}
}
}
} else {
// pos_args.len() < non_default_params_len
let mut params = non_default_params.chain(subr.default_params.iter());
for pos_arg in pos_args.iter() {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&pos_arg.expr,
nth,
params.next().unwrap(),
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
let missing_params = subr
.non_default_params
.iter()
.map(|pt| pt.name().cloned().unwrap_or(Str::ever("_")))
.filter(|pt| !passed_params.contains(pt))
.collect::<Vec<_>>();
if !missing_params.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
missing_params,
)));
}
}
if errs.is_empty() {
Ok(None)
} else {
Err(errs)
}
}
other => {
if let Ok(typ_ctx) = self.get_singular_ctx_by_hir_expr(obj, &self.name) {
if let Some(call_vi) = typ_ctx.get_current_scope_var("__call__") {
let mut dummy = TyVarCache::new(self.level, self);
let instance =
self.instantiate_t_inner(call_vi.t.clone(), &mut dummy, obj.loc())?;
self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
return Ok(Some(instance));
}
}
let hint = if other == &ClassType {
Some(switch_lang! {
"japanese" => format!("インスタンスを生成したい場合は、{}.newを使用してください", obj.to_string_notype()),
"simplified_chinese" => format!("如果要生成实例，请使用 {}.new", obj.to_string_notype()),
"traditional_chinese" => format!("如果要生成實例，請使用 {}.new", obj.to_string_notype()),
"english" => format!("If you want to generate an instance, use {}.new", obj.to_string_notype()),
})
} else {
None
};
Err(self.not_callable_error(obj, attr_name, other, hint))
}
}
}
fn gen_too_many_args_error(
&self,
callee: &hir::Expr,
subr_ty: &SubrType,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckErrors {
let mut unknown_args = vec![];
let mut passed_args: Vec<&hir::KwArg> = vec![];
let mut duplicated_args = vec![];
for kw_arg in kw_args.iter() {
if subr_ty
.non_default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
&& subr_ty
.var_params
.as_ref()
.map(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
.unwrap_or(true)
&& subr_ty
.default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
{
unknown_args.push(kw_arg);
}
if passed_args.iter().any(|a| a.keyword == kw_arg.keyword) {
duplicated_args.push(kw_arg);
} else {
passed_args.push(kw_arg);
}
}
if unknown_args.is_empty() && duplicated_args.is_empty() {
let params_len = subr_ty.non_default_params.len() + subr_ty.default_params.len();
TyCheckErrors::from(TyCheckError::too_many_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
params_len,
pos_args.len(),
kw_args.len(),
))
} else {
let unknown_arg_errors = unknown_args.into_iter().map(|arg| {
TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
let duplicated_arg_errors = duplicated_args.into_iter().map(|arg| {
TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
unknown_arg_errors.chain(duplicated_arg_errors).collect()
}
}
fn substitute_pos_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
if let Some(name) = param.name() {
if passed_params.contains(name) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
name,
)));
} else {
passed_params.insert(name.clone());
}
}
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
let mut hint = Self::get_call_type_mismatch_hint(
callee.ref_t(),
attr_name.as_ref().map(|i| &i.inspect()[..]),
nth,
param_t,
arg_t,
);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
std::mem::take(&mut hint),
)
})
.collect(),
)
})?;
Ok(())
}
fn substitute_var_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
)
})
}
fn substitute_kw_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::KwArg,
nth: usize,
subr_ty: &SubrType,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.expr.ref_t();
let kw_name = arg.keyword.inspect();
if passed_params.contains(&kw_name[..]) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)));
}
if let Some(pt) = subr_ty
.non_default_params
.iter()
.chain(subr_ty.default_params.iter())
.find(|pt| pt.name().as_ref() == Some(&kw_name))
{
passed_params.insert(kw_name.clone());
self.sub_unify(arg_t, pt.typ(), arg.loc(), Some(kw_name))
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {}", pt.typ());
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + readable_name(kw_name);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
pt.typ(),
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(pt.typ(), arg_t),
)
})
.collect(),
)
})?;
} else {
return Err(TyCheckErrors::from(TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.keyword.loc(),
&callee.to_string(),
self.caused_by(),
kw_name,
)));
}
Ok(())
}
pub(crate) fn get_call_t(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
if let hir::Expr::Accessor(hir::Accessor::Ident(local)) = obj {
if local.vis().is_private() {
match &local.inspect()[..] {
"match" => {
return self.get_match_call_t(SubrKind::Func, pos_args, kw_args);
}
"match!" => {
return self.get_match_call_t(SubrKind::Proc, pos_args, kw_args);
}
_ => {}
}
}
}
let found = self.search_callee_info(obj, attr_name, input, namespace)?;
log!(
"Found:\ncallee: {obj}{}\nfound: {found}",
fmt_option!(pre ".", attr_name.as_ref().map(|ident| &ident.name))
);
let instance = self.instantiate(found.t, obj)?;
log!(
"Instantiated:\ninstance: {instance}\npos_args: ({})\nkw_args: ({})",
fmt_slice(pos_args),
fmt_slice(kw_args)
);
let res = self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
let instance = if let Some(__call__) = res {
__call__
} else {
instance
};
log!(info "Substituted:\ninstance: {instance}");
let res = self.eval_t_params(instance, self.level, obj.loc())?;
log!(info "Params evaluated:\nres: {res}\n");
self.propagate(&res, obj)?;
log!(info "Propagated:\nres: {res}\n");
let res = VarInfo { t: res, ..found };
Ok(res)
}
pub(crate) fn get_const_local(
&self,
name: &Token,
namespace: &Str,
) -> SingleTyCheckResult<ValueObj> {
if let Some(obj) = self.consts.get(name.inspect()) {
Ok(obj.clone())
} else {
/*if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
return parent.get_const_local(name, namespace);
}*/
Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
name.inspect(),
self.get_similar_name(name.inspect()),
))
}
}context/register.rs (lines 1427-1434)
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
pub fn del(&mut self, ident: &hir::Identifier) -> CompileResult<()> {
if self.rec_get_const_obj(ident.inspect()).is_some()
|| self
.get_builtins()
.unwrap()
.get_local_kv(ident.inspect())
.is_some()
{
Err(TyCheckErrors::from(TyCheckError::del_error(
self.cfg.input.clone(),
line!() as usize,
ident,
self.caused_by(),
)))
} else if self.locals.get(ident.inspect()).is_some() {
let vi = self.locals.remove(ident.inspect()).unwrap();
self.deleted_locals.insert(ident.name.clone(), vi);
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)))
}
}context/eval.rs (lines 132-139)
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
fn eval_const_acc(&self, acc: &Accessor) -> EvalResult<ValueObj> {
match acc {
Accessor::Ident(ident) => {
if let Some(val) = self.rec_get_const_obj(ident.inspect()) {
Ok(val.clone())
} else if ident.is_const() {
Err(EvalErrors::from(EvalError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)))
} else {
Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
acc.loc(),
self.caused_by(),
)))
}
}
Accessor::Attr(attr) => {
let obj = self.eval_const_expr(&attr.obj)?;
Ok(self.eval_attr(obj, &attr.ident)?)
}
other => {
feature_error!(self, other.loc(), &format!("eval {other}")).map_err(Into::into)
}
}
}
fn eval_attr(&self, obj: ValueObj, ident: &Identifier) -> SingleEvalResult<ValueObj> {
if let Some(val) = obj.try_get_attr(&Field::from(ident)) {
return Ok(val);
}
if let ValueObj::Type(t) = &obj {
if let Some(sups) = self.get_nominal_super_type_ctxs(t.typ()) {
for ctx in sups {
if let Some(val) = ctx.consts.get(ident.inspect()) {
return Ok(val.clone());
}
for (_, methods) in ctx.methods_list.iter() {
if let Some(v) = methods.consts.get(ident.inspect()) {
return Ok(v.clone());
}
}
}
}
}
Err(EvalError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
&obj.t(),
ident.inspect(),
None,
))
}
fn eval_const_bin(&self, bin: &BinOp) -> EvalResult<ValueObj> {
let lhs = self.eval_const_expr(&bin.args[0])?;
let rhs = self.eval_const_expr(&bin.args[1])?;
let op = try_get_op_kind_from_token(bin.op.kind)?;
self.eval_bin(op, lhs, rhs)
}
fn eval_const_unary(&self, unary: &UnaryOp) -> EvalResult<ValueObj> {
let val = self.eval_const_expr(&unary.args[0])?;
let op = try_get_op_kind_from_token(unary.op.kind)?;
self.eval_unary_val(op, val)
}
fn eval_args(&self, args: &Args) -> EvalResult<ValueArgs> {
let mut evaluated_pos_args = vec![];
for arg in args.pos_args().iter() {
let val = self.eval_const_expr(&arg.expr)?;
evaluated_pos_args.push(val);
}
let mut evaluated_kw_args = dict! {};
for arg in args.kw_args().iter() {
let val = self.eval_const_expr(&arg.expr)?;
evaluated_kw_args.insert(arg.keyword.inspect().clone(), val);
}
Ok(ValueArgs::new(evaluated_pos_args, evaluated_kw_args))
}
fn eval_const_call(&self, call: &Call) -> EvalResult<ValueObj> {
if let Expr::Accessor(acc) = call.obj.as_ref() {
match acc {
Accessor::Ident(ident) => {
let obj = self.rec_get_const_obj(ident.inspect()).ok_or_else(|| {
EvalError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)
})?;
let subr = option_enum_unwrap!(obj, ValueObj::Subr)
.ok_or_else(|| {
EvalError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
None,
&mono("Subroutine"),
&obj.t(),
self.get_candidates(&obj.t()),
None,
)
})?
.clone();
let args = self.eval_args(&call.args)?;
self.call(subr, args, call.loc())
}
// TODO: eval attr
Accessor::Attr(_attr) => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
))),
// TODO: eval type app
Accessor::TypeApp(_type_app) => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
))),
_ => unreachable!(),
}
} else {
Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
call.loc(),
self.caused_by(),
)))
}
}context/instantiate.rs (lines 388-395)
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934
pub(crate) fn instantiate_predecl_t(
&self,
predecl: &PreDeclTypeSpec,
opt_decl_t: Option<&ParamTy>,
tmp_tv_cache: &mut TyVarCache,
not_found_is_qvar: bool,
) -> TyCheckResult<Type> {
match predecl {
ast::PreDeclTypeSpec::Simple(simple) => {
self.instantiate_simple_t(simple, opt_decl_t, tmp_tv_cache, not_found_is_qvar)
}
ast::PreDeclTypeSpec::Attr { namespace, t } => {
if let Ok(namespace) = Parser::validate_const_expr(namespace.as_ref().clone()) {
if let Ok(namespace) =
self.instantiate_const_expr_as_type(&namespace, None, tmp_tv_cache)
{
let rhs = t.ident.inspect();
return Ok(proj(namespace, rhs));
}
}
let ctx = self.get_singular_ctx(namespace.as_ref(), &self.name)?;
if let Some((typ, _)) = ctx.rec_get_type(t.ident.inspect()) {
// TODO: visibility check
Ok(typ.clone())
} else {
Err(TyCheckErrors::from(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
t.loc(),
self.caused_by(),
t.ident.inspect(),
self.get_similar_name(t.ident.inspect()),
)))
}
}
other => type_feature_error!(self, other.loc(), &format!("instantiating {other}")),
}
}
pub(crate) fn instantiate_simple_t(
&self,
simple: &SimpleTypeSpec,
opt_decl_t: Option<&ParamTy>,
tmp_tv_cache: &mut TyVarCache,
not_found_is_qvar: bool,
) -> TyCheckResult<Type> {
match &simple.ident.inspect()[..] {
"_" | "Obj" => Ok(Type::Obj),
"Nat" => Ok(Type::Nat),
"Int" => Ok(Type::Int),
"Ratio" => Ok(Type::Ratio),
"Float" => Ok(Type::Float),
"Str" => Ok(Type::Str),
"Bool" => Ok(Type::Bool),
"NoneType" => Ok(Type::NoneType),
"Ellipsis" => Ok(Type::Ellipsis),
"NotImplemented" => Ok(Type::NotImplemented),
"Inf" => Ok(Type::Inf),
"NegInf" => Ok(Type::NegInf),
"Never" => Ok(Type::Never),
"ClassType" => Ok(Type::ClassType),
"TraitType" => Ok(Type::TraitType),
"Type" => Ok(Type::Type),
"Array" => {
// TODO: kw
let mut args = simple.args.pos_args();
if let Some(first) = args.next() {
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
let len = if let Some(len) = args.next() {
self.instantiate_const_expr(&len.expr, None, tmp_tv_cache)?
} else {
TyParam::erased(Nat)
};
Ok(array_t(t, len))
} else {
Ok(mono("GenericArray"))
}
}
"Ref" => {
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"Ref",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_(t))
}
"RefMut" => {
// TODO after
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"RefMut",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_mut(t, None))
}
"Self" => self.rec_get_self_t().ok_or_else(|| {
TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
erg_common::fn_name_full!(),
line!(),
))
}),
other if simple.args.is_empty() => {
if let Some(t) = tmp_tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tmp_tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
if let Some(tv_cache) = &self.tv_cache {
if let Some(t) = tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
}
if let Some(outer) = &self.outer {
if let Ok(t) = outer.instantiate_simple_t(
simple,
opt_decl_t,
tmp_tv_cache,
not_found_is_qvar,
) {
return Ok(t);
}
}
if let Some(decl_t) = opt_decl_t {
return Ok(decl_t.typ().clone());
}
if let Some((typ, _)) = self.rec_get_type(other) {
Ok(typ.clone())
} else if not_found_is_qvar {
let tyvar = named_free_var(Str::rc(other), self.level, Constraint::Uninited);
tmp_tv_cache.push_or_init_tyvar(&Str::rc(other), &tyvar);
Ok(tyvar)
} else {
Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)))
}
}
other => {
let ctx = if let Some((_, ctx)) = self.rec_get_type(other) {
ctx
} else {
return Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.ident.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)));
};
// FIXME: kw args
let mut new_params = vec![];
for (i, arg) in simple.args.pos_args().enumerate() {
let params =
self.instantiate_const_expr(&arg.expr, Some((ctx, i)), tmp_tv_cache);
let params = params.or_else(|e| {
if not_found_is_qvar {
let name = Str::from(arg.expr.to_string());
let tp = TyParam::named_free_var(
name.clone(),
self.level,
Constraint::Uninited,
);
tmp_tv_cache.push_or_init_typaram(&name, &tp);
Ok(tp)
} else {
Err(e)
}
})?;
new_params.push(params);
}
// FIXME: non-builtin
Ok(poly(Str::rc(other), new_params))
}
}
}
pub(crate) fn instantiate_const_expr(
&self,
expr: &ast::ConstExpr,
erased_idx: Option<(&Context, usize)>,
tmp_tv_cache: &mut TyVarCache,
) -> TyCheckResult<TyParam> {
match expr {
ast::ConstExpr::Lit(lit) => Ok(TyParam::Value(self.eval_lit(lit)?)),
ast::ConstExpr::Accessor(ast::ConstAccessor::Local(name)) => {
if &name.inspect()[..] == "_" {
let t = if let Some((ctx, i)) = erased_idx {
ctx.params[i].1.t.clone()
} else {
Type::Uninited
};
return Ok(TyParam::erased(t));
}
if let Some(tp) = tmp_tv_cache.get_typaram(name.inspect()) {
return Ok(tp.clone());
} else if let Some(t) = tmp_tv_cache.get_tyvar(name.inspect()) {
return Ok(TyParam::t(t.clone()));
}
if let Some(tv_ctx) = &self.tv_cache {
if let Some(t) = tv_ctx.get_tyvar(name.inspect()) {
return Ok(TyParam::t(t.clone()));
} else if let Some(tp) = tv_ctx.get_typaram(name.inspect()) {
return Ok(tp.clone());
}
}
if let Some(value) = self.rec_get_const_obj(name.inspect()) {
return Ok(TyParam::Value(value.clone()));
}
Err(TyCheckErrors::from(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
name.inspect(),
self.get_similar_name(name.inspect()),
)))
}
other => type_feature_error!(self, other.loc(), &format!("instantiating {other}")),
}
}
pub(crate) fn instantiate_const_expr_as_type(
&self,
expr: &ast::ConstExpr,
erased_idx: Option<(&Context, usize)>,
tmp_tv_cache: &mut TyVarCache,
) -> TyCheckResult<Type> {
match self.instantiate_const_expr(expr, erased_idx, tmp_tv_cache)? {
TyParam::Type(t) => Ok(*t),
TyParam::Value(ValueObj::Type(t)) => Ok(t.into_typ()),
other => type_feature_error!(self, expr.loc(), &format!("{other}")),
}
}
fn instantiate_func_param_spec(
&self,
p: &ParamTySpec,
opt_decl_t: Option<&ParamTy>,
default_t: Option<&TypeSpec>,
tmp_tv_cache: &mut TyVarCache,
mode: RegistrationMode,
) -> TyCheckResult<ParamTy> {
let t = self.instantiate_typespec(&p.ty, opt_decl_t, tmp_tv_cache, mode, false)?;
if let Some(default_t) = default_t {
Ok(ParamTy::kw_default(
p.name.as_ref().unwrap().inspect().to_owned(),
t,
self.instantiate_typespec(default_t, opt_decl_t, tmp_tv_cache, mode, false)?,
))
} else {
Ok(ParamTy::pos(
p.name.as_ref().map(|t| t.inspect().to_owned()),
t,
))
}
}
pub(crate) fn instantiate_typespec(
&self,
t_spec: &TypeSpec,
opt_decl_t: Option<&ParamTy>,
tmp_tv_cache: &mut TyVarCache,
mode: RegistrationMode,
not_found_is_qvar: bool,
) -> TyCheckResult<Type> {
match t_spec {
TypeSpec::Infer(_) => Ok(free_var(self.level, Constraint::new_type_of(Type))),
TypeSpec::PreDeclTy(predecl) => Ok(self.instantiate_predecl_t(
predecl,
opt_decl_t,
tmp_tv_cache,
not_found_is_qvar,
)?),
TypeSpec::And(lhs, rhs) => Ok(self.intersection(
&self.instantiate_typespec(
lhs,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?,
&self.instantiate_typespec(
rhs,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?,
)),
TypeSpec::Or(lhs, rhs) => Ok(self.union(
&self.instantiate_typespec(
lhs,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?,
&self.instantiate_typespec(
rhs,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?,
)),
TypeSpec::Not(lhs, rhs) => Ok(not(
self.instantiate_typespec(lhs, opt_decl_t, tmp_tv_cache, mode, not_found_is_qvar)?,
self.instantiate_typespec(rhs, opt_decl_t, tmp_tv_cache, mode, not_found_is_qvar)?,
)),
TypeSpec::Array(arr) => {
let elem_t = self.instantiate_typespec(
&arr.ty,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?;
let mut len = self.instantiate_const_expr(&arr.len, None, tmp_tv_cache)?;
if let TyParam::Erased(t) = &mut len {
*t.as_mut() = Type::Nat;
}
Ok(array_t(elem_t, len))
}
TypeSpec::SetWithLen(set) => {
let elem_t = self.instantiate_typespec(
&set.ty,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?;
let mut len = self.instantiate_const_expr(&set.len, None, tmp_tv_cache)?;
if let TyParam::Erased(t) = &mut len {
*t.as_mut() = Type::Nat;
}
Ok(set_t(elem_t, len))
}
TypeSpec::Tuple(tup) => {
let mut inst_tys = vec![];
for spec in tup.tys.iter() {
inst_tys.push(self.instantiate_typespec(
spec,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?);
}
Ok(tuple_t(inst_tys))
}
TypeSpec::Dict(dict) => {
let mut inst_tys = dict! {};
for (k, v) in dict {
inst_tys.insert(
self.instantiate_typespec(
k,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?,
self.instantiate_typespec(
v,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?,
);
}
Ok(dict_t(inst_tys.into()))
}
TypeSpec::Record(rec) => {
let mut inst_tys = dict! {};
for (k, v) in rec {
inst_tys.insert(
k.into(),
self.instantiate_typespec(
v,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?,
);
}
Ok(Type::Record(inst_tys))
}
// TODO: エラー処理(リテラルでない)はパーサーにやらせる
TypeSpec::Enum(set) => {
let mut new_set = set! {};
for arg in set.pos_args() {
new_set.insert(self.instantiate_const_expr(&arg.expr, None, tmp_tv_cache)?);
}
let ty = new_set.iter().fold(Type::Never, |t, tp| {
self.union(&t, &self.get_tp_t(tp).unwrap())
});
Ok(tp_enum(ty, new_set))
}
TypeSpec::Interval { op, lhs, rhs } => {
let op = match op.kind {
TokenKind::Closed => IntervalOp::Closed,
TokenKind::LeftOpen => IntervalOp::LeftOpen,
TokenKind::RightOpen => IntervalOp::RightOpen,
TokenKind::Open => IntervalOp::Open,
_ => assume_unreachable!(),
};
let l = self.instantiate_const_expr(lhs, None, tmp_tv_cache)?;
let l = self.eval_tp(l)?;
let r = self.instantiate_const_expr(rhs, None, tmp_tv_cache)?;
let r = self.eval_tp(r)?;
if let Some(Greater) = self.try_cmp(&l, &r) {
panic!("{l}..{r} is not a valid interval type (should be lhs <= rhs)")
}
Ok(int_interval(op, l, r))
}
TypeSpec::Subr(subr) => {
let mut inner_tv_ctx = if !subr.bounds.is_empty() {
let tv_cache = self.instantiate_ty_bounds(&subr.bounds, mode)?;
Some(tv_cache)
} else {
None
};
if let Some(inner) = &mut inner_tv_ctx {
inner.merge(tmp_tv_cache);
}
let tmp_tv_ctx = if let Some(inner) = &mut inner_tv_ctx {
inner
} else {
tmp_tv_cache
};
let non_defaults = try_map_mut(subr.non_defaults.iter(), |p| {
self.instantiate_func_param_spec(p, opt_decl_t, None, tmp_tv_ctx, mode)
})?;
let var_args = subr
.var_args
.as_ref()
.map(|p| {
self.instantiate_func_param_spec(p, opt_decl_t, None, tmp_tv_ctx, mode)
})
.transpose()?;
let defaults = try_map_mut(subr.defaults.iter(), |p| {
self.instantiate_func_param_spec(
&p.param,
opt_decl_t,
Some(&p.default),
tmp_tv_ctx,
mode,
)
})?
.into_iter()
.collect();
let return_t = self.instantiate_typespec(
&subr.return_t,
opt_decl_t,
tmp_tv_ctx,
mode,
not_found_is_qvar,
)?;
Ok(subr_t(
SubrKind::from(subr.arrow.kind),
non_defaults,
var_args,
defaults,
return_t,
))
}
TypeSpec::TypeApp { spec, args } => {
type_feature_error!(self, t_spec.loc(), &format!("instantiating {spec}{args}"))
}
}
}
pub(crate) fn instantiate_ty_bound(
&self,
bound: &TypeBoundSpec,
tv_cache: &mut TyVarCache,
mode: RegistrationMode,
) -> TyCheckResult<()> {
// REVIEW: 型境界の左辺に来れるのは型変数だけか?
// TODO: 高階型変数
match bound {
TypeBoundSpec::NonDefault { lhs, spec } => {
let constr =
match spec.op.kind {
TokenKind::SubtypeOf => Constraint::new_subtype_of(
self.instantiate_typespec(&spec.t_spec, None, tv_cache, mode, true)?,
),
TokenKind::SupertypeOf => {
return type_feature_error!(self, spec.loc(), "supertype of");
}
TokenKind::Colon => Constraint::new_type_of(self.instantiate_typespec(
&spec.t_spec,
None,
tv_cache,
mode,
true,
)?),
_ => unreachable!(),
};
let tv = named_free_var(lhs.inspect().clone(), self.level, constr);
tv_cache.push_or_init_tyvar(lhs.inspect(), &tv);
Ok(())
}
TypeBoundSpec::WithDefault { .. } => type_feature_error!(
self,
bound.loc(),
"type boundary specification with default"
),
}
}
pub(crate) fn instantiate_ty_bounds(
&self,
bounds: &TypeBoundSpecs,
mode: RegistrationMode,
) -> TyCheckResult<TyVarCache> {
let mut tv_cache = TyVarCache::new(self.level, self);
for bound in bounds.iter() {
self.instantiate_ty_bound(bound, &mut tv_cache, mode)?;
}
for tv in tv_cache.tyvar_instances.values() {
if tv.constraint().map(|c| c.is_uninited()).unwrap_or(false) {
return Err(TyCheckErrors::from(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
bounds.loc(),
self.caused_by(),
&tv.local_name(),
self.get_similar_name(&tv.local_name()),
)));
}
}
for tp in tv_cache.typaram_instances.values() {
if tp.constraint().map(|c| c.is_uninited()).unwrap_or(false) {
return Err(TyCheckErrors::from(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
bounds.loc(),
self.caused_by(),
&tp.to_string(),
self.get_similar_name(&tp.to_string()),
)));
}
}
Ok(tv_cache)
}reorder.rs (lines 80-87)
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
pub fn reorder(mut self, mut ast: AST) -> Result<AST, TyCheckErrors> {
log!(info "the reordering process has started.");
let mut new = vec![];
while let Some(chunk) = ast.module.lpop() {
match chunk {
Expr::Def(def) => {
match def.body.block.first().unwrap() {
Expr::Call(call) => {
match call.obj.get_name().map(|s| &s[..]) {
// TODO: decorator
Some("Class" | "Inherit" | "Inheritable") => {
self.def_root_pos_map.insert(
def.sig.ident().unwrap().inspect().clone(),
new.len(),
);
let type_def = ClassDef::new(def, vec![]);
new.push(Expr::ClassDef(type_def));
}
Some("Patch") => {
self.def_root_pos_map.insert(
def.sig.ident().unwrap().inspect().clone(),
new.len(),
);
let type_def = PatchDef::new(def, vec![]);
new.push(Expr::PatchDef(type_def));
}
_ => {
new.push(Expr::Def(def));
}
}
}
_ => {
new.push(Expr::Def(def));
}
}
}
Expr::Methods(methods) => match &methods.class {
TypeSpec::PreDeclTy(PreDeclTypeSpec::Simple(simple)) => {
self.link_methods(simple.ident.inspect().clone(), &mut new, methods)
}
TypeSpec::TypeApp { spec, .. } => {
if let TypeSpec::PreDeclTy(PreDeclTypeSpec::Simple(simple)) = spec.as_ref()
{
self.link_methods(simple.ident.inspect().clone(), &mut new, methods)
} else {
let similar_name = self
.def_root_pos_map
.keys()
.fold("".to_string(), |acc, key| acc + &key[..] + ",");
self.errs.push(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
methods.class.loc(),
"".into(),
&methods.class.to_string(),
Some(&Str::from(similar_name)),
));
}
}
other => todo!("{other}"),
},
other => {
new.push(other);
}
}
}
let ast = AST::new(ast.name, Module::new(new));
log!(info "the reordering process has completed:\n{}", ast);
if self.errs.is_empty() {
Ok(ast)
} else {
Err(self.errs)
}
}
fn link_methods(&mut self, name: Str, new: &mut Vec<Expr>, methods: Methods) {
if let Some(pos) = self.def_root_pos_map.get(&name) {
match new.remove(*pos) {
Expr::ClassDef(mut class_def) => {
class_def.methods_list.push(methods);
new.insert(*pos, Expr::ClassDef(class_def));
}
Expr::PatchDef(mut patch_def) => {
patch_def.methods_list.push(methods);
new.insert(*pos, Expr::PatchDef(patch_def));
}
_ => unreachable!(),
}
} else {
let similar_name = self
.def_root_pos_map
.keys()
.fold("".to_string(), |acc, key| acc + &key[..] + ",");
self.errs.push(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
methods.class.loc(),
"".into(),
&name,
Some(&Str::from(similar_name)),
));
}
}Additional examples can be found in:
sourcepub fn access_before_def_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
defined_line: usize,
similar_name: Option<&str>
) -> Self
pub fn access_before_def_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
defined_line: usize,
similar_name: Option<&str>
) -> Self
Examples found in repository?
context/inquire.rs (lines 366-374)
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
pub(crate) fn rec_get_var_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.get_current_scope_var(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
} else if let Some((name, _vi)) = self
.future_defined_locals
.get_key_value(&ident.inspect()[..])
{
return Err(TyCheckError::access_before_def_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
} else if let Some((name, _vi)) = self.deleted_locals.get_key_value(&ident.inspect()[..]) {
return Err(TyCheckError::access_deleted_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
match parent.rec_get_var_info(ident, acc_kind, input, namespace) {
Ok(vi) => Ok(vi),
Err(err) if err.core.kind == ErrorKind::DummyError => {
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
Err(err) => Err(err),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}sourcepub fn access_deleted_var_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
del_line: usize,
similar_name: Option<&str>
) -> Self
pub fn access_deleted_var_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
del_line: usize,
similar_name: Option<&str>
) -> Self
Examples found in repository?
context/inquire.rs (lines 376-384)
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
pub(crate) fn rec_get_var_info(
&self,
ident: &Identifier,
acc_kind: AccessKind,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if let Some(vi) = self.get_current_scope_var(&ident.inspect()[..]) {
match self.validate_visibility(ident, vi, input, namespace) {
Ok(()) => {
return Ok(vi.clone());
}
Err(err) => {
if !acc_kind.is_local() {
return Err(err);
}
}
}
} else if let Some((name, _vi)) = self
.future_defined_locals
.get_key_value(&ident.inspect()[..])
{
return Err(TyCheckError::access_before_def_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
} else if let Some((name, _vi)) = self.deleted_locals.get_key_value(&ident.inspect()[..]) {
return Err(TyCheckError::access_deleted_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
name.ln_begin().unwrap_or(0),
self.get_similar_name(ident.inspect()),
));
}
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
match parent.rec_get_var_info(ident, acc_kind, input, namespace) {
Ok(vi) => Ok(vi),
Err(err) if err.core.kind == ErrorKind::DummyError => {
Err(TyCheckError::no_var_error(
input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
))
}
Err(err) => Err(err),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}sourcepub fn no_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
similar_name: Option<&str>
) -> Self
pub fn no_type_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
similar_name: Option<&str>
) -> Self
Examples found in repository?
context/instantiate.rs (lines 514-521)
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
pub(crate) fn instantiate_simple_t(
&self,
simple: &SimpleTypeSpec,
opt_decl_t: Option<&ParamTy>,
tmp_tv_cache: &mut TyVarCache,
not_found_is_qvar: bool,
) -> TyCheckResult<Type> {
match &simple.ident.inspect()[..] {
"_" | "Obj" => Ok(Type::Obj),
"Nat" => Ok(Type::Nat),
"Int" => Ok(Type::Int),
"Ratio" => Ok(Type::Ratio),
"Float" => Ok(Type::Float),
"Str" => Ok(Type::Str),
"Bool" => Ok(Type::Bool),
"NoneType" => Ok(Type::NoneType),
"Ellipsis" => Ok(Type::Ellipsis),
"NotImplemented" => Ok(Type::NotImplemented),
"Inf" => Ok(Type::Inf),
"NegInf" => Ok(Type::NegInf),
"Never" => Ok(Type::Never),
"ClassType" => Ok(Type::ClassType),
"TraitType" => Ok(Type::TraitType),
"Type" => Ok(Type::Type),
"Array" => {
// TODO: kw
let mut args = simple.args.pos_args();
if let Some(first) = args.next() {
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
let len = if let Some(len) = args.next() {
self.instantiate_const_expr(&len.expr, None, tmp_tv_cache)?
} else {
TyParam::erased(Nat)
};
Ok(array_t(t, len))
} else {
Ok(mono("GenericArray"))
}
}
"Ref" => {
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"Ref",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_(t))
}
"RefMut" => {
// TODO after
let mut args = simple.args.pos_args();
let Some(first) = args.next() else {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
simple.args.loc(),
"RefMut",
self.caused_by(),
vec![Str::from("T")],
)));
};
let t = self.instantiate_const_expr_as_type(&first.expr, None, tmp_tv_cache)?;
Ok(ref_mut(t, None))
}
"Self" => self.rec_get_self_t().ok_or_else(|| {
TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
erg_common::fn_name_full!(),
line!(),
))
}),
other if simple.args.is_empty() => {
if let Some(t) = tmp_tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tmp_tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
if let Some(tv_cache) = &self.tv_cache {
if let Some(t) = tv_cache.get_tyvar(other) {
return Ok(t.clone());
} else if let Some(tp) = tv_cache.get_typaram(other) {
let t = enum_unwrap!(tp, TyParam::Type);
return Ok(t.as_ref().clone());
}
}
if let Some(outer) = &self.outer {
if let Ok(t) = outer.instantiate_simple_t(
simple,
opt_decl_t,
tmp_tv_cache,
not_found_is_qvar,
) {
return Ok(t);
}
}
if let Some(decl_t) = opt_decl_t {
return Ok(decl_t.typ().clone());
}
if let Some((typ, _)) = self.rec_get_type(other) {
Ok(typ.clone())
} else if not_found_is_qvar {
let tyvar = named_free_var(Str::rc(other), self.level, Constraint::Uninited);
tmp_tv_cache.push_or_init_tyvar(&Str::rc(other), &tyvar);
Ok(tyvar)
} else {
Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)))
}
}
other => {
let ctx = if let Some((_, ctx)) = self.rec_get_type(other) {
ctx
} else {
return Err(TyCheckErrors::from(TyCheckError::no_type_error(
self.cfg.input.clone(),
line!() as usize,
simple.ident.loc(),
self.caused_by(),
other,
self.get_similar_name(other),
)));
};
// FIXME: kw args
let mut new_params = vec![];
for (i, arg) in simple.args.pos_args().enumerate() {
let params =
self.instantiate_const_expr(&arg.expr, Some((ctx, i)), tmp_tv_cache);
let params = params.or_else(|e| {
if not_found_is_qvar {
let name = Str::from(arg.expr.to_string());
let tp = TyParam::named_free_var(
name.clone(),
self.level,
Constraint::Uninited,
);
tmp_tv_cache.push_or_init_typaram(&name, &tp);
Ok(tp)
} else {
Err(e)
}
})?;
new_params.push(params);
}
// FIXME: non-builtin
Ok(poly(Str::rc(other), new_params))
}
}
}sourcepub fn type_not_found(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
typ: &Type
) -> Self
pub fn type_not_found(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
typ: &Type
) -> Self
Examples found in repository?
context/tyvar.rs (lines 369-375)
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
fn validate_subsup(
&self,
sub_t: Type,
super_t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
// TODO: Subr, ...
match (sub_t, super_t) {
// See tests\should_err\subtyping.er:8~13
(
Type::Poly {
name: ln,
params: lps,
},
Type::Poly {
name: rn,
params: rps,
},
) if ln == rn => {
let typ = poly(ln, lps.clone());
let (_, ctx) = self.get_nominal_type_ctx(&typ).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&typ,
)
})?;
let variances = ctx.type_params_variance();
let mut tps = vec![];
for ((lp, rp), variance) in lps
.into_iter()
.zip(rps.into_iter())
.zip(variances.into_iter())
{
self.sub_unify_tp(&lp, &rp, Some(variance), loc, false)?;
let param = if variance == Covariant { lp } else { rp };
tps.push(param);
}
Ok(poly(rn, tps))
}
(sub_t, super_t) => self.validate_simple_subsup(sub_t, super_t, variance, loc),
}
}
fn validate_simple_subsup(
&self,
sub_t: Type,
super_t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
if self.is_trait(&super_t) {
self.check_trait_impl(&sub_t, &super_t, loc)?;
}
// REVIEW: Even if type constraints can be satisfied, implementation may not exist
if self.subtype_of(&sub_t, &super_t) {
match variance {
Variance::Covariant => {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
Ok(sub_t)
}
Variance::Contravariant => {
let super_t = if cfg!(feature = "debug") {
super_t
} else {
self.deref_tyvar(super_t, variance, loc)?
};
Ok(super_t)
}
Variance::Invariant => {
// need to check if sub_t == super_t
if self.supertype_of(&sub_t, &super_t) {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
Ok(sub_t)
} else {
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&self.deref_tyvar(sub_t, variance, loc)?,
&self.deref_tyvar(super_t, variance, loc)?,
loc,
self.caused_by(),
)))
}
}
}
} else {
let sub_t = if cfg!(feature = "debug") {
sub_t
} else {
self.deref_tyvar(sub_t, variance, loc)?
};
let super_t = if cfg!(feature = "debug") {
super_t
} else {
self.deref_tyvar(super_t, variance, loc)?
};
Err(TyCheckErrors::from(TyCheckError::subtyping_error(
self.cfg.input.clone(),
line!() as usize,
&sub_t,
&super_t,
loc,
self.caused_by(),
)))
}
}
/// e.g.
/// ```python
// ?T(:> Nat, <: Int)[n] ==> Nat (self.level <= n)
// ?T(:> Nat, <: Sub(?U(:> {1}))) ==> Nat
// ?T(:> Nat, <: Sub(?U(:> {1}))) -> ?U ==> |U: Type, T <: Sub(U)| T -> U
// ?T(:> Nat, <: Sub(Str)) ==> Error!
// ?T(:> {1, "a"}, <: Eq(?T(:> {1, "a"}, ...)) ==> Error!
// ```
pub(crate) fn deref_tyvar(
&self,
t: Type,
variance: Variance,
loc: Location,
) -> TyCheckResult<Type> {
match t {
// ?T(:> Nat, <: Int)[n] ==> Nat (self.level <= n)
// ?T(:> Nat, <: Sub ?U(:> {1}))[n] ==> Nat
// ?T(:> Nat, <: Sub(Str)) ==> Error!
// ?T(:> {1, "a"}, <: Eq(?T(:> {1, "a"}, ...)) ==> Error!
Type::FreeVar(fv) if fv.constraint_is_sandwiched() => {
let (sub_t, super_t) = fv.get_subsup().unwrap();
if self.level <= fv.level().unwrap() {
self.validate_subsup(sub_t, super_t, variance, loc)
} else {
// no dereference at this point
// drop(constraint);
Ok(Type::FreeVar(fv))
}
}
Type::FreeVar(fv) if fv.is_unbound() => {
if self.level == 0 {
match &*fv.crack_constraint() {
Constraint::TypeOf(_) => {
Err(TyCheckErrors::from(TyCheckError::dummy_infer_error(
self.cfg.input.clone(),
fn_name!(),
line!(),
)))
}
_ => unreachable!(),
}
} else {
let new_constraint = fv.crack_constraint().clone();
let new_constraint = self.deref_constraint(new_constraint, variance, loc)?;
fv.update_constraint(new_constraint);
Ok(Type::FreeVar(fv))
}
}
Type::FreeVar(fv) if fv.is_linked() => {
let t = fv.unwrap_linked();
self.deref_tyvar(t, variance, loc)
}
Type::Poly { name, mut params } => {
let typ = poly(&name, params.clone());
let (_, ctx) = self.get_nominal_type_ctx(&typ).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&typ,
)
})?;
let variances = ctx.type_params_variance();
for (param, variance) in params.iter_mut().zip(variances.into_iter()) {
*param = self.deref_tp(mem::take(param), variance, loc)?;
}
Ok(Type::Poly { name, params })
}
Type::Subr(mut subr) => {
for param in subr.non_default_params.iter_mut() {
*param.typ_mut() =
self.deref_tyvar(mem::take(param.typ_mut()), Contravariant, loc)?;
}
if let Some(var_args) = &mut subr.var_params {
*var_args.typ_mut() =
self.deref_tyvar(mem::take(var_args.typ_mut()), Contravariant, loc)?;
}
for d_param in subr.default_params.iter_mut() {
*d_param.typ_mut() =
self.deref_tyvar(mem::take(d_param.typ_mut()), Contravariant, loc)?;
}
subr.return_t =
Box::new(self.deref_tyvar(mem::take(&mut subr.return_t), Covariant, loc)?);
Ok(Type::Subr(subr))
}
Type::Ref(t) => {
let t = self.deref_tyvar(*t, variance, loc)?;
Ok(ref_(t))
}
Type::RefMut { before, after } => {
let before = self.deref_tyvar(*before, variance, loc)?;
let after = if let Some(after) = after {
Some(self.deref_tyvar(*after, variance, loc)?)
} else {
None
};
Ok(ref_mut(before, after))
}
// Type::Callable { .. } => todo!(),
Type::Record(mut rec) => {
for (_, field) in rec.iter_mut() {
*field = self.deref_tyvar(mem::take(field), variance, loc)?;
}
Ok(Type::Record(rec))
}
Type::Refinement(refine) => {
let t = self.deref_tyvar(*refine.t, variance, loc)?;
// TODO: deref_predicate
Ok(refinement(refine.var, t, refine.preds))
}
Type::And(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
Ok(self.intersection(&l, &r))
}
Type::Or(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
Ok(self.union(&l, &r))
}
Type::Not(l, r) => {
let l = self.deref_tyvar(*l, variance, loc)?;
let r = self.deref_tyvar(*r, variance, loc)?;
// TODO: complement
Ok(not(l, r))
}
Type::Proj { lhs, rhs } => {
let lhs = self.deref_tyvar(*lhs, variance, loc)?;
self.eval_proj(lhs, rhs, self.level, loc)
}
Type::ProjCall {
lhs,
attr_name,
args,
} => {
let lhs = self.deref_tp(*lhs, variance, loc)?;
let mut new_args = vec![];
for arg in args.into_iter() {
new_args.push(self.deref_tp(arg, variance, loc)?);
}
self.eval_proj_call(lhs, attr_name, new_args, self.level, loc)
}
t => Ok(t),
}
}More examples
context/inquire.rs (lines 541-547)
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
fn get_attr_from_nominal_t(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
if let Some(sups) = self.get_nominal_super_type_ctxs(&self_t) {
for ctx in sups {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
let coerced = self
.deref_tyvar(obj.t(), Variance::Covariant, Location::Unknown)
.map_err(|mut es| es.remove(0))?;
if obj.ref_t() != &coerced {
for ctx in self.get_nominal_super_type_ctxs(&coerced).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&coerced,
)
})? {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
self.coerce(obj.ref_t());
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
Err(TyCheckError::dummy(input.clone(), line!() as usize))
}
/// get type from given attributive type (Record).
/// not ModuleType or ClassType etc.
fn get_attr_info_from_attributive(
&self,
t: &Type,
ident: &Identifier,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
match t {
// (obj: Never).foo: Never
Type::Never => Ok(VarInfo::ILLEGAL.clone()),
Type::FreeVar(fv) if fv.is_linked() => {
self.get_attr_info_from_attributive(&fv.crack(), ident, namespace)
}
Type::FreeVar(fv) /* if fv.is_unbound() */ => {
let sup = fv.get_super().unwrap();
self.get_attr_info_from_attributive(&sup, ident, namespace)
}
Type::Ref(t) => self.get_attr_info_from_attributive(t, ident, namespace),
Type::RefMut { before, .. } => {
self.get_attr_info_from_attributive(before, ident, namespace)
}
Type::Refinement(refine) => {
self.get_attr_info_from_attributive(&refine.t, ident, namespace)
}
Type::Record(record) => {
if let Some(attr_t) = record.get(ident.inspect()) {
let muty = Mutability::from(&ident.inspect()[..]);
let vi = VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
);
Ok(vi)
} else {
let t = Type::Record(record.clone());
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
&t,
ident.inspect(),
self.get_similar_attr(&t, ident.inspect()),
))
}
}
other => {
if let Some(v) = self.rec_get_const_obj(&other.local_name()) {
match v {
ValueObj::Type(TypeObj::Generated(gen)) => self
.get_gen_t_require_attr_t(gen, &ident.inspect()[..])
.map(|attr_t| {
let muty = Mutability::from(&ident.inspect()[..]);
VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
)
})
.ok_or_else(|| {
TyCheckError::dummy(self.cfg.input.clone(), line!() as usize)
}),
ValueObj::Type(TypeObj::Builtin(_t)) => {
// FIXME:
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
_other => Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
)),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
}
}
// returns callee's type, not the return type
fn search_callee_info(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if obj.ref_t() == Type::FAILURE {
// (...Obj) -> Failure
return Ok(VarInfo {
t: Type::Subr(SubrType::new(
SubrKind::Func,
vec![],
Some(ParamTy::pos(None, ref_(Obj))),
vec![],
Failure,
)),
..VarInfo::default()
});
}
if let Some(attr_name) = attr_name.as_ref() {
for ctx in self
.get_nominal_super_type_ctxs(obj.ref_t())
.ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
obj.ref_t(),
)
})?
{
if let Some(vi) = ctx
.locals
.get(attr_name.inspect())
.or_else(|| ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in ctx.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
if let Some(vi) = singular_ctx
.locals
.get(attr_name.inspect())
.or_else(|| singular_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, method_ctx) in singular_ctx.methods_list.iter() {
if let Some(vi) = method_ctx
.locals
.get(attr_name.inspect())
.or_else(|| method_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
return Err(TyCheckError::singular_no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.qual_name().unwrap_or("?"),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr_from_singular(obj, attr_name.inspect()),
));
}
match self.get_method_type_by_name(attr_name) {
Ok(method) => {
self.sub_unify(obj.ref_t(), &method.definition_type, obj.loc(), None)
// HACK: change this func's return type to TyCheckResult<Type>
.map_err(|mut errs| errs.remove(0))?;
return Ok(method.method_type.clone());
}
Err(err) if err.core.kind == ErrorKind::TypeError => {
return Err(err);
}
_ => {}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(attr_name.inspect())
.or_else(|| patch.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr(obj.ref_t(), attr_name.inspect()),
))
} else {
Ok(VarInfo {
t: obj.t(),
..VarInfo::default()
})
}
}
fn validate_visibility(
&self,
ident: &Identifier,
vi: &VarInfo,
input: &Input,
namespace: &str,
) -> SingleTyCheckResult<()> {
if ident.vis() != vi.vis {
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
vi.vis,
))
// check if the private variable is loaded from the other scope
} else if vi.vis.is_private()
&& &self.name[..] != "<builtins>"
&& &self.name[..] != namespace
&& !namespace.contains(&self.name[..])
{
log!(err "{namespace}/{}", self.name);
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
Private,
))
} else {
Ok(())
}
}
// HACK: dname.loc()はダミーLocationしか返さないので、エラーならop.loc()で上書きする
fn append_loc_info(&self, e: TyCheckError, loc: Location) -> TyCheckError {
if e.core.loc == Location::Unknown {
let mut sub_msges = Vec::new();
for sub_msg in e.core.sub_messages {
sub_msges.push(SubMessage::ambiguous_new(loc, sub_msg.msg, sub_msg.hint));
}
let core = ErrorCore::new(
sub_msges,
e.core.main_message,
e.core.errno,
e.core.kind,
e.core.loc,
);
TyCheckError::new(core, self.cfg.input.clone(), e.caused_by)
} else {
e
}
}
pub(crate) fn get_binop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 2);
let cont = binop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let t = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, t));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let lhs = args[0].expr.clone();
let rhs = args[1].expr.clone();
let bin = hir::BinOp::new(op_ident.name.into_token(), lhs, rhs, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, bin.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
pub(crate) fn get_unaryop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 1);
let cont = unaryop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let vi = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, vi));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let expr = args[0].expr.clone();
let unary = hir::UnaryOp::new(op_ident.name.into_token(), expr, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, unary.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
/// 可変依存型の変更を伝搬させる
fn propagate(&self, t: &Type, callee: &hir::Expr) -> TyCheckResult<()> {
if let Type::Subr(subr) = t {
if let Some(after) = subr.self_t().and_then(|self_t| {
if let RefMut { after, .. } = self_t {
after.as_ref()
} else {
None
}
}) {
self.reunify(callee.ref_t(), after, callee.loc())?;
}
}
Ok(())
}
fn not_callable_error(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
other: &Type,
hint: Option<String>,
) -> TyCheckErrors {
let (loc, name) = if let Some(attr_name) = attr_name {
(
Location::concat(obj, attr_name),
(obj.to_string() + &attr_name.to_string()),
)
} else {
(obj.loc(), obj.to_string())
};
TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&name,
None,
&mono("Callable"),
other,
self.get_candidates(other),
hint,
))
}
/// if `obj` has `__call__` method, then the return value is `Some(call_instance)`
///
/// e.g.
/// ```python
/// substitute_call(instance: ((?T, ?U) -> ?T), [Int, Str], []) => instance: (Int, Str) -> Int
/// substitute_call(instance: ((?T, Int) -> ?T), [Int, Nat], []) => instance: (Int, Int) -> Str
/// substitute_call(instance: ((?M(: Nat)..?N(: Nat)) -> ?M+?N), [1..2], []) => instance: (1..2) -> {3}
/// substitute_call(instance: ((?L(: Add(?R, ?O)), ?R) -> ?O), [1, 2], []) => instance: (Nat, Nat) -> Nat
/// substitute_call(instance: ((Failure, ?T) -> ?T), [Int, Int]) => instance: (Failure, Int) -> Int
/// ```
fn substitute_call(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
instance: &Type,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<Option<Type>> {
match instance {
Type::FreeVar(fv) if fv.is_linked() => {
self.substitute_call(obj, attr_name, &fv.crack(), pos_args, kw_args)
}
Type::FreeVar(fv) => {
if let Some(sub) = fv.get_sub() {
if !self.subtype_of(&sub, &mono("GenericCallable")) {
return Err(self.not_callable_error(obj, attr_name, instance, None));
}
}
if let Some(attr_name) = attr_name {
feature_error!(TyCheckErrors, TyCheckError, self, attr_name.loc(), "")
} else {
let is_procedural = obj
.show_acc()
.map(|acc| acc.ends_with('!'))
.unwrap_or(false);
let kind = if is_procedural {
SubrKind::Proc
} else {
SubrKind::Func
};
let ret_t = free_var(self.level, Constraint::new_type_of(Type));
let non_default_params = pos_args.iter().map(|a| anon(a.expr.t())).collect();
let subr_t = subr_t(kind, non_default_params, None, vec![], ret_t);
fv.link(&subr_t);
Ok(None)
}
}
Type::Refinement(refine) => {
self.substitute_call(obj, attr_name, &refine.t, pos_args, kw_args)
}
Type::Subr(subr) => {
let mut errs = TyCheckErrors::empty();
let is_method = subr.self_t().is_some();
let callee = if let Some(ident) = attr_name {
if is_method {
obj.clone()
} else {
let attr = hir::Attribute::new(
obj.clone(),
hir::Identifier::bare(ident.dot.clone(), ident.name.clone()),
);
hir::Expr::Accessor(hir::Accessor::Attr(attr))
}
} else {
obj.clone()
};
let params_len = subr.non_default_params.len() + subr.default_params.len();
if (params_len < pos_args.len() || params_len < pos_args.len() + kw_args.len())
&& subr.var_params.is_none()
{
return Err(self.gen_too_many_args_error(&callee, subr, pos_args, kw_args));
}
let mut passed_params = set! {};
let non_default_params = if is_method {
let mut non_default_params = subr.non_default_params.iter();
let self_pt = non_default_params.next().unwrap();
if let Err(mut es) =
self.sub_unify(obj.ref_t(), self_pt.typ(), obj.loc(), self_pt.name())
{
errs.append(&mut es);
}
non_default_params
} else {
subr.non_default_params.iter()
};
let non_default_params_len = non_default_params.len();
let mut nth = 1;
if pos_args.len() >= non_default_params_len {
let (non_default_args, var_args) = pos_args.split_at(non_default_params_len);
for (nd_arg, nd_param) in non_default_args.iter().zip(non_default_params) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&nd_arg.expr,
nth,
nd_param,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
if let Some(var_param) = subr.var_params.as_ref() {
for var_arg in var_args.iter() {
if let Err(mut es) = self.substitute_var_arg(
&callee,
attr_name,
&var_arg.expr,
nth,
var_param,
) {
errs.append(&mut es);
}
nth += 1;
}
} else {
for (arg, pt) in var_args.iter().zip(subr.default_params.iter()) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&arg.expr,
nth,
pt,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for not_passed in subr
.default_params
.iter()
.filter(|pt| !passed_params.contains(pt.name().unwrap()))
{
if let ParamTy::KwWithDefault { ty, default, .. } = ¬_passed {
if let Err(mut es) =
self.sub_unify(default, ty, obj.loc(), not_passed.name())
{
errs.append(&mut es);
}
}
}
} else {
// pos_args.len() < non_default_params_len
let mut params = non_default_params.chain(subr.default_params.iter());
for pos_arg in pos_args.iter() {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&pos_arg.expr,
nth,
params.next().unwrap(),
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
let missing_params = subr
.non_default_params
.iter()
.map(|pt| pt.name().cloned().unwrap_or(Str::ever("_")))
.filter(|pt| !passed_params.contains(pt))
.collect::<Vec<_>>();
if !missing_params.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
missing_params,
)));
}
}
if errs.is_empty() {
Ok(None)
} else {
Err(errs)
}
}
other => {
if let Ok(typ_ctx) = self.get_singular_ctx_by_hir_expr(obj, &self.name) {
if let Some(call_vi) = typ_ctx.get_current_scope_var("__call__") {
let mut dummy = TyVarCache::new(self.level, self);
let instance =
self.instantiate_t_inner(call_vi.t.clone(), &mut dummy, obj.loc())?;
self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
return Ok(Some(instance));
}
}
let hint = if other == &ClassType {
Some(switch_lang! {
"japanese" => format!("インスタンスを生成したい場合は、{}.newを使用してください", obj.to_string_notype()),
"simplified_chinese" => format!("如果要生成实例，请使用 {}.new", obj.to_string_notype()),
"traditional_chinese" => format!("如果要生成實例，請使用 {}.new", obj.to_string_notype()),
"english" => format!("If you want to generate an instance, use {}.new", obj.to_string_notype()),
})
} else {
None
};
Err(self.not_callable_error(obj, attr_name, other, hint))
}
}
}
fn gen_too_many_args_error(
&self,
callee: &hir::Expr,
subr_ty: &SubrType,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckErrors {
let mut unknown_args = vec![];
let mut passed_args: Vec<&hir::KwArg> = vec![];
let mut duplicated_args = vec![];
for kw_arg in kw_args.iter() {
if subr_ty
.non_default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
&& subr_ty
.var_params
.as_ref()
.map(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
.unwrap_or(true)
&& subr_ty
.default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
{
unknown_args.push(kw_arg);
}
if passed_args.iter().any(|a| a.keyword == kw_arg.keyword) {
duplicated_args.push(kw_arg);
} else {
passed_args.push(kw_arg);
}
}
if unknown_args.is_empty() && duplicated_args.is_empty() {
let params_len = subr_ty.non_default_params.len() + subr_ty.default_params.len();
TyCheckErrors::from(TyCheckError::too_many_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
params_len,
pos_args.len(),
kw_args.len(),
))
} else {
let unknown_arg_errors = unknown_args.into_iter().map(|arg| {
TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
let duplicated_arg_errors = duplicated_args.into_iter().map(|arg| {
TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
unknown_arg_errors.chain(duplicated_arg_errors).collect()
}
}
fn substitute_pos_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
if let Some(name) = param.name() {
if passed_params.contains(name) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
name,
)));
} else {
passed_params.insert(name.clone());
}
}
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
let mut hint = Self::get_call_type_mismatch_hint(
callee.ref_t(),
attr_name.as_ref().map(|i| &i.inspect()[..]),
nth,
param_t,
arg_t,
);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
std::mem::take(&mut hint),
)
})
.collect(),
)
})?;
Ok(())
}
fn substitute_var_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
)
})
}
fn substitute_kw_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::KwArg,
nth: usize,
subr_ty: &SubrType,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.expr.ref_t();
let kw_name = arg.keyword.inspect();
if passed_params.contains(&kw_name[..]) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)));
}
if let Some(pt) = subr_ty
.non_default_params
.iter()
.chain(subr_ty.default_params.iter())
.find(|pt| pt.name().as_ref() == Some(&kw_name))
{
passed_params.insert(kw_name.clone());
self.sub_unify(arg_t, pt.typ(), arg.loc(), Some(kw_name))
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {}", pt.typ());
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + readable_name(kw_name);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
pt.typ(),
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(pt.typ(), arg_t),
)
})
.collect(),
)
})?;
} else {
return Err(TyCheckErrors::from(TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.keyword.loc(),
&callee.to_string(),
self.caused_by(),
kw_name,
)));
}
Ok(())
}
pub(crate) fn get_call_t(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
if let hir::Expr::Accessor(hir::Accessor::Ident(local)) = obj {
if local.vis().is_private() {
match &local.inspect()[..] {
"match" => {
return self.get_match_call_t(SubrKind::Func, pos_args, kw_args);
}
"match!" => {
return self.get_match_call_t(SubrKind::Proc, pos_args, kw_args);
}
_ => {}
}
}
}
let found = self.search_callee_info(obj, attr_name, input, namespace)?;
log!(
"Found:\ncallee: {obj}{}\nfound: {found}",
fmt_option!(pre ".", attr_name.as_ref().map(|ident| &ident.name))
);
let instance = self.instantiate(found.t, obj)?;
log!(
"Instantiated:\ninstance: {instance}\npos_args: ({})\nkw_args: ({})",
fmt_slice(pos_args),
fmt_slice(kw_args)
);
let res = self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
let instance = if let Some(__call__) = res {
__call__
} else {
instance
};
log!(info "Substituted:\ninstance: {instance}");
let res = self.eval_t_params(instance, self.level, obj.loc())?;
log!(info "Params evaluated:\nres: {res}\n");
self.propagate(&res, obj)?;
log!(info "Propagated:\nres: {res}\n");
let res = VarInfo { t: res, ..found };
Ok(res)
}
pub(crate) fn get_const_local(
&self,
name: &Token,
namespace: &Str,
) -> SingleTyCheckResult<ValueObj> {
if let Some(obj) = self.consts.get(name.inspect()) {
Ok(obj.clone())
} else {
/*if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
return parent.get_const_local(name, namespace);
}*/
Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
name.inspect(),
self.get_similar_name(name.inspect()),
))
}
}
pub(crate) fn _get_const_attr(
&self,
obj: &hir::Expr,
name: &Token,
namespace: &Str,
) -> SingleTyCheckResult<ValueObj> {
let self_t = obj.ref_t();
for ctx in self.get_nominal_super_type_ctxs(self_t).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
self_t,
)
})? {
if let Ok(t) = ctx.get_const_local(name, namespace) {
return Ok(t);
}
}
// TODO: dependent type widening
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
parent._get_const_attr(obj, name, namespace)
} else {
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
self_t,
name.inspect(),
self.get_similar_attr(self_t, name.inspect()),
))
}
}context/eval.rs (lines 955-961)
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
pub(crate) fn eval_proj(
&self,
lhs: Type,
rhs: Str,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
// Currently Erg does not allow projection-types to be evaluated with type variables included.
// All type variables will be dereferenced or fail.
let (sub, opt_sup) = match lhs.clone() {
Type::FreeVar(fv) if fv.is_linked() => {
return self.eval_t_params(proj(fv.crack().clone(), rhs), level, t_loc)
}
Type::FreeVar(fv) if fv.is_unbound() => {
let (sub, sup) = fv.get_subsup().unwrap();
(sub, Some(sup))
}
other => (other, None),
};
// cannot determine at this point
if sub == Type::Never {
return Ok(proj(lhs, rhs));
}
// in Methods
if self.name == sub.qual_name() {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, self, level, t_loc)
{
return Ok(t);
}
}
for ty_ctx in self.get_nominal_super_type_ctxs(&sub).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&sub,
)
})? {
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, ty_ctx, level, t_loc)
{
return Ok(t);
}
for (class, methods) in ty_ctx.methods_list.iter() {
match (&class, &opt_sup) {
(ClassDefType::ImplTrait { impl_trait, .. }, Some(sup)) => {
if !self.supertype_of(impl_trait, sup) {
continue;
}
}
(ClassDefType::ImplTrait { impl_trait, .. }, None) => {
if !self.supertype_of(impl_trait, &sub) {
continue;
}
}
_ => {}
}
if let Some(t) =
self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, methods, level, t_loc)
{
return Ok(t);
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, Type::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tyvar(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj(coerced, rhs);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce(&lhs);
t
})
} else {
let proj = proj(lhs, rhs);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}
pub(crate) fn convert_tp_into_ty(&self, tp: TyParam) -> Result<Type, ()> {
match tp {
TyParam::Array(tps) => {
let len = tps.len();
let mut t = Type::Never;
for elem_tp in tps {
let elem_t = self.convert_tp_into_ty(elem_tp)?;
// not union
t = self.union(&t, &elem_t);
}
Ok(array_t(t, TyParam::value(len)))
}
TyParam::FreeVar(fv) if fv.is_linked() => self.convert_tp_into_ty(fv.crack().clone()),
TyParam::Type(t) => Ok(t.as_ref().clone()),
TyParam::Value(v) => Type::try_from(v),
// TODO: Array, Dict, Set
_ => Err(()),
}
}
fn _convert_type_to_dict_type(&self, ty: Type) -> Result<Dict<Type, Type>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Dict" => {
let dict = Dict::try_from(params[0].clone())?;
let mut new_dict = dict! {};
for (k, v) in dict.into_iter() {
let k = self.convert_tp_into_ty(k)?;
let v = self.convert_tp_into_ty(v)?;
new_dict.insert(k, v);
}
Ok(new_dict)
}
_ => Err(()),
}
}
fn convert_type_to_array(&self, ty: Type) -> Result<Vec<ValueObj>, ()> {
match ty {
Type::Poly { name, params } if &name[..] == "Array" || &name[..] == "Array!" => {
let t = self.convert_tp_into_ty(params[0].clone())?;
let len = enum_unwrap!(params[1], TyParam::Value:(ValueObj::Nat:(_)));
Ok(vec![ValueObj::builtin_t(t); len as usize])
}
_ => Err(()),
}
}
pub(crate) fn convert_value_into_array(&self, val: ValueObj) -> Result<Vec<ValueObj>, ()> {
match val {
ValueObj::Array(arr) => Ok(arr.to_vec()),
ValueObj::Type(t) => self.convert_type_to_array(t.into_typ()),
_ => Err(()),
}
}
fn validate_and_project(
&self,
sub: &Type,
opt_sup: Option<&Type>,
rhs: &str,
methods: &Context,
level: usize,
t_loc: Location,
) -> Option<Type> {
// e.g. sub: Int, opt_sup: Add(?T), rhs: Output, methods: Int.methods
// sub: [Int; 4], opt_sup: Add([Int; 2]), rhs: Output, methods: [T; N].methods
if let Ok(obj) = methods.get_const_local(&Token::symbol(rhs), &self.name) {
#[allow(clippy::single_match)]
// opt_sup: Add(?T), methods.impl_of(): Add(Int)
// opt_sup: Add([Int; 2]), methods.impl_of(): Add([T; M])
match (&opt_sup, methods.impl_of()) {
(Some(sup), Some(trait_)) => {
if !self.supertype_of(&trait_, sup) {
return None;
}
}
_ => {}
}
// obj: Int|<: Add(Int)|.Output == ValueObj::Type(<type Int>)
// obj: [T; N]|<: Add([T; M])|.Output == ValueObj::Type(<type [T; M+N]>)
if let ValueObj::Type(quant_projected_t) = obj {
let projected_t = quant_projected_t.into_typ();
let (quant_sub, _) = self.rec_get_type(&sub.local_name()).unwrap();
if let Some(sup) = opt_sup {
if let Some(quant_sup) = methods.impl_of() {
// T -> Int, M -> 2
self.substitute_typarams(&quant_sup, sup);
}
}
// T -> Int, N -> 4
self.substitute_typarams(quant_sub, sub);
// [T; M+N] -> [Int; 4+2] -> [Int; 6]
let res = self.eval_t_params(projected_t, level, t_loc).ok();
if let Some(t) = res {
let mut tv_cache = TyVarCache::new(self.level, self);
let t = self.detach(t, &mut tv_cache);
// Int -> T, 2 -> M, 4 -> N
self.undo_substitute_typarams(quant_sub);
if let Some(quant_sup) = methods.impl_of() {
self.undo_substitute_typarams(&quant_sup);
}
return Some(t);
}
} else {
todo!()
}
}
None
}
/// e.g.
/// F((Int), 3) => F(Int, 3)
/// F(?T, ?T) => F(?1, ?1)
fn detach(&self, ty: Type, tv_cache: &mut TyVarCache) -> Type {
match ty {
Type::FreeVar(fv) if fv.is_linked() => self.detach(fv.crack().clone(), tv_cache),
Type::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(t) = tv_cache.get_tyvar(&name) {
t.clone()
} else {
let tv = Type::FreeVar(new_fv);
tv_cache.push_or_init_tyvar(&name, &tv);
tv
}
}
Type::Poly { name, params } => {
let mut new_params = vec![];
for param in params {
new_params.push(self.detach_tp(param, tv_cache));
}
poly(name, new_params)
}
_ => ty,
}
}
fn detach_tp(&self, tp: TyParam, tv_cache: &mut TyVarCache) -> TyParam {
match tp {
TyParam::FreeVar(fv) if fv.is_linked() => self.detach_tp(fv.crack().clone(), tv_cache),
TyParam::FreeVar(fv) => {
let new_fv = fv.detach();
let name = new_fv.unbound_name().unwrap();
if let Some(tp) = tv_cache.get_typaram(&name) {
tp.clone()
} else {
let tp = TyParam::FreeVar(new_fv);
tv_cache.push_or_init_typaram(&name, &tp);
tp
}
}
TyParam::Type(t) => TyParam::t(self.detach(*t, tv_cache)),
_ => tp,
}
}
#[allow(clippy::only_used_in_recursion)]
/// e.g. qt: Array(T, N), st: Array(Int, 3)
pub(crate) fn substitute_typarams(&self, qt: &Type, st: &Type) {
let qtps = qt.typarams();
let stps = st.typarams();
if qtps.len() != stps.len() {
log!(err "{} {}", erg_common::fmt_vec(&qtps), erg_common::fmt_vec(&stps));
return; // TODO: e.g. Sub(Int) / Eq and Sub(?T)
}
for (qtp, stp) in qtps.into_iter().zip(stps.into_iter()) {
match qtp {
TyParam::FreeVar(fv) if fv.is_generalized() => {
if !stp.is_generalized() {
fv.undoable_link(&stp);
}
}
TyParam::Type(t) if t.is_generalized() => {
let qt = enum_unwrap!(t.as_ref(), Type::FreeVar);
let st = enum_unwrap!(stp, TyParam::Type);
if !st.is_generalized() {
qt.undoable_link(&st);
}
}
TyParam::Type(qt) => {
let st = enum_unwrap!(stp, TyParam::Type);
let st = if st.typarams_len() != qt.typarams_len() {
let st = enum_unwrap!(*st, Type::FreeVar);
st.get_sub().unwrap()
} else {
*st
};
if !st.is_generalized() {
self.substitute_typarams(&qt, &st);
}
self.sub_unify(&st, &qt, Location::Unknown, None).unwrap();
}
_ => {}
}
}
}
#[allow(clippy::only_used_in_recursion)]
pub(crate) fn undo_substitute_typarams(&self, substituted: &Type) {
for tp in substituted.typarams().into_iter() {
match tp {
TyParam::FreeVar(fv) if fv.is_undoable_linked() => fv.undo(),
TyParam::Type(t) if t.is_free_var() => {
let subst = enum_unwrap!(t.as_ref(), Type::FreeVar);
if subst.is_undoable_linked() {
subst.undo();
}
}
TyParam::Type(t) => {
self.undo_substitute_typarams(&t);
}
_ => {}
}
}
}
pub(crate) fn eval_proj_call(
&self,
lhs: TyParam,
attr_name: Str,
args: Vec<TyParam>,
level: usize,
t_loc: Location,
) -> EvalResult<Type> {
let t = self.get_tp_t(&lhs)?;
for ty_ctx in self.get_nominal_super_type_ctxs(&t).ok_or_else(|| {
EvalError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
t_loc,
self.caused_by(),
&t,
)
})? {
if let Ok(obj) = ty_ctx.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let is_method = subr.sig_t().self_t().is_some();
let mut pos_args = vec![];
if is_method {
match ValueObj::try_from(lhs) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
for (_class, methods) in ty_ctx.methods_list.iter() {
if let Ok(obj) = methods.get_const_local(&Token::symbol(&attr_name), &self.name) {
if let ValueObj::Subr(subr) = obj {
let mut pos_args = vec![];
for pos_arg in args.into_iter() {
match ValueObj::try_from(pos_arg) {
Ok(value) => {
pos_args.push(value);
}
Err(_) => {
return feature_error!(self, t_loc, "??");
}
}
}
let args = ValueArgs::new(pos_args, dict! {});
let t = self.call(subr, args, t_loc)?;
let t = enum_unwrap!(t, ValueObj::Type); // TODO: error handling
return Ok(t.into_typ());
} else {
return feature_error!(self, t_loc, "??");
}
}
}
}
if lhs.is_unbound_var() {
let (sub, sup) = enum_unwrap!(&lhs, TyParam::FreeVar).get_subsup().unwrap();
if self.is_trait(&sup) && !self.trait_impl_exists(&sub, &sup) {
return Err(EvalErrors::from(EvalError::no_trait_impl_error(
self.cfg.input.clone(),
line!() as usize,
&sub,
&sup,
t_loc,
self.caused_by(),
None,
)));
}
}
// if the target can't be found in the supertype, the type will be dereferenced.
// In many cases, it is still better to determine the type variable than if the target is not found.
let coerced = self.deref_tp(lhs.clone(), Variance::Covariant, t_loc)?;
if lhs != coerced {
let proj = proj_call(coerced, attr_name, args);
self.eval_t_params(proj, level, t_loc).map(|t| {
self.coerce_tp(&lhs);
t
})
} else {
let proj = proj_call(lhs, attr_name, args);
Err(EvalErrors::from(EvalError::no_candidate_error(
self.cfg.input.clone(),
line!() as usize,
&proj,
t_loc,
self.caused_by(),
Self::get_no_candidate_hint(&proj),
)))
}
}lower.rs (lines 1350-1356)
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
fn lower_class_def(&mut self, class_def: ast::ClassDef) -> LowerResult<hir::ClassDef> {
log!(info "entered {}({class_def})", fn_name!());
let mut hir_def = self.lower_def(class_def.def)?;
let mut hir_methods = hir::Block::empty();
let mut dummy_tv_cache = TyVarCache::new(self.ctx.level, &self.ctx);
for mut methods in class_def.methods_list.into_iter() {
let (class, impl_trait) = match &methods.class {
ast::TypeSpec::TypeApp { spec, args } => {
let (impl_trait, loc) = match &args.args.pos_args().first().unwrap().expr {
// TODO: check `tasc.op`
ast::Expr::TypeAsc(tasc) => (
self.ctx.instantiate_typespec(
&tasc.t_spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
tasc.t_spec.loc(),
),
_ => return unreachable_error!(LowerErrors, LowerError, self),
};
(
self.ctx.instantiate_typespec(
spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
Some((impl_trait, loc)),
)
}
other => (
self.ctx.instantiate_typespec(
other,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?,
None,
),
};
// assume the class has implemented the trait, regardless of whether the implementation is correct
if let Some((trait_, trait_loc)) = &impl_trait {
self.register_trait_impl(&class, trait_, *trait_loc)?;
}
if let Some((_, class_root)) = self.ctx.get_nominal_type_ctx(&class) {
if !class_root.kind.is_class() {
return Err(LowerErrors::from(LowerError::method_definition_error(
self.cfg.input.clone(),
line!() as usize,
methods.loc(),
self.ctx.caused_by(),
&class.qual_name(),
None,
)));
}
} else {
return Err(LowerErrors::from(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
methods.class.loc(),
self.ctx.caused_by(),
&class.qual_name(),
self.ctx.get_similar_name(&class.local_name()),
)));
}
let kind = ContextKind::MethodDefs(impl_trait.as_ref().map(|(t, _)| t.clone()));
let vis = if self.cfg.python_compatible_mode {
Public
} else {
Private
};
self.ctx.grow(&class.local_name(), kind, vis, None);
for attr in methods.attrs.iter_mut() {
match attr {
ast::ClassAttr::Def(def) => {
if methods.vis.is(TokenKind::Dot) {
def.sig.ident_mut().unwrap().dot = Some(Token::new(
TokenKind::Dot,
".",
def.sig.ln_begin().unwrap_or(0),
def.sig.col_begin().unwrap_or(0),
));
}
self.ctx.preregister_def(def).map_err(|errs| {
self.pop_append_errs();
errs
})?;
}
ast::ClassAttr::Decl(_decl) => {}
}
}
for attr in methods.attrs.into_iter() {
match attr {
ast::ClassAttr::Def(def) => match self.lower_def(def) {
Ok(def) => {
hir_methods.push(hir::Expr::Def(def));
}
Err(errs) => {
self.errs.extend(errs);
}
},
ast::ClassAttr::Decl(decl) => {
let decl = self.lower_type_asc(decl)?;
hir_methods.push(hir::Expr::TypeAsc(decl));
}
}
}
if let Err(mut errs) = self.ctx.check_decls() {
self.errs.append(&mut errs);
}
if let Some((trait_, _)) = &impl_trait {
self.check_override(&class, Some(trait_));
} else {
self.check_override(&class, None);
}
if let Err(err) = self.check_trait_impl(impl_trait, &class) {
self.errs.push(err);
}
self.check_collision_and_push(class);
}
let class = mono(hir_def.sig.ident().inspect());
let Some((_, class_ctx)) = self.ctx.get_nominal_type_ctx(&class) else {
return Err(LowerErrors::from(LowerError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
hir_def.sig.loc(),
self.ctx.caused_by(),
&class,
)));
};
let type_obj = enum_unwrap!(self.ctx.rec_get_const_obj(hir_def.sig.ident().inspect()).unwrap(), ValueObj::Type:(TypeObj::Generated:(_)));
let sup_type = enum_unwrap!(&hir_def.body.block.first().unwrap(), hir::Expr::Call)
.args
.get_left_or_key("Super")
.unwrap();
Self::check_inheritable(&self.cfg, &mut self.errs, type_obj, sup_type, &hir_def.sig);
// vi.t.non_default_params().unwrap()[0].typ().clone()
let (__new__, need_to_gen_new) = if let (Some(dunder_new_vi), Some(new_vi)) = (
class_ctx.get_current_scope_var("__new__"),
class_ctx.get_current_scope_var("new"),
) {
(dunder_new_vi.t.clone(), new_vi.kind == VarKind::Auto)
} else {
return unreachable_error!(LowerErrors, LowerError, self);
};
let require_or_sup = self.get_require_or_sup_or_base(hir_def.body.block.remove(0));
Ok(hir::ClassDef::new(
type_obj.clone(),
hir_def.sig,
require_or_sup,
need_to_gen_new,
__new__,
hir_methods,
))
}
fn lower_patch_def(&mut self, class_def: ast::PatchDef) -> LowerResult<hir::PatchDef> {
log!(info "entered {}({class_def})", fn_name!());
let base_t = {
let base_t_expr =
enum_unwrap!(class_def.def.body.block.get(0).unwrap(), ast::Expr::Call)
.args
.get_left_or_key("Base")
.unwrap();
let spec = Parser::expr_to_type_spec(base_t_expr.clone()).unwrap();
let mut dummy_tv_cache = TyVarCache::new(self.ctx.level, &self.ctx);
self.ctx.instantiate_typespec(
&spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?
};
let mut hir_def = self.lower_def(class_def.def)?;
let base = self.get_require_or_sup_or_base(hir_def.body.block.remove(0));
let mut hir_methods = hir::Block::empty();
for mut methods in class_def.methods_list.into_iter() {
let kind = ContextKind::PatchMethodDefs(base_t.clone());
self.ctx
.grow(hir_def.sig.ident().inspect(), kind, hir_def.sig.vis(), None);
for attr in methods.attrs.iter_mut() {
match attr {
ast::ClassAttr::Def(def) => {
if methods.vis.is(TokenKind::Dot) {
def.sig.ident_mut().unwrap().dot = Some(Token::new(
TokenKind::Dot,
".",
def.sig.ln_begin().unwrap(),
def.sig.col_begin().unwrap(),
));
}
self.ctx.preregister_def(def).map_err(|errs| {
self.pop_append_errs();
errs
})?;
}
ast::ClassAttr::Decl(_decl) => {}
}
}
for attr in methods.attrs.into_iter() {
match attr {
ast::ClassAttr::Def(def) => match self.lower_def(def) {
Ok(def) => {
hir_methods.push(hir::Expr::Def(def));
}
Err(errs) => {
self.errs.extend(errs);
}
},
ast::ClassAttr::Decl(decl) => {
let decl = self.lower_type_asc(decl)?;
hir_methods.push(hir::Expr::TypeAsc(decl));
}
}
}
if let Err(mut errs) = self.ctx.check_decls() {
self.errs.append(&mut errs);
}
self.push_patch();
}
Ok(hir::PatchDef::new(hir_def.sig, base, hir_methods))
}
fn lower_attr_def(&mut self, attr_def: ast::AttrDef) -> LowerResult<hir::AttrDef> {
log!(info "entered {}({attr_def})", fn_name!());
let attr = self.lower_acc(attr_def.attr)?;
let expr = self.lower_expr(*attr_def.expr)?;
if let Err(err) = self.var_result_t_check(
attr.loc(),
&Str::from(attr.show()),
attr.ref_t(),
expr.ref_t(),
) {
self.errs.push(err);
}
Ok(hir::AttrDef::new(attr, hir::Block::new(vec![expr])))
}
fn register_trait_impl(
&mut self,
class: &Type,
trait_: &Type,
trait_loc: Location,
) -> LowerResult<()> {
// TODO: polymorphic trait
if let Some(impls) = self.ctx.trait_impls.get_mut(&trait_.qual_name()) {
impls.insert(TypeRelationInstance::new(class.clone(), trait_.clone()));
} else {
self.ctx.trait_impls.insert(
trait_.qual_name(),
set! {TypeRelationInstance::new(class.clone(), trait_.clone())},
);
}
let trait_ctx = if let Some((_, trait_ctx)) = self.ctx.get_nominal_type_ctx(trait_) {
trait_ctx.clone()
} else {
// TODO: maybe parameters are wrong
return Err(LowerErrors::from(LowerError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
trait_loc,
self.ctx.caused_by(),
&trait_.local_name(),
None,
)));
};
let Some((_, class_ctx)) = self.ctx.get_mut_nominal_type_ctx(class) else {
return Err(LowerErrors::from(LowerError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
trait_loc,
self.ctx.caused_by(),
class,
)));
};
class_ctx.register_supertrait(trait_.clone(), &trait_ctx);
Ok(())
}sourcepub fn no_attr_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
obj_t: &Type,
name: &str,
similar_name: Option<&str>
) -> Self
pub fn no_attr_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
obj_t: &Type,
name: &str,
similar_name: Option<&str>
) -> Self
Examples found in repository?
context/eval.rs (lines 177-185)
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
fn eval_attr(&self, obj: ValueObj, ident: &Identifier) -> SingleEvalResult<ValueObj> {
if let Some(val) = obj.try_get_attr(&Field::from(ident)) {
return Ok(val);
}
if let ValueObj::Type(t) = &obj {
if let Some(sups) = self.get_nominal_super_type_ctxs(t.typ()) {
for ctx in sups {
if let Some(val) = ctx.consts.get(ident.inspect()) {
return Ok(val.clone());
}
for (_, methods) in ctx.methods_list.iter() {
if let Some(v) = methods.consts.get(ident.inspect()) {
return Ok(v.clone());
}
}
}
}
}
Err(EvalError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
&obj.t(),
ident.inspect(),
None,
))
}More examples
context/inquire.rs (lines 503-511)
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
pub(crate) fn rec_get_attr_info(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
let name = ident.name.token();
match self.get_attr_info_from_attributive(&self_t, ident, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
match singular_ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
match self.get_attr_from_nominal_t(obj, ident, input, namespace) {
Ok(vi) => {
return Ok(vi);
}
Err(e) if e.core.kind == ErrorKind::DummyError => {}
Err(e) => {
return Err(e);
}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(ident.inspect())
.or_else(|| patch.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(ident.inspect())
.or_else(|| methods_ctx.decls.get(ident.inspect()))
{
self.validate_visibility(ident, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
// TODO: dependent type widening
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
parent.rec_get_attr_info(obj, ident, input, namespace)
} else {
Err(TyCheckError::no_attr_error(
input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
&self_t,
name.inspect(),
self.get_similar_attr(&self_t, name.inspect()),
))
}
}
fn get_attr_from_nominal_t(
&self,
obj: &hir::Expr,
ident: &Identifier,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
let self_t = obj.t();
if let Some(sups) = self.get_nominal_super_type_ctxs(&self_t) {
for ctx in sups {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
let coerced = self
.deref_tyvar(obj.t(), Variance::Covariant, Location::Unknown)
.map_err(|mut es| es.remove(0))?;
if obj.ref_t() != &coerced {
for ctx in self.get_nominal_super_type_ctxs(&coerced).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
&coerced,
)
})? {
match ctx.rec_get_var_info(ident, AccessKind::Attr, input, namespace) {
Ok(t) => {
self.coerce(obj.ref_t());
return Ok(t);
}
Err(e) if e.core.kind == ErrorKind::NameError => {}
Err(e) => {
return Err(e);
}
}
}
}
Err(TyCheckError::dummy(input.clone(), line!() as usize))
}
/// get type from given attributive type (Record).
/// not ModuleType or ClassType etc.
fn get_attr_info_from_attributive(
&self,
t: &Type,
ident: &Identifier,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
match t {
// (obj: Never).foo: Never
Type::Never => Ok(VarInfo::ILLEGAL.clone()),
Type::FreeVar(fv) if fv.is_linked() => {
self.get_attr_info_from_attributive(&fv.crack(), ident, namespace)
}
Type::FreeVar(fv) /* if fv.is_unbound() */ => {
let sup = fv.get_super().unwrap();
self.get_attr_info_from_attributive(&sup, ident, namespace)
}
Type::Ref(t) => self.get_attr_info_from_attributive(t, ident, namespace),
Type::RefMut { before, .. } => {
self.get_attr_info_from_attributive(before, ident, namespace)
}
Type::Refinement(refine) => {
self.get_attr_info_from_attributive(&refine.t, ident, namespace)
}
Type::Record(record) => {
if let Some(attr_t) = record.get(ident.inspect()) {
let muty = Mutability::from(&ident.inspect()[..]);
let vi = VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
);
Ok(vi)
} else {
let t = Type::Record(record.clone());
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
namespace.into(),
&t,
ident.inspect(),
self.get_similar_attr(&t, ident.inspect()),
))
}
}
other => {
if let Some(v) = self.rec_get_const_obj(&other.local_name()) {
match v {
ValueObj::Type(TypeObj::Generated(gen)) => self
.get_gen_t_require_attr_t(gen, &ident.inspect()[..])
.map(|attr_t| {
let muty = Mutability::from(&ident.inspect()[..]);
VarInfo::new(
attr_t.clone(),
muty,
Public,
VarKind::Builtin,
None,
None,
None,
)
})
.ok_or_else(|| {
TyCheckError::dummy(self.cfg.input.clone(), line!() as usize)
}),
ValueObj::Type(TypeObj::Builtin(_t)) => {
// FIXME:
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
_other => Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
)),
}
} else {
Err(TyCheckError::dummy(
self.cfg.input.clone(),
line!() as usize,
))
}
}
}
}
// returns callee's type, not the return type
fn search_callee_info(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if obj.ref_t() == Type::FAILURE {
// (...Obj) -> Failure
return Ok(VarInfo {
t: Type::Subr(SubrType::new(
SubrKind::Func,
vec![],
Some(ParamTy::pos(None, ref_(Obj))),
vec![],
Failure,
)),
..VarInfo::default()
});
}
if let Some(attr_name) = attr_name.as_ref() {
for ctx in self
.get_nominal_super_type_ctxs(obj.ref_t())
.ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
obj.ref_t(),
)
})?
{
if let Some(vi) = ctx
.locals
.get(attr_name.inspect())
.or_else(|| ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in ctx.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
if let Some(vi) = singular_ctx
.locals
.get(attr_name.inspect())
.or_else(|| singular_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, method_ctx) in singular_ctx.methods_list.iter() {
if let Some(vi) = method_ctx
.locals
.get(attr_name.inspect())
.or_else(|| method_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
return Err(TyCheckError::singular_no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.qual_name().unwrap_or("?"),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr_from_singular(obj, attr_name.inspect()),
));
}
match self.get_method_type_by_name(attr_name) {
Ok(method) => {
self.sub_unify(obj.ref_t(), &method.definition_type, obj.loc(), None)
// HACK: change this func's return type to TyCheckResult<Type>
.map_err(|mut errs| errs.remove(0))?;
return Ok(method.method_type.clone());
}
Err(err) if err.core.kind == ErrorKind::TypeError => {
return Err(err);
}
_ => {}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(attr_name.inspect())
.or_else(|| patch.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr(obj.ref_t(), attr_name.inspect()),
))
} else {
Ok(VarInfo {
t: obj.t(),
..VarInfo::default()
})
}
}
fn validate_visibility(
&self,
ident: &Identifier,
vi: &VarInfo,
input: &Input,
namespace: &str,
) -> SingleTyCheckResult<()> {
if ident.vis() != vi.vis {
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
vi.vis,
))
// check if the private variable is loaded from the other scope
} else if vi.vis.is_private()
&& &self.name[..] != "<builtins>"
&& &self.name[..] != namespace
&& !namespace.contains(&self.name[..])
{
log!(err "{namespace}/{}", self.name);
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
Private,
))
} else {
Ok(())
}
}
// HACK: dname.loc()はダミーLocationしか返さないので、エラーならop.loc()で上書きする
fn append_loc_info(&self, e: TyCheckError, loc: Location) -> TyCheckError {
if e.core.loc == Location::Unknown {
let mut sub_msges = Vec::new();
for sub_msg in e.core.sub_messages {
sub_msges.push(SubMessage::ambiguous_new(loc, sub_msg.msg, sub_msg.hint));
}
let core = ErrorCore::new(
sub_msges,
e.core.main_message,
e.core.errno,
e.core.kind,
e.core.loc,
);
TyCheckError::new(core, self.cfg.input.clone(), e.caused_by)
} else {
e
}
}
pub(crate) fn get_binop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 2);
let cont = binop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let t = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, t));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let lhs = args[0].expr.clone();
let rhs = args[1].expr.clone();
let bin = hir::BinOp::new(op_ident.name.into_token(), lhs, rhs, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, bin.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
pub(crate) fn get_unaryop_t(
&self,
op: &Token,
args: &[hir::PosArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
erg_common::debug_power_assert!(args.len() == 1);
let cont = unaryop_to_dname(op.inspect());
let symbol = Token::from_str(op.kind, cont);
let vi = self.rec_get_var_info(
&Identifier::new(None, VarName::new(symbol.clone())),
AccessKind::Name,
input,
namespace,
)?;
let op = hir::Expr::Accessor(hir::Accessor::private(symbol, vi));
self.get_call_t(&op, &None, args, &[], input, namespace)
.map_err(|errs| {
let op_ident = enum_unwrap!(op, hir::Expr::Accessor:(hir::Accessor::Ident:(_)));
let vi = op_ident.vi.clone();
let expr = args[0].expr.clone();
let unary = hir::UnaryOp::new(op_ident.name.into_token(), expr, vi);
let errs = errs
.into_iter()
.map(|e| self.append_loc_info(e, unary.loc()))
.collect();
TyCheckErrors::new(errs)
})
}
/// 可変依存型の変更を伝搬させる
fn propagate(&self, t: &Type, callee: &hir::Expr) -> TyCheckResult<()> {
if let Type::Subr(subr) = t {
if let Some(after) = subr.self_t().and_then(|self_t| {
if let RefMut { after, .. } = self_t {
after.as_ref()
} else {
None
}
}) {
self.reunify(callee.ref_t(), after, callee.loc())?;
}
}
Ok(())
}
fn not_callable_error(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
other: &Type,
hint: Option<String>,
) -> TyCheckErrors {
let (loc, name) = if let Some(attr_name) = attr_name {
(
Location::concat(obj, attr_name),
(obj.to_string() + &attr_name.to_string()),
)
} else {
(obj.loc(), obj.to_string())
};
TyCheckErrors::from(TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
loc,
self.caused_by(),
&name,
None,
&mono("Callable"),
other,
self.get_candidates(other),
hint,
))
}
/// if `obj` has `__call__` method, then the return value is `Some(call_instance)`
///
/// e.g.
/// ```python
/// substitute_call(instance: ((?T, ?U) -> ?T), [Int, Str], []) => instance: (Int, Str) -> Int
/// substitute_call(instance: ((?T, Int) -> ?T), [Int, Nat], []) => instance: (Int, Int) -> Str
/// substitute_call(instance: ((?M(: Nat)..?N(: Nat)) -> ?M+?N), [1..2], []) => instance: (1..2) -> {3}
/// substitute_call(instance: ((?L(: Add(?R, ?O)), ?R) -> ?O), [1, 2], []) => instance: (Nat, Nat) -> Nat
/// substitute_call(instance: ((Failure, ?T) -> ?T), [Int, Int]) => instance: (Failure, Int) -> Int
/// ```
fn substitute_call(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
instance: &Type,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckResult<Option<Type>> {
match instance {
Type::FreeVar(fv) if fv.is_linked() => {
self.substitute_call(obj, attr_name, &fv.crack(), pos_args, kw_args)
}
Type::FreeVar(fv) => {
if let Some(sub) = fv.get_sub() {
if !self.subtype_of(&sub, &mono("GenericCallable")) {
return Err(self.not_callable_error(obj, attr_name, instance, None));
}
}
if let Some(attr_name) = attr_name {
feature_error!(TyCheckErrors, TyCheckError, self, attr_name.loc(), "")
} else {
let is_procedural = obj
.show_acc()
.map(|acc| acc.ends_with('!'))
.unwrap_or(false);
let kind = if is_procedural {
SubrKind::Proc
} else {
SubrKind::Func
};
let ret_t = free_var(self.level, Constraint::new_type_of(Type));
let non_default_params = pos_args.iter().map(|a| anon(a.expr.t())).collect();
let subr_t = subr_t(kind, non_default_params, None, vec![], ret_t);
fv.link(&subr_t);
Ok(None)
}
}
Type::Refinement(refine) => {
self.substitute_call(obj, attr_name, &refine.t, pos_args, kw_args)
}
Type::Subr(subr) => {
let mut errs = TyCheckErrors::empty();
let is_method = subr.self_t().is_some();
let callee = if let Some(ident) = attr_name {
if is_method {
obj.clone()
} else {
let attr = hir::Attribute::new(
obj.clone(),
hir::Identifier::bare(ident.dot.clone(), ident.name.clone()),
);
hir::Expr::Accessor(hir::Accessor::Attr(attr))
}
} else {
obj.clone()
};
let params_len = subr.non_default_params.len() + subr.default_params.len();
if (params_len < pos_args.len() || params_len < pos_args.len() + kw_args.len())
&& subr.var_params.is_none()
{
return Err(self.gen_too_many_args_error(&callee, subr, pos_args, kw_args));
}
let mut passed_params = set! {};
let non_default_params = if is_method {
let mut non_default_params = subr.non_default_params.iter();
let self_pt = non_default_params.next().unwrap();
if let Err(mut es) =
self.sub_unify(obj.ref_t(), self_pt.typ(), obj.loc(), self_pt.name())
{
errs.append(&mut es);
}
non_default_params
} else {
subr.non_default_params.iter()
};
let non_default_params_len = non_default_params.len();
let mut nth = 1;
if pos_args.len() >= non_default_params_len {
let (non_default_args, var_args) = pos_args.split_at(non_default_params_len);
for (nd_arg, nd_param) in non_default_args.iter().zip(non_default_params) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&nd_arg.expr,
nth,
nd_param,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
if let Some(var_param) = subr.var_params.as_ref() {
for var_arg in var_args.iter() {
if let Err(mut es) = self.substitute_var_arg(
&callee,
attr_name,
&var_arg.expr,
nth,
var_param,
) {
errs.append(&mut es);
}
nth += 1;
}
} else {
for (arg, pt) in var_args.iter().zip(subr.default_params.iter()) {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&arg.expr,
nth,
pt,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for not_passed in subr
.default_params
.iter()
.filter(|pt| !passed_params.contains(pt.name().unwrap()))
{
if let ParamTy::KwWithDefault { ty, default, .. } = ¬_passed {
if let Err(mut es) =
self.sub_unify(default, ty, obj.loc(), not_passed.name())
{
errs.append(&mut es);
}
}
}
} else {
// pos_args.len() < non_default_params_len
let mut params = non_default_params.chain(subr.default_params.iter());
for pos_arg in pos_args.iter() {
if let Err(mut es) = self.substitute_pos_arg(
&callee,
attr_name,
&pos_arg.expr,
nth,
params.next().unwrap(),
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
for kw_arg in kw_args.iter() {
if let Err(mut es) = self.substitute_kw_arg(
&callee,
attr_name,
kw_arg,
nth,
subr,
&mut passed_params,
) {
errs.append(&mut es);
}
nth += 1;
}
let missing_params = subr
.non_default_params
.iter()
.map(|pt| pt.name().cloned().unwrap_or(Str::ever("_")))
.filter(|pt| !passed_params.contains(pt))
.collect::<Vec<_>>();
if !missing_params.is_empty() {
return Err(TyCheckErrors::from(TyCheckError::args_missing_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
missing_params,
)));
}
}
if errs.is_empty() {
Ok(None)
} else {
Err(errs)
}
}
other => {
if let Ok(typ_ctx) = self.get_singular_ctx_by_hir_expr(obj, &self.name) {
if let Some(call_vi) = typ_ctx.get_current_scope_var("__call__") {
let mut dummy = TyVarCache::new(self.level, self);
let instance =
self.instantiate_t_inner(call_vi.t.clone(), &mut dummy, obj.loc())?;
self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
return Ok(Some(instance));
}
}
let hint = if other == &ClassType {
Some(switch_lang! {
"japanese" => format!("インスタンスを生成したい場合は、{}.newを使用してください", obj.to_string_notype()),
"simplified_chinese" => format!("如果要生成实例，请使用 {}.new", obj.to_string_notype()),
"traditional_chinese" => format!("如果要生成實例，請使用 {}.new", obj.to_string_notype()),
"english" => format!("If you want to generate an instance, use {}.new", obj.to_string_notype()),
})
} else {
None
};
Err(self.not_callable_error(obj, attr_name, other, hint))
}
}
}
fn gen_too_many_args_error(
&self,
callee: &hir::Expr,
subr_ty: &SubrType,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
) -> TyCheckErrors {
let mut unknown_args = vec![];
let mut passed_args: Vec<&hir::KwArg> = vec![];
let mut duplicated_args = vec![];
for kw_arg in kw_args.iter() {
if subr_ty
.non_default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
&& subr_ty
.var_params
.as_ref()
.map(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
.unwrap_or(true)
&& subr_ty
.default_params
.iter()
.all(|pt| pt.name() != Some(kw_arg.keyword.inspect()))
{
unknown_args.push(kw_arg);
}
if passed_args.iter().any(|a| a.keyword == kw_arg.keyword) {
duplicated_args.push(kw_arg);
} else {
passed_args.push(kw_arg);
}
}
if unknown_args.is_empty() && duplicated_args.is_empty() {
let params_len = subr_ty.non_default_params.len() + subr_ty.default_params.len();
TyCheckErrors::from(TyCheckError::too_many_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
params_len,
pos_args.len(),
kw_args.len(),
))
} else {
let unknown_arg_errors = unknown_args.into_iter().map(|arg| {
TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
let duplicated_arg_errors = duplicated_args.into_iter().map(|arg| {
TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
arg.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)
});
unknown_arg_errors.chain(duplicated_arg_errors).collect()
}
}
fn substitute_pos_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
if let Some(name) = param.name() {
if passed_params.contains(name) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
name,
)));
} else {
passed_params.insert(name.clone());
}
}
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
let mut hint = Self::get_call_type_mismatch_hint(
callee.ref_t(),
attr_name.as_ref().map(|i| &i.inspect()[..]),
nth,
param_t,
arg_t,
);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
std::mem::take(&mut hint),
)
})
.collect(),
)
})?;
Ok(())
}
fn substitute_var_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::Expr,
nth: usize,
param: &ParamTy,
) -> TyCheckResult<()> {
let arg_t = arg.ref_t();
let param_t = ¶m.typ();
self.sub_unify(arg_t, param_t, arg.loc(), param.name())
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {param_t}");
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + param.name().map(|s| readable_name(&s[..])).unwrap_or("");
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
param_t,
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
)
})
}
fn substitute_kw_arg(
&self,
callee: &hir::Expr,
attr_name: &Option<Identifier>,
arg: &hir::KwArg,
nth: usize,
subr_ty: &SubrType,
passed_params: &mut Set<Str>,
) -> TyCheckResult<()> {
let arg_t = arg.expr.ref_t();
let kw_name = arg.keyword.inspect();
if passed_params.contains(&kw_name[..]) {
return Err(TyCheckErrors::from(TyCheckError::multiple_args_error(
self.cfg.input.clone(),
line!() as usize,
callee.loc(),
&callee.to_string(),
self.caused_by(),
arg.keyword.inspect(),
)));
}
if let Some(pt) = subr_ty
.non_default_params
.iter()
.chain(subr_ty.default_params.iter())
.find(|pt| pt.name().as_ref() == Some(&kw_name))
{
passed_params.insert(kw_name.clone());
self.sub_unify(arg_t, pt.typ(), arg.loc(), Some(kw_name))
.map_err(|errs| {
log!(err "semi-unification failed with {callee}\n{arg_t} !<: {}", pt.typ());
let name = if let Some(attr) = attr_name {
format!("{callee}{attr}")
} else {
callee.show_acc().unwrap_or_default()
};
let name = name + "::" + readable_name(kw_name);
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::type_mismatch_error(
self.cfg.input.clone(),
line!() as usize,
e.core.loc,
e.caused_by,
&name[..],
Some(nth),
pt.typ(),
arg_t,
self.get_candidates(arg_t),
Self::get_simple_type_mismatch_hint(pt.typ(), arg_t),
)
})
.collect(),
)
})?;
} else {
return Err(TyCheckErrors::from(TyCheckError::unexpected_kw_arg_error(
self.cfg.input.clone(),
line!() as usize,
arg.keyword.loc(),
&callee.to_string(),
self.caused_by(),
kw_name,
)));
}
Ok(())
}
pub(crate) fn get_call_t(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
pos_args: &[hir::PosArg],
kw_args: &[hir::KwArg],
input: &Input,
namespace: &Str,
) -> TyCheckResult<VarInfo> {
if let hir::Expr::Accessor(hir::Accessor::Ident(local)) = obj {
if local.vis().is_private() {
match &local.inspect()[..] {
"match" => {
return self.get_match_call_t(SubrKind::Func, pos_args, kw_args);
}
"match!" => {
return self.get_match_call_t(SubrKind::Proc, pos_args, kw_args);
}
_ => {}
}
}
}
let found = self.search_callee_info(obj, attr_name, input, namespace)?;
log!(
"Found:\ncallee: {obj}{}\nfound: {found}",
fmt_option!(pre ".", attr_name.as_ref().map(|ident| &ident.name))
);
let instance = self.instantiate(found.t, obj)?;
log!(
"Instantiated:\ninstance: {instance}\npos_args: ({})\nkw_args: ({})",
fmt_slice(pos_args),
fmt_slice(kw_args)
);
let res = self.substitute_call(obj, attr_name, &instance, pos_args, kw_args)?;
let instance = if let Some(__call__) = res {
__call__
} else {
instance
};
log!(info "Substituted:\ninstance: {instance}");
let res = self.eval_t_params(instance, self.level, obj.loc())?;
log!(info "Params evaluated:\nres: {res}\n");
self.propagate(&res, obj)?;
log!(info "Propagated:\nres: {res}\n");
let res = VarInfo { t: res, ..found };
Ok(res)
}
pub(crate) fn get_const_local(
&self,
name: &Token,
namespace: &Str,
) -> SingleTyCheckResult<ValueObj> {
if let Some(obj) = self.consts.get(name.inspect()) {
Ok(obj.clone())
} else {
/*if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
return parent.get_const_local(name, namespace);
}*/
Err(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
name.inspect(),
self.get_similar_name(name.inspect()),
))
}
}
pub(crate) fn _get_const_attr(
&self,
obj: &hir::Expr,
name: &Token,
namespace: &Str,
) -> SingleTyCheckResult<ValueObj> {
let self_t = obj.ref_t();
for ctx in self.get_nominal_super_type_ctxs(self_t).ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
self_t,
)
})? {
if let Ok(t) = ctx.get_const_local(name, namespace) {
return Ok(t);
}
}
// TODO: dependent type widening
if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) {
parent._get_const_attr(obj, name, namespace)
} else {
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
namespace.into(),
self_t,
name.inspect(),
self.get_similar_attr(self_t, name.inspect()),
))
}
}
pub(crate) fn get_similar_name(&self, name: &str) -> Option<&str> {
get_similar_name(
self.dir().into_iter().map(|(vn, _)| &vn.inspect()[..]),
name,
)
}
pub(crate) fn get_similar_attr_from_singular<'a>(
&'a self,
obj: &hir::Expr,
name: &str,
) -> Option<&'a str> {
if let Ok(ctx) = self.get_singular_ctx_by_hir_expr(obj, &self.name) {
if let Some(name) = ctx.get_similar_name(name) {
return Some(name);
}
}
None
}
pub(crate) fn get_similar_attr<'a>(&'a self, self_t: &'a Type, name: &str) -> Option<&'a str> {
for ctx in self.get_nominal_super_type_ctxs(self_t)? {
if let Some(name) = ctx.get_similar_name(name) {
return Some(name);
}
}
None
}
// selfが示す型が、各パラメータTypeに対してどのような変性Varianceを持つかを返す
// 特に指定されない型に対してはInvariant
// e.g. K(T, U) = Class(..., Impl: F(T) and Output(U) and Input(T))
// -> K.variance() == vec![Contravariant, Covariant]
// TODO: support keyword arguments
pub(crate) fn type_params_variance(&self) -> Vec<Variance> {
let in_inout = |t: &Type, name: &VarName| {
(&t.qual_name()[..] == "Input" || &t.qual_name()[..] == "Output")
&& t.typarams()
.first()
.map(|inner| inner.qual_name().as_ref() == Some(name.inspect()))
.unwrap_or(false)
};
self.params
.iter()
.map(|(opt_name, _)| {
if let Some(name) = opt_name {
// トレイトの変性を調べるときはsuper_classesも見る必要がある
if let Some(t) = self
.super_traits
.iter()
.chain(self.super_classes.iter())
.find(|t| in_inout(t, name))
{
match &t.qual_name()[..] {
"Output" => Variance::Covariant,
"Input" => Variance::Contravariant,
_ => unreachable!(),
}
} else {
Variance::Invariant
}
} else {
Variance::Invariant
}
})
.collect()
}
/// Perform types linearization.
/// TODO: Current implementation may be very inefficient.
///
/// C3 linearization requires prior knowledge of inter-type dependencies, and cannot be used for Erg structural subtype linearization
///
/// Algorithm:
/// ```python
/// [Int, Str, Nat, Never, Obj, Str!, Module]
/// => [], [Int, Str, Nat, Never, Obj, Str!, Module]
/// => [[Int]], [Str, Nat, Never, Obj, Str!, Module]
/// # 1. If related, put them in the same array; if not, put them in different arrays.
/// => [[Int], [Str]], [Nat, Never, Obj, Str!, Module]
/// => ...
/// => [[Int, Nat, Never, Obj]], [Str, Str!], [Module]]
/// # 2. Then, perform sorting on the arrays
/// => [[Never, Nat, Int, Obj], [Str!, Str], [Module]]
/// # 3. Concatenate the arrays
/// => [Never, Nat, Int, Obj, Str!, Str, Module]
/// # 4. From the left, "slide" types as far as it can.
/// => [Never, Nat, Int, Str!, Str, Module, Obj]
/// ```
pub fn sort_types<'a>(&self, types: impl Iterator<Item = &'a Type>) -> Vec<&'a Type> {
let mut buffers: Vec<Vec<&Type>> = vec![];
for t in types {
let mut found = false;
for buf in buffers.iter_mut() {
if buf.iter().all(|buf_inner| self.related(buf_inner, t)) {
found = true;
buf.push(t);
break;
}
}
if !found {
buffers.push(vec![t]);
}
}
for buf in buffers.iter_mut() {
// this unwrap should be safe
buf.sort_by(|lhs, rhs| self.cmp_t(lhs, rhs).try_into().unwrap());
}
let mut concatenated = buffers.into_iter().flatten().collect::<Vec<_>>();
let mut idx = 0;
let len = concatenated.len();
while let Some(maybe_sup) = concatenated.get(idx) {
if let Some(pos) = concatenated
.iter()
.take(len - idx - 1)
.rposition(|t| self.supertype_of(maybe_sup, t))
{
let sup = concatenated.remove(idx);
concatenated.insert(pos, sup); // not `pos + 1` because the element was removed at idx
}
idx += 1;
}
concatenated
}
pub(crate) fn get_nominal_super_type_ctxs<'a>(&'a self, t: &Type) -> Option<Vec<&'a Context>> {
match t {
Type::FreeVar(fv) if fv.is_linked() => self.get_nominal_super_type_ctxs(&fv.crack()),
Type::FreeVar(fv) => {
if let Some(sup) = fv.get_super() {
self.get_nominal_super_type_ctxs(&sup)
} else {
self.get_nominal_super_type_ctxs(&Type)
}
}
Type::And(l, r) => {
match (
self.get_nominal_super_type_ctxs(l),
self.get_nominal_super_type_ctxs(r),
) {
// TODO: sort
(Some(l), Some(r)) => Some([l, r].concat()),
(Some(l), None) => Some(l),
(None, Some(r)) => Some(r),
(None, None) => None,
}
}
// TODO
Type::Or(l, r) => match (l.as_ref(), r.as_ref()) {
(Type::FreeVar(l), Type::FreeVar(r)) if l.is_unbound() && r.is_unbound() => {
let (_lsub, lsup) = l.get_subsup().unwrap();
let (_rsub, rsup) = r.get_subsup().unwrap();
self.get_nominal_super_type_ctxs(&self.union(&lsup, &rsup))
}
(Type::Refinement(l), Type::Refinement(r)) if l.t == r.t => {
self.get_nominal_super_type_ctxs(&l.t)
}
_ => None,
},
_ => self
.get_simple_nominal_super_type_ctxs(t)
.map(|ctxs| ctxs.collect()),
}
}
/// include `t` itself
fn get_simple_nominal_super_type_ctxs<'a>(
&'a self,
t: &Type,
) -> Option<impl Iterator<Item = &'a Context>> {
let (_, ctx) = self.get_nominal_type_ctx(t)?;
let sups = ctx
.super_classes
.iter()
.chain(ctx.super_traits.iter())
.map(|sup| {
self.get_nominal_type_ctx(sup)
.unwrap_or_else(|| todo!("compiler bug: {sup} not found"))
.1
});
Some(vec![ctx].into_iter().chain(sups))
}
pub(crate) fn _get_super_traits(&self, typ: &Type) -> Option<impl Iterator<Item = Type>> {
self.get_nominal_type_ctx(typ)
.map(|(_, ctx)| ctx.super_traits.clone().into_iter())
}
/// if `typ` is a refinement type, include the base type (refine.t)
pub(crate) fn _get_super_classes(&self, typ: &Type) -> Option<impl Iterator<Item = Type>> {
self.get_nominal_type_ctx(typ).map(|(_, ctx)| {
let super_classes = ctx.super_classes.clone();
let derefined = typ.derefine();
if typ != &derefined {
vec![derefined].into_iter().chain(super_classes)
} else {
vec![].into_iter().chain(super_classes)
}
})
}
// TODO: Never
pub(crate) fn get_nominal_type_ctx<'a>(
&'a self,
typ: &Type,
) -> Option<(&'a Type, &'a Context)> {
match typ {
Type::FreeVar(fv) if fv.is_linked() => {
if let Some(res) = self.get_nominal_type_ctx(&fv.crack()) {
return Some(res);
}
}
Type::FreeVar(fv) => {
let sup = fv.get_super().unwrap();
if let Some(res) = self.get_nominal_type_ctx(&sup) {
return Some(res);
}
}
Type::Refinement(refine) => {
if let Some(res) = self.get_nominal_type_ctx(&refine.t) {
return Some(res);
}
}
Type::Quantified(_) => {
if let Some((t, ctx)) = self
.get_builtins()
.unwrap_or(self)
.rec_get_mono_type("QuantifiedFunc")
{
return Some((t, ctx));
}
}
Type::Subr(subr) => match subr.kind {
SubrKind::Func => {
if let Some((t, ctx)) = self
.get_builtins()
.unwrap_or(self)
.rec_get_mono_type("Func")
{
return Some((t, ctx));
}
}
SubrKind::Proc => {
if let Some((t, ctx)) = self
.get_builtins()
.unwrap_or(self)
.rec_get_mono_type("Proc")
{
return Some((t, ctx));
}
}
},
Type::Mono(name) => {
if let Some((t, ctx)) = self.rec_get_mono_type(&typ.local_name()) {
return Some((t, ctx));
}
// e.g. http.client.Response -> http.client
let mut namespaces = name.split_with(&[".", "::"]);
if namespaces.len() < 2 {
return None;
}
let type_name = namespaces.pop().unwrap(); // Response
let path = Path::new(namespaces.remove(0));
let mut path = Self::resolve_path(&self.cfg, path)?;
for p in namespaces.into_iter() {
path = self.push_path(path, Path::new(p));
}
if let Some(ctx) = self
.mod_cache
.as_ref()
.and_then(|cache| cache.ref_ctx(path.as_path()))
.or_else(|| {
self.py_mod_cache
.as_ref()
.and_then(|cache| cache.ref_ctx(path.as_path()))
})
{
if let Some((t, ctx)) = ctx.rec_get_mono_type(type_name) {
return Some((t, ctx));
}
}
}
Type::Poly { name, .. } => {
if let Some((t, ctx)) = self.rec_get_poly_type(&typ.local_name()) {
return Some((t, ctx));
}
// NOTE: This needs to be changed if we want to be able to define classes/traits outside of the top level
let mut namespaces = name.split_with(&[".", "::"]);
if namespaces.len() < 2 {
return None;
}
let type_name = namespaces.pop().unwrap(); // Response
let path = Path::new(namespaces.remove(0));
let mut path = Self::resolve_path(&self.cfg, path)?;
for p in namespaces.into_iter() {
path = self.push_path(path, Path::new(p));
}
if let Some(ctx) = self
.mod_cache
.as_ref()
.and_then(|cache| cache.ref_ctx(path.as_path()))
.or_else(|| {
self.py_mod_cache
.as_ref()
.and_then(|cache| cache.ref_ctx(path.as_path()))
})
{
if let Some((t, ctx)) = ctx.rec_get_poly_type(type_name) {
return Some((t, ctx));
}
}
}
Type::Record(rec) if rec.values().all(|attr| self.supertype_of(&Type, attr)) => {
return self
.get_builtins()
.unwrap_or(self)
.rec_get_mono_type("RecordType");
}
Type::Record(_) => {
return self
.get_builtins()
.unwrap_or(self)
.rec_get_mono_type("Record");
}
Type::Or(_l, _r) => {
if let Some(ctx) = self.get_nominal_type_ctx(&poly("Or", vec![])) {
return Some(ctx);
}
}
// FIXME: `F()`などの場合、実際は引数が省略されていてもmonomorphicになる
other if other.is_monomorphic() => {
if let Some((t, ctx)) = self.rec_get_mono_type(&other.local_name()) {
return Some((t, ctx));
}
}
Type::Ref(t) | Type::RefMut { before: t, .. } => {
if let Some(res) = self.get_nominal_type_ctx(t) {
return Some(res);
}
}
other => {
log!("{other} has no nominal definition");
}
}
None
}
// TODO: Never
pub(crate) fn get_mut_nominal_type_ctx<'a>(
&'a mut self,
typ: &Type,
) -> Option<(&'a Type, &'a mut Context)> {
match typ {
Type::FreeVar(fv) if fv.is_linked() => {
if let Some(res) = self.get_mut_nominal_type_ctx(&fv.crack()) {
return Some(res);
}
}
Type::FreeVar(fv) => {
let sup = fv.get_super().unwrap();
if let Some(res) = self.get_mut_nominal_type_ctx(&sup) {
return Some(res);
}
}
Type::Refinement(refine) => {
if let Some(res) = self.get_mut_nominal_type_ctx(&refine.t) {
return Some(res);
}
}
Type::Quantified(_) => {
if let Some(res) = self.get_mut_nominal_type_ctx(&mono("QuantifiedFunc")) {
return Some(res);
}
}
Type::Mono(_) => {
if let Some((t, ctx)) = self.rec_get_mut_mono_type(&typ.local_name()) {
return Some((t, ctx));
}
}
Type::Poly { .. } => {
if let Some((t, ctx)) = self.rec_get_mut_poly_type(&typ.local_name()) {
return Some((t, ctx));
}
}
// FIXME: `F()`などの場合、実際は引数が省略されていてもmonomorphicになる
other if other.is_monomorphic() => {
if let Some((t, ctx)) = self.rec_get_mut_mono_type(&other.local_name()) {
return Some((t, ctx));
}
}
Type::Ref(t) | Type::RefMut { before: t, .. } => {
if let Some(res) = self.get_mut_nominal_type_ctx(t) {
return Some(res);
}
}
other => {
log!("{other} has no nominal definition");
}
}
None
}
pub(crate) fn get_trait_impls(&self, t: &Type) -> Set<TypeRelationInstance> {
match t {
// And(Add, Sub) == intersection({Int <: Add(Int), Bool <: Add(Bool) ...}, {Int <: Sub(Int), ...})
// == {Int <: Add(Int) and Sub(Int), ...}
Type::And(l, r) => {
let l_impls = self.get_trait_impls(l);
let l_base = Set::from_iter(l_impls.iter().map(|ti| &ti.sub_type));
let r_impls = self.get_trait_impls(r);
let r_base = Set::from_iter(r_impls.iter().map(|ti| &ti.sub_type));
let bases = l_base.intersection(&r_base);
let mut isec = set! {};
for base in bases.into_iter() {
let lti = l_impls.iter().find(|ti| &ti.sub_type == base).unwrap();
let rti = r_impls.iter().find(|ti| &ti.sub_type == base).unwrap();
let sup_trait = self.intersection(<i.sup_trait, &rti.sup_trait);
isec.insert(TypeRelationInstance::new(lti.sub_type.clone(), sup_trait));
}
isec
}
Type::Or(l, r) => {
let l_impls = self.get_trait_impls(l);
let r_impls = self.get_trait_impls(r);
// FIXME:
l_impls.union(&r_impls)
}
_ => self.get_simple_trait_impls(t),
}
}
pub(crate) fn get_simple_trait_impls(&self, t: &Type) -> Set<TypeRelationInstance> {
let current = if let Some(impls) = self.trait_impls.get(&t.qual_name()) {
impls.clone()
} else {
set! {}
};
if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
current.union(&outer.get_simple_trait_impls(t))
} else {
current
}
}
pub(crate) fn all_patches(&self) -> Vec<&Context> {
if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
[outer.all_patches(), self.patches.values().collect()].concat()
} else {
self.patches.values().collect()
}
}
pub(crate) fn resolve_path(cfg: &ErgConfig, path: &Path) -> Option<PathBuf> {
Self::resolve_real_path(cfg, path).or_else(|| Self::resolve_decl_path(cfg, path))
}
pub(crate) fn resolve_real_path(cfg: &ErgConfig, path: &Path) -> Option<PathBuf> {
if let Ok(path) = cfg.input.local_resolve(path) {
Some(path)
} else if let Ok(path) = erg_std_path()
.join(format!("{}.er", path.display()))
.canonicalize()
{
Some(path)
} else if let Ok(path) = erg_std_path()
.join(format!("{}", path.display()))
.join("__init__.er")
.canonicalize()
{
Some(path)
} else {
None
}
}
pub(crate) fn resolve_decl_path(cfg: &ErgConfig, path: &Path) -> Option<PathBuf> {
if let Ok(path) = cfg.input.local_resolve(path) {
Some(path)
} else if let Ok(path) = erg_pystd_path()
.join(format!("{}.d.er", path.display()))
.canonicalize()
{
Some(path)
} else if let Ok(path) = erg_pystd_path()
.join(format!("{}.d", path.display()))
.join("__init__.d.er")
.canonicalize()
{
Some(path)
} else {
None
}
}
pub(crate) fn push_path(&self, mut path: PathBuf, add: &Path) -> PathBuf {
path.pop(); // __init__.d.er
if let Ok(path) = path.join(add).canonicalize() {
path
} else if let Ok(path) = path.join(format!("{}.d.er", add.display())).canonicalize() {
path
} else if let Ok(path) = path
.join(format!("{}.d", add.display()))
.join("__init__.d.er")
.canonicalize()
{
path
} else {
todo!("{} {}", path.display(), add.display())
}
}
// FIXME: 現在の実装だとimportしたモジュールはどこからでも見れる
pub(crate) fn get_mod(&self, name: &str) -> Option<&Context> {
let t = self.get_var_info(name).map(|(_, vi)| vi.t.clone())?;
if t.is_module() {
let path =
option_enum_unwrap!(t.typarams().remove(0), TyParam::Value:(ValueObj::Str:(_)))?;
let path = Self::resolve_path(&self.cfg, Path::new(&path[..]))?;
self.mod_cache
.as_ref()
.and_then(|cache| cache.ref_ctx(&path))
.or_else(|| {
self.py_mod_cache
.as_ref()
.and_then(|cache| cache.ref_ctx(&path))
})
} else {
None
}
}
// rec_get_const_localとは違い、位置情報を持たないしエラーとならない
pub(crate) fn rec_get_const_obj(&self, name: &str) -> Option<&ValueObj> {
if let Some(val) = self.consts.get(name) {
return Some(val);
}
for (_, ctx) in self.methods_list.iter() {
if let Some(val) = ctx.consts.get(name) {
return Some(val);
}
}
if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.rec_get_const_obj(name)
} else {
None
}
}
pub(crate) fn _rec_get_const_param_defaults(&self, name: &str) -> Option<&Vec<ConstTemplate>> {
if let Some(impls) = self.const_param_defaults.get(name) {
Some(impls)
} else if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer._rec_get_const_param_defaults(name)
} else {
None
}
}
// TODO: poly type
pub(crate) fn rec_get_self_t(&self) -> Option<Type> {
if self.kind.is_method_def() || self.kind.is_type() {
Some(mono(self.name.clone()))
} else if let ContextKind::PatchMethodDefs(t) = &self.kind {
Some(t.clone())
} else if let Some(outer) = self.get_outer() {
outer.rec_get_self_t()
} else {
None
}
}
pub(crate) fn rec_get_mono_type(&self, name: &str) -> Option<(&Type, &Context)> {
if let Some((t, ctx)) = self.mono_types.get(name) {
Some((t, ctx))
} else if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.rec_get_mono_type(name)
} else {
None
}
}
pub(crate) fn rec_get_poly_type(&self, name: &str) -> Option<(&Type, &Context)> {
if let Some((t, ctx)) = self.poly_types.get(name) {
Some((t, ctx))
} else if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.rec_get_poly_type(name)
} else {
None
}
}
fn rec_get_mut_mono_type(&mut self, name: &str) -> Option<(&mut Type, &mut Context)> {
if let Some((t, ctx)) = self.mono_types.get_mut(name) {
Some((t, ctx))
} else if let Some(outer) = self.outer.as_mut() {
// builtins cannot be got as mutable
outer.rec_get_mut_mono_type(name)
} else {
None
}
}
fn rec_get_mut_poly_type(&mut self, name: &str) -> Option<(&mut Type, &mut Context)> {
if let Some((t, ctx)) = self.poly_types.get_mut(name) {
Some((t, ctx))
} else if let Some(outer) = self.outer.as_mut() {
outer.rec_get_mut_poly_type(name)
} else {
None
}
}
pub(crate) fn rec_get_type(&self, name: &str) -> Option<(&Type, &Context)> {
if let Some((t, ctx)) = self.mono_types.get(name) {
Some((t, ctx))
} else if let Some((t, ctx)) = self.poly_types.get(name) {
Some((t, ctx))
} else if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.rec_get_type(name)
} else {
None
}
}
pub(crate) fn get_mut_type(&mut self, name: &str) -> Option<(&Type, &mut Context)> {
if let Some((t, ctx)) = self.mono_types.get_mut(name) {
Some((t, ctx))
} else if let Some((t, ctx)) = self.poly_types.get_mut(name) {
Some((t, ctx))
} else {
None
}
}
pub(crate) fn rec_get_patch(&self, name: &str) -> Option<&Context> {
if let Some(ctx) = self.patches.get(name) {
Some(ctx)
} else if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.rec_get_patch(name)
} else {
None
}
}
fn get_method_type_by_name(&self, name: &Identifier) -> SingleTyCheckResult<&MethodInfo> {
// TODO: min_by
if let Some(candidates) = self.method_to_traits.get(name.inspect()) {
let first_method_type = &candidates.first().unwrap().method_type;
if candidates
.iter()
.skip(1)
.all(|t| &t.method_type == first_method_type)
{
return Ok(&candidates[0]);
} else {
return Err(TyCheckError::ambiguous_type_error(
self.cfg.input.clone(),
line!() as usize,
name,
&candidates
.iter()
.map(|t| t.definition_type.clone())
.collect::<Vec<_>>(),
self.caused_by(),
));
}
}
if let Some(candidates) = self.method_to_classes.get(name.inspect()) {
let first_method_type = &candidates.first().unwrap().method_type;
if candidates
.iter()
.skip(1)
.all(|t| &t.method_type == first_method_type)
{
return Ok(&candidates[0]);
} else {
return Err(TyCheckError::ambiguous_type_error(
self.cfg.input.clone(),
line!() as usize,
name,
&candidates
.iter()
.map(|t| t.definition_type.clone())
.collect::<Vec<_>>(),
self.caused_by(),
));
}
}
if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.get_method_type_by_name(name)
} else {
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
&Type::Failure,
name.inspect(),
None,
))
}
}sourcepub fn singular_no_attr_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
obj_name: &str,
obj_t: &Type,
name: &str,
similar_name: Option<&str>
) -> Self
pub fn singular_no_attr_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
obj_name: &str,
obj_t: &Type,
name: &str,
similar_name: Option<&str>
) -> Self
Examples found in repository?
context/inquire.rs (lines 729-738)
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
fn search_callee_info(
&self,
obj: &hir::Expr,
attr_name: &Option<Identifier>,
input: &Input,
namespace: &Str,
) -> SingleTyCheckResult<VarInfo> {
if obj.ref_t() == Type::FAILURE {
// (...Obj) -> Failure
return Ok(VarInfo {
t: Type::Subr(SubrType::new(
SubrKind::Func,
vec![],
Some(ParamTy::pos(None, ref_(Obj))),
vec![],
Failure,
)),
..VarInfo::default()
});
}
if let Some(attr_name) = attr_name.as_ref() {
for ctx in self
.get_nominal_super_type_ctxs(obj.ref_t())
.ok_or_else(|| {
TyCheckError::type_not_found(
self.cfg.input.clone(),
line!() as usize,
obj.loc(),
self.caused_by(),
obj.ref_t(),
)
})?
{
if let Some(vi) = ctx
.locals
.get(attr_name.inspect())
.or_else(|| ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in ctx.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
if let Ok(singular_ctx) = self.get_singular_ctx_by_hir_expr(obj, namespace) {
if let Some(vi) = singular_ctx
.locals
.get(attr_name.inspect())
.or_else(|| singular_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, method_ctx) in singular_ctx.methods_list.iter() {
if let Some(vi) = method_ctx
.locals
.get(attr_name.inspect())
.or_else(|| method_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
return Err(TyCheckError::singular_no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.qual_name().unwrap_or("?"),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr_from_singular(obj, attr_name.inspect()),
));
}
match self.get_method_type_by_name(attr_name) {
Ok(method) => {
self.sub_unify(obj.ref_t(), &method.definition_type, obj.loc(), None)
// HACK: change this func's return type to TyCheckResult<Type>
.map_err(|mut errs| errs.remove(0))?;
return Ok(method.method_type.clone());
}
Err(err) if err.core.kind == ErrorKind::TypeError => {
return Err(err);
}
_ => {}
}
for patch in self.find_patches_of(obj.ref_t()) {
if let Some(vi) = patch
.locals
.get(attr_name.inspect())
.or_else(|| patch.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
for (_, methods_ctx) in patch.methods_list.iter() {
if let Some(vi) = methods_ctx
.locals
.get(attr_name.inspect())
.or_else(|| methods_ctx.decls.get(attr_name.inspect()))
{
self.validate_visibility(attr_name, vi, input, namespace)?;
return Ok(vi.clone());
}
}
}
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
attr_name.loc(),
namespace.into(),
obj.ref_t(),
attr_name.inspect(),
self.get_similar_attr(obj.ref_t(), attr_name.inspect()),
))
} else {
Ok(VarInfo {
t: obj.t(),
..VarInfo::default()
})
}
}sourcepub fn reassign_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
pub fn reassign_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str
) -> Self
Examples found in repository?
declare.rs (lines 74-80)
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
fn declare_def(&mut self, def: ast::Def) -> LowerResult<hir::Def> {
log!(info "entered {}({})", fn_name!(), def.sig);
let name = if let Some(name) = def.sig.name_as_str() {
name.clone()
} else {
Str::ever("<lambda>")
};
if self
.ctx
.registered_info(&name, def.sig.is_const())
.is_some()
&& def.sig.vis().is_private()
{
return Err(LowerErrors::from(LowerError::reassign_error(
self.cfg().input.clone(),
line!() as usize,
def.sig.loc(),
self.ctx.caused_by(),
&name,
)));
}
#[allow(clippy::let_and_return)]
let res = match def.sig {
ast::Signature::Subr(sig) => {
return Err(LowerErrors::from(LowerError::declare_error(
self.cfg().input.clone(),
line!() as usize,
sig.loc(),
self.ctx.caused_by(),
)));
}
ast::Signature::Var(sig) => self.declare_var(sig, def.body),
};
// self.pop_append_errs();
res
}More examples
lower.rs (lines 1052-1058)
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
fn lower_def(&mut self, def: ast::Def) -> LowerResult<hir::Def> {
log!(info "entered {}({})", fn_name!(), def.sig);
if def.def_kind().is_class_or_trait() && self.ctx.kind != ContextKind::Module {
self.ctx.decls.remove(def.sig.ident().unwrap().inspect());
return Err(LowerErrors::from(LowerError::inner_typedef_error(
self.cfg.input.clone(),
line!() as usize,
def.loc(),
self.ctx.caused_by(),
)));
}
let name = if let Some(name) = def.sig.name_as_str() {
name.clone()
} else {
Str::ever("<lambda>")
};
if self
.ctx
.registered_info(&name, def.sig.is_const())
.is_some()
&& def.sig.vis().is_private()
{
return Err(LowerErrors::from(LowerError::reassign_error(
self.cfg.input.clone(),
line!() as usize,
def.sig.loc(),
self.ctx.caused_by(),
&name,
)));
}
let kind = ContextKind::from(def.def_kind());
let vis = def.sig.vis();
let res = match def.sig {
ast::Signature::Subr(sig) => {
let tv_cache = self
.ctx
.instantiate_ty_bounds(&sig.bounds, RegistrationMode::Normal)?;
self.ctx.grow(&name, kind, vis, Some(tv_cache));
self.lower_subr_def(sig, def.body)
}
ast::Signature::Var(sig) => {
self.ctx.grow(&name, kind, vis, None);
self.lower_var_def(sig, def.body)
}
};
// TODO: Context上の関数に型境界情報を追加
self.pop_append_errs();
// remove from decls regardless of success or failure to lower
self.ctx.decls.remove(&name);
res
}context/register.rs (lines 262-268)
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
fn assign_param(
&mut self,
sig: &ast::NonDefaultParamSignature,
default_val_exists: bool,
opt_decl_t: Option<&ParamTy>,
) -> TyCheckResult<()> {
let vis = if self.cfg.python_compatible_mode {
Public
} else {
Private
};
match &sig.pat {
// Literal patterns will be desugared to discard patterns
ast::ParamPattern::Lit(_) => unreachable!(),
ast::ParamPattern::Discard(_token) => {
let spec_t = self.instantiate_param_sig_t(
sig,
opt_decl_t,
&mut TyVarCache::new(self.level, self),
Normal,
)?;
let kind = VarKind::parameter(
DefId(get_hash(&(&self.name, "_"))),
DefaultInfo::NonDefault,
);
self.params.push((
Some(VarName::from_static("_")),
VarInfo::new(spec_t, Immutable, vis, kind, None, None, None),
));
Ok(())
}
ast::ParamPattern::VarName(name) => {
if self
.registered_info(name.inspect(), name.is_const())
.is_some()
{
Err(TyCheckErrors::from(TyCheckError::reassign_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
name.inspect(),
)))
} else {
// ok, not defined
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let spec_t =
self.instantiate_param_sig_t(sig, opt_decl_t, &mut dummy_tv_cache, Normal)?;
if &name.inspect()[..] == "self" {
if let Some(self_t) = self.rec_get_self_t() {
self.sub_unify(&spec_t, &self_t, name.loc(), Some(name.inspect()))?;
} else {
log!(err "self_t is None");
}
}
let default = if default_val_exists {
DefaultInfo::WithDefault
} else {
DefaultInfo::NonDefault
};
let kind = VarKind::parameter(DefId(get_hash(&(&self.name, name))), default);
let muty = Mutability::from(&name.inspect()[..]);
self.params.push((
Some(name.clone()),
VarInfo::new(spec_t, muty, vis, kind, None, None, None),
));
Ok(())
}
}
ast::ParamPattern::Ref(name) => {
if self
.registered_info(name.inspect(), name.is_const())
.is_some()
{
Err(TyCheckErrors::from(TyCheckError::reassign_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
name.inspect(),
)))
} else {
// ok, not defined
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let spec_t =
self.instantiate_param_sig_t(sig, opt_decl_t, &mut dummy_tv_cache, Normal)?;
if &name.inspect()[..] == "self" {
if let Some(self_t) = self.rec_get_self_t() {
self.sub_unify(&spec_t, &self_t, name.loc(), Some(name.inspect()))?;
} else {
log!(err "self_t is None");
}
}
let spec_t = ref_(spec_t);
let default = if default_val_exists {
DefaultInfo::WithDefault
} else {
DefaultInfo::NonDefault
};
let kind = VarKind::parameter(DefId(get_hash(&(&self.name, name))), default);
self.params.push((
Some(name.clone()),
VarInfo::new(spec_t, Immutable, vis, kind, None, None, None),
));
Ok(())
}
}
ast::ParamPattern::RefMut(name) => {
if self
.registered_info(name.inspect(), name.is_const())
.is_some()
{
Err(TyCheckErrors::from(TyCheckError::reassign_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
name.inspect(),
)))
} else {
// ok, not defined
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let spec_t =
self.instantiate_param_sig_t(sig, opt_decl_t, &mut dummy_tv_cache, Normal)?;
if &name.inspect()[..] == "self" {
if let Some(self_t) = self.rec_get_self_t() {
self.sub_unify(&spec_t, &self_t, name.loc(), Some(name.inspect()))?;
} else {
log!(err "self_t is None");
}
}
let spec_t = ref_mut(spec_t.clone(), Some(spec_t));
let default = if default_val_exists {
DefaultInfo::WithDefault
} else {
DefaultInfo::NonDefault
};
let kind = VarKind::parameter(DefId(get_hash(&(&self.name, name))), default);
self.params.push((
Some(name.clone()),
VarInfo::new(spec_t, Immutable, vis, kind, None, None, None),
));
Ok(())
}
}
other => {
log!(err "{other}");
unreachable!("{other}")
}
}
}
pub(crate) fn assign_params(
&mut self,
params: &hir::Params,
opt_decl_subr_t: Option<SubrType>,
) -> TyCheckResult<()> {
let mut errs = TyCheckErrors::empty();
if let Some(decl_subr_t) = opt_decl_subr_t {
assert_eq!(
params.non_defaults.len(),
decl_subr_t.non_default_params.len()
);
assert_eq!(params.defaults.len(), decl_subr_t.default_params.len());
for (sig, pt) in params
.non_defaults
.iter()
.zip(decl_subr_t.non_default_params.iter())
{
if let Err(es) = self.assign_param(sig, false, Some(pt)) {
errs.extend(es);
}
}
for (sig, pt) in params
.defaults
.iter()
.zip(decl_subr_t.default_params.iter())
{
if let Err(es) = self.assign_param(&sig.sig, true, Some(pt)) {
errs.extend(es);
}
}
} else {
for sig in params.non_defaults.iter() {
if let Err(es) = self.assign_param(sig, false, None) {
errs.extend(es);
}
}
for sig in params.defaults.iter() {
if let Err(es) = self.assign_param(&sig.sig, true, None) {
errs.extend(es);
}
}
}
if errs.is_empty() {
Ok(())
} else {
Err(errs)
}
}
/// ## Errors
/// * TypeError: if `return_t` != typeof `body`
/// * AssignError: if `name` has already been registered
pub(crate) fn assign_subr(
&mut self,
sig: &ast::SubrSignature,
id: DefId,
body_t: &Type,
) -> TyCheckResult<Type> {
// already defined as const
if sig.ident.is_const() {
let vi = self.decls.remove(sig.ident.inspect()).unwrap();
let t = vi.t.clone();
self.locals.insert(sig.ident.name.clone(), vi);
return Ok(t);
}
let muty = if sig.ident.is_const() {
Mutability::Const
} else {
Mutability::Immutable
};
let name = &sig.ident.name;
// FIXME: constでない関数
let t = self
.get_current_scope_var(name.inspect())
.map(|v| &v.t)
.unwrap();
let non_default_params = t.non_default_params().unwrap();
let var_args = t.var_args();
let default_params = t.default_params().unwrap();
let mut errs = if let Some(spec_ret_t) = t.return_t() {
let return_t_loc = sig
.return_t_spec
.as_ref()
.map(|t_spec| t_spec.loc())
.unwrap_or_else(|| sig.loc());
self.sub_unify(body_t, spec_ret_t, return_t_loc, None)
.map_err(|errs| {
TyCheckErrors::new(
errs.into_iter()
.map(|e| {
TyCheckError::return_type_error(
self.cfg.input.clone(),
line!() as usize,
e.core.get_loc_with_fallback(),
e.caused_by,
readable_name(name.inspect()),
spec_ret_t,
body_t,
)
})
.collect(),
)
})
} else {
Ok(())
};
let return_t = if errs.is_err() {
Type::Failure
} else {
// NOTE: not `body_t.clone()` because the body may contain `return`
t.return_t().unwrap().clone()
};
let sub_t = if sig.ident.is_procedural() {
proc(
non_default_params.clone(),
var_args.cloned(),
default_params.clone(),
return_t,
)
} else {
func(
non_default_params.clone(),
var_args.cloned(),
default_params.clone(),
return_t,
)
};
sub_t.lift();
let found_t = self.generalize_t(sub_t);
let py_name = if let Some(vi) = self.decls.remove(name) {
if !self.supertype_of(&vi.t, &found_t) {
let err = TyCheckError::violate_decl_error(
self.cfg.input.clone(),
line!() as usize,
sig.ident.loc(),
self.caused_by(),
name.inspect(),
&vi.t,
&found_t,
);
match errs {
Ok(()) => {
errs = Err(TyCheckErrors::from(err));
}
Err(ref mut es) => {
es.push(err);
}
}
}
vi.py_name
} else {
None
};
let comptime_decos = sig
.decorators
.iter()
.filter_map(|deco| match &deco.0 {
ast::Expr::Accessor(ast::Accessor::Ident(local)) if local.is_const() => {
Some(local.inspect().clone())
}
_ => None,
})
.collect();
let vi = VarInfo::new(
found_t,
muty,
sig.ident.vis(),
VarKind::Defined(id),
Some(comptime_decos),
self.impl_of(),
py_name,
);
let t = vi.t.clone();
log!(info "Registered {}::{name}: {t}", self.name);
self.locals.insert(name.clone(), vi);
errs?;
Ok(t)
}
pub(crate) fn fake_subr_assign(
&mut self,
ident: &Identifier,
decorators: &Set<Decorator>,
failure_t: Type,
) -> TyCheckResult<()> {
// already defined as const
if ident.is_const() {
let Some(vi) = self.decls.remove(ident.inspect()) else {
return Err(TyCheckErrors::from(TyCheckError::unreachable(
self.cfg.input.clone(),
fn_name!(),
line!(),
)));
};
self.locals.insert(ident.name.clone(), vi);
}
let muty = if ident.is_const() {
Mutability::Const
} else {
Mutability::Immutable
};
let name = &ident.name;
self.decls.remove(name);
let comptime_decos = decorators
.iter()
.filter_map(|deco| match &deco.0 {
ast::Expr::Accessor(ast::Accessor::Ident(local)) if local.is_const() => {
Some(local.inspect().clone())
}
_ => None,
})
.collect();
let vi = VarInfo::new(
failure_t,
muty,
ident.vis(),
VarKind::DoesNotExist,
Some(comptime_decos),
self.impl_of(),
None,
);
log!(info "Registered {}::{name}: {}", self.name, &vi.t);
self.locals.insert(name.clone(), vi);
Ok(())
}
// To allow forward references and recursive definitions
pub(crate) fn preregister(&mut self, block: &ast::Block) -> TyCheckResult<()> {
let mut total_errs = TyCheckErrors::empty();
for expr in block.iter() {
match expr {
ast::Expr::Def(def) => {
if let Err(errs) = self.preregister_def(def) {
total_errs.extend(errs.into_iter());
}
}
ast::Expr::ClassDef(class_def) => {
if let Err(errs) = self.preregister_def(&class_def.def) {
total_errs.extend(errs.into_iter());
}
}
ast::Expr::PatchDef(patch_def) => {
if let Err(errs) = self.preregister_def(&patch_def.def) {
total_errs.extend(errs.into_iter());
}
}
_ => {}
}
}
if total_errs.is_empty() {
Ok(())
} else {
Err(total_errs)
}
}
pub(crate) fn preregister_def(&mut self, def: &ast::Def) -> TyCheckResult<()> {
let id = Some(def.body.id);
let __name__ = def.sig.ident().map(|i| i.inspect()).unwrap_or(UBAR);
match &def.sig {
ast::Signature::Subr(sig) => {
if sig.is_const() {
let tv_cache = self.instantiate_ty_bounds(&sig.bounds, PreRegister)?;
let vis = def.sig.vis();
self.grow(__name__, ContextKind::Proc, vis, Some(tv_cache));
let (obj, const_t) = match self.eval_const_block(&def.body.block) {
Ok(obj) => (obj.clone(), v_enum(set! {obj})),
Err(e) => {
self.pop();
return Err(e);
}
};
if let Some(spec) = sig.return_t_spec.as_ref() {
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let spec_t = self
.instantiate_typespec(
spec,
None,
&mut dummy_tv_cache,
PreRegister,
false,
)
.map_err(|err| {
self.pop();
err
})?;
self.sub_unify(&const_t, &spec_t, def.body.loc(), None)
.map_err(|err| {
self.pop();
err
})?;
}
self.pop();
self.register_gen_const(def.sig.ident().unwrap(), obj)?;
} else {
self.declare_sub(sig, id)?;
}
}
ast::Signature::Var(sig) => {
if sig.is_const() {
let kind = ContextKind::from(def.def_kind());
self.grow(__name__, kind, sig.vis(), None);
let (obj, const_t) = match self.eval_const_block(&def.body.block) {
Ok(obj) => (obj.clone(), v_enum(set! {obj})),
Err(errs) => {
self.pop();
return Err(errs);
}
};
if let Some(spec) = sig.t_spec.as_ref() {
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let spec_t = self
.instantiate_typespec(
spec,
None,
&mut dummy_tv_cache,
PreRegister,
false,
)
.map_err(|err| {
self.pop();
err
})?;
self.sub_unify(&const_t, &spec_t, def.body.loc(), None)
.map_err(|err| {
self.pop();
err
})?;
}
self.pop();
if let Some(ident) = sig.ident() {
self.register_gen_const(ident, obj)?;
}
} else {
let opt_t = self
.eval_const_block(&def.body.block)
.map(|o| v_enum(set! {o}))
.ok();
self.pre_define_var(sig, opt_t, id)?;
}
}
}
Ok(())
}
/// e.g. .new
fn register_auto_impl(
&mut self,
name: &'static str,
t: Type,
muty: Mutability,
vis: Visibility,
py_name: Option<Str>,
) {
let name = VarName::from_static(name);
if self.locals.get(&name).is_some() {
panic!("already registered: {name}");
} else {
self.locals.insert(
name,
VarInfo::new(t, muty, vis, VarKind::Auto, None, self.impl_of(), py_name),
);
}
}
/// e.g. ::__new__
fn register_fixed_auto_impl(
&mut self,
name: &'static str,
t: Type,
muty: Mutability,
vis: Visibility,
py_name: Option<Str>,
) {
let name = VarName::from_static(name);
if self.locals.get(&name).is_some() {
panic!("already registered: {name}");
} else {
self.locals.insert(
name,
VarInfo::new(
t,
muty,
vis,
VarKind::FixedAuto,
None,
self.impl_of(),
py_name,
),
);
}
}
fn _register_gen_decl(
&mut self,
name: VarName,
t: Type,
vis: Visibility,
impl_of: Option<Type>,
py_name: Option<Str>,
) {
if self.decls.get(&name).is_some() {
panic!("already registered: {name}");
} else {
self.decls.insert(
name,
VarInfo::new(t, Immutable, vis, VarKind::Declared, None, impl_of, py_name),
);
}
}
fn _register_gen_impl(
&mut self,
name: VarName,
t: Type,
muty: Mutability,
vis: Visibility,
impl_of: Option<Type>,
py_name: Option<Str>,
) {
if self.locals.get(&name).is_some() {
panic!("already registered: {name}");
} else {
let id = DefId(get_hash(&(&self.name, &name)));
self.locals.insert(
name,
VarInfo::new(t, muty, vis, VarKind::Defined(id), None, impl_of, py_name),
);
}
}
pub(crate) fn register_trait(&mut self, class: Type, methods: Self) {
let trait_ = if let ContextKind::MethodDefs(Some(tr)) = &methods.kind {
tr.clone()
} else {
todo!()
};
self.super_traits.push(trait_.clone());
self.methods_list
.push((ClassDefType::impl_trait(class, trait_), methods));
}
pub(crate) fn register_marker_trait(&mut self, trait_: Type) {
self.super_traits.push(trait_);
}
pub(crate) fn register_gen_const(
&mut self,
ident: &Identifier,
obj: ValueObj,
) -> SingleTyCheckResult<()> {
if self.rec_get_const_obj(ident.inspect()).is_some() && ident.vis().is_private() {
Err(TyCheckError::reassign_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
))
} else {
match obj {
ValueObj::Type(t) => match t {
TypeObj::Generated(gen) => {
self.register_gen_type(ident, gen);
}
TypeObj::Builtin(t) => {
self.register_type_alias(ident, t);
}
},
// TODO: not all value objects are comparable
other => {
let id = DefId(get_hash(ident));
let vi = VarInfo::new(
v_enum(set! {other.clone()}),
Const,
ident.vis(),
VarKind::Defined(id),
None,
self.impl_of(),
None,
);
self.decls.insert(ident.name.clone(), vi);
self.consts.insert(ident.name.clone(), other);
}
}
Ok(())
}
}pub fn unused_warning(
input: Input,
errno: usize,
loc: Location,
name: &str,
caused_by: String
) -> Self
sourcepub fn union_return_type_warning(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
fn_name: &str,
typ: &Type
) -> Self
pub fn union_return_type_warning(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
fn_name: &str,
typ: &Type
) -> Self
Examples found in repository?
lower.rs (lines 1175-1182)
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
fn lower_subr_def(
&mut self,
sig: ast::SubrSignature,
body: ast::DefBody,
) -> LowerResult<hir::Def> {
log!(info "entered {}({sig})", fn_name!());
let t = self
.ctx
.outer
.as_ref()
.unwrap()
.get_current_scope_var(sig.ident.inspect())
.map(|vi| vi.t.clone())
.unwrap_or(Type::Failure);
match t {
Type::Subr(subr_t) => {
let params = self.lower_params(sig.params.clone())?;
if let Err(errs) = self.ctx.assign_params(¶ms, Some(subr_t)) {
self.errs.extend(errs);
}
if let Err(errs) = self.ctx.preregister(&body.block) {
self.errs.extend(errs);
}
match self.lower_block(body.block) {
Ok(block) => {
let found_body_t = block.ref_t();
let t = self.ctx.outer.as_mut().unwrap().assign_subr(
&sig,
body.id,
found_body_t,
)?;
let return_t = t.return_t().unwrap();
if return_t.union_types().is_some() && sig.return_t_spec.is_none() {
let warn = LowerWarning::union_return_type_warning(
self.input().clone(),
line!() as usize,
sig.loc(),
self.ctx.caused_by(),
sig.ident.inspect(),
&Context::readable_type(return_t),
);
self.warns.push(warn);
}
let mut ident = hir::Identifier::bare(sig.ident.dot, sig.ident.name);
ident.vi.t = t;
let sig = hir::SubrSignature::new(ident, params);
let body = hir::DefBody::new(body.op, block, body.id);
Ok(hir::Def::new(hir::Signature::Subr(sig), body))
}
Err(errs) => {
self.ctx.outer.as_mut().unwrap().assign_subr(
&sig,
ast::DefId(0),
&Type::Failure,
)?;
Err(errs)
}
}
}
Type::Failure => {
let params = self.lower_params(sig.params)?;
if let Err(errs) = self.ctx.assign_params(¶ms, None) {
self.errs.extend(errs);
}
if let Err(errs) = self.ctx.preregister(&body.block) {
self.errs.extend(errs);
}
self.ctx.outer.as_mut().unwrap().fake_subr_assign(
&sig.ident,
&sig.decorators,
Type::Failure,
)?;
let block = self.lower_block(body.block)?;
let ident = hir::Identifier::bare(sig.ident.dot, sig.ident.name);
let sig = hir::SubrSignature::new(ident, params);
let body = hir::DefBody::new(body.op, block, body.id);
Ok(hir::Def::new(hir::Signature::Subr(sig), body))
}
_ => unreachable_error!(LowerErrors, LowerError, self),
}
}sourcepub fn del_error(
input: Input,
errno: usize,
ident: &Identifier,
caused_by: String
) -> Self
pub fn del_error(
input: Input,
errno: usize,
ident: &Identifier,
caused_by: String
) -> Self
Examples found in repository?
context/register.rs (lines 1416-1421)
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
pub fn del(&mut self, ident: &hir::Identifier) -> CompileResult<()> {
if self.rec_get_const_obj(ident.inspect()).is_some()
|| self
.get_builtins()
.unwrap()
.get_local_kv(ident.inspect())
.is_some()
{
Err(TyCheckErrors::from(TyCheckError::del_error(
self.cfg.input.clone(),
line!() as usize,
ident,
self.caused_by(),
)))
} else if self.locals.get(ident.inspect()).is_some() {
let vi = self.locals.remove(ident.inspect()).unwrap();
self.deleted_locals.insert(ident.name.clone(), vi);
Ok(())
} else {
Err(TyCheckErrors::from(TyCheckError::no_var_error(
self.cfg.input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
self.get_similar_name(ident.inspect()),
)))
}
}sourcepub fn visibility_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
vis: Visibility
) -> Self
pub fn visibility_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
vis: Visibility
) -> Self
Examples found in repository?
context/inquire.rs (lines 797-804)
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
fn validate_visibility(
&self,
ident: &Identifier,
vi: &VarInfo,
input: &Input,
namespace: &str,
) -> SingleTyCheckResult<()> {
if ident.vis() != vi.vis {
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
vi.vis,
))
// check if the private variable is loaded from the other scope
} else if vi.vis.is_private()
&& &self.name[..] != "<builtins>"
&& &self.name[..] != namespace
&& !namespace.contains(&self.name[..])
{
log!(err "{namespace}/{}", self.name);
Err(TyCheckError::visibility_error(
input.clone(),
line!() as usize,
ident.loc(),
self.caused_by(),
ident.inspect(),
Private,
))
} else {
Ok(())
}
}sourcepub fn override_error<S: Into<String>>(
input: Input,
errno: usize,
name: &str,
name_loc: Location,
superclass: &Type,
caused_by: S
) -> Self
pub fn override_error<S: Into<String>>(
input: Input,
errno: usize,
name: &str,
name_loc: Location,
superclass: &Type,
caused_by: S
) -> Self
Examples found in repository?
lower.rs (lines 1559-1566)
1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
fn check_override(&mut self, class: &Type, impl_trait: Option<&Type>) {
if let Some(sups) = self.ctx.get_nominal_super_type_ctxs(class) {
// exclude the first one because it is the class itself
for sup in sups.into_iter().skip(1) {
for (method_name, vi) in self.ctx.locals.iter().chain(
self.ctx
.methods_list
.iter()
.flat_map(|(_, c)| c.locals.iter()),
) {
if let Some(sup_vi) = sup.get_current_scope_var(method_name.inspect()) {
// must `@Override`
if let Some(decos) = &vi.comptime_decos {
if decos.contains("Override") {
continue;
}
}
if sup_vi.impl_of.as_ref() != impl_trait {
continue;
}
self.errs.push(LowerError::override_error(
self.cfg.input.clone(),
line!() as usize,
method_name.inspect(),
method_name.loc(),
&mono(&sup.name), // TODO: get super type
self.ctx.caused_by(),
));
}
}
}
}
}sourcepub fn inheritance_error(
input: Input,
errno: usize,
class: String,
loc: Location,
caused_by: String
) -> Self
pub fn inheritance_error(
input: Input,
errno: usize,
class: String,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
lower.rs (lines 1519-1525)
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
fn check_inheritable(
cfg: &ErgConfig,
errs: &mut LowerErrors,
type_obj: &GenTypeObj,
sup_class: &hir::Expr,
sub_sig: &hir::Signature,
) {
if let TypeObj::Generated(gen) = type_obj.require_or_sup().unwrap() {
if let Some(impls) = gen.impls() {
if !impls.contains_intersec(&mono("InheritableType")) {
errs.push(LowerError::inheritance_error(
cfg.input.clone(),
line!() as usize,
sup_class.to_string(),
sup_class.loc(),
sub_sig.ident().inspect().into(),
));
}
} else {
errs.push(LowerError::inheritance_error(
cfg.input.clone(),
line!() as usize,
sup_class.to_string(),
sup_class.loc(),
sub_sig.ident().inspect().into(),
));
}
}
}sourcepub fn file_error(
input: Input,
errno: usize,
desc: String,
loc: Location,
caused_by: String,
hint: Option<String>
) -> Self
pub fn file_error(
input: Input,
errno: usize,
desc: String,
loc: Location,
caused_by: String,
hint: Option<String>
) -> Self
Examples found in repository?
error.rs (line 2246)
2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247
pub fn module_env_error(
input: Input,
errno: usize,
mod_name: &str,
loc: Location,
caused_by: String,
) -> Self {
let desc = switch_lang!(
"japanese" => format!("{mod_name}モジュールはお使いの環境をサポートしていません"),
"simplified_chinese" => format!("{mod_name}模块不支持您的环境"),
"traditional_chinese" => format!("{mod_name}模塊不支持您的環境"),
"english" => format!("module {mod_name} is not supported in your environment"),
);
Self::file_error(input, errno, desc, loc, caused_by, None)
}sourcepub fn module_env_error(
input: Input,
errno: usize,
mod_name: &str,
loc: Location,
caused_by: String
) -> Self
pub fn module_env_error(
input: Input,
errno: usize,
mod_name: &str,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
context/register.rs (lines 1327-1333)
1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
fn get_path(&self, mod_name: &Literal, __name__: Str) -> CompileResult<PathBuf> {
match Self::resolve_decl_path(&self.cfg, Path::new(&__name__[..])) {
Some(path) => {
if self.is_pystd_main_module(path.as_path())
&& !BUILTIN_PYTHON_MODS.contains(&&__name__[..])
{
let err = TyCheckError::module_env_error(
self.cfg.input.clone(),
line!() as usize,
&__name__,
mod_name.loc(),
self.caused_by(),
);
return Err(TyCheckErrors::from(err));
}
Ok(path)
}
None => {
if let Ok(path) = self.cfg.input.local_py_resolve(Path::new(&__name__[..])) {
// pylyzer is a static analysis tool for Python.
// It can convert a Python script to an Erg AST for code analysis.
// There is also an option to output the analysis result as `d.er`. Use this if the system have pylyzer installed.
match Command::new("pylyzer")
.arg("--dump-decl")
.arg(path.to_str().unwrap())
.output()
{
Ok(out) if out.status.success() => {
if let Some(path) =
Self::resolve_decl_path(&self.cfg, Path::new(&__name__[..]))
{
return Ok(path);
}
}
_ => {}
}
}
let err = TyCheckError::import_error(
self.cfg.input.clone(),
line!() as usize,
format!("module {__name__} not found"),
mod_name.loc(),
self.caused_by(),
self.mod_cache.as_ref().unwrap().get_similar_name(&__name__),
self.similar_builtin_py_mod_name(&__name__).or_else(|| {
self.py_mod_cache
.as_ref()
.unwrap()
.get_similar_name(&__name__)
}),
);
Err(TyCheckErrors::from(err))
}
}
}sourcepub fn import_error(
input: Input,
errno: usize,
desc: String,
loc: Location,
caused_by: String,
similar_erg_mod: Option<Str>,
similar_py_mod: Option<Str>
) -> Self
pub fn import_error(
input: Input,
errno: usize,
desc: String,
loc: Location,
caused_by: String,
similar_erg_mod: Option<Str>,
similar_py_mod: Option<Str>
) -> Self
Examples found in repository?
context/register.rs (lines 1246-1255)
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
fn import_erg_mod(&self, mod_name: &Literal) -> CompileResult<PathBuf> {
let __name__ = enum_unwrap!(mod_name.value.clone(), ValueObj::Str);
let mod_cache = self.mod_cache.as_ref().unwrap();
let py_mod_cache = self.py_mod_cache.as_ref().unwrap();
let path = match Self::resolve_real_path(&self.cfg, Path::new(&__name__[..])) {
Some(path) => path,
None => {
let err = TyCheckErrors::from(TyCheckError::import_error(
self.cfg.input.clone(),
line!() as usize,
format!("module {__name__} not found"),
mod_name.loc(),
self.caused_by(),
self.mod_cache.as_ref().unwrap().get_similar_name(&__name__),
self.similar_builtin_py_mod_name(&__name__)
.or_else(|| py_mod_cache.get_similar_name(&__name__)),
));
return Err(err);
}
};
if mod_cache.get(&path).is_some() {
return Ok(path);
}
let cfg = self.cfg.inherit(path.clone());
let src = cfg.input.read();
let mut builder =
HIRBuilder::new_with_cache(cfg, __name__, mod_cache.clone(), py_mod_cache.clone());
match builder.build(src, "exec") {
Ok(artifact) => {
mod_cache.register(
path.clone(),
Some(artifact.object),
builder.pop_mod_ctx().unwrap(),
);
}
Err(artifact) => {
if let Some(hir) = artifact.object {
mod_cache.register(path, Some(hir), builder.pop_mod_ctx().unwrap());
}
return Err(artifact.errors);
}
}
Ok(path)
}
fn similar_builtin_py_mod_name(&self, name: &Str) -> Option<Str> {
get_similar_name(BUILTIN_PYTHON_MODS.into_iter(), name).map(Str::rc)
}
fn is_pystd_main_module(&self, path: &Path) -> bool {
let mut path = PathBuf::from(path);
if path.ends_with("__init__.d.er") {
path.pop();
path.pop();
} else {
path.pop();
}
let pystd_path = erg_pystd_path();
path == pystd_path
}
/// e.g. http.d/client.d.er -> http.client
/// math.d.er -> math
fn mod_name(&self, path: &Path) -> Str {
let mut name = path
.file_name()
.unwrap()
.to_str()
.unwrap()
.trim_end_matches(".d.er")
.to_string();
for parent in path.components().rev().skip(1) {
let parent = parent.as_os_str().to_str().unwrap();
if parent.ends_with(".d") {
name = parent.trim_end_matches(".d").to_string() + "." + &name;
} else {
break;
}
}
Str::from(name)
}
fn get_path(&self, mod_name: &Literal, __name__: Str) -> CompileResult<PathBuf> {
match Self::resolve_decl_path(&self.cfg, Path::new(&__name__[..])) {
Some(path) => {
if self.is_pystd_main_module(path.as_path())
&& !BUILTIN_PYTHON_MODS.contains(&&__name__[..])
{
let err = TyCheckError::module_env_error(
self.cfg.input.clone(),
line!() as usize,
&__name__,
mod_name.loc(),
self.caused_by(),
);
return Err(TyCheckErrors::from(err));
}
Ok(path)
}
None => {
if let Ok(path) = self.cfg.input.local_py_resolve(Path::new(&__name__[..])) {
// pylyzer is a static analysis tool for Python.
// It can convert a Python script to an Erg AST for code analysis.
// There is also an option to output the analysis result as `d.er`. Use this if the system have pylyzer installed.
match Command::new("pylyzer")
.arg("--dump-decl")
.arg(path.to_str().unwrap())
.output()
{
Ok(out) if out.status.success() => {
if let Some(path) =
Self::resolve_decl_path(&self.cfg, Path::new(&__name__[..]))
{
return Ok(path);
}
}
_ => {}
}
}
let err = TyCheckError::import_error(
self.cfg.input.clone(),
line!() as usize,
format!("module {__name__} not found"),
mod_name.loc(),
self.caused_by(),
self.mod_cache.as_ref().unwrap().get_similar_name(&__name__),
self.similar_builtin_py_mod_name(&__name__).or_else(|| {
self.py_mod_cache
.as_ref()
.unwrap()
.get_similar_name(&__name__)
}),
);
Err(TyCheckErrors::from(err))
}
}
}sourcepub fn inner_typedef_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
pub fn inner_typedef_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
lower.rs (lines 1034-1039)
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
fn lower_def(&mut self, def: ast::Def) -> LowerResult<hir::Def> {
log!(info "entered {}({})", fn_name!(), def.sig);
if def.def_kind().is_class_or_trait() && self.ctx.kind != ContextKind::Module {
self.ctx.decls.remove(def.sig.ident().unwrap().inspect());
return Err(LowerErrors::from(LowerError::inner_typedef_error(
self.cfg.input.clone(),
line!() as usize,
def.loc(),
self.ctx.caused_by(),
)));
}
let name = if let Some(name) = def.sig.name_as_str() {
name.clone()
} else {
Str::ever("<lambda>")
};
if self
.ctx
.registered_info(&name, def.sig.is_const())
.is_some()
&& def.sig.vis().is_private()
{
return Err(LowerErrors::from(LowerError::reassign_error(
self.cfg.input.clone(),
line!() as usize,
def.sig.loc(),
self.ctx.caused_by(),
&name,
)));
}
let kind = ContextKind::from(def.def_kind());
let vis = def.sig.vis();
let res = match def.sig {
ast::Signature::Subr(sig) => {
let tv_cache = self
.ctx
.instantiate_ty_bounds(&sig.bounds, RegistrationMode::Normal)?;
self.ctx.grow(&name, kind, vis, Some(tv_cache));
self.lower_subr_def(sig, def.body)
}
ast::Signature::Var(sig) => {
self.ctx.grow(&name, kind, vis, None);
self.lower_var_def(sig, def.body)
}
};
// TODO: Context上の関数に型境界情報を追加
self.pop_append_errs();
// remove from decls regardless of success or failure to lower
self.ctx.decls.remove(&name);
res
}sourcepub fn declare_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
pub fn declare_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String
) -> Self
Examples found in repository?
declare.rs (lines 28-33)
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
fn declare_var(
&mut self,
sig: ast::VarSignature,
mut body: ast::DefBody,
) -> LowerResult<hir::Def> {
log!(info "entered {}({sig})", fn_name!());
if body.block.len() > 1 {
return Err(LowerErrors::from(LowerError::declare_error(
self.cfg().input.clone(),
line!() as usize,
body.block.loc(),
self.ctx.caused_by(),
)));
}
let chunk = self.declare_chunk(body.block.remove(0))?;
let py_name = if let hir::Expr::TypeAsc(tasc) = &chunk {
enum_unwrap!(tasc.expr.as_ref(), hir::Expr::Accessor)
.local_name()
.map(Str::rc)
} else {
sig.inspect().cloned()
};
let block = hir::Block::new(vec![chunk]);
let found_body_t = block.ref_t();
let ident = match &sig.pat {
ast::VarPattern::Ident(ident) => ident,
_ => unreachable!(),
};
let id = body.id;
self.ctx
.assign_var_sig(&sig, found_body_t, id, py_name.clone())?;
let mut ident = hir::Identifier::bare(ident.dot.clone(), ident.name.clone());
ident.vi.t = found_body_t.clone();
ident.vi.py_name = py_name;
let sig = hir::VarSignature::new(ident);
let body = hir::DefBody::new(body.op, block, body.id);
Ok(hir::Def::new(hir::Signature::Var(sig), body))
}
/// allowed: alias, import, const functions (e.g. Class)
fn declare_def(&mut self, def: ast::Def) -> LowerResult<hir::Def> {
log!(info "entered {}({})", fn_name!(), def.sig);
let name = if let Some(name) = def.sig.name_as_str() {
name.clone()
} else {
Str::ever("<lambda>")
};
if self
.ctx
.registered_info(&name, def.sig.is_const())
.is_some()
&& def.sig.vis().is_private()
{
return Err(LowerErrors::from(LowerError::reassign_error(
self.cfg().input.clone(),
line!() as usize,
def.sig.loc(),
self.ctx.caused_by(),
&name,
)));
}
#[allow(clippy::let_and_return)]
let res = match def.sig {
ast::Signature::Subr(sig) => {
return Err(LowerErrors::from(LowerError::declare_error(
self.cfg().input.clone(),
line!() as usize,
sig.loc(),
self.ctx.caused_by(),
)));
}
ast::Signature::Var(sig) => self.declare_var(sig, def.body),
};
// self.pop_append_errs();
res
}
fn declare_class_def(&mut self, _class_def: ast::ClassDef) -> LowerResult<hir::ClassDef> {
todo!()
}
fn fake_lower_obj(&self, obj: ast::Expr) -> LowerResult<hir::Expr> {
match obj {
ast::Expr::Accessor(ast::Accessor::Ident(ident)) => {
let acc = hir::Accessor::Ident(hir::Identifier::bare(ident.dot, ident.name));
Ok(hir::Expr::Accessor(acc))
}
ast::Expr::Accessor(ast::Accessor::Attr(attr)) => {
let obj = self.fake_lower_obj(*attr.obj)?;
let ident = hir::Identifier::bare(attr.ident.dot, attr.ident.name);
Ok(obj.attr_expr(ident))
}
other => Err(LowerErrors::from(LowerError::declare_error(
self.cfg().input.clone(),
line!() as usize,
other.loc(),
self.ctx.caused_by(),
))),
}
}
fn declare_ident(&mut self, tasc: ast::TypeAscription) -> LowerResult<hir::TypeAscription> {
log!(info "entered {}({})", fn_name!(), tasc);
let is_instance_ascription = tasc.is_instance_ascription();
let mut dummy_tv_cache = TyVarCache::new(self.ctx.level, &self.ctx);
match *tasc.expr {
ast::Expr::Accessor(ast::Accessor::Ident(mut ident)) => {
if self.cfg().python_compatible_mode {
ident.trim_end_proc_mark();
}
let py_name = Str::rc(ident.inspect().trim_end_matches('!'));
let t = self.ctx.instantiate_typespec(
&tasc.t_spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?;
t.lift();
let t = self.ctx.generalize_t(t);
if is_instance_ascription {
self.declare_instance(&ident, &t, py_name)?;
} else {
self.declare_subtype(&ident, &t)?;
}
let muty = Mutability::from(&ident.inspect()[..]);
let vis = ident.vis();
let py_name = Str::rc(ident.inspect().trim_end_matches('!'));
let vi = VarInfo::new(t, muty, vis, VarKind::Declared, None, None, Some(py_name));
let ident = hir::Identifier::new(ident.dot, ident.name, None, vi);
Ok(hir::Expr::Accessor(hir::Accessor::Ident(ident)).type_asc(tasc.t_spec))
}
ast::Expr::Accessor(ast::Accessor::Attr(mut attr)) => {
if self.cfg().python_compatible_mode {
attr.ident.trim_end_proc_mark();
}
let py_name = Str::rc(attr.ident.inspect().trim_end_matches('!'));
let t = self.ctx.instantiate_typespec(
&tasc.t_spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?;
let namespace = self.ctx.name.clone();
let ctx = self
.ctx
.get_mut_singular_ctx(attr.obj.as_ref(), &namespace)?;
ctx.assign_var_sig(
&ast::VarSignature::new(ast::VarPattern::Ident(attr.ident.clone()), None),
&t,
ast::DefId(0),
Some(py_name),
)?;
let obj = self.fake_lower_obj(*attr.obj)?;
let muty = Mutability::from(&attr.ident.inspect()[..]);
let vis = attr.ident.vis();
let py_name = Str::rc(attr.ident.inspect().trim_end_matches('!'));
let vi = VarInfo::new(t, muty, vis, VarKind::Declared, None, None, Some(py_name));
let ident = hir::Identifier::new(attr.ident.dot, attr.ident.name, None, vi);
let attr = obj.attr_expr(ident);
Ok(attr.type_asc(tasc.t_spec))
}
other => Err(LowerErrors::from(LowerError::declare_error(
self.cfg().input.clone(),
line!() as usize,
other.loc(),
self.ctx.caused_by(),
))),
}
}
fn declare_instance(
&mut self,
ident: &ast::Identifier,
t: &Type,
py_name: Str,
) -> LowerResult<()> {
// .X = 'x': Type
if ident.is_raw() {
return Ok(());
}
if ident.is_const() {
let vi = VarInfo::new(
t.clone(),
Mutability::Const,
ident.vis(),
VarKind::Declared,
None,
None,
Some(py_name.clone()),
);
self.ctx.decls.insert(ident.name.clone(), vi);
}
self.ctx.assign_var_sig(
&ast::VarSignature::new(ast::VarPattern::Ident(ident.clone()), None),
t,
ast::DefId(0),
Some(py_name),
)?;
match t {
Type::ClassType => {
let ty_obj = GenTypeObj::class(
mono(format!("{}{ident}", self.ctx.path())),
TypeObj::Builtin(Type::Uninited),
None,
);
self.ctx.register_gen_type(ident, ty_obj);
}
Type::TraitType => {
let ty_obj = GenTypeObj::trait_(
mono(format!("{}{ident}", self.ctx.path())),
TypeObj::Builtin(Type::Uninited),
None,
);
self.ctx.register_gen_type(ident, ty_obj);
}
_ => {}
}
Ok(())
}
fn declare_subtype(&mut self, ident: &ast::Identifier, trait_: &Type) -> LowerResult<()> {
if ident.is_raw() {
return Ok(());
}
if let Some((_, ctx)) = self.ctx.get_mut_type(ident.inspect()) {
ctx.register_marker_trait(trait_.clone());
Ok(())
} else {
Err(LowerErrors::from(LowerError::no_var_error(
self.cfg().input.clone(),
line!() as usize,
ident.loc(),
self.ctx.caused_by(),
ident.inspect(),
self.ctx.get_similar_name(ident.inspect()),
)))
}
}
fn declare_chunk(&mut self, expr: ast::Expr) -> LowerResult<hir::Expr> {
log!(info "entered {}", fn_name!());
match expr {
ast::Expr::Def(def) => Ok(hir::Expr::Def(self.declare_def(def)?)),
ast::Expr::ClassDef(class_def) => {
Ok(hir::Expr::ClassDef(self.declare_class_def(class_def)?))
}
ast::Expr::TypeAsc(tasc) => Ok(hir::Expr::TypeAsc(self.declare_ident(tasc)?)),
ast::Expr::Call(call)
if call
.additional_operation()
.map(|op| op.is_import())
.unwrap_or(false) =>
{
Ok(hir::Expr::Call(self.lower_call(call)?))
}
other => Err(LowerErrors::from(LowerError::declare_error(
self.cfg().input.clone(),
line!() as usize,
other.loc(),
self.ctx.caused_by(),
))),
}
}sourcepub fn invalid_type_cast_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
cast_to: &Type,
hint: Option<String>
) -> Self
pub fn invalid_type_cast_error(
input: Input,
errno: usize,
loc: Location,
caused_by: String,
name: &str,
cast_to: &Type,
hint: Option<String>
) -> Self
Examples found in repository?
context/register.rs (lines 1486-1494)
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
pub(crate) fn cast(
&mut self,
type_spec: ast::TypeSpec,
call: &mut hir::Call,
) -> TyCheckResult<()> {
let mut dummy_tv_cache = TyVarCache::new(self.level, self);
let cast_to = self.instantiate_typespec(
&type_spec,
None,
&mut dummy_tv_cache,
RegistrationMode::Normal,
false,
)?;
let lhs = enum_unwrap!(
call.args.get_mut_left_or_key("pred").unwrap(),
hir::Expr::BinOp
)
.lhs
.as_mut();
match (
self.supertype_of(lhs.ref_t(), &cast_to),
self.subtype_of(lhs.ref_t(), &cast_to),
) {
// assert 1 in {1}
(true, true) => Ok(()),
// assert x in Int (x: Nat)
(false, true) => Ok(()), // TODO: warn (needless)
// assert x in Nat (x: Int)
(true, false) => {
if let hir::Expr::Accessor(ref acc) = lhs {
self.change_var_type(acc, cast_to.clone())?;
}
match lhs.ref_t() {
Type::FreeVar(fv) if fv.is_linked() => {
let constraint = Constraint::new_subtype_of(cast_to);
fv.replace(FreeKind::new_unbound(self.level, constraint));
}
Type::FreeVar(fv) => {
let new_constraint = Constraint::new_subtype_of(cast_to);
fv.update_constraint(new_constraint);
}
_ => {
*lhs.ref_mut_t() = cast_to;
}
}
Ok(())
}
// assert x in Str (x: Int)
(false, false) => Err(TyCheckErrors::from(TyCheckError::invalid_type_cast_error(
self.cfg.input.clone(),
line!() as usize,
lhs.loc(),
self.caused_by(),
&lhs.to_string(),
&cast_to,
None,
))),
}
}Trait Implementations§
source§impl Clone for CompileError
impl Clone for CompileError
source§fn clone(&self) -> CompileError
fn clone(&self) -> CompileError
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for CompileError
impl Debug for CompileError
source§impl Display for CompileError
impl Display for CompileError
source§impl Error for CompileError
impl Error for CompileError
1.30.0 · source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more
1.0.0 · source§fn description(&self) -> &str
fn description(&self) -> &str
👎Deprecated since 1.42.0: use the Display impl or to_string()
source§impl ErrorDisplay for CompileError
impl ErrorDisplay for CompileError
fn core(&self) -> &ErrorCore
fn input(&self) -> &Input
source§fn caused_by(&self) -> &str
fn caused_by(&self) -> &str
The block name the error caused.
This will be None if the error occurred before semantic analysis.
fn write_to_stderr(&self)
fn write_to<W>(&self, w: &mut W)where
W: Write,
fn show(&self) -> String
source§impl From<CompileError> for CompileErrors
impl From<CompileError> for CompileErrors
source§fn from(err: CompileError) -> Self
fn from(err: CompileError) -> Self
Converts to this type from the input type.
source§impl From<ParserRunnerError> for CompileError
impl From<ParserRunnerError> for CompileError
source§fn from(err: ParserRunnerError) -> Self
fn from(err: ParserRunnerError) -> Self
Converts to this type from the input type.
source§impl FromIterator<CompileError> for CompileErrors
impl FromIterator<CompileError> for CompileErrors
source§fn from_iter<I: IntoIterator<Item = CompileError>>(iter: I) -> Self
fn from_iter<I: IntoIterator<Item = CompileError>>(iter: I) -> Self
Creates a value from an iterator. Read more