kopscript 0.1.0

package/dist/parser.js

@@ -0,0 +1,995 @@
+import { TokenKind } from "./tokens.js";
+import { Lexer } from "./lexer.js";
+import { DiagnosticBag } from "./diagnostics.js";
+export class Parser {
+    constructor(tokens, diagnostics) {
+        this.tokens = tokens;
+        this.diagnostics = diagnostics;
+        this.pos = 0;
+    }
+    parseProgram() {
+        const usings = [];
+        while (this.check(TokenKind.Using)) {
+            usings.push(this.parseUsing());
+        }
+        const statements = [];
+        while (!this.check(TokenKind.EOF)) {
+            if (this.check(TokenKind.Using)) {
+                const t = this.peek();
+                this.diagnostics.error("'using' directives must appear at the top of the file, before any other declaration", t.line, t.col);
+                this.parseUsing(); // consume and discard so parsing can continue
+                continue;
+            }
+            const stmt = this.parseStatement();
+            if (stmt)
+                statements.push(stmt);
+        }
+        return { kind: "Program", usings, statements };
+    }
+    parseUsing() {
+        const start = this.advance(); // 'using'
+        const pathTok = this.consume(TokenKind.String, "Expected a module path string after 'using'");
+        this.consume(TokenKind.Semicolon, "Expected ';' after using directive");
+        return { kind: "UsingDecl", path: pathTok.lexeme, line: start.line, col: start.col };
+    }
+    // ---------- statements ----------
+    parseStatement() {
+        try {
+            if (this.check(TokenKind.Public) || this.check(TokenKind.Private))
+                return this.parseExportableDecl();
+            if (this.check(TokenKind.Const)) {
+                const decl = this.parseConstDecl();
+                this.consume(TokenKind.Semicolon, "Expected ';' after constant declaration");
+                return decl;
+            }
+            if (this.check(TokenKind.Class))
+                return this.parseClassDecl(true);
+            if (this.check(TokenKind.Interface))
+                return this.parseInterfaceDecl(true);
+            if (this.check(TokenKind.Enum))
+                return this.parseEnumDecl(true);
+            if (this.check(TokenKind.Extern))
+                return this.parseExternDecl(true);
+            if (this.check(TokenKind.LBrace))
+                return this.parseBlock();
+            if (this.check(TokenKind.If))
+                return this.parseIf();
+            if (this.check(TokenKind.While))
+                return this.parseWhile();
+            if (this.check(TokenKind.For))
+                return this.parseFor();
+            if (this.check(TokenKind.Foreach))
+                return this.parseForeach();
+            if (this.check(TokenKind.Return))
+                return this.parseReturn();
+            if (this.check(TokenKind.Try))
+                return this.parseTry();
+            if (this.check(TokenKind.Throw))
+                return this.parseThrow();
+            if (this.check(TokenKind.Break)) {
+                const t = this.advance();
+                this.consume(TokenKind.Semicolon, "Expected ';' after 'break'");
+                return { kind: "BreakStatement", line: t.line, col: t.col };
+            }
+            if (this.check(TokenKind.Continue)) {
+                const t = this.advance();
+                this.consume(TokenKind.Semicolon, "Expected ';' after 'continue'");
+                return { kind: "ContinueStatement", line: t.line, col: t.col };
+            }
+            if (this.isDeclStart())
+                return this.parseDeclaration(true);
+            const expr = this.parseExpression();
+            this.consume(TokenKind.Semicolon, "Expected ';' after expression");
+            return { kind: "ExpressionStatement", expression: expr, line: expr.line, col: expr.col };
+        }
+        catch (err) {
+            this.synchronize();
+            return null;
+        }
+    }
+    // Parses a leading `public`/`private` modifier and applies it to whatever
+    // exportable declaration follows (class, interface, enum, or free
+    // function). Variable declarations aren't exportable — `using` only pulls
+    // in types and functions — so `public`/`private` on one is a parse error.
+    parseExportableDecl() {
+        const modifierTok = this.advance(); // 'public' or 'private'
+        const isExported = modifierTok.kind === TokenKind.Public;
+        if (this.check(TokenKind.Class))
+            return this.parseClassDecl(isExported);
+        if (this.check(TokenKind.Interface))
+            return this.parseInterfaceDecl(isExported);
+        if (this.check(TokenKind.Enum))
+            return this.parseEnumDecl(isExported);
+        if (this.check(TokenKind.Extern))
+            return this.parseExternDecl(isExported);
+        if (this.isDeclStart()) {
+            const decl = this.parseDeclaration(isExported);
+            if (decl.kind === "VarDecl") {
+                this.diagnostics.error("'public'/'private' cannot modify a variable declaration", modifierTok.line, modifierTok.col);
+            }
+            return decl;
+        }
+        this.diagnostics.error("Expected a class, interface, enum, or function declaration after 'public'/'private'", modifierTok.line, modifierTok.col);
+        throw new ParseError();
+    }
+    // Lookahead for the C#-style `Type name` declaration shape (locals and
+    // free functions alike): a type, then an identifier. Two bare identifiers
+    // in a row never occurs anywhere else in this grammar, so the heuristic is
+    // unambiguous — but now that types can start with `(` (function types),
+    // a simple fixed-width token peek can't reliably tell a function type
+    // apart from, say, a parenthesized call. So this does a real trial parse
+    // of a type via parseType() and rolls back position and any diagnostics
+    // it emitted along the way, regardless of outcome.
+    isDeclStart() {
+        const savedPos = this.pos;
+        const savedDiagnosticsLength = this.diagnostics.diagnostics.length;
+        let result;
+        try {
+            if (this.check(TokenKind.Async))
+                this.advance(); // optional 'async' prefix on a free function
+            this.parseType();
+            result = this.check(TokenKind.Identifier);
+        }
+        catch {
+            result = false;
+        }
+        this.pos = savedPos;
+        this.diagnostics.diagnostics.length = savedDiagnosticsLength;
+        return result;
+    }
+    // Parses `Type name = init;` or `[async] Type name(params) { ... }` — a
+    // variable or a free function, disambiguated by what follows the name.
+    // `isExported` only applies to the function case (see parseExportableDecl);
+    // `async` only applies there too (checked and rejected on a var below).
+    parseDeclaration(isExported) {
+        const start = this.peek();
+        let isAsync = false;
+        if (this.check(TokenKind.Async)) {
+            isAsync = true;
+            this.advance();
+        }
+        const type = this.parseType();
+        const name = this.consume(TokenKind.Identifier, "Expected name").lexeme;
+        if (this.check(TokenKind.LParen)) {
+            const params = this.parseParamList();
+            const body = this.parseBlock();
+            return { kind: "FunctionDecl", isExported, isAsync, name, params, returnType: type, body, line: start.line, col: start.col };
+        }
+        if (isAsync) {
+            this.diagnostics.error("'async' cannot modify a variable declaration", start.line, start.col);
+        }
+        this.consume(TokenKind.Assign, "Expected '=' in variable declaration");
+        const init = this.parseExpression();
+        this.consume(TokenKind.Semicolon, "Expected ';' after variable declaration");
+        return { kind: "VarDecl", isConst: false, name, type, init, line: start.line, col: start.col };
+    }
+    // Parses `Type name = init` without consuming a trailing terminator — used
+    // both for top-level/block statements (which add the `;`) and for-loop
+    // initializers (which don't).
+    parseVarDeclHeader() {
+        const start = this.peek();
+        const type = this.parseType();
+        const name = this.consume(TokenKind.Identifier, "Expected variable name").lexeme;
+        this.consume(TokenKind.Assign, "Expected '=' in variable declaration");
+        const init = this.parseExpression();
+        return { kind: "VarDecl", isConst: false, name, type, init, line: start.line, col: start.col };
+    }
+    parseConstDecl() {
+        const start = this.advance(); // 'const'
+        const type = this.parseType();
+        const name = this.consume(TokenKind.Identifier, "Expected constant name").lexeme;
+        this.consume(TokenKind.Assign, "Expected '=' in constant declaration");
+        const init = this.parseExpression();
+        return { kind: "VarDecl", isConst: true, name, type, init, line: start.line, col: start.col };
+    }
+    parseParamList() {
+        this.consume(TokenKind.LParen, "Expected '('");
+        const params = [];
+        if (!this.check(TokenKind.RParen)) {
+            do {
+                const type = this.parseType();
+                const name = this.consume(TokenKind.Identifier, "Expected parameter name").lexeme;
+                params.push({ name, type });
+            } while (this.match(TokenKind.Comma));
+        }
+        this.consume(TokenKind.RParen, "Expected ')' after parameters");
+        return params;
+    }
+    parseClassDecl(isExported) {
+        const start = this.advance(); // 'class'
+        const name = this.consume(TokenKind.Identifier, "Expected class name").lexeme;
+        const baseList = [];
+        if (this.match(TokenKind.Colon)) {
+            do {
+                baseList.push(this.consume(TokenKind.Identifier, "Expected base class or interface name").lexeme);
+            } while (this.match(TokenKind.Comma));
+        }
+        this.consume(TokenKind.LBrace, "Expected '{' before class body");
+        const fields = [];
+        const properties = [];
+        const methods = [];
+        let ctor = null;
+        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            let visibility = "public";
+            if (this.check(TokenKind.Public) || this.check(TokenKind.Private) || this.check(TokenKind.Protected)) {
+                const v = this.advance().kind;
+                visibility = v === TokenKind.Public ? "public" : v === TokenKind.Private ? "private" : "protected";
+            }
+            if (this.check(TokenKind.Constructor)) {
+                const ctorStart = this.advance();
+                const params = this.parseParamList();
+                let baseArgs = null;
+                if (this.match(TokenKind.Colon)) {
+                    this.consume(TokenKind.Base, "Expected 'base' after ':'");
+                    this.consume(TokenKind.LParen, "Expected '(' after 'base'");
+                    baseArgs = [];
+                    if (!this.check(TokenKind.RParen)) {
+                        do {
+                            baseArgs.push(this.parseExpression());
+                        } while (this.match(TokenKind.Comma));
+                    }
+                    this.consume(TokenKind.RParen, "Expected ')' after base constructor arguments");
+                }
+                const body = this.parseBlock();
+                ctor = { kind: "ConstructorDecl", params, baseArgs, body, line: ctorStart.line, col: ctorStart.col };
+                continue;
+            }
+            let isStatic = false;
+            if (this.check(TokenKind.Static)) {
+                isStatic = true;
+                this.advance();
+            }
+            let isAsync = false;
+            if (this.check(TokenKind.Async)) {
+                isAsync = true;
+                this.advance();
+            }
+            let isVirtual = false;
+            let isOverride = false;
+            if (this.check(TokenKind.Virtual)) {
+                isVirtual = true;
+                this.advance();
+            }
+            else if (this.check(TokenKind.Override)) {
+                isOverride = true;
+                this.advance();
+            }
+            const memberStart = this.peek();
+            const type = this.parseType();
+            const memberName = this.consume(TokenKind.Identifier, "Expected field, property, or method name").lexeme;
+            if (this.check(TokenKind.LParen)) {
+                const params = this.parseParamList();
+                const body = this.parseBlock();
+                if (isStatic && (isVirtual || isOverride)) {
+                    this.diagnostics.error("'static' methods cannot be 'virtual' or 'override'", memberStart.line, memberStart.col);
+                }
+                methods.push({
+                    kind: "MethodDecl",
+                    visibility,
+                    isStatic,
+                    isAsync,
+                    isVirtual,
+                    isOverride,
+                    name: memberName,
+                    params,
+                    returnType: type,
+                    body,
+                    line: memberStart.line,
+                    col: memberStart.col,
+                });
+            }
+            else if (this.check(TokenKind.LBrace)) {
+                if (isVirtual || isOverride) {
+                    this.diagnostics.error("'virtual'/'override' are only valid on methods", memberStart.line, memberStart.col);
+                }
+                if (isAsync) {
+                    this.diagnostics.error("'async' is only valid on methods", memberStart.line, memberStart.col);
+                }
+                if (isStatic) {
+                    this.diagnostics.error("'static' properties are not supported in v1 (use a static field instead)", memberStart.line, memberStart.col);
+                }
+                this.advance(); // '{'
+                this.consume(TokenKind.Get, "Expected 'get' in property accessor list");
+                this.consume(TokenKind.Semicolon, "Expected ';' after 'get'");
+                let hasSetter = false;
+                if (this.check(TokenKind.Set)) {
+                    hasSetter = true;
+                    this.advance();
+                    this.consume(TokenKind.Semicolon, "Expected ';' after 'set'");
+                }
+                this.consume(TokenKind.RBrace, "Expected '}' after property accessors");
+                properties.push({
+                    kind: "PropertyDecl",
+                    visibility,
+                    hasSetter,
+                    name: memberName,
+                    type,
+                    line: memberStart.line,
+                    col: memberStart.col,
+                });
+            }
+            else {
+                if (isVirtual || isOverride) {
+                    this.diagnostics.error("'virtual'/'override' are only valid on methods", memberStart.line, memberStart.col);
+                }
+                if (isAsync) {
+                    this.diagnostics.error("'async' is only valid on methods", memberStart.line, memberStart.col);
+                }
+                let initializer = null;
+                if (isStatic) {
+                    this.consume(TokenKind.Assign, "Static fields require an initializer (there is no constructor to assign them in)");
+                    initializer = this.parseExpression();
+                }
+                this.consume(TokenKind.Semicolon, "Expected ';' after field declaration");
+                fields.push({
+                    kind: "FieldDecl",
+                    visibility,
+                    isStatic,
+                    initializer,
+                    name: memberName,
+                    type,
+                    line: memberStart.line,
+                    col: memberStart.col,
+                });
+            }
+        }
+        this.consume(TokenKind.RBrace, "Expected '}' after class body");
+        return { kind: "ClassDecl", isExported, name, baseList, fields, properties, constructor: ctor, methods, line: start.line, col: start.col };
+    }
+    parseInterfaceDecl(isExported) {
+        const start = this.advance(); // 'interface'
+        const name = this.consume(TokenKind.Identifier, "Expected interface name").lexeme;
+        const baseList = [];
+        if (this.match(TokenKind.Colon)) {
+            do {
+                baseList.push(this.consume(TokenKind.Identifier, "Expected base interface name").lexeme);
+            } while (this.match(TokenKind.Comma));
+        }
+        this.consume(TokenKind.LBrace, "Expected '{' before interface body");
+        const methods = [];
+        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            const memberStart = this.peek();
+            const returnType = this.parseType();
+            const methodName = this.consume(TokenKind.Identifier, "Expected method name").lexeme;
+            const params = this.parseParamList();
+            this.consume(TokenKind.Semicolon, "Expected ';' after interface method signature");
+            methods.push({ name: methodName, params, returnType, line: memberStart.line, col: memberStart.col });
+        }
+        this.consume(TokenKind.RBrace, "Expected '}' after interface body");
+        return { kind: "InterfaceDecl", isExported, name, baseList, methods, line: start.line, col: start.col };
+    }
+    parseEnumDecl(isExported) {
+        const start = this.advance(); // 'enum'
+        const name = this.consume(TokenKind.Identifier, "Expected enum name").lexeme;
+        this.consume(TokenKind.LBrace, "Expected '{' before enum body");
+        const members = [];
+        if (!this.check(TokenKind.RBrace)) {
+            do {
+                members.push(this.consume(TokenKind.Identifier, "Expected enum member name").lexeme);
+            } while (this.match(TokenKind.Comma) && !this.check(TokenKind.RBrace));
+        }
+        this.consume(TokenKind.RBrace, "Expected '}' after enum body");
+        return { kind: "EnumDecl", isExported, name, members, line: start.line, col: start.col };
+    }
+    // `extern <Type> <Name>(<params>) [from "<path>"] [as "<jsName>"];`      (function)
+    // `extern <Type> <Name> [from "<path>"] [as "<jsName>"];`                (value)
+    // `extern class <Name> { ... } [from "<path>"] [as "<jsName>"];`         (class)
+    parseExternDecl(isExported) {
+        const start = this.advance(); // 'extern'
+        if (this.check(TokenKind.Class)) {
+            this.advance();
+            return this.parseExternClassBody(start, isExported);
+        }
+        const type = this.parseType();
+        const name = this.consume(TokenKind.Identifier, "Expected name").lexeme;
+        if (this.check(TokenKind.LParen)) {
+            const params = this.parseParamList();
+            const { modulePath, jsName } = this.parseExternTail(name);
+            this.consume(TokenKind.Semicolon, "Expected ';' after extern function declaration");
+            return { kind: "ExternFunctionDecl", isExported, name, jsName, params, returnType: type, modulePath, line: start.line, col: start.col };
+        }
+        const { modulePath, jsName } = this.parseExternTail(name);
+        this.consume(TokenKind.Semicolon, "Expected ';' after extern declaration");
+        return { kind: "ExternValueDecl", isExported, name, jsName, type, modulePath, line: start.line, col: start.col };
+    }
+    // Optional `from "<path>"` (omit for an ambient global) and optional
+    // `as "<jsName>"` (omit when the JS-side name matches the KopScript-declared one).
+    parseExternTail(defaultJsName) {
+        let modulePath = null;
+        if (this.match(TokenKind.From)) {
+            modulePath = this.consume(TokenKind.String, "Expected a module path string after 'from'").lexeme;
+        }
+        let jsName = defaultJsName;
+        if (this.match(TokenKind.As)) {
+            jsName = this.consume(TokenKind.String, "Expected the external name string after 'as'").lexeme;
+        }
+        return { modulePath, jsName };
+    }
+    parseExternClassBody(start, isExported) {
+        const name = this.consume(TokenKind.Identifier, "Expected class name").lexeme;
+        this.consume(TokenKind.LBrace, "Expected '{' before extern class body");
+        let hasConstructor = false;
+        let ctorParams = [];
+        const properties = [];
+        const methods = [];
+        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            let isStatic = false;
+            if (this.check(TokenKind.Static)) {
+                isStatic = true;
+                this.advance();
+            }
+            let isVirtual = false;
+            let virtualTok = null;
+            if (this.check(TokenKind.Virtual)) {
+                virtualTok = this.advance();
+                isVirtual = true;
+            }
+            if (this.check(TokenKind.Constructor)) {
+                const ctorTok = this.advance();
+                if (virtualTok) {
+                    this.diagnostics.error(`'virtual' is not valid on an extern constructor`, virtualTok.line, virtualTok.col);
+                }
+                if (hasConstructor) {
+                    this.diagnostics.error(`Extern class '${name}' already has a constructor signature`, ctorTok.line, ctorTok.col);
+                }
+                ctorParams = this.parseParamList();
+                hasConstructor = true;
+                this.consume(TokenKind.Semicolon, "Expected ';' after extern constructor signature");
+                continue;
+            }
+            const type = this.parseType();
+            const memberName = this.consume(TokenKind.Identifier, "Expected member name").lexeme;
+            if (this.check(TokenKind.LParen)) {
+                const params = this.parseParamList();
+                this.consume(TokenKind.Semicolon, "Expected ';' after extern method signature");
+                methods.push({ isStatic, isVirtual, name: memberName, params, returnType: type });
+            }
+            else if (this.check(TokenKind.LBrace)) {
+                if (virtualTok) {
+                    this.diagnostics.error(`'virtual' is not valid on an extern property`, virtualTok.line, virtualTok.col);
+                }
+                this.advance();
+                this.consume(TokenKind.Get, "Expected 'get' in extern property accessor list");
+                this.consume(TokenKind.Semicolon, "Expected ';' after 'get'");
+                let hasSetter = false;
+                if (this.check(TokenKind.Set)) {
+                    hasSetter = true;
+                    this.advance();
+                    this.consume(TokenKind.Semicolon, "Expected ';' after 'set'");
+                }
+                this.consume(TokenKind.RBrace, "Expected '}' after extern property accessors");
+                properties.push({ isStatic, name: memberName, type, hasSetter });
+            }
+            else {
+                if (virtualTok) {
+                    this.diagnostics.error(`'virtual' is not valid on an extern property`, virtualTok.line, virtualTok.col);
+                }
+                this.consume(TokenKind.Semicolon, "Expected ';' after extern property declaration");
+                properties.push({ isStatic, name: memberName, type, hasSetter: true });
+            }
+        }
+        this.consume(TokenKind.RBrace, "Expected '}' after extern class body");
+        const { modulePath, jsName } = this.parseExternTail(name);
+        this.consume(TokenKind.Semicolon, "Expected ';' after extern class declaration");
+        return { kind: "ExternClassDecl", isExported, name, jsName, hasConstructor, ctorParams, properties, methods, modulePath, line: start.line, col: start.col };
+    }
+    parseBlock() {
+        const start = this.consume(TokenKind.LBrace, "Expected '{'");
+        const statements = [];
+        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            const stmt = this.parseStatement();
+            if (stmt)
+                statements.push(stmt);
+        }
+        this.consume(TokenKind.RBrace, "Expected '}'");
+        return { kind: "Block", statements, line: start.line, col: start.col };
+    }
+    parseIf() {
+        const start = this.advance(); // 'if'
+        this.consume(TokenKind.LParen, "Expected '(' after 'if'");
+        const condition = this.parseExpression();
+        this.consume(TokenKind.RParen, "Expected ')' after condition");
+        const thenBranch = this.parseBlock();
+        let elseBranch = null;
+        if (this.match(TokenKind.Else)) {
+            elseBranch = this.check(TokenKind.If) ? this.parseIf() : this.parseBlock();
+        }
+        return { kind: "IfStatement", condition, thenBranch, elseBranch, line: start.line, col: start.col };
+    }
+    parseWhile() {
+        const start = this.advance(); // 'while'
+        this.consume(TokenKind.LParen, "Expected '(' after 'while'");
+        const condition = this.parseExpression();
+        this.consume(TokenKind.RParen, "Expected ')' after condition");
+        const body = this.parseBlock();
+        return { kind: "WhileStatement", condition, body, line: start.line, col: start.col };
+    }
+    parseFor() {
+        const start = this.advance(); // 'for'
+        this.consume(TokenKind.LParen, "Expected '(' after 'for'");
+        let init = null;
+        if (this.check(TokenKind.Const)) {
+            init = this.parseConstDecl();
+        }
+        else if (this.isDeclStart()) {
+            init = this.parseVarDeclHeader();
+        }
+        else if (!this.check(TokenKind.Semicolon)) {
+            const expr = this.parseExpression();
+            init = { kind: "ExpressionStatement", expression: expr, line: expr.line, col: expr.col };
+        }
+        this.consume(TokenKind.Semicolon, "Expected ';' after for-loop initializer");
+        let condition = null;
+        if (!this.check(TokenKind.Semicolon))
+            condition = this.parseExpression();
+        this.consume(TokenKind.Semicolon, "Expected ';' after for-loop condition");
+        let update = null;
+        if (!this.check(TokenKind.RParen))
+            update = this.parseExpression();
+        this.consume(TokenKind.RParen, "Expected ')' after for clauses");
+        const body = this.parseBlock();
+        return { kind: "ForStatement", init, condition, update, body, line: start.line, col: start.col };
+    }
+    parseForeach() {
+        const start = this.advance(); // 'foreach'
+        this.consume(TokenKind.LParen, "Expected '(' after 'foreach'");
+        const varType = this.parseType();
+        const varName = this.consume(TokenKind.Identifier, "Expected loop variable name").lexeme;
+        this.consume(TokenKind.In, "Expected 'in' in foreach loop");
+        const iterable = this.parseExpression();
+        this.consume(TokenKind.RParen, "Expected ')' after foreach clause");
+        const body = this.parseBlock();
+        return { kind: "ForInStatement", varType, varName, iterable, body, line: start.line, col: start.col };
+    }
+    parseReturn() {
+        const start = this.advance(); // 'return'
+        let value = null;
+        if (!this.check(TokenKind.Semicolon))
+            value = this.parseExpression();
+        this.consume(TokenKind.Semicolon, "Expected ';' after return statement");
+        return { kind: "ReturnStatement", value, line: start.line, col: start.col };
+    }
+    parseTry() {
+        const start = this.advance(); // 'try'
+        const tryBlock = this.parseBlock();
+        let catchParam = null;
+        let catchBlock = null;
+        if (this.match(TokenKind.Catch)) {
+            this.consume(TokenKind.LParen, "Expected '(' after 'catch'");
+            const type = this.parseType();
+            const name = this.consume(TokenKind.Identifier, "Expected catch parameter name").lexeme;
+            this.consume(TokenKind.RParen, "Expected ')' after catch parameter");
+            catchParam = { type, name };
+            catchBlock = this.parseBlock();
+        }
+        let finallyBlock = null;
+        if (this.match(TokenKind.Finally)) {
+            finallyBlock = this.parseBlock();
+        }
+        if (!catchBlock && !finallyBlock) {
+            this.diagnostics.error("'try' must be followed by 'catch' and/or 'finally'", start.line, start.col);
+        }
+        return { kind: "TryStatement", tryBlock, catchParam, catchBlock, finallyBlock, line: start.line, col: start.col };
+    }
+    parseThrow() {
+        const start = this.advance(); // 'throw'
+        const expression = this.parseExpression();
+        this.consume(TokenKind.Semicolon, "Expected ';' after 'throw'");
+        return { kind: "ThrowStatement", expression, line: start.line, col: start.col };
+    }
+    // ---------- types ----------
+    parseType() {
+        let type;
+        if (this.check(TokenKind.LParen)) {
+            type = this.parseFunctionType();
+        }
+        else if (this.check(TokenKind.Task)) {
+            this.advance();
+            let resultType = { kind: "NamedType", name: "void" };
+            if (this.match(TokenKind.Lt)) {
+                resultType = this.parseType();
+                this.consume(TokenKind.Gt, "Expected '>' after task result type");
+            }
+            type = { kind: "TaskType", resultType };
+        }
+        else if (this.check(TokenKind.State)) {
+            this.advance();
+            this.consume(TokenKind.Lt, "Expected '<' after 'state'");
+            const valueType = this.parseType();
+            this.consume(TokenKind.Gt, "Expected '>' after state value type");
+            type = { kind: "StateType", valueType };
+        }
+        else {
+            const nameToken = this.check(TokenKind.Void) ? this.advance() : this.consume(TokenKind.Identifier, "Expected type name");
+            type = { kind: "NamedType", name: nameToken.lexeme };
+        }
+        while (this.check(TokenKind.LBracket)) {
+            this.advance();
+            this.consume(TokenKind.RBracket, "Expected ']' after '[' in array type");
+            type = { kind: "ArrayType", element: type };
+        }
+        return type;
+    }
+    // `(number, string) => bool` — unnamed parameter types, unlike a lambda's
+    // parameter list.
+    parseFunctionType() {
+        this.consume(TokenKind.LParen, "Expected '('");
+        const params = [];
+        if (!this.check(TokenKind.RParen)) {
+            do {
+                params.push(this.parseType());
+            } while (this.match(TokenKind.Comma));
+        }
+        this.consume(TokenKind.RParen, "Expected ')' after function type parameters");
+        this.consume(TokenKind.Arrow, "Expected '=>' after function type parameters");
+        const returnType = this.parseType();
+        return { kind: "FunctionType", params, returnType };
+    }
+    // ---------- expressions ----------
+    parseExpression() {
+        return this.parseAssignment();
+    }
+    parseAssignment() {
+        const left = this.parseLogicalOr();
+        if (this.check(TokenKind.Assign)) {
+            const opTok = this.advance();
+            const value = this.parseAssignment();
+            return { kind: "AssignExpr", target: left, value, line: opTok.line, col: opTok.col };
+        }
+        return left;
+    }
+    parseLogicalOr() {
+        let left = this.parseLogicalAnd();
+        while (this.check(TokenKind.OrOr)) {
+            const op = this.advance();
+            const right = this.parseLogicalAnd();
+            left = { kind: "LogicalExpr", op: "||", left, right, line: op.line, col: op.col };
+        }
+        return left;
+    }
+    parseLogicalAnd() {
+        let left = this.parseEquality();
+        while (this.check(TokenKind.AndAnd)) {
+            const op = this.advance();
+            const right = this.parseEquality();
+            left = { kind: "LogicalExpr", op: "&&", left, right, line: op.line, col: op.col };
+        }
+        return left;
+    }
+    parseEquality() {
+        let left = this.parseComparison();
+        while (this.check(TokenKind.Eq) || this.check(TokenKind.NotEq)) {
+            const op = this.advance();
+            const right = this.parseComparison();
+            left = { kind: "BinaryExpr", op: op.kind === TokenKind.Eq ? "==" : "!=", left, right, line: op.line, col: op.col };
+        }
+        return left;
+    }
+    parseComparison() {
+        let left = this.parseAdditive();
+        while (this.check(TokenKind.Lt) ||
+            this.check(TokenKind.Gt) ||
+            this.check(TokenKind.LtEq) ||
+            this.check(TokenKind.GtEq)) {
+            const op = this.advance();
+            const right = this.parseAdditive();
+            const map = { [TokenKind.Lt]: "<", [TokenKind.Gt]: ">", [TokenKind.LtEq]: "<=", [TokenKind.GtEq]: ">=" };
+            left = { kind: "BinaryExpr", op: map[op.kind], left, right, line: op.line, col: op.col };
+        }
+        return left;
+    }
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.check(TokenKind.Plus) || this.check(TokenKind.Minus)) {
+            const op = this.advance();
+            const right = this.parseMultiplicative();
+            left = { kind: "BinaryExpr", op: op.kind === TokenKind.Plus ? "+" : "-", left, right, line: op.line, col: op.col };
+        }
+        return left;
+    }
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.check(TokenKind.Star) || this.check(TokenKind.Slash) || this.check(TokenKind.Percent)) {
+            const op = this.advance();
+            const right = this.parseUnary();
+            const map = { [TokenKind.Star]: "*", [TokenKind.Slash]: "/", [TokenKind.Percent]: "%" };
+            left = { kind: "BinaryExpr", op: map[op.kind], left, right, line: op.line, col: op.col };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.check(TokenKind.Minus) || this.check(TokenKind.Not)) {
+            const op = this.advance();
+            const operand = this.parseUnary();
+            return { kind: "UnaryExpr", op: op.kind === TokenKind.Minus ? "-" : "!", operand, line: op.line, col: op.col };
+        }
+        if (this.check(TokenKind.Await)) {
+            const op = this.advance();
+            const operand = this.parseUnary();
+            return { kind: "AwaitExpr", operand, line: op.line, col: op.col };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        for (;;) {
+            if (this.check(TokenKind.Dot)) {
+                const dot = this.advance();
+                const name = this.consume(TokenKind.Identifier, "Expected property name after '.'").lexeme;
+                expr = { kind: "MemberExpr", object: expr, property: name, line: dot.line, col: dot.col };
+            }
+            else if (this.check(TokenKind.LParen)) {
+                const paren = this.advance();
+                const args = [];
+                if (!this.check(TokenKind.RParen)) {
+                    do {
+                        args.push(this.parseExpression());
+                    } while (this.match(TokenKind.Comma));
+                }
+                this.consume(TokenKind.RParen, "Expected ')' after arguments");
+                expr = { kind: "CallExpr", callee: expr, args, line: paren.line, col: paren.col };
+            }
+            else if (this.check(TokenKind.LBracket)) {
+                const bracket = this.advance();
+                const index = this.parseExpression();
+                this.consume(TokenKind.RBracket, "Expected ']' after index");
+                expr = { kind: "IndexExpr", object: expr, index, line: bracket.line, col: bracket.col };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    parsePrimary() {
+        const t = this.peek();
+        if (this.check(TokenKind.Number)) {
+            this.advance();
+            return { kind: "NumberLiteral", value: parseFloat(t.lexeme), line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.String)) {
+            this.advance();
+            return { kind: "StringLiteral", value: t.lexeme, line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.InterpolatedString)) {
+            this.advance();
+            return this.parseInterpolatedString(t);
+        }
+        if (this.check(TokenKind.True) || this.check(TokenKind.False)) {
+            this.advance();
+            return { kind: "BoolLiteral", value: t.kind === TokenKind.True, line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.This)) {
+            this.advance();
+            return { kind: "ThisExpr", line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.New)) {
+            this.advance();
+            const className = this.consume(TokenKind.Identifier, "Expected class name after 'new'").lexeme;
+            this.consume(TokenKind.LParen, "Expected '(' after class name");
+            const args = [];
+            if (!this.check(TokenKind.RParen)) {
+                do {
+                    args.push(this.parseExpression());
+                } while (this.match(TokenKind.Comma));
+            }
+            this.consume(TokenKind.RParen, "Expected ')' after constructor arguments");
+            return { kind: "NewExpr", className, args, line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.LBracket)) {
+            this.advance();
+            const elements = [];
+            if (!this.check(TokenKind.RBracket)) {
+                do {
+                    elements.push(this.parseExpression());
+                } while (this.match(TokenKind.Comma));
+            }
+            this.consume(TokenKind.RBracket, "Expected ']' after array literal");
+            return { kind: "ArrayLiteral", elements, line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.Match)) {
+            return this.parseMatchExpr();
+        }
+        if (this.check(TokenKind.State)) {
+            this.advance();
+            this.consume(TokenKind.LParen, "Expected '(' after 'state'");
+            const initializer = this.parseExpression();
+            this.consume(TokenKind.RParen, "Expected ')' after state initializer");
+            return { kind: "StateExpr", initializer, line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.Identifier)) {
+            this.advance();
+            return { kind: "Identifier", name: t.lexeme, line: t.line, col: t.col };
+        }
+        if (this.check(TokenKind.LParen)) {
+            if (this.looksLikeLambda())
+                return this.parseLambda();
+            this.advance();
+            const expr = this.parseExpression();
+            this.consume(TokenKind.RParen, "Expected ')' after expression");
+            return expr;
+        }
+        this.diagnostics.error(`Unexpected token '${t.lexeme || t.kind}'`, t.line, t.col);
+        throw new ParseError();
+    }
+    // Lightweight lookahead (not a trial parse) distinguishing a lambda's
+    // parameter list from a parenthesized expression. A lambda parameter is
+    // always `Type name` (types are required, no inference in v1), so seeing
+    // two consecutive identifiers — or an empty `()` followed by `=>` — is
+    // unambiguous. This doesn't handle a lambda whose own first parameter is
+    // itself a function type (e.g. a higher-order lambda); that's a known v1
+    // gap in favor of keeping this check cheap.
+    looksLikeLambda() {
+        let i = this.pos + 1; // just past '('
+        if (this.tokens[i]?.kind === TokenKind.RParen) {
+            return this.tokens[i + 1]?.kind === TokenKind.Arrow;
+        }
+        const startKind = this.tokens[i]?.kind;
+        if (startKind !== TokenKind.Identifier && startKind !== TokenKind.Void)
+            return false;
+        i++;
+        while (this.tokens[i]?.kind === TokenKind.LBracket && this.tokens[i + 1]?.kind === TokenKind.RBracket) {
+            i += 2;
+        }
+        return this.tokens[i]?.kind === TokenKind.Identifier;
+    }
+    parseLambda() {
+        const start = this.peek(); // '('
+        this.advance();
+        const params = [];
+        if (!this.check(TokenKind.RParen)) {
+            do {
+                const type = this.parseType();
+                const name = this.consume(TokenKind.Identifier, "Expected lambda parameter name").lexeme;
+                params.push({ name, type });
+            } while (this.match(TokenKind.Comma));
+        }
+        this.consume(TokenKind.RParen, "Expected ')' after lambda parameters");
+        this.consume(TokenKind.Arrow, "Expected '=>' after lambda parameters");
+        const body = this.check(TokenKind.LBrace) ? this.parseBlock() : this.parseExpression();
+        return { kind: "LambdaExpr", params, body, line: start.line, col: start.col };
+    }
+    parseInterpolatedString(token) {
+        const parts = [];
+        const raw = token.lexeme;
+        let text = "";
+        let i = 0;
+        const flushText = () => {
+            if (text.length > 0) {
+                parts.push({ kind: "Text", text });
+                text = "";
+            }
+        };
+        while (i < raw.length) {
+            const c = raw[i];
+            if (c === "\\" && i + 1 < raw.length) {
+                const esc = raw[i + 1];
+                const map = { n: "\n", t: "\t", r: "\r", "\\": "\\", '"': '"', "{": "{", "}": "}" };
+                text += map[esc] ?? esc;
+                i += 2;
+                continue;
+            }
+            if (c === "{") {
+                flushText();
+                let depth = 1;
+                let j = i + 1;
+                while (j < raw.length && depth > 0) {
+                    if (raw[j] === "{")
+                        depth++;
+                    else if (raw[j] === "}")
+                        depth--;
+                    if (depth > 0)
+                        j++;
+                }
+                const exprSource = raw.slice(i + 1, j);
+                parts.push({ kind: "Expr", expression: this.parseSubExpression(exprSource, token) });
+                i = j + 1;
+                continue;
+            }
+            text += c;
+            i++;
+        }
+        flushText();
+        if (parts.length === 0)
+            parts.push({ kind: "Text", text: "" });
+        return { kind: "InterpolatedStringLiteral", parts, line: token.line, col: token.col };
+    }
+    parseSubExpression(source, token) {
+        const subDiagnostics = new DiagnosticBag();
+        const subTokens = new Lexer(source, subDiagnostics).tokenize();
+        const subParser = new Parser(subTokens, subDiagnostics);
+        const expr = subParser.parseExpression();
+        for (const d of subDiagnostics.diagnostics) {
+            this.diagnostics.error(d.message, token.line, token.col);
+        }
+        return expr;
+    }
+    parseMatchExpr() {
+        const start = this.advance(); // 'match'
+        const subject = this.parseExpression();
+        this.consume(TokenKind.LBrace, "Expected '{' after match subject");
+        const arms = [];
+        while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
+            const armStart = this.peek();
+            const pattern = this.parsePattern();
+            this.consume(TokenKind.Arrow, "Expected '=>' after match pattern");
+            const result = this.parseExpression();
+            arms.push({ pattern, result, line: armStart.line, col: armStart.col });
+            if (!this.match(TokenKind.Comma))
+                break;
+        }
+        this.consume(TokenKind.RBrace, "Expected '}' after match arms");
+        return { kind: "MatchExpr", subject, arms, line: start.line, col: start.col };
+    }
+    parsePattern() {
+        if (this.check(TokenKind.Underscore)) {
+            this.advance();
+            return { kind: "WildcardPattern" };
+        }
+        if (this.check(TokenKind.RegexLiteral)) {
+            const t = this.advance();
+            return { kind: "RegexPattern", source: t.lexeme };
+        }
+        const values = [this.parseLogicalOr()];
+        while (this.match(TokenKind.Comma)) {
+            values.push(this.parseLogicalOr());
+        }
+        return { kind: "LiteralPattern", values };
+    }
+    // ---------- token helpers ----------
+    check(kind) {
+        return this.peek().kind === kind;
+    }
+    peek() {
+        return this.tokens[this.pos];
+    }
+    advance() {
+        const t = this.tokens[this.pos];
+        if (this.pos < this.tokens.length - 1)
+            this.pos++;
+        return t;
+    }
+    match(kind) {
+        if (this.check(kind)) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    consume(kind, message) {
+        if (this.check(kind))
+            return this.advance();
+        const t = this.peek();
+        this.diagnostics.error(message, t.line, t.col);
+        throw new ParseError();
+    }
+    synchronize() {
+        // Guarantee forward progress: always consume the offending token first,
+        // so a parse failure immediately after a semicolon can't leave `pos`
+        // unmoved and re-throw on the same token forever.
+        if (!this.check(TokenKind.EOF))
+            this.advance();
+        while (!this.check(TokenKind.EOF)) {
+            if (this.tokens[this.pos - 1]?.kind === TokenKind.Semicolon)
+                return;
+            if (this.check(TokenKind.Class) ||
+                this.check(TokenKind.Interface) ||
+                this.check(TokenKind.Enum) ||
+                this.check(TokenKind.Extern) ||
+                this.check(TokenKind.Const) ||
+                this.check(TokenKind.If) ||
+                this.check(TokenKind.While) ||
+                this.check(TokenKind.For) ||
+                this.check(TokenKind.Foreach) ||
+                this.check(TokenKind.Return) ||
+                this.check(TokenKind.Try) ||
+                this.check(TokenKind.Throw) ||
+                this.isDeclStart()) {
+                return;
+            }
+            this.advance();
+        }
+    }
+}
+class ParseError extends Error {
+}