fez-lisp 1.5.64 → 1.5.65

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/package.json +1 -1
  2. package/src/check.js +101 -100
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "fez-lisp",
3
3
  "description": "Lisp interpreted & compiled to JavaScript",
4
4
  "author": "AT290690",
5
- "version": "1.5.64",
5
+ "version": "1.5.65",
6
6
  "type": "module",
7
7
  "main": "index.js",
8
8
  "keywords": [
package/src/check.js CHANGED
@@ -1466,13 +1466,14 @@ export const typeCheck = (ast) => {
1466
1466
  const isPredicate = getSuffix(name) === PREDICATE_SUFFIX
1467
1467
  resolveRetunType(returns, rem, RETURNS, isPredicate)
1468
1468
  }
1469
+ const rightHand = rest.at(-1)
1469
1470
  if (
1470
- rest.at(-1) &&
1471
- rest.at(-1)[0] &&
1472
- rest.at(-1)[0][TYPE] === APPLY &&
1473
- rest.at(-1)[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
1471
+ rightHand &&
1472
+ rightHand[0] &&
1473
+ rightHand[0][TYPE] === APPLY &&
1474
+ rightHand[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
1474
1475
  ) {
1475
- const n = rest.at(-1).length
1476
+ const n = rightHand.length
1476
1477
  env[name] = {
1477
1478
  [STATS]: {
1478
1479
  [TYPE_PROP]: [APPLY],
@@ -1491,15 +1492,16 @@ export const typeCheck = (ast) => {
1491
1492
  env[name][STATS].retried += 1
1492
1493
  stack.unshift(() => {
1493
1494
  checkReturnType()
1494
- check(rest.at(-1), env, exp)
1495
+ check(rightHand, env, exp)
1495
1496
  })
1496
- check(rest.at(-1), env, exp)
1497
+ check(rightHand, env, exp)
1497
1498
  } else {
1498
- check(rest.at(-1), env, exp)
1499
+ check(rightHand, env, exp)
1499
1500
  }
1500
1501
  } else {
1502
+ const isL = isLeaf(rightHand)
1501
1503
  // if (!(name in env)) {
1502
- if (rest[1][TYPE] === WORD) {
1504
+ if (isL && rightHand[TYPE] === WORD) {
1503
1505
  env[name] = env[rest[1][VALUE]]
1504
1506
 
1505
1507
  if (
@@ -1516,115 +1518,114 @@ export const typeCheck = (ast) => {
1516
1518
  warningStack.add(
1517
1519
  `${name} is assigned to ${rest[1][VALUE]} which ends in (${MUTATION_SUFFIX}) so ${name} must also end in (${MUTATION_SUFFIX}) (check #18)`
1518
1520
  )
1519
- } else {
1520
- const isL = isLeaf(rest.at(-1))
1521
- const right = isL ? rest.at(-1) : rest.at(-1)[0]
1522
- if (isL && right[TYPE] === ATOM) {
1523
- const isPredicate = getSuffix(name) === PREDICATE_SUFFIX
1524
- // This never happens
1525
- // if (
1526
- // isPredicate &&
1527
- // right[VALUE] !== TRUE &&
1528
- // right[VALUE] !== FALSE
1529
- // ) {
1530
- // }
1531
- env[name] = {
1532
- [STATS]: {
1533
- retried: 0,
1534
- [TYPE_PROP]: [ATOM],
1535
- [RETURNS]: [ATOM]
1536
- }
1537
- }
1538
- if (isPredicate) {
1539
- env[name][STATS][TYPE_PROP][1] = PREDICATE
1540
- env[name][STATS][RETURNS] = [ATOM, PREDICATE]
1521
+ } else if (isL && rightHand[TYPE] === ATOM) {
1522
+ const isPredicate = getSuffix(name) === PREDICATE_SUFFIX
1523
+ // This never happens
1524
+ // if (
1525
+ // isPredicate &&
1526
+ // right[VALUE] !== TRUE &&
1527
+ // right[VALUE] !== FALSE
1528
+ // ) {
1529
+ // }
1530
+ env[name] = {
1531
+ [STATS]: {
1532
+ retried: 0,
1533
+ [TYPE_PROP]: [ATOM],
1534
+ [RETURNS]: [ATOM]
1541
1535
  }
1542
- } else {
1543
- const isPredicate = getSuffix(name) === PREDICATE_SUFFIX
1544
- if (
1545
- right &&
1546
- right[VALUE] &&
1547
- getSuffix(right[VALUE]) === PREDICATE_SUFFIX &&
1548
- !isPredicate
1549
- )
1536
+ }
1537
+ if (isPredicate) {
1538
+ if (rightHand[VALUE] !== TRUE && rightHand !== FALSE) {
1550
1539
  warningStack.add(
1551
- `${name} is assigned to ${right[VALUE]} which ends in (${PREDICATE_SUFFIX}) so ${name} must also end in (${PREDICATE_SUFFIX}) (check #19)`
1540
+ `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but the (Atom) value is neither ${TRUE} or ${FALSE} (${stringifyArgs(
1541
+ exp
1542
+ )}) (check #14)`
1552
1543
  )
1553
- env[name] = {
1554
- [STATS]: {
1555
- retried: 0,
1556
- [TYPE_PROP]: [
1557
- isL
1558
- ? right[TYPE]
1559
- : env[right?.[VALUE]]?.[STATS]?.[RETURNS]?.[0] ??
1560
- UNKNOWN
1561
- ],
1562
- [RETURNS]: [UNKNOWN]
1563
- }
1564
- }
1565
- if (isPredicate) {
1544
+ } else {
1566
1545
  env[name][STATS][TYPE_PROP][1] = PREDICATE
1567
1546
  env[name][STATS][RETURNS] = [ATOM, PREDICATE]
1568
1547
  }
1569
- if (right && right[VALUE]) {
1570
- if (right[VALUE] === KEYWORDS.CALL_FUNCTION) {
1571
- if (isLeaf(rest.at(-1).at(-1))) {
1572
- const fnName = rest.at(-1).at(-1)[VALUE]
1573
- const fn = env[fnName]
1574
- if (
1575
- !isPredicate &&
1576
- fn[STATS][RETURNS][1] === PREDICATE
1577
- ) {
1578
- warningStack.add(
1579
- `${name} is assigned to ${fnName} which ends in (${PREDICATE_SUFFIX}) so ${name} must also end in (${PREDICATE_SUFFIX}) (check #24)`
1580
- )
1581
- } else if (
1582
- isPredicate &&
1583
- fn[STATS][RETURNS][1] !== PREDICATE
1584
- ) {
1585
- warningStack.add(
1586
- `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (check #25)`
1587
- )
1588
- }
1589
- env[name][STATS][TYPE_PROP] = fn[STATS][RETURNS]
1590
- env[name][STATS][RETURNS] = fn[STATS][RETURNS]
1591
- } else {
1592
- const body = rest.at(-1).at(-1).at(-1)
1593
- const rem = hasBlock(body) ? body.at(-1) : body
1594
- const returns = isLeaf(rem) ? rem : rem[0]
1595
- resolveRetunType(
1596
- returns,
1597
- rem,
1598
- TYPE_PROP,
1599
- isPredicate
1548
+ }
1549
+ } else {
1550
+ const right = rightHand[0]
1551
+ const isPredicate = getSuffix(name) === PREDICATE_SUFFIX
1552
+ if (
1553
+ right &&
1554
+ right[VALUE] &&
1555
+ getSuffix(right[VALUE]) === PREDICATE_SUFFIX &&
1556
+ !isPredicate
1557
+ )
1558
+ warningStack.add(
1559
+ `${name} is assigned to ${right[VALUE]} which ends in (${PREDICATE_SUFFIX}) so ${name} must also end in (${PREDICATE_SUFFIX}) (check #19)`
1560
+ )
1561
+ env[name] = {
1562
+ [STATS]: {
1563
+ retried: 0,
1564
+ [TYPE_PROP]: [
1565
+ isL
1566
+ ? right[TYPE]
1567
+ : env[right?.[VALUE]]?.[STATS]?.[RETURNS]?.[0] ??
1568
+ UNKNOWN
1569
+ ],
1570
+ [RETURNS]: [UNKNOWN]
1571
+ }
1572
+ }
1573
+ if (isPredicate) {
1574
+ env[name][STATS][TYPE_PROP][1] = PREDICATE
1575
+ env[name][STATS][RETURNS] = [ATOM, PREDICATE]
1576
+ }
1577
+ if (right && right[VALUE]) {
1578
+ if (right[VALUE] === KEYWORDS.CALL_FUNCTION) {
1579
+ if (isLeaf(rightHand.at(-1))) {
1580
+ const fnName = rightHand.at(-1)[VALUE]
1581
+ const fn = env[fnName]
1582
+ if (
1583
+ !isPredicate &&
1584
+ fn[STATS][RETURNS][1] === PREDICATE
1585
+ ) {
1586
+ warningStack.add(
1587
+ `${name} is assigned to ${fnName} which ends in (${PREDICATE_SUFFIX}) so ${name} must also end in (${PREDICATE_SUFFIX}) (check #24)`
1588
+ )
1589
+ } else if (
1590
+ isPredicate &&
1591
+ fn[STATS][RETURNS][1] !== PREDICATE
1592
+ ) {
1593
+ warningStack.add(
1594
+ `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (check #25)`
1600
1595
  )
1601
1596
  }
1597
+ env[name][STATS][TYPE_PROP] = fn[STATS][RETURNS]
1598
+ env[name][STATS][RETURNS] = fn[STATS][RETURNS]
1602
1599
  } else {
1603
- const body = rest.at(-1)
1600
+ const body = rightHand.at(-1).at(-1)
1604
1601
  const rem = hasBlock(body) ? body.at(-1) : body
1605
1602
  const returns = isLeaf(rem) ? rem : rem[0]
1606
1603
  resolveRetunType(returns, rem, TYPE_PROP, isPredicate)
1607
1604
  }
1608
- if (env[right[VALUE]]?.[STATS]?.[RETURNS]?.[1]) {
1609
- if (
1610
- env[right[VALUE]][STATS][RETURNS][1] ===
1611
- PREDICATE &&
1612
- !isPredicate
1613
- ) {
1614
- warningStack.add(
1615
- `${name} is assigned to the result of a (${toTypeNames(
1616
- PREDICATE
1617
- )}) so ${name} must end in (${PREDICATE_SUFFIX}) (check #23)`
1618
- )
1619
- }
1620
- env[name][STATS][RETURNS] =
1621
- env[right[VALUE]][STATS][RETURNS]
1605
+ } else {
1606
+ const body = rightHand
1607
+ const rem = hasBlock(body) ? body.at(-1) : body
1608
+ const returns = isLeaf(rem) ? rem : rem[0]
1609
+ resolveRetunType(returns, rem, TYPE_PROP, isPredicate)
1610
+ }
1611
+ if (env[right[VALUE]]?.[STATS]?.[RETURNS]?.[1]) {
1612
+ if (
1613
+ env[right[VALUE]][STATS][RETURNS][1] === PREDICATE &&
1614
+ !isPredicate
1615
+ ) {
1616
+ warningStack.add(
1617
+ `${name} is assigned to the result of a (${toTypeNames(
1618
+ PREDICATE
1619
+ )}) so ${name} must end in (${PREDICATE_SUFFIX}) (check #23)`
1620
+ )
1622
1621
  }
1622
+ env[name][STATS][RETURNS] =
1623
+ env[right[VALUE]][STATS][RETURNS]
1623
1624
  }
1624
1625
  }
1625
1626
  }
1626
1627
  // }
1627
- check(rest.at(-1), env, scope)
1628
+ check(rightHand, env, scope)
1628
1629
  }
1629
1630
  Types.set(withScope(name, env), () => formatType(name, env))
1630
1631
  }