yukigo-mini-parser 0.1.0 → 0.1.1

package/src/index.ts

@@ -1,24 +1,39 @@
-import { YukigoParser } from "yukigo-ast";
-import nearley from "nearley";
-import grammar from "./grammar.js";
-
-export class YukigoMiniParser implements YukigoParser {
-  public errors: string[] = [];
-
-  public parse(code: string) {
-    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
-    try {
-      parser.feed(code);
-      parser.finish();
-    } catch (error) {
-      const token = error.token;
-      const message = `Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`;
-      this.errors.push(message)
-    }
-    const results = parser.results
-    if(results.length > 1)
-      throw Error(`Ambiguous grammar. The parser generated ${results.length} ASTs`)
-
-    return results[0]
-  }
-}
+import { AST, Expression, YukigoParser } from "yukigo-ast";
+import nearley from "nearley";
+import grammar from "./grammar.js";
+import { Token } from "moo";
+
+class UnexpectedToken extends Error {
+  constructor(token: Token) {
+    super(
+      `Parser: Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`
+    );
+  }
+}
+
+export class YukigoMiniParser implements YukigoParser {
+  public errors: string[] = [];
+
+  public parse(code: string): AST {
+    return this.feedParser(code);
+  }
+  public parseExpression(code: string): Expression {
+    return this.feedParser(code);
+  }
+  private feedParser(code: string): any {
+    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
+    try {
+      parser.feed(code);
+      parser.finish();
+    } catch (error) {
+      if ("token" in error) throw new UnexpectedToken(error.token);
+      throw error
+    }
+    const results = parser.results;
+    if (results.length > 1)
+      throw Error(
+        `Ambiguous grammar. The parser generated ${results.length} ASTs`
+      );
+    return results[0];
+  }
+}

package/src/lexer.ts

