@starpak/lang 0.0.0-stage → 0.1.2

package/lib/parser.js

@@ -0,0 +1,1133 @@
+"use strict";
+/**
+ * Spak Lang - Recursive descent parser
+ *
+ * Produces an AST (`Program`) from Spak source. The grammar follows
+ * docs/syntax/spak-lang.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+exports.parseExpression = parseExpression;
+const lexer_1 = require("./lexer");
+const token_1 = require("./token");
+/**
+ * Binary operator precedence, low to high. `^` is right-associative.
+ */
+const BINARY_PRECEDENCE = {
+    'or': 1,
+    'and': 2,
+    '==': 3,
+    '~=': 3,
+    '<': 3,
+    '<=': 3,
+    '>': 3,
+    '>=': 3,
+    '|>': 4,
+    '??': 5,
+    '..': 6,
+    '+': 7,
+    '-': 7,
+    '*': 8,
+    '/': 8,
+    '//': 8,
+    '%': 8,
+    '^': 10,
+};
+const UNARY_PRECEDENCE = 9;
+const BLOCK_END_KEYWORDS = [
+    'end', 'else', 'elseif', 'when', 'until', 'catch', 'finally',
+];
+const PRIMITIVE_TYPE_NAMES = new Set([
+    'any', 'nil', 'number', 'string', 'boolean', 'table', 'function',
+]);
+/** Statement kinds that may carry a `---` doc comment. */
+const DOC_STATEMENTS = new Set([
+    'FnDecl', 'ClassDecl', 'VarDecl', 'TypeAliasDecl', 'ExportDecl', 'ImportDecl',
+]);
+function isNameToken(token) {
+    return token.type === token_1.TokenType.Identifier || token.type === token_1.TokenType.Keyword;
+}
+class Parser {
+    tokens;
+    pos = 0;
+    constructor(source) {
+        this.tokens = (0, lexer_1.tokenize)(source);
+    }
+    /* ---------------------------------------------------------------- */
+    /* Token helpers                                                     */
+    /* ---------------------------------------------------------------- */
+    peek(offset = 0) {
+        const index = this.pos + offset;
+        return this.tokens[index < this.tokens.length ? index : this.tokens.length - 1];
+    }
+    next() {
+        const token = this.peek();
+        if (this.pos < this.tokens.length - 1)
+            this.pos++;
+        return token;
+    }
+    at(type, value) {
+        const token = this.peek();
+        return token.type === type && (value === undefined || token.value === value);
+    }
+    atKeyword(value) {
+        return this.at(token_1.TokenType.Keyword, value);
+    }
+    atOperator(value) {
+        return this.at(token_1.TokenType.Operator, value);
+    }
+    match(type, value) {
+        if (!this.at(type, value))
+            return false;
+        this.next();
+        return true;
+    }
+    matchKeyword(value) {
+        return this.match(token_1.TokenType.Keyword, value);
+    }
+    matchOperator(value) {
+        return this.match(token_1.TokenType.Operator, value);
+    }
+    expect(type, value, message) {
+        if (this.at(type, value))
+            return this.next();
+        const token = this.peek();
+        throw this.error(message ?? `Expected ${value ?? type} but got "${token.value}"`, token);
+    }
+    expectKeyword(value) {
+        return this.expect(token_1.TokenType.Keyword, value, `Expected "${value}"`);
+    }
+    expectName(message) {
+        if (isNameToken(this.peek()))
+            return this.next();
+        throw this.error(message);
+    }
+    error(message, token = this.peek()) {
+        return new SyntaxError(`${message} at ${token.line}:${token.column}`);
+    }
+    loc(token) {
+        return { line: token.line, column: token.column };
+    }
+    skipNewlines() {
+        while (this.at(token_1.TokenType.Newline))
+            this.next();
+    }
+    skipSeparators() {
+        while (this.at(token_1.TokenType.Newline) || this.at(token_1.TokenType.Semicolon))
+            this.next();
+    }
+    isBlockEnd() {
+        const token = this.peek();
+        return token.type === token_1.TokenType.Keyword && BLOCK_END_KEYWORDS.includes(token.value);
+    }
+    isStatementEnd() {
+        const token = this.peek();
+        return token.type === token_1.TokenType.EOF
+            || token.type === token_1.TokenType.Newline
+            || token.type === token_1.TokenType.Semicolon
+            || this.isBlockEnd();
+    }
+    /* ---------------------------------------------------------------- */
+    /* Program & statements                                              */
+    /* ---------------------------------------------------------------- */
+    parseProgram() {
+        const start = this.peek();
+        const body = [];
+        this.skipSeparators();
+        while (!this.at(token_1.TokenType.EOF)) {
+            const before = this.pos;
+            body.push(this.parseStatement());
+            if (this.pos === before)
+                throw this.error('Unexpected token');
+            this.skipSeparators();
+        }
+        return { kind: 'Program', body, loc: this.loc(start) };
+    }
+    parseStatement() {
+        const doc = this.peek().doc;
+        const statement = this.parseStatementCore();
+        if (doc && DOC_STATEMENTS.has(statement.kind)) {
+            ;
+            statement.doc = doc;
+        }
+        return statement;
+    }
+    parseStatementCore() {
+        const token = this.peek();
+        if (token.type === token_1.TokenType.Operator && token.value === '@') {
+            return this.parseDecoratedDeclaration();
+        }
+        if (token.type === token_1.TokenType.Keyword) {
+            switch (token.value) {
+                case 'global':
+                    return this.parseVarDeclaration('global');
+                case 'const':
+                    return this.parseVarDeclaration('const');
+                case 'import':
+                    return this.parseImport();
+                case 'export':
+                    return this.parseExport();
+                case 'type':
+                    return this.parseTypeAlias();
+                case 'fn':
+                    return this.parseFnDecl([], false, false);
+                case 'class':
+                    return this.parseClassDecl([]);
+                case 'async':
+                    if (this.peek(1).type === token_1.TokenType.Keyword && this.peek(1).value === 'fn') {
+                        this.next();
+                        return this.parseFnDecl([], true, false);
+                    }
+                    break;
+                case 'throw':
+                    return this.parseThrow();
+                case 'spawn':
+                    return this.parseSpawn();
+                case 'if':
+                    return this.parseIf();
+                case 'unless':
+                    return this.parseUnless();
+                case 'while':
+                    return this.parseWhile();
+                case 'repeat':
+                    return this.parseRepeat();
+                case 'for':
+                    return this.parseFor();
+                case 'return':
+                    return this.parseReturn();
+                case 'break': {
+                    const keyword = this.next();
+                    return { kind: 'BreakStmt', loc: this.loc(keyword) };
+                }
+                case 'continue': {
+                    const keyword = this.next();
+                    return { kind: 'ContinueStmt', loc: this.loc(keyword) };
+                }
+                case 'match':
+                    return this.parseMatch();
+                case 'try':
+                    return this.parseTry();
+            }
+        }
+        return this.parseSimpleStatement();
+    }
+    parseBlock(terminators) {
+        const start = this.peek();
+        const body = [];
+        this.skipSeparators();
+        while (!this.at(token_1.TokenType.EOF)) {
+            const token = this.peek();
+            if (token.type === token_1.TokenType.Keyword && terminators.includes(token.value))
+                break;
+            const before = this.pos;
+            body.push(this.parseStatement());
+            if (this.pos === before)
+                throw this.error('Unexpected token');
+            this.skipSeparators();
+        }
+        return { kind: 'Block', body, loc: this.loc(start) };
+    }
+    parseVarDeclaration(scope) {
+        const keyword = this.next();
+        const names = [];
+        do {
+            const name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected variable name');
+            const entry = { name: name.value };
+            if (this.matchOperator(':'))
+                entry.type = this.parseType();
+            names.push(entry);
+        } while (this.matchOperator(','));
+        const values = this.matchOperator('=') ? this.parseExprList() : [];
+        return { kind: 'VarDecl', names, values, scope, loc: this.loc(keyword) };
+    }
+    parseSimpleStatement() {
+        const start = this.peek();
+        // Destructuring assignment: `{ x, y } = p` / `[a, b] = list`.
+        if (this.atOperator('{') || this.atOperator('[')) {
+            const saved = this.pos;
+            try {
+                const target = this.parsePattern();
+                if (this.matchOperator('=')) {
+                    const values = this.parseExprList();
+                    const node = { kind: 'Assign', targets: [target], values, loc: this.loc(start) };
+                    return node;
+                }
+            }
+            catch {
+                // Not a pattern; rewind and parse it as an expression instead.
+            }
+            this.pos = saved;
+        }
+        const first = this.parseExpression();
+        // Typed declaration without a keyword: x: number = 1
+        if (first.kind === 'Ident' && this.atOperator(':')) {
+            this.next();
+            const type = this.parseType();
+            const name = { name: first.name, type };
+            const values = this.matchOperator('=') ? this.parseExprList() : [];
+            return { kind: 'VarDecl', names: [name], values, scope: 'local', loc: first.loc };
+        }
+        const targets = [first];
+        while (this.matchOperator(','))
+            targets.push(this.parseExpression());
+        if (this.matchOperator('=')) {
+            const values = this.parseExprList();
+            // Assignment is declaration: plain identifiers create local bindings.
+            if (targets.every((target) => target.kind === 'Ident')) {
+                const names = targets.map((target) => ({ name: target.name }));
+                return { kind: 'VarDecl', names, values, scope: 'local', loc: this.loc(start) };
+            }
+            return { kind: 'Assign', targets, values, loc: this.loc(start) };
+        }
+        if (targets.length > 1)
+            throw this.error('Expected "=" in assignment');
+        return { kind: 'ExprStmt', expr: first, loc: this.loc(start) };
+    }
+    parsePattern() {
+        if (this.atOperator('{'))
+            return this.parseTablePattern();
+        if (this.atOperator('['))
+            return this.parseArrayPattern();
+        throw this.error('Expected destructuring pattern');
+    }
+    parseTablePattern() {
+        const start = this.expect(token_1.TokenType.Operator, '{');
+        const entries = [];
+        this.skipNewlines();
+        while (!this.atOperator('}')) {
+            const key = this.expectName('Expected field name in table pattern');
+            const entry = { key: key.value };
+            if (this.matchOperator('=')) {
+                const value = this.parseExpression();
+                // `{ a = first }` renames, any other value is a default.
+                if (value.kind === 'Ident')
+                    entry.target = value.name;
+                else
+                    entry.default = value;
+            }
+            entries.push(entry);
+            this.skipNewlines();
+            if (!this.matchOperator(','))
+                break;
+            this.skipNewlines();
+        }
+        this.expect(token_1.TokenType.Operator, '}', 'Expected "}"');
+        return { kind: 'TablePattern', entries, loc: this.loc(start) };
+    }
+    parseArrayPattern() {
+        const start = this.expect(token_1.TokenType.Operator, '[');
+        const elements = [];
+        this.skipNewlines();
+        while (!this.atOperator(']')) {
+            const name = this.expectName('Expected name in array pattern');
+            elements.push(name.value);
+            this.skipNewlines();
+            if (!this.matchOperator(','))
+                break;
+            this.skipNewlines();
+        }
+        this.expect(token_1.TokenType.Operator, ']', 'Expected "]"');
+        return { kind: 'ArrayPattern', elements, loc: this.loc(start) };
+    }
+    parseFnDecl(decorators, isAsync, isMethod) {
+        const start = this.expectKeyword('fn');
+        let name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected function name').value;
+        let receiver;
+        if (this.matchOperator(':')) {
+            receiver = name;
+            name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected method name').value;
+        }
+        const params = this.parseParams();
+        const returnType = this.matchOperator(':') ? this.parseType() : undefined;
+        let body;
+        let exprBody;
+        if (this.matchOperator('=')) {
+            exprBody = this.parseExpression();
+        }
+        else {
+            body = this.parseBlock(['end']);
+            this.expectKeyword('end');
+        }
+        const decl = {
+            kind: 'FnDecl',
+            name,
+            params,
+            returnType,
+            body,
+            exprBody,
+            isMethod: isMethod || !!receiver,
+            decorators,
+            loc: this.loc(start),
+        };
+        if (receiver)
+            decl.receiver = receiver;
+        if (isAsync)
+            decl.async = true;
+        return decl;
+    }
+    parseParams() {
+        this.expect(token_1.TokenType.Operator, '(', 'Expected "("');
+        const params = [];
+        this.skipNewlines();
+        while (!this.atOperator(')')) {
+            if (this.matchOperator('...')) {
+                params.push({ name: '...', rest: true });
+                this.skipNewlines();
+                break;
+            }
+            const name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected parameter name');
+            const param = { name: name.value };
+            if (this.matchOperator(':'))
+                param.type = this.parseType();
+            if (this.matchOperator('='))
+                param.default = this.parseExpression();
+            params.push(param);
+            this.skipNewlines();
+            if (!this.matchOperator(','))
+                break;
+            this.skipNewlines();
+        }
+        this.expect(token_1.TokenType.Operator, ')', 'Expected ")"');
+        return params;
+    }
+    parseDecorators() {
+        const decorators = [];
+        while (this.atOperator('@')) {
+            const at = this.next();
+            const name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected decorator name').value;
+            const args = this.atOperator('(') ? this.parseArguments() : [];
+            decorators.push({ kind: 'Decorator', name, args, loc: this.loc(at) });
+            this.skipNewlines();
+        }
+        return decorators;
+    }
+    parseDecoratedDeclaration() {
+        const decorators = this.parseDecorators();
+        if (this.atKeyword('class'))
+            return this.parseClassDecl(decorators);
+        if (this.atKeyword('async') && this.peek(1).value === 'fn') {
+            this.next();
+            return this.parseFnDecl(decorators, true, false);
+        }
+        if (this.atKeyword('fn'))
+            return this.parseFnDecl(decorators, false, false);
+        throw this.error('Expected "fn" or "class" after decorator');
+    }
+    parseClassDecl(decorators) {
+        const start = this.expectKeyword('class');
+        const name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected class name').value;
+        const superClass = this.matchKeyword('extends')
+            ? this.expect(token_1.TokenType.Identifier, undefined, 'Expected super class name').value
+            : undefined;
+        const members = [];
+        this.skipSeparators();
+        while (!this.atKeyword('end') && !this.at(token_1.TokenType.EOF)) {
+            const doc = this.peek().doc;
+            let member;
+            if (this.atOperator('@')) {
+                member = this.parseClassMember(this.parseDecorators());
+            }
+            else {
+                member = this.parseClassMember([]);
+            }
+            if (doc)
+                member.doc = doc;
+            members.push(member);
+            this.skipSeparators();
+        }
+        this.expectKeyword('end');
+        return { kind: 'ClassDecl', name, superClass, members, decorators, loc: this.loc(start) };
+    }
+    /** Parses one class body member, with decorators already consumed. */
+    parseClassMember(decorators) {
+        if (this.atKeyword('async') && this.peek(1).value === 'fn') {
+            this.next();
+            return this.parseFnDecl(decorators, true, true);
+        }
+        if (this.atKeyword('fn'))
+            return this.parseFnDecl(decorators, false, true);
+        return this.parseField(decorators);
+    }
+    parseField(decorators = []) {
+        const name = this.expectName('Expected field name');
+        const entry = { name: name.value };
+        if (this.matchOperator(':'))
+            entry.type = this.parseType();
+        const values = this.matchOperator('=') ? [this.parseExpression()] : [];
+        const decl = { kind: 'VarDecl', names: [entry], values, scope: 'local', loc: this.loc(name) };
+        if (decorators.length)
+            decl.decorators = decorators;
+        return decl;
+    }
+    parseIf() {
+        const start = this.expectKeyword('if');
+        const cond = this.parseExpression();
+        this.expectKeyword('then');
+        const then = this.parseBlock(['elseif', 'else', 'end']);
+        const elifs = [];
+        while (this.matchKeyword('elseif')) {
+            const elifCond = this.parseExpression();
+            this.expectKeyword('then');
+            const body = this.parseBlock(['elseif', 'else', 'end']);
+            elifs.push({ cond: elifCond, body });
+        }
+        const elseBody = this.matchKeyword('else') ? this.parseBlock(['end']) : undefined;
+        this.expectKeyword('end');
+        return { kind: 'IfStmt', cond, then, elifs, else: elseBody, loc: this.loc(start) };
+    }
+    parseUnless() {
+        const start = this.expectKeyword('unless');
+        const cond = this.parseExpression();
+        this.expectKeyword('do');
+        const body = this.parseBlock(['end']);
+        this.expectKeyword('end');
+        return { kind: 'UnlessStmt', cond, body, loc: this.loc(start) };
+    }
+    parseWhile() {
+        const start = this.expectKeyword('while');
+        const cond = this.parseExpression();
+        this.expectKeyword('do');
+        const body = this.parseBlock(['end']);
+        this.expectKeyword('end');
+        return { kind: 'WhileStmt', cond, body, loc: this.loc(start) };
+    }
+    parseRepeat() {
+        const start = this.expectKeyword('repeat');
+        const body = this.parseBlock(['until']);
+        this.expectKeyword('until');
+        const cond = this.parseExpression();
+        return { kind: 'RepeatStmt', body, cond, loc: this.loc(start) };
+    }
+    parseFor() {
+        const start = this.expectKeyword('for');
+        const first = this.expect(token_1.TokenType.Identifier, undefined, 'Expected loop variable');
+        const vars = [first.value];
+        while (this.atOperator(',')) {
+            this.next();
+            vars.push(this.expect(token_1.TokenType.Identifier, undefined, 'Expected loop variable').value);
+        }
+        if (this.matchOperator('=')) {
+            if (vars.length > 1)
+                throw this.error('Numeric for accepts a single variable');
+            const from = this.parseExpression();
+            this.expect(token_1.TokenType.Operator, ',', 'Expected "," in numeric for');
+            const to = this.parseExpression();
+            const step = this.matchOperator(',') ? this.parseExpression() : undefined;
+            this.expectKeyword('do');
+            const body = this.parseBlock(['end']);
+            this.expectKeyword('end');
+            const node = {
+                kind: 'ForNumeric',
+                varName: first.value,
+                from,
+                to,
+                step,
+                inclusive: true,
+                body,
+                loc: this.loc(start),
+            };
+            return node;
+        }
+        this.expectKeyword('in');
+        const iter = this.parseRangeExpr();
+        this.expectKeyword('do');
+        const body = this.parseBlock(['end']);
+        this.expectKeyword('end');
+        const node = { kind: 'ForIn', vars, iter, body, loc: this.loc(start) };
+        return node;
+    }
+    parseReturn() {
+        const start = this.expectKeyword('return');
+        const values = this.isStatementEnd() ? [] : this.parseExprList();
+        return { kind: 'ReturnStmt', values, loc: this.loc(start) };
+    }
+    parseThrow() {
+        const start = this.expectKeyword('throw');
+        if (this.isStatementEnd())
+            throw this.error('Expected expression after "throw"');
+        return { kind: 'ThrowStmt', value: this.parseExpression(), loc: this.loc(start) };
+    }
+    parseSpawn() {
+        const start = this.expectKeyword('spawn');
+        if (this.isStatementEnd())
+            throw this.error('Expected expression after "spawn"');
+        return { kind: 'SpawnStmt', value: this.parseExpression(), loc: this.loc(start) };
+    }
+    parseMatch() {
+        const start = this.expectKeyword('match');
+        const subject = this.parseExpression();
+        this.skipSeparators();
+        const arms = [];
+        while (this.atKeyword('when')) {
+            const when = this.next();
+            const patterns = this.parseExprList();
+            const guard = this.matchKeyword('if') ? this.parseExpression() : undefined;
+            this.expectKeyword('then');
+            const body = this.parseBlock(['when', 'else', 'end']);
+            arms.push({ patterns, guard, body, loc: this.loc(when) });
+            this.skipSeparators();
+        }
+        const elseBody = this.matchKeyword('else') ? this.parseBlock(['end']) : undefined;
+        this.expectKeyword('end');
+        return { kind: 'MatchStmt', subject, arms, elseBody, loc: this.loc(start) };
+    }
+    parseTry() {
+        const start = this.expectKeyword('try');
+        const body = this.parseBlock(['catch', 'finally', 'end']);
+        let catchVar;
+        let catchType;
+        let catchBody;
+        if (this.matchKeyword('catch')) {
+            if (this.at(token_1.TokenType.Identifier)) {
+                catchVar = this.next().value;
+                if (this.matchOperator(':'))
+                    catchType = this.parseType();
+            }
+            catchBody = this.parseBlock(['finally', 'end']);
+        }
+        const finallyBody = this.matchKeyword('finally') ? this.parseBlock(['end']) : undefined;
+        this.expectKeyword('end');
+        return { kind: 'TryStmt', body, catchVar, catchType, catchBody, finallyBody, loc: this.loc(start) };
+    }
+    parseImport() {
+        const start = this.expectKeyword('import');
+        const clauses = [];
+        let source;
+        if (this.at(token_1.TokenType.String)) {
+            source = this.next().value;
+        }
+        else if (this.matchOperator('{')) {
+            this.skipNewlines();
+            while (!this.atOperator('}')) {
+                const name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected import name');
+                const clause = { name: name.value };
+                if (this.matchKeyword('as')) {
+                    clause.alias = this.expect(token_1.TokenType.Identifier, undefined, 'Expected alias').value;
+                }
+                clauses.push(clause);
+                this.skipNewlines();
+                if (!this.matchOperator(','))
+                    break;
+                this.skipNewlines();
+            }
+            this.expect(token_1.TokenType.Operator, '}', 'Expected "}"');
+            this.expectKeyword('from');
+            source = this.expect(token_1.TokenType.String, undefined, 'Expected module path').value;
+        }
+        else if (this.matchOperator('*')) {
+            this.expectKeyword('as');
+            const alias = this.expect(token_1.TokenType.Identifier, undefined, 'Expected namespace alias');
+            clauses.push({ name: '*', alias: alias.value });
+            this.expectKeyword('from');
+            source = this.expect(token_1.TokenType.String, undefined, 'Expected module path').value;
+        }
+        else {
+            const name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected import name');
+            const clause = { name: name.value };
+            if (this.matchKeyword('as')) {
+                clause.alias = this.expect(token_1.TokenType.Identifier, undefined, 'Expected alias').value;
+            }
+            clauses.push(clause);
+            this.expectKeyword('from');
+            source = this.expect(token_1.TokenType.String, undefined, 'Expected module path').value;
+        }
+        return { kind: 'ImportDecl', clauses, source, loc: this.loc(start) };
+    }
+    parseExport() {
+        const start = this.expectKeyword('export');
+        if (this.matchKeyword('default')) {
+            const expr = this.parseExpression();
+            const node = { kind: 'ExportDefault', expr, loc: this.loc(start) };
+            return node;
+        }
+        let declaration;
+        if (this.atKeyword('const'))
+            declaration = this.parseVarDeclaration('const');
+        else if (this.atKeyword('global'))
+            declaration = this.parseVarDeclaration('global');
+        else if (this.atKeyword('fn'))
+            declaration = this.parseFnDecl([], false, false);
+        else if (this.atKeyword('class'))
+            declaration = this.parseClassDecl([]);
+        else if (this.atKeyword('type'))
+            declaration = this.parseTypeAlias();
+        else if (this.atKeyword('async') && this.peek(1).value === 'fn') {
+            this.next();
+            declaration = this.parseFnDecl([], true, false);
+        }
+        else {
+            throw this.error('Expected declaration after "export"');
+        }
+        if (declaration.kind === 'VarDecl')
+            declaration.export = true;
+        const node = { kind: 'ExportDecl', declaration, loc: this.loc(start) };
+        return node;
+    }
+    parseTypeAlias() {
+        const start = this.expectKeyword('type');
+        const name = this.expect(token_1.TokenType.Identifier, undefined, 'Expected type name').value;
+        this.expect(token_1.TokenType.Operator, '=', 'Expected "=" in type alias');
+        const type = this.parseType();
+        return { kind: 'TypeAliasDecl', name, type, loc: this.loc(start) };
+    }
+    /* ---------------------------------------------------------------- */
+    /* Types                                                             */
+    /* ---------------------------------------------------------------- */
+    parseType() {
+        const start = this.peek();
+        const types = [this.parseTypePostfix()];
+        while (this.matchOperator('|'))
+            types.push(this.parseTypePostfix());
+        if (types.length === 1)
+            return types[0];
+        return { kind: 'union', types, loc: this.loc(start) };
+    }
+    parseTypePostfix() {
+        let type = this.parseTypePrimary();
+        while (this.matchOperator('?')) {
+            type = { kind: 'optional', type, inner: type, loc: type.loc };
+        }
+        return type;
+    }
+    parseTypePrimary() {
+        const token = this.peek();
+        if (this.matchOperator('(')) {
+            const params = [];
+            this.skipNewlines();
+            while (!this.atOperator(')')) {
+                params.push(this.parseType());
+                this.skipNewlines();
+                if (!this.matchOperator(','))
+                    break;
+                this.skipNewlines();
+            }
+            this.expect(token_1.TokenType.Operator, ')', 'Expected ")"');
+            this.expect(token_1.TokenType.Operator, '->', 'Expected "->" in function type');
+            const returns = this.parseType();
+            return { kind: 'fn', params, returns, loc: this.loc(token) };
+        }
+        if (this.matchOperator('[')) {
+            const element = this.parseType();
+            this.expect(token_1.TokenType.Operator, ']', 'Expected "]"');
+            return { kind: 'array', element, loc: this.loc(token) };
+        }
+        if (this.matchOperator('{')) {
+            this.skipNewlines();
+            const entries = [];
+            while (!this.atOperator('}')) {
+                const member = this.expect(token_1.TokenType.Identifier, undefined, 'Expected type member name');
+                this.expect(token_1.TokenType.Operator, ':', 'Expected ":" in type');
+                const type = this.parseType();
+                entries.push({ name: member.value, type });
+                this.skipNewlines();
+                if (!this.matchOperator(','))
+                    break;
+                this.skipNewlines();
+            }
+            this.expect(token_1.TokenType.Operator, '}', 'Expected "}"');
+            if (entries.length === 1 && PRIMITIVE_TYPE_NAMES.has(entries[0].name)) {
+                return {
+                    kind: 'dict',
+                    key: { kind: 'named', name: entries[0].name, loc: this.loc(token) },
+                    value: entries[0].type,
+                    loc: this.loc(token),
+                };
+            }
+            return { kind: 'record', fields: entries, loc: this.loc(token) };
+        }
+        if (token.type === token_1.TokenType.Identifier || this.atKeyword('nil')) {
+            this.next();
+            return { kind: 'named', name: token.value, loc: this.loc(token) };
+        }
+        throw this.error('Expected type annotation');
+    }
+    /* ---------------------------------------------------------------- */
+    /* Expressions                                                       */
+    /* ---------------------------------------------------------------- */
+    parseExprList() {
+        const list = [this.parseExpression()];
+        while (this.matchOperator(','))
+            list.push(this.parseExpression());
+        return list;
+    }
+    parseExpression(minPrecedence = 1) {
+        let left = this.parseUnary();
+        while (true) {
+            const token = this.peek();
+            const op = token.value;
+            const precedence = BINARY_PRECEDENCE[op];
+            if (precedence === undefined || precedence < minPrecedence)
+                break;
+            const isOperator = token.type === token_1.TokenType.Operator
+                || (token.type === token_1.TokenType.Keyword && (op === 'and' || op === 'or'));
+            if (!isOperator)
+                break;
+            this.next();
+            const right = this.parseExpression(op === '^' ? precedence : precedence + 1);
+            const binary = { kind: 'Binary', op, left, right, loc: left.loc };
+            left = binary;
+        }
+        return left;
+    }
+    parseUnary() {
+        const token = this.peek();
+        if (token.type === token_1.TokenType.Keyword && token.value === 'not') {
+            this.next();
+            return {
+                kind: 'Unary',
+                op: 'not',
+                argument: this.parseExpression(UNARY_PRECEDENCE),
+                loc: this.loc(token),
+            };
+        }
+        if (token.type === token_1.TokenType.Keyword && token.value === 'await') {
+            this.next();
+            const node = {
+                kind: 'AwaitExpr',
+                argument: this.parseExpression(UNARY_PRECEDENCE),
+                loc: this.loc(token),
+            };
+            return node;
+        }
+        if (token.type === token_1.TokenType.Operator && (token.value === '-' || token.value === '#')) {
+            this.next();
+            return {
+                kind: 'Unary',
+                op: token.value,
+                argument: this.parseExpression(UNARY_PRECEDENCE),
+                loc: this.loc(token),
+            };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        while (true) {
+            const token = this.peek();
+            if (token.type === token_1.TokenType.Operator && token.value === '(') {
+                const args = this.parseArguments();
+                const call = { kind: 'Call', callee: expr, args, loc: expr.loc };
+                expr = call;
+                continue;
+            }
+            if (token.type === token_1.TokenType.Operator && (token.value === '.' || token.value === '?.')) {
+                this.next();
+                const property = this.expectName('Expected property name');
+                const member = {
+                    kind: 'Member',
+                    object: expr,
+                    property: property.value,
+                    loc: expr.loc,
+                };
+                if (token.value === '?.')
+                    member.optional = true;
+                expr = member;
+                continue;
+            }
+            if (token.type === token_1.TokenType.Operator && token.value === '[') {
+                this.next();
+                this.skipNewlines();
+                const index = this.parseRangeExpr();
+                this.skipNewlines();
+                this.expect(token_1.TokenType.Operator, ']', 'Expected "]"');
+                const node = { kind: 'Index', object: expr, index, loc: expr.loc };
+                if (index.kind === 'Range')
+                    node.isRange = true;
+                expr = node;
+                continue;
+            }
+            // Method call: a:b(args). A bare `:` is a type annotation instead.
+            if (token.type === token_1.TokenType.Operator && token.value === ':'
+                && isNameToken(this.peek(1))
+                && this.peek(2).type === token_1.TokenType.Operator && this.peek(2).value === '(') {
+                this.next();
+                const property = this.next();
+                const member = {
+                    kind: 'Member',
+                    object: expr,
+                    property: property.value,
+                    loc: expr.loc,
+                };
+                const args = this.parseArguments();
+                const call = { kind: 'Call', callee: member, args, isMethod: true, loc: expr.loc };
+                expr = call;
+                continue;
+            }
+            break;
+        }
+        return expr;
+    }
+    parseArguments() {
+        this.expect(token_1.TokenType.Operator, '(', 'Expected "("');
+        const args = [];
+        this.skipNewlines();
+        while (!this.atOperator(')')) {
+            if (this.atOperator('...')) {
+                const spreadToken = this.next();
+                const spread = { kind: 'Spread', loc: this.loc(spreadToken) };
+                if (!this.atOperator(')') && !this.atOperator(','))
+                    spread.argument = this.parseExpression();
+                args.push(spread);
+            }
+            else {
+                args.push(this.parseExpression());
+            }
+            this.skipNewlines();
+            if (!this.matchOperator(','))
+                break;
+            this.skipNewlines();
+        }
+        this.expect(token_1.TokenType.Operator, ')', 'Expected ")"');
+        return args;
+    }
+    parsePrimary() {
+        const token = this.peek();
+        switch (token.type) {
+            case token_1.TokenType.Number: {
+                this.next();
+                return {
+                    kind: 'NumberLit',
+                    value: Number(token.value.replace(/_/g, '')),
+                    loc: this.loc(token),
+                };
+            }
+            case token_1.TokenType.String: {
+                this.next();
+                const literal = { kind: 'StringLit', value: token.value, loc: this.loc(token) };
+                if (token.value.includes('\n'))
+                    literal.multiline = true;
+                return literal;
+            }
+            case token_1.TokenType.FString: {
+                this.next();
+                const literal = {
+                    kind: 'StringLit',
+                    value: token.value,
+                    fstring: true,
+                    parts: parseFStringParts(token),
+                    loc: this.loc(token),
+                };
+                if (token.value.includes('\n'))
+                    literal.multiline = true;
+                return literal;
+            }
+            case token_1.TokenType.Identifier: {
+                this.next();
+                const ident = { kind: 'Ident', name: token.value, loc: this.loc(token) };
+                return ident;
+            }
+            case token_1.TokenType.Keyword:
+                return this.parseKeywordPrimary(token);
+            case token_1.TokenType.Operator:
+                if (token.value === '{')
+                    return this.parseTable();
+                if (token.value === '(') {
+                    this.next();
+                    const expr = this.parseExpression();
+                    this.expect(token_1.TokenType.Operator, ')', 'Expected ")"');
+                    return expr;
+                }
+                break;
+        }
+        throw this.error(`Unexpected token "${token.value}"`);
+    }
+    parseKeywordPrimary(token) {
+        switch (token.value) {
+            case 'true':
+            case 'false':
+                this.next();
+                return { kind: 'BoolLit', value: token.value === 'true', loc: this.loc(token) };
+            case 'nil':
+                this.next();
+                return { kind: 'NilLit', loc: this.loc(token) };
+            case 'self':
+                this.next();
+                return { kind: 'SelfExpr', loc: this.loc(token) };
+            case 'fn':
+                return this.parseFunctionExpr(false);
+            case 'async':
+                if (this.peek(1).type === token_1.TokenType.Keyword && this.peek(1).value === 'fn') {
+                    this.next();
+                    return this.parseFunctionExpr(true);
+                }
+                break;
+        }
+        throw this.error(`Unexpected keyword "${token.value}"`);
+    }
+    parseFunctionExpr(isAsync) {
+        const start = this.expectKeyword('fn');
+        const params = this.parseParams();
+        const returnType = this.matchOperator(':') ? this.parseType() : undefined;
+        let body;
+        let exprBody;
+        if (this.matchOperator('->')) {
+            exprBody = this.parseExpression();
+        }
+        else {
+            body = this.parseBlock(['end']);
+            this.expectKeyword('end');
+        }
+        const node = {
+            kind: 'FunctionExpr',
+            params,
+            returnType,
+            body,
+            exprBody,
+            loc: this.loc(start),
+        };
+        if (isAsync)
+            node.async = true;
+        return node;
+    }
+    parseTable() {
+        const start = this.expect(token_1.TokenType.Operator, '{');
+        const fields = [];
+        while (true) {
+            this.skipNewlines();
+            if (this.atOperator('}'))
+                break;
+            if (this.matchOperator('[')) {
+                const key = this.parseExpression();
+                this.expect(token_1.TokenType.Operator, ']', 'Expected "]"');
+                this.expect(token_1.TokenType.Operator, '=', 'Expected "="');
+                const value = this.parseExpression();
+                fields.push({ key, value });
+            }
+            else if (isNameToken(this.peek())
+                && this.peek(1).type === token_1.TokenType.Operator
+                && this.peek(1).value === '=') {
+                const key = this.next();
+                this.next();
+                const value = this.parseExpression();
+                const keyNode = { kind: 'Ident', name: key.value, loc: this.loc(key) };
+                fields.push({ key: keyNode, value });
+            }
+            else if (this.peek().type === token_1.TokenType.Identifier && this.isTableFieldEnd(this.peek(1))) {
+                const shorthand = this.next();
+                const ident = { kind: 'Ident', name: shorthand.value, loc: this.loc(shorthand) };
+                fields.push({ key: ident, value: ident });
+            }
+            else {
+                fields.push({ value: this.parseExpression() });
+            }
+            this.skipNewlines();
+            if (this.matchOperator(',') || this.match(token_1.TokenType.Semicolon))
+                continue;
+            if (this.atOperator('}'))
+                break;
+        }
+        this.expect(token_1.TokenType.Operator, '}', 'Expected "}"');
+        return { kind: 'Table', fields, loc: this.loc(start) };
+    }
+    isTableFieldEnd(token) {
+        return token.type === token_1.TokenType.Newline
+            || token.type === token_1.TokenType.Semicolon
+            || token.type === token_1.TokenType.EOF
+            || (token.type === token_1.TokenType.Operator && (token.value === ',' || token.value === '}'));
+    }
+    /**
+     * Range is only meaningful in `for ... in` heads and slices, where `..`
+     * must not be treated as string concatenation.
+     */
+    parseRangeExpr() {
+        const start = this.peek();
+        const expr = this.parseExpression();
+        if (expr.kind === 'Binary' && expr.op === '..') {
+            const range = {
+                kind: 'Range',
+                from: expr.left,
+                to: expr.right,
+                inclusive: true,
+                loc: expr.loc,
+            };
+            return range;
+        }
+        if (this.atOperator('..') || this.atOperator('..<')) {
+            const inclusive = this.next().value === '..';
+            const to = this.parseExpression();
+            const range = { kind: 'Range', from: expr, to, inclusive, loc: this.loc(start) };
+            return range;
+        }
+        return expr;
+    }
+    /** Parses a complete standalone expression (used by f-string interpolation). */
+    parseExpressionOnly() {
+        const expr = this.parseExpression();
+        if (!this.at(token_1.TokenType.EOF))
+            throw this.error('Unexpected token in expression');
+        return expr;
+    }
+}
+/** Splits an f-string body into literal text and parsed interpolation expressions. */
+function parseFStringParts(token) {
+    const raw = token.value;
+    const parts = [];
+    let text = '';
+    let index = 0;
+    while (index < raw.length) {
+        const ch = raw[index];
+        if (ch === '{' && raw[index + 1] === '{') {
+            text += '{';
+            index += 2;
+            continue;
+        }
+        if (ch === '}' && raw[index + 1] === '}') {
+            text += '}';
+            index += 2;
+            continue;
+        }
+        if (ch === '{') {
+            const close = findInterpolationEnd(raw, index + 1);
+            if (close < 0) {
+                throw new SyntaxError(`Unterminated f-string interpolation (line ${token.line}, column ${token.column})`);
+            }
+            if (text) {
+                parts.push(text);
+                text = '';
+            }
+            parts.push(new Parser(raw.slice(index + 1, close)).parseExpressionOnly());
+            index = close + 1;
+            continue;
+        }
+        text += ch;
+        index++;
+    }
+    if (text)
+        parts.push(text);
+    return parts;
+}
+/** Finds the `}` closing an interpolation, skipping nested braces and strings. */
+function findInterpolationEnd(raw, from) {
+    let depth = 1;
+    let quote = '';
+    for (let i = from; i < raw.length; i++) {
+        const ch = raw[i];
+        if (quote) {
+            if (ch === '\\')
+                i++;
+            else if (ch === quote)
+                quote = '';
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function parse(source) {
+    return new Parser(source).parseProgram();
+}
+/** Parses a single expression; mainly useful for tooling and f-string chunks. */
+function parseExpression(source) {
+    return new Parser(source).parseExpressionOnly();
+}
+//# sourceMappingURL=parser.js.map