@forgecharts/sdk 1.1.23

package/src/pine/pine-lexer.ts

@@ -0,0 +1,265 @@
+/**
+ * Pine Script Lexer — tokenises a Pine v5 source string.
+ *
+ * Differences vs TScript lexer:
+ *  - `//@version=N` comment is parsed for the version number
+ *  - `color.red`, `ta.sma`, `math.abs` — namespace.member chains
+ *  - `:=` reassignment operator
+ *  - Indentation-based block structure (INDENT / DEDENT tokens)
+ *  - `var` / `varip` keywords
+ *  - `=>` (function body arrow, for single-line user functions — recognised
+ *    but not fully transpiled; emits an diagnostic)
+ */
+
+export type PineTok =
+  | 'NUMBER' | 'STRING' | 'BOOL' | 'COLOR'
+  | 'IDENT'
+  | 'PLUS' | 'MINUS' | 'STAR' | 'SLASH' | 'PERCENT'
+  | 'LT' | 'GT' | 'LTE' | 'GTE' | 'EQEQ' | 'NEQ'
+  | 'QMARK' | 'COLON' | 'ARROW'   // ?: =>
+  | 'ASSIGN' | 'REASSIGN'          // = :=
+  | 'DOT'
+  | 'LPAREN' | 'RPAREN' | 'LBRACKET' | 'RBRACKET'
+  | 'COMMA'
+  | 'INDENT' | 'DEDENT' | 'NEWLINE'
+  | 'EOF';
+
+export type PineToken = {
+  kind:  PineTok;
+  value: string;
+  line:  number;
+  col:   number;
+};
+
+export class PineLexer {
+  private _src:    string;
+  private _pos:    number = 0;
+  private _line:   number = 1;
+  private _col:    number = 1;
+
+  /** Version extracted from `//@version=N` */
+  version = 5;
+
+  constructor(src: string) {
+    this._src = src.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  }
+
+  tokenize(): PineToken[] {
+    // First pass: raw tokens (with raw NEWLINEs and spaces preserved)
+    const raw = this._rawTokenize();
+    // Second pass: inject INDENT / DEDENT for indented blocks
+    return this._injectIndents(raw);
+  }
+
+  // ─── Raw tokenisation ────────────────────────────────────────────────────────
+
+  private _rawTokenize(): PineToken[] {
+    const tokens: PineToken[] = [];
+
+    while (this._pos < this._src.length) {
+      const ch = this._src[this._pos]!;
+
+      // Handle newline
+      if (ch === '\n') {
+        tokens.push(this._make('NEWLINE', '\n'));
+        this._pos++; this._line++; this._col = 1;
+        continue;
+      }
+
+      // Skip horizontal whitespace (not newlines — needed for indent tracking)
+      if (ch === ' ' || ch === '\t') {
+        this._pos++; this._col++;
+        continue;
+      }
+
+      // Line comment
+      if (ch === '/' && this._peek(1) === '/') {
+        // Check for version annotation
+        const commentStart = this._pos;
+        while (this._pos < this._src.length && this._src[this._pos] !== '\n') {
+          this._pos++; this._col++;
+        }
+        const comment = this._src.slice(commentStart, this._pos);
+        const vMatch = comment.match(/\/\/@version\s*=\s*(\d+)/);
+        if (vMatch) this.version = parseInt(vMatch[1]!, 10);
+        continue;
+      }
+
+      // Numbers
+      if ((ch >= '0' && ch <= '9') || (ch === '.' && this._isDigit(this._peek(1)))) {
+        tokens.push(this._readNumber());
+        continue;
+      }
+
+      // Strings
+      if (ch === '"' || ch === "'") {
+        tokens.push(this._readString(ch));
+        continue;
+      }
+
+      // Identifiers / keywords
+      if (this._isAlpha(ch)) {
+        const tok = this._readIdent();
+        tokens.push(tok);
+        continue;
+      }
+
+      // Two-char operators
+      const two = this._src.slice(this._pos, this._pos + 2);
+      if (two === '<=') { tokens.push(this._make('LTE',      two)); this._adv(2); continue; }
+      if (two === '>=') { tokens.push(this._make('GTE',      two)); this._adv(2); continue; }
+      if (two === '==') { tokens.push(this._make('EQEQ',     two)); this._adv(2); continue; }
+      if (two === '!=') { tokens.push(this._make('NEQ',      two)); this._adv(2); continue; }
+      if (two === ':=') { tokens.push(this._make('REASSIGN', two)); this._adv(2); continue; }
+      if (two === '=>') { tokens.push(this._make('ARROW',    two)); this._adv(2); continue; }
+
+      // Single-char operators
+      const singleOps: Record<string, PineTok> = {
+        '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'PERCENT',
+        '<': 'LT',   '>': 'GT',
+        '?': 'QMARK', ':': 'COLON',
+        '(': 'LPAREN', ')': 'RPAREN', '[': 'LBRACKET', ']': 'RBRACKET',
+        ',': 'COMMA', '.': 'DOT',
+        '=': 'ASSIGN',
+      };
+      if (ch in singleOps) {
+        tokens.push(this._make(singleOps[ch]!, ch));
+        this._pos++; this._col++;
+        continue;
+      }
+
+      throw new SyntaxError(`[Pine] Unexpected character '${ch}' at ${this._line}:${this._col}`);
+    }
+
+    tokens.push(this._make('EOF', ''));
+    return tokens;
+  }
+
+  // ─── Indent/Dedent injection ─────────────────────────────────────────────────
+
+  private _injectIndents(raw: PineToken[]): PineToken[] {
+    const out: PineToken[] = [];
+    const indentStack: number[] = [0];
+    let i = 0;
+
+    while (i < raw.length) {
+      const tok = raw[i]!;
+
+      if (tok.kind !== 'NEWLINE') {
+        out.push(tok);
+        i++;
+        continue;
+      }
+
+      // After a NEWLINE, measure the indentation of the next non-empty line
+      out.push(tok);   // keep the NEWLINE token
+      i++;
+
+      // Count leading spaces of the next real line
+      let spaces = 0;
+      let j = i;
+      while (j < raw.length && (raw[j]!.kind === 'NEWLINE')) {
+        // blank line — skip
+        out.push(raw[j]!);
+        j++;
+      }
+      i = j;
+
+      if (i >= raw.length || raw[i]!.kind === 'EOF') break;
+
+      // Compute indent width from the column of the next token
+      const nextTok = raw[i]!;
+      spaces = nextTok.col - 1;  // col is 1-based
+
+      const currentIndent = indentStack[indentStack.length - 1]!;
+
+      if (spaces > currentIndent) {
+        indentStack.push(spaces);
+        out.push({ kind: 'INDENT', value: '', line: nextTok.line, col: 1 });
+      } else {
+        while (spaces < indentStack[indentStack.length - 1]!) {
+          indentStack.pop();
+          out.push({ kind: 'DEDENT', value: '', line: nextTok.line, col: 1 });
+        }
+      }
+    }
+
+    // Close any remaining open indents
+    while (indentStack.length > 1) {
+      indentStack.pop();
+      out.push({ kind: 'DEDENT', value: '', line: 0, col: 0 });
+    }
+
+    out.push({ kind: 'EOF', value: '', line: this._line, col: this._col });
+    return out;
+  }
+
+  // ─── Helpers ─────────────────────────────────────────────────────────────────
+
+  private _make(kind: PineTok, value: string): PineToken {
+    return { kind, value, line: this._line, col: this._col };
+  }
+
+  private _peek(offset: number): string {
+    return this._src[this._pos + offset] ?? '';
+  }
+
+  private _adv(n = 1): void {
+    this._pos  += n;
+    this._col  += n;
+  }
+
+  private _isDigit(ch: string): boolean {
+    return ch >= '0' && ch <= '9';
+  }
+
+  private _isAlpha(ch: string): boolean {
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
+  }
+
+  private _isAlphaNum(ch: string): boolean {
+    return this._isAlpha(ch) || this._isDigit(ch);
+  }
+
+  private _readNumber(): PineToken {
+    const start = this._pos;
+    const startCol = this._col;
+    while (this._pos < this._src.length) {
+      const c = this._src[this._pos]!;
+      if (this._isDigit(c) || c === '.') { this._pos++; this._col++; }
+      else break;
+    }
+    return { kind: 'NUMBER', value: this._src.slice(start, this._pos), line: this._line, col: startCol };
+  }
+
+  private _readString(quote: string): PineToken {
+    const startCol = this._col;
+    this._pos++; this._col++;
+    let result = '';
+    while (this._pos < this._src.length && this._src[this._pos] !== quote) {
+      if (this._src[this._pos] === '\\') {
+        this._pos++; this._col++;
+        const esc = this._src[this._pos] ?? '';
+        result += esc === 'n' ? '\n' : esc === 't' ? '\t' : esc;
+      } else {
+        result += this._src[this._pos];
+      }
+      this._pos++; this._col++;
+    }
+    this._pos++; this._col++;
+    return { kind: 'STRING', value: result, line: this._line, col: startCol };
+  }
+
+  private _readIdent(): PineToken {
+    const start = this._pos;
+    const startCol = this._col;
+    while (this._pos < this._src.length && this._isAlphaNum(this._src[this._pos]!)) {
+      this._pos++; this._col++;
+    }
+    const name = this._src.slice(start, this._pos);
+    if (name === 'true' || name === 'false') {
+      return { kind: 'BOOL', value: name, line: this._line, col: startCol };
+    }
+    return { kind: 'IDENT', value: name, line: this._line, col: startCol };
+  }
+}

package/src/pine/pine-parser.ts

@@ -0,0 +1,439 @@
+/**
+ * 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) };
+  }
+}