@divmain/jdm-asm 0.2.0 → 0.2.3

package/src/compiler/expression-parser.ts

@@ -1,536 +0,0 @@
-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 };