new instructions

youknowone · youknowone · commit 4d5e9c78cfc6 · 2025-07-09T13:33:19.000+09:00
diff --git a/compiler/core/src/bytecode.rs b/compiler/core/src/bytecode.rs
@@ -442,7 +442,12 @@ pub enum Instruction {
     LoadGlobal(Arg<NameIdx>),
     LoadDeref(Arg<NameIdx>),
     LoadClassDeref(Arg<NameIdx>),
+    LoadFromDictOrDeref(Arg<NameIdx>),
     StoreFast(Arg<NameIdx>),
+    StoreFastLoadFast {
+        store_idx: Arg<NameIdx>,
+        load_idx: Arg<NameIdx>,
+    },
     StoreLocal(Arg<NameIdx>),
     StoreGlobal(Arg<NameIdx>),
     StoreDeref(Arg<NameIdx>),
@@ -1258,8 +1263,9 @@ impl Instruction {
             ImportName { .. } | ImportNameless => -1,
             ImportStar => -1,
             ImportFrom { .. } => 1,
-            LoadFast(_) | LoadNameAny(_) | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) => 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,
             Subscript => -1,
@@ -1462,7 +1468,12 @@ impl Instruction {
             LoadGlobal(idx) => w!(LoadGlobal, name = idx),
             LoadDeref(idx) => w!(LoadDeref, cell_name = idx),
             LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
+            LoadFromDictOrDeref(idx) => w!(LoadFromDictOrDeref, name = idx),
             StoreFast(idx) => w!(StoreFast, varname = idx),
+            StoreFastLoadFast { store_idx, load_idx } => {
+                write!(f, "StoreFastLoadFast(")?;
+                write!(f, "store={}, load={})", store_idx.get(arg), load_idx.get(arg))
+            }
             StoreLocal(idx) => w!(StoreLocal, name = idx),
             StoreGlobal(idx) => w!(StoreGlobal, name = idx),
             StoreDeref(idx) => w!(StoreDeref, cell_name = idx),
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -606,11 +606,50 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
+            bytecode::Instruction::LoadFromDictOrDeref(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let dict = self.locals.as_object();
+                let value = match dict.get_item(name, vm) {
+                    Ok(value) => value,
+                    Err(_) => {
+                        // Try to load from deref if not in dict
+                        let i = self.code.cellvars.iter().position(|n| n == &name)
+                            .or_else(|| self.code.freevars.iter().position(|n| n == &name)
+                                .map(|i| i + self.code.cellvars.len()))
+                            .ok_or_else(|| vm.new_name_error(format!("name '{}' is not defined", name), name.to_owned()))?;
+                        self.cells_frees[i]
+                            .get()
+                            .ok_or_else(|| self.unbound_cell_exception(i, vm))?
+                    }
+                };
+                self.push_value(value);
+                Ok(None)
+            }
             bytecode::Instruction::StoreFast(idx) => {
                 let value = self.pop_value();
                 self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
                 Ok(None)
             }
+            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]
+                    .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()],
+                        )
+                    })?;
+                self.push_value(loaded);
+                Ok(None)
+            }
             bytecode::Instruction::StoreLocal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let value = self.pop_value();
