@lewin671/python-vm 0.1.2 → 0.1.3

package/dist/vm/execution.js

@@ -1,283 +1,792 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeBlock = exports.executeStatementGenerator = exports.executeBlockGenerator = exports.executeStatement = exports.evaluateExpression = exports.matchPattern = exports.applyBindings = exports.matchValueEquals = exports.iterableToArray = exports.applyCompare = void 0;
 exports.execute = execute;
-exports.executeBlock = executeBlock;
-exports.iterableToArray = iterableToArray;
-exports.matchValueEquals = matchValueEquals;
-exports.matchPattern = matchPattern;
-exports.applyBindings = applyBindings;
-exports.executeBlockGenerator = executeBlockGenerator;
-exports.executeStatementGenerator = executeStatementGenerator;
+exports.executeFrame = executeFrame;
 const types_1 = require("../types");
 const runtime_types_1 = require("./runtime-types");
-const runtime_types_2 = require("./runtime-types");
 function execute(bytecode) {
-    if (!bytecode.ast) {
-        throw new Error('Bytecode missing AST');
-    }
     const globalScope = new runtime_types_1.Scope();
     this.installBuiltins(globalScope);
-    return this.executeBlock(bytecode.ast.body, globalScope);
-}
-function executeBlock(body, scope) {
-    let lastValue = null;
-    for (const stmt of body) {
-        lastValue = this.executeStatement(stmt, scope);
-    }
-    return lastValue;
-}
-function iterableToArray(iterable) {
-    if (iterable instanceof runtime_types_2.PyDict)
-        return Array.from(iterable.keys());
-    if (iterable instanceof Set)
-        return Array.from(iterable.values());
-    if (Array.isArray(iterable))
-        return iterable;
-    if (iterable && typeof iterable[Symbol.iterator] === 'function')
-        return Array.from(iterable);
-    throw new Error('Object is not iterable');
+    const frame = new runtime_types_1.Frame(bytecode, globalScope);
+    return this.executeFrame(frame);
 }
