fez-lisp 1.6.64 → 1.6.66

package/package.json

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

package/src/check.js

@@ -72,7 +72,6 @@ export const identity = (name) => [
 ]
 export const typeSetDefaultFunction = (Types, name, env, exp) =>
   Types.set(withScope(name, env), () => formatType(name, env))
-
 const returnType = (rest) => {
   const body = rest.at(-1)
   const rem = hasBlock(body) ? body.at(-1) : body
@@ -218,6 +217,12 @@ export const setReturnToTypeRef = (stats, value) => {
   )
 }
 export const setStats = (a, b) => (a[STATS] = b[STATS])
+export const cloneStats = (name, x) => ({
+  [STATS]: {
+    ...x[STATS],
+    [SIGNATURE]: name
+  }
+})
 export const setStatsRef = (a, b) => (a[STATS] = b[STATS])
 export const setTypeToReturnRef = (stats, value) => {
   // To prevent getters overwritting the array subtype
@@ -607,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)
@@ -629,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 =
@@ -687,11 +718,17 @@ const resolveSetter = (first, rest, env, stack) => {
       case WORD:
         if (env[right[VALUE]]) {
           if (hasSubType(env[right[VALUE]][STATS])) {
-            if (currentSubType.has(UNKNOWN))
-              current[STATS][TYPE_PROP][1] = new SubType([
-                ...getSubType(env[right[VALUE]][STATS])
-              ])
-            else if (!equalSubTypes(current[STATS], env[right[VALUE]][STATS]))
+            if (currentSubType.has(UNKNOWN)) {
+              if (env[right[VALUE]][STATS][TYPE_PROP][0] === COLLECTION) {
+                current[STATS][TYPE_PROP][1] = new SubType([
+                  COLLECTION,
+                  ...getSubType(env[right[VALUE]][STATS]).types
+                ])
+              } else
+                current[STATS][TYPE_PROP][1] = new SubType(
+                  getSubType(env[right[VALUE]][STATS]).types
+                )
+            } else if (!equalSubTypes(current[STATS], env[right[VALUE]][STATS]))
               throw new TypeError(
                 `Incorrect array type at (${
                   first[VALUE]
@@ -701,9 +738,9 @@ const resolveSetter = (first, rest, env, stack) => {
                   getTypes(env[right[VALUE]][STATS])
                 )}) (${stringifyArgs([first, rest])}) (check #198)`
               )
-            current[STATS][TYPE_PROP][1] = new SubType(
-              getSubType(env[right[VALUE]][STATS])
-            )
+            // current[STATS][TYPE_PROP][1] = new SubType(
+            //   getSubType(env[right[VALUE]][STATS])
+            // )
           } else
             retry(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
               resolveSetter(first, rest, env, stack)
@@ -722,11 +759,17 @@ const resolveSetter = (first, rest, env, stack) => {
             break
           }
           if (hasSubReturn(env[right[VALUE]][STATS])) {
-            if (currentSubType.has(UNKNOWN))
-              current[STATS][TYPE_PROP][1] = new SubType([
-                ...getSubReturn(env[right[VALUE]][STATS])
-              ])
-            else if (
+            if (currentSubType.has(UNKNOWN)) {
+              if (env[right[VALUE]][STATS][RETURNS][0] === COLLECTION) {
+                current[STATS][TYPE_PROP][1] = new SubType([
+                  COLLECTION,
+                  ...getSubReturn(env[right[VALUE]][STATS]).types
+                ])
+              } else
+                current[STATS][TYPE_PROP][1] = new SubType(
+                  getSubReturn(env[right[VALUE]][STATS]).types
+                )
+            } else if (
               !equalSubTypesWithSubReturn(
                 current[STATS],
                 env[right[VALUE]][STATS]
@@ -741,9 +784,9 @@ const resolveSetter = (first, rest, env, stack) => {
                   getReturns(env[right[VALUE]][STATS])
                 )}) (${stringifyArgs([first, rest])}) (check #198)`
               )
-            current[STATS][TYPE_PROP][1] = new SubType([
-              ...getSubReturn(env[right[VALUE]][STATS])
-            ])
+            // current[STATS][TYPE_PROP][1] = new SubType([
+            //   ...getSubReturn(env[right[VALUE]][STATS])
+            // ])
           }
           // else
           // retry(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
@@ -753,6 +796,7 @@ const resolveSetter = (first, rest, env, stack) => {
         break
     }
     setTypeToCollection(current[STATS])
+
     // // Retry setting the sub-type if infered it out later
     // if (!hasSubType(current[STATS]) || getSubType(current[STATS]).has(UNKNOWN))
     //   retry(current[STATS], [first[VALUE], rest], stack, () =>
@@ -852,7 +896,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]
@@ -1421,7 +1465,6 @@ export const typeCheck = (
               check(rightHand, env, scope)
             }
             typeSet(Types, name, env, exp)
-            // Types.set(withScope(name, env), () => formatType(name, env))
             break
           case KEYWORDS.ANONYMOUS_FUNCTION:
             {