fez-lisp 1.5.31 → 1.5.33

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.33",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/check.js

@@ -61,7 +61,6 @@ export const typeCheck = (ast) => {
     [DEBUG.SET_THEME]: {
       [STATS]: { type: APPLY, [ARGS_COUNT]: VARIADIC, [RETURNS]: UNKNOWN }
     },
-    [SCOPE_NAME]: performance.now().toString().replace('.', 0),
     [KEYWORDS.BLOCK]: {
       [STATS]: { type: APPLY, [ARGS_COUNT]: VARIADIC, [RETURNS]: UNKNOWN }
     },
@@ -376,8 +375,29 @@ export const typeCheck = (ast) => {
     }
   }
   const errorStack = new Map()
-  const withScope = (name, env) =>
-    `${env[SCOPE_NAME] ?? root[SCOPE_NAME]}_${name}`
+  // const isDefinitionOfAFunction = (head, tail) =>
+  //   head[TYPE] === APPLY &&
+  //   head[VALUE] === KEYWORDS.DEFINE_VARIABLE &&
+  //   tail.at(-1)[0][TYPE] === APPLY &&
+  //   tail.at(-1)[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
+  const getScopeNames = (scope) => {
+    const scopeNames = []
+    let current = scope
+
+    while (current) {
+      if (current[SCOPE_NAME]) {
+        scopeNames.push(current[SCOPE_NAME])
+      }
+      current = Object.getPrototypeOf(current)
+    }
+    return scopeNames.reverse()
+  }
+  const withScope = (name, scope) => {
+    const chain = getScopeNames(scope)
+    const str = `${chain.join('_')}_${name}`
+    // console.log({ str })
+    return { str, chain }
+  }
 
   const stack = []
   const check = (exp, env, scope) => {
@@ -386,14 +406,15 @@ export const typeCheck = (ast) => {
       switch (first[TYPE]) {
         case WORD:
           {
-            const key = withScope(first[VALUE], scope)
-            if (env[first[VALUE]] === undefined) {
-              errorStack.set(
-                key,
-                `Trying to access undefined variable ${first[VALUE]} (check #11)`
-              )
-            }
-            // else if (errorStack.has(key)) errorStack.delete(key)
+            stack.push(() => {
+              const key = withScope(first[VALUE], scope)
+              if (env[first[VALUE]] === undefined) {
+                errorStack.set(
+                  key.str,
+                  `Trying to access undefined variable ${first[VALUE]} (check #11)`
+                )
+              }
+            })
           }
           break
         case ATOM:
@@ -402,50 +423,48 @@ 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)[0][TYPE] === APPLY &&
+                    rest.at(-1)[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
+                  ) {
+                    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
+                    check(rest.at(-1), env, exp)
+                  } else {
+                    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
+                          }
+                        }
+                    }
+                    check(rest.at(-1), env, scope)
                   }
-                  if (env[SCOPE_NAME]) {
-                    const key = withScope(name, scope)
-                    if (errorStack.has(key)) errorStack.delete(key)
-                  }
-                  check(rest.at(-1), env, scope)
                 }
               }
               break
@@ -462,19 +481,20 @@ export const typeCheck = (ast) => {
                 }
                 const params = exp.slice(1, -1)
                 const copy = Object.create(env)
-                if (isLeaf(scope[1])) {
+                if (Array.isArray(scope[1]) && scope[1][TYPE] === WORD) {
                   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]])
                     env[copy[SCOPE_NAME]][STATS][ARGS].push(copy[param[VALUE]])
                 }
-                check(rest.at(-1), copy, scope)
+                check(rest.at(-1), copy, copy)
               }
               break
             default:
