@lewin671/python-vm 0.1.5 → 0.1.7

package/dist/vm/execution.js

@@ -5,6 +5,21 @@ exports.execute = execute;
 exports.executeFrame = executeFrame;
 const types_1 = require("../types");
 const runtime_types_1 = require("./runtime-types");
+const fStringCache = new Map();
+const FSTRING_CACHE_LIMIT = 1000;
+let fStringAccessCounter = 0;
+const pruneFStringCache = () => {
+    if (fStringCache.size <= FSTRING_CACHE_LIMIT)
+        return;
+    const targetSize = Math.floor(FSTRING_CACHE_LIMIT * 0.8);
+    const entries = Array.from(fStringCache.entries());
+    entries.sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+    const removeCount = entries.length - targetSize;
+    for (let i = 0; i < removeCount; i++) {
+        fStringCache.delete(entries[i][0]);
+    }
+};
+const fastIteratorSymbol = Symbol('fastIterator');
 function execute(bytecode) {
     const globalScope = new runtime_types_1.Scope();
     this.installBuiltins(globalScope);
@@ -26,34 +41,102 @@ function executeFrame(frame) {
         }
     }
     let lastValue = null;
+    // Cache frequently accessed properties for faster access (V8 optimization)
+    const stack = frame.stack;
+    const locals = frame.locals;
+    const scope = frame.scope;
+    const scopeValues = scope.values;
+    const syncLocals = varnames ? varnames.map((name) => name !== undefined && scopeValues.has(name)) : null;
+    const unsyncedLocals = syncLocals
+        ? syncLocals.reduce((acc, synced, index) => {
+            if (!synced)
+                acc.push(index);
+            return acc;
+        }, [])
+        : null;
+    let scopeValueSize = scopeValues.size;
+    const refreshLocalsSync = () => {
+        if (!syncLocals || !unsyncedLocals || unsyncedLocals.length === 0)
+            return;
+        if (scopeValues.size === scopeValueSize)
+            return;
+        scopeValueSize = scopeValues.size;
+        for (let i = unsyncedLocals.length - 1; i >= 0; i--) {
+            const idx = unsyncedLocals[i];
+            const name = varnames[idx];
+            if (name !== undefined && scopeValues.has(name)) {
+                syncLocals[idx] = true;
+                // Swap-with-last removal to avoid shifting the entire array.
+                unsyncedLocals[i] = unsyncedLocals[unsyncedLocals.length - 1];
+                unsyncedLocals.pop();
+            }
+        }
+    };
+    const iterSymbol = Symbol.iterator;
     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);