@@ -1,49 +1,49 @@
-import moo from "moo";
-import { makeLexer } from "moo-ignore";
-
-const keywords = [
-  "return",
-  "if",
-  "else"
-]
-
-export const MiniLexerConfig = {
-  EOF: "*__EOF__*",
-  wildcard: "_",
-  WS: /[ \t]+/,
-  comment: /--.*?$|{-[\s\S]*?-}/,
-  number:
-    /0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|(?:\d*\.\d+|\d+)(?:[eE][+-]?\d+)?/,
-  char: /'(?:\\['\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^'\\\n\r])?'/,
-  string: /"(?:\\["\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^"\\\n\r])*"/,
-  bool: {
-    match: ["True", "False"],
-  },
-  semicolon: ";",
-  assign: ":=",
-  notEqual: "!=",
-  equal: "==",
-  gte: ">=",
-  gt: ">",
-  lte: "<=",
-  lt: "<",
-  lparen: "(",
-  rparen: ")",
-  lsquare: "[",
-  rsquare: "]",
-  lbracket: "{",
-  rbracket: "}",
-  comma: ",",
-  operator: /\+|\*/,
-  variable: {
-    match: /[a-z_][a-zA-Z0-9_']*/,
-    type: moo.keywords({
-      keyword: keywords,
-    }),
-  },
-  NL: { match: /\r?\n/, lineBreaks: true },
-};
-
-export const MiniLexer = makeLexer(MiniLexerConfig, ["NL", "comment"], {
-  eof: true,
-});
+import moo from "moo";
+import { makeLexer } from "moo-ignore";
+
+const keywords = [
+  "return",
+  "if",
+  "else"
+]
+
+export const MiniLexerConfig = {
+  EOF: "*__EOF__*",
+  wildcard: "_",
+  WS: /[ \t]+/,
+  comment: /--.*?$|{-[\s\S]*?-}/,
+  number:
+    /0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|(?:\d*\.\d+|\d+)(?:[eE][+-]?\d+)?/,
+  char: /'(?:\\['\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^'\\\n\r])?'/,
+  string: /"(?:\\["\\bfnrtv0]|\\u[0-9a-fA-F]{4}|[^"\\\n\r])*"/,
+  bool: {
+    match: ["True", "False"],
+  },
+  semicolon: ";",
+  assign: ":=",
+  notEqual: "!=",
+  equal: "==",
+  gte: ">=",
+  gt: ">",
+  lte: "<=",
+  lt: "<",
+  lparen: "(",
+  rparen: ")",
+  lsquare: "[",
+  rsquare: "]",
+  lbracket: "{",
+  rbracket: "}",
+  comma: ",",
+  operator: /\+|\*/,
+  variable: {
+    match: /[a-z_][a-zA-Z0-9_']*/,
+    type: moo.keywords({
+      keyword: keywords,
+    }),
+  },
+  NL: { match: /\r?\n/, lineBreaks: true },
+};
+
+export const MiniLexer = makeLexer(MiniLexerConfig, ["NL", "comment"], {
+  eof: true,
+});

package/src/parse.ts

@@ -1,18 +1,18 @@
-import { YukigoMiniParser } from "./index.js";
-
-const parser = new YukigoMiniParser()
-
-const code = `int n
-int result
-
-n := 5
-result := 1
-
-while n > 0 do
-    result := result * n
-    n := n - 1
-endwhile
-
-print result # This should print 120`
-
+import { YukigoMiniParser } from "./index.js";
+
+const parser = new YukigoMiniParser()
+
+const code = `int n
+int result
+
+n := 5
+result := 1
+
+while n > 0 do
+    result := result * n
+    n := n - 1
+endwhile
+
+print result # This should print 120`
+
 console.log(parser.parse(code))

package/tests/parser.spec.ts

@@ -1,158 +1,158 @@
-import { assert } from "chai";
-import {
-  ArithmeticBinaryOperation,
-  Assignment,
-  ComparisonOperation,
-  Equation,
-  If,
-  ListPrimitive,
-  ListType,
-  NilPrimitive,
-  NumberPrimitive,
-  ParameterizedType,
-  Procedure,
-  Return,
-  Sequence,
-  SimpleType,
-  SymbolPrimitive,
-  TypeSignature,
-  UnguardedBody,
-  Variable,
-  VariablePattern,
-  While,
-  YukigoParser,
-} from "yukigo-ast";
-import { YukigoMiniParser } from "../src/index.js";
-
-describe("Parser Tests", () => {
-  let parser: YukigoParser;
-  beforeEach(() => {
-    parser = new YukigoMiniParser();
-  });
-
-  it("should parse assignment", () => {
-    const code = `int n; int result;`;
-    assert.deepEqual(parser.parse(code), [
-      new Variable(
-        new SymbolPrimitive("n"),
-        new NilPrimitive(null),
-        new SimpleType("int", [])
-      ),
-      new Variable(
-        new SymbolPrimitive("result"),
-        new NilPrimitive(null),
-        new SimpleType("int", [])
-      ),
-    ]);
-  });
-  it("should parse function declaration", () => {
-    const code = `int add(int x, int y) {
-  int result := x + y;
-  return result;
-};`;
-    assert.deepEqual(parser.parse(code), [
-      new TypeSignature(
-        new SymbolPrimitive("add"),
-        new ParameterizedType(
-          [new SimpleType("int", []), new SimpleType("int", [])],
-          new SimpleType("int", []),
-          []
-        )
-      ),
-      new Procedure(new SymbolPrimitive("add"), [
-        new Equation(
-          [
-            new VariablePattern(new SymbolPrimitive("x")),
-            new VariablePattern(new SymbolPrimitive("y")),
-          ],
-          new UnguardedBody(
-            new Sequence([
-              new Variable(
-                new SymbolPrimitive("result"),
-                new ArithmeticBinaryOperation(
-                  "Plus",
-                  new SymbolPrimitive("x"),
-                  new SymbolPrimitive("y")
-                ),
-                new SimpleType("int", [])
-              ),
-              new Return(new SymbolPrimitive("result")),
-            ])
-          )
-        ),
-      ]),
-    ]);
-  });
-  it("should parse list primitive", () => {
-    const code = `int[] numberList := [1, 2, 3 + 4];`;
-    assert.deepEqual(parser.parse(code), [
-      new Variable(
-        new SymbolPrimitive("numberList"),
-        new ListPrimitive([
-          new NumberPrimitive(1),
-          new NumberPrimitive(2),
-          new ArithmeticBinaryOperation(
-            "Plus",
-            new NumberPrimitive(3),
-            new NumberPrimitive(4)
-          ),
-        ]),
-        new ListType(new SimpleType("int", []), [])
-      ),
-    ]);
-  });
-  it("should parse if statement", () => {
-    const code = `if(a != b) { c := a + b; } else { c := a * 2; };`;
-    assert.deepEqual(parser.parse(code), [
-      new If(
-        new ComparisonOperation(
-          "NotEqual",
-          new SymbolPrimitive("a"),
-          new SymbolPrimitive("b")
-        ),
-        new Sequence([
-          new Assignment(
-            new SymbolPrimitive("c"),
-            new ArithmeticBinaryOperation(
-              "Plus",
-              new SymbolPrimitive("a"),
-              new SymbolPrimitive("b")
-            )
-          ),
-        ]),
-        new Sequence([
-          new Assignment(
-            new SymbolPrimitive("c"),
-            new ArithmeticBinaryOperation(
-              "Multiply",
-              new SymbolPrimitive("a"),
-              new NumberPrimitive(2)
-            )
-          ),
-        ]),
-      ),
-    ]);
-  });
-  it("should parse while loop statement", () => {
-    const code = `while(a < 10) { a := a + 1; };`;
-    assert.deepEqual(parser.parse(code), [
-      new While(
-        new ComparisonOperation(
-          "LessThan",
-          new SymbolPrimitive("a"),
-          new NumberPrimitive(10)
-        ),
-        new Sequence([
-          new Assignment(
-            new SymbolPrimitive("a"),
-            new ArithmeticBinaryOperation(
-              "Plus",
-              new SymbolPrimitive("a"),
-              new NumberPrimitive(1)
-            )
-          ),
-        ]),
-      ),
-    ]);
-  });
-});
+import { assert } from "chai";
+import {
+  ArithmeticBinaryOperation,
+  Assignment,
+  ComparisonOperation,
+  Equation,
+  If,
+  ListPrimitive,
+  ListType,
+  NilPrimitive,
+  NumberPrimitive,
+  ParameterizedType,
+  Procedure,
+  Return,
+  Sequence,
+  SimpleType,
+  SymbolPrimitive,
+  TypeSignature,
+  UnguardedBody,
+  Variable,
+  VariablePattern,
+  While,
+  YukigoParser,
+} from "yukigo-ast";
+import { YukigoMiniParser } from "../src/index.js";
+
+describe("Parser Tests", () => {
+  let parser: YukigoParser;
+  beforeEach(() => {
+    parser = new YukigoMiniParser();
+  });
+
+  it("should parse assignment", () => {
+    const code = `int n; int result;`;
+    assert.deepEqual(parser.parse(code), [
+      new Variable(
+        new SymbolPrimitive("n"),
+        new NilPrimitive(null),
+        new SimpleType("int", [])
+      ),
+      new Variable(
+        new SymbolPrimitive("result"),
+        new NilPrimitive(null),
+        new SimpleType("int", [])
+      ),
+    ]);
+  });
+  it("should parse function declaration", () => {
+    const code = `int add(int x, int y) {
+  int result := x + y;
+  return result;
+};`;
+    assert.deepEqual(parser.parse(code), [
+      new TypeSignature(
+        new SymbolPrimitive("add"),
+        new ParameterizedType(
+          [new SimpleType("int", []), new SimpleType("int", [])],
+          new SimpleType("int", []),
+          []
+        )
+      ),
+      new Procedure(new SymbolPrimitive("add"), [
+        new Equation(
+          [
+            new VariablePattern(new SymbolPrimitive("x")),
+            new VariablePattern(new SymbolPrimitive("y")),
+          ],
+          new UnguardedBody(
+            new Sequence([
+              new Variable(
+                new SymbolPrimitive("result"),
+                new ArithmeticBinaryOperation(
+                  "Plus",
+                  new SymbolPrimitive("x"),
+                  new SymbolPrimitive("y")
+                ),
+                new SimpleType("int", [])
+              ),
+              new Return(new SymbolPrimitive("result")),
+            ])
+          )
+        ),
+      ]),
+    ]);
+  });
+  it("should parse list primitive", () => {
+    const code = `int[] numberList := [1, 2, 3 + 4];`;
+    assert.deepEqual(parser.parse(code), [
+      new Variable(
+        new SymbolPrimitive("numberList"),
+        new ListPrimitive([
+          new NumberPrimitive(1),
+          new NumberPrimitive(2),
+          new ArithmeticBinaryOperation(
+            "Plus",
+            new NumberPrimitive(3),
+            new NumberPrimitive(4)
+          ),
+        ]),
+        new ListType(new SimpleType("int", []), [])
+      ),
+    ]);
+  });
+  it("should parse if statement", () => {
+    const code = `if (a != b) { c := a + b; } else { c := a * 2; };`;
+    assert.deepEqual(parser.parse(code), [
+      new If(
+        new ComparisonOperation(
+          "NotEqual",
+          new SymbolPrimitive("a"),
+          new SymbolPrimitive("b")
+        ),
+        new Sequence([
+          new Assignment(
+            new SymbolPrimitive("c"),
+            new ArithmeticBinaryOperation(
+              "Plus",
+              new SymbolPrimitive("a"),
+              new SymbolPrimitive("b")
+            )
+          ),
+        ]),
+        new Sequence([
+          new Assignment(
+            new SymbolPrimitive("c"),
+            new ArithmeticBinaryOperation(
+              "Multiply",
+              new SymbolPrimitive("a"),
+              new NumberPrimitive(2)
+            )
+          ),
+        ])
+      ),
+    ]);
+  });
+  it("should parse while loop statement", () => {
+    const code = `while (a < 10) { a := a + 1; };`;
+    assert.deepEqual(parser.parse(code), [
+      new While(
+        new ComparisonOperation(
+          "LessThan",
+          new SymbolPrimitive("a"),
+          new NumberPrimitive(10)
+        ),
+        new Sequence([
+          new Assignment(
+            new SymbolPrimitive("a"),
+            new ArithmeticBinaryOperation(
+              "Plus",
+              new SymbolPrimitive("a"),
+              new NumberPrimitive(1)
+            )
+          ),
+        ])
+      ),
+    ]);
+  });
+});

package/tsconfig.json

@@ -1,17 +1,24 @@
-{
-  "compilerOptions": {
-    "target": "ES2024",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2024"],
-    "outDir": "./dist",
-    "declaration": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "sourceMap": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true
-  },
-  "include": ["src"],
-  "exclude": ["dist/**/*"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2024"],
+    "outDir": "./dist",
+    "declaration": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "sourceMap": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "exclude": [
+    "dist/**/*"
+  ],
+  "references": [
+    {
+      "path": "../yukigo-ast"
+    }
+  ]
+}