@forgecharts/sdk 1.1.23 → 1.1.28

package/src/pine/pine-parser.ts

@@ -1,439 +0,0 @@
-/**
- * Pine Script Parser — recursive-descent, produces a PineProgram AST.
- *
- * Handles the supported Pine v5 subset:
- *   indicator(), input.*(), ta.*(), math.*(), plot(), plotshape()
- *   var / varip declarations
- *   := reassignment
- *   if / else (indented blocks)
- *   ternary  a ? b : c
- *   namespace.member  and  namespace.call(...)
- */
-
-import { PineLexer } from './pine-lexer';
-import type { PineToken, PineTok } from './pine-lexer';
-import type {
-  PineProgram, PineStmt, PineExpr,
-  PineIndicatorDecl, PineVarDecl, PineAssign, PineExprStmt, PineIf,
-  PineNumberLit, PineStringLit, PineBoolLit, PineNa,
-  PineIdent, PineNsCall, PineCall, PineIndex,
-  PineBinary, PineUnary, PineTernary, PineMember,
-  Loc,
-} from './pine-ast';
-
-
-export class PineParser {
-  private _tokens: PineToken[];
-  private _pos    = 0;
-  readonly version: number;
-
-  constructor(src: string) {
-    const lexer = new PineLexer(src);
-    this._tokens = lexer.tokenize();
-    this.version  = lexer.version;
-  }
-
-  parse(): PineProgram {
-    const stmts: PineStmt[] = [];
-    this._skipNL();
-    while (!this._check('EOF')) {
-      const s = this._stmt();
-      if (s !== null) stmts.push(s);
-      this._skipNL();
-    }
-    return { kind: 'PineProgram', version: this.version, stmts };
-  }
-
-  // ─── Statements ─────────────────────────────────────────────────────────────
-
-  private _stmt(): PineStmt | null {
-    const t = this._cur();
-    const loc: Loc = { line: t.line, col: t.col };
-
-    // var / varip declaration
-    if (t.kind === 'IDENT' && (t.value === 'var' || t.value === 'varip')) {
-      return this._varDecl();
-    }
-
-    // if statement
-    if (t.kind === 'IDENT' && t.value === 'if') {
-      return this._ifStmt();
-    }
-
-    // Assignment: IDENT = expr  or  IDENT := expr
-    // Also handles "IDENT type_hint = expr" e.g. "float x = 1.0" — skip type hints
-    if (t.kind === 'IDENT') {
-      // Peek ahead skipping possible type-hint token
-      const p1 = this._peekKind(1);
-      const p2 = this._peekKind(2);
-      const isAssign  = p1 === 'ASSIGN'    || p1 === 'REASSIGN';
-      const isTyped   = p1 === 'IDENT' && (p2 === 'ASSIGN' || p2 === 'REASSIGN');
-      if (isAssign || isTyped) {
-        return this._assignStmt();
-      }
-    }
-
-    // indicator() special top-level
-    if (t.kind === 'IDENT' && t.value === 'indicator') {
-      return this._indicatorDecl();
-    }
-
-    // Expression statement (plot, function calls, etc.)
-    const expr = this._expr();
-    this._consumeNLorEOF();
-    return { kind: 'PineExprStmt', expr, loc };
-  }
-
-  private _varDecl(): PineVarDecl {
-    const tok = this._advance();
-    const modifier = tok.value as 'var' | 'varip';
-    const loc: Loc = { line: tok.line, col: tok.col };
-
-    // optional type hint (float, int, bool, string, color, ...)
-    let typeHint: string | undefined;
-    if (this._check('IDENT') && this._peekKind(1) === 'ASSIGN') {
-      // possible: "var float x = ..."
-      const maybeType = this._cur().value;
-      if (['float','int','bool','string','color','series','simple','const'].includes(maybeType)) {
-        typeHint = maybeType;
-        this._advance();
-      }
-    }
-
-    const name = this._consume('IDENT', "Expected variable name after 'var'").value;
-    this._consume('ASSIGN', "Expected '=' in var declaration");
-    const value = this._expr();
-    this._consumeNLorEOF();
-    return typeHint !== undefined
-      ? { kind: 'PineVarDecl', modifier, name, typeHint, value, loc }
-      : { kind: 'PineVarDecl', modifier, name, value, loc } as PineVarDecl;
-  }
-
-  private _assignStmt(): PineAssign {
-    const nameTok = this._advance();
-    const loc: Loc = { line: nameTok.line, col: nameTok.col };
-    const name = nameTok.value;
-
-    // Skip type hint if present: "float x = ..."
-    let op: '=' | ':=' = '=';
-    if (this._check('IDENT')) {
-      // type hint token — consume silently
-      this._advance();
-    }
-    if (this._check('REASSIGN')) {
-      op = ':=';
-      this._advance();
-    } else {
-      this._consume('ASSIGN', "Expected '=' or ':='");
-    }
-
-    const value = this._expr();
-    this._consumeNLorEOF();
-    return { kind: 'PineAssign', name, op, value, loc };
-  }
-
-  private _indicatorDecl(): PineIndicatorDecl {
-    const tok = this._advance(); // consume 'indicator'
-    const loc: Loc = { line: tok.line, col: tok.col };
-    this._consume('LPAREN', "Expected '(' after 'indicator'");
-    const { args, namedArgs } = this._argList();
-    this._consume('RPAREN', "Expected ')' after indicator args");
-    this._consumeNLorEOF();
-    return { kind: 'PineIndicatorDecl', args, namedArgs, loc };
-  }
-
-  private _ifStmt(): PineIf {
-    const tok = this._advance(); // consume 'if'
-    const loc: Loc = { line: tok.line, col: tok.col };
-
-    const condition = this._expr();
-    this._consumeNLorEOF();
-
-    const then: PineStmt[] = this._indentedBlock();
-    const else_: PineStmt[] = [];
-
-    // optional 'else'
-    if (this._check('IDENT') && this._cur().value === 'else') {
-      this._advance();
-      this._consumeNLorEOF();
-      else_.push(...this._indentedBlock());
-    }
-
-    return { kind: 'PineIf', condition, then, else_, loc };
-  }
-
-  private _indentedBlock(): PineStmt[] {
-    const stmts: PineStmt[] = [];
-    if (!this._check('INDENT')) return stmts;
-    this._advance(); // consume INDENT
-    this._skipNL();
-    while (!this._check('DEDENT') && !this._check('EOF')) {
-      const s = this._stmt();
-      if (s !== null) stmts.push(s);
-      this._skipNL();
-    }
-    if (this._check('DEDENT')) this._advance(); // consume DEDENT
-    return stmts;
-  }
-
-  // ─── Expressions ────────────────────────────────────────────────────────────
-
-  private _expr(): PineExpr { return this._ternary(); }
-
-  private _ternary(): PineExpr {
-    let left = this._or();
-    if (this._match('QMARK')) {
-      const consequent = this._expr();
-      this._consume('COLON', "Expected ':' in ternary");
-      const alternate = this._expr();
-      const node: PineTernary = {
-        kind: 'PineTernary', condition: left, consequent, alternate,
-        loc: this._locOf(left),
-      };
-      return node;
-    }
-    return left;
-  }
-
-  private _or(): PineExpr {
-    let left = this._and();
-    while (this._checkIdent('or')) {
-      this._advance();
-      const right = this._and();
-      left = this._bin('or', left, right);
-    }
-    return left;
-  }
-
-  private _and(): PineExpr {
-    let left = this._not();
-    while (this._checkIdent('and')) {
-      this._advance();
-      const right = this._not();
-      left = this._bin('and', left, right);
-    }
-    return left;
-  }
-
-  private _not(): PineExpr {
-    if (this._checkIdent('not')) {
-      const loc = this._locOfCur();
-      this._advance();
-      const operand = this._comparison();
-      const node: PineUnary = { kind: 'PineUnary', op: 'not', operand, loc };
-      return node;
-    }
-    return this._comparison();
-  }
-
-  private _comparison(): PineExpr {
-    let left = this._addition();
-    while (true) {
-      if (this._match('LTE'))  { left = this._bin('<=', left, this._addition()); continue; }
-      if (this._match('GTE'))  { left = this._bin('>=', left, this._addition()); continue; }
-      if (this._match('EQEQ')) { left = this._bin('==', left, this._addition()); continue; }
-      if (this._match('NEQ'))  { left = this._bin('!=', left, this._addition()); continue; }
-      if (this._match('LT'))   { left = this._bin('<',  left, this._addition()); continue; }
-      if (this._match('GT'))   { left = this._bin('>',  left, this._addition()); continue; }
-      break;
-    }
-    return left;
-  }
-
-  private _addition(): PineExpr {
-    let left = this._multiply();
-    while (true) {
-      if (this._match('PLUS'))  { left = this._bin('+', left, this._multiply()); continue; }
-      if (this._match('MINUS')) { left = this._bin('-', left, this._multiply()); continue; }
-      break;
-    }
-    return left;
-  }
-
-  private _multiply(): PineExpr {
-    let left = this._unary();
-    while (true) {
-      if (this._match('STAR'))    { left = this._bin('*', left, this._unary()); continue; }
-      if (this._match('SLASH'))   { left = this._bin('/', left, this._unary()); continue; }
-      if (this._match('PERCENT')) { left = this._bin('%', left, this._unary()); continue; }
-      break;
-    }
-    return left;
-  }
-
-  private _unary(): PineExpr {
-    if (this._match('MINUS')) {
-      const operand = this._unary();
-      const node: PineUnary = { kind: 'PineUnary', op: '-', operand, loc: this._locOfCur() };
-      return node;
-    }
-    return this._postfix();
-  }
-
-  private _postfix(): PineExpr {
-    let expr = this._primary();
-    // Series indexing: expr[n]
-    while (this._check('LBRACKET')) {
-      const loc = this._locOfCur();
-      this._advance();
-      const index = this._expr();
-      this._consume('RBRACKET', "Expected ']'");
-      const node: PineIndex = { kind: 'PineIndex', series: expr, index, loc };
-      expr = node;
-    }
-    return expr;
-  }
-
-  private _primary(): PineExpr {
-    const t = this._cur();
-    const loc: Loc = { line: t.line, col: t.col };
-
-    if (t.kind === 'NUMBER') {
-      this._advance();
-      const node: PineNumberLit = { kind: 'PineNumberLit', value: parseFloat(t.value), loc };
-      return node;
-    }
-
-    if (t.kind === 'STRING') {
-      this._advance();
-      const node: PineStringLit = { kind: 'PineStringLit', value: t.value, loc };
-      return node;
-    }
-
-    if (t.kind === 'BOOL') {
-      this._advance();
-      const node: PineBoolLit = { kind: 'PineBoolLit', value: t.value === 'true', loc };
-      return node;
-    }
-
-    // na constant
-    if (t.kind === 'IDENT' && t.value === 'na') {
-      this._advance();
-      const node: PineNa = { kind: 'PineNa', loc };
-      return node;
-    }
-
-    // IDENT '.' IDENT  →  namespace member or namespaced call
-    if (t.kind === 'IDENT' && this._peekKind(1) === 'DOT') {
-      const ns = t.value;
-      this._advance(); // consume ns
-      this._advance(); // consume .
-      const member = this._consume('IDENT', "Expected member name after '.'").value;
-
-      // Namespaced call: ns.fn(...)
-      if (this._check('LPAREN')) {
-        this._advance();
-        const { args, namedArgs } = this._argList();
-        this._consume('RPAREN', "Expected ')'");
-        const node: PineNsCall = { kind: 'PineNsCall', namespace: ns, fn: member, args, namedArgs, loc };
-        return node;
-      }
-
-      // Namespaced member: color.red, bar_index, etc.
-      const node: PineMember = { kind: 'PineMember', object: ns, prop: member, loc };
-      return node;
-    }
-
-    // Plain function call: IDENT '(' ... ')'
-    if (t.kind === 'IDENT' && this._peekKind(1) === 'LPAREN') {
-      const fn = t.value;
-      this._advance();
-      this._advance(); // consume (
-      const { args, namedArgs } = this._argList();
-      this._consume('RPAREN', "Expected ')'");
-      const node: PineCall = { kind: 'PineCall', fn, args, namedArgs, loc };
-      return node;
-    }
-
-    // Plain identifier
-    if (t.kind === 'IDENT') {
-      this._advance();
-      const node: PineIdent = { kind: 'PineIdent', name: t.value, loc };
-      return node;
-    }
-
-    // Grouped expression
-    if (t.kind === 'LPAREN') {
-      this._advance();
-      const inner = this._expr();
-      this._consume('RPAREN', "Expected ')'");
-      return inner;
-    }
-
-    throw new SyntaxError(`[Pine] Unexpected token '${t.value}' (${t.kind}) at ${t.line}:${t.col}`);
-  }
-
-  // ─── Arg list helper ────────────────────────────────────────────────────────
-
-  private _argList(): { args: PineExpr[]; namedArgs: Map<string, PineExpr> } {
-    const args: PineExpr[] = [];
-    const namedArgs = new Map<string, PineExpr>();
-
-    if (this._check('RPAREN')) return { args, namedArgs };
-
-    // First arg
-    this._parseOneArg(args, namedArgs);
-
-    while (this._match('COMMA')) {
-      if (this._check('RPAREN')) break; // trailing comma
-      this._parseOneArg(args, namedArgs);
-    }
-
-    return { args, namedArgs };
-  }
-
-  private _parseOneArg(
-    args:      PineExpr[],
-    namedArgs: Map<string, PineExpr>,
-  ): void {
-    // Named arg: name = value ?   (peek: IDENT = non-'=')
-    if (
-      this._check('IDENT') &&
-      this._peekKind(1) === 'ASSIGN' &&
-      this._peekKind(2) !== 'ASSIGN'   // not ==
-    ) {
-      const key = this._advance().value;
-      this._advance(); // consume =
-      const val = this._expr();
-      namedArgs.set(key, val);
-    } else {
-      args.push(this._expr());
-    }
-  }
-
-  // ─── Token helpers ───────────────────────────────────────────────────────────
-
-  private _cur(): PineToken { return this._tokens[this._pos]!; }
-  private _advance(): PineToken { return this._tokens[this._pos++]!; }
-  private _check(kind: PineTok): boolean { return this._cur().kind === kind; }
-  private _checkIdent(name: string): boolean {
-    const t = this._cur();
-    return t.kind === 'IDENT' && t.value === name;
-  }
-  private _peekKind(offset: number): PineTok {
-    return this._tokens[this._pos + offset]?.kind ?? 'EOF';
-  }
-  private _match(kind: PineTok): boolean {
-    if (this._check(kind)) { this._advance(); return true; }
-    return false;
-  }
-  private _consume(kind: PineTok, msg: string): PineToken {
-    if (this._check(kind)) return this._advance();
-    const t = this._cur();
-    throw new SyntaxError(`[Pine] ${msg} — got '${t.value}' (${t.kind}) at ${t.line}:${t.col}`);
-  }
-  private _skipNL(): void {
-    while (this._check('NEWLINE')) this._advance();
-  }
-  private _consumeNLorEOF(): void {
-    if (this._check('NEWLINE') || this._check('EOF')) {
-      if (this._check('NEWLINE')) this._advance();
-    }
-  }
-  private _locOfCur(): Loc { return { line: this._cur().line, col: this._cur().col }; }
-  private _locOf(expr: PineExpr): Loc { return (expr as { loc: Loc }).loc; }
-
-  private _bin(op: PineBinary['op'], left: PineExpr, right: PineExpr): PineBinary {
-    return { kind: 'PineBinary', op, left, right, loc: this._locOf(left) };
-  }
-}