+        let entry = fStringCache.get(template);
+        let parts;
+        if (!entry) {
+            parts = [];
+            const regex = /\{([^}]+)\}/g;
+            let lastIndex = 0;
+            let match;
+            while ((match = regex.exec(template)) !== null) {
+                if (match.index > lastIndex) {
+                    parts.push({ kind: 'text', value: template.slice(lastIndex, match.index) });
+                }
+                const { rawExpr, rawSpec } = this.splitFormatSpec(match[1]);
+                parts.push({ kind: 'expr', expr: rawExpr.trim(), spec: rawSpec ? rawSpec.trim() : '' });
+                lastIndex = regex.lastIndex;
+            }
+            if (lastIndex < template.length) {
+                parts.push({ kind: 'text', value: template.slice(lastIndex) });
+            }
+            entry = {
+                parts,
+                lastAccess: fStringCache.size >= FSTRING_CACHE_LIMIT ? ++fStringAccessCounter : 0,
+            };
+            fStringCache.set(template, entry);
+            pruneFStringCache();
+        }
+        else {
+            if (fStringCache.size >= FSTRING_CACHE_LIMIT) {
+                entry.lastAccess = ++fStringAccessCounter;
+            }
+            parts = entry.parts;
+        }
+        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}`);
                     }
-                    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]);
+                    evalScope.values.set(varname, val);
+                }
+                else if (locals[i] !== undefined) {
+                    if (process.env['DEBUG_NONLOCAL']) {
+                        console.log(`renderFString: varname=${varname}, locals[${i}]=${locals[i]}`);
                     }
+                    evalScope.values.set(varname, locals[i]);
                 }
             }
-            const inner = this.evaluateExpressionString(rawExpr.trim(), evalScope);
-            return this.applyFormatSpec(inner, rawSpec ? rawSpec.trim() : '');
-        });
+        }
+        let result = '';
+        for (const part of parts) {
+            if (part.kind === 'text') {
+                result += part.value;
+            }
+            else {
+                const inner = this.evaluateExpressionString(part.expr, evalScope);
+                result += this.applyFormatSpec(inner, part.spec);
+            }
+        }
+        return result;
     };
     const normalizeThrown = (err) => {
         if (err instanceof runtime_types_1.PyException) {
@@ -76,8 +159,8 @@ function executeFrame(frame) {
         if (frame.blockStack.length === 0)
             return false;
         const block = frame.blockStack.pop();
-        frame.stack.length = block.stackHeight;
-        frame.stack.push(normalizeThrown(err));
+        stack.length = block.stackHeight;
+        stack.push(normalizeThrown(err));
         frame.pc = block.handler;
         return true;
     };
@@ -96,100 +179,202 @@ function executeFrame(frame) {
             switch (opcode) {
                 // === HOT PATH: Most frequently executed opcodes (>5% execution time) ===
                 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;
-                    }
-                    const val = frame.locals[arg];
+                    // Optimize common case: value is in locals
+                    let val = locals[arg];
                     if (val === undefined) {
-                        throw new runtime_types_1.PyException('UnboundLocalError', `local variable '${varname}' referenced before assignment`);
+                        // Check scope values as fallback
+                        refreshLocalsSync();
+                        if (syncLocals && syncLocals[arg]) {
+                            val = scopeValues.get(varnames[arg]);
+                            locals[arg] = val;
+                        }
+                        else if (varnames && varnames[arg] !== undefined && scopeValues.has(varnames[arg])) {
+                            if (syncLocals)
+                                syncLocals[arg] = true;
+                            val = scopeValues.get(varnames[arg]);
+                            locals[arg] = val;
+                        }
+                        else {
+                            const varname = varnames[arg];
+                            throw new runtime_types_1.PyException('UnboundLocalError', `local variable '${varname}' referenced before assignment`);
+                        }
                     }
-                    frame.stack.push(val);
+                    stack.push(val);
                     break;
                 }
                 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));
+                            stack.push(renderFString(val.__fstring__, frame.scope));
                         }
                         else {
-                            frame.stack.push(val);
+                            stack.push(val);
                         }
                     }
                     break;
                 case types_1.OpCode.LOAD_NAME: {
                     const name = names[arg];
-                    const val = frame.scope.get(name);
+                    const val = scope.get(name);
                     // console.log(`LOAD_NAME ${name} -> ${val}`);
-                    frame.stack.push(val);
+                    stack.push(val);
                     break;
                 }
                 case types_1.OpCode.BINARY_ADD: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('+', a, b));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a + b);
+                    }
+                    else {
+                        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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a - b);
+                    }
+                    else {
+                        stack.push(this.applyBinary('-', a, b));
+                    }
                     break;
                 }
                 case types_1.OpCode.BINARY_MULTIPLY: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('*', a, b));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a * b);
+                    }
+                    else {
+                        stack.push(this.applyBinary('*', a, b));
+                    }
                     break;
                 }
                 case types_1.OpCode.CALL_FUNCTION: {
-                    const args = [];
-                    for (let i = 0; i < arg; i++) {
-                        args.unshift(frame.stack.pop());
+                    const argCount = arg;
+                    const args = new Array(argCount);
+                    // Pop arguments in reverse order
+                    for (let i = argCount - 1; i >= 0; i--) {
+                        args[i] = stack.pop();
                     }
-                    const func = frame.stack.pop();
-                    frame.stack.push(this.callFunction(func, args, frame.scope));
+                    const func = stack.pop();
+                    stack.push(this.callFunction(func, args, scope));
                     break;
                 }
                 case types_1.OpCode.RETURN_VALUE:
-                    return frame.stack.pop();
+                    return stack.pop();
                 case types_1.OpCode.COMPARE_OP: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyCompare(arg, a, b));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple integer comparisons
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        let result = undefined;
+                        switch (arg) {
+                            case types_1.CompareOp.LT:
+                                result = a < b;
+                                break;
+                            case types_1.CompareOp.LE:
+                                result = a <= b;
+                                break;
+                            case types_1.CompareOp.EQ:
+                                result = a === b;
+                                break;
+                            case types_1.CompareOp.NE:
+                                result = a !== b;
+                                break;
+                            case types_1.CompareOp.GT:
+                                result = a > b;
+                                break;
+                            case types_1.CompareOp.GE:
+                                result = a >= b;
+                                break;
+                        }
+                        if (result !== undefined) {
+                            stack.push(result);
+                        }
+                        else {
+                            stack.push(this.applyCompare(arg, a, b));
+                        }
+                    }
+                    else {
+                        stack.push(this.applyCompare(arg, a, b));
+                    }
                     break;
                 }
                 case types_1.OpCode.POP_JUMP_IF_FALSE: {
-                    const val = frame.stack.pop();
-                    if (!this.isTruthy(val, frame.scope)) {
+                    const val = stack.pop();
+                    // Fast path for booleans and numbers
+                    let isFalse = false;
+                    if (typeof val === 'boolean') {
+                        isFalse = !val;
+                    }
+                    else if (typeof val === 'number') {
+                        isFalse = val === 0;
+                    }
+                    else if (val === null || val === undefined) {
+                        isFalse = true;
+                    }
+                    else {
+                        isFalse = !this.isTruthy(val, scope);
+                    }
+                    if (isFalse) {
                         frame.pc = arg;
                     }
                     break;
                 }
                 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);
+                    const val = stack.pop();
+                    locals[arg] = val;
+                    if (syncLocals) {
+                        refreshLocalsSync();
+                        if (syncLocals[arg]) {
+                            scopeValues.set(varnames[arg], val);
+                        }
                     }
                     break;
                 }
                 case types_1.OpCode.STORE_NAME:
-                    frame.scope.set(names[arg], frame.stack.pop());
+                    scope.set(names[arg], stack.pop());
                     break;
                 case types_1.OpCode.FOR_ITER: {
-                    const iter = frame.stack[frame.stack.length - 1];
+                    const iter = stack[stack.length - 1];
+                    if (iter && iter[fastIteratorSymbol] === 'array') {
+                        const idx = iter.index;
+                        if (idx >= iter.data.length) {
+                            stack.pop();
+                            frame.pc = arg;
+                        }
+                        else {
+                            stack.push(iter.data[idx]);
+                            iter.index = idx + 1;
+                        }
+                        break;
+                    }
+                    if (iter && iter[fastIteratorSymbol] === 'range') {
+                        const current = iter.current;
+                        if (iter.step > 0 ? current < iter.end : current > iter.end) {
+                            stack.push(current);
+                            iter.current = current + iter.step;
+                        }
+                        else {
+                            stack.pop();
+                            frame.pc = arg;
+                        }
+                        break;
+                    }
                     const next = iter.next();
                     if (next.done) {
-                        frame.stack.pop();
+                        stack.pop();
                         frame.pc = arg;
                     }
                     else {
-                        frame.stack.push(next.value);
+                        stack.push(next.value);
                     }
                     break;
                 }
@@ -197,30 +382,54 @@ function executeFrame(frame) {
                     frame.pc = arg;
                     break;
                 case types_1.OpCode.INPLACE_ADD: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('+', a, b));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a + b);
+                    }
+                    else {
+                        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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a - b);
+                    }
+                    else {
+                        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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a * b);
+                    }
+                    else {
+                        stack.push(this.applyInPlaceBinary('*', a, b));
+                    }
                     break;
                 }
                 case types_1.OpCode.POP_TOP:
-                    lastValue = frame.stack.pop();
+                    lastValue = 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]());
+                    const obj = stack.pop();
+                    if (Array.isArray(obj)) {
+                        stack.push({ [fastIteratorSymbol]: 'array', data: obj, index: 0 });
+                    }
+                    else if (obj instanceof runtime_types_1.PyRange) {
+                        stack.push({ [fastIteratorSymbol]: 'range', current: obj.start, end: obj.end, step: obj.step });
+                    }
+                    else if (obj && typeof obj[iterSymbol] === 'function') {
+                        stack.push(obj[iterSymbol]());
                     }
                     else {
                         throw new runtime_types_1.PyException('TypeError', `'${typeof obj}' object is not iterable`);
@@ -228,145 +437,163 @@ function executeFrame(frame) {
                     break;
                 }
                 case types_1.OpCode.LOAD_ATTR: {
-                    const obj = frame.stack.pop();
-                    frame.stack.push(this.getAttribute(obj, names[arg], frame.scope));
+                    const obj = stack.pop();
+                    stack.push(this.getAttribute(obj, names[arg], frame.scope));
                     break;
                 }
                 // Other BINARY operations
                 case types_1.OpCode.BINARY_DIVIDE: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('/', a, b));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a / b);
+                    }
+                    else {
+                        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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(Math.floor(a / b));
+                    }
+                    else {
+                        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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a % b);
+                    }
+                    else {
+                        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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyBinary('>>', a, b));
                     break;
                 }
                 // Other INPLACE operations
                 case types_1.OpCode.INPLACE_DIVIDE: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('/', a, b));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    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));
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('>>', a, b));
                     break;
                 }
                 // Other JUMP operations
                 case types_1.OpCode.POP_JUMP_IF_TRUE: {
-                    const val = frame.stack.pop();
+                    const val = 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];
+                    const val = stack[stack.length - 1];
                     if (!this.isTruthy(val, frame.scope)) {
                         frame.pc = arg;
                     }
                     else {
-                        frame.stack.pop();
+                        stack.pop();
                     }
                     break;
                 }
                 case types_1.OpCode.JUMP_IF_TRUE_OR_POP: {
-                    const val = frame.stack[frame.stack.length - 1];
+                    const val = stack[stack.length - 1];
                     if (this.isTruthy(val, frame.scope)) {
                         frame.pc = arg;
                     }
                     else {
-                        frame.stack.pop();
+                        stack.pop();
                     }
                     break;
                 }
@@ -379,7 +606,7 @@ function executeFrame(frame) {
                         globalScope = globalScope.parent;
                     }
                     const val = globalScope.get(name);
-                    frame.stack.push(val);
+                    stack.push(val);
                     break;
                 }
                 case types_1.OpCode.STORE_GLOBAL: {
@@ -389,25 +616,25 @@ function executeFrame(frame) {
                     while (globalScope.parent !== null) {
                         globalScope = globalScope.parent;
                     }
-                    globalScope.set(name, frame.stack.pop());
+                    globalScope.set(name, stack.pop());
                     break;
                 }
                 case types_1.OpCode.STORE_ATTR: {
-                    const val = frame.stack.pop();
-                    const obj = frame.stack.pop();
+                    const val = stack.pop();
+                    const obj = 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));
+                    const index = stack.pop();
+                    const obj = stack.pop();
+                    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();
+                    const index = stack.pop();
+                    const obj = stack.pop();
+                    const val = 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`);
@@ -448,8 +675,8 @@ function executeFrame(frame) {
                     break;
                 }
                 case types_1.OpCode.DELETE_SUBSCR: {
-                    const index = frame.stack.pop();
-                    const obj = frame.stack.pop();
+                    const index = stack.pop();
+                    const obj = stack.pop();
                     if (Array.isArray(obj)) {
                         if (index && (index.__slice__ || index.type === types_1.ASTNodeType.SLICE)) {
                             const start = index.start !== undefined ? index.start : null;
@@ -490,18 +717,18 @@ function executeFrame(frame) {
                 }
                 // UNPACK operations
                 case types_1.OpCode.UNPACK_SEQUENCE: {
-                    const seq = frame.stack.pop();
+                    const seq = 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]);
+                        stack.push(items[i]);
                     }
                     break;
                 }
                 case types_1.OpCode.UNPACK_EX: {
-                    const seq = frame.stack.pop();
+                    const seq = stack.pop();
                     const items = Array.isArray(seq) ? seq : Array.from(seq);
                     const beforeCount = (arg >> 8) & 0xff;
                     const afterCount = arg & 0xff;
@@ -512,129 +739,131 @@ function executeFrame(frame) {
                     // 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]);
+                        stack.push(items[items.length - afterCount + i]);
                     }
-                    frame.stack.push(middle);
+                    stack.push(middle);
                     for (let i = beforeCount - 1; i >= 0; i--) {
-                        frame.stack.push(items[i]);
+                        stack.push(items[i]);
                     }
                     break;
                 }
                 // Stack operations
                 case types_1.OpCode.DUP_TOP: {
-                    const val = frame.stack[frame.stack.length - 1];
-                    frame.stack.push(val);
+                    const val = stack[stack.length - 1];
+                    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);
+                    const top = stack[stack.length - 1];
+                    const second = stack[stack.length - 2];
+                    stack.push(second);
+                    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);
+                    const a = stack.pop();
+                    const b = stack.pop();
+                    stack.push(a);
+                    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);
+                    const a = stack.pop();
+                    const b = stack.pop();
+                    const c = stack.pop();
+                    stack.push(a);
+                    stack.push(c);
+                    stack.push(b);
                     break;
                 }
                 // UNARY operations
                 case types_1.OpCode.UNARY_POSITIVE: {
-                    const a = frame.stack.pop();
-                    frame.stack.push(+a);
+                    const a = stack.pop();
+                    stack.push(+a);
                     break;
                 }
                 case types_1.OpCode.UNARY_NEGATIVE: {
-                    const a = frame.stack.pop();
+                    const a = stack.pop();
                     if (typeof a === 'bigint') {
-                        frame.stack.push(-a);
+                        stack.push(-a);
                     }
                     else {
-                        frame.stack.push(-a);
+                        stack.push(-a);
                     }
                     break;
                 }
                 case types_1.OpCode.UNARY_NOT: {
-                    const a = frame.stack.pop();
-                    frame.stack.push(!this.isTruthy(a, frame.scope));
+                    const a = stack.pop();
+                    stack.push(!this.isTruthy(a, frame.scope));
                     break;
                 }
                 case types_1.OpCode.UNARY_INVERT: {
-                    const a = frame.stack.pop();
+                    const a = stack.pop();
                     if (typeof a === 'bigint') {
-                        frame.stack.push(~a);
+                        stack.push(~a);
                     }
                     else {
-                        frame.stack.push(~Number(a));
+                        stack.push(~Number(a));
                     }
                     break;
                 }
                 // BUILD operations
                 case types_1.OpCode.BUILD_LIST: {
-                    const list = [];
-                    for (let i = 0; i < arg; i++)
-                        list.unshift(frame.stack.pop());
-                    frame.stack.push(list);
+                    const count = arg;
+                    const list = new Array(count);
+                    for (let i = count - 1; i >= 0; i--)
+                        list[i] = stack.pop();
+                    stack.push(list);
                     break;
                 }
                 case types_1.OpCode.BUILD_TUPLE: {
-                    const tuple = [];
-                    for (let i = 0; i < arg; i++)
-                        tuple.unshift(frame.stack.pop());
+                    const count = arg;
+                    const tuple = new Array(count);
+                    for (let i = count - 1; i >= 0; i--)
+                        tuple[i] = stack.pop();
                     tuple.__tuple__ = true;
-                    frame.stack.push(tuple);
+                    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();
+                        const v = stack.pop();
+                        const k = 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);
+                    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());
+                        set.add(stack.pop());
                     }
