fez-lisp 1.5.31 → 1.5.32

package/package.json

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

package/src/check.js

@@ -376,8 +376,7 @@ export const typeCheck = (ast) => {
     }
   }
   const errorStack = new Map()
-  const withScope = (name, env) =>
-    `${env[SCOPE_NAME] ?? root[SCOPE_NAME]}_${name}`
+  const withScope = (name, scope) => `${scope[SCOPE_NAME]}_${name}`
 
   const stack = []
   const check = (exp, env, scope) => {
@@ -402,48 +401,58 @@ export const typeCheck = (ast) => {
           switch (first[VALUE]) {
             case KEYWORDS.DEFINE_VARIABLE:
               {
-                if (
-                  rest.length &&
-                  rest.at(-1).length &&
-                  rest.at(-1)[0][TYPE] === APPLY &&
-                  rest.at(-1)[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
-                ) {
-                  const name = rest[0][VALUE]
-                  const n = rest.at(-1).length
-                  env[name] = {
-                    [STATS]: {
-                      type: APPLY,
-                      [ARGS_COUNT]: n - 2,
-                      [ARGS]: []
-                    }
-                  }
-                  if (name[name.length - 1] === PREDICATE_SUFFIX)
-                    env[name][STATS][SUBTYPE] = PREDICATE
-
-                  scope = exp
-                  if (env[SCOPE_NAME]) {
-                    const key = withScope(name, scope)
-                    if (errorStack.has(key)) errorStack.delete(key)
-                  }
-                  check(rest.at(-1), env, scope)
+                if (rest.length !== 2) {
+                  throw new TypeError(
+                    `Incorrect number of arguments for (${
+                      first[VALUE]
+                    }). Expected (= 2) but got ${rest.length} (${stringifyArgs(
+                      exp
+                    )}) (check #10)`
+                  )
                 } else {
-                  const name = rest[0][VALUE]
-                  if (!(name in env)) {
-                    if (rest[1][TYPE] === WORD) env[name] = env[rest[1][VALUE]]
-                    else
-                      env[name] = {
-                        [STATS]: {
-                          type: isLeaf(rest.at(-1))
-                            ? rest.at(-1)[TYPE]
-                            : env[rest.at(-1)[0]?.[VALUE]]?.[STATS]?.[
-                                RETURNS
-                              ] ?? UNKNOWN
-                        }
+                  if (
+                    rest.at(-1).length &&
+                    rest.at(-1)[0][TYPE] === APPLY &&
+                    rest.at(-1)[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
+                  ) {
+                    const name = rest[0][VALUE]
+                    const n = rest.at(-1).length
+                    env[name] = {
+                      [STATS]: {
+                        type: APPLY,
+                        [ARGS_COUNT]: n - 2,
+                        [ARGS]: []
                       }
-                  }
-                  if (env[SCOPE_NAME]) {
+                    }
+                    if (name[name.length - 1] === PREDICATE_SUFFIX)
+                      env[name][STATS][SUBTYPE] = PREDICATE
                     const key = withScope(name, scope)
                     if (errorStack.has(key)) errorStack.delete(key)
+                    scope = exp
+                  } else {
+                    const name = rest[0][VALUE]
+                    if (!(name in env)) {
+                      if (rest[1][TYPE] === WORD)
+                        env[name] = env[rest[1][VALUE]]
+                      else
+                        env[name] = {
+                          [STATS]: {
+                            type: isLeaf(rest.at(-1))
+                              ? rest.at(-1)[TYPE]
+                              : env[rest.at(-1)[0]?.[VALUE]]?.[STATS]?.[
+                                  RETURNS
+                                ] ?? UNKNOWN
+                          }
+                        }
+                    }
+                    // if (name === 'math:decimal-scaling') {
+                    //   const key = withScope(name, scope)
+                    //   if (errorStack.has(key)) errorStack.delete(key)
+                    // }
+                    // if (scope[SCOPE_NAME]) {
+                    // const key = withScope(name, scope)
+                    // if (errorStack.has(key)) errorStack.delete(key)
+                    // }
                   }
                   check(rest.at(-1), env, scope)
                 }
@@ -464,11 +473,13 @@ export const typeCheck = (ast) => {
                 const copy = Object.create(env)
                 if (isLeaf(scope[1])) {
                   copy[SCOPE_NAME] = scope[1][VALUE]
-                } else
+                } else {
                   copy[SCOPE_NAME] = performance
                     .now()
                     .toString()
                     .replace('.', 0)
+                }
+
                 for (const param of params) {
                   copy[param[VALUE]] = { [STATS]: { type: UNKNOWN } }
                   if (env[copy[SCOPE_NAME]])

package/src/macros.js

@@ -619,7 +619,6 @@ export const deSuggarAst = (ast, scope) => {
                       ]
                       deSuggarAst(exp[exp.length - 1])
                     } else if (prefix === OPTIMIZATIONS.CACHE) {
-                      // TODO: Make this
                       const args = last.slice(1, -1)
                       const newName = `*${performance
                         .now()
@@ -810,7 +809,7 @@ export const deSuggarAst = (ast, scope) => {
 export const replaceStrings = (source) => {
   // const quotes = source.match(/"(.*?)"/g)
   const quotes = source.match(/"(?:.*?(\n|\r))*?.*?"/g)
-  // TODO handle escaping
+  // TODO: handle escaping
   if (quotes)
     for (const q of quotes)
       source = source.replaceAll(

package/src/utils.js

@@ -195,8 +195,34 @@ const extractDeps = (visited, deps) =>
     .map((x) => deps.get(x))
     .sort((a, b) => a.index - b.index)
     .map((x) => x.value)
-const toIgnore = (ast) =>
-  ast.filter(([x]) => isDefinition(x)).map(([_, x]) => x[VALUE])
+const toIgnore = (ast) => {
+  const out = []
+  const dfs = (exp) => {
+    const [head, ...tail] = isLeaf(exp) ? [exp] : exp
+    if (head == undefined) return []
+    switch (head[TYPE]) {
+      case WORD:
+        break
+      case ATOM:
+        break
+      case APPLY:
+        {
+          switch (head[VALUE]) {
+            case KEYWORDS.DEFINE_VARIABLE:
+              out.push(tail[0][VALUE])
+              break
+            default:
+              for (const r of tail) dfs(r)
+              break
+          }
+        }
+        break
+    }
+  }
+  dfs(ast[0])
+  return out
+  // ast.filter(([x]) => isDefinition(x)).map(([_, x]) => x[VALUE])
+}
 export const treeShake = (ast, libs) => {
   const deps = toDeps(libs)
   const visited = new Set()