@graffiticode/parser 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/ast.js

@@ -171,6 +171,10 @@ export class Ast {
     };
   }
 
+  static hasSyntaxError(ctx) {
+    return ctx.state.errors && ctx.state.errors.length > 0;
+  }
+
   static dump(n) {
     let s;
     if (typeof n === "object") {

package/src/folder.js

@@ -184,7 +184,7 @@ export class Folder {
     if (word) {
       if (word.cls === "val") {
         if (word.val) {
-          Ast.string(ctx, word.val); // strip quotes;
+          Ast.string(ctx, word.val, node.coord); // strip quotes;
         } else if (word.nid) {
           let wrd;
           if ((wrd = Ast.node(ctx, word.nid)).tag === "LAMBDA") {
@@ -229,6 +229,7 @@ export class Folder {
       Ast.push(ctx, {
         tag: name,
         elts: [],
+        coord: node.coord,
       });
     }
   }
@@ -238,7 +239,7 @@ export class Folder {
   }
 
   static str(node) {
-    Ast.string(Folder.#ctx, node.elts[0]);
+    Ast.string(Folder.#ctx, node.elts[0], node.coord);
   }
 
   static bool(node) {

package/src/parse.js

@@ -71,6 +71,16 @@ export function assertErr(ctx, b, str, coord) {
       "assertErr()",
       "str=" + str,
     );
+    // Push error into state errors collection
+    if (!ctx.state.errors) {
+      ctx.state.errors = [];
+    }
+    ctx.state.errors.push({
+      message: str,
+      coord
+    });
+
+    // Create error node in AST
     Ast.error(ctx, str, coord);
     throw new Error(str);
   }
@@ -79,7 +89,9 @@ export function assertErr(ctx, b, str, coord) {
 export const parse = (function () {
   function assert(b, str) {
     if (!b) {
-      throw new Error(str);
+      // Just throw a simple error with the message "Syntax Error" if none provided
+      // This will be caught by our catch-all handler
+      throw new Error(str || "Syntax Error");
     }
   }
 
@@ -160,6 +172,7 @@ export const parse = (function () {
   const TK_STRPREFIX = 0xB2;
   const TK_STRMIDDLE = 0xB3;
   const TK_STRSUFFIX = 0xB4;
+  const TK_DOTDOT = 0xB5;
 
   function tokenToLexeme(tk) {
     switch (tk) {
@@ -191,6 +204,7 @@ export const parse = (function () {
       case TK_PLUS: return "a '+'";
       case TK_MINUS: return "a '-'";
       case TK_DOT: return "a '.'";
+      case TK_DOTDOT: return "a '..'";
       case TK_COLON: return "a ':'";
       case TK_COMMA: return "a ','";
       case TK_BACKQUOTE: return "a '`'";
@@ -205,11 +219,14 @@ export const parse = (function () {
     if (nextToken !== tk) {
       const to = getPos(ctx);
       const from = to - lexeme.length;
-      assertErr(ctx, false, "Expecting " + tokenToLexeme(tk) +
-                ", found " + tokenToLexeme(nextToken) + ".", { from, to });
+      const errorMessage = "Expecting " + tokenToLexeme(tk) +
+                          ", found " + tokenToLexeme(nextToken) + ".";
+
+      // Use assertErr to ensure error is tracked consistently
+      assertErr(ctx, false, errorMessage, { from, to });
+
       next(ctx); // Advance past error.
-      throw new Error("Expecting " + tokenToLexeme(tk) +
-                      ", found " + tokenToLexeme(nextToken) + ".");
+      throw new Error(errorMessage);
     }
   }
 
@@ -283,20 +300,20 @@ export const parse = (function () {
   function str(ctx, cc) {
     if (match(ctx, TK_STR)) {
       eat(ctx, TK_STR);
-      Ast.string(ctx, lexeme); // strip quotes;
+      Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
       cc.cls = "string";
       return cc;
     } else if (match(ctx, TK_STRPREFIX)) {
       ctx.state.inStr++;
       eat(ctx, TK_STRPREFIX);
       startCounter(ctx);
-      Ast.string(ctx, lexeme); // strip quotes;
+      Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
       countCounter(ctx);
       const ret = function (ctx) {
         return strSuffix(ctx, function (ctx) {
           ctx.state.inStr--;
           eat(ctx, TK_STRSUFFIX);
-          Ast.string(ctx, lexeme); // strip quotes;
+          Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
           countCounter(ctx);
           Ast.list(ctx, ctx.state.exprc);
           stopCounter(ctx);
@@ -320,7 +337,7 @@ export const parse = (function () {
       if (match(ctx, TK_STRMIDDLE)) {
         // Not done yet.
         eat(ctx, TK_STRMIDDLE);
-        Ast.string(ctx, lexeme); // strip quotes;
+        Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
         countCounter(ctx);
         ret = function (ctx) {
           return strSuffix(ctx, resume);
@@ -350,7 +367,7 @@ export const parse = (function () {
   function bindingName(ctx, cc) {
     if (match(ctx, TK_IDENT)) {
       eat(ctx, TK_IDENT);
-      Ast.string(ctx, lexeme);
+      Ast.string(ctx, lexeme, getCoord(ctx));
       cc.cls = "variable";
       return cc;
     }
@@ -409,8 +426,6 @@ export const parse = (function () {
         }
       }
     } else {
-      // cc.cls = "error";
-      // Ast.error(ctx, "Name '" + lexeme + "' not found.", coord);
       // Create a tag value.
       Ast.name(ctx, lexeme, coord);
     }
@@ -853,9 +868,17 @@ export const parse = (function () {
     return exprsStart(ctx, TK_DOT, function (ctx) {
       let nid;
       while (Ast.peek(ctx) !== nid) {
+        console.log(
+          "program()",
+          "peek()=" + Ast.peek(ctx),
+        );
         nid = Ast.pop(ctx);
         folder.fold(ctx, nid); // Fold the exprs on top
       }
+      console.log(
+        "program()",
+        "nodeStack.length=" + ctx.state.nodeStack.length,
+      );
       Ast.exprs(ctx, ctx.state.nodeStack.length, true);
       Ast.program(ctx);
       assert(cc === null, "internal error, expecting null continuation");
@@ -988,17 +1011,28 @@ export const parse = (function () {
           cls = x;
         } else {
           console.log("catch() x=" + x.stack);
-          // next(ctx);
+
+          // Add generic "Syntax Error" message if not already handled
+          if (!Ast.hasSyntaxError(ctx)) {
+            // Create a generic syntax error
+            const coord = getCoord(ctx) || { from: 0, to: stream.pos || 0 };
+            Ast.error(ctx, "Syntax Error", coord);
+          }
+
           state.cc = null; // done for now.
           return Ast.poolToJSON(ctx);
-          // cls = "error";
-          // throw new Error(JSON.stringify(window.gcexports.errors, null, 2));
         }
       } else {
         // throw x
         next(ctx);
         cls = "error";
         console.log(x.stack);
+
+        // Add generic "Syntax Error" message for non-Error exceptions too
+        if (!Ast.hasSyntaxError(ctx)) {
+          const coord = getCoord(ctx) || { from: 0, to: stream.pos || 0 };
+          Ast.error(ctx, "Syntax Error", coord);
+        }
       }
     }
     const t1 = new Date();
@@ -1043,6 +1077,11 @@ export const parse = (function () {
           case 46: // dot
             if (isNumeric(stream.peek())) {
               return number(c);
+            // } else if (stream.peek() === 46) {
+            // TODO
+            //   stream.next();
+            //   lexeme += String.fromCharCode(c);
+            //   return TK_DOTDOT;
             }
             lexeme += String.fromCharCode(c);
             return TK_DOT;

package/src/parser.js

@@ -7,7 +7,7 @@ const main = {
   parse(src, lexicon) {
     const stream = new parse.StringStream(src);
     const state = {
-      cc: parse.program, // top level parsing function
+      cc: parse.program, // top level parsig function
       argc: 0,
       argcStack: [0],
       paramc: 0,

package/src/parser.spec.js

@@ -320,6 +320,126 @@ describe("parser integration tests", () => {
     expect(identNodeB).not.toBeNull();
   });
 
+  it("should handle syntax errors with generic error message", async () => {
+    // Test various syntax errors and confirm they're caught properly
+    let errorNode = null;
+    let result = null;
+
+    try {
+      // Unclosed string - missing closing quote
+      result = await parser.parse(0, "'unclosed string..");
+    } catch (e) {
+      // Check for expected error (we should now have a robust parser that doesn't throw)
+      console.error("Unexpected error:", e);
+      throw e;
+    }
+
+    // Should get a result even with syntax error
+    expect(result).toHaveProperty("root");
+
+    // Find the ERROR node
+    errorNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "ERROR") {
+          errorNode = node;
+          break;
+        }
+      }
+    }
+
+    // Should have an ERROR node
+    expect(errorNode).not.toBeNull();
+    expect(errorNode.tag).toBe("ERROR");
+
+    // The error message should be either the specific syntax error or the generic "Syntax Error"
+    // Verify that we have an ERROR node with the proper structure
+    expect(errorNode.elts.length).toBeGreaterThan(0);
+
+    // The error structure might be different based on implementation details
+    // We just want to ensure there's an error node in the result
+    expect(errorNode.tag).toBe("ERROR");
+  });
+
+  it("should handle mismatched brackets with syntax error", async () => {
+    let result = null;
+
+    try {
+      // Missing closing bracket
+      result = await parser.parse(0, "[1, 2, 3..");
+    } catch (e) {
+      console.error("Unexpected error:", e);
+      throw e;
+    }
+
+    // Should get a result even with syntax error
+    expect(result).toHaveProperty("root");
+
+    // Find the ERROR node
+    let errorNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "ERROR") {
+          errorNode = node;
+          break;
+        }
+      }
+    }
+
+    // Should have an ERROR node
+    expect(errorNode).not.toBeNull();
+    expect(errorNode.tag).toBe("ERROR");
+
+    // The error message should indicate the syntax error
+    // Verify that we have an ERROR node with the proper structure
+    expect(errorNode.elts.length).toBeGreaterThan(0);
+
+    // The error structure might be different based on implementation details
+    // We just want to ensure there's an error node in the result
+    expect(errorNode.tag).toBe("ERROR");
+  });
+
+  it("should handle invalid token sequences with syntax error", async () => {
+    let result = null;
+
+    try {
+      // Invalid sequence of tokens
+      result = await parser.parse(0, "if then else..");
+    } catch (e) {
+      console.error("Unexpected error:", e);
+      throw e;
+    }
+
+    // Should get a result even with syntax error
+    expect(result).toHaveProperty("root");
+
+    // Find the ERROR node
+    let errorNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "ERROR") {
+          errorNode = node;
+          break;
+        }
+      }
+    }
+
+    // Should have an ERROR node
+    expect(errorNode).not.toBeNull();
+    expect(errorNode.tag).toBe("ERROR");
+
+    // The error message should indicate the syntax error
+    // Verify that we have an ERROR node with the proper structure
+    expect(errorNode.elts.length).toBeGreaterThan(0);
+
+    // The error structure might be different based on implementation details
+    // We just want to ensure there's an error node in the result
+    expect(errorNode.tag).toBe("ERROR");
+  });
+
   it("should perform parse-time evaluation for adding two numbers", async () => {
     // Create parser with custom lexicon that defines 'add' function
     const customLexiconCache = new Map();