@graffiticode/parser 0.1.2 → 0.1.4

package/jest.config.js

@@ -0,0 +1,5 @@
+export default {
+  testEnvironment: "node",
+  forceExit: true,
+  verbose: true,
+};

package/jest.config.js~

@@ -0,0 +1,6 @@
+export default {
+  testEnvironment: "node",
+  forceExit: true,
+  // Set to true to see all test details
+  verbose: false
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -14,7 +14,8 @@
   "scripts": {
     "lint": "eslint src/",
     "lint:fix": "eslint --fix src/",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest"
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "console-test": "node console-output-test.js"
   },
   "keywords": [],
   "author": "",

package/src/ast.js

@@ -148,13 +148,31 @@ export class Ast {
 
   static poolToJSON(ctx) {
     const nodePool = ctx.state.nodePool;
-    const obj = {};
-    for (let i = 1; i < nodePool.length; i++) {
-      const n = nodePool[i];
-      obj[i] = nodeToJSON(n);
-    }
-    obj.root = (nodePool.length - 1);
-    return obj;
+    const rootId = nodePool.length - 1;
+    // Find all nodes transitively referenced from root
+    const referencedNodes = new Set();
+    const collectReferences = (nodeId) => {
+      if (!nodeId || referencedNodes.has(nodeId)) return;
+      referencedNodes.add(nodeId);
+
+      const node = nodePool[nodeId];
+      if (node && node.elts) {
+        node.elts.forEach(elt => {
+          if (typeof elt === "number") collectReferences(elt);
+        });
+      }
+    };
+    collectReferences(rootId);
+    return {
+      ...Object.fromEntries(
+        Array.from(referencedNodes).map(id => [id, nodeToJSON(nodePool[id])])
+      ),
+      root: rootId
+    };
+  }
+
+  static hasSyntaxError(ctx) {
+    return ctx.state.errors && ctx.state.errors.length > 0;
   }
 
   static dump(n) {
@@ -666,11 +684,7 @@ export class Ast {
       });
       nids.push(word.nid || 0);
     }
-    const pattern = env.pattern;
-    console.log(
-      "lambda()",
-      "pattern=" + JSON.stringify(pattern, null, 2),
-    );
+    // const pattern = env.pattern;
     Ast.push(ctx, {
       tag: "LAMBDA",
       elts: [{

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") {
@@ -225,8 +225,12 @@ export class Folder {
         assert(false);
       }
     } else {
-      // assertErr(ctx, false, "unresolved ident " + name, node.coord);
-      Ast.push(ctx, node);
+      // Tag value.
+      Ast.push(ctx, {
+        tag: name,
+        elts: [],
+        coord: node.coord,
+      });
     }
   }
 
@@ -235,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);
     }
   }
 
@@ -266,7 +283,7 @@ export const parse = (function () {
   function number(ctx, cc) {
     eat(ctx, TK_NUM);
     cc.cls = "number";
-    Ast.number(ctx, lexeme, getCoord(ctx));
+    Ast.number(ctx, lexeme);
     return cc;
   }
 
@@ -281,28 +298,24 @@ export const parse = (function () {
   */
 
   function str(ctx, cc) {
-    let coord;
     if (match(ctx, TK_STR)) {
       eat(ctx, TK_STR);
-      coord = getCoord(ctx);
-      Ast.string(ctx, lexeme, coord); // 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);
-      coord = getCoord(ctx);
-      Ast.string(ctx, lexeme, coord); // 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);
-          const coord = getCoord(ctx);
-          Ast.string(ctx, lexeme, coord); // strip quotes;
+          Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
           countCounter(ctx);
-          Ast.list(ctx, ctx.state.exprc, getCoord(ctx));
+          Ast.list(ctx, ctx.state.exprc);
           stopCounter(ctx);
           Ast.concat(ctx);
           cc.cls = "string";
@@ -324,8 +337,7 @@ export const parse = (function () {
       if (match(ctx, TK_STRMIDDLE)) {
         // Not done yet.
         eat(ctx, TK_STRMIDDLE);
-        const coord = getCoord(ctx);
-        Ast.string(ctx, lexeme, coord); // strip quotes;
+        Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
         countCounter(ctx);
         ret = function (ctx) {
           return strSuffix(ctx, resume);
@@ -389,7 +401,7 @@ export const parse = (function () {
         offset: ctx.state.paramc,
         nid: 0
       });
-      Ast.name(ctx, lexeme, getCoord(ctx));
+      Ast.name(ctx, lexeme);
       cc.cls = "val";
       return cc;
     }
@@ -414,8 +426,8 @@ 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);
     }
     // assert(cc, "name");
     return cc;
@@ -505,14 +517,12 @@ export const parse = (function () {
     return ret;
   }
   function list(ctx, cc) {
-    const coord = getCoord(ctx);
     eat(ctx, TK_LEFTBRACKET);
     startCounter(ctx);
     const ret = function (ctx) {
       return elements(ctx, function (ctx) {
         eat(ctx, TK_RIGHTBRACKET);
-        coord.to = getCoord(ctx).to;
-        Ast.list(ctx, ctx.state.exprc, coord);
+        Ast.list(ctx, ctx.state.exprc);
         stopCounter(ctx);
         cc.cls = "punc";
         return cc;
@@ -858,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");
@@ -984,7 +1002,7 @@ export const parse = (function () {
         stream.next();
       }
       if (cc && !stream.peek()) {
-        assertErr(ctx, false, "End of progam reached.", getCoord(ctx));
+        assertErr(ctx, false, "Missing program terminator.", getCoord(ctx));
       }
     } catch (x) {
       // console.log("catch() x=" + x);
@@ -993,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();
@@ -1048,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,
@@ -35,10 +35,6 @@ const main = {
     if (state.cc) {
       throw new Error("End of program reached.");
     }
-    console.log(
-      "parse()",
-      "ast=" + JSON.stringify(ast, null, 2),
-    );
     return ast;
   }
 };

package/src/parser.spec.js

@@ -1,6 +1,7 @@
 import { jest } from "@jest/globals";
-import { buildParser } from "./parser.js";
+import { buildParser, parser } from "./parser.js";
 import { mockPromiseValue, mockPromiseError } from "./testing/index.js";
+import vm from "vm";
 
 describe("lang/parser", () => {
   const log = jest.fn();
@@ -149,3 +150,373 @@ describe("lang/parser", () => {
     await expect(parser.parse(lang, src)).rejects.toBe(err);
   });
 });
+
+describe("parser integration tests", () => {
+  // Tests using the actual parser
+  it("should parse string literals", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, "'hello, world'..");
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the STR node
+    let strNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "STR" && node.elts[0] === "hello, world") {
+          strNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(strNode).not.toBeNull();
+    expect(strNode.tag).toBe("STR");
+    expect(strNode.elts).toEqual(["hello, world"]);
+
+    // Program structure verification
+    const rootId = result.root;
+    const rootNode = result[rootId];
+    expect(rootNode.tag).toBe("PROG");
+  });
+
+  it("should parse numeric literals", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, "42..");
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the NUM node
+    let numNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "NUM" && node.elts[0] === "42") {
+          numNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(numNode).not.toBeNull();
+    expect(numNode.tag).toBe("NUM");
+    expect(numNode.elts).toEqual(["42"]);
+  });
+
+  it("should have a PROG node at the root", async () => {
+    // Let's test the most basic structure that should always work
+    const result = await parser.parse(0, "123..");
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Verify the structure: we need to have a PROG node at the root
+    const rootId = result.root;
+    const rootNode = result[rootId];
+    expect(rootNode.tag).toBe("PROG");
+
+    // Find the NUM node for 123
+    let numNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "NUM" && node.elts[0] === "123") {
+          numNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(numNode).not.toBeNull();
+    expect(numNode.tag).toBe("NUM");
+    expect(numNode.elts[0]).toBe("123");
+  });
+
+  it("should parse complex program: apply (<a b: add a b>) [10 20]..", async () => {
+    // Create parser with custom lexicon
+    const customLexiconCache = new Map();
+    customLexiconCache.set(0, {
+      add: {
+        tk: 2,
+        name: "add",
+        cls: "function",
+        length: 2
+      },
+      apply: {
+        tk: 40,
+        name: "apply",
+        cls: "function",
+        length: 2
+      }
+    });
+
+    // Use the parser with our custom cache
+    const customParser = buildParser({
+      log: console.log,
+      cache: customLexiconCache,
+      getLangAsset: async () => ({}),
+      main: {
+        parse: (src, lexicon) => {
+          return Promise.resolve(parser.parse(0, src));
+        }
+      },
+      vm
+    });
+
+    // Act
+    const result = await customParser.parse(0, "apply (<a b: add a b>) [10 20]..");
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Verify basic structure
+    const rootId = result.root;
+    const rootNode = result[rootId];
+    expect(rootNode.tag).toBe("PROG");
+
+    // Find NUM nodes with values 10 and 20
+    let num10Node = null;
+    let num20Node = null;
+
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "NUM") {
+          if (node.elts[0] === "10") {
+            num10Node = node;
+          } else if (node.elts[0] === "20") {
+            num20Node = node;
+          }
+        }
+      }
+    }
+
+    // At minimum, we should be able to find the number values
+    expect(num10Node).not.toBeNull();
+    expect(num20Node).not.toBeNull();
+
+    // Find IDENT nodes with names 'a' and 'b'
+    let identNodeA = null;
+    let identNodeB = null;
+
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "IDENT") {
+          if (node.elts[0] === "a") {
+            identNodeA = node;
+          } else if (node.elts[0] === "b") {
+            identNodeB = node;
+          }
+        }
+      }
+    }
+
+    // Check that we found the identifiers
+    expect(identNodeA).not.toBeNull();
+    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();
+    customLexiconCache.set(0, {
+      add: {
+        tk: 2,
+        name: "add",
+        cls: "function",
+        length: 2
+      }
+    });
+
+    // Use the parser with our custom cache
+    const customParser = buildParser({
+      log: console.log,
+      cache: customLexiconCache,
+      getLangAsset: async () => ({}),
+      main: {
+        parse: (src, lexicon) => {
+          return Promise.resolve(parser.parse(0, src));
+        }
+      },
+      vm
+    });
+
+    // Act - parse a simple addition expression
+    const result = await customParser.parse(0, "add 123 456..");
+    console.log(
+      "TEST",
+      "result=" + JSON.stringify(result, null, 2),
+    );
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Verify basic structure
+    const rootId = result.root;
+    const rootNode = result[rootId];
+    expect(rootNode.tag).toBe("PROG");
+
+    // Find the result node - expecting a single NUM node with the sum
+    let resultNode = null;
+
+    // Check all nodes for the result of evaluation (123 + 456 = 579)
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "NUM" && node.elts[0] === "579") {
+          resultNode = node;
+          break;
+        }
+      }
+    }
+
+    // We should find a node with the computed value (579)
+    expect(resultNode).not.toBeNull();
+    expect(resultNode.tag).toBe("NUM");
+    expect(resultNode.elts[0]).toBe("579");
+
+    // The original numbers should not be in the final AST
+    // if parse-time evaluation is working correctly
+    let found123 = false;
+    let found456 = false;
+
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "NUM") {
+          if (node.elts[0] === "123") found123 = true;
+          if (node.elts[0] === "456") found456 = true;
+        }
+      }
+    }
+
+    // The original operands should not be in the final AST
+    // if they were properly evaluated at parse time
+    expect(found123).toBe(false);
+    expect(found456).toBe(false);
+  });
+});

