takomusic 1.2.0 → 1.3.1

package/dist/parser/parser.js

@@ -5,6 +5,8 @@ export class Parser {
     tokens;
     current = 0;
     filePath;
+    errors = [];
+    panicMode = false;
     constructor(tokens, filePath) {
         this.tokens = tokens;
         this.filePath = filePath;
@@ -20,6 +22,66 @@ export class Parser {
         }
         return { kind: 'Program', statements, position: pos };
     }
+    // Parse with error recovery - collects multiple errors instead of stopping at first
+    parseWithErrors() {
+        this.errors = [];
+        const statements = [];
+        const pos = this.peek().position;
+        while (!this.isAtEnd()) {
+            try {
+                this.panicMode = false;
+                const stmt = this.parseStatement();
+                if (stmt) {
+                    statements.push(stmt);
+                }
+            }
+            catch (e) {
+                if (e instanceof MFError) {
+                    this.errors.push(e);
+                    this.synchronize();
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        const program = { kind: 'Program', statements, position: pos };
+        return { program, errors: this.errors };
+    }
+    // Synchronize after an error by skipping to the next statement boundary
+    synchronize() {
+        this.panicMode = true;
+        this.advance();
+        while (!this.isAtEnd()) {
+            // If we just passed a semicolon, we're at a statement boundary
+            if (this.previous().type === TokenType.SEMICOLON) {
+                return;
+            }
+            // If the current token starts a new statement, we're synchronized
+            switch (this.peek().type) {
+                case TokenType.PROC:
+                case TokenType.CONST:
+                case TokenType.LET:
+                case TokenType.IF:
+                case TokenType.FOR:
+                case TokenType.WHILE:
+                case TokenType.MATCH:
+                case TokenType.RETURN:
+                case TokenType.BREAK:
+                case TokenType.CONTINUE:
+                case TokenType.IMPORT:
+                case TokenType.EXPORT:
+                case TokenType.VOCAL:
+                case TokenType.MIDI:
+                    return;
+            }
+            this.advance();
+        }
+    }
+    // Get collected errors (for parseWithErrors)
+    getErrors() {
+        return this.errors;
+    }
     parseStatement() {
         if (this.check(TokenType.IMPORT)) {
             return this.parseImport();
@@ -45,6 +107,9 @@ export class Parser {
         if (this.check(TokenType.WHILE)) {
             return this.parseWhile();
         }
+        if (this.check(TokenType.MATCH)) {
+            return this.parseMatch();
+        }
         if (this.check(TokenType.RETURN)) {
             return this.parseReturn();
         }
@@ -63,7 +128,24 @@ export class Parser {
     }
     parseImport() {
         const pos = this.advance().position; // consume 'import'
-        this.expect(TokenType.LBRACE, "Expected '{' after 'import'");
+        // Check for wildcard import: import * as name from "path"
+        if (this.check(TokenType.STAR)) {
+            this.advance(); // consume '*'
+            this.expect(TokenType.AS, "Expected 'as' after '*' in import");
+            const nameToken = this.expect(TokenType.IDENT, 'Expected namespace identifier after "as"');
+            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: [],
+                namespace: nameToken.value,
+                path: pathToken.value,
+                position: pos,
+            };
+        }
+        // Named imports: import { a, b } from "path"
+        this.expect(TokenType.LBRACE, "Expected '{' or '*' after 'import'");
         const imports = [];
         if (!this.check(TokenType.RBRACE)) {
             do {
@@ -106,6 +188,7 @@ export class Parser {
         this.expect(TokenType.LPAREN, "Expected '(' after proc name");
         const params = [];
         if (!this.check(TokenType.RPAREN)) {
+            let hasDefault = false;
             do {
                 // Check for rest parameter
                 if (this.check(TokenType.SPREAD)) {
@@ -115,7 +198,18 @@ export class Parser {
                     break; // Rest must be last
                 }
                 const param = this.expect(TokenType.IDENT, 'Expected parameter name');
-                params.push({ name: param.value });
+                // Check for default value
+                if (this.match(TokenType.EQ)) {
+                    hasDefault = true;
+                    const defaultValue = this.parseExpression();
+                    params.push({ name: param.value, defaultValue });
+                }
+                else {
+                    if (hasDefault) {
+                        throw this.error('Required parameters cannot follow parameters with default values');
+                    }
+                    params.push({ name: param.value });
+                }
             } while (this.match(TokenType.COMMA));
         }
         this.expect(TokenType.RPAREN, "Expected ')' after parameters");
@@ -166,8 +260,14 @@ export class Parser {
         const consequent = this.parseBlock();
         let alternate = null;
         if (this.match(TokenType.ELSE)) {
-            this.expect(TokenType.LBRACE, "Expected '{' after 'else'");
-            alternate = this.parseBlock();
+            if (this.check(TokenType.IF)) {
+                // else if: recursively parse as nested IfStatement
+                alternate = this.parseIf();
+            }
+            else {
+                this.expect(TokenType.LBRACE, "Expected '{' after 'else'");
+                alternate = this.parseBlock();
+            }
         }
         return {
             kind: 'IfStatement',
@@ -240,6 +340,44 @@ export class Parser {
             position: pos,
         };
     }
+    parseMatch() {
+        const pos = this.advance().position; // consume 'match'
+        this.expect(TokenType.LPAREN, "Expected '(' after 'match'");
+        const expression = this.parseExpression();
+        this.expect(TokenType.RPAREN, "Expected ')' after match expression");
+        this.expect(TokenType.LBRACE, "Expected '{' before match cases");
+        const cases = [];
+        let hasDefault = false;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            if (this.check(TokenType.CASE)) {
+                this.advance(); // consume 'case'
+                const pattern = this.parseExpression();
+                this.expect(TokenType.LBRACE, "Expected '{' before case body");
+                const body = this.parseBlock();
+                cases.push({ pattern, body });
+            }
+            else if (this.check(TokenType.DEFAULT)) {
+                if (hasDefault) {
+                    throw new MFError('SYNTAX', 'Multiple default cases in match statement', this.peek().position, this.filePath);
+                }
+                this.advance(); // consume 'default'
+                this.expect(TokenType.LBRACE, "Expected '{' before default body");
+                const body = this.parseBlock();
+                cases.push({ pattern: null, body });
+                hasDefault = true;
+            }
+            else {
+                throw new MFError('SYNTAX', "Expected 'case' or 'default' in match statement", this.peek().position, this.filePath);
+            }
+        }
+        this.expect(TokenType.RBRACE, "Expected '}' after match cases");
+        return {
+            kind: 'MatchStatement',
+            expression,
+            cases,
+            position: pos,
+        };
+    }
     parseReturn() {
         const pos = this.advance().position; // consume 'return'
         let value = null;
@@ -341,10 +479,10 @@ export class Parser {
             }
             throw this.error('Invalid assignment target');
         }
-        // Compound assignment: +=, -=, *=, /=
+        // Compound assignment: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
         if (this.checkCompoundAssign()) {
             const op = this.advance().value; // e.g., '+='
-            const binaryOp = op.charAt(0); // e.g., '+'
+            const binaryOp = this.getCompoundAssignOp(op); // e.g., '+'
             const rhs = this.parseExpression();
             this.expect(TokenType.SEMICOLON, "Expected ';' after assignment");
             // Desugar: x += y  ->  x = x + y
@@ -392,16 +530,44 @@ export class Parser {
     }
     checkCompoundAssign() {
         return this.check(TokenType.PLUSEQ) || this.check(TokenType.MINUSEQ) ||
-            this.check(TokenType.STAREQ) || this.check(TokenType.SLASHEQ);
+            this.check(TokenType.STAREQ) || this.check(TokenType.SLASHEQ) ||
+            this.check(TokenType.PERCENTEQ) || this.check(TokenType.BITANDEQ) ||
+            this.check(TokenType.BITOREQ) || this.check(TokenType.BITXOREQ) ||
+            this.check(TokenType.SHLEQ) || this.check(TokenType.SHREQ);
+    }
+    getCompoundAssignOp(op) {
+        // Map compound assignment operator to its binary operator
+        const opMap = {
+            '+=': '+', '-=': '-', '*=': '*', '/=': '/', '%=': '%',
+            '&=': '&', '|=': '|', '^=': '^', '<<=': '<<', '>>=': '>>'
+        };
+        return opMap[op] || op.charAt(0);
     }
     // Expression parsing with precedence climbing
     parseExpression() {
-        return this.parseOr();
+        return this.parseConditional();
+    }
+    // Ternary operator: a ? b : c (lowest precedence)
+    parseConditional() {
+        let expr = this.parseOr();
+        if (this.match(TokenType.QUESTION)) {
+            const consequent = this.parseExpression();
+            this.expect(TokenType.COLON, "Expected ':' in ternary expression");
+            const alternate = this.parseConditional();
+            expr = {
+                kind: 'ConditionalExpression',
+                condition: expr,
+                consequent,
+                alternate,
+                position: expr.position,
+            };
+        }
+        return expr;
     }
     parseOr() {
-        let left = this.parseAnd();
+        let left = this.parseNullish();
         while (this.match(TokenType.OR)) {
-            const right = this.parseAnd();
+            const right = this.parseNullish();
             left = {
                 kind: 'BinaryExpression',
                 operator: '||',
@@ -412,10 +578,24 @@ export class Parser {
         }
         return left;
     }
+    parseNullish() {
+        let left = this.parseAnd();
+        while (this.match(TokenType.NULLISH)) {
+            const right = this.parseAnd();
+            left = {
+                kind: 'BinaryExpression',
+                operator: '??',
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
     parseAnd() {
-        let left = this.parseEquality();
+        let left = this.parseBitOr();
         while (this.match(TokenType.AND)) {
-            const right = this.parseEquality();
+            const right = this.parseBitOr();
             left = {
                 kind: 'BinaryExpression',
                 operator: '&&',
@@ -426,6 +606,48 @@ export class Parser {
         }
         return left;
     }
+    parseBitOr() {
+        let left = this.parseBitXor();
+        while (this.match(TokenType.BITOR)) {
+            const right = this.parseBitXor();
+            left = {
+                kind: 'BinaryExpression',
+                operator: '|',
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseBitXor() {
+        let left = this.parseBitAnd();
+        while (this.match(TokenType.BITXOR)) {
+            const right = this.parseBitAnd();
+            left = {
+                kind: 'BinaryExpression',
+                operator: '^',
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseBitAnd() {
+        let left = this.parseEquality();
+        while (this.match(TokenType.BITAND)) {
+            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)) {
@@ -442,11 +664,26 @@ export class Parser {
         return left;
     }
     parseComparison() {
-        let left = this.parseAdditive();
+        let left = this.parseShift();
         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.parseShift();
+            left = {
+                kind: 'BinaryExpression',
+                operator: op,
+                left,
+                right,
+                position: left.position,
+            };
+        }
+        return left;
+    }
+    parseShift() {
+        let left = this.parseAdditive();
+        while (this.check(TokenType.SHL) || this.check(TokenType.SHR)) {
             const op = this.advance().value;
             const right = this.parseAdditive();
             left = {
@@ -490,7 +727,7 @@ export class Parser {
         return left;
     }
     parseUnary() {
-        if (this.check(TokenType.NOT) || this.check(TokenType.MINUS)) {
+        if (this.check(TokenType.NOT) || this.check(TokenType.MINUS) || this.check(TokenType.BITNOT)) {
             const op = this.advance().value;
             const operand = this.parseUnary();
             return {
@@ -500,11 +737,25 @@ export class Parser {
                 position: operand.position,
             };
         }
+        // typeof operator
+        if (this.check(TokenType.TYPEOF)) {
+            const pos = this.advance().position;
+            const operand = this.parseUnary();
+            return {
+                kind: 'TypeofExpression',
+                operand,
+                position: pos,
+            };
+        }
         return this.parseCall();
     }
     parseCall() {
         let expr = this.parsePrimary();
-        while (true) {
+        // Safety limit to prevent infinite loops in pathological cases
+        const MAX_CHAIN_LENGTH = 1000;
+        let chainLength = 0;
+        while (chainLength < MAX_CHAIN_LENGTH) {
+            chainLength++;
             if (this.check(TokenType.LPAREN)) {
                 // Function call: expr(args) - supports first-class functions
                 expr = this.finishCall(expr);
@@ -518,6 +769,7 @@ export class Parser {
                     kind: 'IndexExpression',
                     object: expr,
                     index,
+                    optional: false,
                     position: pos,
                 };
             }
@@ -529,13 +781,45 @@ export class Parser {
                     kind: 'MemberExpression',
                     object: expr,
                     property: prop.value,
+                    optional: false,
                     position: pos,
                 };
             }
+            else if (this.check(TokenType.QUESTIONDOT)) {
+                // Optional chaining: expr?.property or expr?.[index]
+                const pos = this.advance().position; // consume '?.'
+                if (this.check(TokenType.LBRACKET)) {
+                    // Optional index: expr?.[index]
+                    this.advance(); // consume '['
+                    const index = this.parseExpression();
+                    this.expect(TokenType.RBRACKET, "Expected ']' after index");
+                    expr = {
+                        kind: 'IndexExpression',
+                        object: expr,
+                        index,
+                        optional: true,
+                        position: pos,
+                    };
+                }
+                else {
+                    // Optional property: expr?.property
+                    const prop = this.expect(TokenType.IDENT, 'Expected property name after "?."');
+                    expr = {
+                        kind: 'MemberExpression',
+                        object: expr,
+                        property: prop.value,
+                        optional: true,
+                        position: pos,
+                    };
+                }
+            }
             else {
                 break;
             }
         }
+        if (chainLength >= MAX_CHAIN_LENGTH) {
+            throw this.error('Expression chain too long (possible infinite loop in parser)');
+        }
         return expr;
     }
     finishCall(callee) {
@@ -611,6 +895,14 @@ export class Parser {
                 position: token.position,
             };
         }
+        // Null literal
+        if (this.check(TokenType.NULL)) {
+            this.advance();
+            return {
+                kind: 'NullLiteral',
+                position: token.position,
+            };
+        }
         // Pitch literal
         if (this.check(TokenType.PITCH)) {
             this.advance();
@@ -634,6 +926,10 @@ export class Parser {
         if (this.check(TokenType.LBRACE)) {
             return this.parseObjectLiteral();
         }
+        // Template literal
+        if (this.check(TokenType.TEMPLATE_STRING) || this.check(TokenType.TEMPLATE_HEAD)) {
+            return this.parseTemplateLiteral();
+        }
         // Identifier
         if (this.check(TokenType.IDENT)) {
             this.advance();
@@ -720,13 +1016,33 @@ export class Parser {
         };
     }
     parsePitchLiteral(token) {
-        // Parse pitch like C4, C#4, Db4
+        // Parse pitch like C4, C#4, Db4, C##4, Cx4, Cbb4
         const value = token.value;
         let idx = 0;
         const noteChar = value[idx++].toUpperCase();
         let accidental = '';
-        if (value[idx] === '#' || value[idx] === 'b') {
-            accidental = value[idx++];
+        if (value[idx] === '#') {
+            accidental = '#';
+            idx++;
+            // Check for double sharp (##)
+            if (value[idx] === '#') {
+                accidental = '##';
+                idx++;
+            }
+        }
+        else if (value[idx] === 'x') {
+            // 'x' notation for double sharp
+            accidental = '##';
+            idx++;
+        }
+        else if (value[idx] === 'b') {
+            accidental = 'b';
+            idx++;
+            // Check for double flat (bb)
+            if (value[idx] === 'b') {
+                accidental = 'bb';
+                idx++;
+            }
         }
         const octaveStr = value.slice(idx);
         const octave = parseInt(octaveStr, 10);
@@ -741,28 +1057,69 @@ export class Parser {
         };
     }
     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,
+        // Note offsets and octave adjustments for enharmonic equivalents
+        // B# = C of next octave, Cb = B of previous octave, etc.
+        const noteData = {
+            'C': { offset: 0, octaveAdjust: 0 },
+            'C#': { offset: 1, octaveAdjust: 0 },
+            'Db': { offset: 1, octaveAdjust: 0 },
+            'C##': { offset: 2, octaveAdjust: 0 },
+            'Cbb': { offset: 10, octaveAdjust: -1 }, // Cbb = Bb of previous octave
+            'D': { offset: 2, octaveAdjust: 0 },
+            'D#': { offset: 3, octaveAdjust: 0 },
+            'Eb': { offset: 3, octaveAdjust: 0 },
+            'D##': { offset: 4, octaveAdjust: 0 },
+            'Dbb': { offset: 0, octaveAdjust: 0 },
+            'E': { offset: 4, octaveAdjust: 0 },
+            'Fb': { offset: 4, octaveAdjust: 0 },
+            'E#': { offset: 5, octaveAdjust: 0 },
+            'E##': { offset: 6, octaveAdjust: 0 },
+            'Ebb': { offset: 2, octaveAdjust: 0 },
+            'F': { offset: 5, octaveAdjust: 0 },
+            'F#': { offset: 6, octaveAdjust: 0 },
+            'Gb': { offset: 6, octaveAdjust: 0 },
+            'F##': { offset: 7, octaveAdjust: 0 },
+            'Fbb': { offset: 3, octaveAdjust: 0 },
+            'G': { offset: 7, octaveAdjust: 0 },
+            'G#': { offset: 8, octaveAdjust: 0 },
+            'Ab': { offset: 8, octaveAdjust: 0 },
+            'G##': { offset: 9, octaveAdjust: 0 },
+            'Gbb': { offset: 5, octaveAdjust: 0 },
+            'A': { offset: 9, octaveAdjust: 0 },
+            'A#': { offset: 10, octaveAdjust: 0 },
+            'Bb': { offset: 10, octaveAdjust: 0 },
+            'A##': { offset: 11, octaveAdjust: 0 },
+            'Abb': { offset: 7, octaveAdjust: 0 },
+            'B': { offset: 11, octaveAdjust: 0 },
+            'Cb': { offset: 11, octaveAdjust: -1 }, // Cb = B of previous octave
+            'B#': { offset: 0, octaveAdjust: 1 }, // B# = C of next octave
+            'B##': { offset: 1, octaveAdjust: 1 }, // B## = C# of next octave
+            'Bbb': { offset: 9, octaveAdjust: 0 },
         };
-        const offset = noteOffsets[note] ?? 0;
+        const data = noteData[note] ?? { offset: 0, octaveAdjust: 0 };
         // MIDI: C4 = 60, so C0 = 12
-        return (octave + 1) * 12 + offset;
+        return (octave + 1 + data.octaveAdjust) * 12 + data.offset;
     }
     parseDurLiteral(token) {
-        // Parse duration like 1/4, 3/8
-        const [numStr, denStr] = token.value.split('/');
+        // Parse duration like 1/4, 3/8, 1/4., 1/4..
+        const value = token.value;
+        // Count trailing dots
+        let dots = 0;
+        let i = value.length - 1;
+        while (i >= 0 && value[i] === '.') {
+            dots++;
+            i--;
+        }
+        // Extract fraction part (without dots)
+        const fractionPart = value.slice(0, value.length - dots);
+        const [numStr, denStr] = fractionPart.split('/');
         const numerator = parseInt(numStr, 10);
         const denominator = parseInt(denStr, 10);
         return {
             kind: 'DurLiteral',
             numerator,
             denominator,
+            dots,
             position: token.position,
         };
     }
@@ -844,6 +1201,53 @@ export class Parser {
             position: pos,
         };
     }
+    parseTemplateLiteral() {
+        const pos = this.peek().position;
+        const quasis = [];
+        const expressions = [];
+        // Simple template string without interpolation
+        if (this.check(TokenType.TEMPLATE_STRING)) {
+            quasis.push(this.advance().value);
+            return {
+                kind: 'TemplateLiteral',
+                quasis,
+                expressions,
+                position: pos,
+            };
+        }
+        // Template with interpolation
+        // Head: `text${
+        quasis.push(this.advance().value);
+        // Parse expressions and middle/tail parts
+        // Safety limit to prevent infinite loops
+        const MAX_TEMPLATE_PARTS = 1000;
+        let partCount = 0;
+        while (partCount < MAX_TEMPLATE_PARTS) {
+            partCount++;
+            // Parse expression between ${ and }
+            expressions.push(this.parseExpression());
+            // Expect TEMPLATE_MIDDLE or TEMPLATE_TAIL
+            if (this.check(TokenType.TEMPLATE_MIDDLE)) {
+                quasis.push(this.advance().value);
+            }
+            else if (this.check(TokenType.TEMPLATE_TAIL)) {
+                quasis.push(this.advance().value);
+                break;
+            }
+            else {
+                throw this.error('Expected template continuation');
+            }
+        }
+        if (partCount >= MAX_TEMPLATE_PARTS) {
+            throw this.error('Template literal has too many parts (possible infinite loop)');
+        }
+        return {
+            kind: 'TemplateLiteral',
+            quasis,
+            expressions,
+            position: pos,
+        };
+    }
     // Helper methods
     peek() {
         return this.tokens[this.current];
@@ -861,6 +1265,9 @@ export class Parser {
         }
         return this.tokens[this.current - 1];
     }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
     check(type) {
         if (this.isAtEnd())
             return false;