takomusic 1.2.0 → 1.3.1

package/dist/interpreter/interpreter.js

@@ -94,6 +94,10 @@ export class Interpreter {
     registerConst(name, value) {
         this.scope.defineConst(name, value);
     }
+    // Get the global scope (for namespace imports)
+    getGlobalScope() {
+        return this.scope;
+    }
     execute(program) {
         // First pass: collect all proc declarations from this module
         for (const stmt of program.statements) {
@@ -156,11 +160,18 @@ export class Interpreter {
                     this.scope = oldScope;
                 }
                 else if (stmt.alternate) {
-                    const childScope = this.scope.createChild();
-                    const oldScope = this.scope;
-                    this.scope = childScope;
-                    this.executeStatements(stmt.alternate);
-                    this.scope = oldScope;
+                    if (Array.isArray(stmt.alternate)) {
+                        // else: alternate is Statement[]
+                        const childScope = this.scope.createChild();
+                        const oldScope = this.scope;
+                        this.scope = childScope;
+                        this.executeStatements(stmt.alternate);
+                        this.scope = oldScope;
+                    }
+                    else {
+                        // else if: alternate is a single IfStatement
+                        this.executeStatement(stmt.alternate);
+                    }
                 }
                 break;
             }
@@ -229,6 +240,46 @@ export class Interpreter {
                 }
                 break;
             }
+            case 'MatchStatement': {
+                const matchValue = this.evaluate(stmt.expression);
+                let matched = false;
+                let defaultCase = null;
+                for (const matchCase of stmt.cases) {
+                    if (matchCase.pattern === null) {
+                        // Store default case for later
+                        defaultCase = matchCase;
+                        continue;
+                    }
+                    const caseValue = this.evaluate(matchCase.pattern);
+                    if (this.valuesEqual(matchValue, caseValue)) {
+                        // Execute the matching case
+                        const childScope = this.scope.createChild();
+                        const oldScope = this.scope;
+                        this.scope = childScope;
+                        try {
+                            this.executeStatements(matchCase.body);
+                        }
+                        finally {
+                            this.scope = oldScope;
+                        }
+                        matched = true;
+                        break;
+                    }
+                }
+                // If no case matched, execute default case if present
+                if (!matched && defaultCase) {
+                    const childScope = this.scope.createChild();
+                    const oldScope = this.scope;
+                    this.scope = childScope;
+                    try {
+                        this.executeStatements(defaultCase.body);
+                    }
+                    finally {
+                        this.scope = oldScope;
+                    }
+                }
+                break;
+            }
             case 'ReturnStatement': {
                 const value = stmt.value ? this.evaluate(stmt.value) : makeNull();
                 throw new ReturnSignal(value);
@@ -271,10 +322,23 @@ export class Interpreter {
             }
             case 'ForEachStatement': {
                 const iterable = this.evaluate(stmt.iterable);
-                if (iterable.type !== 'array') {
-                    throw createError('E400', 'For-each requires an array', stmt.position, this.filePath);
+                // Build the list of elements to iterate over
+                let elements = [];
+                if (iterable.type === 'array') {
+                    elements = iterable.elements;
                 }
-                for (const element of iterable.elements) {
+                else if (iterable.type === 'string') {
+                    // Iterate over characters
+                    elements = [...iterable.value].map(c => makeString(c));
+                }
+                else if (iterable.type === 'object') {
+                    // Iterate over keys
+                    elements = [...iterable.properties.keys()].map(k => makeString(k));
+                }
+                else {
+                    throw createError('E400', `Cannot iterate over type '${iterable.type}'`, stmt.position, this.filePath);
+                }
+                for (const element of elements) {
                     const childScope = this.scope.createChild();
                     childScope.defineConst(stmt.variable, element);
                     const oldScope = this.scope;
@@ -389,6 +453,8 @@ export class Interpreter {
                 return makeString(expr.value);
             case 'BoolLiteral':
                 return makeBool(expr.value);
+            case 'NullLiteral':
+                return makeNull();
             case 'PitchLiteral':
                 return makePitch(expr.midi);
             case 'DurLiteral':
@@ -396,7 +462,7 @@ export class Interpreter {
                 if (expr.numerator <= 0 || expr.denominator <= 0) {
                     throw new MFError('E101', `Invalid duration: ${expr.numerator}/${expr.denominator} (must be positive)`, expr.position, this.filePath);
                 }
-                return makeDur(expr.numerator, expr.denominator);
+                return makeDur(expr.numerator, expr.denominator, expr.dots);
             case 'TimeLiteral':
                 return makeTime(expr.bar, expr.beat, expr.sub);
             case 'ArrayLiteral': {
@@ -430,6 +496,10 @@ export class Interpreter {
                 return this.evaluateCall(expr.callee, expr.arguments, expr.position);
             case 'IndexExpression': {
                 const obj = this.evaluate(expr.object);
+                // Optional chaining: return null if object is null
+                if (expr.optional && obj.type === 'null') {
+                    return makeNull();
+                }
                 const idx = this.evaluate(expr.index);
                 if (obj.type === 'array') {
                     if (idx.type !== 'int') {
@@ -482,6 +552,10 @@ export class Interpreter {
             }
             case 'MemberExpression': {
                 const obj = this.evaluate(expr.object);
+                // Optional chaining: return null if object is null
+                if (expr.optional && obj.type === 'null') {
+                    return makeNull();
+                }
                 if (obj.type === 'object') {
                     const value = obj.properties.get(expr.property);
                     return value ?? makeNull();
@@ -500,20 +574,59 @@ export class Interpreter {
                 throw createError('E400', 'Spread element not allowed here', expr.position, this.filePath);
             case 'RangeExpression':
                 throw new Error(`${expr.kind} cannot be evaluated as expression`);
+            case 'ConditionalExpression':
+                // Ternary operator: condition ? consequent : alternate
+                return isTruthy(this.evaluate(expr.condition))
+                    ? this.evaluate(expr.consequent)
+                    : this.evaluate(expr.alternate);
+            case 'TemplateLiteral': {
+                // Template literal: `Hello ${name}!`
+                let result = '';
+                for (let i = 0; i < expr.quasis.length; i++) {
+                    result += expr.quasis[i];
+                    if (i < expr.expressions.length) {
+                        const val = this.evaluate(expr.expressions[i]);
+                        result += toString(val);
+                    }
+                }
+                return makeString(result);
+            }
+            case 'TypeofExpression': {
+                const val = this.evaluate(expr.operand);
+                return makeString(val.type);
+            }
             default:
                 throw new Error(`Unknown expression kind: ${expr.kind}`);
         }
     }
     evaluateBinary(op, leftExpr, rightExpr) {
-        const left = this.evaluate(leftExpr);
-        const right = this.evaluate(rightExpr);
-        // Short-circuit evaluation for logical operators
+        // Short-circuit evaluation for logical operators - evaluate right side only if needed
         if (op === '&&') {
-            return makeBool(isTruthy(left) && isTruthy(right));
+            const left = this.evaluate(leftExpr);
+            if (!isTruthy(left)) {
+                return makeBool(false);
+            }
+            const right = this.evaluate(rightExpr);
+            return makeBool(isTruthy(right));
         }
         if (op === '||') {
-            return makeBool(isTruthy(left) || isTruthy(right));
+            const left = this.evaluate(leftExpr);
+            if (isTruthy(left)) {
+                return makeBool(true);
+            }
+            const right = this.evaluate(rightExpr);
+            return makeBool(isTruthy(right));
+        }
+        // Nullish coalescing: return left if not null, else evaluate right
+        if (op === '??') {
+            const left = this.evaluate(leftExpr);
+            if (left.type !== 'null') {
+                return left;
+            }
+            return this.evaluate(rightExpr);
         }
+        const left = this.evaluate(leftExpr);
+        const right = this.evaluate(rightExpr);
         // Comparison operators
         if (op === '==' || op === '!=') {
             const equal = this.valuesEqual(left, right);
@@ -586,15 +699,21 @@ export class Interpreter {
         if (op === '/') {
             // Dur / Int
             if (left.type === 'dur' && right.type === 'int') {
+                if (right.value === 0) {
+                    throw createError('E400', 'Division by zero', leftExpr.position, this.filePath);
+                }
                 const den = left.denominator * right.value;
                 const gcd = this.gcd(left.numerator, den);
+                if (gcd === 0) {
+                    throw createError('E400', 'Division by zero in duration calculation', leftExpr.position, this.filePath);
+                }
                 return makeDur(left.numerator / gcd, den / gcd);
             }
             // Numeric
             const l = toNumber(left);
             const r = toNumber(right);
             if (r === 0) {
-                throw new Error('Division by zero');
+                throw createError('E400', 'Division by zero', rightExpr.position, this.filePath);
             }
             // Division always returns float unless both are int and divide evenly
             if (left.type === 'int' && right.type === 'int' && l % r === 0) {
@@ -606,14 +725,40 @@ export class Interpreter {
             const l = toNumber(left);
             const r = toNumber(right);
             if (r === 0) {
-                throw new Error('Modulo by zero');
+                throw createError('E400', 'Modulo by zero', rightExpr.position, this.filePath);
             }
             if (left.type === 'int' && right.type === 'int') {
                 return makeInt(l % r);
             }
             return makeFloat(l % r);
         }
-        throw new Error(`Unknown binary operator: ${op}`);
+        // Bitwise operators (only work on integers)
+        if (op === '&') {
+            const l = Math.trunc(toNumber(left));
+            const r = Math.trunc(toNumber(right));
+            return makeInt(l & r);
+        }
+        if (op === '|') {
+            const l = Math.trunc(toNumber(left));
+            const r = Math.trunc(toNumber(right));
+            return makeInt(l | r);
+        }
+        if (op === '^') {
+            const l = Math.trunc(toNumber(left));
+            const r = Math.trunc(toNumber(right));
+            return makeInt(l ^ r);
+        }
+        if (op === '<<') {
+            const l = Math.trunc(toNumber(left));
+            const r = Math.trunc(toNumber(right));
+            return makeInt(l << r);
+        }
+        if (op === '>>') {
+            const l = Math.trunc(toNumber(left));
+            const r = Math.trunc(toNumber(right));
+            return makeInt(l >> r);
+        }
+        throw createError('E400', `Unknown binary operator: ${op}`, leftExpr.position, this.filePath);
     }
     evaluateUnary(op, operandExpr) {
         const operand = this.evaluate(operandExpr);
@@ -624,7 +769,11 @@ export class Interpreter {
             const n = toNumber(operand);
             return operand.type === 'float' ? makeFloat(-n) : makeInt(-n);
         }
-        throw new Error(`Unknown unary operator: ${op}`);
+        if (op === '~') {
+            const n = Math.trunc(toNumber(operand));
+            return makeInt(~n);
+        }
+        throw createError('E400', `Unknown unary operator: ${op}`, operandExpr.position, this.filePath);
     }
     evaluateCall(calleeExpr, args, position) {
         // Helper to expand arguments (handle spread)
@@ -1299,15 +1448,17 @@ export class Interpreter {
                         throw createError('E400', 'substr() requires at least 2 arguments', position, this.filePath);
                     }
                     const str = this.evaluate(args[0]);
-                    const start = toNumber(this.evaluate(args[1]));
-                    const length = args.length > 2 ? toNumber(this.evaluate(args[2])) : undefined;
+                    const startIdx = Math.floor(toNumber(this.evaluate(args[1])));
+                    const length = args.length > 2 ? Math.floor(toNumber(this.evaluate(args[2]))) : undefined;
                     if (str.type !== 'string') {
                         throw createError('E400', 'substr() first argument must be a string', position, this.filePath);
                     }
+                    // Handle negative start index (from end of string)
+                    const actualStart = startIdx < 0 ? Math.max(0, str.value.length + startIdx) : startIdx;
                     if (length !== undefined) {
-                        return makeString(str.value.substr(start, length));
+                        return makeString(str.value.substring(actualStart, actualStart + length));
                     }
-                    return makeString(str.value.substr(start));
+                    return makeString(str.value.substring(actualStart));
                 }
                 case 'indexOf': {
                     // indexOf(str, search) - returns index or -1
@@ -1568,6 +1719,12 @@ export class Interpreter {
                     if (step === 0) {
                         throw createError('E400', 'range() step cannot be 0', position, this.filePath);
                     }
+                    // Check iteration limit to prevent memory exhaustion
+                    const maxRangeSize = 1000000; // 1 million elements max
+                    const expectedSize = Math.abs(Math.ceil((end - start) / step));
+                    if (expectedSize > maxRangeSize) {
+                        throw createError('E401', `range() would create ${expectedSize} elements, exceeding limit of ${maxRangeSize}`, position, this.filePath);
+                    }
                     const result = [];
                     if (step > 0) {
                         for (let i = start; i < end; i += step) {
@@ -2306,10 +2463,10 @@ export class Interpreter {
             // User-defined proc
             const proc = this.scope.lookupProc(callee);
             if (proc) {
-                // Track recursion depth
+                // Track recursion depth (relaxed from 100 to 1000)
                 const currentDepth = this.callStack.get(callee) || 0;
-                if (currentDepth >= 100) {
-                    throw createError('E310', `Maximum recursion depth exceeded in '${callee}'`, position, this.filePath);
+                if (currentDepth >= 1000) {
+                    throw new MFError('E310', `Maximum recursion depth (1000) exceeded in '${callee}'`, position, this.filePath);
                 }
                 this.callStack.set(callee, currentDepth + 1);
                 // Create scope with parameters
@@ -2359,7 +2516,10 @@ export class Interpreter {
     callFunctionValue(fn, evalArgs, position) {
         // Create new scope chained to closure scope (not current scope!)
         const callScope = fn.closure.createChild();
-        // Bind parameters
+        // Bind parameters (with default value support)
+        // We need to evaluate defaults in the call scope so they can reference earlier params
+        const oldScope = this.scope;
+        this.scope = callScope;
         for (let i = 0; i < fn.params.length; i++) {
             const param = fn.params[i];
             if (param.rest) {
@@ -2367,11 +2527,21 @@ export class Interpreter {
                 callScope.defineConst(param.name, makeArray(evalArgs.slice(i)));
                 break;
             }
-            const value = i < evalArgs.length ? evalArgs[i] : makeNull();
+            let value;
+            if (i < evalArgs.length) {
+                value = evalArgs[i];
+            }
+            else if (param.defaultValue) {
+                // Evaluate default value in call scope (can reference earlier params)
+                value = this.evaluate(param.defaultValue);
+            }
+            else {
+                value = makeNull();
+            }
             callScope.defineConst(param.name, value);
         }
-        const oldScope = this.scope;
-        this.scope = callScope;
+        // Scope is already set to callScope for default value evaluation
+        // Keep it that way for body execution
         let result = makeNull();
         try {
             if (Array.isArray(fn.body)) {