takomusic 1.2.0

package/dist/parser/parser.js

@@ -0,0 +1,896 @@
+// Parser for MFS language
+import { TokenType } from '../types/token.js';
+import { MFError } from '../errors.js';
+export class Parser {
+    tokens;
+    current = 0;
+    filePath;
+    constructor(tokens, filePath) {
+        this.tokens = tokens;
+        this.filePath = filePath;
+    }
+    parse() {
+        const statements = [];
+        const pos = this.peek().position;
+        while (!this.isAtEnd()) {
+            const stmt = this.parseStatement();
+            if (stmt) {
+                statements.push(stmt);
+            }
+        }
+        return { kind: 'Program', statements, position: pos };
+    }
+    parseStatement() {
+        if (this.check(TokenType.IMPORT)) {
+            return this.parseImport();
+        }
+        if (this.check(TokenType.EXPORT)) {
+            return this.parseExport();
+        }
+        if (this.check(TokenType.PROC)) {
+            return this.parseProc(false);
+        }
+        if (this.check(TokenType.CONST)) {
+            return this.parseConst(false);
+        }
+        if (this.check(TokenType.LET)) {
+            return this.parseLet();
+        }
+        if (this.check(TokenType.IF)) {
+            return this.parseIf();
+        }
+        if (this.check(TokenType.FOR)) {
+            return this.parseFor();
+        }
+        if (this.check(TokenType.WHILE)) {
+            return this.parseWhile();
+        }
+        if (this.check(TokenType.RETURN)) {
+            return this.parseReturn();
+        }
+        if (this.check(TokenType.BREAK)) {
+            return this.parseBreak();
+        }
+        if (this.check(TokenType.CONTINUE)) {
+            return this.parseContinue();
+        }
+        // track block: track(kind, id, opts?) { ... }
+        if (this.checkIdent('track')) {
+            return this.parseTrackBlock();
+        }
+        // Assignment or expression statement
+        return this.parseAssignmentOrExpression();
+    }
+    parseImport() {
+        const pos = this.advance().position; // consume 'import'
+        this.expect(TokenType.LBRACE, "Expected '{' after 'import'");
+        const imports = [];
+        if (!this.check(TokenType.RBRACE)) {
+            do {
+                const ident = this.expect(TokenType.IDENT, 'Expected identifier in import list');
+                imports.push(ident.value);
+            } while (this.match(TokenType.COMMA));
+        }
+        this.expect(TokenType.RBRACE, "Expected '}' after import list");
+        this.expect(TokenType.IDENT, "Expected 'from'"); // 'from' keyword
+        const pathToken = this.expect(TokenType.STRING, 'Expected module path');
+        this.expect(TokenType.SEMICOLON, "Expected ';' after import");
+        return {
+            kind: 'ImportStatement',
+            imports,
+            path: pathToken.value,
+            position: pos,
+        };
+    }
+    parseExport() {
+        const pos = this.advance().position; // consume 'export'
+        let declaration;
+        if (this.check(TokenType.PROC)) {
+            declaration = this.parseProc(true);
+        }
+        else if (this.check(TokenType.CONST)) {
+            declaration = this.parseConst(true);
+        }
+        else {
+            throw this.error("Expected 'proc' or 'const' after 'export'");
+        }
+        return {
+            kind: 'ExportStatement',
+            declaration,
+            position: pos,
+        };
+    }
+    parseProc(exported) {
+        const pos = this.advance().position; // consume 'proc'
+        const name = this.expect(TokenType.IDENT, 'Expected proc name').value;
+        this.expect(TokenType.LPAREN, "Expected '(' after proc name");
+        const params = [];
+        if (!this.check(TokenType.RPAREN)) {
+            do {
+                // Check for rest parameter
+                if (this.check(TokenType.SPREAD)) {
+                    this.advance(); // consume '...'
+                    const param = this.expect(TokenType.IDENT, 'Expected rest parameter name');
+                    params.push({ name: param.value, rest: true });
+                    break; // Rest must be last
+                }
+                const param = this.expect(TokenType.IDENT, 'Expected parameter name');
+                params.push({ name: param.value });
+            } while (this.match(TokenType.COMMA));
+        }
+        this.expect(TokenType.RPAREN, "Expected ')' after parameters");
+        this.expect(TokenType.LBRACE, "Expected '{' before proc body");
+        const body = this.parseBlock();
+        return {
+            kind: 'ProcDeclaration',
+            name,
+            params,
+            body,
+            exported,
+            position: pos,
+        };
+    }
+    parseConst(exported) {
+        const pos = this.advance().position; // consume 'const'
+        const name = this.expect(TokenType.IDENT, 'Expected constant name').value;
+        this.expect(TokenType.EQ, "Expected '=' after constant name");
+        const value = this.parseExpression();
+        this.expect(TokenType.SEMICOLON, "Expected ';' after constant value");
+        return {
+            kind: 'ConstDeclaration',
+            name,
+            value,
+            exported,
+            position: pos,
+        };
+    }
+    parseLet() {
+        const pos = this.advance().position; // consume 'let'
+        const name = this.expect(TokenType.IDENT, 'Expected variable name').value;
+        this.expect(TokenType.EQ, "Expected '=' after variable name");
+        const value = this.parseExpression();
+        this.expect(TokenType.SEMICOLON, "Expected ';' after variable value");
+        return {
+            kind: 'LetDeclaration',
+            name,
+            value,
+            position: pos,
+        };
+    }
+    parseIf() {
+        const pos = this.advance().position; // consume 'if'
+        this.expect(TokenType.LPAREN, "Expected '(' after 'if'");
+        const condition = this.parseExpression();
+        this.expect(TokenType.RPAREN, "Expected ')' after condition");
+        this.expect(TokenType.LBRACE, "Expected '{' before if body");
+        const consequent = this.parseBlock();
+        let alternate = null;
+        if (this.match(TokenType.ELSE)) {
+            this.expect(TokenType.LBRACE, "Expected '{' after 'else'");
+            alternate = this.parseBlock();
+        }
+        return {
+            kind: 'IfStatement',
+            condition,
+            consequent,
+            alternate,
+            position: pos,
+        };
+    }
+    parseFor() {
+        const pos = this.advance().position; // consume 'for'
+        this.expect(TokenType.LPAREN, "Expected '(' after 'for'");
+        const variable = this.expect(TokenType.IDENT, 'Expected loop variable').value;
+        this.expect(TokenType.IN, "Expected 'in' after loop variable");
+        const firstExpr = this.parseAdditive();
+        // Check if this is a range (has ..) or array iteration
+        if (this.check(TokenType.DOTDOT) || this.check(TokenType.DOTDOTEQ)) {
+            // Range iteration: for (i in 0..10) or for (i in 0..=10)
+            let inclusive = false;
+            if (this.match(TokenType.DOTDOTEQ)) {
+                inclusive = true;
+            }
+            else {
+                this.advance(); // consume '..'
+            }
+            const rangeEnd = this.parseAdditive();
+            const range = {
+                kind: 'RangeExpression',
+                start: firstExpr,
+                end: rangeEnd,
+                inclusive,
+                position: firstExpr.position,
+            };
+            this.expect(TokenType.RPAREN, "Expected ')' after range");
+            this.expect(TokenType.LBRACE, "Expected '{' before for body");
+            const body = this.parseBlock();
+            return {
+                kind: 'ForStatement',
+                variable,
+                range,
+                body,
+                position: pos,
+            };
+        }
+        else {
+            // Array iteration: for (x in array)
+            this.expect(TokenType.RPAREN, "Expected ')' after iterable");
+            this.expect(TokenType.LBRACE, "Expected '{' before for body");
+            const body = this.parseBlock();
+            return {
+                kind: 'ForEachStatement',
+                variable,
+                iterable: firstExpr,
+                body,
+                position: pos,
+            };
+        }
+    }
+    parseWhile() {
+        const pos = this.advance().position; // consume 'while'
+        this.expect(TokenType.LPAREN, "Expected '(' after 'while'");
+        const condition = this.parseExpression();
+        this.expect(TokenType.RPAREN, "Expected ')' after condition");
+        this.expect(TokenType.LBRACE, "Expected '{' before while body");
+        const body = this.parseBlock();
+        return {
+            kind: 'WhileStatement',
+            condition,
+            body,
+            position: pos,
+        };
+    }
+    parseReturn() {
+        const pos = this.advance().position; // consume 'return'
+        let value = null;
+        if (!this.check(TokenType.SEMICOLON)) {
+            value = this.parseExpression();
+        }
+        this.expect(TokenType.SEMICOLON, "Expected ';' after return");
+        return {
+            kind: 'ReturnStatement',
+            value,
+            position: pos,
+        };
+    }
+    parseBreak() {
+        const pos = this.advance().position; // consume 'break'
+        this.expect(TokenType.SEMICOLON, "Expected ';' after break");
+        return { kind: 'BreakStatement', position: pos };
+    }
+    parseContinue() {
+        const pos = this.advance().position; // consume 'continue'
+        this.expect(TokenType.SEMICOLON, "Expected ';' after continue");
+        return { kind: 'ContinueStatement', position: pos };
+    }
+    parseTrackBlock() {
+        const pos = this.advance().position; // consume 'track'
+        this.expect(TokenType.LPAREN, "Expected '(' after 'track'");
+        // Parse track kind (vocal or midi)
+        const kindToken = this.advance();
+        if (kindToken.type !== TokenType.VOCAL && kindToken.type !== TokenType.MIDI) {
+            throw this.error("Expected 'vocal' or 'midi' as track kind");
+        }
+        const trackKind = kindToken.value;
+        this.expect(TokenType.COMMA, "Expected ',' after track kind");
+        const id = this.expect(TokenType.IDENT, 'Expected track id').value;
+        let options = null;
+        if (this.match(TokenType.COMMA)) {
+            options = this.parseObjectLiteral();
+        }
+        this.expect(TokenType.RPAREN, "Expected ')' after track arguments");
+        this.expect(TokenType.LBRACE, "Expected '{' before track body");
+        const body = this.parseBlock();
+        return {
+            kind: 'TrackBlock',
+            trackKind,
+            id,
+            options,
+            body,
+            position: pos,
+        };
+    }
+    parseBlock() {
+        const statements = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const stmt = this.parseStatement();
+            if (stmt) {
+                statements.push(stmt);
+            }
+        }
+        this.expect(TokenType.RBRACE, "Expected '}' after block");
+        return statements;
+    }
+    parseAssignmentOrExpression() {
+        const pos = this.peek().position;
+        // Parse the left-hand side expression first
+        const expr = this.parseExpression();
+        // Check for assignment operators
+        if (this.check(TokenType.EQ)) {
+            this.advance(); // consume '='
+            const value = this.parseExpression();
+            this.expect(TokenType.SEMICOLON, "Expected ';' after assignment");
+            // Simple variable assignment
+            if (expr.kind === 'Identifier') {
+                return {
+                    kind: 'AssignmentStatement',
+                    name: expr.name,
+                    value,
+                    position: pos,
+                };
+            }
+            // Index assignment: arr[i] = value
+            if (expr.kind === 'IndexExpression') {
+                return {
+                    kind: 'IndexAssignmentStatement',
+                    object: expr.object,
+                    index: expr.index,
+                    value,
+                    position: pos,
+                };
+            }
+            // Property assignment: obj.prop = value
+            if (expr.kind === 'MemberExpression') {
+                return {
+                    kind: 'PropertyAssignmentStatement',
+                    object: expr.object,
+                    property: expr.property,
+                    value,
+                    position: pos,
+                };
+            }
+            throw this.error('Invalid assignment target');
+        }
+        // Compound assignment: +=, -=, *=, /=
+        if (this.checkCompoundAssign()) {
+            const op = this.advance().value; // e.g., '+='
+            const binaryOp = op.charAt(0); // e.g., '+'
+            const rhs = this.parseExpression();
+            this.expect(TokenType.SEMICOLON, "Expected ';' after assignment");
+            // Desugar: x += y  ->  x = x + y
+            if (expr.kind === 'Identifier') {
+                const binaryExpr = {
+                    kind: 'BinaryExpression',
+                    operator: binaryOp,
+                    left: expr,
+                    right: rhs,
+                    position: pos,
+                };
+                return {
+                    kind: 'AssignmentStatement',
+                    name: expr.name,
+                    value: binaryExpr,
+                    position: pos,
+                };
+            }
+            // arr[i] += y  ->  arr[i] = arr[i] + y
+            if (expr.kind === 'IndexExpression') {
+                const binaryExpr = {
+                    kind: 'BinaryExpression',
+                    operator: binaryOp,
+                    left: expr,
+                    right: rhs,
+                    position: pos,
+                };
+                return {
+                    kind: 'IndexAssignmentStatement',
+                    object: expr.object,
+                    index: expr.index,
+                    value: binaryExpr,
+                    position: pos,
+                };
+            }
+            throw this.error('Invalid compound assignment target');
+        }
+        // Expression statement
+        this.expect(TokenType.SEMICOLON, "Expected ';' after expression");
+        return {
+            kind: 'ExpressionStatement',
+            expression: expr,
+            position: pos,
+        };
+    }
+    checkCompoundAssign() {
+        return this.check(TokenType.PLUSEQ) || this.check(TokenType.MINUSEQ) ||
+            this.check(TokenType.STAREQ) || this.check(TokenType.SLASHEQ);
+    }
+    // Expression parsing with precedence climbing
+    parseExpression() {
+        return this.parseOr();
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.match(TokenType.OR)) {
+            const right = this.parseAnd();
+            left = {
+                kind: 'BinaryExpression',
+                operator: '||',
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseEquality();
+        while (this.match(TokenType.AND)) {
+            const right = this.parseEquality();
+            left = {
+                kind: 'BinaryExpression',
+                operator: '&&',
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseEquality() {
+        let left = this.parseComparison();
+        while (this.check(TokenType.EQEQ) || this.check(TokenType.NEQ)) {
+            const op = this.advance().value;
+            const right = this.parseComparison();
+            left = {
+                kind: 'BinaryExpression',
+                operator: op,
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseComparison() {
+        let left = this.parseAdditive();
+        while (this.check(TokenType.LT) ||
+            this.check(TokenType.GT) ||
+            this.check(TokenType.LTEQ) ||
+            this.check(TokenType.GTEQ)) {
+            const op = this.advance().value;
+            const right = this.parseAdditive();
+            left = {
+                kind: 'BinaryExpression',
+                operator: op,
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.check(TokenType.PLUS) || this.check(TokenType.MINUS)) {
+            const op = this.advance().value;
+            const right = this.parseMultiplicative();
+            left = {
+                kind: 'BinaryExpression',
+                operator: op,
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.check(TokenType.STAR) || this.check(TokenType.SLASH) || this.check(TokenType.PERCENT)) {
+            const op = this.advance().value;
+            const right = this.parseUnary();
+            left = {
+                kind: 'BinaryExpression',
+                operator: op,
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.check(TokenType.NOT) || this.check(TokenType.MINUS)) {
+            const op = this.advance().value;
+            const operand = this.parseUnary();
+            return {
+                kind: 'UnaryExpression',
+                operator: op,
+                operand,
+                position: operand.position,
+            };
+        }
+        return this.parseCall();
+    }
+    parseCall() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.check(TokenType.LPAREN)) {
+                // Function call: expr(args) - supports first-class functions
+                expr = this.finishCall(expr);
+            }
+            else if (this.check(TokenType.LBRACKET)) {
+                // Index access: expr[index]
+                const pos = this.advance().position; // consume '['
+                const index = this.parseExpression();
+                this.expect(TokenType.RBRACKET, "Expected ']' after index");
+                expr = {
+                    kind: 'IndexExpression',
+                    object: expr,
+                    index,
+                    position: pos,
+                };
+            }
+            else if (this.check(TokenType.DOT)) {
+                // Member access: expr.property
+                const pos = this.advance().position; // consume '.'
+                const prop = this.expect(TokenType.IDENT, 'Expected property name after "."');
+                expr = {
+                    kind: 'MemberExpression',
+                    object: expr,
+                    property: prop.value,
+                    position: pos,
+                };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    finishCall(callee) {
+        const pos = this.advance().position; // consume '('
+        const args = [];
+        if (!this.check(TokenType.RPAREN)) {
+            do {
+                // Check for spread argument
+                if (this.check(TokenType.SPREAD)) {
+                    const spreadPos = this.advance().position; // consume '...'
+                    args.push({
+                        kind: 'SpreadElement',
+                        argument: this.parseExpression(),
+                        position: spreadPos,
+                    });
+                }
+                else {
+                    args.push(this.parseExpression());
+                }
+            } while (this.match(TokenType.COMMA));
+        }
+        this.expect(TokenType.RPAREN, "Expected ')' after arguments");
+        return {
+            kind: 'CallExpression',
+            callee,
+            arguments: args,
+            position: callee.position,
+        };
+    }
+    parsePrimary() {
+        const token = this.peek();
+        // Int literal
+        if (this.check(TokenType.INT)) {
+            this.advance();
+            return {
+                kind: 'IntLiteral',
+                value: parseInt(token.value, 10),
+                position: token.position,
+            };
+        }
+        // Float literal
+        if (this.check(TokenType.FLOAT)) {
+            this.advance();
+            return {
+                kind: 'FloatLiteral',
+                value: parseFloat(token.value),
+                position: token.position,
+            };
+        }
+        // String literal
+        if (this.check(TokenType.STRING)) {
+            this.advance();
+            return {
+                kind: 'StringLiteral',
+                value: token.value,
+                position: token.position,
+            };
+        }
+        // Bool literal
+        if (this.check(TokenType.TRUE)) {
+            this.advance();
+            return {
+                kind: 'BoolLiteral',
+                value: true,
+                position: token.position,
+            };
+        }
+        if (this.check(TokenType.FALSE)) {
+            this.advance();
+            return {
+                kind: 'BoolLiteral',
+                value: false,
+                position: token.position,
+            };
+        }
+        // Pitch literal
+        if (this.check(TokenType.PITCH)) {
+            this.advance();
+            return this.parsePitchLiteral(token);
+        }
+        // Dur literal
+        if (this.check(TokenType.DUR)) {
+            this.advance();
+            return this.parseDurLiteral(token);
+        }
+        // Time literal
+        if (this.check(TokenType.TIME)) {
+            this.advance();
+            return this.parseTimeLiteral(token);
+        }
+        // Array literal
+        if (this.check(TokenType.LBRACKET)) {
+            return this.parseArrayLiteral();
+        }
+        // Object literal
+        if (this.check(TokenType.LBRACE)) {
+            return this.parseObjectLiteral();
+        }
+        // Identifier
+        if (this.check(TokenType.IDENT)) {
+            this.advance();
+            return {
+                kind: 'Identifier',
+                name: token.value,
+                position: token.position,
+            };
+        }
+        // Parenthesized expression or arrow function
+        if (this.check(TokenType.LPAREN)) {
+            return this.parseParenOrArrow();
+        }
+        throw this.error(`Unexpected token: ${token.value}`);
+    }
+    // Parse either a parenthesized expression or an arrow function
+    parseParenOrArrow() {
+        const startPos = this.peek().position;
+        this.advance(); // consume '('
+        // Empty params: () => ...
+        if (this.check(TokenType.RPAREN)) {
+            this.advance(); // consume ')'
+            if (this.check(TokenType.ARROW)) {
+                return this.finishArrowFunction([], startPos);
+            }
+            throw this.error('Empty parentheses are not allowed except for arrow functions');
+        }
+        // Try to parse as parameters for arrow function
+        // We need to look ahead to determine if this is arrow function or just parens
+        const savedPos = this.current;
+        // Check if we can parse as parameters (all identifiers/rest, no complex expressions)
+        const params = [];
+        let isArrow = true;
+        try {
+            do {
+                if (this.check(TokenType.SPREAD)) {
+                    this.advance();
+                    const name = this.expect(TokenType.IDENT, 'Expected parameter name');
+                    params.push({ name: name.value, rest: true });
+                    break;
+                }
+                if (!this.check(TokenType.IDENT)) {
+                    isArrow = false;
+                    break;
+                }
+                const name = this.advance().value;
+                params.push({ name });
+            } while (this.match(TokenType.COMMA));
+            if (isArrow && this.check(TokenType.RPAREN)) {
+                this.advance(); // consume ')'
+                if (this.check(TokenType.ARROW)) {
+                    return this.finishArrowFunction(params, startPos);
+                }
+            }
+        }
+        catch {
+            // Not a valid arrow function parameter list
+        }
+        // Backtrack and parse as parenthesized expression
+        this.current = savedPos;
+        const expr = this.parseExpression();
+        this.expect(TokenType.RPAREN, "Expected ')' after expression");
+        // Check for arrow after single-param parens: (x) => ...
+        if (this.check(TokenType.ARROW) && expr.kind === 'Identifier') {
+            return this.finishArrowFunction([{ name: expr.name }], startPos);
+        }
+        return expr;
+    }
+    finishArrowFunction(params, startPos) {
+        this.advance(); // consume '=>'
+        let body;
+        if (this.check(TokenType.LBRACE)) {
+            this.advance(); // consume '{'
+            body = this.parseBlock();
+        }
+        else {
+            body = this.parseExpression();
+        }
+        return {
+            kind: 'ArrowFunction',
+            params,
+            body,
+            position: startPos,
+        };
+    }
+    parsePitchLiteral(token) {
+        // Parse pitch like C4, C#4, Db4
+        const value = token.value;
+        let idx = 0;
+        const noteChar = value[idx++].toUpperCase();
+        let accidental = '';
+        if (value[idx] === '#' || value[idx] === 'b') {
+            accidental = value[idx++];
+        }
+        const octaveStr = value.slice(idx);
+        const octave = parseInt(octaveStr, 10);
+        const note = noteChar + accidental;
+        const midi = this.noteToMidi(note, octave);
+        return {
+            kind: 'PitchLiteral',
+            note,
+            octave,
+            midi,
+            position: token.position,
+        };
+    }
+    noteToMidi(note, octave) {
+        const noteOffsets = {
+            'C': 0, 'C#': 1, 'Db': 1,
+            'D': 2, 'D#': 3, 'Eb': 3,
+            'E': 4, 'Fb': 4, 'E#': 5,
+            'F': 5, 'F#': 6, 'Gb': 6,
+            'G': 7, 'G#': 8, 'Ab': 8,
+            'A': 9, 'A#': 10, 'Bb': 10,
+            'B': 11, 'Cb': 11, 'B#': 0,
+        };
+        const offset = noteOffsets[note] ?? 0;
+        // MIDI: C4 = 60, so C0 = 12
+        return (octave + 1) * 12 + offset;
+    }
+    parseDurLiteral(token) {
+        // Parse duration like 1/4, 3/8
+        const [numStr, denStr] = token.value.split('/');
+        const numerator = parseInt(numStr, 10);
+        const denominator = parseInt(denStr, 10);
+        return {
+            kind: 'DurLiteral',
+            numerator,
+            denominator,
+            position: token.position,
+        };
+    }
+    parseTimeLiteral(token) {
+        // Parse time like 1:1 or 1:1:0
+        const parts = token.value.split(':').map((p) => parseInt(p, 10));
+        const bar = parts[0];
+        const beat = parts[1];
+        const sub = parts[2] ?? 0;
+        return {
+            kind: 'TimeLiteral',
+            bar,
+            beat,
+            sub,
+            position: token.position,
+        };
+    }
+    parseArrayLiteral() {
+        const pos = this.advance().position; // consume '['
+        const elements = [];
+        if (!this.check(TokenType.RBRACKET)) {
+            do {
+                if (this.check(TokenType.SPREAD)) {
+                    const spreadPos = this.advance().position; // consume '...'
+                    elements.push({
+                        kind: 'SpreadElement',
+                        argument: this.parseExpression(),
+                        position: spreadPos,
+                    });
+                }
+                else {
+                    elements.push(this.parseExpression());
+                }
+            } while (this.match(TokenType.COMMA));
+        }
+        this.expect(TokenType.RBRACKET, "Expected ']' after array elements");
+        return {
+            kind: 'ArrayLiteral',
+            elements,
+            position: pos,
+        };
+    }
+    parseObjectLiteral() {
+        const pos = this.advance().position; // consume '{'
+        const properties = [];
+        if (!this.check(TokenType.RBRACE)) {
+            do {
+                // Spread property: { ...obj }
+                if (this.check(TokenType.SPREAD)) {
+                    this.advance(); // consume '...'
+                    const argument = this.parseExpression();
+                    properties.push({ kind: 'spread', argument });
+                }
+                else {
+                    const keyToken = this.expect(TokenType.IDENT, 'Expected property name');
+                    const key = keyToken.value;
+                    // Shorthand property: { x } means { x: x }
+                    if (this.check(TokenType.COMMA) || this.check(TokenType.RBRACE)) {
+                        properties.push({
+                            kind: 'property',
+                            key,
+                            value: { kind: 'Identifier', name: key, position: keyToken.position },
+                            shorthand: true,
+                        });
+                    }
+                    else {
+                        // Full property: { key: value }
+                        this.expect(TokenType.COLON, "Expected ':' after property name");
+                        const value = this.parseExpression();
+                        properties.push({ kind: 'property', key, value, shorthand: false });
+                    }
+                }
+            } while (this.match(TokenType.COMMA));
+        }
+        this.expect(TokenType.RBRACE, "Expected '}' after object properties");
+        return {
+            kind: 'ObjectLiteral',
+            properties,
+            position: pos,
+        };
+    }
+    // Helper methods
+    peek() {
+        return this.tokens[this.current];
+    }
+    peekAhead(offset) {
+        const idx = this.current + offset;
+        if (idx >= this.tokens.length) {
+            return this.tokens[this.tokens.length - 1];
+        }
+        return this.tokens[idx];
+    }
+    advance() {
+        if (!this.isAtEnd()) {
+            this.current++;
+        }
+        return this.tokens[this.current - 1];
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    checkAhead(offset, type) {
+        return this.peekAhead(offset).type === type;
+    }
+    checkIdent(name) {
+        return this.check(TokenType.IDENT) && this.peek().value === name;
+    }
+    match(type) {
+        if (this.check(type)) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    expect(type, message) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        throw this.error(message);
+    }
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    error(message) {
+        const token = this.peek();
+        return new MFError('SYNTAX', message, token.position, this.filePath);
+    }
+}
+//# sourceMappingURL=parser.js.map