fez-lisp 1.5.87 → 1.5.89

package/package.json

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

package/src/check.js

@@ -73,7 +73,7 @@ const checkPredicateName = (exp, rest, warningStack) => {
             rest[0][VALUE]
           }) to an (${
             STATIC_TYPES.ATOM
-          }) that is not (or ${TRUE} ${FALSE}) (${stringifyArgs(rest)})`
+          }) that is not (or ${TRUE} ${FALSE}) (${stringifyArgs(exp)})`
         )
       else if (
         last[TYPE] === WORD &&
@@ -90,6 +90,9 @@ const checkPredicateName = (exp, rest, warningStack) => {
     } else if (last[0][0] === APPLY) {
       const application = last[0]
       switch (application[VALUE]) {
+        case KEYWORDS.IF:
+          // TODO finishthis #1
+          break
         default:
           if (
             getSuffix(application[VALUE]) !== PREDICATE_SUFFIX &&
@@ -107,6 +110,23 @@ const checkPredicateName = (exp, rest, warningStack) => {
     }
   }
 }
+const checkPredicateNameDeep = (name, exp, rest, returns, warningStack) => {
+  if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
+    const fn = rest.at(-1).at(-1).at(-1)
+    checkPredicateName(
+      exp,
+      [
+        [WORD, name],
+        isLeaf(fn)
+          ? fn // when apply is a word (let x? (lambda (apply [] array:empty!)))
+          : drillReturnType(fn, (r) => r[VALUE] === KEYWORDS.CALL_FUNCTION) // when apply is an annonymous lambda // (let fn? (lambda x (apply x (lambda x (array:empty! [])))))
+      ],
+      warningStack
+    )
+  } else {
+    checkPredicateName(exp, [[WORD, name], returns], warningStack)
+  }
+}
 // const assign = (a, b, i) => {
 //   a[i] = b[i]
 // }
@@ -223,11 +243,26 @@ export const typeCheck = (ast) => {
                     // ATOM ASSIGMENT
                     env[name][STATS][prop][0] = ATOM
                     env[name][STATS][RETURNS][0] = ATOM
+                    checkPredicateName(
+                      exp,
+                      [[WORD, name], returns],
+                      warningStack
+                    )
                   } else {
                     switch (returns[VALUE]) {
                       case KEYWORDS.IF:
                         {
                           const re = rem.slice(2)
+                          checkPredicateName(
+                            exp,
+                            [[WORD, name], isLeaf(re[0]) ? re[0] : re[0][0]],
+                            warningStack
+                          )
+                          checkPredicateName(
+                            exp,
+                            [[WORD, name], isLeaf(re[1]) ? re[1] : re[1][0]],
+                            warningStack
+                          )
                           if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM) {
                             // ATOM ASSIGMENT
                             env[name][STATS][prop][0] = ATOM
@@ -291,30 +326,19 @@ export const typeCheck = (ast) => {
                         }
                         break
                       default:
+                        checkPredicateNameDeep(
+                          name,
+                          exp,
+                          rest,
+                          returns,
+                          warningStack
+                        )
                         if (!env[returns[VALUE]])
                           env[name][STATS][RETURNS] = [UNKNOWN]
                         // env[name][STATS][RETURNS] = APPLY
                         else if (
                           env[returns[VALUE]][STATS][TYPE_PROP][0] === APPLY
                         ) {
-                          // TODO This seems to be able to be deleted
-                          // FOR NOT IT CAN BE
-                          // if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
-                          //   if (isLeaf(rest.at(-1).at(-1).at(-1))) {
-                          //     const fnName = rest.at(-1).at(-1).at(-1)[VALUE]
-                          //     const fn = env[fnName]
-                          //     env[name][STATS][TYPE_PROP][0] =
-                          //       fn[STATS][RETURNS][0]
-                          //   } else {
-                          //     const [returns, rem] = drillReturnType(
-                          //       rest.at(-1).at(-1).at(-1),
-                          //       (returns) =>
-                          //         returns[VALUE] === KEYWORDS.CALL_FUNCTION
-                          //     )
-                          //     resolveRetunType(returns, rem, TYPE_PROP)
-                          //   }
-                          // }
-
                           // ALWAYS APPLY
                           // rest.at(-1)[0][TYPE] === APPLY
                           // Here is upon application to store the result in the variable