package/src/parse.spec.js

@@ -1,118 +0,0 @@
-import { buildParser } from "./parser.js";
-import { mockPromiseValue } from "./testing/index.js";
-
-describe("parse operations", () => {
-  const log = jest.fn();
-
-  it("should parse 'apply (<a b: add a b>) [10 20]'", async () => {
-    // Arrange
-    const cache = new Map();
-    const getLangAsset = mockPromiseValue("{}");
-    const main = {
-      parse: mockPromiseValue({
-        1: {
-          elts: ["a"],
-          tag: "IDENT"
-        },
-        2: {
-          elts: ["b"],
-          tag: "IDENT"
-        },
-        3: {
-          elts: [1, 2],
-          tag: "ADD"
-        },
-        4: {
-          elts: [3],
-          tag: "EXPRS"
-        },
-        5: {
-          elts: [1, 2],
-          tag: "LIST"
-        },
-        6: {
-          elts: [5, 4],
-          tag: "LAMBDA"
-        },
-        7: {
-          elts: ["10"],
-          tag: "NUM"
-        },
-        8: {
-          elts: ["20"],
-          tag: "NUM"
-        },
-        9: {
-          elts: [7, 8],
-          tag: "LIST"
-        },
-        10: {
-          elts: [6, 9],
-          tag: "APPLY"
-        },
-        11: {
-          elts: [10],
-          tag: "EXPRS"
-        },
-        12: {
-          elts: [11],
-          tag: "PROG"
-        },
-        root: 12
-      })
-    };
-    const parser = buildParser({ log, cache, getLangAsset, main });
-    const lang = "0002";
-    const src = "apply (<a b: add a b>) [10 20]..";
-
-    // Act
-    const result = await parser.parse(lang, src);
-
-    // Assert
-    expect(result).toHaveProperty("root", 12);
-    expect(result[10].tag).toBe("APPLY");
-    expect(result[10].elts).toEqual([6, 9]);
-    expect(result[6].tag).toBe("LAMBDA");
-    expect(result[9].tag).toBe("LIST");
-  });
-
-  it("should parse 'hello, world!'", async () => {
-    // Arrange
-    const cache = new Map();
-    const getLangAsset = mockPromiseValue("{}");
-    const main = {
-      parse: mockPromiseValue({
-        1: {
-          elts: [
-            "hello, world"
-          ],
-          tag: "STR"
-        },
-        2: {
-          elts: [
-            1
-          ],
-          tag: "EXPRS"
-        },
-        3: {
-          elts: [
-            2
-          ],
-          tag: "PROG"
-        },
-        root: 3
-      })
-    };
-    const parser = buildParser({ log, cache, getLangAsset, main });
-    const lang = "0002";
-    const src = "'hello, world'..";
-
-    // Act
-    const result = await parser.parse(lang, src);
-
-    // Assert
-    expect(result).toHaveProperty("root", 3);
-    expect(result[1].tag).toBe("STR");
-    expect(result[1].elts).toEqual(["hello, world"]);
-  });
-});