yukigo-mini-parser 0.1.3 → 0.2.2

package/src/grammar.ne

@@ -1,132 +1,131 @@
-@{%
-import { MiniLexer } from "./lexer.js"
-import { 
-    SimpleType, 
-    Assignment, 
-    Variable,
-    ListPrimitive,
-    ListType,
-    ArithmeticBinaryOperation, 
-    SymbolPrimitive, 
-    NumberPrimitive, 
-    ComparisonOperation,
-    BooleanPrimitive, 
-    StringPrimitive, 
-    ParameterizedType,
-    Sequence,
-    UnguardedBody,
-    If,
-    While,
-    VariablePattern,
-    Equation,
-    Procedure,
-    TypeSignature,
-    CharPrimitive,
-    NilPrimitive,
-    Return
-} from "yukigo-ast"
-%}
-
-@preprocessor typescript
-@lexer MiniLexer
-
-program -> _ statements _ %EOF {% (d) => d[1].flat(Infinity) %}
-
-statements -> 
-    statement {% (d) => [d[0]] %}
-    | statements _ statement {% (d) => [...d[0], d[2]] %}
-
-# Statements
-
-statement -> (assignment | variable_statement | function_statement | return_statement | if_statement | while_statement) _ ";" {% (d) => d[0][0] %}
-
-variable_statement -> type __ variable (_ ":=" _ expression):? {% (d) => new Variable(d[2], d[3] ? d[3][3] : new NilPrimitive(null), d[0]) %}
-
-return_statement -> "return" _ expression {% (d) => new Return(d[2]) %}
-
-while_statement -> "while" _ condition _ statement_list {% d => new While(d[2], d[4]) %}
-
-if_statement -> "if" _ condition _ statement_list _ "else" _ statement_list {% d => new If(d[2], d[4], d[8]) %}
-
-condition -> "(" _ expression _ ")" {% (d) => d[2] %}
-
-statement_list -> "{" _ body _ "}" {% d => d[2] %}
-body -> 
-    statements {% (d) => new Sequence(d[0].flat(Infinity)) %}
-    | null {% () => new Sequence([]) %}
-
-assignment -> variable _ ":=" _ expression {% (d) => new Assignment(d[0], d[4]) %}
-
-## Function rules
-
-function_statement -> type __ variable ("(" _ param_list:? _ ")" _ statement_list) {% (d) => {
-    const paramTypeList = []
-    const patternList = []
-    if(d[3][2]) {
-        for(const [paramType, paramPattern] of d[3][2]) {
-            paramTypeList.push(paramType);
-            patternList.push(paramPattern);
-        }
-    }
-    const signatureType = new ParameterizedType(paramTypeList, d[0], []) 
-
-    const signature = new TypeSignature(d[2], signatureType);
-    const procedure =  new Procedure(d[2], [new Equation(patternList, new UnguardedBody(d[3][6]))])
-    return [signature, procedure]
-}%}
-
-param_list -> param (_ "," _ param):* {% d => [d[0], ...d[1].map(x => x[3])] %}
-
-param -> type __ variable {% d => [d[0], new VariablePattern(d[2])] %}
-
-
-# Expressions
-
-expression -> comparison {% (d) => d[0] %}
-
-comparison ->
-    addition _ comparison_operator _ addition {% (d) => new ComparisonOperation(d[2], d[0], d[4]) %}
-    | addition {% (d) => d[0] %}
-
-addition -> 
-    addition _ "+" _ multiplication {% (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4]) %}
-    | addition _ "-" _ multiplication {% (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4]) %}
-    | multiplication {% (d) => d[0] %}
-
-multiplication -> 
-    multiplication _ "*" _ primary {% (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4]) %}
-    | multiplication _ "/" _ primary {% (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4]) %}
-    | primary {% (d) => d[0] %}
-
-primary -> 
-    "(" _ expression _ ")" {% (d) => d[2] %}
-    | primitive {% (d) => d[0] %}
-
-primitive -> 
-    %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
-    | %char {% (d) => new CharPrimitive(d[0].value) %}
-    | %string {% (d) => new StringPrimitive(d[0].value) %}
-    | %bool {% (d) => new BooleanPrimitive(d[0].value) %}
-    | variable {% (d) => d[0] %}
-    | list_primitive {% d => d[0] %}
-
-type -> 
-    variable {% (d) => new SimpleType(d[0].value, []) %}
-    | type "[" "]" {% (d) => new ListType(d[0], []) %}
-
-list_primitive -> "[" _ expression_list _ "]" {% (d) => new ListPrimitive(d[2]) %}
-
-expression_list -> expression _ ("," _ expression):* {% (d) => ([d[0], ...d[2].map(x => x[2])]) %}
-
-variable -> %variable {% (d) => new SymbolPrimitive(d[0].value) %}
-
-comparison_operator -> 
-    %equal {% d => "Equal" %}
-    | %notEqual {% d => "NotEqual" %}
-    | %lt {% d => "LessThan" %}
-    | %lte {% d => "LessOrEqualThan" %}
-    | %gt {% d => "GreaterThan" %}
-    | %gte {% d => "GreaterOrEqualThan" %}
-
-_ -> %WS:* {% d => null %}
+@{%
+const { MiniLexer } = require("./lexer.js")
+const { 
+    SimpleType, 
+    Assignment, 
+    Variable,
+    ListPrimitive,
+    ListType,
+    ArithmeticBinaryOperation, 
+    SymbolPrimitive, 
+    NumberPrimitive, 
+    ComparisonOperation,
+    BooleanPrimitive, 
+    StringPrimitive, 
+    ParameterizedType,
+    Sequence,
+    UnguardedBody,
+    If,
+    While,
+    VariablePattern,
+    Equation,
+    Procedure,
+    TypeSignature,
+    CharPrimitive,
+    NilPrimitive,
+    Return
+} = require("yukigo-ast")
+%}
+
+@lexer MiniLexer
+
+program -> _ statements _ %EOF {% (d) => d[1].flat(Infinity) %}
+
+statements -> 
+    statement {% (d) => [d[0]] %}
+    | statements _ statement {% (d) => [...d[0], d[2]] %}
+
+# Statements
+
+statement -> (assignment | variable_statement | function_statement | return_statement | if_statement | while_statement) _ ";" {% (d) => d[0][0] %}
+
+variable_statement -> type __ variable (_ ":=" _ expression):? {% (d) => new Variable(d[2], d[3] ? d[3][3] : new NilPrimitive(null), d[0]) %}
+
+return_statement -> "return" _ expression {% (d) => new Return(d[2]) %}
+
+while_statement -> "while" _ condition _ statement_list {% d => new While(d[2], d[4]) %}
+
+if_statement -> "if" _ condition _ statement_list _ "else" _ statement_list {% d => new If(d[2], d[4], d[8]) %}
+
+condition -> "(" _ expression _ ")" {% (d) => d[2] %}
+
+statement_list -> "{" _ body _ "}" {% d => d[2] %}
+body -> 
+    statements {% (d) => new Sequence(d[0].flat(Infinity)) %}
+    | null {% () => new Sequence([]) %}
+
+assignment -> variable _ ":=" _ expression {% (d) => new Assignment(d[0], d[4]) %}
+
+## Function rules
+
+function_statement -> type __ variable ("(" _ param_list:? _ ")" _ statement_list) {% (d) => {
+    const paramTypeList = []
+    const patternList = []
+    if(d[3][2]) {
+        for(const [paramType, paramPattern] of d[3][2]) {
+            paramTypeList.push(paramType);
+            patternList.push(paramPattern);
+        }
+    }
+    const signatureType = new ParameterizedType(paramTypeList, d[0], []) 
+
+    const signature = new TypeSignature(d[2], signatureType);
+    const procedure =  new Procedure(d[2], [new Equation(patternList, new UnguardedBody(d[3][6]))])
+    return [signature, procedure]
+}%}
+
+param_list -> param (_ "," _ param):* {% d => [d[0], ...d[1].map(x => x[3])] %}
+
+param -> type __ variable {% d => [d[0], new VariablePattern(d[2])] %}
+
+
+# Expressions
+
+expression -> comparison {% (d) => d[0] %}
+
+comparison ->
+    addition _ comparison_operator _ addition {% (d) => new ComparisonOperation(d[2], d[0], d[4]) %}
+    | addition {% (d) => d[0] %}
+
+addition -> 
+    addition _ "+" _ multiplication {% (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4]) %}
+    | addition _ "-" _ multiplication {% (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4]) %}
+    | multiplication {% (d) => d[0] %}
+
+multiplication -> 
+    multiplication _ "*" _ primary {% (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4]) %}
+    | multiplication _ "/" _ primary {% (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4]) %}
+    | primary {% (d) => d[0] %}
+
+primary -> 
+    "(" _ expression _ ")" {% (d) => d[2] %}
+    | primitive {% (d) => d[0] %}
+
+primitive -> 
+    %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
+    | %char {% (d) => new CharPrimitive(d[0].value) %}
+    | %string {% (d) => new StringPrimitive(d[0].value) %}
+    | %bool {% (d) => new BooleanPrimitive(d[0].value) %}
+    | variable {% (d) => d[0] %}
+    | list_primitive {% d => d[0] %}
+
+type -> 
+    variable {% (d) => new SimpleType(d[0].value, []) %}
+    | type "[" "]" {% (d) => new ListType(d[0], []) %}
+
+list_primitive -> "[" _ expression_list _ "]" {% (d) => new ListPrimitive(d[2]) %}
+
+expression_list -> expression _ ("," _ expression):* {% (d) => ([d[0], ...d[2].map(x => x[2])]) %}
+
+variable -> %variable {% (d) => new SymbolPrimitive(d[0].value) %}
+
+comparison_operator -> 
+    %equal {% d => "Equal" %}
+    | %notEqual {% d => "NotEqual" %}
+    | %lt {% d => "LessThan" %}
+    | %lte {% d => "LessOrEqualThan" %}
+    | %gt {% d => "GreaterThan" %}
+    | %gte {% d => "GreaterOrEqualThan" %}
+
+_ -> %WS:* {% d => null %}
 __ -> %WS:+ {% d => null %}

package/src/index.ts

@@ -1,39 +1,50 @@
-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];
-  }
-}
+import { AST, Expression, YukigoParser } from "yukigo-ast";
+import nearley from "nearley";
+import grammar from "./grammar.cjs";
+import { Token } from "moo";
+
+interface NearleyError {
+  token?: any;
+  offset?: number;
+  [key: string]: any;
+}
+
+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 as any),
+    );
+    try {
+      parser.feed(code);
+      parser.finish();
+    } catch (e: unknown) {
+      const error = e as NearleyError; // Assert the shape
+      if (error.token) {
+        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,50 @@
-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";
+// @ts-ignore
+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,
+});