@scinorandex/sparse 0.0.8 → 0.1.2

package/test/parser.test.ts

@@ -0,0 +1,392 @@
+import path from "path";
+import { ColumnAndRow, Token } from "@scinorandex/slex";
+import { describe, expect, it } from "vitest";
+import {
+  LR1ParserGraveError,
+  LR1StackSymbol,
+  Sparse,
+  SparseGrammarError,
+  assertReducersCoverGrammar,
+  buildProductions,
+  buildStates,
+  defineReducers,
+  enumToString,
+  loadGrammar,
+  missingReducerNames,
+  namedProductions,
+} from "../src/index";
+import {
+  MathTokenType,
+  SemiTokenType,
+  mathLexer,
+  readFile,
+  root,
+  semiLexer,
+} from "./helpers";
+
+type Node = { nodes: LR1StackSymbol<MathTokenType, {}, Node>[] };
+
+class AstNode implements Node {
+  constructor(public readonly nodes: LR1StackSymbol<MathTokenType, {}, Node>[]) {}
+  toObject(): unknown[] {
+    return this.nodes.map((node) => (node.type === "token" ? node.token.lexeme : (node.node as AstNode).toObject()));
+  }
+}
+
+const reducer = (_newInput: any, oldInput: { input: LR1StackSymbol<MathTokenType, {}, Node>[] }) =>
+  new AstNode(oldInput.input);
+
+const toStringifiedTokenType = enumToString<MathTokenType>(MathTokenType);
+const toSemiStringifiedTokenType = enumToString<SemiTokenType>(SemiTokenType);
+
+const mathGrammarPath = path.join(root, "example/math/grammar.txt");
+const mathTablePath = path.join(root, "example/math/table.txt");
+
+describe("parsing", () => {
+  it("parses a math expression from a prebuilt table", async () => {
+    const generator = await Sparse.fromGrammarFile<MathTokenType, {}, Node>({
+      grammarPath: mathGrammarPath,
+      tablePath: mathTablePath,
+      toStringifiedTokenType,
+    });
+
+    const result = generator.generate(mathLexer("2.4 + 3.5 * 1 / 456.789"), { reducer }).parse();
+
+    expect(result.errors).toEqual([]);
+    expect(result.result).not.toBe(null);
+  });
+
+  it("exposes the named symbols of the right hand side through the bag", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER: first] [EOF];
+`);
+    const generator = Sparse.fromProductions<MathTokenType, {}, unknown>({
+      productions,
+      toStringifiedTokenType,
+      quiet: true,
+    });
+
+    const seen: unknown[] = [];
+    generator
+      .generate(mathLexer("1"), {
+        reducer: (newInput) => {
+          seen.push(newInput.name);
+          if (newInput.name === "program")
+            seen.push({ first: (newInput.bag.first as Token<MathTokenType, {}>).lexeme });
+          return new AstNode([]);
+        },
+      })
+      .parse();
+
+    expect(seen).toEqual(["program", { first: "1" }]);
+  });
+
+  it("reports a syntax error with the position and the terminals it wanted", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: <EXPRESSION> [EOF];
+<EXPRESSION: expression>: [NUMBER] ([PLUS] [NUMBER])*;
+`);
+    const generator = Sparse.fromProductions<MathTokenType, {}, Node>({
+      productions,
+      toStringifiedTokenType,
+      quiet: true,
+    });
+
+    try {
+      generator.generate(mathLexer("1 + "), { reducer }).parse();
+      throw new Error("expected the parse to fail");
+    } catch (err) {
+      expect(err).toBeInstanceOf(LR1ParserGraveError);
+      const message = (err as LR1ParserGraveError<MathTokenType, {}>).reason;
+      expect(message).toContain("Invalid syntax at 1:4");
+      expect(message).toContain("got EOF");
+      expect(message).toContain("[NUMBER]");
+      // gotos are not terminals, so they must not show up in the message
+      expect(message).not.toContain("<");
+    }
+  });
+
+  it("keeps the token that could not be parsed", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] [EOF];
+`);
+    const generator = Sparse.fromProductions<MathTokenType, {}, Node>({
+      productions,
+      toStringifiedTokenType,
+      quiet: true,
+    });
+
+    try {
+      generator.generate(mathLexer("1 1"), { reducer }).parse();
+      throw new Error("expected the parse to fail");
+    } catch (err) {
+      expect(err).toBeInstanceOf(LR1ParserGraveError);
+      const token = (err as LR1ParserGraveError<MathTokenType, {}>).currentToken;
+      expect(token?.type).toBe(MathTokenType.NUMBER);
+      expect(token?.lexeme).toBe("1");
+      expect(token?.line).toBe(1);
+    }
+  });
+
+  it("explains that the table does not match the grammar instead of crashing", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] [EOF];
+`);
+    // Reduce by production 0 (accept) for everything: syntactically valid, semantically nonsense.
+    const generator = new Sparse<MathTokenType, {}, Node>({
+      productions,
+      states: buildStates(`[NUMBER]=r0\n`),
+      toStringifiedTokenType,
+      validate: true,
+    });
+
+    // Nothing gets shifted, so the parser has no tree to return rather than crashing on an empty stack.
+    expect(generator.generate(mathLexer("1"), { reducer }).parse().result).toBe(null);
+  });
+
+  it("rejects a table that does not belong to the grammar when validate is on", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] [EOF];
+`);
+
+    expect(
+      () =>
+        new Sparse<MathTokenType, {}, Node>({
+          productions,
+          states: buildStates(`[EOF]=r9\n`),
+          toStringifiedTokenType,
+          validate: true,
+        }),
+    ).toThrow(/does not match the grammar/);
+  });
+
+  it("keeps the collected errors between reductions and clears them on reset", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] [SEMICOLON] [EOF];
+`);
+    const generator = Sparse.fromProductions<SemiTokenType, {}, unknown>({
+      productions: productions as any,
+      toStringifiedTokenType: toSemiStringifiedTokenType,
+      quiet: true,
+    });
+
+    const parser = generator.generate(semiLexer("1"), {
+      reducer: () => ({ tag: "reduced" }),
+      recover({ lexer, insertToken, addError, finish }) {
+        const next = lexer.peekNextToken();
+        const inserted = insertToken(
+          new Token<SemiTokenType, {}>(SemiTokenType.SEMICOLON, ";", new ColumnAndRow(next.line, next.column), {}),
+        );
+        if (inserted != null) return inserted;
+        addError("inserted a semicolon");
+        return finish();
+      },
+    });
+
+    expect(parser.parse().errors).toHaveLength(1);
+    parser.reset();
+
+    // The lexer is exhausted, so the second run fails on the input rather than on leftover stacks.
+    expect(() => parser.parse()).toThrow(/Cannot insert|Invalid syntax/);
+  });
+});
+
+describe("error recovery", () => {
+  const productionsWithSemicolon = () =>
+    Sparse.fromProductions<SemiTokenType, {}, unknown>({
+      productions: buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] [SEMICOLON] [EOF];
+`),
+      toStringifiedTokenType: toSemiStringifiedTokenType,
+      quiet: true,
+    });
+
+  it("inserts a token that was missing from the input", () => {
+    const generator = productionsWithSemicolon();
+    const parser = generator.generate(semiLexer("1"), {
+      reducer: () => ({ tag: "reduced" }),
+      recover({ lexer, insertToken, addError, finish }) {
+        const next = lexer.peekNextToken();
+        const inserted = insertToken(
+          new Token<SemiTokenType, {}>(SemiTokenType.SEMICOLON, ";", new ColumnAndRow(next.line, next.column), {}),
+        );
+        if (inserted != null) return inserted;
+        addError("inserted a semicolon");
+        return finish();
+      },
+    });
+
+    const result = parser.parse();
+    expect(result.errors.map((error) => error.message)).toEqual(["inserted a semicolon"]);
+    expect(result.result).not.toBe(null);
+  });
+
+  it("records the position of the error it adds", () => {
+    const generator = productionsWithSemicolon();
+    const parser = generator.generate(semiLexer("1"), {
+      reducer: () => null,
+      recover({ insertToken, addError, finish, crash }) {
+        const inserted = insertToken(
+          new Token<SemiTokenType, {}>(SemiTokenType.SEMICOLON, ";", new ColumnAndRow(0, 0), {}),
+        );
+        if (inserted != null) return crash(inserted.reason);
+        addError("inserted a semicolon");
+        return finish();
+      },
+    });
+
+    expect(parser.parse().errors[0].token.line).toBe(1);
+  });
+
+  it("refuses to insert a token the current state does not accept", () => {
+    const generator = productionsWithSemicolon();
+    let reason: string | null = null;
+
+    const parser = generator.generate(semiLexer("1"), {
+      reducer: () => null,
+      recover({ insertToken, crash }) {
+        // NUMBER is not shiftable at this point, so inserting it has to be refused.
+        const inserted = insertToken(new Token<SemiTokenType, {}>(SemiTokenType.NUMBER, "1", new ColumnAndRow(0, 0), {}));
+        if (inserted != null) {
+          reason = inserted.reason;
+          return inserted;
+        }
+        return crash("unreachable");
+      },
+    });
+
+    expect(() => parser.parse()).toThrow(LR1ParserGraveError);
+    expect(reason).toContain("Cannot insert");
+  });
+});
+
+describe("reducer helpers", () => {
+  const grammar = `<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] ([PLUS] [NUMBER])* [EOF];
+`;
+
+  it("lists the productions a grammar names", () => {
+    expect(namedProductions(buildProductions(grammar))).toEqual(["autogenerated-kleene", "program"]);
+  });
+
+  it("names the reducers that are missing", () => {
+    expect(missingReducerNames(buildProductions(grammar), { program: () => null })).toEqual([
+      "autogenerated-kleene",
+    ]);
+  });
+
+  it("explains that * and + need the autogenerated-kleene reducer", () => {
+    expect(() => assertReducersCoverGrammar(buildProductions(grammar), { program: () => null })).toThrow(
+      /autogenerated-kleene/,
+    );
+  });
+
+  it("says which reducers it does have", () => {
+    expect(() => assertReducersCoverGrammar(buildProductions(grammar), {})).toThrow(/Your reducer map is empty/);
+  });
+
+  it("dispatches to the reducer named in the grammar", () => {
+    const generator = Sparse.fromProductions<MathTokenType, {}, string>({
+      productions: buildProductions(grammar),
+      toStringifiedTokenType,
+      quiet: true,
+    });
+
+    const parser = generator.generate(mathLexer("1 + 2"), {
+      reducer: defineReducers({ program: () => "program", "autogenerated-kleene": () => "list" }),
+    });
+
+    expect(parser.parse().result).toBe("program");
+  });
+
+  it("throws a named error when a reducer is missing at parse time", () => {
+    const generator = Sparse.fromProductions<MathTokenType, {}, string>({
+      productions: buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] [EOF];
+`),
+      toStringifiedTokenType,
+      quiet: true,
+    });
+
+    expect(() => generator.generate(mathLexer("1"), { reducer: defineReducers({}) }).parse()).toThrow(
+      /No reducer for production "program"/,
+    );
+  });
+
+  it("surfaces the reducer's own message when a reducer throws", () => {
+    const generator = Sparse.fromProductions<MathTokenType, {}, string>({
+      productions: buildProductions(`<S>: <PROGRAM>;
+<PROGRAM: program>: [NUMBER] [EOF];
+`),
+      toStringifiedTokenType,
+      quiet: true,
+    });
+
+    try {
+      generator
+        .generate(mathLexer("1"), {
+          reducer: () => {
+            throw new Error("I refuse");
+          },
+        })
+        .parse();
+      throw new Error("expected the parse to fail");
+    } catch (err) {
+      expect((err as LR1ParserGraveError<MathTokenType, {}>).reason).toContain("I refuse");
+      expect((err as LR1ParserGraveError<MathTokenType, {}>).reason).toContain('("program")');
+      expect((err as Error).cause).toBeInstanceOf(Error);
+    }
+  });
+});
+
+describe("loading grammars and tables from disk", () => {
+  it("reads a grammar from disk", async () => {
+    const result = await loadGrammar(mathGrammarPath);
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.value.length).toBeGreaterThan(0);
+  });
+
+  it("turns a missing file into a failure", async () => {
+    const result = await loadGrammar(path.join(root, "example/nope.txt"));
+    expect(result.success).toBe(false);
+  });
+
+  it("returns a Result instead of throwing when the grammar is missing", async () => {
+    const result = await Sparse.tryFromGrammarFile<MathTokenType, {}, Node>({
+      grammarPath: path.join(root, "example/math/does-not-exist.txt"),
+      tablePath: mathTablePath,
+      toStringifiedTokenType,
+    });
+
+    expect(result.success).toBe(false);
+    if (result.success === false) expect(result.reason).toContain("Could not read the grammar file");
+  });
+
+  it("reports a table that does not match the grammar", async () => {
+    const wrongTable = path.join(root, "example/kleene-test/grammar.txt");
+    const result = await Sparse.tryFromGrammarFile<MathTokenType, {}, Node>({
+      grammarPath: mathGrammarPath,
+      tablePath: wrongTable,
+      toStringifiedTokenType,
+    });
+
+    expect(result.success).toBe(false);
+    if (result.success === false) expect(result.reason).toContain(wrongTable);
+  });
+
+  it("throws SparseGrammarError with a position", async () => {
+    await expect(
+      Sparse.fromGrammarFile<MathTokenType, {}, Node>({
+        grammarPath: mathGrammarPath,
+        tablePath: mathGrammarPath,
+        toStringifiedTokenType,
+      }),
+    ).rejects.toThrow(SparseGrammarError);
+  });
+
+  it("keeps the math grammar's structure intact", async () => {
+    const productions = buildProductions(await readFile("math/grammar.txt"));
+    expect(productions.map((production) => production.identifier)).toContain("<FACTOR_EXPRESSION>");
+    expect(productions.every((production) => production.rhs.length > 0)).toBe(true);
+  });
+});

