new instructions?

youknowone · youknowone · commit 4fbdd3239f73 · 2025-07-09T13:33:19.000+09:00
diff --git a/compiler/core/src/bytecode.rs b/compiler/core/src/bytecode.rs
@@ -456,6 +456,8 @@ pub enum Instruction {
     DeleteGlobal(Arg<NameIdx>),
     DeleteDeref(Arg<NameIdx>),
     LoadClosure(Arg<NameIdx>),
+    MakeCell(Arg<NameIdx>),
+    CopyFreeVars(Arg<u32>),
     Subscript,
     StoreSubscript,
     DeleteSubscript,
@@ -1263,11 +1265,18 @@ impl Instruction {
             ImportName { .. } | ImportNameless => -1,
             ImportStar => -1,
             ImportFrom { .. } => 1,
-            LoadFast(_) | LoadNameAny(_) | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) | LoadFromDictOrDeref(_) => 1,
+            LoadFast(_)
+            | LoadNameAny(_)
+            | LoadGlobal(_)
+            | LoadDeref(_)
+            | LoadClassDeref(_)
+            | LoadFromDictOrDeref(_) => 1,
             StoreFast(_) | StoreLocal(_) | StoreGlobal(_) | StoreDeref(_) => -1,
             StoreFastLoadFast { .. } => 0, // Stores then loads, net effect 0
             DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
             LoadClosure(_) => 1,
+            MakeCell(_) => 0,
+            CopyFreeVars(n) => 0, // Copies from closure to locals, no stack effect
             Subscript => -1,
             StoreSubscript => -3,
             DeleteSubscript => -2,
@@ -1470,9 +1479,17 @@ impl Instruction {
             LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
             LoadFromDictOrDeref(idx) => w!(LoadFromDictOrDeref, name = idx),
             StoreFast(idx) => w!(StoreFast, varname = idx),
-            StoreFastLoadFast { store_idx, load_idx } => {
+            StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
                 write!(f, "StoreFastLoadFast(")?;
-                write!(f, "store={}, load={})", store_idx.get(arg), load_idx.get(arg))
+                write!(
+                    f,
+                    "store={}, load={})",
+                    store_idx.get(arg),
+                    load_idx.get(arg)
+                )
             }
             StoreLocal(idx) => w!(StoreLocal, name = idx),
             StoreGlobal(idx) => w!(StoreGlobal, name = idx),
@@ -1578,6 +1595,8 @@ impl Instruction {
             TypeAlias => w!(TypeAlias),
             ParamSpec => w!(ParamSpec),
             TypeVarTuple => w!(TypeVarTuple),
+            MakeCell(idx) => w!(MakeCell, cell_name = idx),
+            CopyFreeVars(count) => w!(CopyFreeVars, count),
         }
     }
 }
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -630,23 +630,21 @@ impl ExecutingFrame<'_> {
                 self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
                 Ok(None)
             }
-            bytecode::Instruction::StoreFastLoadFast { store_idx, load_idx } => {
+            bytecode::Instruction::StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
                 let value = self.pop_value();
-                // Store the value
-                self.fastlocals.lock()[store_idx.get(arg) as usize] = Some(value.clone());
-                // Then load from a different fast local
-                let loaded = self.fastlocals.lock()[load_idx.get(arg) as usize]
+
+                // Store the value at store_idx
+                let mut fastlocals = self.fastlocals.lock();
+                fastlocals[store_idx.get(arg) as usize] = Some(value);
+
+                // Load from load_idx (which might be the same as store_idx)
+                let loaded = fastlocals[load_idx.get(arg) as usize]
                     .clone()
-                    .ok_or_else(|| {
-                        let varname = self.code.varnames[load_idx.get(arg) as usize];
-                        vm.new_exception(
-                            vm.ctx.exceptions.unbound_local_error.to_owned(),
-                            vec![vm
-                                .ctx
-                                .new_str(format!("local variable '{varname}' referenced before assignment"))
-                                .into()],
-                        )
-                    })?;
+                    .expect("must exist");
+                drop(fastlocals); // Release the lock before pushing
                 self.push_value(loaded);
                 Ok(None)
             }
@@ -715,6 +713,31 @@ impl ExecutingFrame<'_> {
                 self.push_value(value.into());
                 Ok(None)
             }
+            bytecode::Instruction::MakeCell(i) => {
+                // Create a new cell for the given name
+                let idx = i.get(arg) as usize;
+                if idx < self.cells_frees.len() {
+                    // Cell already exists, skip
+                } else {
+                    // This is a simplified implementation
+                    // In CPython, MAKE_CELL creates cells for variables that will be used in closures
+                }
+                Ok(None)
+            }
+            bytecode::Instruction::CopyFreeVars(n) => {
+                // Copy free variables from the closure to fast locals
+                let n = n.get(arg) as usize;
+                // In CPython, this copies free variables from the function's closure
+                // to the frame's fast locals at the beginning of the code object
+                let mut fastlocals = self.fastlocals.lock();
+                for i in 0..n.min(self.cells_frees.len()) {
+                    let value = self.cells_frees[i].get();
+                    if i < fastlocals.len() {
+                        fastlocals[i] = value;
+                    }
+                }
+                Ok(None)
+            }
             bytecode::Instruction::Subscript => self.execute_subscript(vm),
             bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
             bytecode::Instruction::DeleteSubscript => self.execute_delete_subscript(vm),
