fez-lisp 1.5.137 → 1.5.139

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 +166 -164
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.137",
5
+ "version": "1.5.139",
6
6
  "type": "module",
7
7
  "main": "index.js",
8
8
  "keywords": [
package/src/check.js CHANGED
@@ -224,10 +224,13 @@ export const setReturnToTypeRef = (stats, value) => {
224
224
  }
225
225
  export const setStatsRef = (a, b) => (a[STATS] = b[STATS])
226
226
  export const setTypeToReturnRef = (stats, value) => {
227
- return (
228
- (isUnknownType(stats) || isAnyType(stats)) &&
229
- (stats[TYPE_PROP] = value[RETURNS])
230
- )
227
+ // To prevent getters overwritting the array subtype
228
+ // Change main type if unknown
229
+ if (isUnknownType(stats) || isAnyType(stats))
230
+ stats[TYPE_PROP][0] = value[RETURNS][0]
231
+ // cange sub type if it doesn't have
232
+ if (!hasSubType(stats) || getSubType(stats).has(UNKNOWN))
233
+ stats[TYPE_PROP][1] = value[RETURNS][1]
231
234
  }
232
235
  export const setPropRef = (stats, prop, value) => {
233
236
  return (
@@ -424,16 +427,24 @@ const withScope = (name, scope) => {
424
427
  const chain = getScopeNames(scope)
425
428
  return `${chain.length === 1 ? '; ' : ''}${chain.join(' ')} ${name}`
426
429
  }
427
- const retry = (stats, ctx, stack, cb) => {
430
+ const retry = (stats, ctx, stack, cb, method = 'prepend') => {
428
431
  if (
429
432
  (isUnknownNotAnyType(stats) || isUnknownNotAnyReturn(stats)) &&
430
433
  stats.retried < MAX_RETRY_DEFINITION
431
434
  ) {
432
435
  stats.retried += 1
433
- stagger(stack, 'prepend', ctx, cb)
436
+ stagger(stack, method, ctx, cb)
437
+ }
438
+ }
439
+ const once = (stats, ctx, stack, cb, method = 'prepend') => {
440
+ if (
441
+ (isUnknownNotAnyType(stats) || isUnknownNotAnyReturn(stats)) &&
442
+ !stats.tried
443
+ ) {
444
+ stats.tried = true
445
+ stagger(stack, method, ctx, cb)
434
446
  }
435
447
  }
436
-
437
448
  const retryArgs = (stats, ctx, stack, cb) => {
438
449
  if (stats.counter < MAX_ARGUMENT_RETRY) {
439
450
  stats.counter++
@@ -620,7 +631,7 @@ const resolveGetter = ({ rem, prop, name, env }) => {
620
631
  setPropToSubReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
621
632
  } else if (!isAtom && isCollection) {
622
633
  setPropToReturn(env[name][STATS], env[array[VALUE]][STATS])
623
- }
634
+ } else return false
624
635
  } else return false
625
636
  break
626
637
  case WORD:
@@ -637,7 +648,7 @@ const resolveGetter = ({ rem, prop, name, env }) => {
637
648
  setPropToSubType(env[name][STATS], prop, env[array[VALUE]][STATS])
638
649
  } else if (!isAtom && isCollection) {
639
650
  setPropToType(env[name][STATS], env[array[VALUE]][STATS])
640
- }
651
+ } else return false
641
652
  } else return false
642
653
  }
643
654
  break
@@ -1310,190 +1321,181 @@ export const typeCheck = (ast) => {
1310
1321
  getTypes(env[name][STATS])
1311
1322
  )}) (${stringifyArgs(exp)}) (check #202)`
1312
1323
  )
1313
- else {
1314
- // TODO the special form will set type first but it
1315
- // might be known already
1316
- // example
1317
- // (let xs [])
1318
- // (let x (array:set-and-get! xs 0 100))
1319
- // (length x)
1320
-
1321
- // if (
1322
- // isUnknownType(env[name][STATS]) &&
1323
- // !env[name][STATS].tried
1324
- // ) {
1325
- // once(env[name][STATS], stack, () =>
1326
- // check(exp, env, scope)
1327
- // )
1328
- // }
1329
- if (isSpecial)
1330
- setType(env[name][STATS], args[i][STATS])
1331
- }
1332
1324
  }
1333
1325
  break
