GeezerVison

crates/vm/src/frame.rs (1)

1806-1820: Same packed‑index constraint as LoadFastLoadFast applies here.

crates/codegen/src/ir.rs (1)

407-466: Guard fusion across differing spans/handlers.
Fusing across different except_handler or source spans can alter exception-table coverage or line events. Consider guarding (or asserting) that both instructions share the same span/handler before combining.

💡 Suggested guard

                     let curr = &block.instructions[i];
                     let next = &block.instructions[i + 1];
 
+                    if curr.except_handler != next.except_handler
+                        || curr.location != next.location
+                        || curr.end_location != next.end_location
+                    {
+                        i += 1;
+                        continue;
+                    }
+
                     // Only combine if both are real instructions (not pseudo)
                     let (Some(curr_instr), Some(next_instr)) =
                         (curr.instr.real(), next.instr.real())
                     else {

crates/compiler-core/src/bytecode/instruction.rs (1)

171-247: Add disassembly formatting for new/common-constant & fused ops.
Now that LoadCommonConstant, LoadFastLoadFast, and StoreFastStoreFast are used, fmt_dis falls back to RUSTPYTHON_PLACEHOLDER for them. Adding explicit cases improves debug output.

♻️ Suggested disassembly cases

@@
-            Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
+            Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
+            Self::LoadCommonConstant { idx } => {
+                let c = idx.get(arg);
+                write!(f, "{:pad$}({})", "LOAD_COMMON_CONSTANT", c)
+            }
@@
             Self::LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
+            Self::LoadFastLoadFast { .. } => {
+                let packed = arg.0;
+                let idx1 = packed >> 4;
+                let idx2 = packed & 0xF;
+                write!(f, "LOAD_FAST_LOAD_FAST ({}, {})", varname(idx1), varname(idx2))
+            }
@@
             Self::StoreFast(idx) => w!(STORE_FAST, varname = idx),
+            Self::StoreFastStoreFast { .. } => {
+                let packed = arg.0;
+                let idx1 = packed >> 4;
+                let idx2 = packed & 0xF;
+                write!(f, "STORE_FAST_STORE_FAST ({}, {})", varname(idx1), varname(idx2))
+            }