package/test/table.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildProductions,
+  buildStates,
+  generateStates,
+  tryBuildStates,
+  validateTable,
+  validateTableStates,
+  TableState,
+  type TableState as TableStateType,
+} from "../src/index";
+import { EXAMPLE_GRAMMARS, readFile } from "./helpers";
+
+const dump = (states: TableStateType[]) =>
+  states.map((state) =>
+    [...state.actions.entries()].map(([key, action]) => `${key}=${action.type === "goto" ? "" : action.type === "shift" ? "s" : "r"}${action.value}`),
+  );
+
+describe("table file parsing", () => {
+  it("reads a hand written table", () => {
+    const states = buildStates(`[EOF]=s1, <PROGRAM>=1\n[EOF]=r0\n`);
+    expect(states.length).toBe(2);
+    expect(states[0].getTerminalAction("EOF")).toEqual({ type: "shift", value: 1 });
+    expect(states[0].getVariableAction("<PROGRAM>")).toEqual({ type: "goto", value: 1 });
+    expect(states[1].getTerminalAction("EOF")).toEqual({ type: "reduce", value: 0 });
+  });
+
+  it("reports malformed actions as failures instead of silently accepting them", () => {
+    const cases: [string, string, string][] = [
+      ["wrong action prefix", `[A]=q3\n`, `"[A]=q3"`],
+      ["non numeric shift", `[A]=sX\n`, `"[A]=sX"`],
+      ["state out of range", `[A]=s99999\n`, "only has 1 states"],
+    ];
+
+    for (const [name, table, expected] of cases) {
+      const result = tryBuildStates(table);
+      expect(result.success, `${name} should fail`).toBe(false);
+      if (result.success === false) expect(result.reason).toContain(expected);
+    }
+  });
+
+  it("reports tables that are not tables at all", () => {
+    for (const table of ["", "hello world\n", "A=s1\n"]) {
+      const result = tryBuildStates(table);
+      expect(result.success).toBe(false);
+      if (result.success === false) expect(result.reason).toContain("Invalid syntax");
+    }
+  });
+
+  it("throws from buildStates, mentioning the position", () => {
+    expect(() => buildStates("hello world\n")).toThrow(/while parsing the parsing table at 1:\d+/);
+  });
+
+  it("rejects an empty table", () => {
+    const result = validateTableStates([]);
+    expect(result.success).toBe(false);
+    if (result.success === false) expect(result.reason).toContain("does not contain any states");
+  });
+
+  it("rejects state 0 without actions", () => {
+    const result = validateTableStates([new TableState()]);
+    expect(result.success).toBe(false);
+    if (result.success === false) expect(result.reason).toContain("State 0 has no actions");
+  });
+
+  it("rejects a terminal mapped to a goto", () => {
+    const states = [new TableState(new Map([["[A]", { type: "goto" as const, value: 0 }]]))];
+    const result = validateTableStates(states);
+    expect(result.success).toBe(false);
+    if (result.success === false) expect(result.reason).toContain("variables can only be reached by a \"goto\"");
+  });
+
+  it("rejects a variable mapped to a shift", () => {
+    const states = [new TableState(new Map([["<A>", { type: "shift" as const, value: 0 }]]))];
+    const result = validateTableStates(states);
+    expect(result.success).toBe(false);
+    if (result.success === false) expect(result.reason).toContain("variables can only be reached by a \"goto\"");
+  });
+});
+
+describe("table generation and round trip", () => {
+  it.each(EXAMPLE_GRAMMARS)("round trips the %s table through the table file format", async (_name, grammarPath) => {
+    const grammar = await readFile(grammarPath);
+    const productions = buildProductions(grammar);
+
+    const result = generateStates(productions);
+    if (result.success === false) throw new Error(result.reason);
+
+    const fromMemory = result.value.toStates();
+    const fromText = tryBuildStates(result.value.toTable(), { productions });
+    if (fromText.success === false) throw new Error(fromText.reason);
+
+    expect(dump(fromText.value)).toEqual(dump(fromMemory));
+  });
+
+  it("rebuilds the committed math table byte for byte", async () => {
+    const committed = await readFile("math/table.txt");
+    const productions = buildProductions(await readFile("math/grammar.txt"));
+    const result = generateStates(productions);
+    if (result.success === false) throw new Error(result.reason);
+    expect(result.value.toTable().trim()).toBe(committed.trim());
+  });
+
+  it("rebuilds the committed LoLang table byte for byte", async () => {
+    const committed = await readFile("LoLang/table.txt");
+    const productions = buildProductions(await readFile("LoLang/grammar.txt"));
+    const result = generateStates(productions);
+    if (result.success === false) throw new Error(result.reason);
+    expect(result.value.toTable().trim()).toBe(committed.trim());
+  });
+
+  it("keeps the JSON representation used for codegen stable", async () => {
+    const productions = buildProductions(await readFile("math/grammar.txt"));
+    const result = generateStates(productions);
+    if (result.success === false) throw new Error(result.reason);
+
+    const json = result.value.toJSObject();
+    const restored = json.map((state) => TableState.fromJSObject(state));
+
+    expect(dump(restored)).toEqual(dump(result.value.toStates()));
+    expect(validateTableStates(restored, { productions }).success).toBe(true);
+  });
+});
+
+describe("validateTable", () => {
+  it("accepts a table that belongs to the grammar", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;\n<PROGRAM: program>: [EOF];\n`);
+    const states = buildStates(`[EOF]=s1, <PROGRAM>=1\n[EOF]=r0\n`);
+    expect(validateTable(productions, states).success).toBe(true);
+  });
+
+  it("rejects a stale table whose reduce actions point past the end of the grammar", () => {
+    const productions = buildProductions(`<S>: <PROGRAM>;\n<PROGRAM: program>: [EOF];\n`);
+    const states = buildStates(`[EOF]=r7\n`);
+    const result = validateTable(productions, states);
+    expect(result.success).toBe(false);
+    if (result.success === false) expect(result.reason).toContain("Is the table stale?");
+  });
+
+  it("rejects an empty grammar", () => {
+    const result = validateTable([], [new TableState(new Map([["[A]", { type: "reduce" as const, value: 0 }]]))]);
+    expect(result.success).toBe(false);
+  });
+});

package/tsconfig.json

@@ -26,5 +26,5 @@
     "types": ["node"]
   },
   "exclude": ["node_modules"],
-  "include": ["./src/**/*.ts", "./example/**/*.ts"]
+  "include": ["./src/**/*.ts", "./example/**/*.ts", "./test/**/*.ts"]
 }

package/example/complicated/grammar.txt

@@ -1,37 +0,0 @@
-<S>: <PROGRAM>;
-<PROGRAM>: (<FUNCTION_DEFINITION_LIST: functions>)? [EOF];
-
-<FUNCTION_DEFINITION_LIST>: <FUNCTION_DEFINITION: function> (<FUNCTION_DEFINITION_LIST: rest>)?;
-<FUNCTION_DEFINITION>: [FUNCTION] [IDENTIFIER] [LPAREN] (<PARAMETER_LIST: parameters>)? [RPAREN] [LBRACE] (<STATEMENT_LIST: statements>)? [RBRACE];
-<PARAMETER_LIST>: [IDENTIFIER: parameter_name] ([COMMA] <PARAMETER_LIST: rest>)?;
-
-<STATEMENT_LIST>: <STATEMENT: stmt> (<STATEMENT_LIST: rest>)?;
-<BLOCK_STATEMENT>: [LBRACE] (<STATEMENT_LIST: stmt_list>) [RBRACE];
-
-<STATEMENT>: <IF_STATEMENT | WHILE_LOOP | EXPRESSION_STATEMENT | BLOCK_STATEMENT | VARIABLE_DEFINITION: stmt>;
-
-<VARIABLE_DEFINITION>: [VAR] [IDENTIFIER: identifier] [EQUALS] <EXPRESSION: expr> [SEMICOLON];
-<IF_STATEMENT>: [IF] [LPAREN] (<EXPRESSION: condition>)? [RPAREN] <STATEMENT: stmt> ([ELSE] <STATEMENT: else_stmt>)?;
-<WHILE_LOOP>: [WHILE] [IDENTIFIER: loop_name] [LPAREN] <EXPRESSION: condition> [RPAREN] <STATEMENT: stmt>;
-<EXPRESSION_STATEMENT>: <EXPRESSION: expr> [SEMICOLON];
-
-<EXPRESSION>: <ASSIGNMENT_EXPRESSION: expr>;
-<ASSIGNMENT_EXPRESSION>: ([IDENTIFIER: identifier] [EQUALS])? <EQUALITY_EXPRESSION: expr>;
-<EQUALITY_EXPRESSION>: <COMPARISON_EXPRESSION: left> ([DOUBLE_EQUALS | NOT_EQUALS: op] <COMPARISON_EXPRESSION: right>)?;
-
-<COMPARISON_EXPRESSION>: <BITWISE_OR_EXPRESSION: left> ([LESS_THAN | GREATER_THAN | LESS_THAN_EQUALS | GREATER_THAN_EQUALS: op] <BITWISE_OR_EXPRESSION: right>)?;
-<BITWISE_OR_EXPRESSION>: <BITWISE_AND_EXPRESSION: left> ([PIPE | TILDE_PIPE: op] <BITWISE_OR_EXPRESSION: right>)?;
-<BITWISE_AND_EXPRESSION>: <BITWISE_XOR_EXPRESSION: left> ([AMPERSAND | TILDE_AMPERSAND: op] <BITWISE_AND_EXPRESSION: right>)?;
-<BITWISE_XOR_EXPRESSION>: <TERM_EXPRESSION: left> ([CARAT | TILDE_CARAT: op] <BITWISE_XOR_EXPRESSION: right>)?;
-
-<TERM_EXPRESSION>: <UNARY_EXPR: left> ([PLUS | MINUS: op] <TERM_EXPRESSION: right>)?;
-<UNARY_EXPR>: ([LEFTSHIFT | RIGHTSHIFT | TILDE: op])? <ENDPOINT: expr>; 
-
-<GROUPING_EXPRESSION>: [LPAREN] <EXPRESSION: expr> [RPAREN];
-<FUNCTION_CALL_EXPRESSION>: [IDENTIFIER: function_name] [LPAREN] (<ARGUMENT_LIST: arguments>)? [RPAREN];
-<ARGUMENT_LIST>: <EXPRESSION: arg> ([COMMA] <ARGUMENT_LIST: rest>)?;
-
-<ENDPOINT>: [IDENTIFIER: identifier];
-<ENDPOINT>: [NUMBER: number];
-<ENDPOINT>: <GROUPING_EXPRESSION: expr>;
-<ENDPOINT>: <FUNCTION_CALL_EXPRESSION: expr>;