fez-lisp 1.6.68 → 1.6.70

package/package.json

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

package/src/check.js

@@ -612,13 +612,60 @@ const resolveCondition = ({ rem, name, env, exp, prop, stack, check }) => {
       break
   }
 }
+const resolveGetterRec = ([head, tail], env, times = 0) => {
+  if (GET_ARRAY_INFERENCE_SET.has(head[VALUE])) {
+    return resolveGetterRec(tail, env, ++times)
+  } else {
+    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 }) => {
   const array = isLeaf(rem[1]) ? rem[1] : rem[1][0]
   if (!env[array[VALUE]] || !env[name]) return true
   switch (array[TYPE]) {
     case APPLY:
       // TODO: figure out recursively what is the inner type of all nested getters
-      if (GET_ARRAY_INFERENCE_SET.has(array[VALUE])) return true
+      if (GET_ARRAY_INFERENCE_SET.has(array[VALUE])) {
+        const rec = resolveGetterRec(rem, env)
+        if (!rec) return true
+        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 - 1
+            }) levels at (${stringifyArgs(exp)}) (check #1003)`
+          )
+        if (times === level - 1) {
+          setPropToType(env[name][STATS], prop, {
+            [TYPE_PROP]: types.length
+              ? [type, new SubType([types.at(-1)])]
+              : [UNKNOWN]
+          })
+        } else {
+          setPropToType(env[name][STATS], prop, {
+            [TYPE_PROP]: types.length
+              ? [COLLECTION, new SubType(types.slice(times))]
+              : [UNKNOWN]
+          })
+        }
+        return true
+      }
       if (
         getReturn(env[array[VALUE]][STATS]) === UNKNOWN ||
         getReturn(env[array[VALUE]][STATS]) === ANY
@@ -644,8 +691,12 @@ const resolveGetter = ({ rem, prop, name, env, caller, exp }) => {
           setPropToReturn(env[name][STATS], prop, {
             [RETURNS]: [f, new SubType(r)]
           })
-        } else return false
-      } else return false
+        } else if (rightSub.has(APPLY)) {
+          // TODOD: abstractions go here but what can we do with them
+          // perhaps show the signature?
+          setPropToAbstraction(env[name][STATS], prop)
+        }
+      }
       break
     case WORD:
       {
@@ -675,8 +726,12 @@ const resolveGetter = ({ rem, prop, name, env, caller, exp }) => {
             setPropToType(env[name][STATS], prop, {
               [TYPE_PROP]: [f, new SubType(r)]
             })
-          } else return false
-        } else return false
+          } else if (rightSub.has(APPLY)) {
+            // TODOD: abstractions go here but what can we do with them
+            // perhaps show the signature?
+            setPropToAbstraction(env[name][STATS], prop)
+          }
+        }
       }
       break
   }
@@ -837,11 +892,13 @@ const initArrayType = ({ rem, env }) => {
       ret[0].length = 0
       const subT = new SubType([COLLECTION])
       ret[0].push(COLLECTION, subT)
-      while (head && !isSubType(head[1])) {
-        subT.add(COLLECTION)
+      while (Array.isArray(head) && !isSubType(head[1])) {
+        if (head[0] === APPLY) subT.types.push(APPLY)
+        else subT.add(COLLECTION)
         head = head[0]
       }
-      if (head && head[1].types.length) subT.add(head[1].types[0])
+      if (Array.isArray(head) && head[1].types.length)
+        subT.add(head[1].types[0])
     }
     const [main, sub] = ret[0]
     if (isSubType(sub) && sub.types.at(-1) === COLLECTION) sub.types.pop()
@@ -910,8 +967,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]
@@ -1267,17 +1342,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]) &&
@@ -1322,9 +1403,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],
@@ -1334,12 +1415,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)

package/src/macros.js

@@ -114,6 +114,20 @@ export const deSuggarAst = (ast, scope) => {
               //       }
               //     }
               //       break
+              case PLACEHOLDER:
+                {
+                  exp.length = 0
+                  rest.reverse()
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 1) {
+                    if (i < rest.length - 1) {
+                      temp.push([APPLY, SUGGAR.GET_ARRAY], [], rest[i])
+                      temp = temp.at(-2)
+                    } else temp.push(...rest[i])
+                  }
+                  deSuggarAst(exp, scope)
+                }
+                break
               case KEYWORDS.GET_ARRAY:
                 if (rest.length === 1) {
                   exp[0][VALUE] = 'math:var-get'