fez-lisp 1.6.65 → 1.6.67

package/package.json

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

package/src/check.js

@@ -612,11 +612,24 @@ const resolveCondition = ({ rem, name, env, exp, prop, stack, check }) => {
       break
   }
 }
-const resolveGetter = ({ rem, prop, name, env }) => {
+const resolveGetter = ({ rem, prop, name, env, caller, exp }) => {
   const array = isLeaf(rem[1]) ? rem[1] : rem[1][0]
   if (!env[array[VALUE]] || !env[name]) return true
   switch (array[TYPE]) {
     case APPLY:
+      if (
+        getReturn(env[array[VALUE]][STATS]) === UNKNOWN ||
+        getReturn(env[array[VALUE]][STATS]) === ANY
+      )
+        return true
+      if (getReturn(env[array[VALUE]][STATS]) !== COLLECTION)
+        throw new TypeError(
+          `Incorrect type of argument (${0}) for (${caller}). Expected (${formatSubType(
+            getTypes(env[caller][STATS][ARGUMENTS][0][STATS])
+          )}) but got (${formatSubType(
+            getReturns(env[array[VALUE]][STATS])
+          )}) (${stringifyArgs(exp)}) (check #1001)`
+        )
       if (hasSubReturn(env[array[VALUE]][STATS])) {
         const rightSub = getSubReturn(env[array[VALUE]][STATS])
         const isAtom = rightSub.has(NUMBER) || rightSub.has(BOOLEAN)
@@ -634,6 +647,19 @@ const resolveGetter = ({ rem, prop, name, env }) => {
       break
     case WORD:
       {
+        if (
+          getType(env[array[VALUE]][STATS]) === UNKNOWN ||
+          getType(env[array[VALUE]][STATS]) === ANY
+        )
+          return true
+        if (getType(env[array[VALUE]][STATS]) !== COLLECTION)
+          throw new TypeError(
+            `Incorrect type of argument (${0}) for (${caller}). Expected (${formatSubType(
+              getTypes(env[caller][STATS][ARGUMENTS][0][STATS])
+            )}) but got (${formatSubType(
+              getType(env[array[VALUE]][STATS])
+            )}) (${stringifyArgs(exp)}) (check #1002)`
+          )
         if (hasSubType(env[array[VALUE]][STATS])) {
           const rightSub = getSubType(env[array[VALUE]][STATS])
           const isAtom =
@@ -802,6 +828,7 @@ const initArrayTypeRec = ({ rem, env }) => {
 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 (Array.isArray(ret[0][0])) {
       let head = ret[0][0]
@@ -818,12 +845,24 @@ const initArrayType = ({ rem, env }) => {
     if (isSubType(sub) && sub.types.at(-1) === COLLECTION) sub.types.pop()
     return {
       [TYPE_PROP]: [APPLY],
-      [RETURNS]: [COLLECTION, new SubType(isSubType(sub) ? [...sub] : [main])]
+      [RETURNS]: [
+        COLLECTION,
+        isCollection
+          ? new SubType(
+              isSubType(sub) ? [COLLECTION, ...sub] : [COLLECTION, main]
+            )
+          : new SubType(isSubType(sub) ? [...sub] : [main])
+      ]
     }
   } else
     return {
       [TYPE_PROP]: [APPLY],
-      [RETURNS]: [COLLECTION, new SubType([UNKNOWN])]
+      [RETURNS]: [
+        COLLECTION,
+        isCollection
+          ? new SubType([COLLECTION, UNKNOWN])
+          : new SubType([UNKNOWN])
+      ]
     }
 }
 const resolveReturnType = ({
@@ -870,7 +909,7 @@ const resolveReturnType = ({
       default:
         {
           if (GET_ARRAY_INFERENCE_SET.has(returns[VALUE]))
-            resolveGetter({ rem, prop, name, env })
+            resolveGetter({ rem, prop, name, env, caller: returns[VALUE], exp })
           checkPredicateNameDeep(name, exp, exp.slice(1), returns)
           // TODO: DRY
           const index = env[name][STATS][ARGUMENTS]