LoadClosure as pseudo op

Author: youknowone

crates/codegen/src/compile.rs

@@ -4074,7 +4074,7 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, Instruction::LoadClosure(idx.to_u32()));
+                emit!(self, PseudoInstruction::LoadClosure(idx.to_u32()));
             }
 
             // Build tuple of closure variables
@@ -4297,7 +4297,7 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
+            emit!(self, PseudoInstruction::LoadClosure(classcell_idx.to_u32()));
             emit!(self, Instruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
             emit!(self, Instruction::StoreName(classcell));

crates/codegen/src/ir.rs

@@ -263,6 +263,13 @@ impl CodeInfo {
                         info.arg = OpArg(encoded);
                         info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
+                    // LOAD_CLOSURE pseudo → LOAD_FAST (with varnames offset)
+                    PseudoInstruction::LoadClosure(idx) => {
+                        let varnames_len = varname_cache.len() as u32;
+                        let new_idx = varnames_len + idx.get(info.arg);
+                        info.arg = OpArg(new_idx);
+                        info.instr = Instruction::LoadFast(Arg::marker()).into();
+                    }
                     PseudoInstruction::Jump { .. } => {
                         // PseudoInstruction::Jump instructions are handled later
                     }

crates/compiler-core/src/bytecode/instruction.rs

@@ -385,8 +385,6 @@ pub enum Instruction {
     InstrumentedPopJumpIfNone = 252,            // Placeholder
     InstrumentedPopJumpIfNotNone = 253,         // Placeholder
     InstrumentedLine = 254,                     // Placeholder
-    // Pseudos (needs to be moved to `PseudoInstruction` enum.
-    LoadClosure(Arg<NameIdx>) = 255, // TODO: Move to pseudos
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
@@ -417,9 +415,6 @@ impl TryFrom<u8> for Instruction {
         let instrumented_start = u8::from(Self::InstrumentedResume);
         let instrumented_end = u8::from(Self::InstrumentedLine);
 
-        // TODO: Remove this; This instruction needs to be pseudo
-        let load_closure = u8::from(Self::LoadClosure(Arg::marker()));
-
         // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
         let custom_ops: &[u8] = &[
             u8::from(Self::Break {
@@ -459,7 +454,6 @@ impl TryFrom<u8> for Instruction {
 
         if (cpython_start..=cpython_end).contains(&value)
             || value == resume_id
-            || value == load_closure
             || custom_ops.contains(&value)
             || (specialized_start..=specialized_end).contains(&value)
             || (instrumented_start..=instrumented_end).contains(&value)
@@ -706,7 +700,6 @@ impl InstructionMetadata for Instruction {
             Self::StoreFastStoreFast { .. } => 0,
             Self::PopJumpIfNone { .. } => 0,
             Self::PopJumpIfNotNone { .. } => 0,
-            Self::LoadClosure(_) => 1,
             Self::BinaryOpAddFloat => 0,
             Self::BinaryOpAddInt => 0,
             Self::BinaryOpAddUnicode => 0,
@@ -937,7 +930,6 @@ impl InstructionMetadata for Instruction {
             }
             Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
             Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
-            Self::LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
             Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
             Self::LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
             Self::LoadFast(idx) => w!(LOAD_FAST, varname = idx),
@@ -1039,6 +1031,7 @@ pub enum PseudoInstruction {
     SetupFinally = 265,       // Placeholder
     SetupWith = 266,          // Placeholder
     StoreFastMaybeNull = 267, // Placeholder
+    LoadClosure(Arg<NameIdx>) = 268,
 }
 
 const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
@@ -1059,7 +1052,7 @@ impl TryFrom<u16> for PseudoInstruction {
         let start = u16::from(Self::Jump {
             target: Arg::marker(),
         });
-        let end = u16::from(Self::StoreFastMaybeNull);
+        let end = u16::from(Self::LoadClosure(Arg::marker()));
 
         if (start..=end).contains(&value) {
             Ok(unsafe { mem::transmute::<u16, Self>(value) })
@@ -1095,6 +1088,7 @@ impl InstructionMetadata for PseudoInstruction {
             Self::SetupWith => 0,
             Self::StoreFastMaybeNull => 0,
             Self::Reserved258 => 0,
+            Self::LoadClosure(_) => 1,
         }
     }
 

crates/stdlib/src/opcode.rs

@@ -125,7 +125,6 @@ mod opcode {
                 Ok(AnyInstruction::Real(
                     Instruction::DeleteDeref(_)
                         | Instruction::LoadFromDictOrDeref(_)
-                        | Instruction::LoadClosure(_)
                         | Instruction::LoadDeref(_)
                         | Instruction::StoreDeref(_)
                 ))

crates/vm/src/frame.rs

@@ -115,10 +115,24 @@ impl Frame {
         func_obj: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> Self {
-        let cells_frees = core::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
-            .take(code.cellvars.len())
-            .chain(closure.iter().cloned())
-            .collect();
+        let nlocals = code.varnames.len();
+        let ncells = code.cellvars.len();
+        let nfrees = closure.len();
+
+        let cells_frees: Box<[PyCellRef]> =
+            core::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
+                .take(ncells)
+                .chain(closure.iter().cloned())
+                .collect();
+
+        // Extend fastlocals to include varnames + cellvars + freevars (localsplus)
+        let total_locals = nlocals + ncells + nfrees;
+        let mut fastlocals_vec: Vec<Option<PyObjectRef>> = vec![None; total_locals];
+
+        // Store cell objects at cellvars and freevars positions
+        for (i, cell) in cells_frees.iter().enumerate() {
+            fastlocals_vec[nlocals + i] = Some(cell.clone().into());
+        }
 
         let state = FrameState {
             stack: BoxVec::new(code.max_stackdepth as usize),
@@ -127,7 +141,7 @@ impl Frame {
         };
 
         Self {
-            fastlocals: PyMutex::new(vec![None; code.varnames.len()].into_boxed_slice()),
+            fastlocals: PyMutex::new(fastlocals_vec.into_boxed_slice()),
             cells_frees,
             locals: scope.locals,
             globals: scope.globals,
@@ -1191,11 +1205,6 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            Instruction::LoadClosure(i) => {
-                let value = self.cells_frees[i.get(arg) as usize].clone();
-                self.push_value(value.into());
-                Ok(None)
-            }
             Instruction::LoadConst { idx } => {
                 self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)