@@ -482,7 +502,7 @@ export const typeCheck = (ast) => {
                 const key = withScope(first[VALUE], scope)
                 if (env[first[VALUE]] === undefined)
                   errorStack.set(
-                    key,
+                    key.str,
                     `Trying to call undefined (lambda) ${first[VALUE]} (check #9)`
                   )
                 else if (
@@ -491,7 +511,7 @@ export const typeCheck = (ast) => {
                   env[first[VALUE]][STATS][ARGS_COUNT] !== rest.length
                 ) {
                   errorStack.set(
-                    key,
+                    key.str,
                     `Incorrect number of arguments for (${
                       first[VALUE]
                     }). Expected (= ${
@@ -506,10 +526,10 @@ export const typeCheck = (ast) => {
                   if (first[TYPE] === APPLY && !isSpecial) {
                     if (env[first[VALUE]][STATS].type === ATOM) {
                       errorStack.set(
-                        key,
+                        key.str,
                         `(${first[VALUE]}) is not a (lambda) (${stringifyArgs(
                           exp
-                        )})`
+                        )}) (check #12)`
                       )
                     } else if (!env[first[VALUE]][STATS][ARGS_COUNT]) {
                       env[first[VALUE]][STATS][RETURNS] = UNKNOWN
@@ -535,7 +555,7 @@ export const typeCheck = (ast) => {
                           env[rest[i][VALUE]][STATS][ARGS_COUNT]
                         ) {
                           errorStack.set(
-                            key,
+                            key.str,
                             `Incorrect number of arguments for (${
                               first[VALUE]
                             }). Expected (= ${
@@ -554,7 +574,7 @@ export const typeCheck = (ast) => {
                       ) {
                         if (args[i][STATS][ARGS_COUNT] !== rest[i].length - 2)
                           errorStack.set(
-                            key,
+                            key.str,
                             `Incorrect number of arguments for (${
                               first[VALUE]
                             }). Expected (= ${
@@ -584,7 +604,7 @@ export const typeCheck = (ast) => {
                             ) {
                               // console.log(env[CAR][STATS], expectedArgs[i][TYPE])
                               errorStack.set(
-                                key,
+                                key.str,
                                 `Incorrect type of arguments for special form (${
                                   first[VALUE]
                                 }). Expected (${toTypeNames(
@@ -618,7 +638,7 @@ export const typeCheck = (ast) => {
                                       env[TT][STATS][RETURNS]
                                   )
                                     errorStack.set(
-                                      key,
+                                      key.str,
                                       `Incorrect type of arguments for special form (${
                                         first[VALUE]
                                       }). Expected (${toTypeNames(
@@ -633,7 +653,7 @@ export const typeCheck = (ast) => {
                                   expectedArgs[i][TYPE] !== T
                                 ) {
                                   errorStack.set(
-                                    key,
+                                    key.str,
                                     `Incorrect type of arguments for special form (${
                                       first[VALUE]
                                     }). Expected (${toTypeNames(
@@ -650,7 +670,7 @@ export const typeCheck = (ast) => {
                               case APPLY:
                               case ATOM:
                                 errorStack.set(
-                                  key,
+                                  key.str,
                                   `Incorrect type of arguments for (${
                                     first[VALUE]
                                   }). Expected (${toTypeNames(
@@ -686,7 +706,7 @@ export const typeCheck = (ast) => {
                                 args[i][STATS].type)
                           ) {
                             errorStack.set(
-                              key,
+                              key.str,
                               `Incorrect type of arguments ${i} for (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
@@ -704,8 +724,6 @@ export const typeCheck = (ast) => {
                               args[i][STATS].type === UNKNOWN
                             ) {
                               retry.retried = true
-                              if (!scope[SCOPE_NAME])
-                                scope[SCOPE_NAME] = scope[1][VALUE]
                               stack.unshift(() => check(exp, env, scope))
                             }
                             // console.log(
@@ -725,7 +743,7 @@ export const typeCheck = (ast) => {
                             args[i][STATS].type
                         ) {
                           errorStack.set(
-                            key,
+                            key.str,
                             `Incorrect type of arguments ${i} for (${
                               first[VALUE]
                             }). Expected (${toTypeNames(
@@ -760,6 +778,7 @@ export const typeCheck = (ast) => {
     }
   }
   const copy = JSON.parse(JSON.stringify(ast))
+  copy[SCOPE_NAME] = 'root'
   check(copy, root, copy)
   while (stack.length) stack.pop()()
   if (errorStack.size)

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()