@jalvin/compiler 2.0.32 → 2.0.33

package/dist/parser/index.js

@@ -0,0 +1,2387 @@
+"use strict";
+// ─────────────────────────────────────────────────────────────────────────────
+// Jalvin Parser — recursive-descent, produces a fully-typed AST
+//
+// Grammar overview (informal EBNF):
+//   program        = packageDecl? importDecl* topLevelDecl*
+//   topLevelDecl   = funDecl | componentDecl | classDecl | dataClassDecl
+//                  | sealedClassDecl | interfaceDecl | objectDecl
+//                  | typeAliasDecl | propertyDecl | extensionFunDecl
+//   ...
+// ─────────────────────────────────────────────────────────────────────────────
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+exports.parse = parse;
+const AST = __importStar(require("../ast.js"));
+const lexer_js_1 = require("../lexer.js");
+const diagnostics_js_1 = require("../diagnostics.js");
+const constants_js_1 = require("./constants.js");
+const helpers_js_1 = require("./helpers.js");
+// ---------------------------------------------------------------------------
+// Parser class
+// ---------------------------------------------------------------------------
+class Parser {
+    pos = 0;
+    tokens;
+    diag;
+    file;
+    source;
+    depth = 0;
+    constructor(tokens, file, diag, source = "") {
+        this.tokens = tokens;
+        this.diag = diag;
+        this.file = file;
+        this.source = source;
+    }
+    // ── Entry point ────────────────────────────────────────────────────────────
+    parseProgram() {
+        const start = this.current().span;
+        let packageDecl = null;
+        if (this.check("KwPackage" /* TokenKind.KwPackage */)) {
+            packageDecl = this.parsePackageDecl();
+        }
+        const imports = [];
+        while (this.check("KwImport" /* TokenKind.KwImport */)) {
+            imports.push(this.parseImportDecl());
+        }
+        const declarations = [];
+        while (!this.check("EOF" /* TokenKind.EOF */)) {
+            // skip stray semicolons
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (this.check("EOF" /* TokenKind.EOF */))
+                break;
+            const decl = this.parseTopLevelDecl();
+            if (decl)
+                declarations.push(decl);
+        }
+        const end = this.current().span;
+        return {
+            kind: "Program",
+            span: AST.spanFrom(start, end),
+            packageDecl,
+            imports,
+            declarations,
+        };
+    }
+    // ── Package & imports ──────────────────────────────────────────────────────
+    parsePackageDecl() {
+        const start = this.expect("KwPackage" /* TokenKind.KwPackage */).span;
+        const path = this.parseDottedName();
+        this.eatSemicolon();
+        return { kind: "PackageDecl", span: start, path };
+    }
+    parseImportDecl() {
+        const start = this.expect("KwImport" /* TokenKind.KwImport */).span;
+        const path = [];
+        if (this.check("At" /* TokenKind.At */)) {
+            this.advance();
+            path.push("@" + this.expectIdentOrKeyword());
+        }
+        else {
+            path.push(this.expectIdentOrKeyword());
+        }
+        while (this.check("Dot" /* TokenKind.Dot */) || this.check("Slash" /* TokenKind.Slash */)) {
+            this.advance();
+            if (this.check("Star" /* TokenKind.Star */)) {
+                this.advance();
+                this.eatSemicolon();
+                return { kind: "ImportDecl", span: start, path, star: true, alias: null };
+            }
+            path.push(this.expectIdentOrKeyword());
+        }
+        let alias = null;
+        if (this.check("KwAs" /* TokenKind.KwAs */)) {
+            this.advance();
+            alias = this.expectIdentifier();
+        }
+        this.eatSemicolon();
+        return { kind: "ImportDecl", span: start, path, star: false, alias };
+    }
+    // ── Top-level declarations ─────────────────────────────────────────────────
+    parseTopLevelDecl() {
+        // Collect modifiers and annotations
+        const mods = this.parseModifiers();
+        if (this.check("KwFun" /* TokenKind.KwFun */)) {
+            return this.parseFunOrExtension(mods);
+        }
+        if (this.check("KwComponent" /* TokenKind.KwComponent */)) {
+            return this.parseComponentDecl(mods);
+        }
+        if (this.check("KwData" /* TokenKind.KwData */) && this.checkNext("KwClass" /* TokenKind.KwClass */)) {
+            return this.parseDataClassDecl(mods);
+        }
+        if (this.check("KwSealed" /* TokenKind.KwSealed */) && this.checkNext("KwClass" /* TokenKind.KwClass */)) {
+            return this.parseSealedClassDecl(mods);
+        }
+        if (this.check("KwEnum" /* TokenKind.KwEnum */) && this.checkNext("KwClass" /* TokenKind.KwClass */)) {
+            return this.parseEnumClassDecl(mods);
+        }
+        if (this.check("KwClass" /* TokenKind.KwClass */)) {
+            return this.parseClassDecl(mods);
+        }
+        if (this.check("KwInterface" /* TokenKind.KwInterface */)) {
+            return this.parseInterfaceDecl(mods);
+        }
+        if (this.check("KwObject" /* TokenKind.KwObject */)) {
+            return this.parseObjectDecl(mods);
+        }
+        if (this.check("KwTypealias" /* TokenKind.KwTypealias */)) {
+            return this.parseTypeAliasDecl(mods);
+        }
+        if (this.check("KwVal" /* TokenKind.KwVal */) || this.check("KwVar" /* TokenKind.KwVar */)) {
+            if (this.checkNext("LParen" /* TokenKind.LParen */)) {
+                return this.parseDestructuringDecl(mods);
+            }
+            return this.parsePropertyDeclTopLevel(mods);
+        }
+        const tok = this.current();
+        this.diag.error(tok.span, diagnostics_js_1.E_UNEXPECTED_TOKEN, `Unexpected token '${tok.text}' at top level`);
+        this.advance();
+        return null;
+    }
+    // ── Modifiers ──────────────────────────────────────────────────────────────
+    parseModifiers() {
+        let visibility = "public";
+        const modifiers = [];
+        const annotations = [];
+        const seen = new Set();
+        // Collect leading annotations: @Name or @Name("...") or @Name(key=val,...)
+        while (this.check("At" /* TokenKind.At */)) {
+            const atSpan = this.current().span;
+            this.advance(); // consume @
+            const name = this.expectIdentOrKeyword();
+            let args = null;
+            if (this.check("LParen" /* TokenKind.LParen */)) {
+                this.advance(); // consume (
+                // Collect everything until matching )
+                const parts = [];
+                let depth = 1;
+                while (!this.check("EOF" /* TokenKind.EOF */) && depth > 0) {
+                    const tok = this.current();
+                    if (tok.kind === "LParen" /* TokenKind.LParen */) {
+                        depth++;
+                        parts.push(tok.text);
+                        this.advance();
+                    }
+                    else if (tok.kind === "RParen" /* TokenKind.RParen */) {
+                        depth--;
+                        if (depth > 0)
+                            parts.push(tok.text);
+                        this.advance();
+                    }
+                    else {
+                        parts.push(tok.text);
+                        this.advance();
+                    }
+                }
+                args = parts.join("");
+            }
+            annotations.push({ span: AST.spanFrom(atSpan, this.prevSpan()), name, args });
+            this.eatSemicolon();
+        }
+        const addMod = (m) => {
+            if (seen.has(m)) {
+                this.diag.error(this.current().span, diagnostics_js_1.E_DUPLICATE_MODIFIER, `Duplicate modifier '${m}'`);
+                return;
+            }
+            seen.add(m);
+            if (m === "public" || m === "private" || m === "protected" || m === "internal") {
+                if (seen.has("public") || seen.has("private") || seen.has("protected") || seen.has("internal")) {
+                    if (seen.size > 1) {
+                        this.diag.error(this.current().span, diagnostics_js_1.E_INCOMPATIBLE_MODIFIERS, "Multiple visibility modifiers");
+                    }
+                }
+                visibility = m;
+            }
+            else {
+                modifiers.push(m);
+            }
+        };
+        loop: while (true) {
+            switch (this.current().kind) {
+                case "KwPublic" /* TokenKind.KwPublic */:
+                    addMod("public");
+                    this.advance();
+                    break;
+                case "KwPrivate" /* TokenKind.KwPrivate */:
+                    addMod("private");
+                    this.advance();
+                    break;
+                case "KwProtected" /* TokenKind.KwProtected */:
+                    addMod("protected");
+                    this.advance();
+                    break;
+                case "KwInternal" /* TokenKind.KwInternal */:
+                    addMod("internal");
+                    this.advance();
+                    break;
+                case "KwOpen" /* TokenKind.KwOpen */:
+                    addMod("open");
+                    this.advance();
+                    break;
+                case "KwAbstract" /* TokenKind.KwAbstract */:
+                    addMod("abstract");
+                    this.advance();
+                    break;
+                case "KwOverride" /* TokenKind.KwOverride */:
+                    addMod("override");
+                    this.advance();
+                    break;
+                case "KwInline" /* TokenKind.KwInline */:
+                    addMod("inline");
+                    this.advance();
+                    break;
+                case "KwOperator" /* TokenKind.KwOperator */:
+                    addMod("operator");
+                    this.advance();
+                    break;
+                case "KwInfix" /* TokenKind.KwInfix */:
+                    addMod("infix");
+                    this.advance();
+                    break;
+                case "KwExternal" /* TokenKind.KwExternal */:
+                    addMod("external");
+                    this.advance();
+                    break;
+                case "KwSuspend" /* TokenKind.KwSuspend */:
+                    addMod("suspend");
+                    this.advance();
+                    break;
+                case "KwTailrec" /* TokenKind.KwTailrec */:
+                    addMod("tailrec");
+                    this.advance();
+                    break;
+                case "KwReified" /* TokenKind.KwReified */:
+                    addMod("reified");
+                    this.advance();
+                    break;
+                case "KwConst" /* TokenKind.KwConst */:
+                    addMod("const");
+                    this.advance();
+                    break;
+                case "KwLateinit" /* TokenKind.KwLateinit */:
+                    addMod("lateinit");
+                    this.advance();
+                    break;
+                case "KwFinal" /* TokenKind.KwFinal */:
+                    addMod("final");
+                    this.advance();
+                    break;
+                default: break loop;
+            }
+        }
+        return { visibility, modifiers, annotations };
+    }
+    // ── function / extension function ─────────────────────────────────────────
+    parseFunOrExtension(mods) {
+        const start = this.expect("KwFun" /* TokenKind.KwFun */).span;
+        const typeParams = this.parseTypeParams();
+        // Could be `fun Type.name(...) { }` — extension function
+        // We parse the first "name" and check for a dot after optional type args
+        let receiver = null;
+        // Peek: if there is a dotted-type followed by `.` before `(`, it's an extension
+        const savedPos = this.pos;
+        const possibleReceiver = this.tryParseTypeRef();
+        if (possibleReceiver && this.check("Dot" /* TokenKind.Dot */)) {
+            // Pattern: `fun GenericType<T>.name(...)` — receiver fully parsed, `.name` follows
+            receiver = possibleReceiver;
+            this.advance(); // consume '.'
+        }
+        else if (possibleReceiver?.kind === "SimpleTypeRef" &&
+            possibleReceiver.name.length >= 2 &&
+            (this.check("LParen" /* TokenKind.LParen */) || this.check("Lt" /* TokenKind.Lt */))) {
+            // Pattern: `fun Cart.subtotal()` — tryParseTypeRef greedily consumed "Cart.subtotal"
+            // as a qualified type name. Split: last component is function name, rest is receiver.
+            const parts = possibleReceiver.name;
+            const extReceiver = { kind: "SimpleTypeRef", span: possibleReceiver.span, name: parts.slice(0, -1) };
+            const extName = parts[parts.length - 1];
+            const params = this.parseParamList();
+            let returnType = null;
+            if (this.check("Colon" /* TokenKind.Colon */)) {
+                this.advance();
+                returnType = this.parseTypeRef();
+            }
+            let body = null;
+            if (this.check("Eq" /* TokenKind.Eq */)) {
+                this.advance();
+                body = this.parseExpr();
+                this.eatSemicolon();
+            }
+            else if (this.check("LBrace" /* TokenKind.LBrace */)) {
+                body = this.parseBlock();
+            }
+            else {
+                this.eatSemicolon();
+            }
+            const span = AST.spanFrom(start, this.prevSpan());
+            if (!body) {
+                body = { kind: "Block", span, statements: [] };
+            }
+            return { kind: "ExtensionFunDecl", span, modifiers: mods, name: extName, typeParams, receiver: extReceiver, params, returnType, body: body };
+        }
+        else {
+            this.pos = savedPos; // backtrack
+        }
+        const name = this.expectIdentifier();
+        const params = this.parseParamList();
+        let returnType = null;
+        if (this.check("Colon" /* TokenKind.Colon */)) {
+            this.advance();
+            returnType = this.parseTypeRef();
+        }
+        let body = null;
+        if (this.check("Eq" /* TokenKind.Eq */)) {
+            this.advance();
+            body = this.parseExpr();
+            this.eatSemicolon();
+        }
+        else if (this.check("LBrace" /* TokenKind.LBrace */)) {
+            body = this.parseBlock();
+        }
+        else {
+            this.eatSemicolon();
+        }
+        const span = AST.spanFrom(start, this.prevSpan());
+        if (receiver) {
+            if (!body) {
+                this.diag.error(span, diagnostics_js_1.E_EXPECTED_TOKEN, "Extension function must have a body");
+                body = { kind: "Block", span, statements: [] };
+            }
+            return {
+                kind: "ExtensionFunDecl",
+                span,
+                modifiers: mods,
+                name,
+                typeParams,
+                receiver,
+                params,
+                returnType,
+                body,
+            };
+        }
+        return {
+            kind: "FunDecl",
+            span,
+            modifiers: mods,
+            name,
+            typeParams,
+            receiver: null,
+            params,
+            returnType,
+            body,
+        };
+    }
+    parseComponentDecl(mods) {
+        const start = this.expect("KwComponent" /* TokenKind.KwComponent */).span;
+        this.expect("KwFun" /* TokenKind.KwFun */);
+        const name = this.expectIdentifier();
+        const params = this.parseParamList();
+        const body = this.parseBlock();
+        return {
+            kind: "ComponentDecl",
+            span: AST.spanFrom(start, body.span),
+            modifiers: mods,
+            name,
+            params,
+            body,
+        };
+    }
+    // ── Class declarations ─────────────────────────────────────────────────────
+    parseClassDecl(mods) {
+        const start = this.expect("KwClass" /* TokenKind.KwClass */).span;
+        const name = this.expectIdentifier();
+        const typeParams = this.parseTypeParams();
+        const primaryConstructor = this.parsePrimaryConstructorOpt();
+        const superTypes = this.parseSuperTypes();
+        const body = this.check("LBrace" /* TokenKind.LBrace */) ? this.parseClassBody() : null;
+        this.eatSemicolon();
+        return {
+            kind: "ClassDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            name,
+            typeParams,
+            primaryConstructor,
+            superTypes,
+            body,
+        };
+    }
+    parseDataClassDecl(mods) {
+        const start = this.expect("KwData" /* TokenKind.KwData */).span;
+        this.expect("KwClass" /* TokenKind.KwClass */);
+        const name = this.expectIdentifier();
+        const typeParams = this.parseTypeParams();
+        const primaryConstructor = this.parsePrimaryConstructor();
+        const superTypes = this.parseSuperTypes();
+        const body = this.check("LBrace" /* TokenKind.LBrace */) ? this.parseClassBody() : null;
+        this.eatSemicolon();
+        return {
+            kind: "DataClassDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            name,
+            typeParams,
+            primaryConstructor,
+            superTypes,
+            body,
+        };
+    }
+    parseSealedClassDecl(mods) {
+        const start = this.expect("KwSealed" /* TokenKind.KwSealed */).span;
+        this.expect("KwClass" /* TokenKind.KwClass */);
+        const name = this.expectIdentifier();
+        const typeParams = this.parseTypeParams();
+        const primaryConstructor = this.parsePrimaryConstructorOpt();
+        const superTypes = this.parseSuperTypes();
+        const body = this.check("LBrace" /* TokenKind.LBrace */) ? this.parseClassBody() : null;
+        this.eatSemicolon();
+        return {
+            kind: "SealedClassDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            name,
+            typeParams,
+            primaryConstructor,
+            superTypes,
+            body,
+        };
+    }
+    parseInterfaceDecl(mods) {
+        const start = this.expect("KwInterface" /* TokenKind.KwInterface */).span;
+        const name = this.expectIdentifier();
+        const typeParams = this.parseTypeParams();
+        const superTypes = this.parseSuperTypes();
+        const body = this.check("LBrace" /* TokenKind.LBrace */) ? this.parseClassBody() : null;
+        this.eatSemicolon();
+        return {
+            kind: "InterfaceDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            name,
+            typeParams,
+            superTypes,
+            body,
+        };
+    }
+    parseObjectDecl(mods) {
+        const start = this.expect("KwObject" /* TokenKind.KwObject */).span;
+        let name = null;
+        if (this.check("Identifier" /* TokenKind.Identifier */)) {
+            name = this.advance().text;
+        }
+        const superTypes = this.parseSuperTypes();
+        // Body is optional: `object Foo : Base()` is valid without `{ }`.
+        const body = this.check("LBrace" /* TokenKind.LBrace */)
+            ? this.parseClassBody()
+            : { span: this.prevSpan(), members: [] };
+        this.eatSemicolon();
+        return {
+            kind: "ObjectDecl",
+            span: AST.spanFrom(start, body.span),
+            modifiers: mods,
+            name,
+            superTypes,
+            body,
+        };
+    }
+    parseTypeAliasDecl(mods) {
+        const start = this.expect("KwTypealias" /* TokenKind.KwTypealias */).span;
+        const name = this.expectIdentifier();
+        const typeParams = this.parseTypeParams();
+        this.expect("Eq" /* TokenKind.Eq */);
+        const type = this.parseTypeRef();
+        this.eatSemicolon();
+        return {
+            kind: "TypeAliasDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            name,
+            typeParams,
+            type,
+        };
+    }
+    // ── enum class ────────────────────────────────────────────────────────────
+    parseEnumClassDecl(mods) {
+        const start = this.expect("KwEnum" /* TokenKind.KwEnum */).span;
+        this.expect("KwClass" /* TokenKind.KwClass */);
+        const name = this.expectIdentifier();
+        const typeParams = this.parseTypeParams();
+        const primaryConstructor = this.parsePrimaryConstructorOpt();
+        const superTypes = this.parseSuperTypes();
+        const entries = [];
+        let body = null;
+        if (this.check("LBrace" /* TokenKind.LBrace */)) {
+            const bodyStart = this.expect("LBrace" /* TokenKind.LBrace */).span;
+            const members = [];
+            // Parse enum entries (identifiers at the start of the block, before `;`)
+            while (!this.check("RBrace" /* TokenKind.RBrace */) && !this.check("EOF" /* TokenKind.EOF */)) {
+                while (this.check("Semicolon" /* TokenKind.Semicolon */)) {
+                    this.advance();
+                    // A lone `;` separates entries from the member body
+                    break;
+                }
+                if (this.check("RBrace" /* TokenKind.RBrace */))
+                    break;
+                // If we see an identifier and it looks like an enum entry (not a declaration keyword)
+                if (this.check("Identifier" /* TokenKind.Identifier */) &&
+                    !this.isDeclarationKeyword(this.current().kind)) {
+                    const entrySpan = this.current().span;
+                    const entryName = this.advance().text;
+                    let args = [];
+                    if (this.check("LParen" /* TokenKind.LParen */)) {
+                        args = this.parseCallArgs();
+                    }
+                    let entryBody = null;
+                    if (this.check("LBrace" /* TokenKind.LBrace */)) {
+                        entryBody = this.parseClassBody();
+                    }
+                    entries.push({ span: AST.spanFrom(entrySpan, this.prevSpan()), name: entryName, args, body: entryBody });
+                    if (this.check("Comma" /* TokenKind.Comma */))
+                        this.advance();
+                }
+                else {
+                    // Non-entry member (method, property, etc.)
+                    const member = this.parseClassMember();
+                    if (member)
+                        members.push(member);
+                }
+            }
+            const bodyEnd = this.expect("RBrace" /* TokenKind.RBrace */).span;
+            if (members.length > 0) {
+                body = { span: AST.spanFrom(bodyStart, bodyEnd), members };
+            }
+        }
+        this.eatSemicolon();
+        return {
+            kind: "EnumClassDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            name,
+            typeParams,
+            primaryConstructor,
+            superTypes,
+            entries,
+            body,
+        };
+    }
+    // ── Destructuring declaration — val (a, b) = expr ─────────────────────────
+    parseDestructuringDecl(mods) {
+        const start = this.current().span;
+        const mutable = this.check("KwVar" /* TokenKind.KwVar */);
+        this.advance(); // val | var
+        this.expect("LParen" /* TokenKind.LParen */);
+        const names = [];
+        const types = [];
+        while (!this.check("RParen" /* TokenKind.RParen */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            if (this.check("Underscore" /* TokenKind.Underscore */)) {
+                this.advance();
+                names.push(null);
+                types.push(null);
+            }
+            else {
+                names.push(this.expectIdentifier());
+                if (this.check("Colon" /* TokenKind.Colon */)) {
+                    this.advance();
+                    types.push(this.parseTypeRef());
+                }
+                else {
+                    types.push(null);
+                }
+            }
+            if (this.check("Comma" /* TokenKind.Comma */))
+                this.advance();
+        }
+        this.expect("RParen" /* TokenKind.RParen */);
+        this.expect("Eq" /* TokenKind.Eq */);
+        const initializer = this.parseExpr();
+        this.eatSemicolon();
+        return {
+            kind: "DestructuringDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            mutable,
+            names,
+            types,
+            initializer,
+        };
+    }
+    isDeclarationKeyword(kind) {
+        return (kind === "KwFun" /* TokenKind.KwFun */ ||
+            kind === "KwVal" /* TokenKind.KwVal */ ||
+            kind === "KwVar" /* TokenKind.KwVar */ ||
+            kind === "KwClass" /* TokenKind.KwClass */ ||
+            kind === "KwInterface" /* TokenKind.KwInterface */ ||
+            kind === "KwObject" /* TokenKind.KwObject */ ||
+            kind === "KwData" /* TokenKind.KwData */ ||
+            kind === "KwSealed" /* TokenKind.KwSealed */ ||
+            kind === "KwEnum" /* TokenKind.KwEnum */ ||
+            kind === "KwOverride" /* TokenKind.KwOverride */ ||
+            kind === "KwAbstract" /* TokenKind.KwAbstract */ ||
+            kind === "KwOpen" /* TokenKind.KwOpen */ ||
+            kind === "KwPrivate" /* TokenKind.KwPrivate */ ||
+            kind === "KwProtected" /* TokenKind.KwProtected */ ||
+            kind === "KwInternal" /* TokenKind.KwInternal */ ||
+            kind === "KwPublic" /* TokenKind.KwPublic */ ||
+            kind === "KwSuspend" /* TokenKind.KwSuspend */ ||
+            kind === "KwInline" /* TokenKind.KwInline */ ||
+            kind === "KwLateinit" /* TokenKind.KwLateinit */);
+    }
+    parsePropertyDeclTopLevel(mods) {
+        return this.parsePropertyDecl(mods);
+    }
+    // ── Class body ─────────────────────────────────────────────────────────────
+    parseClassBody() {
+        const start = this.expect("LBrace" /* TokenKind.LBrace */).span;
+        const members = [];
+        while (!this.check("RBrace" /* TokenKind.RBrace */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (this.check("RBrace" /* TokenKind.RBrace */))
+                break;
+            const m = this.parseClassMember();
+            if (m)
+                members.push(m);
+        }
+        const end = this.expect("RBrace" /* TokenKind.RBrace */).span;
+        return { span: AST.spanFrom(start, end), members };
+    }
+    parseClassMember() {
+        if (this.check("KwInit" /* TokenKind.KwInit */)) {
+            return this.parseInitBlock();
+        }
+        if (this.check("KwConstructor" /* TokenKind.KwConstructor */)) {
+            return this.parseSecondaryConstructor();
+        }
+        if (this.check("KwCompanion" /* TokenKind.KwCompanion */)) {
+            return this.parseCompanionObject();
+        }
+        const mods = this.parseModifiers();
+        if (this.check("KwFun" /* TokenKind.KwFun */))
+            return this.parseFunOrExtension(mods);
+        if (this.check("KwComponent" /* TokenKind.KwComponent */))
+            return this.parseComponentDecl(mods);
+        if (this.check("KwVal" /* TokenKind.KwVal */) || this.check("KwVar" /* TokenKind.KwVar */)) {
+            return this.parsePropertyDecl(mods);
+        }
+        if (this.check("KwData" /* TokenKind.KwData */) && this.checkNext("KwClass" /* TokenKind.KwClass */)) {
+            return this.parseDataClassDecl(mods);
+        }
+        if (this.check("KwSealed" /* TokenKind.KwSealed */) && this.checkNext("KwClass" /* TokenKind.KwClass */)) {
+            return this.parseSealedClassDecl(mods);
+        }
+        if (this.check("KwEnum" /* TokenKind.KwEnum */) && this.checkNext("KwClass" /* TokenKind.KwClass */)) {
+            return this.parseEnumClassDecl(mods);
+        }
+        if (this.check("KwClass" /* TokenKind.KwClass */))
+            return this.parseClassDecl(mods);
+        if (this.check("KwObject" /* TokenKind.KwObject */))
+            return this.parseObjectDecl(mods);
+        const tok = this.current();
+        this.diag.error(tok.span, diagnostics_js_1.E_UNEXPECTED_TOKEN, `Unexpected token '${tok.text}' in class body`);
+        this.advance();
+        return null;
+    }
+    parseInitBlock() {
+        const start = this.expect("KwInit" /* TokenKind.KwInit */).span;
+        const body = this.parseBlock();
+        return { kind: "InitBlock", span: AST.spanFrom(start, body.span), body };
+    }
+    parseSecondaryConstructor() {
+        const start = this.expect("KwConstructor" /* TokenKind.KwConstructor */).span;
+        const mods = AST.DEFAULT_MODIFIERS;
+        const params = this.parseParamList();
+        let delegation = null;
+        const delegateArgs = [];
+        if (this.check("Colon" /* TokenKind.Colon */)) {
+            this.advance();
+            if (this.check("KwThis" /* TokenKind.KwThis */)) {
+                delegation = "this";
+                this.advance();
+            }
+            else if (this.check("KwSuper" /* TokenKind.KwSuper */)) {
+                delegation = "super";
+                this.advance();
+            }
+            delegateArgs.push(...this.parseCallArgs());
+        }
+        const body = this.parseBlock();
+        return {
+            kind: "SecondaryConstructor",
+            span: AST.spanFrom(start, body.span),
+            modifiers: mods,
+            params,
+            delegation,
+            delegateArgs,
+            body,
+        };
+    }
+    parseCompanionObject() {
+        const start = this.expect("KwCompanion" /* TokenKind.KwCompanion */).span;
+        this.expect("KwObject" /* TokenKind.KwObject */);
+        let name = null;
+        if (this.check("Identifier" /* TokenKind.Identifier */)) {
+            name = this.advance().text;
+        }
+        const superTypes = this.parseSuperTypes();
+        const body = this.parseClassBody();
+        return {
+            kind: "CompanionObject",
+            span: AST.spanFrom(start, body.span),
+            name,
+            superTypes,
+            body,
+        };
+    }
+    // ── Property declaration ───────────────────────────────────────────────────
+    parsePropertyDecl(mods) {
+        const start = this.current().span;
+        const mutable = this.check("KwVar" /* TokenKind.KwVar */);
+        this.advance(); // val | var
+        const typeParams = this.parseTypeParams();
+        const name = this.expectIdentifier();
+        let type = null;
+        if (this.check("Colon" /* TokenKind.Colon */)) {
+            this.advance();
+            type = this.parseTypeRef();
+        }
+        let initializer = null;
+        let delegate = null;
+        if (this.check("Eq" /* TokenKind.Eq */)) {
+            this.advance();
+            initializer = this.parseExpr();
+        }
+        else if (this.check("KwBy" /* TokenKind.KwBy */)) {
+            this.advance();
+            delegate = this.parseExpr();
+        }
+        let getter = null;
+        let setter = null;
+        // Parse get/set accessors
+        while (true) {
+            if (this.checkIdent("get")) {
+                getter = this.parsePropertyAccessor();
+            }
+            else if (this.checkIdent("set")) {
+                setter = this.parsePropertyAccessor();
+            }
+            else {
+                break;
+            }
+        }
+        this.eatSemicolon();
+        return {
+            kind: "PropertyDecl",
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: mods,
+            mutable,
+            name,
+            typeParams,
+            type,
+            initializer,
+            delegate,
+            getter,
+            setter,
+        };
+    }
+    parsePropertyAccessor() {
+        const start = this.advance().span; // consume 'get' | 'set'
+        const params = [];
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            this.advance();
+            if (!this.check("RParen" /* TokenKind.RParen */)) {
+                params.push(this.parseParam());
+            }
+            this.expect("RParen" /* TokenKind.RParen */);
+        }
+        let body = null;
+        if (this.check("Eq" /* TokenKind.Eq */)) {
+            this.advance();
+            body = this.parseExpr();
+            this.eatSemicolon();
+        }
+        else if (this.check("LBrace" /* TokenKind.LBrace */)) {
+            body = this.parseBlock();
+        }
+        else {
+            this.eatSemicolon();
+        }
+        return {
+            span: AST.spanFrom(start, this.prevSpan()),
+            modifiers: AST.DEFAULT_MODIFIERS,
+            params,
+            body,
+        };
+    }
+    // ── Constructor / params ───────────────────────────────────────────────────
+    parsePrimaryConstructor() {
+        const start = this.current().span;
+        let mods = AST.DEFAULT_MODIFIERS;
+        if (this.check("KwConstructor" /* TokenKind.KwConstructor */)) {
+            this.advance();
+        }
+        const params = this.parseParamList();
+        return { span: AST.spanFrom(start, this.prevSpan()), modifiers: mods, params };
+    }
+    parsePrimaryConstructorOpt() {
+        if (this.check("LParen" /* TokenKind.LParen */) || this.check("KwConstructor" /* TokenKind.KwConstructor */)) {
+            return this.parsePrimaryConstructor();
+        }
+        return null;
+    }
+    parseParamList() {
+        this.expect("LParen" /* TokenKind.LParen */);
+        const params = [];
+        while (!this.check("RParen" /* TokenKind.RParen */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            // Skip ASI-inserted semicolons between params
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (this.check("RParen" /* TokenKind.RParen */) || this.check("EOF" /* TokenKind.EOF */))
+                break;
+            const prevPos = this.pos;
+            params.push(this.parseParam());
+            // Safety: if parseParam made no progress, break to avoid infinite loop
+            if (this.pos === prevPos)
+                break;
+            // Skip trailing semicolons/ASI before the comma or close paren
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (!this.check("RParen" /* TokenKind.RParen */))
+                this.expect("Comma" /* TokenKind.Comma */);
+        }
+        this.expect("RParen" /* TokenKind.RParen */);
+        return params;
+    }
+    parseParam() {
+        const start = this.current().span;
+        let vararg = false;
+        let propertyKind = null;
+        if (this.checkIdent("vararg")) {
+            vararg = true;
+            this.advance();
+        }
+        if (this.check("KwVal" /* TokenKind.KwVal */)) {
+            propertyKind = "val";
+            this.advance();
+        }
+        else if (this.check("KwVar" /* TokenKind.KwVar */)) {
+            propertyKind = "var";
+            this.advance();
+        }
+        const name = this.expectIdentOrKeyword();
+        this.expect("Colon" /* TokenKind.Colon */);
+        const type = this.parseTypeRef();
+        let defaultValue = null;
+        if (this.check("Eq" /* TokenKind.Eq */)) {
+            this.advance();
+            defaultValue = this.parseExpr();
+        }
+        return {
+            span: AST.spanFrom(start, this.prevSpan()),
+            propertyKind,
+            name,
+            type,
+            defaultValue,
+            vararg,
+        };
+    }
+    // ── Super types ────────────────────────────────────────────────────────────
+    parseSuperTypes() {
+        const entries = [];
+        if (!this.check("Colon" /* TokenKind.Colon */))
+            return entries;
+        this.advance();
+        entries.push(this.parseSuperTypeEntry());
+        while (this.check("Comma" /* TokenKind.Comma */)) {
+            this.advance();
+            entries.push(this.parseSuperTypeEntry());
+        }
+        return entries;
+    }
+    parseSuperTypeEntry() {
+        const start = this.current().span;
+        const type = this.parseTypeRef();
+        let delegateArgs = null;
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            delegateArgs = this.parseCallArgs();
+        }
+        return { span: AST.spanFrom(start, this.prevSpan()), type, delegateArgs };
+    }
+    // ── Type references ────────────────────────────────────────────────────────
+    parseTypeRef() {
+        const t = this.parseTypeRefInner();
+        if (this.check("Question" /* TokenKind.Question */)) {
+            const span = this.advance().span;
+            return { kind: "NullableTypeRef", span: AST.spanFrom(t.span, span), base: t };
+        }
+        return t;
+    }
+    tryParseTypeRef() {
+        const saved = this.pos;
+        try {
+            const t = this.parseTypeRef();
+            return t;
+        }
+        catch {
+            this.pos = saved;
+            return null;
+        }
+    }
+    parseTypeRefInner() {
+        const start = this.current().span;
+        // Function type: (A, B) -> C  or  Receiver.(A) -> B
+        // Use lookahead to confirm `(...) ->` before speculatively parsing.
+        if (this.check("LParen" /* TokenKind.LParen */) && this.looksLikeFunctionType()) {
+            const saved = this.pos;
+            try {
+                return this.parseFunctionType(null);
+            }
+            catch {
+                this.pos = saved;
+                // fall through to simple type
+            }
+        }
+        // Parenthesized type: (T) — supports nullable function types like (() -> Unit)?
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            const saved = this.pos;
+            try {
+                this.advance(); // consume (
+                const inner = this.parseTypeRef();
+                if (this.check("RParen" /* TokenKind.RParen */)) {
+                    this.advance(); // consume )
+                    return inner;
+                }
+                this.pos = saved;
+            }
+            catch {
+                this.pos = saved;
+            }
+        }
+        // Simple or generic type
+        const name = [this.expectIdentOrKeyword()];
+        while (this.check("Dot" /* TokenKind.Dot */) && !this.check("DotDot" /* TokenKind.DotDot */)) {
+            this.advance();
+            name.push(this.expectIdentOrKeyword());
+        }
+        const simple = {
+            kind: "SimpleTypeRef",
+            span: AST.spanFrom(start, this.prevSpan()),
+            name,
+        };
+        if (this.check("Lt" /* TokenKind.Lt */)) {
+            const args = this.parseTypeArgs();
+            return {
+                kind: "GenericTypeRef",
+                span: AST.spanFrom(start, this.prevSpan()),
+                base: simple,
+                args,
+            };
+        }
+        return simple;
+    }
+    parseFunctionType(receiver) {
+        const start = this.current().span;
+        this.expect("LParen" /* TokenKind.LParen */);
+        const params = [];
+        while (!this.check("RParen" /* TokenKind.RParen */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            // Named param: `name: Type` — we just discard the name
+            if (this.check("Identifier" /* TokenKind.Identifier */) && this.checkNext("Colon" /* TokenKind.Colon */)) {
+                this.advance();
+                this.advance();
+            }
+            const prevPos = this.pos;
+            params.push(this.parseTypeRef());
+            // Safety: if parseTypeRef didn't advance, bail to prevent infinite loop
+            if (this.pos === prevPos)
+                break;
+            if (!this.check("RParen" /* TokenKind.RParen */))
+                this.expect("Comma" /* TokenKind.Comma */);
+        }
+        this.expect("RParen" /* TokenKind.RParen */);
+        this.expect("Arrow" /* TokenKind.Arrow */);
+        const returnType = this.parseTypeRef();
+        return {
+            kind: "FunctionTypeRef",
+            span: AST.spanFrom(start, this.prevSpan()),
+            receiver,
+            params,
+            returnType,
+        };
+    }
+    /** Lookahead: scan past matching parens to see if followed by `->` */
+    looksLikeFunctionType() {
+        let i = this.pos + 1; // skip the opening `(`
+        let depth = 1;
+        while (i < this.tokens.length && depth > 0) {
+            const k = this.tokens[i].kind;
+            if (k === "LParen" /* TokenKind.LParen */)
+                depth++;
+            else if (k === "RParen" /* TokenKind.RParen */)
+                depth--;
+            else if (k === "EOF" /* TokenKind.EOF */)
+                return false;
+            i++;
+        }
+        // After closing `)`, the next token must be `->`
+        return this.tokens[i]?.kind === "Arrow" /* TokenKind.Arrow */;
+    }
+    parseTypeArgs() {
+        this.expect("Lt" /* TokenKind.Lt */);
+        const args = [];
+        while (!this.check("Gt" /* TokenKind.Gt */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            const prevPos = this.pos;
+            const span = this.current().span;
+            if (this.check("Star" /* TokenKind.Star */)) {
+                this.advance();
+                args.push({ span, variance: null, star: true, type: null });
+            }
+            else {
+                let variance = null;
+                if (this.check("KwIn" /* TokenKind.KwIn */)) {
+                    variance = "in";
+                    this.advance();
+                }
+                else if (this.checkIdent("out")) {
+                    variance = "out";
+                    this.advance();
+                }
+                const t = this.parseTypeRef();
+                args.push({ span: AST.spanFrom(span, t.span), variance, star: false, type: t });
+            }
+            // Safety: if no progress was made, break to prevent infinite loop
+            if (this.pos === prevPos)
+                break;
+            if (!this.check("Gt" /* TokenKind.Gt */))
+                this.expect("Comma" /* TokenKind.Comma */);
+        }
+        this.expect("Gt" /* TokenKind.Gt */);
+        return args;
+    }
+    parseTypeParams() {
+        if (!this.check("Lt" /* TokenKind.Lt */))
+            return [];
+        this.advance();
+        const params = [];
+        while (!this.check("Gt" /* TokenKind.Gt */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            const span = this.current().span;
+            let reified = false;
+            let variance = null;
+            if (this.checkIdent("reified")) {
+                reified = true;
+                this.advance();
+            }
+            if (this.check("KwIn" /* TokenKind.KwIn */)) {
+                variance = "in";
+                this.advance();
+            }
+            else if (this.checkIdent("out")) {
+                variance = "out";
+                this.advance();
+            }
+            const name = this.expectIdentifier();
+            let upperBound = null;
+            if (this.check("Colon" /* TokenKind.Colon */)) {
+                this.advance();
+                upperBound = this.parseTypeRef();
+            }
+            params.push({ span: AST.spanFrom(span, this.prevSpan()), name, variance, reified, upperBound });
+            if (!this.check("Gt" /* TokenKind.Gt */))
+                this.expect("Comma" /* TokenKind.Comma */);
+        }
+        this.expect("Gt" /* TokenKind.Gt */);
+        return params;
+    }
+    // ── Block ──────────────────────────────────────────────────────────────────
+    parseBlock() {
+        const start = this.expect("LBrace" /* TokenKind.LBrace */).span;
+        const statements = [];
+        while (!this.check("RBrace" /* TokenKind.RBrace */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (this.check("RBrace" /* TokenKind.RBrace */))
+                break;
+            const s = this.parseStmt();
+            if (s)
+                statements.push(s);
+        }
+        const end = this.expect("RBrace" /* TokenKind.RBrace */).span;
+        return { kind: "Block", span: AST.spanFrom(start, end), statements };
+    }
+    // ── Statements ─────────────────────────────────────────────────────────────
+    parseStmt() {
+        const tok = this.current();
+        switch (tok.kind) {
+            case "KwVal" /* TokenKind.KwVal */:
+            case "KwVar" /* TokenKind.KwVar */:
+                if (this.checkNext("LParen" /* TokenKind.LParen */)) {
+                    return this.parseDestructuringDecl(AST.DEFAULT_MODIFIERS);
+                }
+                return this.parseLocalProperty();
+            case "KwReturn" /* TokenKind.KwReturn */:
+                return this.parseReturnStmt();
+            case "KwThrow" /* TokenKind.KwThrow */:
+                return this.parseThrowStmt();
+            case "KwBreak" /* TokenKind.KwBreak */:
+                return this.parseBreakStmt();
+            case "KwContinue" /* TokenKind.KwContinue */:
+                return this.parseContinueStmt();
+            case "KwIf" /* TokenKind.KwIf */:
+                return this.parseIfStmt();
+            case "KwWhen" /* TokenKind.KwWhen */:
+                return this.parseWhenStmt();
+            case "KwFor" /* TokenKind.KwFor */:
+                return this.parseForStmt();
+            case "KwWhile" /* TokenKind.KwWhile */:
+                return this.parseWhileStmt();
+            case "KwDo" /* TokenKind.KwDo */:
+                return this.parseDoWhileStmt();
+            case "KwTry" /* TokenKind.KwTry */:
+                return this.parseTryCatchStmt();
+            case "LBrace" /* TokenKind.LBrace */:
+                return this.parseBlock();
+            default: {
+                // Could be a labeled statement: `label@ while (...) {}`
+                if (tok.kind === "Identifier" /* TokenKind.Identifier */ && this.checkNext("At" /* TokenKind.At */)) {
+                    return this.parseLabeledStmt();
+                }
+                // Expression statement (assignment, call, etc.)
+                const expr = this.parseExpr();
+                this.eatSemicolon();
+                return { kind: "ExprStmt", span: expr.span, expr };
+            }
+        }
+    }
+    parseLocalProperty() {
+        return this.parsePropertyDecl(AST.DEFAULT_MODIFIERS);
+    }
+    parseReturnStmt() {
+        const start = this.expect("KwReturn" /* TokenKind.KwReturn */).span;
+        let label = null;
+        if (this.check("At" /* TokenKind.At */)) {
+            this.advance();
+            label = this.expectIdentifier();
+        }
+        let value = null;
+        if (!this.check("Semicolon" /* TokenKind.Semicolon */) && !this.check("RBrace" /* TokenKind.RBrace */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            value = this.parseExpr();
+        }
+        this.eatSemicolon();
+        return { kind: "ReturnStmt", span: AST.spanFrom(start, this.prevSpan()), label, value };
+    }
+    parseThrowStmt() {
+        const start = this.expect("KwThrow" /* TokenKind.KwThrow */).span;
+        const value = this.parseExpr();
+        this.eatSemicolon();
+        return { kind: "ThrowStmt", span: AST.spanFrom(start, value.span), value };
+    }
+    parseBreakStmt() {
+        const start = this.expect("KwBreak" /* TokenKind.KwBreak */).span;
+        let label = null;
+        if (this.check("At" /* TokenKind.At */)) {
+            this.advance();
+            label = this.expectIdentifier();
+        }
+        this.eatSemicolon();
+        return { kind: "BreakStmt", span: AST.spanFrom(start, this.prevSpan()), label };
+    }
+    parseContinueStmt() {
+        const start = this.expect("KwContinue" /* TokenKind.KwContinue */).span;
+        let label = null;
+        if (this.check("At" /* TokenKind.At */)) {
+            this.advance();
+            label = this.expectIdentifier();
+        }
+        this.eatSemicolon();
+        return { kind: "ContinueStmt", span: AST.spanFrom(start, this.prevSpan()), label };
+    }
+    parseIfStmt() {
+        const start = this.expect("KwIf" /* TokenKind.KwIf */).span;
+        this.expect("LParen" /* TokenKind.LParen */);
+        const condition = this.parseExpr();
+        this.expect("RParen" /* TokenKind.RParen */);
+        const then = this.parseBlock();
+        // Skip ASI-inserted semicolons between the then-block's `}` and `else`
+        while (this.check("Semicolon" /* TokenKind.Semicolon */))
+            this.advance();
+        let elseClause = null;
+        if (this.check("KwElse" /* TokenKind.KwElse */)) {
+            this.advance();
+            if (this.check("KwIf" /* TokenKind.KwIf */)) {
+                elseClause = this.parseIfStmt();
+            }
+            else {
+                elseClause = this.parseBlock();
+            }
+        }
+        return {
+            kind: "IfStmt",
+            span: AST.spanFrom(start, this.prevSpan()),
+            condition,
+            then,
+            else: elseClause,
+        };
+    }
+    parseWhenStmt() {
+        const start = this.expect("KwWhen" /* TokenKind.KwWhen */).span;
+        let subject = null;
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            const subStart = this.advance().span;
+            let binding = null;
+            if (this.check("KwVal" /* TokenKind.KwVal */) && this.peekKindAt(2) === "Eq" /* TokenKind.Eq */) {
+                this.advance();
+                binding = this.expectIdentifier();
+                this.expect("Eq" /* TokenKind.Eq */);
+            }
+            const expr = this.parseExpr();
+            this.expect("RParen" /* TokenKind.RParen */);
+            subject = { span: AST.spanFrom(subStart, this.prevSpan()), binding, expr };
+        }
+        this.expect("LBrace" /* TokenKind.LBrace */);
+        const branches = [];
+        while (!this.check("RBrace" /* TokenKind.RBrace */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            branches.push(this.parseWhenBranch());
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+        }
+        const end = this.expect("RBrace" /* TokenKind.RBrace */).span;
+        return { kind: "WhenStmt", span: AST.spanFrom(start, end), subject, branches };
+    }
+    parseWhenBranch() {
+        const start = this.current().span;
+        let isElse = false;
+        const conditions = [];
+        if (this.check("KwElse" /* TokenKind.KwElse */)) {
+            isElse = true;
+            this.advance();
+        }
+        else {
+            conditions.push(this.parseWhenCondition());
+            while (this.check("Comma" /* TokenKind.Comma */)) {
+                this.advance();
+                conditions.push(this.parseWhenCondition());
+            }
+        }
+        this.expect("Arrow" /* TokenKind.Arrow */);
+        let body;
+        if (this.check("LBrace" /* TokenKind.LBrace */)) {
+            body = this.parseBlock();
+        }
+        else {
+            body = this.parseExpr();
+            this.eatSemicolon();
+        }
+        return { span: AST.spanFrom(start, this.prevSpan()), conditions, isElse, body };
+    }
+    parseWhenCondition() {
+        const span = this.current().span;
+        const negated = this.check("Bang" /* TokenKind.Bang */);
+        if (negated)
+            this.advance();
+        if (this.check("KwIs" /* TokenKind.KwIs */)) {
+            this.advance();
+            const type = this.parseTypeRef();
+            return { kind: "WhenIsCondition", span, negated, type };
+        }
+        if (this.check("KwIn" /* TokenKind.KwIn */)) {
+            this.advance();
+            const expr = this.parseExpr();
+            return { kind: "WhenInCondition", span, negated, expr };
+        }
+        const expr = this.parseExpr();
+        return { kind: "WhenExprCondition", span, expr };
+    }
+    parseForStmt() {
+        const start = this.expect("KwFor" /* TokenKind.KwFor */).span;
+        this.expect("LParen" /* TokenKind.LParen */);
+        const binding = this.parseForBinding();
+        this.expect("KwIn" /* TokenKind.KwIn */);
+        const iterable = this.parseExpr();
+        this.expect("RParen" /* TokenKind.RParen */);
+        const body = this.parseBlock();
+        return { kind: "ForStmt", span: AST.spanFrom(start, body.span), binding, iterable, body };
+    }
+    parseForBinding() {
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            this.advance();
+            const names = [];
+            while (!this.check("RParen" /* TokenKind.RParen */) && !this.check("EOF" /* TokenKind.EOF */)) {
+                if (this.check("Underscore" /* TokenKind.Underscore */)) {
+                    names.push(null);
+                    this.advance();
+                }
+                else
+                    names.push(this.expectIdentifier());
+                if (!this.check("RParen" /* TokenKind.RParen */))
+                    this.expect("Comma" /* TokenKind.Comma */);
+            }
+            this.expect("RParen" /* TokenKind.RParen */);
+            return { kind: "TupleDestructure", names };
+        }
+        return this.expectIdentifier();
+    }
+    parseWhileStmt() {
+        const start = this.expect("KwWhile" /* TokenKind.KwWhile */).span;
+        this.expect("LParen" /* TokenKind.LParen */);
+        const condition = this.parseExpr();
+        this.expect("RParen" /* TokenKind.RParen */);
+        const body = this.parseBlock();
+        return { kind: "WhileStmt", span: AST.spanFrom(start, body.span), condition, body };
+    }
+    parseDoWhileStmt() {
+        const start = this.expect("KwDo" /* TokenKind.KwDo */).span;
+        const body = this.parseBlock();
+        this.expect("KwWhile" /* TokenKind.KwWhile */);
+        this.expect("LParen" /* TokenKind.LParen */);
+        const condition = this.parseExpr();
+        this.expect("RParen" /* TokenKind.RParen */);
+        this.eatSemicolon();
+        return { kind: "DoWhileStmt", span: AST.spanFrom(start, this.prevSpan()), body, condition };
+    }
+    parseTryCatchStmt() {
+        const start = this.expect("KwTry" /* TokenKind.KwTry */).span;
+        const body = this.parseBlock();
+        const catches = [];
+        while (this.check("KwCatch" /* TokenKind.KwCatch */)) {
+            catches.push(this.parseCatchClause());
+        }
+        let fin = null;
+        if (this.check("KwFinally" /* TokenKind.KwFinally */)) {
+            this.advance();
+            fin = this.parseBlock();
+        }
+        return { kind: "TryCatchStmt", span: AST.spanFrom(start, this.prevSpan()), body, catches, finally: fin };
+    }
+    parseCatchClause() {
+        const start = this.expect("KwCatch" /* TokenKind.KwCatch */).span;
+        this.expect("LParen" /* TokenKind.LParen */);
+        const name = this.expectIdentifier();
+        this.expect("Colon" /* TokenKind.Colon */);
+        const type = this.parseTypeRef();
+        this.expect("RParen" /* TokenKind.RParen */);
+        const body = this.parseBlock();
+        return { span: AST.spanFrom(start, body.span), name, type, body };
+    }
+    parseLabeledStmt() {
+        const start = this.current().span;
+        const label = this.advance().text; // label name
+        this.expect("At" /* TokenKind.At */);
+        const body = this.parseStmt();
+        return { kind: "LabeledStmt", span: AST.spanFrom(start, body.span), label, body };
+    }
+    // ── Expressions (Pratt parser / precedence climbing) ──────────────────────
+    parseExpr() {
+        if (this.depth > constants_js_1.MAX_EXPR_DEPTH) {
+            const tok = this.current();
+            this.diag.error(tok.span, diagnostics_js_1.E_EXPECTED_EXPRESSION, `Expression nesting too deep near '${tok.text || tok.kind}'`);
+            // Make forward progress so callers can recover instead of looping.
+            if (!this.check("EOF" /* TokenKind.EOF */))
+                this.advance();
+            return { kind: "NullLiteralExpr", span: tok.span };
+        }
+        this.depth++;
+        try {
+            return this.parseAssign();
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    parseAssign() {
+        const left = this.parseElvis();
+        const assignOps = {
+            ["Eq" /* TokenKind.Eq */]: "=",
+            ["PlusEq" /* TokenKind.PlusEq */]: "+=",
+            ["MinusEq" /* TokenKind.MinusEq */]: "-=",
+            ["StarEq" /* TokenKind.StarEq */]: "*=",
+            ["SlashEq" /* TokenKind.SlashEq */]: "/=",
+            ["PercentEq" /* TokenKind.PercentEq */]: "%=",
+        };
+        const op = assignOps[this.current().kind];
+        if (op) {
+            this.advance();
+            const right = this.parseAssign();
+            if (op === "=") {
+                return {
+                    kind: "AssignExpr",
+                    span: AST.spanFrom(left.span, right.span),
+                    target: left,
+                    value: right,
+                };
+            }
+            return {
+                kind: "CompoundAssignExpr",
+                span: AST.spanFrom(left.span, right.span),
+                op: op,
+                target: left,
+                value: right,
+            };
+        }
+        return left;
+    }
+    parseElvis() {
+        let left = this.parseOr();
+        while (this.check("QuestionColon" /* TokenKind.QuestionColon */)) {
+            this.advance();
+            const right = this.parseOr();
+            left = { kind: "ElvisExpr", span: AST.spanFrom(left.span, right.span), left, right };
+        }
+        return left;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.check("PipePipe" /* TokenKind.PipePipe */)) {
+            this.advance();
+            const right = this.parseAnd();
+            left = { kind: "BinaryExpr", span: AST.spanFrom(left.span, right.span), op: "||", left, right };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseEquality();
+        while (this.check("AmpAmp" /* TokenKind.AmpAmp */)) {
+            this.advance();
+            const right = this.parseEquality();
+            left = { kind: "BinaryExpr", span: AST.spanFrom(left.span, right.span), op: "&&", left, right };
+        }
+        return left;
+    }
+    parseEquality() {
+        let left = this.parseComparison();
+        while (true) {
+            let op = null;
+            if (this.check("EqEq" /* TokenKind.EqEq */))
+                op = "==";
+            else if (this.check("BangEq" /* TokenKind.BangEq */))
+                op = "!=";
+            else if (this.check("EqEqEq" /* TokenKind.EqEqEq */))
+                op = "===";
+            else if (this.check("BangEqEq" /* TokenKind.BangEqEq */))
+                op = "!==";
+            else
+                break;
+            this.advance();
+            const right = this.parseComparison();
+            left = { kind: "BinaryExpr", span: AST.spanFrom(left.span, right.span), op, left, right };
+        }
+        return left;
+    }
+    parseComparison() {
+        let left = this.parseRange();
+        while (true) {
+            let op = null;
+            if (this.check("Lt" /* TokenKind.Lt */))
+                op = "<";
+            else if (this.check("Gt" /* TokenKind.Gt */))
+                op = ">";
+            else if (this.check("LtEq" /* TokenKind.LtEq */))
+                op = "<=";
+            else if (this.check("GtEq" /* TokenKind.GtEq */))
+                op = ">=";
+            else
+                break;
+            this.advance();
+            const right = this.parseRange();
+            left = { kind: "BinaryExpr", span: AST.spanFrom(left.span, right.span), op, left, right };
+        }
+        return left;
+    }
+    parseRange() {
+        const left = this.parseInfix();
+        if (this.check("DotDot" /* TokenKind.DotDot */)) {
+            this.advance();
+            const right = this.parseInfix();
+            return { kind: "RangeExpr", span: AST.spanFrom(left.span, right.span), from: left, to: right, inclusive: true };
+        }
+        if (this.check("DotDotLt" /* TokenKind.DotDotLt */)) {
+            this.advance();
+            const right = this.parseInfix();
+            return { kind: "RangeExpr", span: AST.spanFrom(left.span, right.span), from: left, to: right, inclusive: false };
+        }
+        return left;
+    }
+    parseInfix() {
+        let left = this.parseAdditive();
+        // Infix function calls: `a infixFun b` → `a.infixFun(b)`
+        // An identifier at this position (not a keyword, not the start of a block) is an infix call.
+        while (this.check("Identifier" /* TokenKind.Identifier */)) {
+            // Disambiguate: peek to see if the token after the identifier is a valid start of an expression.
+            // If the next next token is `(`, it's a regular call like `foo bar(...)`, not infix.
+            // We accept any identifier followed by a non-( expression start.
+            const saved = this.pos;
+            const name = this.current().text;
+            this.advance(); // consume identifier
+            // If followed immediately by `(` it looks like a regular call, not infix — back off
+            if (this.check("LParen" /* TokenKind.LParen */)) {
+                this.pos = saved;
+                break;
+            }
+            // Try to parse the right-hand operand
+            const right = this.parseAdditive();
+            const callee = {
+                kind: "MemberExpr",
+                span: left.span,
+                target: left,
+                member: name,
+            };
+            const callArg = {
+                span: right.span,
+                name: null,
+                spread: false,
+                value: right,
+            };
+            left = {
+                kind: "CallExpr",
+                span: AST.spanFrom(left.span, right.span),
+                callee,
+                typeArgs: [],
+                args: [callArg],
+                trailingLambda: null,
+            };
+        }
+        // `is` and `!is` checks
+        while (this.check("KwIs" /* TokenKind.KwIs */) || (this.check("Bang" /* TokenKind.Bang */) && this.checkNext("KwIs" /* TokenKind.KwIs */))) {
+            const negated = this.check("Bang" /* TokenKind.Bang */);
+            if (negated)
+                this.advance();
+            this.advance(); // `is`
+            const type = this.parseTypeRef();
+            left = { kind: "TypeCheckExpr", span: AST.spanFrom(left.span, type.span), negated, expr: left, type };
+        }
+        // `as` and `as?`
+        while (this.check("KwAs" /* TokenKind.KwAs */)) {
+            this.advance();
+            const safe = this.check("Question" /* TokenKind.Question */);
+            if (safe)
+                this.advance();
+            const type = this.parseTypeRef();
+            if (safe) {
+                left = { kind: "SafeCastExpr", span: AST.spanFrom(left.span, type.span), expr: left, type };
+            }
+            else {
+                left = { kind: "TypeCastExpr", span: AST.spanFrom(left.span, type.span), expr: left, type };
+            }
+        }
+        return left;
+    }
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.check("Plus" /* TokenKind.Plus */) || this.check("Minus" /* TokenKind.Minus */)) {
+            const op = this.check("Plus" /* TokenKind.Plus */) ? "+" : "-";
+            this.advance();
+            const right = this.parseMultiplicative();
+            left = { kind: "BinaryExpr", span: AST.spanFrom(left.span, right.span), op, left, right };
+        }
+        return left;
+    }
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.check("Star" /* TokenKind.Star */) || this.check("Slash" /* TokenKind.Slash */) || this.check("Percent" /* TokenKind.Percent */)) {
+            const op = this.check("Star" /* TokenKind.Star */) ? "*" : this.check("Slash" /* TokenKind.Slash */) ? "/" : "%";
+            this.advance();
+            const right = this.parseUnary();
+            left = { kind: "BinaryExpr", span: AST.spanFrom(left.span, right.span), op, left, right };
+        }
+        return left;
+    }
+    parseUnary() {
+        const span = this.current().span;
+        if (this.check("Bang" /* TokenKind.Bang */)) {
+            this.advance();
+            const operand = this.parseUnary();
+            return { kind: "UnaryExpr", span: AST.spanFrom(span, operand.span), op: "!", operand, prefix: true };
+        }
+        if (this.check("Minus" /* TokenKind.Minus */)) {
+            this.advance();
+            const operand = this.parseUnary();
+            return { kind: "UnaryExpr", span: AST.spanFrom(span, operand.span), op: "-", operand, prefix: true };
+        }
+        if (this.check("Plus" /* TokenKind.Plus */)) {
+            this.advance();
+            return this.parseUnary();
+        }
+        // Prefix ++ / --
+        if (this.check("PlusPlus" /* TokenKind.PlusPlus */) || this.check("MinusMinus" /* TokenKind.MinusMinus */)) {
+            const op = this.check("PlusPlus" /* TokenKind.PlusPlus */) ? "++" : "--";
+            this.advance();
+            const target = this.parsePostfix();
+            return { kind: "IncrDecrExpr", span: AST.spanFrom(span, target.span), op, target, prefix: true };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        loop: while (true) {
+            switch (this.current().kind) {
+                case "Dot" /* TokenKind.Dot */: {
+                    this.advance();
+                    const member = this.expectIdentOrKeyword();
+                    expr = { kind: "MemberExpr", span: AST.spanFrom(expr.span, this.prevSpan()), target: expr, member };
+                    break;
+                }
+                case "QuestionDot" /* TokenKind.QuestionDot */: {
+                    this.advance();
+                    // x?.() — safe invocation of a nullable function value
+                    if (this.check("LParen" /* TokenKind.LParen */)) {
+                        const args = this.parseCallArgs();
+                        let trailingLambda = null;
+                        const savedPosAfterArgs = this.pos;
+                        while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                            this.advance();
+                        if (this.check("LBrace" /* TokenKind.LBrace */)) {
+                            trailingLambda = this.parseLambda();
+                        }
+                        else {
+                            this.pos = savedPosAfterArgs;
+                        }
+                        expr = {
+                            kind: "SafeCallExpr",
+                            span: AST.spanFrom(expr.span, this.prevSpan()),
+                            callee: expr,
+                            args,
+                            trailingLambda,
+                        };
+                        break;
+                    }
+                    const member = this.expectIdentOrKeyword();
+                    expr = { kind: "SafeMemberExpr", span: AST.spanFrom(expr.span, this.prevSpan()), target: expr, member };
+                    break;
+                }
+                case "BangBang" /* TokenKind.BangBang */: {
+                    const span = this.advance().span;
+                    expr = { kind: "NotNullExpr", span: AST.spanFrom(expr.span, span), expr };
+                    break;
+                }
+                case "LParen" /* TokenKind.LParen */: {
+                    const args = this.parseCallArgs();
+                    let trailingLambda = null;
+                    // Eat ASI-inserted semicolons between ) and { so Compose-style
+                    // `foo(args) \n { ... }` works (like Kotlin trailing lambdas).
+                    // Restore position if no { follows so statement boundaries are preserved.
+                    const savedPosAfterArgs = this.pos;
+                    while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                        this.advance();
+                    if (this.check("LBrace" /* TokenKind.LBrace */)) {
+                        trailingLambda = this.parseLambda();
+                    }
+                    else {
+                        this.pos = savedPosAfterArgs;
+                    }
+                    expr = {
+                        kind: "CallExpr",
+                        span: AST.spanFrom(expr.span, this.prevSpan()),
+                        callee: expr,
+                        typeArgs: [],
+                        args,
+                        trailingLambda,
+                    };
+                    break;
+                }
+                case "Lt" /* TokenKind.Lt */: {
+                    if (this.current().span.startOffset > 0 && this.source[this.current().span.startOffset - 1] === "\n")
+                        break loop;
+                    // Only attempt type-arg parsing when the next token can actually start a type
+                    // argument (* or `in` or an Identifier). All other tokens should be treated as
+                    // the < comparison operator.
+                    const nextKind = this.tokens[this.pos + 1]?.kind;
+                    if (nextKind !== "Star" /* TokenKind.Star */ && nextKind !== "KwIn" /* TokenKind.KwIn */ && nextKind !== "Identifier" /* TokenKind.Identifier */)
+                        break loop;
+                    const saved = this.pos;
+                    const diagCheckpoint = this.diag.checkpoint();
+                    try {
+                        const typeArgs = this.parseTypeArgs();
+                        if (this.check("LParen" /* TokenKind.LParen */)) {
+                            const args = this.parseCallArgs();
+                            let trailingLambda = null;
+                            if (this.check("LBrace" /* TokenKind.LBrace */)) {
+                                trailingLambda = this.parseLambda();
+                            }
+                            expr = {
+                                kind: "CallExpr",
+                                span: AST.spanFrom(expr.span, this.prevSpan()),
+                                callee: expr,
+                                typeArgs,
+                                args,
+                                trailingLambda,
+                            };
+                            break;
+                        }
+                    }
+                    catch { /**/ }
+                    this.pos = saved;
+                    this.diag.rollback(diagCheckpoint);
+                    break loop;
+                }
+                case "LBracket" /* TokenKind.LBracket */: {
+                    this.advance();
+                    const index = this.parseExpr();
+                    const end = this.expect("RBracket" /* TokenKind.RBracket */).span;
+                    expr = { kind: "IndexExpr", span: AST.spanFrom(expr.span, end), target: expr, index };
+                    break;
+                }
+                case "PlusPlus" /* TokenKind.PlusPlus */:
+                case "MinusMinus" /* TokenKind.MinusMinus */: {
+                    const op = this.check("PlusPlus" /* TokenKind.PlusPlus */) ? "++" : "--";
+                    const end = this.advance().span;
+                    expr = {
+                        kind: "IncrDecrExpr",
+                        span: AST.spanFrom(expr.span, end),
+                        op,
+                        target: expr,
+                        prefix: false,
+                    };
+                    break;
+                }
+                case "LBrace" /* TokenKind.LBrace */: {
+                    if (!this.isStartOfNewStatement()) {
+                        const lambda = this.parseLambda();
+                        expr = {
+                            kind: "CallExpr",
+                            span: AST.spanFrom(expr.span, lambda.span),
+                            callee: expr,
+                            typeArgs: [],
+                            args: [],
+                            trailingLambda: lambda,
+                        };
+                    }
+                    else {
+                        break loop;
+                    }
+                    break;
+                }
+                default:
+                    break loop;
+            }
+        }
+        return expr;
+    }
+    parsePrimary() {
+        const tok = this.current();
+        switch (tok.kind) {
+            case "IntLiteral" /* TokenKind.IntLiteral */:
+                this.advance();
+                return { kind: "IntLiteralExpr", span: tok.span, value: tok.value };
+            case "LongLiteral" /* TokenKind.LongLiteral */:
+                this.advance();
+                return { kind: "LongLiteralExpr", span: tok.span, value: tok.value };
+            case "FloatLiteral" /* TokenKind.FloatLiteral */:
+                this.advance();
+                return { kind: "FloatLiteralExpr", span: tok.span, value: tok.value };
+            case "DoubleLiteral" /* TokenKind.DoubleLiteral */:
+                this.advance();
+                return { kind: "DoubleLiteralExpr", span: tok.span, value: tok.value };
+            case "BooleanLiteral" /* TokenKind.BooleanLiteral */:
+                this.advance();
+                return { kind: "BooleanLiteralExpr", span: tok.span, value: tok.value };
+            case "NullLiteral" /* TokenKind.NullLiteral */:
+                this.advance();
+                return { kind: "NullLiteralExpr", span: tok.span };
+            case "StringLiteral" /* TokenKind.StringLiteral */:
+                return this.parseStringLiteralExpr();
+            case "RawStringLiteral" /* TokenKind.RawStringLiteral */: {
+                this.advance();
+                return { kind: "StringLiteralExpr", span: tok.span, value: tok.value, raw: true };
+            }
+            case "Identifier" /* TokenKind.Identifier */:
+                this.advance();
+                return { kind: "NameExpr", span: tok.span, name: tok.text };
+            case "KwThis" /* TokenKind.KwThis */: {
+                this.advance();
+                let label = null;
+                if (this.check("At" /* TokenKind.At */)) {
+                    this.advance();
+                    label = this.expectIdentifier();
+                }
+                return { kind: "ThisExpr", span: tok.span, label };
+            }
+            case "KwSuper" /* TokenKind.KwSuper */: {
+                this.advance();
+                let label = null;
+                if (this.check("At" /* TokenKind.At */)) {
+                    this.advance();
+                    label = this.expectIdentifier();
+                }
+                return { kind: "SuperExpr", span: tok.span, label };
+            }
+            case "KwIf" /* TokenKind.KwIf */:
+                return this.parseIfExpr();
+            case "KwWhen" /* TokenKind.KwWhen */:
+                return this.parseWhenExpr();
+            case "KwTry" /* TokenKind.KwTry */:
+                return this.parseTryCatchExpr();
+            case "KwLaunch" /* TokenKind.KwLaunch */:
+                return this.parseLaunchExpr();
+            case "KwAsync" /* TokenKind.KwAsync */:
+                return this.parseAsyncExpr();
+            case "KwReturn" /* TokenKind.KwReturn */: {
+                this.advance();
+                let label = null;
+                if (this.check("At" /* TokenKind.At */)) {
+                    this.advance();
+                    label = this.expectIdentifier();
+                }
+                let value = null;
+                if (!this.check("Semicolon" /* TokenKind.Semicolon */) && !this.check("RBrace" /* TokenKind.RBrace */)) {
+                    value = this.parseExpr();
+                }
+                return { kind: "ReturnExpr", span: AST.spanFrom(tok.span, this.prevSpan()), label, value };
+            }
+            case "KwBreak" /* TokenKind.KwBreak */: {
+                this.advance();
+                let label = null;
+                if (this.check("At" /* TokenKind.At */)) {
+                    this.advance();
+                    label = this.expectIdentifier();
+                }
+                return { kind: "BreakExpr", span: tok.span, label };
+            }
+            case "KwContinue" /* TokenKind.KwContinue */: {
+                this.advance();
+                let label = null;
+                if (this.check("At" /* TokenKind.At */)) {
+                    this.advance();
+                    label = this.expectIdentifier();
+                }
+                return { kind: "ContinueExpr", span: tok.span, label };
+            }
+            case "LParen" /* TokenKind.LParen */: {
+                // Check if this is an arrow function: (params) => body
+                if (this.looksLikeArrowFunction()) {
+                    return this.parseArrowFunction();
+                }
+                this.advance();
+                const expr = this.parseExpr();
+                this.expect("RParen" /* TokenKind.RParen */);
+                return { kind: "ParenExpr", span: AST.spanFrom(tok.span, this.prevSpan()), expr };
+            }
+            case "LBrace" /* TokenKind.LBrace */:
+                return this.parseLambda();
+            case "KwObject" /* TokenKind.KwObject */:
+                return this.parseObjectExpr();
+            case "Lt" /* TokenKind.Lt */: {
+                // JSX: <TagName ...> or <TagName ... />
+                // Only treat as JSX if immediately followed by an identifier (tag name)
+                if (this.tokens[this.pos + 1]?.kind === "Identifier" /* TokenKind.Identifier */) {
+                    return this.parseJsxElement();
+                }
+                // fall through to error
+                this.diag.error(tok.span, diagnostics_js_1.E_EXPECTED_EXPRESSION, `Expected an expression, got '${tok.text}'`);
+                this.advance();
+                return { kind: "NullLiteralExpr", span: tok.span };
+            }
+            // listOf(...), setOf(...), mapOf(...) are stdlib calls, handled normally
+            default: {
+                this.diag.error(tok.span, diagnostics_js_1.E_EXPECTED_EXPRESSION, `Expected an expression, got '${tok.text}'`);
+                this.advance();
+                // Return a placeholder to allow parser to continue
+                return { kind: "NullLiteralExpr", span: tok.span };
+            }
+        }
+    }
+    // ── JSX ────────────────────────────────────────────────────────────────────
+    parseJsxElement() {
+        const start = this.expect("Lt" /* TokenKind.Lt */).span;
+        // Tag name (may contain dots: Router.Link)
+        let tag = this.current().text;
+        this.advance();
+        while (this.check("Dot" /* TokenKind.Dot */)) {
+            this.advance();
+            tag += "." + this.current().text;
+            this.advance();
+        }
+        // Attributes
+        const attrs = [];
+        while (!this.check("Gt" /* TokenKind.Gt */) && !this.check("Slash" /* TokenKind.Slash */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            // Skip synthetic semicolons (ASI can insert them in multi-line JSX)
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (this.check("Gt" /* TokenKind.Gt */) || this.check("Slash" /* TokenKind.Slash */))
+                break;
+            const attrStart = this.current().span;
+            const attrName = this.current().text; // accept keywords (class, for) as attr names
+            this.advance();
+            if (!this.check("Eq" /* TokenKind.Eq */)) {
+                attrs.push({ span: attrStart, name: attrName, value: null });
+                continue;
+            }
+            this.advance(); // consume "="
+            if (this.check("StringLiteral" /* TokenKind.StringLiteral */)) {
+                const expr = this.parseStringLiteralExpr();
+                attrs.push({ span: AST.spanFrom(attrStart, expr.span), name: attrName, value: expr });
+            }
+            else if (this.check("LBrace" /* TokenKind.LBrace */)) {
+                this.advance();
+                const expr = this.parseExpr();
+                while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                    this.advance();
+                this.expect("RBrace" /* TokenKind.RBrace */);
+                attrs.push({ span: AST.spanFrom(attrStart, this.prevSpan()), name: attrName, value: expr });
+            }
+        }
+        // Self-closing: />
+        if (this.check("Slash" /* TokenKind.Slash */)) {
+            this.advance();
+            this.expect("Gt" /* TokenKind.Gt */);
+            return { kind: "JsxElement", span: AST.spanFrom(start, this.prevSpan()), tag, attrs, children: [] };
+        }
+        this.expect("Gt" /* TokenKind.Gt */); // consume opening ">"
+        const children = [];
+        while (!this.check("EOF" /* TokenKind.EOF */)) {
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            // Closing tag: </
+            if (this.check("Lt" /* TokenKind.Lt */) && this.checkNext("Slash" /* TokenKind.Slash */))
+                break;
+            // Expression child: { expr }
+            if (this.check("LBrace" /* TokenKind.LBrace */)) {
+                const childStart = this.advance().span;
+                const expr = this.parseExpr();
+                while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                    this.advance();
+                this.expect("RBrace" /* TokenKind.RBrace */);
+                children.push({ kind: "JsxExprChild", span: AST.spanFrom(childStart, this.prevSpan()), expr });
+                continue;
+            }
+            // Nested element: < Identifier
+            if (this.check("Lt" /* TokenKind.Lt */) && this.tokens[this.pos + 1]?.kind === "Identifier" /* TokenKind.Identifier */) {
+                children.push(this.parseJsxElement());
+                continue;
+            }
+            // Text content: collect until { or <, extracting raw source text
+            const textStartOffset = this.current().span.startOffset;
+            const textStartSpan = this.current().span;
+            while (!this.check("EOF" /* TokenKind.EOF */) &&
+                !this.check("LBrace" /* TokenKind.LBrace */) &&
+                !this.check("Lt" /* TokenKind.Lt */) &&
+                !this.check("Semicolon" /* TokenKind.Semicolon */)) {
+                this.advance();
+            }
+            const textEndOffset = this.current().span.startOffset;
+            // Extract raw source and normalize whitespace
+            const rawText = this.source
+                ? this.source.slice(textStartOffset, textEndOffset)
+                : "";
+            const text = rawText.replace(/\s+/g, " ").trim();
+            if (text) {
+                children.push({ kind: "JsxTextChild", span: AST.spanFrom(textStartSpan, this.prevSpan()), text });
+            }
+        }
+        // Consume closing tag: </tagname>
+        this.expect("Lt" /* TokenKind.Lt */);
+        this.expect("Slash" /* TokenKind.Slash */);
+        while (!this.check("Gt" /* TokenKind.Gt */) && !this.check("EOF" /* TokenKind.EOF */))
+            this.advance();
+        const end = this.expect("Gt" /* TokenKind.Gt */).span;
+        return { kind: "JsxElement", span: AST.spanFrom(start, end), tag, attrs, children };
+    }
+    parseStringLiteralExpr() {
+        const tok = this.current();
+        this.advance();
+        const raw = tok.value;
+        // Check if contains ${...} pattern — if so, parse as template
+        if (raw.includes("${")) {
+            const parts = [];
+            let i = 0;
+            let cur = "";
+            while (i < raw.length) {
+                if (raw[i] === "$" && raw[i + 1] === "{") {
+                    if (cur)
+                        parts.push({ kind: "LiteralPart", value: cur });
+                    cur = "";
+                    i += 2;
+                    let depth = 1;
+                    let exprSrc = "";
+                    while (i < raw.length && depth > 0) {
+                        if (raw[i] === "{")
+                            depth++;
+                        else if (raw[i] === "}") {
+                            depth--;
+                            if (depth === 0) {
+                                i++;
+                                break;
+                            }
+                        }
+                        exprSrc += raw[i++];
+                    }
+                    // Re-lex and re-parse the embedded expression
+                    const innerDiag = new diagnostics_js_1.DiagnosticBag();
+                    const innerTokens = new lexer_js_1.Lexer(exprSrc, tok.span.file, innerDiag).tokenize();
+                    const innerParser = new Parser(innerTokens, tok.span.file, innerDiag);
+                    const innerExpr = innerParser.parseExpr();
+                    this.diag.merge(innerDiag);
+                    parts.push({ kind: "ExprPart", expr: innerExpr });
+                }
+                else {
+                    cur += raw[i++];
+                }
+            }
+            if (cur)
+                parts.push({ kind: "LiteralPart", value: cur });
+            return { kind: "StringTemplateExpr", span: tok.span, parts };
+        }
+        return { kind: "StringLiteralExpr", span: tok.span, value: raw, raw: false };
+    }
+    parseIfExpr() {
+        const start = this.expect("KwIf" /* TokenKind.KwIf */).span;
+        this.expect("LParen" /* TokenKind.LParen */);
+        const condition = this.parseExpr();
+        this.expect("RParen" /* TokenKind.RParen */);
+        // Skip ASI semicolons inserted between `if (cond)` and the then-branch
+        while (this.check("Semicolon" /* TokenKind.Semicolon */))
+            this.advance();
+        const then = this.check("LBrace" /* TokenKind.LBrace */)
+            ? this.parseBlock()
+            : this.parseExpr();
+        // Skip synthetic semicolons inserted by ASI between then-branch and else
+        while (this.check("Semicolon" /* TokenKind.Semicolon */))
+            this.advance();
+        this.expect("KwElse" /* TokenKind.KwElse */);
+        // Skip ASI semicolons between else and the else-branch
+        while (this.check("Semicolon" /* TokenKind.Semicolon */))
+            this.advance();
+        const elseExpr = this.check("KwIf" /* TokenKind.KwIf */)
+            ? this.parseIfExpr()
+            : this.check("LBrace" /* TokenKind.LBrace */)
+                ? this.parseBlock()
+                : this.parseExpr();
+        return { kind: "IfExpr", span: AST.spanFrom(start, this.prevSpan()), condition, then, else: elseExpr };
+    }
+    parseWhenExpr() {
+        const start = this.expect("KwWhen" /* TokenKind.KwWhen */).span;
+        let subject = null;
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            const subStart = this.advance().span;
+            let binding = null;
+            if (this.check("KwVal" /* TokenKind.KwVal */) && this.peekKindAt(2) === "Eq" /* TokenKind.Eq */) {
+                this.advance();
+                binding = this.expectIdentifier();
+                this.expect("Eq" /* TokenKind.Eq */);
+            }
+            const expr = this.parseExpr();
+            this.expect("RParen" /* TokenKind.RParen */);
+            subject = { span: AST.spanFrom(subStart, this.prevSpan()), binding, expr };
+        }
+        this.expect("LBrace" /* TokenKind.LBrace */);
+        const branches = [];
+        while (!this.check("RBrace" /* TokenKind.RBrace */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            branches.push(this.parseWhenBranch());
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+        }
+        const end = this.expect("RBrace" /* TokenKind.RBrace */).span;
+        return { kind: "WhenExpr", span: AST.spanFrom(start, end), subject, branches };
+    }
+    parseTryCatchExpr() {
+        const start = this.expect("KwTry" /* TokenKind.KwTry */).span;
+        const body = this.parseBlock();
+        const catches = [];
+        while (this.check("KwCatch" /* TokenKind.KwCatch */))
+            catches.push(this.parseCatchClause());
+        let fin = null;
+        if (this.check("KwFinally" /* TokenKind.KwFinally */)) {
+            this.advance();
+            fin = this.parseBlock();
+        }
+        return { kind: "TryCatchExpr", span: AST.spanFrom(start, this.prevSpan()), body, catches, finally: fin };
+    }
+    parseLaunchExpr() {
+        const start = this.expect("KwLaunch" /* TokenKind.KwLaunch */).span;
+        let context = null;
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            this.advance();
+            context = this.parseExpr();
+            this.expect("RParen" /* TokenKind.RParen */);
+        }
+        const body = this.parseBlock();
+        return { kind: "LaunchExpr", span: AST.spanFrom(start, body.span), context, body };
+    }
+    parseAsyncExpr() {
+        const start = this.expect("KwAsync" /* TokenKind.KwAsync */).span;
+        let context = null;
+        if (this.check("LParen" /* TokenKind.LParen */)) {
+            this.advance();
+            context = this.parseExpr();
+            this.expect("RParen" /* TokenKind.RParen */);
+        }
+        const body = this.parseBlock();
+        return { kind: "AsyncExpr", span: AST.spanFrom(start, body.span), context, body };
+    }
+    parseObjectExpr() {
+        const start = this.expect("KwObject" /* TokenKind.KwObject */).span;
+        const superTypes = this.parseSuperTypes();
+        const body = this.parseClassBody();
+        return { kind: "ObjectExpr", span: AST.spanFrom(start, body.span), superTypes, body };
+    }
+    parseLambda() {
+        const start = this.expect("LBrace" /* TokenKind.LBrace */).span;
+        const params = [];
+        // Check if there are explicit params before `->` or `=>`
+        const hasParams = this.detectLambdaParams();
+        if (hasParams) {
+            // Parse params — stop at either -> or =>
+            while (!this.check("Arrow" /* TokenKind.Arrow */) && !this.check("FatArrow" /* TokenKind.FatArrow */) && !this.check("EOF" /* TokenKind.EOF */)) {
+                const pSpan = this.current().span;
+                let name = null;
+                let type = null;
+                if (this.check("Underscore" /* TokenKind.Underscore */)) {
+                    this.advance();
+                }
+                else {
+                    name = this.expectIdentifier();
+                    if (this.check("Colon" /* TokenKind.Colon */)) {
+                        this.advance();
+                        type = this.parseTypeRef();
+                    }
+                }
+                params.push({ span: AST.spanFrom(pSpan, this.prevSpan()), name, type });
+                if (!this.check("Arrow" /* TokenKind.Arrow */) && !this.check("FatArrow" /* TokenKind.FatArrow */))
+                    this.expect("Comma" /* TokenKind.Comma */);
+            }
+            // Consume either -> or =>
+            if (this.check("FatArrow" /* TokenKind.FatArrow */))
+                this.advance();
+            else
+                this.expect("Arrow" /* TokenKind.Arrow */);
+        }
+        const body = [];
+        while (!this.check("RBrace" /* TokenKind.RBrace */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (this.check("RBrace" /* TokenKind.RBrace */))
+                break;
+            const s = this.parseStmt();
+            if (s)
+                body.push(s);
+        }
+        const end = this.expect("RBrace" /* TokenKind.RBrace */).span;
+        return { kind: "LambdaExpr", span: AST.spanFrom(start, end), params, returnType: null, body };
+    }
+    /** Heuristically determine if this lambda has explicit parameters before `->` or `=>` */
+    detectLambdaParams() {
+        let i = this.pos;
+        let depth = 0;
+        while (i < this.tokens.length) {
+            const k = this.tokens[i].kind;
+            if (k === "LBrace" /* TokenKind.LBrace */ || k === "LParen" /* TokenKind.LParen */)
+                depth++;
+            else if (k === "RBrace" /* TokenKind.RBrace */ || k === "RParen" /* TokenKind.RParen */) {
+                if (depth === 0)
+                    return false;
+                depth--;
+            }
+            else if ((k === "Arrow" /* TokenKind.Arrow */ || k === "FatArrow" /* TokenKind.FatArrow */) && depth === 0) {
+                return true;
+            }
+            else if (k === "Semicolon" /* TokenKind.Semicolon */ && depth === 0) {
+                return false;
+            }
+            i++;
+        }
+        return false;
+    }
+    /** Heuristic lookahead: return true if we are at `(params) =>` (arrow function). */
+    looksLikeArrowFunction() {
+        let i = this.pos + 1; // skip the opening `(`
+        let depth = 1;
+        while (i < this.tokens.length) {
+            const k = this.tokens[i].kind;
+            if (k === "LParen" /* TokenKind.LParen */)
+                depth++;
+            else if (k === "RParen" /* TokenKind.RParen */) {
+                depth--;
+                if (depth === 0) {
+                    return this.tokens[i + 1]?.kind === "FatArrow" /* TokenKind.FatArrow */;
+                }
+            }
+            else if (k === "EOF" /* TokenKind.EOF */)
+                return false;
+            i++;
+        }
+        return false;
+    }
+    /** Parse `(params) => body` as a LambdaExpr (JS-style arrow function). */
+    parseArrowFunction() {
+        const start = this.expect("LParen" /* TokenKind.LParen */).span;
+        const params = [];
+        while (!this.check("RParen" /* TokenKind.RParen */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            const pSpan = this.current().span;
+            let name = null;
+            let type = null;
+            if (this.check("Underscore" /* TokenKind.Underscore */)) {
+                this.advance();
+            }
+            else {
+                name = this.expectIdentifier();
+                if (this.check("Colon" /* TokenKind.Colon */)) {
+                    this.advance();
+                    type = this.parseTypeRef();
+                }
+            }
+            params.push({ span: AST.spanFrom(pSpan, this.prevSpan()), name, type });
+            if (!this.check("RParen" /* TokenKind.RParen */)) {
+                while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                    this.advance();
+                if (!this.check("RParen" /* TokenKind.RParen */))
+                    this.expect("Comma" /* TokenKind.Comma */);
+            }
+        }
+        this.expect("RParen" /* TokenKind.RParen */);
+        this.expect("FatArrow" /* TokenKind.FatArrow */);
+        // Body: block `{ ... }` or single expression
+        const body = [];
+        if (this.check("LBrace" /* TokenKind.LBrace */)) {
+            const block = this.parseBlock();
+            return { kind: "LambdaExpr", span: AST.spanFrom(start, block.span), params, returnType: null, body: block.statements };
+        }
+        const expr = this.parseExpr();
+        body.push({ kind: "ExprStmt", span: expr.span, expr });
+        return { kind: "LambdaExpr", span: AST.spanFrom(start, expr.span), params, returnType: null, body };
+    }
+    // ── Call arguments ─────────────────────────────────────────────────────────
+    parseCallArgs() {
+        this.expect("LParen" /* TokenKind.LParen */);
+        const args = [];
+        while (!this.check("RParen" /* TokenKind.RParen */) && !this.check("EOF" /* TokenKind.EOF */)) {
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (this.check("RParen" /* TokenKind.RParen */) || this.check("EOF" /* TokenKind.EOF */))
+                break;
+            const prevPos = this.pos;
+            args.push(this.parseCallArg());
+            if (this.pos === prevPos)
+                break;
+            while (this.check("Semicolon" /* TokenKind.Semicolon */))
+                this.advance();
+            if (!this.check("RParen" /* TokenKind.RParen */))
+                this.expect("Comma" /* TokenKind.Comma */);
+        }
+        this.expect("RParen" /* TokenKind.RParen */);
+        return args;
+    }
+    parseCallArg() {
+        const start = this.current().span;
+        let name = null;
+        let spread = false;
+        if (this.check("Star" /* TokenKind.Star */)) {
+            spread = true;
+            this.advance();
+        }
+        if (this.check("Identifier" /* TokenKind.Identifier */) && this.checkNext("Eq" /* TokenKind.Eq */)) {
+            name = this.advance().text;
+            this.advance(); // =
+        }
+        const value = this.parseExpr();
+        return { span: AST.spanFrom(start, value.span), name, spread, value };
+    }
+    // ── Utilities ──────────────────────────────────────────────────────────────
+    current() {
+        return this.tokens[this.pos] ?? this.tokens[this.tokens.length - 1];
+    }
+    advance() {
+        const tok = this.current();
+        this.pos++;
+        return tok;
+    }
+    prevSpan() {
+        return this.tokens[Math.max(0, this.pos - 1)].span;
+    }
+    check(kind) {
+        return this.current().kind === kind;
+    }
+    checkNext(kind) {
+        return (this.tokens[this.pos + 1]?.kind ?? "EOF" /* TokenKind.EOF */) === kind;
+    }
+    checkIdent(name) {
+        const tok = this.current();
+        return tok.kind === "Identifier" /* TokenKind.Identifier */ && tok.text === name;
+    }
+    peekKindAt(offset) {
+        return this.tokens[this.pos + offset]?.kind ?? "EOF" /* TokenKind.EOF */;
+    }
+    expect(kind) {
+        if (this.check(kind))
+            return this.advance();
+        const tok = this.current();
+        this.diag.error(tok.span, diagnostics_js_1.E_EXPECTED_TOKEN, `Expected '${kind}' but got '${tok.text}' (${tok.kind})`);
+        // Return a fake token so parsing can continue
+        return { kind, span: tok.span, text: "" };
+    }
+    expectIdentifier() {
+        const tok = this.current();
+        if (tok.kind === "Identifier" /* TokenKind.Identifier */) {
+            this.advance();
+            return tok.text;
+        }
+        this.diag.error(tok.span, diagnostics_js_1.E_EXPECTED_TOKEN, `Expected identifier, got '${tok.text}'`);
+        return "<error>";
+    }
+    expectIdentOrKeyword() {
+        const tok = this.current();
+        if (tok.kind === "Identifier" /* TokenKind.Identifier */ || (0, helpers_js_1.isIdentifierText)(tok.text)) {
+            this.advance();
+            return tok.text;
+        }
+        this.diag.error(tok.span, diagnostics_js_1.E_EXPECTED_TOKEN, `Expected identifier, got '${tok.text}'`);
+        return "<error>";
+    }
+    eatSemicolon() {
+        while (this.check("Semicolon" /* TokenKind.Semicolon */))
+            this.advance();
+    }
+    parseDottedName() {
+        const parts = [this.expectIdentifier()];
+        while (this.check("Dot" /* TokenKind.Dot */)) {
+            this.advance();
+            parts.push(this.expectIdentifier());
+        }
+        return parts;
+    }
+    /**
+     * A trailing `{` is the start of a new statement (not a trailing lambda)
+     * when preceded by a newline-induced semicolon.
+     */
+    isStartOfNewStatement() {
+        const prev = this.tokens[this.pos - 1];
+        return prev?.kind === "Semicolon" /* TokenKind.Semicolon */ && prev.text === "\n";
+    }
+}
+exports.Parser = Parser;
+// ---------------------------------------------------------------------------
+// Public helper
+// ---------------------------------------------------------------------------
+function parse(tokens, file, diag, source = "") {
+    return new Parser(tokens, file, diag, source).parseProgram();
+}
+//# sourceMappingURL=index.js.map