fez-lisp 1.6.69 → 1.6.71

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.6.69",
+  "version": "1.6.71",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/check.js

@@ -616,25 +616,23 @@ const resolveGetterRec = ([head, tail], env, times = 0) => {
   if (GET_ARRAY_INFERENCE_SET.has(head[VALUE])) {
     return resolveGetterRec(tail, env, ++times)
   } else {
-    switch (head) {
-      case APPLY:
-        break
-      case WORD:
-        {
-          if (env[tail][STATS][TYPE_PROP][0] === UNKNOWN) return
-          const types = env[tail][STATS][TYPE_PROP][1].types
-          const sub = types.at(-1)
-          const type =
-            sub === ATOM || sub === NUMBER || sub === BOOLEAN
-              ? ATOM
-              : sub === APPLY
-              ? APPLY
-              : COLLECTION
-          const len = types.length ? types.length + 1 : times + 1
-          return [times, len, type, types]
-        }
-        break
+    if (Array.isArray(head)) {
+      tail = head[VALUE]
+      head = head[TYPE]
     }
+    if (head !== WORD && head !== APPLY) return
+    const prop = head === WORD ? TYPE_PROP : RETURNS
+    if (!env[tail] || env[tail][STATS][prop][0] === UNKNOWN) return
+    const types = env[tail][STATS][prop][1].types
+    const sub = types.at(-1)
+    const type =
+      sub === ATOM || sub === NUMBER || sub === BOOLEAN
+        ? ATOM
+        : sub === APPLY
+        ? APPLY
+        : COLLECTION
+    const len = types.length ? types.length + 1 : times + 1
+    return [times, len, type, types]
   }
 }
 const resolveGetter = ({ rem, prop, name, env, caller, exp }) => {
@@ -649,9 +647,9 @@ const resolveGetter = ({ rem, prop, name, env, caller, exp }) => {
         const [times, level, type, types] = resolveGetterRec(rem, env)
         if (times >= level)
           throw new RangeError(
-            `(${caller}) is trying to access nested structure at level (${level}) which is deeper than it's (${times}) levels at (${stringifyArgs(
-              exp
-            )}) (check #1003)`
+            `(${caller}) is trying to access nested structure at level (${level}) which is deeper than it's (${
+              times - 1
+            }) levels at (${stringifyArgs(exp)}) (check #1003)`
           )
         if (times === level - 1) {
           setPropToType(env[name][STATS], prop, {
@@ -668,7 +666,6 @@ const resolveGetter = ({ rem, prop, name, env, caller, exp }) => {
         }
         return true
       }
-
       if (
         getReturn(env[array[VALUE]][STATS]) === UNKNOWN ||
         getReturn(env[array[VALUE]][STATS]) === ANY
@@ -889,7 +886,11 @@ const initArrayType = ({ rem, env }) => {
   const ret = initArrayTypeRec({ rem, env })
   const known = ret.find((x) => x[0] !== ANY && x[0] !== UNKNOWN)
   const isCollection = ret.length && ret[0] && ret[0][0] === COLLECTION
-  if (known && ret.length) {
+  if (
+    known &&
+    ret.length &&
+    !ret.some((x) => known[0][0] !== x[0][0] || known[0].length !== x[0].length)
+  ) {
     if (Array.isArray(ret[0][0])) {
       let head = ret[0][0]
       ret[0].length = 0
@@ -970,8 +971,26 @@ const resolveReturnType = ({
         break
       default:
         {
-          if (GET_ARRAY_INFERENCE_SET.has(returns[VALUE]))
-            resolveGetter({ rem, prop, name, env, caller: returns[VALUE], exp })
+          if (GET_ARRAY_INFERENCE_SET.has(returns[VALUE])) {
+            resolveGetter({
+              rem,
+              prop,
+              name,
+              env,
+              caller: returns[VALUE],
+              exp
+            })
+            retry(env[name][STATS], exp, stack, () => {
+              resolveGetter({
+                rem,
+                prop,
+                name,
+                env,
+                caller: returns[VALUE],
+                exp
+              })
+            })
+          }
           checkPredicateNameDeep(name, exp, exp.slice(1), returns)
           // TODO: DRY
           const index = env[name][STATS][ARGUMENTS]
@@ -1327,17 +1346,23 @@ export const typeCheck = (
               // If current scope is root then these are user defined types
               if (isLambda) {
                 const lambdaName = `${PLACEHOLDER}${name}`
-                check(
-                  [
-                    [APPLY, KEYWORDS.DEFINE_VARIABLE],
-                    [WORD, lambdaName],
-                    exp.at(-1)
-                  ],
-                  env,
-                  scope
-                )
+                const fn = [
+                  [APPLY, KEYWORDS.DEFINE_VARIABLE],
+                  [WORD, lambdaName],
+                  exp.at(-1)
+                ]
+                check(fn, env, scope)
                 const expected = env[name]
                 const actual = env[lambdaName]
+                if (expected[ARG_COUNT] !== actual[ARG_COUNT]) {
+                  throw new RangeError(
+                    `Incorrect number of arguments for (${
+                      expected[STATS][SIGNATURE]
+                    }) Expected (${expected[ARG_COUNT]}) but got (${
+                      actual[ARG_COUNT]
+                    }) (${stringifyArgs(exp)}) (check #1004)`
+                  )
+                }
                 const checkReturns = () => {
                   if (
                     !isUnknownReturn(actual[STATS]) &&
@@ -1382,9 +1407,9 @@ export const typeCheck = (
                 checkArgs()
                 // Check lambda body with defined types
                 const copy = Object.create(env)
-                for (let i = 0; i < env[name][STATS][ARGUMENTS].length; ++i) {
-                  const A = env[lambdaName][STATS][ARGUMENTS][i]
-                  const B = env[name][STATS][ARGUMENTS][i]
+                for (let i = 0; i < expected[STATS][ARGUMENTS].length; ++i) {
+                  const A = actual[STATS][ARGUMENTS][i]
+                  const B = expected[STATS][ARGUMENTS][i]
                   copy[A[STATS][SIGNATURE]] = {
                     [STATS]: {
                       [SIGNATURE]: A[STATS][SIGNATURE],
@@ -1394,12 +1419,12 @@ export const typeCheck = (
                   }
                 }
                 check(
-                  wrapInApplyLambda(exp.at(-1).slice(2)).at(-1),
+                  wrapInApplyLambda(
+                    exp.at(-1).slice(expected[ARG_COUNT] ? 2 : 1)
+                  ).at(-1),
                   copy,
                   scope
                 )
-                // console.log(exp.at(-1).slice(1))
-                // check(exp.at(-1), env, scope)
                 // Types.delete(`; ${rootScopeIndex} ${lambdaName}`)
               }
               typeSet(Types, name, env, exp)