1334
- case ATOM: {
1335
- if (
1336
- !isUnknownType(args[i][STATS]) &&
1337
- rest[i][TYPE] !== args[i][STATS][TYPE_PROP][0]
1338
- )
1339
- throw new TypeError(
1340
- `Incorrect type of argument (${i}) for (${
1341
- first[VALUE]
1342
- }). Expected (${toTypeNames(
1343
- args[i][STATS][TYPE_PROP][0]
1344
- )}) but got (${toTypeNames(
1345
- rest[i][TYPE]
1346
- )}) (${stringifyArgs(exp)}) (check #2)`
1326
+ case ATOM:
1327
+ {
1328
+ if (
1329
+ !isUnknownType(args[i][STATS]) &&
1330
+ rest[i][TYPE] !== args[i][STATS][TYPE_PROP][0]
1347
1331
  )
1348
- else if (
1349
- hasSubType(args[i][STATS]) &&
1350
- getSubType(args[i][STATS]).has(PREDICATE) &&
1351
- !isAtomABoolean(rest[i][VALUE])
1352
- )
1353
- throw new TypeError(
1354
- `Incorrect type of argument (${i}) for (${
1355
- first[VALUE]
1356
- }). Expected (${formatSubType(
1357
- getTypes(args[i][STATS])
1358
- )}) but got (${
1359
- rest[i][TYPE] === ATOM
1360
- ? toTypeNames(rest[i][TYPE])
1361
- : formatSubType(
1362
- getTypes(env[rest[i][VALUE]][STATS])
1363
- )
1364
- }) (${stringifyArgs(exp)}) (check #203)`
1332
+ throw new TypeError(
1333
+ `Incorrect type of argument (${i}) for (${
1334
+ first[VALUE]
1335
+ }). Expected (${toTypeNames(
1336
+ args[i][STATS][TYPE_PROP][0]
1337
+ )}) but got (${toTypeNames(
1338
+ rest[i][TYPE]
1339
+ )}) (${stringifyArgs(exp)}) (check #2)`
1340
+ )
1341
+ else if (
1342
+ hasSubType(args[i][STATS]) &&
1343
+ getSubType(args[i][STATS]).has(PREDICATE) &&
1344
+ !isAtomABoolean(rest[i][VALUE])
1365
1345
  )
1346
+ throw new TypeError(
1347
+ `Incorrect type of argument (${i}) for (${
1348
+ first[VALUE]
1349
+ }). Expected (${formatSubType(
1350
+ getTypes(args[i][STATS])
1351
+ )}) but got (${
1352
+ rest[i][TYPE] === ATOM
1353
+ ? toTypeNames(rest[i][TYPE])
1354
+ : formatSubType(
1355
+ getTypes(env[rest[i][VALUE]][STATS])
1356
+ )
1357
+ }) (${stringifyArgs(exp)}) (check #203)`
1358
+ )
1359
+ }
1366
1360
  break
1367
- }
1368
- case APPLY: {
1369
- const name = rest[i][VALUE]
1370
- if (!env[name]) continue
1371
- if (
1372
- !isUnknownType(args[i][STATS]) &&
1373
- !isUnknownType(env[name][STATS]) &&
1374
- env[name][STATS][ARG_COUNT] !== VARIADIC
1375
- ) {
1361
+ case APPLY:
1362
+ {
1363
+ const name = rest[i][VALUE]
1364
+ if (!env[name]) continue
1376
1365
  if (
1377
- env[name][STATS][ARG_COUNT] !==
1378
- args[i][STATS][ARG_COUNT]
1366
+ !isUnknownType(args[i][STATS]) &&
1367
+ !isUnknownType(env[name][STATS]) &&
1368
+ env[name][STATS][ARG_COUNT] !== VARIADIC
1379
1369
  ) {
1380
- if (args[i][STATS][ARG_COUNT] === undefined)
1381
- throw new TypeError(
1382
- `Incorrect type for argument of (${
1383
- first[VALUE]
1384
- }) at position (${i}). Expected (${
1385
- STATIC_TYPES.ABSTRACTION
1386
- }) but got (${toTypeNames(
1387
- getType(args[i][STATS])
1388
- )}) (${stringifyArgs(exp)}) (check #111)`
1389
- )
1390
- else if (getType(args[i][STATS]) === APPLY)
1370
+ if (
1371
+ env[name][STATS][ARG_COUNT] !==
1372
+ args[i][STATS][ARG_COUNT]
1373
+ ) {
1374
+ if (args[i][STATS][ARG_COUNT] === undefined)
1375
+ throw new TypeError(
1376
+ `Incorrect type for argument of (${
1377
+ first[VALUE]
1378
+ }) at position (${i}). Expected (${
1379
+ STATIC_TYPES.ABSTRACTION
1380
+ }) but got (${toTypeNames(
1381
+ getType(args[i][STATS])
1382
+ )}) (${stringifyArgs(exp)}) (check #111)`
1383
+ )
1384
+ else if (getType(args[i][STATS]) === APPLY)
1385
+ throw new TypeError(
1386
+ `Incorrect number of arguments for (${
1387
+ args[i][STATS][SIGNATURE]
1388
+ }) the (${
1389
+ KEYWORDS.ANONYMOUS_FUNCTION
1390
+ }) argument of (${
1391
+ first[VALUE]
1392
+ }) at position (${i}). Expected (= ${
1393
+ args[i][STATS][ARG_COUNT]
1394
+ }) but got ${
1395
+ env[name][STATS][ARG_COUNT]
1396
+ } (${stringifyArgs(exp)}) (check #778)`
1397
+ )
1398
+ }
1399
+ }
1400
+ // DEFINED LAMBDAS TYPE CHECKING
1401
+ // #C1
1402
+ // TODO delete this maybe
1403
+ // It will not be possilbe to know return type
1404
+ const match1 = () => {
1405
+ const actual = env[name]
1406
+ const expected = args[i]
1407
+ if (
1408
+ !isUnknownReturn(expected[STATS]) &&
1409
+ !isUnknownReturn(actual[STATS]) &&
1410
+ !equalsReturns(expected[STATS], actual[STATS])
1411
+ ) {
1391
1412
  throw new TypeError(
1392
- `Incorrect number of arguments for (${
1393
- args[i][STATS][SIGNATURE]
1413
+ `Incorrect return type for (${
1414
+ expected[STATS][SIGNATURE]
1394
1415
  }) the (${
1395
1416
  KEYWORDS.ANONYMOUS_FUNCTION
1396
1417
  }) argument of (${
1397
1418
  first[VALUE]
1398
- }) at position (${i}). Expected (= ${
1399
- args[i][STATS][ARG_COUNT]
1400
- }) but got ${
1401
- env[name][STATS][ARG_COUNT]
1402
- } (${stringifyArgs(exp)}) (check #778)`
1403
- )
1404
- }
1405
- }
1406
- // DEFINED LAMBDAS TYPE CHECKING
1407
- // #C1
1408
- // TODO delete this maybe
1409
- // It will not be possilbe to know return type
1410
- const match1 = () => {
1411
- const actual = env[name]
1412
- const expected = args[i]
1413
- if (
1414
- !isUnknownReturn(expected[STATS]) &&
1415
- !isUnknownReturn(actual[STATS]) &&
1416
- !equalsReturns(expected[STATS], actual[STATS])
1417
- ) {
1418
- throw new TypeError(
1419
- `Incorrect return type for (${
1420
- expected[STATS][SIGNATURE]
1421
- }) the (${
1422
- KEYWORDS.ANONYMOUS_FUNCTION
1423
- }) argument of (${
1424
- first[VALUE]
1425
- }) at position (${i}). Expected (${toTypeNames(
1426
- getReturn(expected[STATS])
1427
- )}) but got (${toTypeNames(
1428
- getReturn(actual[STATS])
1429
- )}) (${stringifyArgs(exp)}) (check #782)`
1430
- )
1431
- } else
1432
- retry(actual[STATS], [first, env], stack, match1)
1433
- }
1434
- match1()
1435
- for (
1436
- let j = 0;
1437
- j < args[i][STATS][ARGUMENTS].length;
1438
- ++j
1439
- ) {
1440
- const match2 = () => {
1441
- const actual = env[name][STATS][ARGUMENTS][j]
1442
- const expected = args[i][STATS][ARGUMENTS][j]
1443
- if (
1444
- !isUnknownType(actual[STATS]) &&
1445
- !isUnknownType(expected[STATS]) &&
1446
- !equalsTypes(actual[STATS], expected[STATS])
1447
- )
1448
- throw new TypeError(
1449
- `Incorrect type for (${
1450
- KEYWORDS.ANONYMOUS_FUNCTION
1451
- }) (${
1452
- args[i][STATS][SIGNATURE]
1453
- }) argument at position (${j}) named as (${
1454
- actual[STATS][SIGNATURE]
1455
- }). Expected (${toTypeNames(
1456
- getType(expected[STATS])
1419
+ }) at position (${i}). Expected (${toTypeNames(
1420
+ getReturn(expected[STATS])
1457
1421
  )}) but got (${toTypeNames(
1458
- getType(actual[STATS])
1459
- )}) (${stringifyArgs(exp)}) (check #781)`
1422
+ getReturn(actual[STATS])
1423
+ )}) (${stringifyArgs(exp)}) (check #782)`
1460
1424
  )
1461
- else
1425
+ } else
1462
1426
  retry(
1463
1427
  actual[STATS],
1464
1428
  [first, env],
1465
1429
  stack,
1466
- match2
1430
+ match1
1431
+ )
1432
+ }
1433
+ match1()
1434
+ for (
1435
+ let j = 0;
1436
+ j < args[i][STATS][ARGUMENTS].length;
1437
+ ++j
1438
+ ) {
1439
+ const match2 = () => {
1440
+ const actual = env[name][STATS][ARGUMENTS][j]
1441
+ const expected = args[i][STATS][ARGUMENTS][j]
1442
+ if (
1443
+ !isUnknownType(actual[STATS]) &&
1444
+ !isUnknownType(expected[STATS]) &&
1445
+ !equalsTypes(actual[STATS], expected[STATS])
1467
1446
  )
1447
+ throw new TypeError(
1448
+ `Incorrect type for (${
1449
+ KEYWORDS.ANONYMOUS_FUNCTION
1450
+ }) (${
1451
+ args[i][STATS][SIGNATURE]
1452
+ }) argument at position (${j}) named as (${
1453
+ actual[STATS][SIGNATURE]
1454
+ }). Expected (${toTypeNames(
1455
+ getType(expected[STATS])
1456
+ )}) but got (${toTypeNames(
1457
+ getType(actual[STATS])
1458
+ )}) (${stringifyArgs(exp)}) (check #781)`
1459
+ )
1460
+ else
1461
+ retry(
1462
+ actual[STATS],
1463
+ [first, env],
1464
+ stack,
1465
+ match2
1466
+ )
1467
+ }
1468
+ match2()
1468
1469
  }
1469
- match2()
1470
1470
  }
1471
- }
1471
+ break
1472
1472
  }
1473
- if (!isSpecial) {
1473
+ if (rest[i][TYPE] !== ATOM) {
1474
1474
  const name = rest[i][VALUE]
1475
- if (isUnknownType(args[i][STATS])) {
1476
- retry(args[i][STATS], [first, env], stack, () =>
1477
- check(exp, env, scope)
1478
- )
1479
- }
1480
- // TOODO maybe we don't need this
1475
+ if (!env[name]) return
1476
+ if (
1477
+ // when it's a special form and it's not equal
1478
+ // or failed the boolean subtype case
1479
+ isSpecial &&
1480
+ (!equalsTypes(args[i][STATS], env[name][STATS]) ||
1481
+ !notABooleanType(args[i][STATS], env[name][STATS]))
1482
+ )
1483
+ setType(env[name][STATS], args[i][STATS])
1481
1484
  else if (
1482
- env[name] &&
1483
- !isUnknownType(args[i][STATS]) &&
1484
- isUnknownType(env[name][STATS]) &&
1485
- getType(args[i][STATS]) !== APPLY
1486
- ) {
1487
- // REFF ASSIGMENT
1488
- setTypeRef(env[name][STATS], args[i][STATS])
1489
- } else if (
1490
- env[name] &&
1491
1485
  !isUnknownType(args[i][STATS]) &&
1492
1486
  isUnknownType(env[name][STATS])
1493
1487
  ) {
1494
- setStatsRef(env[rest[i][VALUE]], args[i])
1488
+ // REFF ASSIGMENT
1489
+ if (getType(args[i][STATS]) !== APPLY)
1490
+ setTypeRef(env[name][STATS], args[i][STATS])
1491
+ else setStatsRef(env[rest[i][VALUE]], args[i])
1495
1492
  }
1496
1493
  }
1494
+ if (isUnknownType(args[i][STATS])) {
1495
+ retry(args[i][STATS], [first, env], stack, () =>
1496
+ check(exp, env, scope)
1497
+ )
1498
+ }
1497
1499
  } else {
1498
1500
  const name = rest[i][0][VALUE]
1499
1501
  if (!env[name]) continue