@forgecharts/sdk 1.1.23

package/src/tscript/parser.ts

@@ -0,0 +1,334 @@
+/**
+ * TScript Parser — recursive-descent, produces a typed AST.
+ *
+ * Precedence (low → high):
+ *   ternary   ? :
+ *   or
+ *   and
+ *   not
+ *   comparison  < > <= >= == !=
+ *   addition    + -
+ *   multiply    * / %
+ *   unary       - (prefix)
+ *   primary     literals, identifiers, index [], call()
+ */
+
+import type {
+  Program, Stmt, Expr,
+  IndicatorDecl, AssignStmt, ExprStmt,
+  NumberLit, StringLit, BoolLit, Identifier,
+  IndexExpr, CallExpr, BinaryExpr, UnaryExpr,
+  TernaryExpr, LogicalExpr,
+} from './ast';
+import { Lexer } from './lexer';
+import type { Token, TokenKind } from './lexer';
+
+export class Parser {
+  private _tokens: Token[];
+  private _pos: number = 0;
+
+  constructor(src: string) {
+    this._tokens = new Lexer(src).tokenize().filter((t) => t.kind !== 'NEWLINE' || this._isStatementBoundary(t));
+    // Re-filter: keep NEWLINEs as statement separators but collapse runs
+    this._tokens = this._collapseNewlines(new Lexer(src).tokenize());
+  }
+
+  parse(): Program {
+    const stmts: Stmt[] = [];
+    this._skipNewlines();
+    while (!this._check('EOF')) {
+      stmts.push(this._stmt());
+      this._skipNewlines();
+    }
+    return { kind: 'Program', stmts };
+  }
+
+  // ─── Statements ─────────────────────────────────────────────────────────────
+
+  private _stmt(): Stmt {
+    // indicator("title")
+    if (this._checkIdent('indicator')) {
+      return this._indicatorDecl();
+    }
+
+    // assignment: IDENT = expr  (but not IDENT == ...)
+    if (this._check('IDENT') && this._peekKind(1) === 'EQ') {
+      return this._assign();
+    }
+
+    return this._exprStmt();
+  }
+
+  private _indicatorDecl(): IndicatorDecl {
+    this._consumeIdent('indicator');
+    this._consume('LPAREN', "Expected '(' after 'indicator'");
+    const title = this._consume('STRING', "Expected string title in indicator()").value;
+    this._consume('RPAREN', "Expected ')' after indicator title");
+    this._consumeNewlineOrEOF();
+    return { kind: 'IndicatorDecl', title };
+  }
+
+  private _assign(): AssignStmt {
+    const name = this._consume('IDENT', 'Expected identifier').value;
+    this._consume('EQ', "Expected '='");
+    const value = this._expr();
+    this._consumeNewlineOrEOF();
+    return { kind: 'AssignStmt', name, value };
+  }
+
+  private _exprStmt(): ExprStmt {
+    const expr = this._expr();
+    this._consumeNewlineOrEOF();
+    return { kind: 'ExprStmt', expr };
+  }
+
+  // ─── Expressions ────────────────────────────────────────────────────────────
+
+  private _expr(): Expr {
+    return this._ternary();
+  }
+
+  private _ternary(): Expr {
+    let left = this._or();
+    if (this._match('QMARK')) {
+      const consequent = this._expr();
+      this._consume('COLON', "Expected ':' in ternary expression");
+      const alternate = this._expr();
+      const node: TernaryExpr = { kind: 'TernaryExpr', condition: left, consequent, alternate };
+      left = node;
+    }
+    return left;
+  }
+
+  private _or(): Expr {
+    let left = this._and();
+    while (this._checkIdent('or')) {
+      this._advance();
+      const right = this._and();
+      const node: LogicalExpr = { kind: 'LogicalExpr', op: 'or', left, right };
+      left = node;
+    }
+    return left;
+  }
+
+  private _and(): Expr {
+    let left = this._not();
+    while (this._checkIdent('and')) {
+      this._advance();
+      const right = this._not();
+      const node: LogicalExpr = { kind: 'LogicalExpr', op: 'and', left, right };
+      left = node;
+    }
+    return left;
+  }
+
+  private _not(): Expr {
+    if (this._checkIdent('not')) {
+      this._advance();
+      const operand = this._comparison();
+      const node: UnaryExpr = { kind: 'UnaryExpr', op: 'not', operand };
+      return node;
+    }
+    return this._comparison();
+  }
+
+  private _comparison(): Expr {
+    let left = this._addition();
+    while (true) {
+      if (this._match('LTE'))  { left = this._binop('<=', left, this._addition()); continue; }
+      if (this._match('GTE'))  { left = this._binop('>=', left, this._addition()); continue; }
+      if (this._match('EQEQ')) { left = this._binop('==', left, this._addition()); continue; }
+      if (this._match('NEQ'))  { left = this._binop('!=', left, this._addition()); continue; }
+      if (this._match('LT'))   { left = this._binop('<',  left, this._addition()); continue; }
+      if (this._match('GT'))   { left = this._binop('>',  left, this._addition()); continue; }
+      break;
+    }
+    return left;
+  }
+
+  private _addition(): Expr {
+    let left = this._multiplication();
+    while (true) {
+      if (this._match('PLUS'))  { left = this._binop('+', left, this._multiplication()); continue; }
+      if (this._match('MINUS')) { left = this._binop('-', left, this._multiplication()); continue; }
+      break;
+    }
+    return left;
+  }
+
+  private _multiplication(): Expr {
+    let left = this._unary();
+    while (true) {
+      if (this._match('STAR'))    { left = this._binop('*', left, this._unary()); continue; }
+      if (this._match('SLASH'))   { left = this._binop('/', left, this._unary()); continue; }
+      if (this._match('PERCENT')) { left = this._binop('%', left, this._unary()); continue; }
+      break;
+    }
+    return left;
+  }
+
+  private _unary(): Expr {
+    if (this._match('MINUS')) {
+      const operand = this._unary();
+      const node: UnaryExpr = { kind: 'UnaryExpr', op: '-', operand };
+      return node;
+    }
+    return this._primary();
+  }
+
+  private _primary(): Expr {
+    const tok = this._current();
+
+    // Number literal
+    if (tok.kind === 'NUMBER') {
+      this._advance();
+      const node: NumberLit = { kind: 'NumberLit', value: parseFloat(tok.value) };
+      return node;
+    }
+
+    // String literal
+    if (tok.kind === 'STRING') {
+      this._advance();
+      const node: StringLit = { kind: 'StringLit', value: tok.value };
+      return node;
+    }
+
+    // Bool literal
+    if (tok.kind === 'BOOL') {
+      this._advance();
+      const node: BoolLit = { kind: 'BoolLit', value: tok.value === 'true' };
+      return node;
+    }
+
+    // na (special NaN constant)
+    if (tok.kind === 'IDENT' && tok.value === 'na') {
+      this._advance();
+      const node: NumberLit = { kind: 'NumberLit', value: NaN };
+      return node;
+    }
+
+    // Function call: IDENT '(' args ')'
+    if (tok.kind === 'IDENT' && this._peekKind(1) === 'LPAREN') {
+      return this._callExpr();
+    }
+
+    // Identifier (and optional series index)
+    if (tok.kind === 'IDENT') {
+      this._advance();
+      let node: Expr = { kind: 'Identifier', name: tok.value } satisfies Identifier;
+      // Series index: ident[expr]
+      while (this._check('LBRACKET')) {
+        this._advance();
+        const index = this._expr();
+        this._consume('RBRACKET', "Expected ']'");
+        const indexNode: IndexExpr = { kind: 'IndexExpr', series: node, index };
+        node = indexNode;
+      }
+      return node;
+    }
+
+    // Grouped: '(' expr ')'
+    if (tok.kind === 'LPAREN') {
+      this._advance();
+      const inner = this._expr();
+      this._consume('RPAREN', "Expected ')'");
+      return inner;
+    }
+
+    throw new SyntaxError(
+      `[TScript] Unexpected token '${tok.value}' (${tok.kind}) at ${tok.line}:${tok.col}`,
+    );
+  }
+
+  private _callExpr(): CallExpr {
+    const callee = this._consume('IDENT', 'Expected function name').value;
+    this._consume('LPAREN', "Expected '('");
+    const args: Expr[] = [];
+    if (!this._check('RPAREN')) {
+      args.push(this._expr());
+      while (this._match('COMMA')) {
+        args.push(this._expr());
+      }
+    }
+    this._consume('RPAREN', "Expected ')'");
+    return { kind: 'CallExpr', callee, args };
+  }
+
+  // ─── Utility helpers ────────────────────────────────────────────────────────
+
+  private _binop(
+    op: BinaryExpr['op'],
+    left: Expr,
+    right: Expr,
+  ): BinaryExpr {
+    return { kind: 'BinaryExpr', op, left, right };
+  }
+
+  private _current(): Token {
+    return this._tokens[this._pos]!;
+  }
+
+  private _advance(): Token {
+    return this._tokens[this._pos++]!;
+  }
+
+  private _check(kind: TokenKind): boolean {
+    return this._current().kind === kind;
+  }
+
+  private _checkIdent(name: string): boolean {
+    const t = this._current();
+    return t.kind === 'IDENT' && t.value === name;
+  }
+
+  private _peekKind(offset: number): TokenKind {
+    return this._tokens[this._pos + offset]?.kind ?? 'EOF';
+  }
+
+  private _match(kind: TokenKind): boolean {
+    if (this._check(kind)) { this._advance(); return true; }
+    return false;
+  }
+
+  private _consume(kind: TokenKind, msg: string): Token {
+    if (this._check(kind)) return this._advance();
+    const t = this._current();
+    throw new SyntaxError(`[TScript] ${msg} — got '${t.value}' at ${t.line}:${t.col}`);
+  }
+
+  private _consumeIdent(name: string): Token {
+    if (this._checkIdent(name)) return this._advance();
+    const t = this._current();
+    throw new SyntaxError(`[TScript] Expected '${name}' — got '${t.value}' at ${t.line}:${t.col}`);
+  }
+
+  private _consumeNewlineOrEOF(): void {
+    // Silently accept NEWLINE or EOF; required at end of every statement.
+    if (this._check('NEWLINE') || this._check('EOF')) {
+      if (this._check('NEWLINE')) this._advance();
+    }
+    // If neither, we just continue (expression statements don't need semicolons)
+  }
+
+  private _skipNewlines(): void {
+    while (this._check('NEWLINE')) this._advance();
+  }
+
+  private _collapseNewlines(tokens: Token[]): Token[] {
+    const out: Token[] = [];
+    let lastWasNL = false;
+    for (const t of tokens) {
+      if (t.kind === 'NEWLINE') {
+        if (!lastWasNL) out.push(t);
+        lastWasNL = true;
+      } else {
+        lastWasNL = false;
+        out.push(t);
+      }
+    }
+    return out;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private _isStatementBoundary(_t: Token): boolean { return true; }
+}