-function matchValueEquals(left, right) {
-    if (Array.isArray(left) && Array.isArray(right)) {
-        if (left.length !== right.length)
-            return false;
-        for (let i = 0; i < left.length; i++) {
-            if (!matchValueEquals(left[i], right[i]))
-                return false;
-        }
-        return true;
-    }
-    if (left instanceof Map && right instanceof Map) {
-        if (left.size !== right.size)
-            return false;
-        for (const [k, v] of left.entries()) {
-            if (!right.has(k) || !matchValueEquals(v, right.get(k)))
-                return false;
+function executeFrame(frame) {
+    const { instructions, constants, names, varnames } = frame.bytecode;
+    // console.log('Executing frame with names:', names);
+    // Populate scope with globals and nonlocals from bytecode
+    if (frame.bytecode.globals) {
+        for (const name of frame.bytecode.globals) {
+            frame.scope.globals.add(name);
         }
-        return true;
     }
-    return left === right;
-}
-function matchPattern(node, value, scope) {
-    switch (node.type) {
-        case types_1.ASTNodeType.MATCH_PATTERN_VALUE:
-            return { matched: matchValueEquals(value, this.evaluateExpression(node.value, scope)), bindings: new Map() };
-        case types_1.ASTNodeType.MATCH_PATTERN_WILDCARD:
-            return { matched: true, bindings: new Map() };
-        case types_1.ASTNodeType.MATCH_PATTERN_CAPTURE:
-            return { matched: true, bindings: new Map([[node.name, value]]) };
-        case types_1.ASTNodeType.MATCH_PATTERN_OR: {
-            for (const pattern of node.patterns || []) {
-                const result = this.matchPattern(pattern, value, scope);
-                if (result.matched)
-                    return result;
-            }
-            return { matched: false, bindings: new Map() };
-        }
-        case types_1.ASTNodeType.MATCH_PATTERN_SEQUENCE: {
-            const elements = node.elements || node.patterns;
-            if (!Array.isArray(value) || !elements || elements.length !== value.length) {
-                return { matched: false, bindings: new Map() };
-            }
-            const bindings = new Map();
-            for (let i = 0; i < elements.length; i++) {
-                const result = this.matchPattern(elements[i], value[i], scope);
-                if (!result.matched)
-                    return { matched: false, bindings: new Map() };
-                for (const [k, v] of result.bindings.entries())
-                    bindings.set(k, v);
-            }
-            return { matched: true, bindings };
-        }
-        case 'MatchValue':
-            return { matched: matchValueEquals(value, node.value), bindings: new Map() };
-        case 'MatchSingleton':
-            return { matched: value === node.value, bindings: new Map() };
-        case 'MatchSequence': {
-            if (!Array.isArray(value))
-                return { matched: false, bindings: new Map() };
-            if (!node.patterns || node.patterns.length !== value.length)
-                return { matched: false, bindings: new Map() };
-            const bindings = new Map();
-            for (let i = 0; i < node.patterns.length; i++) {
-                const result = this.matchPattern(node.patterns[i], value[i], scope);
-                if (!result.matched)
-                    return { matched: false, bindings: new Map() };
-                for (const [k, v] of result.bindings.entries())
-                    bindings.set(k, v);
-            }
-            return { matched: true, bindings };
-        }
-        case 'MatchMapping': {
-            if (!(value instanceof runtime_types_2.PyDict))
-                return { matched: false, bindings: new Map() };
-            const bindings = new Map();
-            for (const { key, pattern } of node.keys) {
-                if (!value.has(key))
-                    return { matched: false, bindings: new Map() };
-                const result = this.matchPattern(pattern, value.get(key), scope);
-                if (!result.matched)
-                    return { matched: false, bindings: new Map() };
-                for (const [k, v] of result.bindings.entries())
-                    bindings.set(k, v);
-            }
-            return { matched: true, bindings };
-        }
-        case 'MatchAs':
-            return {
-                matched: true,
-                bindings: node.name ? new Map([[node.name, value]]) : new Map(),
-            };
-        case 'MatchClass': {
-            if (!value || !value.klass || value.klass.name !== node.className)
-                return { matched: false, bindings: new Map() };
-            const bindings = new Map();
-            for (let i = 0; i < node.patterns.length; i++) {
-                const attrName = node.kwd_attrs[i] || node.patterns[i].name;
-                const attrValue = value.attributes.get(attrName);
-                const result = this.matchPattern(node.patterns[i], attrValue, scope);
-                if (!result.matched)
-                    return { matched: false, bindings: new Map() };
-                for (const [k, v] of result.bindings.entries())
-                    bindings.set(k, v);
-            }
-            return { matched: true, bindings };
+    if (frame.bytecode.nonlocals) {
+        for (const name of frame.bytecode.nonlocals) {
+            frame.scope.nonlocals.add(name);
         }
-        default:
-            return { matched: false, bindings: new Map() };
     }
-}
-function applyBindings(bindings, scope) {
-    for (const [name, value] of bindings.entries()) {
-        scope.set(name, value);
-    }
-}
-function* executeBlockGenerator(body, scope) {
-    for (const stmt of body) {
-        yield* this.executeStatementGenerator(stmt, scope);
-    }
-    return null;
-}
-function* executeStatementGenerator(node, scope) {
-    switch (node.type) {
-        case types_1.ASTNodeType.EXPRESSION_STATEMENT: {
-            if (this.expressionHasYield(node.expression)) {
-                yield* this.evaluateExpressionGenerator(node.expression, scope);
-                return null;
-            }
-            this.evaluateExpression(node.expression, scope);
-            return null;
-        }
-        case types_1.ASTNodeType.ASSIGNMENT: {
-            const value = this.expressionHasYield(node.value)
-                ? yield* this.evaluateExpressionGenerator(node.value, scope)
-                : this.evaluateExpression(node.value, scope);
-            for (const target of node.targets) {
-                this.assignTarget(target, value, scope);
-            }
-            return null;
-        }
-        case types_1.ASTNodeType.IF_STATEMENT: {
-            const test = this.expressionHasYield(node.test)
-                ? yield* this.evaluateExpressionGenerator(node.test, scope)
-                : this.evaluateExpression(node.test, scope);
-            if (this.isTruthy(test, scope)) {
-                yield* this.executeBlockGenerator(node.body, scope);
-                return null;
+    let lastValue = null;
+    const renderFString = (template, scope) => {
+        return template.replace(/\{([^}]+)\}/g, (_m, expr) => {
+            const { rawExpr, rawSpec } = this.splitFormatSpec(expr);
+            // Create a temporary scope that includes local variables for f-string evaluation
+            const evalScope = new runtime_types_1.Scope(scope);
+            if (varnames) {
+                for (let i = 0; i < varnames.length; i++) {
+                    const varname = varnames[i];
+                    if (varname === undefined)
+                        continue;
+                    if (scope.values.has(varname)) {
+                        const val = scope.values.get(varname);
+                        if (process.env['DEBUG_NONLOCAL']) {
+                            console.log(`renderFString: varname=${varname}, scope.values.get=${val}`);
+                        }
+                        evalScope.values.set(varname, val);
+                    }
+                    else if (frame.locals[i] !== undefined) {
+                        if (process.env['DEBUG_NONLOCAL']) {
+                            console.log(`renderFString: varname=${varname}, frame.locals[${i}]=${frame.locals[i]}`);
+                        }
+                        evalScope.values.set(varname, frame.locals[i]);
+                    }
+                }
             }
-            for (const branch of node.elifs) {
-                const branchTest = this.expressionHasYield(branch.test)
-                    ? yield* this.evaluateExpressionGenerator(branch.test, scope)
-                    : this.evaluateExpression(branch.test, scope);
-                if (this.isTruthy(branchTest, scope)) {
-                    yield* this.executeBlockGenerator(branch.body, scope);
-                    return null;
+            const inner = this.evaluateExpressionString(rawExpr.trim(), evalScope);
+            return this.applyFormatSpec(inner, rawSpec ? rawSpec.trim() : '');
+        });
+    };
+    const normalizeThrown = (err) => {
+        if (err instanceof runtime_types_1.PyException) {
+            try {
+                const klass = frame.scope.get(err.pyType);
+                if (klass instanceof runtime_types_1.PyClass) {
+                    const inst = new runtime_types_1.PyInstance(klass);
+                    if (err.message)
+                        inst.attributes.set('message', err.message);
+                    return inst;
                 }
             }
-            if (node.orelse?.length) {
-                yield* this.executeBlockGenerator(node.orelse, scope);
+            catch {
+                // Ignore normalization failures
             }
-            return null;
         }
-        case types_1.ASTNodeType.WHILE_STATEMENT: {
-            while (true) {
-                const test = this.expressionHasYield(node.test)
-                    ? yield* this.evaluateExpressionGenerator(node.test, scope)
-                    : this.evaluateExpression(node.test, scope);
-                if (!this.isTruthy(test, scope))
-                    break;
-                try {
-                    yield* this.executeBlockGenerator(node.body, scope);
-                }
-                catch (err) {
-                    if (err instanceof runtime_types_1.BreakSignal)
-                        break;
-                    if (err instanceof runtime_types_1.ContinueSignal)
-                        continue;
-                    throw err;
+        return err;
+    };
+    const dispatchException = (err) => {
+        if (frame.blockStack.length === 0)
+            return false;
+        const block = frame.blockStack.pop();
+        frame.stack.length = block.stackHeight;
+        frame.stack.push(normalizeThrown(err));
+        frame.pc = block.handler;
+        return true;
+    };
+    while (frame.pc < instructions.length) {
+        const instr = instructions[frame.pc++];
+        if (!instr)
+            break;
+        const { opcode, arg } = instr;
+        try {
+            switch (opcode) {
+                case types_1.OpCode.LOAD_CONST:
+                    {
+                        const val = constants[arg];
+                        if (val && typeof val === 'object' && typeof val.__fstring__ === 'string') {
+                            frame.stack.push(renderFString(val.__fstring__, frame.scope));
+                        }
+                        else {
+                            frame.stack.push(val);
+                        }
+                    }
+                    break;
+                case types_1.OpCode.LOAD_NAME: {
+                    const name = names[arg];
+                    const val = frame.scope.get(name);
+                    // console.log(`LOAD_NAME ${name} -> ${val}`);
+                    frame.stack.push(val);
+                    break;
                 }
-            }
-            return null;
-        }
-        case types_1.ASTNodeType.FOR_STATEMENT: {
-            const iterable = this.expressionHasYield(node.iter)
-                ? yield* this.evaluateExpressionGenerator(node.iter, scope)
-                : this.evaluateExpression(node.iter, scope);
-            const items = this.iterableToArray(iterable);
-            for (const item of items) {
-                this.assignTarget(node.target, item, scope);
-                try {
-                    yield* this.executeBlockGenerator(node.body, scope);
-                }
-                catch (err) {
-                    if (err instanceof runtime_types_1.BreakSignal)
+                case types_1.OpCode.STORE_NAME:
+                    frame.scope.set(names[arg], frame.stack.pop());
+                    break;
+                case types_1.OpCode.LOAD_GLOBAL: {
+                    const name = names[arg];
+                    // Find the global (topmost) scope
+                    let globalScope = frame.scope;
+                    while (globalScope.parent !== null) {
+                        globalScope = globalScope.parent;
+                    }
+                    const val = globalScope.get(name);
+                    frame.stack.push(val);
+                    break;
+                }
+                case types_1.OpCode.STORE_GLOBAL: {
+                    const name = names[arg];
+                    // Find the global (topmost) scope
+                    let globalScope = frame.scope;
+                    while (globalScope.parent !== null) {
+                        globalScope = globalScope.parent;
+                    }
+                    globalScope.set(name, frame.stack.pop());
+                    break;
+                }
+                case types_1.OpCode.LOAD_FAST: {
+                    const varname = varnames[arg];
+                    if (varname !== undefined && frame.scope.values.has(varname)) {
+                        const val = frame.scope.values.get(varname);
+                        frame.locals[arg] = val;
+                        frame.stack.push(val);
                         break;
-                    if (err instanceof runtime_types_1.ContinueSignal)
-                        continue;
-                    throw err;
+                    }
+                    const val = frame.locals[arg];
+                    if (val === undefined) {
+                        throw new runtime_types_1.PyException('UnboundLocalError', `local variable '${varname}' referenced before assignment`);
+                    }
+                    frame.stack.push(val);
+                    break;
                 }
-            }
-            return null;
-        }
-        case types_1.ASTNodeType.MATCH_STATEMENT: {
-            const subject = this.expressionHasYield(node.subject)
-                ? yield* this.evaluateExpressionGenerator(node.subject, scope)
-                : this.evaluateExpression(node.subject, scope);
-            for (const matchCase of node.cases) {
-                const result = this.matchPattern(matchCase.pattern, subject, scope);
-                if (!result.matched)
-                    continue;
-                if (matchCase.guard) {
-                    const guardScope = new runtime_types_1.Scope(scope);
-                    this.applyBindings(result.bindings, guardScope);
-                    const guardValue = this.expressionHasYield(matchCase.guard)
-                        ? yield* this.evaluateExpressionGenerator(matchCase.guard, guardScope)
-                        : this.evaluateExpression(matchCase.guard, guardScope);
-                    if (!this.isTruthy(guardValue, scope))
-                        continue;
+                case types_1.OpCode.STORE_FAST: {
+                    const val = frame.stack.pop();
+                    frame.locals[arg] = val;
+                    if (varnames && varnames[arg] !== undefined) {
+                        frame.scope.values.set(varnames[arg], val);
+                    }
+                    break;
+                }
+                case types_1.OpCode.UNPACK_SEQUENCE: {
+                    const seq = frame.stack.pop();
+                    const items = Array.isArray(seq) ? seq : Array.from(seq);
+                    if (items.length !== arg) {
+                        throw new runtime_types_1.PyException('ValueError', `not enough values to unpack (expected ${arg}, got ${items.length})`);
+                    }
+                    for (let i = items.length - 1; i >= 0; i--) {
+                        frame.stack.push(items[i]);
+                    }
+                    break;
+                }
+                case types_1.OpCode.UNPACK_EX: {
+                    const seq = frame.stack.pop();
+                    const items = Array.isArray(seq) ? seq : Array.from(seq);
+                    const beforeCount = (arg >> 8) & 0xff;
+                    const afterCount = arg & 0xff;
+                    if (items.length < beforeCount + afterCount) {
+                        throw new runtime_types_1.PyException('ValueError', 'not enough values to unpack');
+                    }
+                    const middle = items.slice(beforeCount, items.length - afterCount);
+                    // Push in reverse order of assignment popping:
+                    // suffix values (last..first), then middle list, then prefix values (last..first).
+                    for (let i = afterCount - 1; i >= 0; i--) {
+                        frame.stack.push(items[items.length - afterCount + i]);
+                    }
+                    frame.stack.push(middle);
+                    for (let i = beforeCount - 1; i >= 0; i--) {
+                        frame.stack.push(items[i]);
+                    }
+                    break;
+                }
+                case types_1.OpCode.LOAD_ATTR: {
+                    const obj = frame.stack.pop();
+                    frame.stack.push(this.getAttribute(obj, names[arg], frame.scope));
+                    break;
+                }
+                case types_1.OpCode.STORE_ATTR: {
+                    const val = frame.stack.pop();
+                    const obj = frame.stack.pop();
+                    this.setAttribute(obj, names[arg], val);
+                    break;
+                }
+                case types_1.OpCode.LOAD_SUBSCR: {
+                    const index = frame.stack.pop();
+                    const obj = frame.stack.pop();
+                    frame.stack.push(this.getSubscript(obj, index));
+                    break;
+                }
+                case types_1.OpCode.STORE_SUBSCR: {
+                    const index = frame.stack.pop();
+                    const obj = frame.stack.pop();
+                    const val = frame.stack.pop();
+                    // Check if object is a tuple (immutable)
+                    if (Array.isArray(obj) && obj.__tuple__) {
+                        throw new runtime_types_1.PyException('TypeError', `'tuple' object does not support item assignment`);
+                    }
+                    if (Array.isArray(obj)) {
+                        // Handle slice assignment
+                        if (index && (index.__slice__ || index.type === types_1.ASTNodeType.SLICE)) {
+                            const start = index.start !== undefined ? index.start : null;
+                            const end = index.end !== undefined ? index.end : null;
+                            const step = index.step !== undefined ? index.step : 1;
+                            const bounds = this.computeSliceBounds(obj.length, start, end, step);
+                            const indices = this.computeSliceIndices(obj.length, start, end, step);
+                            // For extended slices (step != 1), replacement must have same length
+                            if (bounds.step !== 1) {
+                                if (!Array.isArray(val) || val.length !== indices.length) {
+                                    throw new runtime_types_1.PyException('ValueError', `attempt to assign sequence of size ${Array.isArray(val) ? val.length : 1} to extended slice of size ${indices.length}`);
+                                }
+                                for (let i = 0; i < indices.length; i++) {
+                                    obj[indices[i]] = val[i];
+                                }
+                            }
+                            else {
+                                // Simple slice: replace the slice with the new values
+                                const valArray = Array.isArray(val) ? val : [val];
+                                obj.splice(bounds.start, indices.length, ...valArray);
+                            }
+                        }
+                        else {
+                            obj[index] = val;
+                        }
+                    }
+                    else if (obj instanceof runtime_types_1.PyDict) {
+                        obj.set(index, val);
+                    }
+                    else {
+                        throw new runtime_types_1.PyException('TypeError', `'${typeof obj}' object does not support item assignment`);
+                    }
+                    break;
+                }
+                case types_1.OpCode.DELETE_SUBSCR: {
+                    const index = frame.stack.pop();
+                    const obj = frame.stack.pop();
+                    if (Array.isArray(obj)) {
+                        if (index && (index.__slice__ || index.type === types_1.ASTNodeType.SLICE)) {
+                            const start = index.start !== undefined ? index.start : null;
+                            const end = index.end !== undefined ? index.end : null;
+                            const step = index.step !== undefined ? index.step : 1;
+                            const bounds = this.computeSliceBounds(obj.length, start, end, step);
+                            // Standard deletion of slice
+                            if (bounds.step === 1) {
+                                obj.splice(bounds.start, bounds.end - bounds.start);
+                            }
+                            else {
+                                // Deleting with step != 1
+                                const indices = this.computeSliceIndices(obj.length, start, end, step);
+                                // We must delete from back to front to avoid index shifting problems
+                                indices.sort((a, b) => b - a);
+                                for (const idx of indices) {
+                                    obj.splice(idx, 1);
+                                }
+                            }
+                        }
+                        else {
+                            if (typeof index !== 'number') {
+                                throw new runtime_types_1.PyException('TypeError', 'list indices must be integers or slices');
+                            }
+                            obj.splice(index, 1);
+                        }
+                    }
+                    else if (obj instanceof runtime_types_1.PyDict) {
+                        obj.delete(index);
+                    }
+                    else if (obj instanceof runtime_types_1.PySet) {
+                        obj.delete(index);
+                    }
+                    else {
+                        throw new runtime_types_1.PyException('TypeError', `'${typeof obj}' object does not support item deletion`);
+                    }
+                    break;
+                }
+                case types_1.OpCode.POP_TOP:
+                    lastValue = frame.stack.pop();
+                    break;
+                case types_1.OpCode.DUP_TOP: {
+                    const val = frame.stack[frame.stack.length - 1];
+                    frame.stack.push(val);
+                    break;
+                }
+                case types_1.OpCode.DUP_TOP_TWO: {
+                    const top = frame.stack[frame.stack.length - 1];
+                    const second = frame.stack[frame.stack.length - 2];
+                    frame.stack.push(second);
+                    frame.stack.push(top);
+                    break;
+                }
+                case types_1.OpCode.ROT_TWO: {
+                    const a = frame.stack.pop();
+                    const b = frame.stack.pop();
+                    frame.stack.push(a);
+                    frame.stack.push(b);
+                    break;
+                }
+                case types_1.OpCode.ROT_THREE: {
+                    const a = frame.stack.pop();
+                    const b = frame.stack.pop();
+                    const c = frame.stack.pop();
+                    frame.stack.push(a);
+                    frame.stack.push(c);
+                    frame.stack.push(b);
+                    break;
+                }
+                case types_1.OpCode.BINARY_ADD: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('+', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_SUBTRACT: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('-', a, b));
+                    break;
                 }
-                this.applyBindings(result.bindings, scope);
-                yield* this.executeBlockGenerator(matchCase.body, scope);
-                return null;
+                case types_1.OpCode.BINARY_MULTIPLY: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('*', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_DIVIDE: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('/', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_FLOOR_DIVIDE: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('//', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_MODULO: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('%', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_POWER: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('**', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_AND: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('&', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_XOR: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('^', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_OR: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('|', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_LSHIFT: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('<<', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_RSHIFT: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyBinary('>>', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_ADD: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('+', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_SUBTRACT: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('-', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_MULTIPLY: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('*', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_DIVIDE: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('/', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_FLOOR_DIVIDE: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('//', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_MODULO: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('%', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_POWER: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('**', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_AND: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('&', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_XOR: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('^', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_OR: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('|', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_LSHIFT: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('<<', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_RSHIFT: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyInPlaceBinary('>>', a, b));
+                    break;
+                }
+                case types_1.OpCode.UNARY_POSITIVE: {
+                    const a = frame.stack.pop();
+                    frame.stack.push(+a);
+                    break;
+                }
+                case types_1.OpCode.UNARY_NEGATIVE: {
+                    const a = frame.stack.pop();
+                    if (typeof a === 'bigint') {
+                        frame.stack.push(-a);
+                    }
+                    else {
+                        frame.stack.push(-a);
+                    }
+                    break;
+                }
+                case types_1.OpCode.UNARY_NOT: {
+                    const a = frame.stack.pop();
+                    frame.stack.push(!this.isTruthy(a, frame.scope));
+                    break;
+                }
+                case types_1.OpCode.UNARY_INVERT: {
+                    const a = frame.stack.pop();
+                    if (typeof a === 'bigint') {
+                        frame.stack.push(~a);
+                    }
+                    else {
+                        frame.stack.push(~Number(a));
+                    }
+                    break;
+                }
+                case types_1.OpCode.COMPARE_OP: {
+                    const b = frame.stack.pop();
+                    const a = frame.stack.pop();
+                    frame.stack.push(this.applyCompare(arg, a, b));
+                    break;
+                }
+                case types_1.OpCode.BUILD_LIST: {
+                    const list = [];
+                    for (let i = 0; i < arg; i++)
+                        list.unshift(frame.stack.pop());
+                    frame.stack.push(list);
+                    break;
+                }
+                case types_1.OpCode.BUILD_TUPLE: {
+                    const tuple = [];
+                    for (let i = 0; i < arg; i++)
+                        tuple.unshift(frame.stack.pop());
+                    tuple.__tuple__ = true;
+                    frame.stack.push(tuple);
+                    break;
+                }
+                case types_1.OpCode.BUILD_MAP: {
+                    const dict = new runtime_types_1.PyDict();
+                    const items = [];
+                    for (let i = 0; i < arg; i++) {
+                        const v = frame.stack.pop();
+                        const k = frame.stack.pop();
+                        items.push({ k, v });
+                    }
+                    for (let i = items.length - 1; i >= 0; i--) {
+                        dict.set(items[i].k, items[i].v);
+                    }
+                    frame.stack.push(dict);
+                    break;
+                }
+                case types_1.OpCode.BUILD_SET: {
+                    const set = new runtime_types_1.PySet();
+                    for (let i = 0; i < arg; i++) {
+                        set.add(frame.stack.pop());
+                    }
+                    frame.stack.push(set);
+                    break;
+                }
+                case types_1.OpCode.BUILD_SLICE: {
+                    const step = arg === 3 ? frame.stack.pop() : null;
+                    const end = frame.stack.pop();
+                    const start = frame.stack.pop();
+                    // Create a slice object with start/end/step to match parser AST nodes
+                    frame.stack.push({ __slice__: true, start, end, step });
+                    break;
+                }
+                case types_1.OpCode.JUMP_ABSOLUTE:
+                    frame.pc = arg;
+                    break;
+                case types_1.OpCode.POP_JUMP_IF_FALSE: {
+                    const val = frame.stack.pop();
+                    if (!this.isTruthy(val, frame.scope)) {
+                        frame.pc = arg;
+                    }
+                    break;
+                }
+                case types_1.OpCode.POP_JUMP_IF_TRUE: {
+                    const val = frame.stack.pop();
+                    if (this.isTruthy(val, frame.scope)) {
+                        frame.pc = arg;
+                    }
+                    break;
+                }
+                case types_1.OpCode.JUMP_IF_FALSE_OR_POP: {
+                    const val = frame.stack[frame.stack.length - 1];
+                    if (!this.isTruthy(val, frame.scope)) {
+                        frame.pc = arg;
+                    }
+                    else {
+                        frame.stack.pop();
+                    }
+                    break;
+                }
+                case types_1.OpCode.JUMP_IF_TRUE_OR_POP: {
+                    const val = frame.stack[frame.stack.length - 1];
+                    if (this.isTruthy(val, frame.scope)) {
+                        frame.pc = arg;
+                    }
+                    else {
+                        frame.stack.pop();
+                    }
+                    break;
+                }
+                case types_1.OpCode.GET_ITER: {
+                    const obj = frame.stack.pop();
+                    if (obj && typeof obj[Symbol.iterator] === 'function') {
+                        frame.stack.push(obj[Symbol.iterator]());
+                    }
+                    else {
+                        throw new runtime_types_1.PyException('TypeError', `'${typeof obj}' object is not iterable`);
+                    }
+                    break;
+                }
+                case types_1.OpCode.FOR_ITER: {
+                    const iter = frame.stack[frame.stack.length - 1];
+                    const next = iter.next();
+                    if (next.done) {
+                        frame.stack.pop();
+                        frame.pc = arg;
+                    }
+                    else {
+                        frame.stack.push(next.value);
+                    }
+                    break;
+                }
+                case types_1.OpCode.MAKE_FUNCTION: {
+                    const defaultsCount = arg || 0;
+                    const name = frame.stack.pop();
+                    const bc = frame.stack.pop();
+                    const defaults = [];
+                    // Pop default values from stack in reverse order (last default on top)
+                    for (let i = 0; i < defaultsCount; i++) {
+                        defaults.unshift(frame.stack.pop());
+                    }
+                    // Create a copy of params with evaluated defaults
+                    const params = (bc && bc.params) ? bc.params.map((p) => ({ ...p })) : [];
+                    if (params.length > 0 && defaultsCount > 0) {
+                        let defaultIndex = 0;
+                        for (let i = params.length - defaultsCount; i < params.length; i++) {
+                            if (params[i] && params[i].type === 'Param') {
+                                params[i].defaultEvaluated = defaults[defaultIndex++];
+                            }
+                        }
+                    }
+                    const isGenerator = !!(bc && bc.isGenerator);
+                    const body = (bc && bc.astBody) ? bc.astBody : [];
+                    const func = new runtime_types_1.PyFunction(name, params, body, frame.scope, isGenerator, new Set(), bc);
+                    func.closure_shared_values = frame.scope.values;
+                    frame.stack.push(func);
+                    break;
+                }
+                case types_1.OpCode.LOAD_BUILD_CLASS: {
+                    const enclosingScope = frame.scope;
+                    frame.stack.push((bodyFn, name, ...bases) => {
+                        const classScope = new runtime_types_1.Scope(enclosingScope, true);
+                        if (bodyFn instanceof runtime_types_1.PyFunction && bodyFn.bytecode) {
+                            const bodyFrame = new runtime_types_1.Frame(bodyFn.bytecode, classScope);
+                            // Class bodies take no args; locals stay empty.
+                            this.executeFrame(bodyFrame);
+                        }
+                        else if (typeof bodyFn === 'function') {
+                            bodyFn();
+                        }
+                        const attributes = new Map(classScope.values.entries());
+                        const isException = bases.some((b) => b instanceof runtime_types_1.PyClass && b.isException);
+                        return new runtime_types_1.PyClass(String(name), bases, attributes, isException);
+                    });
+                    break;
+                }
+                case types_1.OpCode.IMPORT_NAME: {
+                    frame.stack.pop(); // level
+                    frame.stack.pop(); // fromlist
+                    const name = names[arg];
+                    frame.stack.push(this.importModule(name, frame.scope));
+                    break;
+                }
+                case types_1.OpCode.RAISE_VARARGS: {
+                    if (arg >= 2)
+                        frame.stack.pop(); // cause
+                    const exc = arg >= 1 ? frame.stack.pop() : null;
+                    // simplified raise
+                    throw exc || new runtime_types_1.PyException('RuntimeError', 'No exception to raise');
+                }
+                case types_1.OpCode.SETUP_FINALLY: {
+                    frame.blockStack.push({ handler: arg, stackHeight: frame.stack.length });
+                    break;
+                }
+                case types_1.OpCode.SETUP_WITH: {
+                    const ctx = frame.stack.pop();
+                    const enter = this.getAttribute(ctx, '__enter__', frame.scope);
+                    const exit = this.getAttribute(ctx, '__exit__', frame.scope);
+                    const result = this.callFunction(enter, [], frame.scope);
+                    frame.stack.push(exit);
+                    frame.stack.push(result);
+                    // Block should assume exit is on stack, so stackHeight includes exit.
+                    // When popping block, we leave exit on stack? 
+                    // No, standard behavior: SETUP_WITH pushes exit, enter_res.
+                    // Handler expects [exit, exc...]? 
+                    // Let's rely on blockStack logic: stack returned to stackHeight on exception.
+                    // If we set stackHeight to include exit, then on exception, we have [exit], then push exc.
+                    frame.blockStack.push({ handler: arg, stackHeight: frame.stack.length - 1 });
+                    break;
+                }
+                case types_1.OpCode.WITH_EXCEPT_START: {
+                    // Stack: [exit, exc_norm] (after normalizeThrown in dispatchException)
+                    // Or [exit, exc]
+                    // This opcode calls exit(type, val, tb)
+                    const exc = frame.stack.pop();
+                    const exit = frame.stack.pop();
+                    // Call exit(type, val, tb)
+                    // For our VM, we can pass (exc.type, exc, None)
+                    const pyType = (exc instanceof runtime_types_1.PyInstance) ? exc.klass : (exc.pyType || exc);
+                    const handled = this.callFunction(exit, [pyType, exc, null], frame.scope);
+                    if (this.isTruthy(handled, frame.scope)) {
+                        // Exception suppressed
+                        // Pop exception from stack (we already popped it)
+                        // Push nothing? or push suppression marker?
+                        // CPython pushes nothing on suppression?
+                        // "If __exit__ returns True, the exception is suppressed, and execution proceeds"
+                        // We usually JUMP after this.
+                        // But if we just consumed the exception, we need to ensure the stack is clean for the next block.
+                    }
+                    else {
+                        // Exception not suppressed, re-raise
+                        throw exc;
+                    }
+                    break;
+                }
+                case types_1.OpCode.POP_BLOCK: {
+                    frame.blockStack.pop();
+                    break;
+                }
+                case types_1.OpCode.CALL_FUNCTION: {
+                    const args = [];
+                    for (let i = 0; i < arg; i++) {
+                        args.unshift(frame.stack.pop());
+                    }
+                    const func = frame.stack.pop();
+                    frame.stack.push(this.callFunction(func, args, frame.scope));
+                    break;
+                }
+                case types_1.OpCode.CALL_FUNCTION_KW: {
+                    const kwNames = frame.stack.pop();
+                    const kwList = Array.isArray(kwNames) ? kwNames : [];
+                    const kwCount = kwList.length;
+                    const total = arg;
+                    const values = [];
+                    for (let i = 0; i < total; i++) {
+                        values.unshift(frame.stack.pop());
+                    }
+                    const func = frame.stack.pop();
+                    const positionalCount = total - kwCount;
+                    const positional = values.slice(0, positionalCount);
+                    const kwargs = {};
+                    for (let i = 0; i < kwCount; i++) {
+                        kwargs[String(kwList[i])] = values[positionalCount + i];
+                    }
+                    frame.stack.push(this.callFunction(func, positional, frame.scope, kwargs));
+                    break;
+                }
+                case types_1.OpCode.CALL_FUNCTION_EX: {
+                    // arg == 1 means there's a kwargs dict on top
+                    // Stack: [func, args_tuple] or [func, args_tuple, kwargs_dict]
+                    const kwargs = {};
+                    if (arg === 1) {
+                        const kwDict = frame.stack.pop();
+                        if (kwDict instanceof runtime_types_1.PyDict) {
+                            for (const [k, v] of kwDict.entries()) {
+                                kwargs[String(k)] = v;
+                            }
+                        }
+                        else if (kwDict && typeof kwDict === 'object') {
+                            for (const [k, v] of Object.entries(kwDict)) {
+                                kwargs[k] = v;
+                            }
+                        }
+                    }
+                    const argsTuple = frame.stack.pop();
+                    const func = frame.stack.pop();
+                    const args = Array.isArray(argsTuple) ? argsTuple : (argsTuple ? Array.from(argsTuple) : []);
+                    frame.stack.push(this.callFunction(func, args, frame.scope, kwargs));
+                    break;
+                }
+                case types_1.OpCode.EVAL_AST: {
+                    const node = frame.stack.pop();
+                    frame.stack.push(this.evaluateExpression(node, frame.scope));
+                    break;
+                }
+                case types_1.OpCode.RETURN_VALUE:
+                    return frame.stack.pop();
+                default:
+                    throw new Error(`VM: Unknown opcode ${types_1.OpCode[opcode]} (${opcode}) at pc ${frame.pc - 1}`);
             }
-            return null;
         }
-        case types_1.ASTNodeType.RETURN_STATEMENT: {
-            const value = node.value
-                ? (this.expressionHasYield(node.value)
-                    ? yield* this.evaluateExpressionGenerator(node.value, scope)
-                    : this.evaluateExpression(node.value, scope))
-                : null;
-            throw new runtime_types_1.ReturnSignal(value);
+        catch (err) {
+            if (dispatchException(err)) {
+                continue;
+            }
+            throw err;
         }
-        case types_1.ASTNodeType.BREAK_STATEMENT:
-            throw new runtime_types_1.BreakSignal();
-        case types_1.ASTNodeType.CONTINUE_STATEMENT:
-            throw new runtime_types_1.ContinueSignal();
-        case types_1.ASTNodeType.PASS_STATEMENT:
-            return null;
-        default:
-            return this.executeStatement(node, scope);
     }
+    return lastValue;
 }
+var execution_helpers_1 = require("./execution-helpers");
+Object.defineProperty(exports, "applyCompare", { enumerable: true, get: function () { return execution_helpers_1.applyCompare; } });
+Object.defineProperty(exports, "iterableToArray", { enumerable: true, get: function () { return execution_helpers_1.iterableToArray; } });
+Object.defineProperty(exports, "matchValueEquals", { enumerable: true, get: function () { return execution_helpers_1.matchValueEquals; } });
+Object.defineProperty(exports, "applyBindings", { enumerable: true, get: function () { return execution_helpers_1.applyBindings; } });
+Object.defineProperty(exports, "matchPattern", { enumerable: true, get: function () { return execution_helpers_1.matchPattern; } });
+Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return execution_helpers_1.evaluateExpression; } });
+Object.defineProperty(exports, "executeStatement", { enumerable: true, get: function () { return execution_helpers_1.executeStatement; } });
+Object.defineProperty(exports, "executeBlockGenerator", { enumerable: true, get: function () { return execution_helpers_1.executeBlockGenerator; } });
+Object.defineProperty(exports, "executeStatementGenerator", { enumerable: true, get: function () { return execution_helpers_1.executeStatementGenerator; } });
+Object.defineProperty(exports, "executeBlock", { enumerable: true, get: function () { return execution_helpers_1.executeBlock; } });
 //# sourceMappingURL=execution.js.map