-                    frame.stack.push(set);
+                    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();
+                    const step = arg === 3 ? stack.pop() : null;
+                    const end = stack.pop();
+                    const start = stack.pop();
                     // Create a slice object with start/end/step to match parser AST nodes
-                    frame.stack.push({ __slice__: true, start, end, step });
+                    stack.push({ __slice__: true, start, end, step });
                     break;
                 }
                 // Function/class operations
                 case types_1.OpCode.MAKE_FUNCTION: {
                     const defaultsCount = arg || 0;
-                    const name = frame.stack.pop();
-                    const bc = frame.stack.pop();
-                    const defaults = [];
+                    const name = stack.pop();
+                    const bc = stack.pop();
+                    const defaults = new Array(defaultsCount);
                     // Pop default values from stack in reverse order (last default on top)
-                    for (let i = 0; i < defaultsCount; i++) {
-                        defaults.unshift(frame.stack.pop());
+                    for (let i = defaultsCount - 1; i >= 0; i--) {
+                        defaults[i] = stack.pop();
                     }
                     // Create a copy of params with evaluated defaults
                     const params = (bc && bc.params) ? bc.params.map((p) => ({ ...p })) : [];
@@ -650,26 +879,26 @@ function executeFrame(frame) {
                     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);
+                    stack.push(func);
                     break;
                 }
                 case types_1.OpCode.CALL_FUNCTION_KW: {
-                    const kwNames = frame.stack.pop();
+                    const kwNames = 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 values = new Array(total);
+                    for (let i = total - 1; i >= 0; i--) {
+                        values[i] = stack.pop();
                     }
-                    const func = frame.stack.pop();
+                    const func = 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));
+                    stack.push(this.callFunction(func, positional, frame.scope, kwargs));
                     break;
                 }
                 case types_1.OpCode.CALL_FUNCTION_EX: {
@@ -677,7 +906,7 @@ function executeFrame(frame) {
                     // Stack: [func, args_tuple] or [func, args_tuple, kwargs_dict]
                     const kwargs = {};
                     if (arg === 1) {
-                        const kwDict = frame.stack.pop();
+                        const kwDict = stack.pop();
                         if (kwDict instanceof runtime_types_1.PyDict) {
                             for (const [k, v] of kwDict.entries()) {
                                 kwargs[String(k)] = v;
@@ -689,15 +918,15 @@ function executeFrame(frame) {
                             }
                         }
                     }
-                    const argsTuple = frame.stack.pop();
-                    const func = frame.stack.pop();
+                    const argsTuple = stack.pop();
+                    const func = stack.pop();
                     const args = Array.isArray(argsTuple) ? argsTuple : (argsTuple ? Array.from(argsTuple) : []);
-                    frame.stack.push(this.callFunction(func, args, frame.scope, kwargs));
+                    stack.push(this.callFunction(func, args, frame.scope, kwargs));
                     break;
                 }
                 case types_1.OpCode.LOAD_BUILD_CLASS: {
                     const enclosingScope = frame.scope;
-                    frame.stack.push((bodyFn, name, ...bases) => {
+                    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);
@@ -715,45 +944,45 @@ function executeFrame(frame) {
                 }
                 // Import/exception operations
                 case types_1.OpCode.IMPORT_NAME: {
-                    frame.stack.pop(); // level
-                    frame.stack.pop(); // fromlist
+                    stack.pop(); // level
+                    stack.pop(); // fromlist
                     const name = names[arg];
-                    frame.stack.push(this.importModule(name, frame.scope));
+                    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;
+                        stack.pop(); // cause
+                    const exc = arg >= 1 ? 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 });
+                    frame.blockStack.push({ handler: arg, stackHeight: stack.length });
                     break;
                 }
                 case types_1.OpCode.SETUP_WITH: {
-                    const ctx = frame.stack.pop();
+                    const ctx = 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);
+                    stack.push(exit);
+                    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 });
+                    frame.blockStack.push({ handler: arg, stackHeight: 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();
+                    const exc = stack.pop();
+                    const exit = 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);
@@ -778,8 +1007,8 @@ function executeFrame(frame) {
                     break;
                 }
                 case types_1.OpCode.EVAL_AST: {
-                    const node = frame.stack.pop();
-                    frame.stack.push(this.evaluateExpression(node, frame.scope));
+                    const node = stack.pop();
+                    stack.push(this.evaluateExpression(node, frame.scope));
                     break;
                 }
                 default: