lt-script 1.0.0

package/dist/compiler/parser/Parser.js

@@ -0,0 +1,873 @@
+import { TokenType } from '../lexer/Token.js';
+import * as AST from './AST.js';
+/**
+ * LT Language Parser
+ * Recursive descent parser for LT → AST
+ */
+export class Parser {
+    tokens;
+    pos = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const body = [];
+        while (!this.isEOF()) {
+            body.push(this.parseStatement());
+        }
+        return { kind: AST.NodeType.Program, body };
+    }
+    // ============ Statement Parsing ============
+    parseStatement() {
+        switch (this.at().type) {
+            case TokenType.VAR:
+            case TokenType.LET:
+            case TokenType.CONST:
+            case TokenType.LOCAL:
+                return this.parseVariableDecl();
+            case TokenType.IF:
+                return this.parseIfStmt();
+            case TokenType.FOR:
+                return this.parseForStmt();
+            case TokenType.WHILE:
+                return this.parseWhileStmt();
+            case TokenType.RETURN:
+                return this.parseReturnStmt();
+            case TokenType.BREAK:
+                this.eat();
+                return { kind: AST.NodeType.BreakStmt };
+            case TokenType.CONTINUE:
+                this.eat();
+                return { kind: AST.NodeType.ContinueStmt };
+            case TokenType.GUARD:
+                return this.parseGuardStmt();
+            case TokenType.SAFE:
+                return this.parseSafeCall();
+            case TokenType.THREAD:
+                return this.parseThreadStmt();
+            case TokenType.LOOP:
+                return this.parseLoopStmt();
+            case TokenType.WAIT:
+                return this.parseWaitStmt();
+            case TokenType.TIMEOUT:
+                return this.parseTimeoutStmt();
+            case TokenType.INTERVAL:
+                return this.parseIntervalStmt();
+            case TokenType.TRY:
+                return this.parseTryCatch();
+            case TokenType.EMIT:
+            case TokenType.EMIT_CLIENT:
+            case TokenType.EMIT_SERVER:
+                return this.parseEmitStmt();
+            case TokenType.EVENT:
+            case TokenType.NETEVENT:
+                return this.parseEventHandler();
+            case TokenType.FUNCTION:
+            case TokenType.FUNC:
+                return this.parseFunctionDecl();
+            case TokenType.SWITCH:
+                return this.parseSwitchStmt();
+            case TokenType.EXPORT:
+                return this.parseExportDecl();
+            case TokenType.COMMAND:
+                return this.parseCommandStmt();
+            default:
+                return this.parseExpressionStatement();
+        }
+    }
+    parseVariableDecl() {
+        const scopeToken = this.eat();
+        const scope = scopeToken.value;
+        // Handle 'local function' syntax (Lua compatibility)
+        if (scope === "local" && (this.at().type === TokenType.FUNCTION || this.at().type === TokenType.FUNC)) {
+            // Treat 'local function x()' as FunctionDecl with isLocal=true
+            const funcDecl = this.parseFunctionDecl(true);
+            return funcDecl;
+        }
+        const names = [];
+        const typeAnnotations = [];
+        const parseName = () => {
+            if (this.at().type === TokenType.LBRACE)
+                return this.parseObjectDestructure();
+            if (this.at().type === TokenType.LBRACKET)
+                return this.parseArrayDestructure();
+            const id = this.parseIdentifier();
+            // Lua 5.4 Attributes: <const>, <close>
+            if (this.match(TokenType.LT)) {
+                // Consume the attribute name (usually 'const' or 'close')
+                const attr = this.eat().value;
+                id.attribute = attr;
+                this.expect(TokenType.GT);
+            }
+            return id;
+        };
+        names.push(parseName());
+        if (this.match(TokenType.COLON)) {
+            typeAnnotations[0] = this.eat().value;
+        }
+        while (this.match(TokenType.COMMA)) {
+            names.push(parseName());
+            if (this.match(TokenType.COLON)) {
+                typeAnnotations[names.length - 1] = this.eat().value;
+            }
+        }
+        let values;
+        if (this.match(TokenType.EQUALS)) {
+            values = [];
+            values.push(this.parseExpression(true));
+            while (this.match(TokenType.COMMA)) {
+                values.push(this.parseExpression(true));
+            }
+        }
+        return { kind: AST.NodeType.VariableDecl, scope, names, typeAnnotations, values };
+    }
+    parseIfStmt() {
+        this.eat(); // if
+        const condition = this.parseExpression();
+        this.expect(TokenType.THEN);
+        const thenBody = this.parseBlockUntil(TokenType.END, TokenType.ELSE, TokenType.ELSEIF);
+        const elseIfClauses = [];
+        while (this.match(TokenType.ELSEIF)) {
+            const cond = this.parseExpression();
+            this.expect(TokenType.THEN);
+            const body = this.parseBlockUntil(TokenType.END, TokenType.ELSE, TokenType.ELSEIF);
+            elseIfClauses.push({ condition: cond, body });
+        }
+        let elseBody;
+        if (this.match(TokenType.ELSE)) {
+            elseBody = this.parseBlockUntil(TokenType.END);
+        }
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.IfStmt, condition, thenBody, elseIfClauses, elseBody };
+    }
+    parseForStmt() {
+        this.eat(); // for
+        const iterators = [];
+        iterators.push(this.parseIdentifier());
+        while (this.match(TokenType.COMMA)) {
+            iterators.push(this.parseIdentifier());
+        }
+        if (this.match(TokenType.IN) || (iterators.length > 1 && this.at().type !== TokenType.EQUALS)) {
+            if (this.at().type !== TokenType.IN && this.at().type !== TokenType.DO) {
+                this.match(TokenType.IN); // Optional IN in some LT contexts
+            }
+            // Check for Range For: i in 1..10
+            const checkpoint = this.pos;
+            if (iterators.length === 1) {
+                try {
+                    const start = this.parseAdditive();
+                    if (this.at().type === TokenType.CONCAT) {
+                        this.eat(); // ..
+                        const end = this.parseAdditive();
+                        let step;
+                        if (this.match(TokenType.BY)) {
+                            step = this.parseAdditive();
+                        }
+                        this.expect(TokenType.DO);
+                        const body = this.parseBlockUntil(TokenType.END);
+                        this.expect(TokenType.END);
+                        return { kind: AST.NodeType.RangeForStmt, counter: iterators[0], start, end, step, body };
+                    }
+                }
+                catch (e) {
+                    // Not a range, fallback
+                }
+                this.pos = checkpoint;
+            }
+            // Generic For
+            const iterable = this.parseExpression();
+            this.expect(TokenType.DO);
+            const body = this.parseBlockUntil(TokenType.END);
+            this.expect(TokenType.END);
+            return { kind: AST.NodeType.ForStmt, iterators, iterable, body };
+        }
+        // Numeric For: for i = 1, 10, 1 do 
+        if (iterators.length > 1) {
+            const tk = this.at();
+            throw new Error(`Numeric for loops (e.g., 'for i = 1, 10') only support a single iterator at ${tk.line}:${tk.column}.`);
+        }
+        const iterator = iterators[0];
+        this.expect(TokenType.EQUALS);
+        const start = this.parseExpression();
+        this.expect(TokenType.COMMA);
+        const end = this.parseExpression();
+        let step;
+        if (this.match(TokenType.COMMA)) {
+            step = this.parseExpression();
+        }
+        this.expect(TokenType.DO);
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.RangeForStmt, counter: iterator, start, end, step, body };
+    }
+    parseWhileStmt() {
+        this.eat(); // while
+        const condition = this.parseExpression();
+        this.expect(TokenType.DO);
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.WhileStmt, condition, body };
+    }
+    parseReturnStmt() {
+        this.eat(); // return
+        let values;
+        if (!this.isStatementEnd()) {
+            values = [];
+            values.push(this.parseExpression());
+            while (this.match(TokenType.COMMA)) {
+                values.push(this.parseExpression());
+            }
+        }
+        return { kind: AST.NodeType.ReturnStmt, values };
+    }
+    parseGuardStmt() {
+        this.eat(); // guard
+        const condition = this.parseExpression();
+        let elseBody;
+        if (this.match(TokenType.ELSE)) {
+            elseBody = [];
+            while (!this.check(TokenType.RETURN) && !this.isEOF()) {
+                elseBody.push(this.parseStatement());
+            }
+            this.expect(TokenType.RETURN);
+            this.match(TokenType.END); // Consume optional END
+        }
+        else {
+            this.expect(TokenType.RETURN);
+        }
+        return { kind: AST.NodeType.GuardStmt, condition, elseBody };
+    }
+    parseSafeCall() {
+        this.eat(); // safe
+        const call = this.parseCallExpr();
+        return { kind: AST.NodeType.SafeCallStmt, call };
+    }
+    parseThreadStmt() {
+        this.eat(); // thread
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.ThreadStmt, body };
+    }
+    parseLoopStmt() {
+        this.eat(); // loop
+        this.expect(TokenType.LPAREN);
+        const conditions = [];
+        conditions.push(this.parseExpression());
+        while (this.match(TokenType.COMMA)) {
+            conditions.push(this.parseExpression());
+        }
+        this.expect(TokenType.RPAREN);
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.LoopStmt, conditions, body };
+    }
+    parseWaitStmt() {
+        this.eat(); // wait
+        const time = this.parseExpression();
+        return { kind: AST.NodeType.WaitStmt, time };
+    }
+    parseTimeoutStmt() {
+        this.eat(); // timeout
+        const delay = this.parseExpression();
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.TimeoutStmt, delay, body };
+    }
+    parseIntervalStmt() {
+        this.eat(); // interval
+        const interval = this.parseExpression();
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.IntervalStmt, interval, body };
+    }
+    parseTryCatch() {
+        this.eat(); // try
+        const tryBody = this.parseBlockUntil(TokenType.CATCH);
+        this.expect(TokenType.CATCH);
+        const catchParam = this.parseIdentifier();
+        const catchBody = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.TryCatchStmt, tryBody, catchParam, catchBody };
+    }
+    parseEmitStmt() {
+        const token = this.eat();
+        const emitType = token.type === TokenType.EMIT ? "emit" :
+            token.type === TokenType.EMIT_CLIENT ? "emitClient" : "emitServer";
+        // Only parse primary to avoid consuming parens as a call
+        const eventName = this.parsePrimary();
+        const args = [];
+        if (this.match(TokenType.LPAREN)) {
+            if (!this.check(TokenType.RPAREN)) {
+                args.push(this.parseExpression());
+                while (this.match(TokenType.COMMA)) {
+                    args.push(this.parseExpression());
+                }
+            }
+            this.expect(TokenType.RPAREN);
+        }
+        return { kind: AST.NodeType.EmitStmt, emitType, eventName, args };
+    }
+    parseEventHandler() {
+        const isNet = this.eat().type === TokenType.NETEVENT;
+        // Only parse primary to avoid consuming parens as a call
+        const eventName = this.parsePrimary();
+        this.expect(TokenType.LPAREN);
+        const params = [];
+        if (!this.check(TokenType.RPAREN)) {
+            params.push(this.parseParameter());
+            while (this.match(TokenType.COMMA)) {
+                params.push(this.parseParameter());
+            }
+        }
+        this.expect(TokenType.RPAREN);
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.EventHandler, isNet, eventName, params, body };
+    }
+    parseFunctionDecl(isLocal = false) {
+        this.eat(); // function or func
+        let name;
+        let current = this.parseIdentifier();
+        while (this.match(TokenType.DOT) || this.match(TokenType.COLON)) {
+            const isMethod = this.tokens[this.pos - 1].type === TokenType.COLON;
+            const property = this.parseIdentifier();
+            current = {
+                kind: AST.NodeType.MemberExpr,
+                object: current,
+                property,
+                computed: false,
+                isMethod
+            };
+            if (isMethod)
+                break; // Colon must be the last part
+        }
+        name = current;
+        this.expect(TokenType.LPAREN);
+        const params = [];
+        if (!this.check(TokenType.RPAREN)) {
+            params.push(this.parseParameter());
+            while (this.match(TokenType.COMMA)) {
+                params.push(this.parseParameter());
+            }
+        }
+        this.expect(TokenType.RPAREN);
+        let returnType;
+        if (this.match(TokenType.COLON)) {
+            returnType = this.eat().value;
+        }
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.FunctionDecl, name, params, returnType, body, isLocal };
+    }
+    parseFunctionExpr() {
+        this.eat(); // function or func
+        let name;
+        if (this.check(TokenType.IDENTIFIER)) {
+            name = this.parseIdentifier();
+        }
+        this.expect(TokenType.LPAREN);
+        const params = [];
+        if (!this.check(TokenType.RPAREN)) {
+            params.push(this.parseParameter());
+            while (this.match(TokenType.COMMA)) {
+                params.push(this.parseParameter());
+            }
+        }
+        this.expect(TokenType.RPAREN);
+        let returnType;
+        if (this.match(TokenType.COLON)) {
+            returnType = this.eat().value;
+        }
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        // Function expressions are anonymous or named local-ish values, usually without 'local' keyword inside the expr itself 
+        // but the AST node structure reuses FunctionDecl.
+        return { kind: AST.NodeType.FunctionDecl, name, params, returnType, body };
+    }
+    parseSwitchStmt() {
+        this.eat(); // switch
+        const discriminant = this.parseExpression();
+        const cases = [];
+        while (this.match(TokenType.CASE)) {
+            const values = [];
+            values.push(this.parseExpression());
+            while (this.match(TokenType.COMMA)) {
+                values.push(this.parseExpression());
+            }
+            const body = this.parseBlockUntil(TokenType.CASE, TokenType.DEFAULT, TokenType.END);
+            cases.push({ values, body });
+        }
+        let defaultCase;
+        if (this.match(TokenType.DEFAULT)) {
+            defaultCase = this.parseBlockUntil(TokenType.END);
+        }
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.SwitchStmt, discriminant, cases, defaultCase };
+    }
+    parseCommandStmt() {
+        this.eat(); // command
+        let nameVal;
+        if (this.at().type === TokenType.STRING) {
+            nameVal = this.eat().value;
+        }
+        else {
+            nameVal = this.parseIdentifier().name;
+        }
+        this.expect(TokenType.LPAREN);
+        const params = [];
+        if (!this.check(TokenType.RPAREN)) {
+            params.push(this.parseParameter());
+            while (this.match(TokenType.COMMA)) {
+                params.push(this.parseParameter());
+            }
+        }
+        this.expect(TokenType.RPAREN);
+        const body = this.parseBlockUntil(TokenType.END);
+        this.expect(TokenType.END);
+        return { kind: AST.NodeType.CommandStmt, commandName: nameVal, params, body };
+    }
+    parseExportDecl() {
+        this.eat(); // export
+        if (this.at().type === TokenType.FUNCTION || this.at().type === TokenType.FUNC) {
+            const decl = this.parseFunctionDecl();
+            return { kind: AST.NodeType.ExportDecl, declaration: decl };
+        }
+        throw new Error(`Expected function declaration after export at ${this.at().line}:${this.at().column}`);
+    }
+    parseExpressionStatement() {
+        const expr = this.parseExpression();
+        // Compound assignment
+        if (this.match(TokenType.PLUS_EQ)) {
+            const value = this.parseExpression();
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "+=", value };
+        }
+        if (this.match(TokenType.MINUS_EQ)) {
+            const value = this.parseExpression();
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "-=", value };
+        }
+        if (this.match(TokenType.STAR_EQ)) {
+            const value = this.parseExpression();
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "*=", value };
+        }
+        if (this.match(TokenType.SLASH_EQ)) {
+            const value = this.parseExpression();
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "/=", value };
+        }
+        if (this.match(TokenType.PERCENT_EQ)) {
+            const value = this.parseExpression();
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "%=", value };
+        }
+        if (this.match(TokenType.CONCAT_EQ)) {
+            const value = this.parseExpression();
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "..=", value };
+        }
+        // Multiple targets: a, b = 1, 2
+        if (this.at().type === TokenType.COMMA) {
+            const targets = [expr];
+            while (this.match(TokenType.COMMA)) {
+                targets.push(this.parseExpression());
+            }
+            this.expect(TokenType.EQUALS);
+            const values = [];
+            values.push(this.parseExpression());
+            while (this.match(TokenType.COMMA)) {
+                values.push(this.parseExpression());
+            }
+            return { kind: AST.NodeType.AssignmentStmt, targets, values };
+        }
+        // Regular assignment
+        if (this.match(TokenType.EQUALS)) {
+            const value = this.parseExpression();
+            return { kind: AST.NodeType.AssignmentStmt, targets: [expr], values: [value] };
+        }
+        return expr;
+    }
+    // ============ Expression Parsing ============
+    parseExpression(allowColon = true) {
+        return this.parseAssignment(allowColon);
+    }
+    parseAssignment(allowColon = true) {
+        let left = this.parseTernaryExpr(allowColon);
+        return left;
+    }
+    parseTernaryExpr(allowColon = true) {
+        let left = this.parseNullCoalesce(allowColon);
+        if (allowColon && this.match(TokenType.QUESTION)) {
+            const consequent = this.parseExpression(false);
+            this.expect(TokenType.COLON);
+            const alternate = this.parseExpression(allowColon);
+            return {
+                kind: AST.NodeType.ConditionalExpr,
+                test: left,
+                consequent,
+                alternate
+            };
+        }
+        return left;
+    }
+    parseNullCoalesce(allowColon = true) {
+        let left = this.parseOr(allowColon);
+        while (this.match(TokenType.NULL_COALESCE)) {
+            const right = this.parseOr(allowColon);
+            left = { kind: AST.NodeType.NullCoalesceExpr, left, right };
+        }
+        return left;
+    }
+    parseOr(allowColon = true) {
+        let left = this.parseAnd(allowColon);
+        while (this.match(TokenType.OR)) {
+            const right = this.parseAnd(allowColon);
+            left = { kind: AST.NodeType.BinaryExpr, left, operator: "or", right };
+        }
+        return left;
+    }
+    parseAnd(allowColon = true) {
+        let left = this.parseEquality(allowColon);
+        while (this.match(TokenType.AND)) {
+            const right = this.parseEquality(allowColon);
+            left = { kind: AST.NodeType.BinaryExpr, left, operator: "and", right };
+        }
+        return left;
+    }
+    parseEquality(allowColon = true) {
+        let left = this.parseComparison(allowColon);
+        while (this.check(TokenType.EQ) || this.check(TokenType.NEQ)) {
+            const op = this.eat().value;
+            const right = this.parseComparison(allowColon);
+            left = { kind: AST.NodeType.BinaryExpr, left, operator: op, right };
+        }
+        return left;
+    }
+    parseComparison(allowColon = true) {
+        let left = this.parseConcat(allowColon);
+        while (this.check(TokenType.LT) || this.check(TokenType.GT) ||
+            this.check(TokenType.LTE) || this.check(TokenType.GTE)) {
+            const op = this.eat().value;
+            const right = this.parseConcat(allowColon);
+            left = { kind: AST.NodeType.BinaryExpr, left, operator: op, right };
+        }
+        return left;
+    }
+    parseConcat(allowColon = true) {
+        let left = this.parseAdditive(allowColon);
+        while (this.check(TokenType.CONCAT)) {
+            this.eat();
+            const right = this.parseAdditive(allowColon);
+            left = { kind: AST.NodeType.BinaryExpr, left, operator: "..", right };
+        }
+        return left;
+    }
+    parseAdditive(allowColon = true) {
+        let left = this.parseMultiplicative(allowColon);
+        while (this.check(TokenType.PLUS) || this.check(TokenType.MINUS)) {
+            const op = this.eat().value;
+            const right = this.parseMultiplicative(allowColon);
+            left = { kind: AST.NodeType.BinaryExpr, left, operator: op, right };
+        }
+        return left;
+    }
+    parseMultiplicative(allowColon = true) {
+        let left = this.parseUnary(allowColon);
+        while (this.check(TokenType.STAR) || this.check(TokenType.SLASH) || this.check(TokenType.PERCENT)) {
+            const op = this.eat().value;
+            const right = this.parseUnary(allowColon);
+            left = { kind: AST.NodeType.BinaryExpr, left, operator: op, right };
+        }
+        return left;
+    }
+    parseUnary(allowColon = true) {
+        if (this.check(TokenType.NOT) || this.check(TokenType.MINUS) || this.check(TokenType.HASH)) {
+            const op = this.eat().value;
+            const operand = this.parseUnary(allowColon);
+            return { kind: AST.NodeType.UnaryExpr, operator: op, operand };
+        }
+        return this.parseCallMember(allowColon);
+    }
+    parseCallMember(allowColon = true) {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.match(TokenType.OPT_DOT)) {
+                const property = this.parseIdentifier();
+                expr = { kind: AST.NodeType.OptionalChainExpr, object: expr, property, computed: false };
+            }
+            else if (this.match(TokenType.OPT_BRACKET)) {
+                const property = this.parseExpression(true);
+                this.expect(TokenType.RBRACKET);
+                expr = { kind: AST.NodeType.OptionalChainExpr, object: expr, property, computed: true };
+            }
+            else if (this.match(TokenType.DOT)) {
+                const property = this.parseIdentifier();
+                expr = { kind: AST.NodeType.MemberExpr, object: expr, property, computed: false };
+            }
+            else if (allowColon && this.match(TokenType.COLON)) {
+                const property = this.parseIdentifier();
+                expr = { kind: AST.NodeType.MemberExpr, object: expr, property, computed: false, isMethod: true };
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                const property = this.parseExpression(true);
+                this.expect(TokenType.RBRACKET);
+                expr = { kind: AST.NodeType.MemberExpr, object: expr, property, computed: true };
+            }
+            else if (this.match(TokenType.LPAREN)) {
+                const args = [];
+                if (!this.check(TokenType.RPAREN)) {
+                    args.push(this.parseExpression(true));
+                    while (this.match(TokenType.COMMA)) {
+                        args.push(this.parseExpression(true));
+                    }
+                }
+                this.expect(TokenType.RPAREN);
+                expr = { kind: AST.NodeType.CallExpr, callee: expr, args };
+            }
+            else if (this.match(TokenType.PLUS_PLUS)) {
+                expr = { kind: AST.NodeType.UpdateExpr, operator: "++", argument: expr, prefix: false };
+            }
+            else if (this.match(TokenType.MINUS_MINUS)) {
+                expr = { kind: AST.NodeType.UpdateExpr, operator: "--", argument: expr, prefix: false };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    parseCallExpr() {
+        return this.parseCallMember();
+    }
+    parsePrimary() {
+        const tk = this.at();
+        switch (tk.type) {
+            case TokenType.FUNCTION:
+            case TokenType.FUNC:
+                return this.parseFunctionExpr();
+            case TokenType.NUMBER:
+                return { kind: AST.NodeType.NumberLiteral, value: parseFloat(this.eat().value) };
+            case TokenType.STRING:
+            case TokenType.LONG_STRING:
+                return this.parseStringLiteral();
+            case TokenType.BOOLEAN:
+                return { kind: AST.NodeType.BooleanLiteral, value: this.eat().value === "true" };
+            case TokenType.NIL:
+                this.eat();
+                return { kind: AST.NodeType.NilLiteral };
+            case TokenType.IDENTIFIER:
+                return this.parseIdentifier();
+            case TokenType.LPAREN:
+                return this.parseParenOrArrow();
+            case TokenType.LBRACE:
+                return this.parseTableLiteral();
+            case TokenType.LBRACKET:
+                return this.parseArrayLiteral();
+            case TokenType.LT:
+                return this.parseVectorLiteral();
+            default:
+                throw new Error(`Unexpected token: ${tk.type} at ${tk.line}:${tk.column}`);
+        }
+    }
+    parseStringLiteral() {
+        const tk = this.eat();
+        const value = tk.value;
+        const isLong = tk.type === TokenType.LONG_STRING;
+        const quote = tk.quote || '"'; // Default to double quote for long strings
+        // Check for interpolation only if $ is followed by a valid identifier start (letter or _)
+        // This prevents SQL JSON paths like "$.bank" from being treated as interpolation
+        const hasInterpolation = /\$[a-zA-Z_]/.test(value);
+        if (hasInterpolation) {
+            return this.parseInterpolatedString(value, quote);
+        }
+        return { kind: AST.NodeType.StringLiteral, value, isLong, quote };
+    }
+    parseInterpolatedString(str, quote = '"') {
+        const parts = [];
+        const regex = /\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(str)) !== null) {
+            if (match.index > lastIndex) {
+                parts.push(str.slice(lastIndex, match.index));
+            }
+            parts.push({ kind: AST.NodeType.Identifier, name: match[1] });
+            lastIndex = regex.lastIndex;
+        }
+        if (lastIndex < str.length) {
+            parts.push(str.slice(lastIndex));
+        }
+        return { kind: AST.NodeType.InterpolatedString, parts, quote };
+    }
+    parseParenOrArrow() {
+        const checkpoint = this.pos;
+        this.eat(); // (
+        // Try to parse as arrow function
+        try {
+            const params = [];
+            if (!this.check(TokenType.RPAREN)) {
+                params.push(this.parseParameter());
+                while (this.match(TokenType.COMMA)) {
+                    params.push(this.parseParameter());
+                }
+            }
+            this.expect(TokenType.RPAREN);
+            if (this.match(TokenType.ARROW)) {
+                let body;
+                if (this.check(TokenType.LBRACE)) {
+                    this.eat();
+                    body = this.parseBlockUntil(TokenType.RBRACE);
+                    this.expect(TokenType.RBRACE);
+                }
+                else {
+                    body = this.parseExpression();
+                }
+                return { kind: AST.NodeType.ArrowFunc, params, body };
+            }
+        }
+        catch {
+            // Not an arrow function, backtrack
+        }
+        // Fallback: parenthesized expression
+        this.pos = checkpoint;
+        this.eat(); // (
+        const expr = this.parseExpression();
+        this.expect(TokenType.RPAREN);
+        return expr;
+    }
+    parseArrayLiteral() {
+        this.eat(); // [
+        const fields = [];
+        while (!this.check(TokenType.RBRACKET) && !this.isEOF()) {
+            fields.push({ value: this.parseExpression() });
+            if (!this.match(TokenType.COMMA))
+                break;
+        }
+        this.expect(TokenType.RBRACKET);
+        return { kind: AST.NodeType.TableLiteral, fields };
+    }
+    parseTableLiteral() {
+        this.eat(); // {
+        const fields = [];
+        while (!this.check(TokenType.RBRACE) && !this.isEOF()) {
+            if (this.match(TokenType.SPREAD)) {
+                const argument = this.parseExpression();
+                fields.push({ value: { kind: AST.NodeType.SpreadExpr, argument } });
+            }
+            else if (this.check(TokenType.LBRACKET)) {
+                // [key] = value
+                this.eat();
+                const key = this.parseExpression();
+                this.expect(TokenType.RBRACKET);
+                this.expect(TokenType.EQUALS);
+                const value = this.parseExpression();
+                fields.push({ key, value });
+            }
+            else if (this.check(TokenType.IDENTIFIER) && (this.peek().type === TokenType.COLON || this.peek().type === TokenType.EQUALS)) {
+                const id = this.parseIdentifier();
+                this.eat(); // : or =
+                const value = this.parseExpression();
+                fields.push({ key: id, value });
+            }
+            else if (this.check(TokenType.IDENTIFIER) && (this.peek().type === TokenType.COMMA || this.peek().type === TokenType.RBRACE)) {
+                // Shorthand: { x } => { x = x }
+                const id = this.parseIdentifier();
+                fields.push({ key: id, value: id, shorthand: true });
+            }
+            else {
+                const value = this.parseExpression();
+                fields.push({ value });
+            }
+            if (!this.match(TokenType.COMMA))
+                break;
+        }
+        this.expect(TokenType.RBRACE);
+        return { kind: AST.NodeType.TableLiteral, fields };
+    }
+    parseVectorLiteral() {
+        this.eat(); // <
+        const components = [];
+        // Use parseConcat to avoid consuming > as comparison operator
+        components.push(this.parseConcat());
+        while (this.match(TokenType.COMMA)) {
+            components.push(this.parseConcat());
+        }
+        this.expect(TokenType.GT);
+        return { kind: AST.NodeType.VectorLiteral, components };
+    }
+    parseIdentifier() {
+        const token = this.expect(TokenType.IDENTIFIER);
+        return { kind: AST.NodeType.Identifier, name: token.value };
+    }
+    parseParameter() {
+        const name = this.parseIdentifier();
+        let typeAnnotation;
+        if (this.match(TokenType.COLON)) {
+            typeAnnotation = this.eat().value;
+        }
+        let defaultValue;
+        if (this.match(TokenType.EQUALS)) {
+            defaultValue = this.parseExpression();
+        }
+        return { name, typeAnnotation, defaultValue };
+    }
+    parseObjectDestructure() {
+        this.eat(); // {
+        const properties = [];
+        while (!this.check(TokenType.RBRACE)) {
+            properties.push(this.parseIdentifier());
+            if (!this.match(TokenType.COMMA))
+                break;
+        }
+        this.expect(TokenType.RBRACE);
+        return { kind: AST.NodeType.ObjectDestructure, properties };
+    }
+    parseArrayDestructure() {
+        this.eat(); // [
+        const elements = [];
+        while (!this.check(TokenType.RBRACKET)) {
+            elements.push(this.parseIdentifier());
+            if (!this.match(TokenType.COMMA))
+                break;
+        }
+        this.expect(TokenType.RBRACKET);
+        return { kind: AST.NodeType.ArrayDestructure, elements };
+    }
+    parseBlockUntil(...stopTokens) {
+        const statements = [];
+        while (!this.isEOF() && !stopTokens.some(t => this.check(t))) {
+            statements.push(this.parseStatement());
+        }
+        return { kind: AST.NodeType.Block, statements };
+    }
+    // ============ Helpers ============
+    at() {
+        return this.tokens[this.pos] ?? { type: TokenType.EOF, value: "", line: -1, column: -1 };
+    }
+    peek() {
+        return this.tokens[this.pos + 1] ?? { type: TokenType.EOF, value: "", line: -1, column: -1 };
+    }
+    eat() {
+        return this.tokens[this.pos++] ?? { type: TokenType.EOF, value: "", line: -1, column: -1 };
+    }
+    match(type) {
+        if (this.at().type === type) {
+            this.eat();
+            return true;
+        }
+        return false;
+    }
+    check(type) {
+        return this.at().type === type;
+    }
+    expect(type) {
+        const token = this.at();
+        if (token.type !== type) {
+            throw new Error(`Expected ${type} but got ${token.type} at ${token.line}:${token.column}`);
+        }
+        return this.eat();
+    }
+    isEOF() {
+        return this.at().type === TokenType.EOF;
+    }
+    isStatementEnd() {
+        const t = this.at().type;
+        return t === TokenType.END || t === TokenType.ELSE || t === TokenType.ELSEIF ||
+            t === TokenType.CATCH || t === TokenType.EOF;
+    }
+}