@divmain/jdm-asm 0.2.0

package/src/compiler/expression-parser.ts

@@ -0,0 +1,536 @@
+import { createToken, CstParser, Lexer, type IToken } from 'chevrotain';
+import { CompilationError, ErrorCode, type SourceLocation } from './errors';
+
+// === TOKENS (order matters - longer matches first) ===
+
+const WhiteSpace = createToken({
+  name: 'WhiteSpace',
+  pattern: /\s+/,
+  group: Lexer.SKIPPED,
+});
+
+const DotDot = createToken({ name: 'DotDot', pattern: /\.\./ });
+const Dot = createToken({ name: 'Dot', pattern: /\./ });
+
+const Eq = createToken({ name: 'Eq', pattern: /==/ });
+const NotEq = createToken({ name: 'NotEq', pattern: /!=/ });
+const EqEq = createToken({ name: 'EqEq', pattern: /===/ });
+const NotEqEq = createToken({ name: 'NotEqEq', pattern: /!==/ });
+const LtEq = createToken({ name: 'LtEq', pattern: /<=/ });
+const GtEq = createToken({ name: 'GtEq', pattern: />=/ });
+const Lt = createToken({ name: 'Lt', pattern: /</ });
+const Gt = createToken({ name: 'Gt', pattern: />/ });
+
+const AndAnd = createToken({ name: 'AndAnd', pattern: /&&/ });
+const OrOr = createToken({ name: 'OrOr', pattern: /\|\|/ });
+const NotNot = createToken({ name: 'NotNot', pattern: /!/ });
+
+// Keywords use longer_alt to ensure 'and'/'or' are recognized as operators rather than
+// variable names - Chevrotain tries longer_alt tokens first, preventing 'android' from
+// incorrectly tokenizing as 'and' + 'roid'.
+const Identifier = createToken({ name: 'Identifier', pattern: /[$a-zA-Z_]\w*/ });
+
+const And = createToken({ name: 'And', pattern: /and/, longer_alt: Identifier });
+const Or = createToken({ name: 'Or', pattern: /or/, longer_alt: Identifier });
+const Not = createToken({ name: 'Not', pattern: /not/, longer_alt: Identifier });
+const In = createToken({ name: 'In', pattern: /in/, longer_alt: Identifier });
+
+const True = createToken({ name: 'True', pattern: /true/, longer_alt: Identifier });
+const False = createToken({ name: 'False', pattern: /false/, longer_alt: Identifier });
+const Null = createToken({ name: 'Null', pattern: /null/, longer_alt: Identifier });
+
+const NumberLiteral = createToken({
+  name: 'NumberLiteral',
+  pattern: /\d[\d_]*(\.\d+)?/,
+});
+
+const StringLiteral = createToken({
+  name: 'StringLiteral',
+  pattern: /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,
+});
+
+// Template strings
+// Token order critical: TemplateHead/Middle/Tail must precede TemplateNoSub because Chevrotain matches first token that fits.
+// Without this order, '`foo${x}`' would incorrectly match TemplateNoSub instead of TemplateHead + expr + TemplateTail.
+// TemplateNoSub pattern must explicitly exclude ${ to prevent ambiguity between templates with/without interpolation.
+const TemplateHead = createToken({
+  name: 'TemplateHead',
+  pattern: /`(?:[^`\\$]|\\.|\$(?!\{))*?\$\{/,
+});
+const TemplateMiddle = createToken({
+  name: 'TemplateMiddle',
+  pattern: /\}(?:[^`\\$]|\\.|\$(?!\{))*?\$\{/,
+});
+const TemplateTail = createToken({
+  name: 'TemplateTail',
+  pattern: /\}(?:[^`\\$]|\\.|\$(?!\{))*?`/,
+});
+// TemplateNoSub should NOT match strings that contain ${, so we exclude them explicitly
+const TemplateNoSub = createToken({
+  name: 'TemplateNoSub',
+  pattern: /`(?:[^`\\$]|\\.|\$(?!\{))*?`/,
+});
+
+const Hash = createToken({ name: 'Hash', pattern: /#/ }); // Current element in higher-order functions
+// Dollar ($) represents explicit reference in unary mode. Uses longer_alt: Identifier to ensure $-prefixed identifiers like '$myVar'
+// are tokenized as a single Identifier token rather than separate Dollar + Identifier tokens, since Identifier pattern includes '$' prefix.
+const Dollar = createToken({ name: 'Dollar', pattern: /\$/, longer_alt: Identifier });
+
+// Operators and delimiters
+const Plus = createToken({ name: 'Plus', pattern: /\+/ });
+const Minus = createToken({ name: 'Minus', pattern: /-/ });
+const Mult = createToken({ name: 'Mult', pattern: /\*/ });
+const Div = createToken({ name: 'Div', pattern: /\// });
+const Mod = createToken({ name: 'Mod', pattern: /%/ });
+const Power = createToken({ name: 'Power', pattern: /\^/ });
+
+const LParen = createToken({ name: 'LParen', pattern: /\(/ });
+const RParen = createToken({ name: 'RParen', pattern: /\)/ });
+const LBracket = createToken({ name: 'LBracket', pattern: /\[/ });
+const RBracket = createToken({ name: 'RBracket', pattern: /\]/ });
+
+const LBrace = createToken({ name: 'LBrace', pattern: /\{/ });
+const RBrace = createToken({ name: 'RBrace', pattern: /\}/ });
+
+const Comma = createToken({ name: 'Comma', pattern: /,/ });
+const Question = createToken({ name: 'Question', pattern: /\?/, longer_alt: Identifier });
+const QuestionQuestion = createToken({ name: 'QuestionQuestion', pattern: /\?\?/ });
+const Colon = createToken({ name: 'Colon', pattern: /:/ });
+
+const allTokens = [
+  WhiteSpace,
+  DotDot,
+  Dot,
+  EqEq,
+  NotEqEq,
+  Eq,
+  NotEq,
+  LtEq,
+  GtEq,
+  Lt,
+  Gt,
+  AndAnd,
+  OrOr,
+  NotNot,
+  And,
+  Or,
+  Not,
+  In,
+  True,
+  False,
+  Null,
+  Plus,
+  Minus,
+  Mult,
+  Div,
+  Mod,
+  Power,
+  LParen,
+  RParen,
+  LBracket,
+  RBracket,
+  LBrace,
+  // Template tokens must come before RBrace so that TemplateTail/TemplateMiddle can match }
+  TemplateHead,
+  TemplateMiddle,
+  TemplateTail,
+  TemplateNoSub,
+  RBrace,
+  Comma,
+  QuestionQuestion,
+  Question,
+  Colon,
+  Hash,
+  Dollar,
+  NumberLiteral,
+  StringLiteral,
+  Identifier,
+];
+
+// === PARSER (precedence via rule layering) ===
+// Precedence (lowest to highest):
+// 1. Ternary: ? :
+// 2. Null coalescing: ??
+// 3. Logical OR: or
+// 4. Logical AND: and
+// 5. Comparison: ==, !=, <, >, <=, >=, in, not in
+// 6. Additive: +, -
+// 7. Multiplicative: *, /, %
+// 8. Power: ^ (RIGHT-ASSOCIATIVE)
+// 9. Unary: not, -
+// 10. Postfix: .property, [index], (call)
+// 11. Primary: literals, identifiers, parentheses
+
+class ZenExpressionParser extends CstParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis();
+  }
+
+  // Entry - ternary (lowest precedence)
+  expression = this.RULE('expression', () => {
+    this.SUBRULE(this.nullCoalescingExpression, { LABEL: 'condition' });
+    this.OPTION(() => {
+      this.CONSUME(Question);
+      this.SUBRULE2(this.expression, { LABEL: 'consequent' });
+      this.CONSUME(Colon);
+      this.SUBRULE3(this.expression, { LABEL: 'alternate' });
+    });
+  });
+
+  nullCoalescingExpression = this.RULE('nullCoalescingExpression', () => {
+    this.SUBRULE(this.orExpression, { LABEL: 'lhs' });
+    this.MANY(() => {
+      this.CONSUME(QuestionQuestion);
+      this.SUBRULE2(this.orExpression, { LABEL: 'rhs' });
+    });
+  });
+
+  orExpression = this.RULE('orExpression', () => {
+    this.SUBRULE(this.andExpression, { LABEL: 'lhs' });
+    this.MANY(() => {
+      this.OR([{ ALT: () => this.CONSUME(Or) }, { ALT: () => this.CONSUME(OrOr) }]);
+      this.SUBRULE2(this.andExpression, { LABEL: 'rhs' });
+    });
+  });
+
+  andExpression = this.RULE('andExpression', () => {
+    this.SUBRULE(this.comparisonExpression, { LABEL: 'lhs' });
+    this.MANY(() => {
+      this.OR([{ ALT: () => this.CONSUME(And) }, { ALT: () => this.CONSUME(AndAnd) }]);
+      this.SUBRULE2(this.comparisonExpression, { LABEL: 'rhs' });
+    });
+  });
+
+  comparisonExpression = this.RULE('comparisonExpression', () => {
+    this.SUBRULE(this.additiveExpression, { LABEL: 'lhs' });
+    this.OPTION(() => {
+      this.OR([
+        { ALT: () => this.CONSUME(Eq) },
+        { ALT: () => this.CONSUME(NotEq) },
+        { ALT: () => this.CONSUME(Lt) },
+        { ALT: () => this.CONSUME(Gt) },
+        { ALT: () => this.CONSUME(LtEq) },
+        { ALT: () => this.CONSUME(GtEq) },
+        { ALT: () => this.CONSUME(In) },
+        {
+          ALT: () => {
+            this.CONSUME(Not);
+            this.CONSUME2(In);
+          },
+        }, // not in
+      ]);
+      this.SUBRULE2(this.additiveExpression, { LABEL: 'rhs' });
+    });
+  });
+
+  additiveExpression = this.RULE('additiveExpression', () => {
+    this.SUBRULE(this.multiplicativeExpression, { LABEL: 'lhs' });
+    this.MANY(() => {
+      this.OR([{ ALT: () => this.CONSUME(Plus) }, { ALT: () => this.CONSUME(Minus) }]);
+      this.SUBRULE2(this.multiplicativeExpression, { LABEL: 'rhs' });
+    });
+  });
+
+  multiplicativeExpression = this.RULE('multiplicativeExpression', () => {
+    this.SUBRULE(this.powerExpression, { LABEL: 'lhs' });
+    this.MANY(() => {
+      this.OR([
+        { ALT: () => this.CONSUME(Mult) },
+        { ALT: () => this.CONSUME(Div) },
+        { ALT: () => this.CONSUME(Mod) },
+      ]);
+      this.SUBRULE2(this.powerExpression, { LABEL: 'rhs' });
+    });
+  });
+
+  // Power is RIGHT-ASSOCIATIVE to match mathematical convention:
+  //  e.g. 2^3^4 = 2^(3^4) = 2^81, not (2^3)^4 = 8^4 = 4096.
+  // Use self-recursion instead of MANY for right-associativity
+  powerExpression = this.RULE('powerExpression', () => {
+    this.SUBRULE(this.unaryExpression, { LABEL: 'base' });
+    this.OPTION(() => {
+      this.CONSUME(Power);
+      this.SUBRULE(this.powerExpression, { LABEL: 'exponent' }); // Self-recursion!
+    });
+  });
+
+  unaryExpression = this.RULE('unaryExpression', () => {
+    this.OR([
+      {
+        ALT: () => {
+          this.CONSUME(Not);
+          this.SUBRULE(this.unaryExpression, { LABEL: 'operand' });
+        },
+      },
+      {
+        ALT: () => {
+          this.CONSUME(NotNot);
+          this.SUBRULE2(this.unaryExpression, { LABEL: 'operand' });
+        },
+      },
+      {
+        ALT: () => {
+          this.CONSUME(Minus);
+          this.SUBRULE3(this.unaryExpression, { LABEL: 'operand' });
+        },
+      },
+      { ALT: () => this.SUBRULE(this.postfixExpression) },
+    ]);
+  });
+
+  // Postfix: .property, [index], (args)
+  postfixExpression = this.RULE('postfixExpression', () => {
+    this.SUBRULE(this.primaryExpression);
+    this.MANY(() => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(Dot);
+            this.CONSUME(Identifier, { LABEL: 'property' });
+          },
+        },
+        {
+          ALT: () => {
+            this.CONSUME(LBracket);
+            this.SUBRULE(this.expression, { LABEL: 'index' });
+            this.CONSUME(RBracket);
+          },
+        },
+        {
+          ALT: () => {
+            this.CONSUME(LParen);
+            this.OPTION(() => this.SUBRULE(this.argumentList));
+            this.CONSUME(RParen);
+          },
+        },
+      ]);
+    });
+  });
+
+  primaryExpression = this.RULE('primaryExpression', () => {
+    this.OR([
+      { ALT: () => this.CONSUME(NumberLiteral) },
+      { ALT: () => this.CONSUME(StringLiteral) },
+      { ALT: () => this.SUBRULE(this.templateLiteral) },
+      { ALT: () => this.CONSUME(True) },
+      { ALT: () => this.CONSUME(False) },
+      { ALT: () => this.CONSUME(Null) },
+      { ALT: () => this.CONSUME(Hash) }, // # for current element in higher-order functions
+      { ALT: () => this.CONSUME(Dollar) }, // $ for explicit reference in unary mode
+      { ALT: () => this.CONSUME(Identifier) },
+      // Array literal: [1, 2, 3]
+      {
+        GATE: () => this.isArrayLiteralStart(),
+        ALT: () => this.SUBRULE(this.arrayLiteralExpression),
+      },
+      // Object literal: {key: value, ...}
+      {
+        GATE: () => this.isObjectLiteralStart(),
+        ALT: () => this.SUBRULE(this.objectLiteralExpression),
+      },
+      {
+        ALT: () => {
+          this.CONSUME(LParen);
+          this.SUBRULE(this.expression);
+          this.CONSUME(RParen);
+        },
+      },
+      // Interval: use GATE to check for DotDot lookahead
+      {
+        GATE: () => this.isIntervalStart(),
+        ALT: () => this.SUBRULE(this.intervalExpression),
+      },
+    ]);
+  });
+
+  // Template string: `Hello ${name}, you have ${count} items`
+  templateLiteral = this.RULE('templateLiteral', () => {
+    this.OR([
+      // Simple template with no interpolation
+      { ALT: () => this.CONSUME(TemplateNoSub) },
+      // Template with interpolation
+      {
+        ALT: () => {
+          this.CONSUME(TemplateHead);
+          this.SUBRULE(this.expression, { LABEL: 'expr' });
+          this.MANY(() => {
+            this.CONSUME(TemplateMiddle);
+            this.SUBRULE2(this.expression, { LABEL: 'expr' });
+          });
+          this.CONSUME(TemplateTail);
+        },
+      },
+    ]);
+  });
+
+  // Interval: [a..b] or (a..b) with open/closed variations
+  intervalExpression = this.RULE('intervalExpression', () => {
+    this.OR([
+      { ALT: () => this.CONSUME(LBracket, { LABEL: 'startBracket' }) },
+      { ALT: () => this.CONSUME(LParen, { LABEL: 'startBracket' }) },
+    ]);
+
+    this.SUBRULE(this.expression, { LABEL: 'start' });
+    this.CONSUME(DotDot);
+    this.SUBRULE2(this.expression, { LABEL: 'end' });
+
+    this.OR2([
+      { ALT: () => this.CONSUME(RBracket, { LABEL: 'endBracket' }) },
+      { ALT: () => this.CONSUME(RParen, { LABEL: 'endBracket' }) },
+    ]);
+  });
+
+  // Array literal: [1, 2, 3] or []
+  arrayLiteralExpression = this.RULE('arrayLiteralExpression', () => {
+    this.CONSUME(LBracket);
+    this.OPTION(() => this.SUBRULE(this.argumentList));
+    this.CONSUME(RBracket);
+  });
+
+  // Object literal: {key: value, ...} or {}
+  objectLiteralExpression = this.RULE('objectLiteralExpression', () => {
+    this.CONSUME(LBrace);
+    this.OPTION(() => this.SUBRULE(this.objectPropertyList));
+    this.CONSUME(RBrace);
+  });
+
+  // Object property list for object literals
+  objectPropertyList = this.RULE('objectPropertyList', () => {
+    this.SUBRULE(this.objectProperty, { LABEL: 'prop' });
+    this.MANY(() => {
+      this.CONSUME(Comma);
+      this.SUBRULE2(this.objectProperty, { LABEL: 'prop' });
+    });
+  });
+
+  // Single object property: key: value
+  objectProperty = this.RULE('objectProperty', () => {
+    this.OR([
+      { ALT: () => this.CONSUME(StringLiteral, { LABEL: 'key' }) },
+      { ALT: () => this.CONSUME(Identifier, { LABEL: 'key' }) },
+    ]);
+    this.CONSUME(Colon);
+    this.SUBRULE(this.expression, { LABEL: 'value' });
+  });
+
+  argumentList = this.RULE('argumentList', () => {
+    this.SUBRULE(this.expression, { LABEL: 'arg' });
+    this.MANY(() => {
+      this.CONSUME(Comma);
+      this.SUBRULE2(this.expression, { LABEL: 'arg' });
+    });
+  });
+
+  // Helper: Check if current position starts an array literal
+  // An array literal is [ followed by expressions and commas, then ]
+  // We must distinguish [1,2] from [a..b]. An interval ALWAYS contains .. before closing
+  private isArrayLiteralStart(): boolean {
+    const lookahead = this.LA(1);
+    if (!lookahead || lookahead.tokenType !== LBracket) {
+      return false;
+    }
+
+    // Check if we have .. before a closing bracket (interval)
+    // If yes, this is not an array literal
+    return !this.isIntervalStart();
+  }
+
+  // Helper: Check if current position starts an object literal
+  // An object literal is { followed by key:value pairs and commas, then }
+  private isObjectLiteralStart(): boolean {
+    const lookahead = this.LA(1);
+    if (!lookahead || lookahead.tokenType !== LBrace) {
+      return false;
+    }
+    return true;
+  }
+
+  // Helper: Check if current position starts an interval (lookahead for ..)
+  // An interval is [expr..expr] or (expr..expr)
+  //
+  // We verify that after the start bracket, we'll eventually see .. before a closing bracket
+  // O(n) lookahead required because interval syntax '[1..10]' is ambiguous with array literals
+  // '[1,2,3]' - we must scan ahead to find '..' token to disambiguate, potentially examining
+  // entire token stream for malformed input.
+  private isIntervalStart(): boolean {
+    const lookahead = this.LA(1);
+    if (!lookahead) {
+      return false;
+    }
+    const tokenType = lookahead.tokenType;
+
+    // Only intervals start with [ or ( and must contain .. before closing
+    if (tokenType !== LBracket && tokenType !== LParen) {
+      return false;
+    }
+
+    // Look ahead through tokens to see if we find DotDot before a closing bracket
+    // Note: Chevrotain's LA() returns EOF token (not null) when past end of input
+    let depth = 0;
+    let i = 0;
+    while (true) {
+      const token = this.LA(++i);
+      // Check for end of input - LA() returns EOF token, not null
+      if (!token || token.tokenType.name === 'EOF') {
+        break;
+      }
+
+      const tt = token.tokenType;
+      if (tt === LBracket || tt === LParen || tt === LBrace) {
+        depth++;
+      } else if (tt === RBracket || tt === RParen || tt === RBrace) {
+        if (depth === 0) {
+          // Found end before DotDot - not an interval
+          return false;
+        }
+        depth--;
+      } else if (tt === DotDot) {
+        // Found DotDot before closing - this is an interval!
+        return true;
+      }
+    }
+
+    return false;
+  }
+}
+
+export const parser = new ZenExpressionParser();
+export const lexer = new Lexer(allTokens);
+
+/**
+ * Parse an expression string and return the CST.
+ *
+ * @param input - The expression string to parse
+ * @param location - Optional source location for error reporting
+ * @returns The Concrete Syntax Tree (CST)
+ * @throws Error if the parse fails
+ */
+export function parseExpression(input: string, location?: SourceLocation): any {
+  const lexResult = lexer.tokenize(input);
+
+  if (lexResult.errors.length > 0) {
+    throw new CompilationError(
+      `Lexer error: ${lexResult.errors.map((e) => e.message).join(', ')}`,
+      ErrorCode.PARSE_ERROR,
+      location,
+      { expression: input },
+    );
+  }
+
+  parser.input = lexResult.tokens;
+  const cst = parser.expression();
+
+  if (parser.errors.length > 0) {
+    throw new CompilationError(
+      `Parse error: ${parser.errors.map((e) => e.message).join(', ')}`,
+      ErrorCode.PARSE_ERROR,
+      location,
+      { expression: input },
+    );
+  }
+
+  return cst;
+}
+
+export type { IToken };