fez-lisp 1.5.17 → 1.5.19

package/package.json

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

package/src/check.js

@@ -1,6 +1,7 @@
 import {
   APPLY,
   ATOM,
+  DEBUG,
   KEYWORDS,
   PLACEHOLDER,
   PREDICATE_SUFFIX,
@@ -40,6 +41,32 @@ const toTypeNames = (type) => {
 }
 export const typeCheck = (ast) => {
   const root = {
+    [DEBUG.LOG]: {
+      [STATS]: {
+        type: APPLY,
+        [ARGS]: [
+          [UNKNOWN, PLACEHOLDER],
+          [APPLY, PLACEHOLDER]
+        ],
+        [ARGS_COUNT]: new Set([2]),
+        [RETURNS]: UNKNOWN
+      }
+    },
+    [DEBUG.STRING]: {
+      [STATS]: { type: APPLY, [ARGS_COUNT]: VARIADIC, [RETURNS]: APPLY }
+    },
+    [DEBUG.ASSERT]: {
+      [STATS]: { type: APPLY, [ARGS_COUNT]: VARIADIC, [RETURNS]: UNKNOWN }
+    },
+    [DEBUG.SIGNATURE]: {
+      [STATS]: { type: APPLY, [ARGS_COUNT]: VARIADIC, [RETURNS]: UNKNOWN }
+    },
+    [DEBUG.LIST_THEMES]: {
+      [STATS]: { type: APPLY, [ARGS_COUNT]: VARIADIC, [RETURNS]: UNKNOWN }
+    },
+    [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 }
@@ -412,8 +439,10 @@ export const typeCheck = (ast) => {
                         }
                       }
                   }
-                  const key = withScope(name, scope)
-                  if (errorStack.has(key)) errorStack.delete(key)
+                  // if (env[SCOPE_NAME]) {
+                  //   const key = withScope(name, scope)
+                  //   if (errorStack.has(key)) errorStack.delete(key)
+                  // }
                   check(rest.at(-1), env, scope)
                 }
               }
@@ -491,7 +520,9 @@ export const typeCheck = (ast) => {
                         args[i][STATS].type === APPLY &&
                         env[rest[i][VALUE]] &&
                         env[rest[i][VALUE]][STATS] &&
-                        env[rest[i][VALUE]][STATS][ARGS_COUNT]
+                        env[rest[i][VALUE]][STATS][ARGS_COUNT] &&
+                        args[i][STATS][ARGS_COUNT] !== VARIADIC &&
+                        env[rest[i][VALUE]][STATS][ARGS_COUNT] !== VARIADIC
                       ) {
                         const argCount = [...args[i][STATS][ARGS_COUNT]]
                         if (
@@ -667,11 +698,14 @@ export const typeCheck = (ast) => {
                               )})`
                             )
                           } else {
+                            // env[rest[i][VALUE]][STATS] THiss SHOULD BE
+                            const retry = env[rest[i][VALUE]]
                             if (
-                              !args[i][STATS].retried &&
+                              retry &&
+                              !retry.retried &&
                               args[i][STATS].type === UNKNOWN
                             ) {
-                              args[i][STATS].retried = true
+                              retry.retried = true
                               if (!scope[SCOPE_NAME])
                                 scope[SCOPE_NAME] = scope[1][VALUE]
                               stack.unshift(() => check(exp, env, scope))
@@ -704,10 +738,12 @@ export const typeCheck = (ast) => {
                           )
                         } else {
                           if (
+                            rest[i].length &&
+                            env[rest[i][0][VALUE]] &&
                             args[i][STATS].type === UNKNOWN &&
-                            !args[i][STATS].retried
+                            !env[rest[i][0][VALUE]].retried
                           ) {
-                            args[i][STATS].retried = true
+                            env[rest[i][0][VALUE]].retried = true
                             if (!scope[SCOPE_NAME])
                               scope[SCOPE_NAME] = scope[1][VALUE]
                             stack.unshift(() => check(exp, env, scope))
@@ -725,8 +761,10 @@ export const typeCheck = (ast) => {
       }
     }
   }
-  check(ast, root, ast)
+  const copy = JSON.parse(JSON.stringify(ast))
+  check(copy, root, copy)
   while (stack.length) stack.pop()()
-  if (errorStack.size) throw new TypeError([...errorStack.values()].join('\n'))
+  if (errorStack.size)
+    throw new TypeError([...new Set(errorStack.values())].join('\n'))
   return ast
 }