From fad76c6f91fe0ac91c047e4bcd58547ad42f91e6 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 11 Jan 2026 11:10:11 +0200
Subject: [PATCH 01/35] save

---
 crates/compiler-core/src/bytecode.rs          | 20 +++---
 .../compiler-core/src/bytecode/instruction.rs | 69 +++++++++++--------
 2 files changed, 50 insertions(+), 39 deletions(-)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 61707b7757e..03da423846c 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -14,7 +14,7 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
-pub use crate::bytecode::instruction::Instruction;
+pub use crate::bytecode::instruction::{Instruction, PseudoInstruction, RealInstruction};
 
 mod instruction;
 
@@ -102,7 +102,7 @@ pub const fn decode_load_attr_arg(oparg: u32) -> (u32, bool) {
     (name_idx, is_method)
 }
 
-/// Oparg values for [`Instruction::ConvertValue`].
+/// Oparg values for [`RealInstruction::ConvertValue`].
 ///
 /// ## See also
 ///
@@ -146,7 +146,7 @@ impl fmt::Display for ConvertValueOparg {
             Self::Str => "1 (str)",
             Self::Repr => "2 (repr)",
             Self::Ascii => "3 (ascii)",
-            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
+            // We should never reach this. `FVC_NONE` are being handled by `RealInstruction::FormatSimple`
             Self::None => "",
         };
 
@@ -452,9 +452,9 @@ pub struct OpArgState {
 
 impl OpArgState {
     #[inline(always)]
-    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
+    pub fn get(&mut self, ins: CodeUnit) -> (RealInstruction, OpArg) {
         let arg = self.extend(ins.arg);
-        if ins.op != Instruction::ExtendedArg {
+        if ins.op != RealInstruction::ExtendedArg {
             self.reset();
         }
         (ins.op, arg)
@@ -590,7 +590,7 @@ impl<T: OpArgType> fmt::Debug for Arg<T> {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 #[repr(transparent)]
 // XXX: if you add a new instruction that stores a Label, make sure to add it in
-// Instruction::label_arg
+// RealInstruction::label_arg
 pub struct Label(pub u32);
 
 impl OpArgType for Label {
@@ -677,14 +677,14 @@ pub type NameIdx = u32;
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct CodeUnit {
-    pub op: Instruction,
+    pub op: RealInstruction,
     pub arg: OpArgByte,
 }
 
 const _: () = assert!(mem::size_of::<CodeUnit>() == 2);
 
 impl CodeUnit {
-    pub const fn new(op: Instruction, arg: OpArgByte) -> Self {
+    pub const fn new(op: RealInstruction, arg: OpArgByte) -> Self {
         Self { op, arg }
     }
 }
@@ -941,9 +941,9 @@ op_arg_enum!(
     /// # Examples
     ///
     /// ```rust
-    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
+    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, RealInstruction};
     /// let (op, _) = Arg::new(BinaryOperator::Add);
-    /// let instruction = Instruction::BinaryOp { op };
+    /// let instruction = RealInstruction::BinaryOp { op };
     /// ```
     ///
     /// See also:
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 24cccbb3ed2..08308c7e96e 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -15,7 +15,7 @@ use crate::{
 /// HAVE_ARGUMENT = 44: opcodes 0-43 have no argument, 44+ have arguments.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
-pub enum Instruction {
+pub enum RealInstruction {
     // ==================== No-argument instructions (opcode < 44) ====================
     Cache = 0, // Placeholder
     BeforeAsyncWith = 1,
@@ -274,28 +274,19 @@ pub enum Instruction {
     JumpIfNotExcMatch(Arg<Label>) = 131,
     SetExcInfo = 134,
     Subscript = 135,
-    // ===== Pseudo Opcodes (252+) ======
-    Jump {
-        target: Arg<Label>,
-    } = 252, // CPython uses pseudo-op 256
-    LoadClosure(Arg<NameIdx>) = 253, // CPython uses pseudo-op 258
-    LoadAttrMethod {
-        idx: Arg<NameIdx>,
-    } = 254, // CPython uses pseudo-op 259
-    PopBlock = 255,                  // CPython uses pseudo-op 263
 }
 
-const _: () = assert!(mem::size_of::<Instruction>() == 1);
+const _: () = assert!(mem::size_of::<RealInstruction>() == 1);
 
-impl From<Instruction> for u8 {
+impl From<RealInstruction> for u8 {
     #[inline]
-    fn from(ins: Instruction) -> Self {
+    fn from(ins: RealInstruction) -> Self {
         // SAFETY: there's no padding bits
-        unsafe { core::mem::transmute::<Instruction, Self>(ins) }
+        unsafe { core::mem::transmute::<RealInstruction, Self>(ins) }
     }
 }
 
-impl TryFrom<u8> for Instruction {
+impl TryFrom<u8> for RealInstruction {
     type Error = MarshalError;
 
     #[inline]
@@ -340,16 +331,9 @@ impl TryFrom<u8> for Instruction {
             u8::from(Self::Subscript),
         ];
 
-        // Pseudo opcodes (252-255)
-        let pseudo_start = u8::from(Self::Jump {
-            target: Arg::marker(),
-        });
-        let pseudo_end = u8::from(Self::PopBlock);
-
         if (cpython_start..=cpython_end).contains(&value)
             || value == resume_id
             || custom_ops.contains(&value)
-            || (pseudo_start..=pseudo_end).contains(&value)
         {
             Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
         } else {
@@ -358,7 +342,7 @@ impl TryFrom<u8> for Instruction {
     }
 }
 
-impl Instruction {
+impl RealInstruction {
     /// Gets the label stored inside this instruction, if it exists
     #[inline]
     pub const fn label_arg(&self) -> Option<Arg<Label>> {
@@ -385,8 +369,8 @@ impl Instruction {
     /// # Examples
     ///
     /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
-    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction};
+    /// let jump_inst = RealInstruction::Jump { target: Arg::marker() };
     /// assert!(jump_inst.unconditional_branch())
     /// ```
     pub const fn unconditional_branch(&self) -> bool {
@@ -410,9 +394,9 @@ impl Instruction {
     /// # Examples
     ///
     /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label};
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label};
     /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = Instruction::Jump { target };
+    /// let jump_instruction = RealInstruction::Jump { target };
     /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
     /// ```
     ///
@@ -522,7 +506,6 @@ impl Instruction {
             Self::SetupAnnotations => 0,
             Self::BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
             Self::WithExceptStart => 1, // push __exit__ result
-            Self::PopBlock => 0,
             Self::RaiseVarargs { kind } => {
                 // Stack effects for different raise kinds:
                 // - Reraise (0): gets from VM state, no stack pop
@@ -775,7 +758,6 @@ impl Instruction {
             Self::MatchMapping => w!(MATCH_MAPPING),
             Self::MatchSequence => w!(MATCH_SEQUENCE),
             Self::Nop => w!(NOP),
-            Self::PopBlock => w!(POP_BLOCK),
             Self::PopExcept => w!(POP_EXCEPT),
             Self::PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
             Self::PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
@@ -820,3 +802,32 @@ impl Instruction {
         }
     }
 }
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(u16)]
+enum PseudoInstruction {
+    Jump { target: Arg<Label> } = 256,
+    LoadClosure(Arg<NameIdx>) = 258,
+    LoadAttrMethod { idx: Arg<NameIdx> } = 259,
+    PopBlock = 263,
+}
+
+const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum Instruction {
+    Real(RealInstruction),
+    Pseudo(PseudoInstruction),
+}
+
+impl From<RealInstruction> for Instruction {
+    fn from(value: RealInstruction) -> Self {
+        Self::Real(value)
+    }
+}
+
+impl From<PseudoInstruction> for Instruction {
+    fn from(value: PseudoInstruction) -> Self {
+        Self::Pseudo(value)
+    }
+}

From ea53cec9adb987a1687250649ac7a1efe60cd6ae Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 11 Jan 2026 23:09:43 +0200
Subject: [PATCH 02/35] save

---
 crates/codegen/src/compile.rs                 | 928 +++++++++---------
 crates/codegen/src/ir.rs                      |  40 +-
 crates/compiler-core/src/bytecode.rs          |  20 +-
 .../compiler-core/src/bytecode/instruction.rs |  93 +-
 4 files changed, 554 insertions(+), 527 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index b7bc3f4d9c7..fc9c2839a69 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -38,8 +38,8 @@ use rustpython_compiler_core::{
     Mode, OneIndexed, PositionEncoding, SourceFile, SourceLocation,
     bytecode::{
         self, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
-        ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, Invert, OpArg, OpArgType,
-        UnpackExArgs,
+        ComparisonOperator, ConstantData, ConvertValueOparg, Invert, OpArg, OpArgType,
+        RealInstruction, UnpackExArgs,
     },
 };
 use rustpython_wtf8::Wtf8Buf;
@@ -274,17 +274,17 @@ pub fn compile_expression(
 }
 
 macro_rules! emit {
-    ($c:expr, Instruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| Instruction::$op { $arg: x })
+    ($c:expr, $inst:ty { $arg:ident$(,)? }$(,)?) => {
+        $c.emit_arg($arg, |x| $inst { $arg: x })
     };
-    ($c:expr, Instruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| Instruction::$op { $arg: x })
+    ($c:expr, $inst:ty { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
+        $c.emit_arg($arg_val, |x| $inst { $arg: x })
     };
-    ($c:expr, Instruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
-        $c.emit_arg($arg_val, Instruction::$op)
+    ($c:expr, $inst:ty( $arg_val:expr $(,)? )$(,)?) => {
+        $c.emit_arg($arg_val, $inst)
     };
-    ($c:expr, Instruction::$op:ident$(,)?) => {
-        $c.emit_no_arg(Instruction::$op)
+    ($c:expr, $inst:ty$(,)?) => {
+        $c.emit_no_arg($inst)
     };
 }
 
@@ -495,12 +495,12 @@ impl Compiler {
             };
             match ctx {
                 ExprContext::Load => {
-                    emit!(self, Instruction::BuildSlice { argc });
-                    emit!(self, Instruction::Subscript);
+                    emit!(self, RealInstruction::BuildSlice { argc });
+                    emit!(self, RealInstruction::Subscript);
                 }
                 ExprContext::Store => {
-                    emit!(self, Instruction::BuildSlice { argc });
-                    emit!(self, Instruction::StoreSubscr);
+                    emit!(self, RealInstruction::BuildSlice { argc });
+                    emit!(self, RealInstruction::StoreSubscr);
                 }
                 _ => unreachable!(),
             }
@@ -510,9 +510,9 @@ impl Compiler {
 
             // Emit appropriate instruction based on context
             match ctx {
-                ExprContext::Load => emit!(self, Instruction::Subscript),
-                ExprContext::Store => emit!(self, Instruction::StoreSubscr),
-                ExprContext::Del => emit!(self, Instruction::DeleteSubscr),
+                ExprContext::Load => emit!(self, RealInstruction::Subscript),
+                ExprContext::Store => emit!(self, RealInstruction::StoreSubscr),
+                ExprContext::Del => emit!(self, RealInstruction::DeleteSubscr),
                 ExprContext::Invalid => {
                     return Err(self.error(CodegenErrorType::SyntaxError(
                         "Invalid expression context".to_owned(),
@@ -546,28 +546,28 @@ impl Compiler {
             match collection_type {
                 CollectionType::Tuple => {
                     if size > 1 || pushed > 0 {
-                        emit!(self, Instruction::BuildTupleFromTuples { size });
+                        emit!(self, RealInstruction::BuildTupleFromTuples { size });
                     }
                     // If size == 1 and pushed == 0, the single tuple is already on the stack
                 }
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildListFromTuples { size });
+                    emit!(self, RealInstruction::BuildListFromTuples { size });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSetFromTuples { size });
+                    emit!(self, RealInstruction::BuildSetFromTuples { size });
                 }
             }
         } else {
             // No starred elements
             match collection_type {
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size });
+                    emit!(self, RealInstruction::BuildTuple { size });
                 }
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size });
+                    emit!(self, RealInstruction::BuildList { size });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size });
+                    emit!(self, RealInstruction::BuildSet { size });
                 }
             }
         }
@@ -800,7 +800,7 @@ impl Compiler {
                         )));
                     }
                 };
-                self.emit_arg(idx, Instruction::LoadDeref);
+                self.emit_arg(idx, RealInstruction::LoadDeref);
 
                 // Load first parameter (typically 'self').
                 // Safety: can_optimize_super_call() ensures argcount > 0, and
@@ -990,7 +990,7 @@ impl Compiler {
         self.current_source_range = TextRange::default();
         emit!(
             self,
-            Instruction::Resume {
+            RealInstruction::Resume {
                 arg: bytecode::ResumeType::AtFuncStart as u32
             }
         );
@@ -1146,9 +1146,9 @@ impl Compiler {
             FBlockType::ForLoop => {
                 // Pop the iterator
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, RealInstruction::Swap { index: 2 });
                 }
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             }
 
             FBlockType::TryExcept => {
@@ -1168,53 +1168,53 @@ impl Compiler {
                 // Note: No lasti here - it's only pushed for cleanup handler exceptions
                 // We need to pop: exc, prev_exc (via PopExcept)
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, RealInstruction::Swap { index: 2 });
                 }
-                emit!(self, Instruction::PopTop); // exc
+                emit!(self, RealInstruction::PopTop); // exc
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, RealInstruction::Swap { index: 2 });
                 }
-                emit!(self, Instruction::PopExcept); // prev_exc is restored
+                emit!(self, RealInstruction::PopExcept); // prev_exc is restored
             }
 
             FBlockType::With | FBlockType::AsyncWith => {
                 // Stack when entering: [..., __exit__, return_value (if preserve_tos)]
                 // Need to call __exit__(None, None, None)
 
-                emit!(self, Instruction::PopBlock);
+                emit!(self, RealInstruction::PopBlock);
 
                 // If preserving return value, swap it below __exit__
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, RealInstruction::Swap { index: 2 });
                 }
                 // Stack after swap: [..., return_value, __exit__] or [..., __exit__]
 
                 // Call __exit__(None, None, None)
                 // Call protocol: [callable, self_or_null, arg1, arg2, arg3]
-                emit!(self, Instruction::PushNull);
+                emit!(self, RealInstruction::PushNull);
                 // Stack: [..., __exit__, NULL]
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
                 // Stack: [..., __exit__, NULL, None, None, None]
-                emit!(self, Instruction::Call { nargs: 3 });
+                emit!(self, RealInstruction::Call { nargs: 3 });
 
                 // For async with, await the result
                 if matches!(info.fb_type, FBlockType::AsyncWith) {
-                    emit!(self, Instruction::GetAwaitable);
+                    emit!(self, RealInstruction::GetAwaitable);
                     self.emit_load_const(ConstantData::None);
                     self.compile_yield_from_sequence(true)?;
                 }
 
                 // Pop the __exit__ result
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             }
 
             FBlockType::HandlerCleanup => {
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, RealInstruction::Swap { index: 2 });
                 }
-                emit!(self, Instruction::PopExcept);
+                emit!(self, RealInstruction::PopExcept);
 
                 // If there's an exception name, clean it up
                 if let FBlockDatum::ExceptionName(ref name) = info.fb_datum {
@@ -1226,9 +1226,9 @@ impl Compiler {
 
             FBlockType::PopValue => {
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, RealInstruction::Swap { index: 2 });
                 }
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             }
         }
         Ok(())
@@ -1495,11 +1495,11 @@ impl Compiler {
                 value: value.into(),
             });
             let doc = self.name("__doc__");
-            emit!(self, Instruction::StoreGlobal(doc))
+            emit!(self, RealInstruction::StoreGlobal(doc))
         }
 
         if Self::find_ann(statements) {
-            emit!(self, Instruction::SetupAnnotations);
+            emit!(self, RealInstruction::SetupAnnotations);
         }
 
         self.compile_statements(statements)?;
@@ -1519,7 +1519,7 @@ impl Compiler {
         self.symbol_table_stack.push(symbol_table);
 
         if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotations);
+            emit!(self, RealInstruction::SetupAnnotations);
         }
 
         if let Some((last, body)) = body.split_last() {
@@ -1528,12 +1528,12 @@ impl Compiler {
                     self.compile_expression(value)?;
                     emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
+                        RealInstruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::Print
                         }
                     );
 
-                    emit!(self, Instruction::PopTop);
+                    emit!(self, RealInstruction::PopTop);
                 } else {
                     self.compile_statement(statement)?;
                 }
@@ -1541,15 +1541,15 @@ impl Compiler {
 
             if let Stmt::Expr(StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, RealInstruction::Copy { index: 1_u32 });
                 emit!(
                     self,
-                    Instruction::CallIntrinsic1 {
+                    RealInstruction::CallIntrinsic1 {
                         func: bytecode::IntrinsicFunction1::Print
                     }
                 );
 
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             } else {
                 self.compile_statement(last)?;
                 self.emit_load_const(ConstantData::None);
@@ -1574,12 +1574,12 @@ impl Compiler {
         if let Some(last_statement) = body.last() {
             match last_statement {
                 Stmt::Expr(_) => {
-                    self.current_block().instructions.pop(); // pop Instruction::PopTop
+                    self.current_block().instructions.pop(); // pop RealInstruction::PopTop
                 }
                 Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
                     let pop_instructions = self.current_block().instructions.pop();
-                    let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    let store_inst = compiler_unwrap_option(self, pop_instructions); // pop RealInstruction::Store
+                    emit!(self, RealInstruction::Copy { index: 1_u32 });
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -1720,40 +1720,40 @@ impl Compiler {
                     NameUsage::Load => {
                         // Special case for class scope
                         if self.ctx.in_class && !self.ctx.in_func() {
-                            Instruction::LoadFromDictOrDeref
+                            RealInstruction::LoadFromDictOrDeref
                         } else {
-                            Instruction::LoadDeref
+                            RealInstruction::LoadDeref
                         }
                     }
-                    NameUsage::Store => Instruction::StoreDeref,
-                    NameUsage::Delete => Instruction::DeleteDeref,
+                    NameUsage::Store => RealInstruction::StoreDeref,
+                    NameUsage::Delete => RealInstruction::DeleteDeref,
                 };
                 self.emit_arg(idx, op);
             }
             NameOp::Fast => {
                 let idx = self.get_local_var_index(&name)?;
                 let op = match usage {
-                    NameUsage::Load => Instruction::LoadFast,
-                    NameUsage::Store => Instruction::StoreFast,
-                    NameUsage::Delete => Instruction::DeleteFast,
+                    NameUsage::Load => RealInstruction::LoadFast,
+                    NameUsage::Store => RealInstruction::StoreFast,
+                    NameUsage::Delete => RealInstruction::DeleteFast,
                 };
                 self.emit_arg(idx, op);
             }
             NameOp::Global => {
                 let idx = self.get_global_name_index(&name);
                 let op = match usage {
-                    NameUsage::Load => Instruction::LoadGlobal,
-                    NameUsage::Store => Instruction::StoreGlobal,
-                    NameUsage::Delete => Instruction::DeleteGlobal,
+                    NameUsage::Load => RealInstruction::LoadGlobal,
+                    NameUsage::Store => RealInstruction::StoreGlobal,
+                    NameUsage::Delete => RealInstruction::DeleteGlobal,
                 };
                 self.emit_arg(idx, op);
             }
             NameOp::Name => {
                 let idx = self.get_global_name_index(&name);
                 let op = match usage {
-                    NameUsage::Load => Instruction::LoadName,
-                    NameUsage::Store => Instruction::StoreName,
-                    NameUsage::Delete => Instruction::DeleteName,
+                    NameUsage::Load => RealInstruction::LoadName,
+                    NameUsage::Store => RealInstruction::StoreName,
+                    NameUsage::Delete => RealInstruction::DeleteName,
                 };
                 self.emit_arg(idx, op);
             }
@@ -1796,11 +1796,11 @@ impl Compiler {
                     });
                     self.emit_load_const(ConstantData::None);
                     let idx = self.name(&name.name);
-                    emit!(self, Instruction::ImportName { idx });
+                    emit!(self, RealInstruction::ImportName { idx });
                     if let Some(alias) = &name.asname {
                         for part in name.name.split('.').skip(1) {
                             let idx = self.name(part);
-                            emit!(self, Instruction::LoadAttr { idx });
+                            emit!(self, RealInstruction::LoadAttr { idx });
                         }
                         self.store_name(alias.as_str())?
                     } else {
@@ -1843,13 +1843,13 @@ impl Compiler {
 
                 let module_name = module.as_ref().map_or("", |s| s.as_str());
                 let module_idx = self.name(module_name);
-                emit!(self, Instruction::ImportName { idx: module_idx });
+                emit!(self, RealInstruction::ImportName { idx: module_idx });
 
                 if import_star {
                     // from .... import *
                     emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
+                        RealInstruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::ImportStar
                         }
                     );
@@ -1860,7 +1860,7 @@ impl Compiler {
                         let name = &name;
                         let idx = self.name(name.name.as_str());
                         // import symbol from module:
-                        emit!(self, Instruction::ImportFrom { idx });
+                        emit!(self, RealInstruction::ImportFrom { idx });
 
                         // Store module under proper name:
                         if let Some(alias) = &name.asname {
@@ -1871,14 +1871,14 @@ impl Compiler {
                     }
 
                     // Pop module from stack:
-                    emit!(self, Instruction::PopTop);
+                    emit!(self, RealInstruction::PopTop);
                 }
             }
             Stmt::Expr(StmtExpr { value, .. }) => {
                 self.compile_expression(value)?;
 
                 // Pop result of stack, since we not use it:
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             }
             Stmt::Global(_) | Stmt::Nonlocal(_) => {
                 // Handled during symbol table construction.
@@ -1906,7 +1906,7 @@ impl Compiler {
                         self.compile_statements(body)?;
                         emit!(
                             self,
-                            Instruction::Jump {
+                            PseudoInstruction::Jump {
                                 target: after_block
                             }
                         );
@@ -1922,7 +1922,7 @@ impl Compiler {
                             self.compile_statements(&clause.body)?;
                             emit!(
                                 self,
-                                Instruction::Jump {
+                                PseudoInstruction::Jump {
                                     target: after_block
                                 }
                             );
@@ -1972,7 +1972,7 @@ impl Compiler {
                     None => bytecode::RaiseKind::BareRaise,
                 };
                 self.set_source_range(*range);
-                emit!(self, Instruction::RaiseVarargs { kind });
+                emit!(self, RealInstruction::RaiseVarargs { kind });
             }
             Stmt::Try(StmtTry {
                 body,
@@ -2031,20 +2031,20 @@ impl Compiler {
                     self.compile_jump_if(test, true, after_block)?;
 
                     let assertion_error = self.name("AssertionError");
-                    emit!(self, Instruction::LoadGlobal(assertion_error));
-                    emit!(self, Instruction::PushNull);
+                    emit!(self, RealInstruction::LoadGlobal(assertion_error));
+                    emit!(self, RealInstruction::PushNull);
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
-                            emit!(self, Instruction::Call { nargs: 1 });
+                            emit!(self, RealInstruction::Call { nargs: 1 });
                         }
                         None => {
-                            emit!(self, Instruction::Call { nargs: 0 });
+                            emit!(self, RealInstruction::Call { nargs: 0 });
                         }
                     }
                     emit!(
                         self,
-                        Instruction::RaiseVarargs {
+                        RealInstruction::RaiseVarargs {
                             kind: bytecode::RaiseKind::Raise,
                         }
                     );
@@ -2097,7 +2097,7 @@ impl Compiler {
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, Instruction::Copy { index: 1_u32 });
+                        emit!(self, RealInstruction::Copy { index: 1_u32 });
                     }
                     self.compile_store(target)?;
                 }
@@ -2166,10 +2166,10 @@ impl Compiler {
                 }
 
                 // Build tuple of 3 elements and call intrinsic
-                emit!(self, Instruction::BuildTuple { size: 3 });
+                emit!(self, RealInstruction::BuildTuple { size: 3 });
                 emit!(
                     self,
-                    Instruction::CallIntrinsic1 {
+                    RealInstruction::CallIntrinsic1 {
                         func: bytecode::IntrinsicFunction1::TypeAlias
                     }
                 );
@@ -2188,7 +2188,7 @@ impl Compiler {
                 self.check_forbidden_name(attr.as_str(), NameUsage::Delete)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, Instruction::DeleteAttr { idx });
+                emit!(self, RealInstruction::DeleteAttr { idx });
             }
             Expr::Subscript(ExprSubscript {
                 value, slice, ctx, ..
@@ -2255,7 +2255,7 @@ impl Compiler {
     fn prepare_decorators(&mut self, decorator_list: &[Decorator]) -> CompileResult<()> {
         for decorator in decorator_list {
             self.compile_expression(&decorator.expression)?;
-            emit!(self, Instruction::PushNull);
+            emit!(self, RealInstruction::PushNull);
         }
         Ok(())
     }
@@ -2266,7 +2266,7 @@ impl Compiler {
     /// applying decorators bottom-up (innermost first).
     fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
         for _ in decorator_list {
-            emit!(self, Instruction::Call { nargs: 1 });
+            emit!(self, RealInstruction::Call { nargs: 1 });
         }
     }
 
@@ -2291,14 +2291,14 @@ impl Compiler {
         if allow_starred && matches!(expr, Expr::Starred(_)) {
             if let Expr::Starred(starred) = expr {
                 self.compile_expression(&starred.value)?;
-                emit!(self, Instruction::UnpackSequence { size: 1 });
+                emit!(self, RealInstruction::UnpackSequence { size: 1 });
             }
         } else {
             self.compile_expression(expr)?;
         }
 
         // Return value
-        emit!(self, Instruction::ReturnValue);
+        emit!(self, RealInstruction::ReturnValue);
 
         // Exit scope and create closure
         let code = self.exit_scope();
@@ -2306,10 +2306,10 @@ impl Compiler {
 
         // Create type params function with closure
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
-        emit!(self, Instruction::PushNull);
+        emit!(self, RealInstruction::PushNull);
 
         // Call the function immediately
-        emit!(self, Instruction::Call { nargs: 0 });
+        emit!(self, RealInstruction::Call { nargs: 0 });
 
         Ok(())
     }
@@ -2343,11 +2343,11 @@ impl Compiler {
                         } else {
                             bytecode::IntrinsicFunction2::TypeVarWithBound
                         };
-                        emit!(self, Instruction::CallIntrinsic2 { func: intrinsic });
+                        emit!(self, RealInstruction::CallIntrinsic2 { func: intrinsic });
                     } else {
                         emit!(
                             self,
-                            Instruction::CallIntrinsic1 {
+                            RealInstruction::CallIntrinsic1 {
                                 func: bytecode::IntrinsicFunction1::TypeVar
                             }
                         );
@@ -2358,13 +2358,13 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
                         emit!(
                             self,
-                            Instruction::CallIntrinsic2 {
+                            RealInstruction::CallIntrinsic2 {
                                 func: bytecode::IntrinsicFunction2::SetTypeparamDefault
                             }
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, RealInstruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
@@ -2373,7 +2373,7 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
+                        RealInstruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::ParamSpec
                         }
                     );
@@ -2383,13 +2383,13 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
                         emit!(
                             self,
-                            Instruction::CallIntrinsic2 {
+                            RealInstruction::CallIntrinsic2 {
                                 func: bytecode::IntrinsicFunction2::SetTypeparamDefault
                             }
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, RealInstruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
@@ -2398,7 +2398,7 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
+                        RealInstruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::TypeVarTuple
                         }
                     );
@@ -2409,20 +2409,20 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, true)?;
                         emit!(
                             self,
-                            Instruction::CallIntrinsic2 {
+                            RealInstruction::CallIntrinsic2 {
                                 func: bytecode::IntrinsicFunction2::SetTypeparamDefault
                             }
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, RealInstruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
             };
         }
         emit!(
             self,
-            Instruction::BuildTuple {
+            RealInstruction::BuildTuple {
                 size: u32::try_from(type_params.len()).unwrap(),
             }
         );
@@ -2510,7 +2510,7 @@ impl Compiler {
             }
 
             // Jump to end (skip exception path blocks)
-            emit!(self, Instruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { target: end_block });
 
             if let Some(finally_except) = finally_except_block {
                 // Restore sub_tables for exception path compilation
@@ -2524,7 +2524,7 @@ impl Compiler {
                 // PUSH_EXC_INFO first, THEN push FinallyEnd fblock
                 // Stack after unwind (no lasti): [exc] (depth = current_depth + 1)
                 // Stack after PUSH_EXC_INFO: [prev_exc, exc] (depth = current_depth + 2)
-                emit!(self, Instruction::PushExcInfo);
+                emit!(self, RealInstruction::PushExcInfo);
                 if let Some(cleanup) = finally_cleanup_block {
                     // FinallyEnd fblock must be pushed AFTER PUSH_EXC_INFO
                     // Depth = current_depth + 1 (only prev_exc remains after RERAISE pops exc)
@@ -2544,7 +2544,7 @@ impl Compiler {
                 // which then properly restores prev_exc before going to outer handler
                 emit!(
                     self,
-                    Instruction::RaiseVarargs {
+                    RealInstruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack
                     }
                 );
@@ -2555,11 +2555,11 @@ impl Compiler {
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::Copy { index: 3_u32 });
-                emit!(self, Instruction::PopExcept);
+                emit!(self, RealInstruction::Copy { index: 3_u32 });
+                emit!(self, RealInstruction::PopExcept);
                 emit!(
                     self,
-                    Instruction::RaiseVarargs {
+                    RealInstruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack
                     }
                 );
@@ -2583,7 +2583,7 @@ impl Compiler {
         self.compile_statements(body)?;
         self.pop_fblock(FBlockType::TryExcept);
         // No PopBlock emit - exception table handles this
-        emit!(self, Instruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { target: else_block });
 
         // except handlers:
         self.switch_to_block(handler_block);
@@ -2605,7 +2605,7 @@ impl Compiler {
 
         // Exception is on top of stack now, pushed by unwind_blocks
         // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopExcept
-        emit!(self, Instruction::PushExcInfo);
+        emit!(self, RealInstruction::PushExcInfo);
         for handler in handlers {
             let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
                 type_, name, body, ..
@@ -2616,23 +2616,23 @@ impl Compiler {
             // check if this handler can handle the exception:
             if let Some(exc_type) = type_ {
                 // Duplicate exception for test:
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, RealInstruction::Copy { index: 1_u32 });
 
                 // Check exception type:
                 self.compile_expression(exc_type)?;
-                emit!(self, Instruction::JumpIfNotExcMatch(next_handler));
+                emit!(self, PseudoInstruction::JumpIfNotExcMatch(next_handler));
 
                 // We have a match, store in name (except x as y)
                 if let Some(alias) = name {
                     self.store_name(alias.as_str())?
                 } else {
                     // Drop exception from top of stack:
-                    emit!(self, Instruction::PopTop);
+                    emit!(self, RealInstruction::PopTop);
                 }
             } else {
                 // Catch all!
                 // Drop exception from top of stack:
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             }
 
             // If name is bound, we need a cleanup handler for RERAISE
@@ -2666,7 +2666,7 @@ impl Compiler {
             let handler_normal_exit = self.new_block();
             emit!(
                 self,
-                Instruction::Jump {
+                PseudoInstruction::Jump {
                     target: handler_normal_exit,
                 }
             );
@@ -2689,7 +2689,7 @@ impl Compiler {
                 // which does COPY 3; POP_EXCEPT; RERAISE
                 emit!(
                     self,
-                    Instruction::RaiseVarargs {
+                    RealInstruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack,
                     }
                 );
@@ -2702,7 +2702,7 @@ impl Compiler {
             // POP_BLOCK (HandlerCleanup) then POP_BLOCK (SETUP_CLEANUP)
             // followed by POP_EXCEPT
             self.pop_fblock(FBlockType::ExceptionHandler);
-            emit!(self, Instruction::PopExcept);
+            emit!(self, RealInstruction::PopExcept);
 
             // Delete the exception variable if it was bound (normal path)
             if let Some(alias) = name {
@@ -2715,7 +2715,7 @@ impl Compiler {
             // Jump to finally block
             emit!(
                 self,
-                Instruction::Jump {
+                PseudoInstruction::Jump {
                     target: finally_block,
                 }
             );
@@ -2742,7 +2742,7 @@ impl Compiler {
         // NOTE: We emit RERAISE 0 BEFORE popping fblock so it is within cleanup handler scope
         emit!(
             self,
-            Instruction::RaiseVarargs {
+            RealInstruction::RaiseVarargs {
                 kind: bytecode::RaiseKind::ReraiseFromStack,
             }
         );
@@ -2757,11 +2757,11 @@ impl Compiler {
         // POP_EXCEPT: pop prev_exc from stack and restore -> [prev_exc, lasti, exc]
         // RERAISE 1: reraise with lasti
         self.switch_to_block(cleanup_block);
-        emit!(self, Instruction::Copy { index: 3_u32 });
-        emit!(self, Instruction::PopExcept);
+        emit!(self, RealInstruction::Copy { index: 3_u32 });
+        emit!(self, RealInstruction::PopExcept);
         emit!(
             self,
-            Instruction::RaiseVarargs {
+            RealInstruction::RaiseVarargs {
                 kind: bytecode::RaiseKind::ReraiseFromStack,
             }
         );
@@ -2790,7 +2790,7 @@ impl Compiler {
             self.compile_statements(finalbody)?;
             // Jump to end_block to skip exception path blocks
             // This prevents fall-through to finally_except_block
-            emit!(self, Instruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { target: end_block });
         }
 
         // finally (exception path)
@@ -2824,7 +2824,7 @@ impl Compiler {
 
             // PUSH_EXC_INFO: [lasti, exc] -> [lasti, prev_exc, exc]
             // Sets exc as current VM exception, saves prev_exc for restoration
-            emit!(self, Instruction::PushExcInfo);
+            emit!(self, RealInstruction::PushExcInfo);
 
             // Run finally body
             self.compile_statements(finalbody)?;
@@ -2836,7 +2836,7 @@ impl Compiler {
             // Stack: [lasti, prev_exc, exc] - exception is on top
             emit!(
                 self,
-                Instruction::RaiseVarargs {
+                RealInstruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack,
                 }
             );
@@ -2852,13 +2852,13 @@ impl Compiler {
         if let Some(cleanup) = finally_cleanup_block {
             self.switch_to_block(cleanup);
             // COPY 3: copy the exception from position 3
-            emit!(self, Instruction::Copy { index: 3_u32 });
+            emit!(self, RealInstruction::Copy { index: 3_u32 });
             // POP_EXCEPT: restore prev_exc as current exception
-            emit!(self, Instruction::PopExcept);
+            emit!(self, RealInstruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
             emit!(
                 self,
-                Instruction::RaiseVarargs {
+                RealInstruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack,
                 }
             );
@@ -2916,14 +2916,14 @@ impl Compiler {
         )?;
         self.compile_statements(body)?;
         self.pop_fblock(FBlockType::TryExcept);
-        emit!(self, Instruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { target: else_block });
 
         // Exception handler entry
         self.switch_to_block(handler_block);
         // Stack: [exc] (from exception table)
 
         // PUSH_EXC_INFO
-        emit!(self, Instruction::PushExcInfo);
+        emit!(self, RealInstruction::PushExcInfo);
         // Stack: [prev_exc, exc]
 
         // Push EXCEPTION_GROUP_HANDLER fblock
@@ -2943,10 +2943,10 @@ impl Compiler {
             // first handler creates list and copies exc
             if i == 0 {
                 // ADDOP_I(c, loc, BUILD_LIST, 0);
-                emit!(self, Instruction::BuildList { size: 0 });
+                emit!(self, RealInstruction::BuildList { size: 0 });
                 // Stack: [prev_exc, exc, []]
                 // ADDOP_I(c, loc, COPY, 2);
-                emit!(self, Instruction::Copy { index: 2 });
+                emit!(self, RealInstruction::Copy { index: 2 });
                 // Stack: [prev_exc, exc, [], exc_copy]
                 // Now stack is: [prev_exc, orig, list, rest]
             }
@@ -2971,17 +2971,17 @@ impl Compiler {
             // Stack: [prev_exc, orig, list, rest, type]
 
             // ADDOP(c, loc, CHECK_EG_MATCH);
-            emit!(self, Instruction::CheckEgMatch);
+            emit!(self, RealInstruction::CheckEgMatch);
             // Stack: [prev_exc, orig, list, new_rest, match]
 
             // ADDOP_I(c, loc, COPY, 1);
             // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
-            emit!(self, Instruction::Copy { index: 1 });
+            emit!(self, RealInstruction::Copy { index: 1 });
             self.emit_load_const(ConstantData::None);
-            emit!(self, Instruction::IsOp(bytecode::Invert::No)); // is None?
+            emit!(self, RealInstruction::IsOp(bytecode::Invert::No)); // is None?
             emit!(
                 self,
-                Instruction::PopJumpIfTrue {
+                RealInstruction::PopJumpIfTrue {
                     target: no_match_block
                 }
             );
@@ -2993,13 +2993,13 @@ impl Compiler {
             // Set matched exception as current exception (for __context__ in handler body)
             // This ensures that exceptions raised in the handler get the matched part
             // as their __context__, not the original full exception group
-            emit!(self, Instruction::SetExcInfo);
+            emit!(self, RealInstruction::SetExcInfo);
 
             // Store match to name or pop
             if let Some(alias) = name {
                 self.store_name(alias.as_str())?;
             } else {
-                emit!(self, Instruction::PopTop); // pop match
+                emit!(self, RealInstruction::PopTop); // pop match
             }
             // Stack: [prev_exc, orig, list, new_rest]
 
@@ -3029,7 +3029,7 @@ impl Compiler {
             }
 
             // Jump to next handler
-            emit!(self, Instruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { target: next_block });
 
             // Handler raised an exception (cleanup_end label)
             self.switch_to_block(handler_except_block);
@@ -3048,20 +3048,20 @@ impl Compiler {
             // After pop: [prev_exc, orig, list, new_rest, lasti] (len=5)
             // nth_value(i) = stack[len - i - 1], we need stack[2] = list
             // stack[5 - i - 1] = 2 -> i = 2
-            emit!(self, Instruction::ListAppend { i: 2 });
+            emit!(self, RealInstruction::ListAppend { i: 2 });
             // Stack: [prev_exc, orig, list, new_rest, lasti]
 
             // POP_TOP - pop lasti
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
             // Stack: [prev_exc, orig, list, new_rest]
 
             // JUMP except_with_error
             // We directly JUMP to next_block since no_match_block falls through to it
-            emit!(self, Instruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { target: next_block });
 
             // No match - pop match (None)
             self.switch_to_block(no_match_block);
-            emit!(self, Instruction::PopTop); // pop match (None)
+            emit!(self, RealInstruction::PopTop); // pop match (None)
             // Stack: [prev_exc, orig, list, new_rest]
             // Falls through to next_block
 
@@ -3077,11 +3077,11 @@ impl Compiler {
                 // PEEK(1) = stack[len-1] after pop
                 // RustPython nth_value(i) = stack[len-i-1] after pop
                 // For LIST_APPEND 1: stack[len-1] = stack[len-i-1] -> i = 0
-                emit!(self, Instruction::ListAppend { i: 0 });
+                emit!(self, RealInstruction::ListAppend { i: 0 });
                 // Stack: [prev_exc, orig, list]
                 emit!(
                     self,
-                    Instruction::Jump {
+                    PseudoInstruction::Jump {
                         target: reraise_star_block
                     }
                 );
@@ -3099,22 +3099,22 @@ impl Compiler {
         // Takes 2 args (orig, list) and produces result
         emit!(
             self,
-            Instruction::CallIntrinsic2 {
+            RealInstruction::CallIntrinsic2 {
                 func: bytecode::IntrinsicFunction2::PrepReraiseStar
             }
         );
         // Stack: [prev_exc, result]
 
         // COPY 1
-        emit!(self, Instruction::Copy { index: 1 });
+        emit!(self, RealInstruction::Copy { index: 1 });
         // Stack: [prev_exc, result, result]
 
         // POP_JUMP_IF_NOT_NONE reraise
         self.emit_load_const(ConstantData::None);
-        emit!(self, Instruction::IsOp(bytecode::Invert::Yes)); // is not None?
+        emit!(self, RealInstruction::IsOp(bytecode::Invert::Yes)); // is not None?
         emit!(
             self,
-            Instruction::PopJumpIfTrue {
+            RealInstruction::PopJumpIfTrue {
                 target: reraise_block
             }
         );
@@ -3122,19 +3122,19 @@ impl Compiler {
 
         // Nothing to reraise
         // POP_TOP - pop result (None)
-        emit!(self, Instruction::PopTop);
+        emit!(self, RealInstruction::PopTop);
         // Stack: [prev_exc]
 
         // POP_BLOCK - no-op for us with exception tables (fblocks handle this)
         // POP_EXCEPT - restore previous exception context
-        emit!(self, Instruction::PopExcept);
+        emit!(self, RealInstruction::PopExcept);
         // Stack: []
 
         if !finalbody.is_empty() {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, Instruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { target: end_block });
 
         // Reraise the result
         self.switch_to_block(reraise_block);
@@ -3142,15 +3142,15 @@ impl Compiler {
 
         // POP_BLOCK - no-op for us
         // SWAP 2
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, RealInstruction::Swap { index: 2 });
         // Stack: [result, prev_exc]
 
         // POP_EXCEPT
-        emit!(self, Instruction::PopExcept);
+        emit!(self, RealInstruction::PopExcept);
         // Stack: [result]
 
         // RERAISE 0
-        emit!(self, Instruction::Reraise { depth: 0 });
+        emit!(self, RealInstruction::Reraise { depth: 0 });
 
         // try-else path
         // NOTE: When we reach here in compilation, the nothing-to-reraise path above
@@ -3175,7 +3175,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, Instruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { target: end_block });
 
         self.switch_to_block(end_block);
         if !finalbody.is_empty() {
@@ -3213,7 +3213,7 @@ impl Compiler {
             }
             emit!(
                 self,
-                Instruction::BuildTuple {
+                RealInstruction::BuildTuple {
                     size: defaults.len().to_u32()
                 }
             );
@@ -3238,7 +3238,7 @@ impl Compiler {
             }
             emit!(
                 self,
-                Instruction::BuildMap {
+                RealInstruction::BuildMap {
                     size: kw_with_defaults.len().to_u32(),
                 }
             );
@@ -3308,13 +3308,13 @@ impl Compiler {
 
         // Handle docstring if present
         if let Some(doc) = doc_str {
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, RealInstruction::Copy { index: 1_u32 });
             self.emit_load_const(ConstantData::Str {
                 value: doc.to_string().into(),
             });
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, RealInstruction::Swap { index: 2 });
             let doc_attr = self.name("__doc__");
-            emit!(self, Instruction::StoreAttr { idx: doc_attr });
+            emit!(self, RealInstruction::StoreAttr { idx: doc_attr });
         }
 
         Ok(())
@@ -3420,7 +3420,7 @@ impl Compiler {
 
             // Load defaults/kwdefaults with LOAD_FAST
             for i in 0..num_typeparam_args {
-                emit!(self, Instruction::LoadFast(i as u32));
+                emit!(self, RealInstruction::LoadFast(i as u32));
             }
         }
 
@@ -3431,7 +3431,7 @@ impl Compiler {
             annotations_flag = bytecode::MakeFunctionFlags::ANNOTATIONS;
             emit!(
                 self,
-                Instruction::BuildMap {
+                RealInstruction::BuildMap {
                     size: num_annotations,
                 }
             );
@@ -3445,18 +3445,18 @@ impl Compiler {
         if is_generic {
             // SWAP to get function on top
             // Stack: [type_params_tuple, function] -> [function, type_params_tuple]
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, RealInstruction::Swap { index: 2 });
 
             // Call INTRINSIC_SET_FUNCTION_TYPE_PARAMS
             emit!(
                 self,
-                Instruction::CallIntrinsic2 {
+                RealInstruction::CallIntrinsic2 {
                     func: bytecode::IntrinsicFunction2::SetFunctionTypeParams,
                 }
             );
 
             // Return the function object from type params scope
-            emit!(self, Instruction::ReturnValue);
+            emit!(self, RealInstruction::ReturnValue);
 
             // Set argcount for type params scope
             self.current_code_info().metadata.argcount = num_typeparam_args as u32;
@@ -3476,31 +3476,31 @@ impl Compiler {
                 match num_typeparam_args {
                     1 => {
                         // Stack: [arg1, closure]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]
-                        emit!(self, Instruction::PushNull); // [closure, arg1, NULL]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]
+                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, arg1]
+                        emit!(self, RealInstruction::PushNull); // [closure, arg1, NULL]
+                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, NULL, arg1]
                     }
                     2 => {
                         // Stack: [arg1, arg2, closure]
-                        emit!(self, Instruction::Swap { index: 3 }); // [closure, arg2, arg1]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1, arg2]
-                        emit!(self, Instruction::PushNull); // [closure, arg1, arg2, NULL]
-                        emit!(self, Instruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]
+                        emit!(self, RealInstruction::Swap { index: 3 }); // [closure, arg2, arg1]
+                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, arg1, arg2]
+                        emit!(self, RealInstruction::PushNull); // [closure, arg1, arg2, NULL]
+                        emit!(self, RealInstruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]
+                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]
                     }
                     _ => unreachable!("only defaults and kwdefaults are supported"),
                 }
                 emit!(
                     self,
-                    Instruction::Call {
+                    RealInstruction::Call {
                         nargs: num_typeparam_args as u32
                     }
                 );
             } else {
                 // Stack: [closure]
-                emit!(self, Instruction::PushNull);
+                emit!(self, RealInstruction::PushNull);
                 // Stack: [closure, NULL]
-                emit!(self, Instruction::Call { nargs: 0 });
+                emit!(self, RealInstruction::Call { nargs: 0 });
             }
         }
 
@@ -3601,13 +3601,13 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, Instruction::LoadClosure(idx.to_u32()));
+                emit!(self, RealInstruction::LoadClosure(idx.to_u32()));
             }
 
             // Build tuple of closure variables
             emit!(
                 self,
-                Instruction::BuildTuple {
+                RealInstruction::BuildTuple {
                     size: code.freevars.len().to_u32(),
                 }
             );
@@ -3619,7 +3619,7 @@ impl Compiler {
         });
 
         // Create function with no flags
-        emit!(self, Instruction::MakeFunction);
+        emit!(self, RealInstruction::MakeFunction);
 
         // Now set attributes one by one using SET_FUNCTION_ATTRIBUTE
         // Note: The order matters! Values must be on stack before calling SET_FUNCTION_ATTRIBUTE
@@ -3628,7 +3628,7 @@ impl Compiler {
         if has_freevars {
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
+                RealInstruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::CLOSURE
                 }
             );
@@ -3638,7 +3638,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::ANNOTATIONS) {
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
+                RealInstruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::ANNOTATIONS
                 }
             );
@@ -3648,7 +3648,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
+                RealInstruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
                 }
             );
@@ -3658,7 +3658,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
+                RealInstruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::DEFAULTS
                 }
             );
@@ -3668,7 +3668,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::TYPE_PARAMS) {
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
+                RealInstruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::TYPE_PARAMS
                 }
             );
@@ -3738,22 +3738,22 @@ impl Compiler {
 
         // Load (global) __name__ and store as __module__
         let dunder_name = self.name("__name__");
-        emit!(self, Instruction::LoadGlobal(dunder_name));
+        emit!(self, RealInstruction::LoadGlobal(dunder_name));
         let dunder_module = self.name("__module__");
-        emit!(self, Instruction::StoreName(dunder_module));
+        emit!(self, RealInstruction::StoreName(dunder_module));
 
         // Store __qualname__
         self.emit_load_const(ConstantData::Str {
             value: qualname.into(),
         });
         let qualname_name = self.name("__qualname__");
-        emit!(self, Instruction::StoreName(qualname_name));
+        emit!(self, RealInstruction::StoreName(qualname_name));
 
         // Store __doc__ only if there's an explicit docstring
         if let Some(doc) = doc_str {
             self.emit_load_const(ConstantData::Str { value: doc.into() });
             let doc_name = self.name("__doc__");
-            emit!(self, Instruction::StoreName(doc_name));
+            emit!(self, RealInstruction::StoreName(doc_name));
         }
 
         // Store __firstlineno__ (new in Python 3.12+)
@@ -3761,22 +3761,22 @@ impl Compiler {
             value: BigInt::from(firstlineno),
         });
         let firstlineno_name = self.name("__firstlineno__");
-        emit!(self, Instruction::StoreName(firstlineno_name));
+        emit!(self, RealInstruction::StoreName(firstlineno_name));
 
         // Set __type_params__ if we have type parameters
         if type_params.is_some() {
             // Load .type_params from enclosing scope
             let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(self, RealInstruction::LoadName(dot_type_params));
 
             // Store as __type_params__
             let dunder_type_params = self.name("__type_params__");
-            emit!(self, Instruction::StoreName(dunder_type_params));
+            emit!(self, RealInstruction::StoreName(dunder_type_params));
         }
 
         // Setup annotations if needed
         if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotations);
+            emit!(self, RealInstruction::SetupAnnotations);
         }
 
         // 3. Compile the class body
@@ -3793,10 +3793,10 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, RealInstruction::LoadClosure(classcell_idx.to_u32()));
+            emit!(self, RealInstruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
-            emit!(self, Instruction::StoreName(classcell));
+            emit!(self, RealInstruction::StoreName(classcell));
         } else {
             self.emit_load_const(ConstantData::None);
         }
@@ -3838,7 +3838,7 @@ impl Compiler {
             // Compile type parameters and store as .type_params
             self.compile_type_params(type_params.unwrap())?;
             let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::StoreName(dot_type_params));
+            emit!(self, RealInstruction::StoreName(dot_type_params));
         }
 
         // Step 2: Compile class body (always done, whether generic or not)
@@ -3859,22 +3859,22 @@ impl Compiler {
             let dot_generic_base = self.name(".generic_base");
 
             // Create .generic_base
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(self, RealInstruction::LoadName(dot_type_params));
             emit!(
                 self,
-                Instruction::CallIntrinsic1 {
+                RealInstruction::CallIntrinsic1 {
                     func: bytecode::IntrinsicFunction1::SubscriptGeneric
                 }
             );
-            emit!(self, Instruction::StoreName(dot_generic_base));
+            emit!(self, RealInstruction::StoreName(dot_generic_base));
 
             // Generate class creation code
-            emit!(self, Instruction::LoadBuildClass);
-            emit!(self, Instruction::PushNull);
+            emit!(self, RealInstruction::LoadBuildClass);
+            emit!(self, RealInstruction::PushNull);
 
             // Set up the class function with type params
             let mut func_flags = bytecode::MakeFunctionFlags::empty();
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(self, RealInstruction::LoadName(dot_type_params));
             func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
 
             // Create class function with closure
@@ -3902,17 +3902,20 @@ impl Compiler {
                 };
 
                 // Add .generic_base as final base
-                emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(self, RealInstruction::LoadName(dot_generic_base));
 
                 // Build args tuple
                 if unpack {
                     // Starred: gather_elements produced tuples on stack
-                    emit!(self, Instruction::BuildTuple { size: 1 }); // (.generic_base,)
-                    emit!(self, Instruction::BuildTupleFromTuples { size: size + 1 });
+                    emit!(self, RealInstruction::BuildTuple { size: 1 }); // (.generic_base,)
+                    emit!(
+                        self,
+                        RealInstruction::BuildTupleFromTuples { size: size + 1 }
+                    );
                 } else {
                     // No starred: individual elements on stack
                     // size includes class_func + name + bases count, +1 for .generic_base
-                    emit!(self, Instruction::BuildTuple { size: size + 1 });
+                    emit!(self, RealInstruction::BuildTuple { size: size + 1 });
                 }
 
                 // Build kwargs if needed
@@ -3920,7 +3923,7 @@ impl Compiler {
                 if has_kwargs {
                     self.compile_keywords(&arguments.unwrap().keywords)?;
                 }
-                emit!(self, Instruction::CallFunctionEx { has_kwargs });
+                emit!(self, RealInstruction::CallFunctionEx { has_kwargs });
             } else {
                 // Simple case: no starred bases, no **kwargs
                 // Compile bases normally
@@ -3934,7 +3937,7 @@ impl Compiler {
                 };
 
                 // Load .generic_base as the last base
-                emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(self, RealInstruction::LoadName(dot_generic_base));
 
                 let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;
 
@@ -3957,14 +3960,14 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        Instruction::CallKw {
+                        RealInstruction::CallKw {
                             nargs: nargs
                                 + u32::try_from(arguments.keywords.len())
                                     .expect("too many keyword arguments")
                         }
                     );
                 } else {
-                    emit!(self, Instruction::Call { nargs });
+                    emit!(self, RealInstruction::Call { nargs });
                 }
             }
 
@@ -3976,12 +3979,12 @@ impl Compiler {
 
             // Execute the type params function
             self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
-            emit!(self, Instruction::PushNull);
-            emit!(self, Instruction::Call { nargs: 0 });
+            emit!(self, RealInstruction::PushNull);
+            emit!(self, RealInstruction::Call { nargs: 0 });
         } else {
             // Non-generic class: standard path
-            emit!(self, Instruction::LoadBuildClass);
-            emit!(self, Instruction::PushNull);
+            emit!(self, RealInstruction::LoadBuildClass);
+            emit!(self, RealInstruction::PushNull);
 
             // Create class function with closure
             self.make_closure(class_code, bytecode::MakeFunctionFlags::empty())?;
@@ -3990,7 +3993,7 @@ impl Compiler {
             if let Some(arguments) = arguments {
                 self.compile_call_helper(2, arguments)?;
             } else {
-                emit!(self, Instruction::Call { nargs: 2 });
+                emit!(self, RealInstruction::Call { nargs: 2 });
             }
         }
 
@@ -4017,7 +4020,7 @@ impl Compiler {
         self.ctx.loop_data = was_in_loop;
         emit!(
             self,
-            Instruction::Jump {
+            PseudoInstruction::Jump {
                 target: while_block,
             }
         );
@@ -4081,12 +4084,12 @@ impl Compiler {
             if self.ctx.func != FunctionContext::AsyncFunction {
                 return Err(self.error(CodegenErrorType::InvalidAsyncWith));
             }
-            emit!(self, Instruction::BeforeAsyncWith);
-            emit!(self, Instruction::GetAwaitable);
+            emit!(self, RealInstruction::BeforeAsyncWith);
+            emit!(self, RealInstruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         } else {
-            emit!(self, Instruction::BeforeWith);
+            emit!(self, RealInstruction::BeforeWith);
         }
 
         // Stack: [..., __exit__, enter_result]
@@ -4114,7 +4117,7 @@ impl Compiler {
                 self.compile_store(var)?;
             }
             None => {
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             }
         }
         // Stack: [..., __exit__]
@@ -4141,20 +4144,20 @@ impl Compiler {
         // Stack: [..., __exit__]
         // Call __exit__(None, None, None)
         self.set_source_range(with_range);
-        emit!(self, Instruction::PushNull);
+        emit!(self, RealInstruction::PushNull);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
-        emit!(self, Instruction::Call { nargs: 3 });
+        emit!(self, RealInstruction::Call { nargs: 3 });
         if is_async {
-            emit!(self, Instruction::GetAwaitable);
+            emit!(self, RealInstruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         }
-        emit!(self, Instruction::PopTop); // Pop __exit__ result
+        emit!(self, RealInstruction::PopTop); // Pop __exit__ result
         emit!(
             self,
-            Instruction::Jump {
+            PseudoInstruction::Jump {
                 target: after_block
             }
         );
@@ -4184,24 +4187,24 @@ impl Compiler {
         )?;
 
         // PUSH_EXC_INFO: [exc] -> [prev_exc, exc]
-        emit!(self, Instruction::PushExcInfo);
+        emit!(self, RealInstruction::PushExcInfo);
 
         // WITH_EXCEPT_START: call __exit__(type, value, tb)
         // Stack: [..., __exit__, lasti, prev_exc, exc]
         // __exit__ is at TOS-3, call with exception info
-        emit!(self, Instruction::WithExceptStart);
+        emit!(self, RealInstruction::WithExceptStart);
 
         if is_async {
-            emit!(self, Instruction::GetAwaitable);
+            emit!(self, RealInstruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         }
 
         // TO_BOOL + POP_JUMP_IF_TRUE: check if exception is suppressed
-        emit!(self, Instruction::ToBool);
+        emit!(self, RealInstruction::ToBool);
         emit!(
             self,
-            Instruction::PopJumpIfTrue {
+            RealInstruction::PopJumpIfTrue {
                 target: suppress_block
             }
         );
@@ -4213,20 +4216,20 @@ impl Compiler {
         self.pop_fblock(FBlockType::ExceptionHandler);
 
         // Not suppressed: RERAISE 2
-        emit!(self, Instruction::Reraise { depth: 2 });
+        emit!(self, RealInstruction::Reraise { depth: 2 });
 
         // ===== Suppress block =====
         // Exception was suppressed, clean up stack
         // Stack: [..., __exit__, lasti, prev_exc, exc, True]
         // Need to pop: True, exc, prev_exc, __exit__
         self.switch_to_block(suppress_block);
-        emit!(self, Instruction::PopTop); // pop True (TO_BOOL result)
-        emit!(self, Instruction::PopExcept); // pop exc and restore prev_exc
-        emit!(self, Instruction::PopTop); // pop __exit__
-        emit!(self, Instruction::PopTop); // pop lasti
+        emit!(self, RealInstruction::PopTop); // pop True (TO_BOOL result)
+        emit!(self, RealInstruction::PopExcept); // pop exc and restore prev_exc
+        emit!(self, RealInstruction::PopTop); // pop __exit__
+        emit!(self, RealInstruction::PopTop); // pop lasti
         emit!(
             self,
-            Instruction::Jump {
+            PseudoInstruction::Jump {
                 target: after_block
             }
         );
@@ -4242,9 +4245,9 @@ impl Compiler {
         // to be in the exception table for these instructions.
         // If we cleared fblock, exceptions here would propagate uncaught.
         self.switch_to_block(cleanup_block);
-        emit!(self, Instruction::Copy { index: 3 });
-        emit!(self, Instruction::PopExcept);
-        emit!(self, Instruction::Reraise { depth: 1 });
+        emit!(self, RealInstruction::Copy { index: 3 });
+        emit!(self, RealInstruction::PopExcept);
+        emit!(self, RealInstruction::Reraise { depth: 1 });
 
         // ===== After block =====
         self.switch_to_block(after_block);
@@ -4272,7 +4275,7 @@ impl Compiler {
             if self.ctx.func != FunctionContext::AsyncFunction {
                 return Err(self.error(CodegenErrorType::InvalidAsyncFor));
             }
-            emit!(self, Instruction::GetAIter);
+            emit!(self, RealInstruction::GetAIter);
 
             self.switch_to_block(for_block);
 
@@ -4290,21 +4293,21 @@ impl Compiler {
                 false,            // no lasti needed
             )?;
 
-            emit!(self, Instruction::GetANext);
+            emit!(self, RealInstruction::GetANext);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
             self.compile_store(target)?;
             // Note: PopBlock is no longer emitted (exception table handles this)
         } else {
             // Retrieve Iterator
-            emit!(self, Instruction::GetIter);
+            emit!(self, RealInstruction::GetIter);
 
             self.switch_to_block(for_block);
 
             // Push fblock for for loop
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
-            emit!(self, Instruction::ForIter { target: else_block });
+            emit!(self, RealInstruction::ForIter { target: else_block });
 
             // Start of loop iteration, set targets:
             self.compile_store(target)?;
@@ -4313,7 +4316,7 @@ impl Compiler {
         let was_in_loop = self.ctx.loop_data.replace((for_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
-        emit!(self, Instruction::Jump { target: for_block });
+        emit!(self, PseudoInstruction::Jump { target: for_block });
 
         self.switch_to_block(else_block);
 
@@ -4321,7 +4324,7 @@ impl Compiler {
         self.pop_fblock(FBlockType::ForLoop);
 
         if is_async {
-            emit!(self, Instruction::EndAsyncFor);
+            emit!(self, RealInstruction::EndAsyncFor);
         }
         self.compile_statements(orelse)?;
 
@@ -4372,7 +4375,7 @@ impl Compiler {
             JumpOp::Jump => {
                 emit!(
                     self,
-                    Instruction::Jump {
+                    PseudoInstruction::Jump {
                         target: pc.fail_pop[pops]
                     }
                 );
@@ -4380,7 +4383,7 @@ impl Compiler {
             JumpOp::PopJumpIfFalse => {
                 emit!(
                     self,
-                    Instruction::PopJumpIfFalse {
+                    RealInstruction::PopJumpIfFalse {
                         target: pc.fail_pop[pops]
                     }
                 );
@@ -4401,7 +4404,7 @@ impl Compiler {
         for &label in pc.fail_pop.iter().skip(1).rev() {
             self.switch_to_block(label);
             // Emit the POP instruction.
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
         }
         // Finally, use the first label.
         self.switch_to_block(pc.fail_pop[0]);
@@ -4422,7 +4425,7 @@ impl Compiler {
             // Emit a SWAP instruction with the current count.
             emit!(
                 self,
-                Instruction::Swap {
+                RealInstruction::Swap {
                     index: u32::try_from(count).unwrap()
                 }
             );
@@ -4445,7 +4448,7 @@ impl Compiler {
         match n {
             // If no name is provided, simply pop the top of the stack.
             None => {
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
                 Ok(())
             }
             Some(name) => {
@@ -4487,7 +4490,7 @@ impl Compiler {
                         before: u8::try_from(i).unwrap(),
                         after: u8::try_from(n - i - 1).unwrap(),
                     };
-                    emit!(self, Instruction::UnpackEx { args });
+                    emit!(self, RealInstruction::UnpackEx { args });
                     seen_star = true;
                 } else {
                     // TODO: Fix error msg
@@ -4499,7 +4502,7 @@ impl Compiler {
         if !seen_star {
             emit!(
                 self,
-                Instruction::UnpackSequence {
+                RealInstruction::UnpackSequence {
                     size: u32::try_from(n).unwrap()
                 }
             );
@@ -4545,33 +4548,33 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, RealInstruction::Copy { index: 1_u32 });
             if i < star {
                 // For indices before the star, use a nonnegative index equal to i.
                 self.emit_load_const(ConstantData::Integer { value: i.into() });
             } else {
                 // For indices after the star, compute a nonnegative index:
                 // index = len(subject) - (size - i)
-                emit!(self, Instruction::GetLen);
+                emit!(self, RealInstruction::GetLen);
                 self.emit_load_const(ConstantData::Integer {
                     value: (patterns.len() - i).into(),
                 });
                 // Subtract to compute the correct index.
                 emit!(
                     self,
-                    Instruction::BinaryOp {
+                    RealInstruction::BinaryOp {
                         op: BinaryOperator::Subtract
                     }
                 );
             }
             // Use BINARY_OP/NB_SUBSCR to extract the element.
-            emit!(self, Instruction::BinarySubscr);
+            emit!(self, RealInstruction::BinarySubscr);
             // Compile the subpattern in irrefutable mode.
             self.compile_pattern_subpattern(pattern, pc)?;
         }
         // Pop the subject off the stack.
         pc.on_top -= 1;
-        emit!(self, Instruction::PopTop);
+        emit!(self, RealInstruction::PopTop);
         Ok(())
     }
 
@@ -4618,7 +4621,7 @@ impl Compiler {
 
         // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
         pc.on_top += 1;
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, RealInstruction::Copy { index: 1_u32 });
         // Compile the sub-pattern.
         self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
         // After success, decrement the on_top counter.
@@ -4717,13 +4720,16 @@ impl Compiler {
             elements: attr_names,
         });
         // 2. Emit MATCH_CLASS with nargs.
-        emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
+        emit!(
+            self,
+            RealInstruction::MatchClass(u32::try_from(nargs).unwrap())
+        );
         // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, RealInstruction::Copy { index: 1_u32 });
         // 4. Load None.
         self.emit_load_const(ConstantData::None);
         // 5. Compare with IS_OP 1.
-        emit!(self, Instruction::IsOp(Invert::Yes));
+        emit!(self, RealInstruction::IsOp(Invert::Yes));
 
         // At this point the TOS is a tuple of (nargs + n_attrs) attributes (or None).
         pc.on_top += 1;
@@ -4733,7 +4739,7 @@ impl Compiler {
         let total = nargs + n_attrs;
         emit!(
             self,
-            Instruction::UnpackSequence {
+            RealInstruction::UnpackSequence {
                 size: u32::try_from(total).unwrap()
             }
         );
@@ -4755,7 +4761,7 @@ impl Compiler {
             pc.on_top -= 1;
 
             if is_true_wildcard {
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
                 continue; // Don't compile wildcard patterns
             }
 
@@ -4796,7 +4802,7 @@ impl Compiler {
         // Stack: [subject]
         pc.on_top += 1;
 
-        emit!(self, Instruction::MatchMapping);
+        emit!(self, RealInstruction::MatchMapping);
         // Stack: [subject, is_mapping]
 
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -4806,19 +4812,19 @@ impl Compiler {
         if size == 0 && star_target.is_none() {
             // If the pattern is just "{}", we're done! Pop the subject
             pc.on_top -= 1;
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
             return Ok(());
         }
 
         // Length check for patterns with keys
         if size > 0 {
             // Check if the mapping has at least 'size' keys
-            emit!(self, Instruction::GetLen);
+            emit!(self, RealInstruction::GetLen);
             self.emit_load_const(ConstantData::Integer { value: size.into() });
             // Stack: [subject, len, size]
             emit!(
                 self,
-                Instruction::CompareOp {
+                RealInstruction::CompareOp {
                     op: ComparisonOperator::GreaterOrEqual
                 }
             );
@@ -4875,28 +4881,28 @@ impl Compiler {
         // Stack: [subject, key1, key2, ..., key_n]
 
         // Build tuple of keys (empty tuple if size==0)
-        emit!(self, Instruction::BuildTuple { size });
+        emit!(self, RealInstruction::BuildTuple { size });
         // Stack: [subject, keys_tuple]
 
         // Match keys
-        emit!(self, Instruction::MatchKeys);
+        emit!(self, RealInstruction::MatchKeys);
         // Stack: [subject, keys_tuple, values_or_none]
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, RealInstruction::Copy { index: 1_u32 });
         // Stack: [subject, keys_tuple, values_tuple, values_tuple_copy]
 
         // Check if copy is None (consumes the copy like POP_JUMP_IF_NONE)
         self.emit_load_const(ConstantData::None);
-        emit!(self, Instruction::IsOp(Invert::Yes));
+        emit!(self, RealInstruction::IsOp(Invert::Yes));
 
         // Stack: [subject, keys_tuple, values_tuple, bool]
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         // Stack: [subject, keys_tuple, values_tuple]
 
         // Unpack values (the original values_tuple)
-        emit!(self, Instruction::UnpackSequence { size });
+        emit!(self, RealInstruction::UnpackSequence { size });
         // Stack after unpack: [subject, keys_tuple, ...unpacked values...]
         pc.on_top += size as usize; // Unpacked size values, tuple replaced by values
         pc.on_top -= 1;
@@ -4918,16 +4924,16 @@ impl Compiler {
             // Stack: [subject, keys_tuple]
 
             // Build rest dict exactly
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, RealInstruction::BuildMap { size: 0 });
             // Stack: [subject, keys_tuple, {}]
-            emit!(self, Instruction::Swap { index: 3 });
+            emit!(self, RealInstruction::Swap { index: 3 });
             // Stack: [{}, keys_tuple, subject]
-            emit!(self, Instruction::DictUpdate { index: 2 });
+            emit!(self, RealInstruction::DictUpdate { index: 2 });
             // Stack after DICT_UPDATE: [rest_dict, keys_tuple]
             // DICT_UPDATE consumes source (subject) and leaves dict in place
 
             // Unpack keys and delete from rest_dict
-            emit!(self, Instruction::UnpackSequence { size });
+            emit!(self, RealInstruction::UnpackSequence { size });
             // Stack: [rest_dict, k1, k2, ..., kn] (if size==0, nothing pushed)
 
             // Delete each key from rest_dict (skipped when size==0)
@@ -4937,14 +4943,14 @@ impl Compiler {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
                 emit!(
                     self,
-                    Instruction::Copy {
+                    RealInstruction::Copy {
                         index: 1 + remaining
                     }
                 );
                 // Stack: [rest_dict, k1, ..., kn, rest_dict]
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, RealInstruction::Swap { index: 2 });
                 // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
-                emit!(self, Instruction::DeleteSubscr);
+                emit!(self, RealInstruction::DeleteSubscr);
                 // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
                 remaining -= 1;
             }
@@ -4961,8 +4967,8 @@ impl Compiler {
             // Non-rest pattern: just clean up the stack
 
             // Pop them as we're not using them
-            emit!(self, Instruction::PopTop); // Pop keys_tuple
-            emit!(self, Instruction::PopTop); // Pop subject
+            emit!(self, RealInstruction::PopTop); // Pop keys_tuple
+            emit!(self, RealInstruction::PopTop); // Pop subject
         }
 
         Ok(())
@@ -4994,7 +5000,7 @@ impl Compiler {
             pc.fail_pop.clear();
             pc.on_top = 0;
             // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, RealInstruction::Copy { index: 1_u32 });
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -5038,7 +5044,7 @@ impl Compiler {
                 }
             }
             // Emit a jump to the common end label and reset any failure jump targets.
-            emit!(self, Instruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { target: end });
             self.emit_and_reset_fail_pop(pc)?;
         }
 
@@ -5050,7 +5056,7 @@ impl Compiler {
         // In Rust, old_pc is a local clone, so we need not worry about that.
 
         // No alternative matched: pop the subject and fail.
-        emit!(self, Instruction::PopTop);
+        emit!(self, RealInstruction::PopTop);
         self.jump_to_fail_pop(pc, JumpOp::Jump)?;
 
         // Use the label "end".
@@ -5072,7 +5078,7 @@ impl Compiler {
 
         // Old context and control will be dropped automatically.
         // Finally, pop the copy of the subject.
-        emit!(self, Instruction::PopTop);
+        emit!(self, RealInstruction::PopTop);
         Ok(())
     }
 
@@ -5113,29 +5119,29 @@ impl Compiler {
 
         // Keep the subject on top during the sequence and length checks.
         pc.on_top += 1;
-        emit!(self, Instruction::MatchSequence);
+        emit!(self, RealInstruction::MatchSequence);
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
 
         if star.is_none() {
             // No star: len(subject) == size
-            emit!(self, Instruction::GetLen);
+            emit!(self, RealInstruction::GetLen);
             self.emit_load_const(ConstantData::Integer { value: size.into() });
             emit!(
                 self,
-                Instruction::CompareOp {
+                RealInstruction::CompareOp {
                     op: ComparisonOperator::Equal
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         } else if size > 1 {
             // Star exists: len(subject) >= size - 1
-            emit!(self, Instruction::GetLen);
+            emit!(self, RealInstruction::GetLen);
             self.emit_load_const(ConstantData::Integer {
                 value: (size - 1).into(),
             });
             emit!(
                 self,
-                Instruction::CompareOp {
+                RealInstruction::CompareOp {
                     op: ComparisonOperator::GreaterOrEqual
                 }
             );
@@ -5146,7 +5152,7 @@ impl Compiler {
         pc.on_top -= 1;
         if only_wildcard {
             // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
         } else if star_wildcard {
             self.pattern_helper_sequence_subscr(patterns, star.unwrap(), pc)?;
         } else {
@@ -5164,11 +5170,11 @@ impl Compiler {
         self.compile_expression(&p.value)?;
         emit!(
             self,
-            Instruction::CompareOp {
+            RealInstruction::CompareOp {
                 op: bytecode::ComparisonOperator::Equal
             }
         );
-        // emit!(self, Instruction::ToBool);
+        // emit!(self, RealInstruction::ToBool);
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         Ok(())
     }
@@ -5185,7 +5191,7 @@ impl Compiler {
             Singleton::True => ConstantData::Boolean { value: true },
         });
         // Compare using the "Is" operator.
-        emit!(self, Instruction::IsOp(Invert::No));
+        emit!(self, RealInstruction::IsOp(Invert::No));
         // Jump to the failure label if the comparison is false.
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         Ok(())
@@ -5241,7 +5247,7 @@ impl Compiler {
         for (i, m) in cases.iter().enumerate().take(case_count) {
             // Only copy the subject if not on the last case
             if i != case_count - 1 {
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, RealInstruction::Copy { index: 1_u32 });
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -5260,37 +5266,37 @@ impl Compiler {
                 self.ensure_fail_pop(pattern_context, 0)?;
                 // Compile the guard expression
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::ToBool);
+                emit!(self, RealInstruction::ToBool);
                 emit!(
                     self,
-                    Instruction::PopJumpIfFalse {
+                    RealInstruction::PopJumpIfFalse {
                         target: pattern_context.fail_pop[0]
                     }
                 );
             }
 
             if i != case_count - 1 {
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             }
 
             self.compile_statements(&m.body)?;
-            emit!(self, Instruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { target: end });
             self.emit_and_reset_fail_pop(pattern_context)?;
         }
 
         if has_default {
             let m = &cases[num_cases - 1];
             if num_cases == 1 {
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::PopTop);
             } else {
-                emit!(self, Instruction::Nop);
+                emit!(self, RealInstruction::Nop);
             }
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
-                emit!(self, Instruction::PopJumpIfFalse { target: end });
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::Copy { index: 1_u32 });
+                emit!(self, RealInstruction::PopJumpIfFalse { target: end });
+                emit!(self, RealInstruction::PopTop);
             }
             self.compile_statements(&m.body)?;
         }
@@ -5308,18 +5314,18 @@ impl Compiler {
     fn compile_addcompare(&mut self, op: &CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
-            CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
-            CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
-            CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
-            CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
-            CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
+            CmpOp::Eq => emit!(self, RealInstruction::CompareOp { op: Equal }),
+            CmpOp::NotEq => emit!(self, RealInstruction::CompareOp { op: NotEqual }),
+            CmpOp::Lt => emit!(self, RealInstruction::CompareOp { op: Less }),
+            CmpOp::LtE => emit!(self, RealInstruction::CompareOp { op: LessOrEqual }),
+            CmpOp::Gt => emit!(self, RealInstruction::CompareOp { op: Greater }),
             CmpOp::GtE => {
-                emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
+                emit!(self, RealInstruction::CompareOp { op: GreaterOrEqual })
             }
-            CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
-            CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
-            CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
-            CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
+            CmpOp::In => emit!(self, RealInstruction::ContainsOp(Invert::No)),
+            CmpOp::NotIn => emit!(self, RealInstruction::ContainsOp(Invert::Yes)),
+            CmpOp::Is => emit!(self, RealInstruction::IsOp(Invert::No)),
+            CmpOp::IsNot => emit!(self, RealInstruction::IsOp(Invert::Yes)),
         }
     }
 
@@ -5367,32 +5373,35 @@ impl Compiler {
             self.compile_expression(comparator)?;
 
             // store rhs for the next comparison in chain
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::Copy { index: 2 });
+            emit!(self, RealInstruction::Swap { index: 2 });
+            emit!(self, RealInstruction::Copy { index: 2 });
 
             self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
             /*
-            emit!(self, Instruction::Copy { index: 1 });
-            // emit!(self, Instruction::ToBool); // TODO: Uncomment this
-            emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::Copy { index: 1 });
+            // emit!(self, RealInstruction::ToBool); // TODO: Uncomment this
+            emit!(self, RealInstruction::PopJumpIfFalse { target: cleanup });
+            emit!(self, RealInstruction::PopTop);
             */
 
-            emit!(self, Instruction::JumpIfFalseOrPop { target: cleanup });
+            emit!(
+                self,
+                PseudoInstruction::JumpIfFalseOrPop { target: cleanup }
+            );
         }
 
         self.compile_expression(last_comparator)?;
         self.compile_addcompare(last_op);
 
         let end = self.new_block();
-        emit!(self, Instruction::Jump { target: end });
+        emit!(self, PseudoInstruction::Jump { target: end });
 
         // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
         self.switch_to_block(cleanup);
-        emit!(self, Instruction::Swap { index: 2 });
-        emit!(self, Instruction::PopTop);
+        emit!(self, RealInstruction::Swap { index: 2 });
+        emit!(self, RealInstruction::PopTop);
 
         self.switch_to_block(end);
         Ok(())
@@ -5415,7 +5424,7 @@ impl Compiler {
                     // *args: *Ts (where Ts is a TypeVarTuple).
                     // Do [annotation_value] = [*Ts].
                     self.compile_expression(value)?;
-                    emit!(self, Instruction::UnpackSequence { size: 1 });
+                    emit!(self, RealInstruction::UnpackSequence { size: 1 });
                     Ok(())
                 }
                 _ => self.compile_expression(annotation),
@@ -5449,14 +5458,14 @@ impl Compiler {
         if let Expr::Name(ExprName { id, .. }) = &target {
             // Store as dict entry in __annotations__ dict:
             let annotations = self.name("__annotations__");
-            emit!(self, Instruction::LoadName(annotations));
+            emit!(self, RealInstruction::LoadName(annotations));
             self.emit_load_const(ConstantData::Str {
                 value: self.mangle(id.as_str()).into_owned().into(),
             });
-            emit!(self, Instruction::StoreSubscr);
+            emit!(self, RealInstruction::StoreSubscr);
         } else {
             // Drop annotation if not assigned to simple identifier.
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
         }
 
         Ok(())
@@ -5474,7 +5483,7 @@ impl Compiler {
                 self.check_forbidden_name(attr.as_str(), NameUsage::Store)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, Instruction::StoreAttr { idx });
+                emit!(self, RealInstruction::StoreAttr { idx });
             }
             Expr::List(ExprList { elts, .. }) | Expr::Tuple(ExprTuple { elts, .. }) => {
                 let mut seen_star = false;
@@ -5496,7 +5505,7 @@ impl Compiler {
                                     )
                                 })?;
                             let args = bytecode::UnpackExArgs { before, after };
-                            emit!(self, Instruction::UnpackEx { args });
+                            emit!(self, RealInstruction::UnpackEx { args });
                         }
                     }
                 }
@@ -5504,7 +5513,7 @@ impl Compiler {
                 if !seen_star {
                     emit!(
                         self,
-                        Instruction::UnpackSequence {
+                        RealInstruction::UnpackSequence {
                             size: elts.len().to_u32(),
                         }
                     );
@@ -5559,18 +5568,18 @@ impl Compiler {
                 // But we can't use compile_subscript directly because we need DUP_TOP2
                 self.compile_expression(value)?;
                 self.compile_expression(slice)?;
-                emit!(self, Instruction::Copy { index: 2_u32 });
-                emit!(self, Instruction::Copy { index: 2_u32 });
-                emit!(self, Instruction::Subscript);
+                emit!(self, RealInstruction::Copy { index: 2_u32 });
+                emit!(self, RealInstruction::Copy { index: 2_u32 });
+                emit!(self, RealInstruction::Subscript);
                 AugAssignKind::Subscript
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
                 let attr = attr.as_str();
                 self.check_forbidden_name(attr, NameUsage::Store)?;
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, RealInstruction::Copy { index: 1_u32 });
                 let idx = self.name(attr);
-                emit!(self, Instruction::LoadAttr { idx });
+                emit!(self, RealInstruction::LoadAttr { idx });
                 AugAssignKind::Attr { idx }
             }
             _ => {
@@ -5588,14 +5597,14 @@ impl Compiler {
             }
             AugAssignKind::Subscript => {
                 // stack: CONTAINER SLICE RESULT
-                emit!(self, Instruction::Swap { index: 3 });
-                emit!(self, Instruction::Swap { index: 2 });
-                emit!(self, Instruction::StoreSubscr);
+                emit!(self, RealInstruction::Swap { index: 3 });
+                emit!(self, RealInstruction::Swap { index: 2 });
+                emit!(self, RealInstruction::StoreSubscr);
             }
             AugAssignKind::Attr { idx } => {
                 // stack: CONTAINER RESULT
-                emit!(self, Instruction::Swap { index: 2 });
-                emit!(self, Instruction::StoreAttr { idx });
+                emit!(self, RealInstruction::Swap { index: 2 });
+                emit!(self, RealInstruction::StoreAttr { idx });
             }
         }
 
@@ -5620,7 +5629,7 @@ impl Compiler {
         };
 
         let op = if inplace { bin_op.as_inplace() } else { bin_op };
-        emit!(self, Instruction::BinaryOp { op })
+        emit!(self, RealInstruction::BinaryOp { op })
     }
 
     /// Implement boolean short circuit evaluation logic.
@@ -5698,14 +5707,14 @@ impl Compiler {
                 if condition {
                     emit!(
                         self,
-                        Instruction::PopJumpIfTrue {
+                        RealInstruction::PopJumpIfTrue {
                             target: target_block,
                         }
                     );
                 } else {
                     emit!(
                         self,
-                        Instruction::PopJumpIfFalse {
+                        RealInstruction::PopJumpIfFalse {
                             target: target_block,
                         }
                     );
@@ -5725,12 +5734,12 @@ impl Compiler {
         for value in values {
             self.compile_expression(value)?;
 
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, RealInstruction::Copy { index: 1_u32 });
             match op {
                 BoolOp::And => {
                     emit!(
                         self,
-                        Instruction::PopJumpIfFalse {
+                        RealInstruction::PopJumpIfFalse {
                             target: after_block,
                         }
                     );
@@ -5738,14 +5747,14 @@ impl Compiler {
                 BoolOp::Or => {
                     emit!(
                         self,
-                        Instruction::PopJumpIfTrue {
+                        RealInstruction::PopJumpIfTrue {
                             target: after_block,
                         }
                     );
                 }
             }
 
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
         }
 
         // If all values did not qualify, take the value of the last value:
@@ -5764,11 +5773,11 @@ impl Compiler {
             self.compile_expression(&item.value)?;
             size += 1;
         }
-        emit!(self, Instruction::BuildMap { size });
+        emit!(self, RealInstruction::BuildMap { size });
 
         for item in unpacked {
             self.compile_expression(&item.value)?;
-            emit!(self, Instruction::DictUpdate { index: 1 });
+            emit!(self, RealInstruction::DictUpdate { index: 1 });
         }
 
         Ok(())
@@ -5795,7 +5804,7 @@ impl Compiler {
 
         // send:
         self.switch_to_block(send_block);
-        emit!(self, Instruction::Send { target: exit_block });
+        emit!(self, RealInstruction::Send { target: exit_block });
 
         // SETUP_FINALLY fail - set up exception handler for YIELD_VALUE
         // Stack at this point: [receiver, yielded_value]
@@ -5811,7 +5820,7 @@ impl Compiler {
         )?;
 
         // YIELD_VALUE with arg=1 (yield-from/await mode - not wrapped for async gen)
-        emit!(self, Instruction::YieldValue { arg: 1 });
+        emit!(self, RealInstruction::YieldValue { arg: 1 });
 
         // POP_BLOCK (implicit - pop fblock before RESUME)
         self.pop_fblock(FBlockType::TryExcept);
@@ -5819,7 +5828,7 @@ impl Compiler {
         // RESUME
         emit!(
             self,
-            Instruction::Resume {
+            RealInstruction::Resume {
                 arg: if is_await {
                     bytecode::ResumeType::AfterAwait as u32
                 } else {
@@ -5829,21 +5838,21 @@ impl Compiler {
         );
 
         // JUMP_NO_INTERRUPT send (regular JUMP in RustPython)
-        emit!(self, Instruction::Jump { target: send_block });
+        emit!(self, PseudoInstruction::Jump { target: send_block });
 
         // fail: CLEANUP_THROW
         // Stack when exception: [receiver, yielded_value, exc]
         // CLEANUP_THROW: [sub_iter, last_sent_val, exc] -> [None, value]
         // After: stack is [None, value], fall through to exit
         self.switch_to_block(fail_block);
-        emit!(self, Instruction::CleanupThrow);
+        emit!(self, RealInstruction::CleanupThrow);
         // Fall through to exit block
 
         // exit: END_SEND
         // Stack: [receiver, value] (from SEND) or [None, value] (from CLEANUP_THROW)
         // END_SEND: [receiver/None, value] -> [value]
         self.switch_to_block(exit_block);
-        emit!(self, Instruction::EndSend);
+        emit!(self, RealInstruction::EndSend);
 
         Ok(())
     }
@@ -5880,16 +5889,16 @@ impl Compiler {
                 match op {
                     UnaryOp::UAdd => emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
+                        RealInstruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::UnaryPositive
                         }
                     ),
-                    UnaryOp::USub => emit!(self, Instruction::UnaryNegative),
+                    UnaryOp::USub => emit!(self, RealInstruction::UnaryNegative),
                     UnaryOp::Not => {
-                        emit!(self, Instruction::ToBool);
-                        emit!(self, Instruction::UnaryNot);
+                        emit!(self, RealInstruction::ToBool);
+                        emit!(self, RealInstruction::UnaryNot);
                     }
-                    UnaryOp::Invert => emit!(self, Instruction::UnaryInvert),
+                    UnaryOp::Invert => emit!(self, RealInstruction::UnaryInvert),
                 };
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
@@ -5903,17 +5912,17 @@ impl Compiler {
                         SuperCallType::TwoArg { .. } => {
                             // LoadSuperAttr (pseudo) - will be converted to real LoadSuperAttr
                             // with flags=0b10 (has_class=true, load_method=false) in ir.rs
-                            emit!(self, Instruction::LoadSuperAttr { arg: idx });
+                            emit!(self, RealInstruction::LoadSuperAttr { arg: idx });
                         }
                         SuperCallType::ZeroArg => {
-                            emit!(self, Instruction::LoadZeroSuperAttr { idx });
+                            emit!(self, RealInstruction::LoadZeroSuperAttr { idx });
                         }
                     }
                 } else {
                     // Normal attribute access
                     self.compile_expression(value)?;
                     let idx = self.name(attr.as_str());
-                    emit!(self, Instruction::LoadAttr { idx });
+                    emit!(self, RealInstruction::LoadAttr { idx });
                 }
             }
             Expr::Compare(ExprCompare {
@@ -5958,7 +5967,7 @@ impl Compiler {
                     Some(_) => BuildSliceArgCount::Three,
                     None => BuildSliceArgCount::Two,
                 };
-                emit!(self, Instruction::BuildSlice { argc });
+                emit!(self, RealInstruction::BuildSlice { argc });
             }
             Expr::Yield(ExprYield { value, .. }) => {
                 if !self.ctx.in_func() {
@@ -5970,10 +5979,10 @@ impl Compiler {
                     Option::None => self.emit_load_const(ConstantData::None),
                 };
                 // arg=0: direct yield (wrapped for async generators)
-                emit!(self, Instruction::YieldValue { arg: 0 });
+                emit!(self, RealInstruction::YieldValue { arg: 0 });
                 emit!(
                     self,
-                    Instruction::Resume {
+                    RealInstruction::Resume {
                         arg: bytecode::ResumeType::AfterYield as u32
                     }
                 );
@@ -5983,7 +5992,7 @@ impl Compiler {
                     return Err(self.error(CodegenErrorType::InvalidAwait));
                 }
                 self.compile_expression(value)?;
-                emit!(self, Instruction::GetAwaitable);
+                emit!(self, RealInstruction::GetAwaitable);
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(true)?;
             }
@@ -5999,7 +6008,7 @@ impl Compiler {
                 }
                 self.mark_generator();
                 self.compile_expression(value)?;
-                emit!(self, Instruction::GetYieldFromIter);
+                emit!(self, RealInstruction::GetYieldFromIter);
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(false)?;
             }
@@ -6027,7 +6036,7 @@ impl Compiler {
                     for element in &defaults {
                         self.compile_expression(element)?;
                     }
-                    emit!(self, Instruction::BuildTuple { size });
+                    emit!(self, RealInstruction::BuildTuple { size });
                 }
 
                 // Prepare keyword-only defaults
@@ -6049,7 +6058,7 @@ impl Compiler {
                     }
                     emit!(
                         self,
-                        Instruction::BuildMap {
+                        RealInstruction::BuildMap {
                             size: default_kw_count.to_u32(),
                         }
                     );
@@ -6094,7 +6103,7 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<listcomp>",
-                    Some(Instruction::BuildList {
+                    Some(RealInstruction::BuildList {
                         size: OpArgMarker::marker(),
                     }),
                     generators,
@@ -6102,7 +6111,7 @@ impl Compiler {
                         compiler.compile_comprehension_element(elt)?;
                         emit!(
                             compiler,
-                            Instruction::ListAppend {
+                            RealInstruction::ListAppend {
                                 i: generators.len().to_u32(),
                             }
                         );
@@ -6117,7 +6126,7 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<setcomp>",
-                    Some(Instruction::BuildSet {
+                    Some(RealInstruction::BuildSet {
                         size: OpArgMarker::marker(),
                     }),
                     generators,
@@ -6125,7 +6134,7 @@ impl Compiler {
                         compiler.compile_comprehension_element(elt)?;
                         emit!(
                             compiler,
-                            Instruction::SetAdd {
+                            RealInstruction::SetAdd {
                                 i: generators.len().to_u32(),
                             }
                         );
@@ -6143,7 +6152,7 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<dictcomp>",
-                    Some(Instruction::BuildMap {
+                    Some(RealInstruction::BuildMap {
                         size: OpArgMarker::marker(),
                     }),
                     generators,
@@ -6154,7 +6163,7 @@ impl Compiler {
 
                         emit!(
                             compiler,
-                            Instruction::MapAdd {
+                            RealInstruction::MapAdd {
                                 i: generators.len().to_u32(),
                             }
                         );
@@ -6186,14 +6195,14 @@ impl Compiler {
 
                         compiler.mark_generator();
                         // arg=0: direct yield (wrapped for async generators)
-                        emit!(compiler, Instruction::YieldValue { arg: 0 });
+                        emit!(compiler, RealInstruction::YieldValue { arg: 0 });
                         emit!(
                             compiler,
-                            Instruction::Resume {
+                            RealInstruction::Resume {
                                 arg: bytecode::ResumeType::AfterYield as u32
                             }
                         );
-                        emit!(compiler, Instruction::PopTop);
+                        emit!(compiler, RealInstruction::PopTop);
 
                         Ok(())
                     },
@@ -6222,7 +6231,7 @@ impl Compiler {
                 self.compile_expression(body)?;
                 emit!(
                     self,
-                    Instruction::Jump {
+                    PseudoInstruction::Jump {
                         target: after_block,
                     }
                 );
@@ -6242,7 +6251,7 @@ impl Compiler {
                 range: _,
             }) => {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, RealInstruction::Copy { index: 1_u32 });
                 self.compile_store(target)?;
             }
             Expr::FString(fstring) => {
@@ -6325,12 +6334,12 @@ impl Compiler {
                         sub_size += 1;
                     }
                 }
-                emit!(self, Instruction::BuildMap { size: sub_size });
+                emit!(self, RealInstruction::BuildMap { size: sub_size });
                 size += 1;
             }
         }
         if size > 1 {
-            emit!(self, Instruction::BuildMapForCall { size });
+            emit!(self, RealInstruction::BuildMapForCall { size });
         }
         Ok(())
     }
@@ -6347,10 +6356,10 @@ impl Compiler {
                 let idx = self.name(attr.as_str());
                 match super_type {
                     SuperCallType::TwoArg { .. } => {
-                        emit!(self, Instruction::LoadSuperMethod { idx });
+                        emit!(self, RealInstruction::LoadSuperMethod { idx });
                     }
                     SuperCallType::ZeroArg => {
-                        emit!(self, Instruction::LoadZeroSuperMethod { idx });
+                        emit!(self, RealInstruction::LoadZeroSuperMethod { idx });
                     }
                 }
                 self.compile_call_helper(0, args)?;
@@ -6359,14 +6368,14 @@ impl Compiler {
                 // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, Instruction::LoadAttrMethod { idx });
+                emit!(self, RealInstruction::LoadAttrMethod { idx });
                 self.compile_call_helper(0, args)?;
             }
         } else {
             // Regular call: push func, then NULL for self_or_null slot
             // Stack layout: [func, NULL, args...] - same as method call [func, self, args...]
             self.compile_expression(func)?;
-            emit!(self, Instruction::PushNull);
+            emit!(self, RealInstruction::PushNull);
             self.compile_call_helper(0, args)?;
         }
         Ok(())
@@ -6397,9 +6406,9 @@ impl Compiler {
         if unpack || has_double_star {
             // Create a tuple with positional args:
             if unpack {
-                emit!(self, Instruction::BuildTupleFromTuples { size });
+                emit!(self, RealInstruction::BuildTupleFromTuples { size });
             } else {
-                emit!(self, Instruction::BuildTuple { size });
+                emit!(self, RealInstruction::BuildTuple { size });
             }
 
             // Create an optional map with kw-args:
@@ -6407,7 +6416,7 @@ impl Compiler {
             if has_kwargs {
                 self.compile_keywords(&arguments.keywords)?;
             }
-            emit!(self, Instruction::CallFunctionEx { has_kwargs });
+            emit!(self, RealInstruction::CallFunctionEx { has_kwargs });
         } else if !arguments.keywords.is_empty() {
             // No **kwargs in this branch (has_double_star is false),
             // so all keywords have arg.is_some()
@@ -6435,9 +6444,9 @@ impl Compiler {
             let nargs = positional
                 .checked_add(keyword_count)
                 .expect("too many arguments");
-            emit!(self, Instruction::CallKw { nargs });
+            emit!(self, RealInstruction::CallKw { nargs });
         } else {
-            emit!(self, Instruction::Call { nargs: count });
+            emit!(self, RealInstruction::Call { nargs: count });
         }
 
         Ok(())
@@ -6456,7 +6465,7 @@ impl Compiler {
 
             loop {
                 if iter.peek().is_none_or(|e| matches!(e, Expr::Starred(_))) {
-                    emit!(self, Instruction::BuildTuple { size: run_size });
+                    emit!(self, RealInstruction::BuildTuple { size: run_size });
                     run_size = 0;
                     size += 1;
                 }
@@ -6468,7 +6477,7 @@ impl Compiler {
                         // tuple, since any side-effects during the conversion
                         // should be made visible before evaluating remaining
                         // expressions.
-                        emit!(self, Instruction::BuildTupleFromIter);
+                        emit!(self, RealInstruction::BuildTupleFromIter);
                         size += 1;
                     }
                     Some(element) => {
@@ -6505,7 +6514,7 @@ impl Compiler {
     fn compile_comprehension(
         &mut self,
         name: &str,
-        init_collection: Option<Instruction>,
+        init_collection: Option<RealInstruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         comprehension_type: ComprehensionType,
@@ -6599,23 +6608,23 @@ impl Compiler {
 
             if loop_labels.is_empty() {
                 // Load iterator onto stack (passed as first argument):
-                emit!(self, Instruction::LoadFast(arg0));
+                emit!(self, RealInstruction::LoadFast(arg0));
             } else {
                 // Evaluate iterated item:
                 self.compile_expression(&generator.iter)?;
 
                 // Get iterator / turn item into an iterator
                 if generator.is_async {
-                    emit!(self, Instruction::GetAIter);
+                    emit!(self, RealInstruction::GetAIter);
                 } else {
-                    emit!(self, Instruction::GetIter);
+                    emit!(self, RealInstruction::GetIter);
                 }
             }
 
             loop_labels.push((loop_block, after_block, generator.is_async));
             self.switch_to_block(loop_block);
             if generator.is_async {
-                emit!(self, Instruction::GetANext);
+                emit!(self, RealInstruction::GetANext);
 
                 let current_depth = (init_collection.is_some() as u32)
                     + u32::try_from(loop_labels.len()).unwrap()
@@ -6635,7 +6644,7 @@ impl Compiler {
             } else {
                 emit!(
                     self,
-                    Instruction::ForIter {
+                    RealInstruction::ForIter {
                         target: after_block,
                     }
                 );
@@ -6651,12 +6660,12 @@ impl Compiler {
         compile_element(self)?;
 
         for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
-            emit!(self, Instruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { target: loop_block });
 
             self.switch_to_block(after_block);
             if is_async {
-                emit!(self, Instruction::EndAsyncFor);
-                emit!(self, Instruction::PopTop);
+                emit!(self, RealInstruction::EndAsyncFor);
+                emit!(self, RealInstruction::PopTop);
             }
         }
 
@@ -6672,7 +6681,7 @@ impl Compiler {
 
         // Create comprehension function with closure
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
-        emit!(self, Instruction::PushNull);
+        emit!(self, RealInstruction::PushNull);
 
         // Evaluate iterated item:
         self.compile_expression(&generators[0].iter)?;
@@ -6680,15 +6689,15 @@ impl Compiler {
         // Get iterator / turn item into an iterator
         // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
         if generators[0].is_async {
-            emit!(self, Instruction::GetAIter);
+            emit!(self, RealInstruction::GetAIter);
         } else {
-            emit!(self, Instruction::GetIter);
+            emit!(self, RealInstruction::GetIter);
         };
 
         // Call just created <listcomp> function:
-        emit!(self, Instruction::Call { nargs: 1 });
+        emit!(self, RealInstruction::Call { nargs: 1 });
         if is_async_list_set_dict_comprehension {
-            emit!(self, Instruction::GetAwaitable);
+            emit!(self, RealInstruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         }
@@ -6728,7 +6737,7 @@ impl Compiler {
     /// This generates bytecode inline without creating a new code object
     fn compile_inlined_comprehension(
         &mut self,
-        init_collection: Option<Instruction>,
+        init_collection: Option<RealInstruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         _has_an_async_gen: bool,
@@ -6754,22 +6763,22 @@ impl Compiler {
         self.compile_expression(&generators[0].iter)?;
         // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
         if generators[0].is_async {
-            emit!(self, Instruction::GetAIter);
+            emit!(self, RealInstruction::GetAIter);
         } else {
-            emit!(self, Instruction::GetIter);
+            emit!(self, RealInstruction::GetIter);
         }
 
         // Step 2: Save local variables that will be shadowed by the comprehension
         for name in &pushed_locals {
             let idx = self.varname(name)?;
-            emit!(self, Instruction::LoadFastAndClear(idx));
+            emit!(self, RealInstruction::LoadFastAndClear(idx));
         }
 
         // Step 3: SWAP iterator to TOS (above saved locals)
         if !pushed_locals.is_empty() {
             emit!(
                 self,
-                Instruction::Swap {
+                RealInstruction::Swap {
                     index: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
@@ -6780,7 +6789,7 @@ impl Compiler {
         if let Some(init_collection) = init_collection {
             self._emit(init_collection, OpArg(0), BlockIdx::NULL);
             // SWAP to get iterator on top
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, RealInstruction::Swap { index: 2 });
         }
 
         // Set up exception handler for cleanup on exception
@@ -6814,9 +6823,9 @@ impl Compiler {
                 // For nested loops, compile the iterator expression
                 self.compile_expression(&generator.iter)?;
                 if generator.is_async {
-                    emit!(self, Instruction::GetAIter);
+                    emit!(self, RealInstruction::GetAIter);
                 } else {
-                    emit!(self, Instruction::GetIter);
+                    emit!(self, RealInstruction::GetIter);
                 }
             }
 
@@ -6824,14 +6833,14 @@ impl Compiler {
             self.switch_to_block(loop_block);
 
             if generator.is_async {
-                emit!(self, Instruction::GetANext);
+                emit!(self, RealInstruction::GetANext);
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(true)?;
                 self.compile_store(&generator.target)?;
             } else {
                 emit!(
                     self,
-                    Instruction::ForIter {
+                    RealInstruction::ForIter {
                         target: after_block,
                     }
                 );
@@ -6849,13 +6858,13 @@ impl Compiler {
 
         // Step 7: Close all loops
         for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
-            emit!(self, Instruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { target: loop_block });
             self.switch_to_block(after_block);
             if is_async {
-                emit!(self, Instruction::EndAsyncFor);
+                emit!(self, RealInstruction::EndAsyncFor);
             }
             // Pop the iterator
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
         }
 
         // Step 8: Clean up - restore saved locals
@@ -6863,30 +6872,30 @@ impl Compiler {
             self.pop_fblock(FBlockType::TryExcept);
 
             // Normal path: jump past cleanup
-            emit!(self, Instruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { target: end_block });
 
             // Exception cleanup path
             self.switch_to_block(cleanup_block);
             // Stack: [saved_locals..., collection, exception]
             // Swap to get collection out from under exception
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::PopTop); // Pop incomplete collection
+            emit!(self, RealInstruction::Swap { index: 2 });
+            emit!(self, RealInstruction::PopTop); // Pop incomplete collection
 
             // Restore locals
             emit!(
                 self,
-                Instruction::Swap {
+                RealInstruction::Swap {
                     index: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
             for name in pushed_locals.iter().rev() {
                 let idx = self.varname(name)?;
-                emit!(self, Instruction::StoreFast(idx));
+                emit!(self, RealInstruction::StoreFast(idx));
             }
             // Re-raise the exception
             emit!(
                 self,
-                Instruction::RaiseVarargs {
+                RealInstruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack
                 }
             );
@@ -6899,7 +6908,7 @@ impl Compiler {
         if !pushed_locals.is_empty() {
             emit!(
                 self,
-                Instruction::Swap {
+                RealInstruction::Swap {
                     index: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
@@ -6908,7 +6917,7 @@ impl Compiler {
         // Restore saved locals
         for name in pushed_locals.iter().rev() {
             let idx = self.varname(name)?;
-            emit!(self, Instruction::StoreFast(idx));
+            emit!(self, RealInstruction::StoreFast(idx));
         }
 
         Ok(())
@@ -6952,14 +6961,14 @@ impl Compiler {
         });
     }
 
-    fn emit_no_arg(&mut self, ins: Instruction) {
+    fn emit_no_arg(&mut self, ins: RealInstruction) {
         self._emit(ins, OpArg::null(), BlockIdx::NULL)
     }
 
     fn emit_arg<A: OpArgType, T: EmitArg<A>>(
         &mut self,
         arg: T,
-        f: impl FnOnce(OpArgMarker<A>) -> Instruction,
+        f: impl FnOnce(OpArgMarker<A>) -> RealInstruction,
     ) {
         let (op, arg, target) = arg.emit(f);
         self._emit(op, arg, target)
@@ -6974,22 +6983,22 @@ impl Compiler {
 
     fn emit_load_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::LoadConst { idx })
+        self.emit_arg(idx, |idx| RealInstruction::LoadConst { idx })
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::ReturnConst { idx })
+        self.emit_arg(idx, |idx| RealInstruction::ReturnConst { idx })
     }
 
     fn emit_return_value(&mut self) {
         if let Some(inst) = self.current_block().instructions.last_mut()
-            && let Instruction::LoadConst { idx } = inst.instr
+            && let RealInstruction::LoadConst { idx } = inst.instr
         {
-            inst.instr = Instruction::ReturnConst { idx };
+            inst.instr = RealInstruction::ReturnConst { idx };
             return;
         }
-        emit!(self, Instruction::ReturnValue)
+        emit!(self, RealInstruction::ReturnValue)
     }
 
     fn current_code_info(&mut self) -> &mut ir::CodeInfo {
@@ -7102,22 +7111,22 @@ impl Compiler {
             match action {
                 UnwindAction::With { is_async } => {
                     // compiler_call_exit_with_nones
-                    emit!(self, Instruction::PushNull);
+                    emit!(self, RealInstruction::PushNull);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
-                    emit!(self, Instruction::Call { nargs: 3 });
+                    emit!(self, RealInstruction::Call { nargs: 3 });
 
                     if is_async {
-                        emit!(self, Instruction::GetAwaitable);
+                        emit!(self, RealInstruction::GetAwaitable);
                         self.emit_load_const(ConstantData::None);
                         self.compile_yield_from_sequence(true)?;
                     }
 
-                    emit!(self, Instruction::PopTop);
+                    emit!(self, RealInstruction::PopTop);
                 }
                 UnwindAction::HandlerCleanup => {
-                    emit!(self, Instruction::PopExcept);
+                    emit!(self, RealInstruction::PopExcept);
                 }
                 UnwindAction::FinallyTry { body, fblock_idx } => {
                     // compile finally body inline
@@ -7137,26 +7146,26 @@ impl Compiler {
                     // Stack when in FinallyEnd: [..., prev_exc, exc]
                     // Note: No lasti here - it's only pushed for cleanup handler exceptions
                     // We need to pop: exc, prev_exc (via PopExcept)
-                    emit!(self, Instruction::PopTop); // exc
-                    emit!(self, Instruction::PopExcept); // prev_exc is restored
+                    emit!(self, RealInstruction::PopTop); // exc
+                    emit!(self, RealInstruction::PopExcept); // prev_exc is restored
                 }
                 UnwindAction::PopValue => {
                     // Pop the return value - continue/break cancels the pending return
-                    emit!(self, Instruction::PopTop);
+                    emit!(self, RealInstruction::PopTop);
                 }
             }
         }
 
         // For break in a for loop, pop the iterator
         if is_break && is_for_loop {
-            emit!(self, Instruction::PopTop);
+            emit!(self, RealInstruction::PopTop);
         }
 
         // Jump to target
         if is_break {
-            emit!(self, Instruction::Break { target: exit_block });
+            emit!(self, RealInstruction::Break { target: exit_block });
         } else {
-            emit!(self, Instruction::Continue { target: loop_block });
+            emit!(self, RealInstruction::Continue { target: loop_block });
         }
 
         Ok(())
@@ -7307,7 +7316,7 @@ impl Compiler {
             .try_into()
             .expect("BuildString size overflowed");
         if part_count > 1 {
-            emit!(self, Instruction::BuildString { size: part_count });
+            emit!(self, RealInstruction::BuildString { size: part_count });
         }
 
         Ok(())
@@ -7398,7 +7407,7 @@ impl Compiler {
                         ConvertValueOparg::Str
                         | ConvertValueOparg::Repr
                         | ConvertValueOparg::Ascii => {
-                            emit!(self, Instruction::ConvertValue { oparg: conversion })
+                            emit!(self, RealInstruction::ConvertValue { oparg: conversion })
                         }
                     }
 
@@ -7406,10 +7415,10 @@ impl Compiler {
                         Some(format_spec) => {
                             self.compile_fstring_elements(flags, &format_spec.elements)?;
 
-                            emit!(self, Instruction::FormatWithSpec);
+                            emit!(self, RealInstruction::FormatWithSpec);
                         }
                         None => {
-                            emit!(self, Instruction::FormatSimple);
+                            emit!(self, RealInstruction::FormatSimple);
                         }
                     }
                 }
@@ -7424,7 +7433,7 @@ impl Compiler {
         } else if element_count > 1 {
             emit!(
                 self,
-                Instruction::BuildString {
+                RealInstruction::BuildString {
                     size: element_count
                 }
             );
@@ -7437,11 +7446,14 @@ impl Compiler {
 trait EmitArg<Arg: OpArgType> {
     fn emit(
         self,
-        f: impl FnOnce(OpArgMarker<Arg>) -> Instruction,
-    ) -> (Instruction, OpArg, BlockIdx);
+        f: impl FnOnce(OpArgMarker<Arg>) -> RealInstruction,
+    ) -> (RealInstruction, OpArg, BlockIdx);
 }
 impl<T: OpArgType> EmitArg<T> for T {
-    fn emit(self, f: impl FnOnce(OpArgMarker<T>) -> Instruction) -> (Instruction, OpArg, BlockIdx) {
+    fn emit(
+        self,
+        f: impl FnOnce(OpArgMarker<T>) -> RealInstruction,
+    ) -> (RealInstruction, OpArg, BlockIdx) {
         let (marker, arg) = OpArgMarker::new(self);
         (f(marker), arg, BlockIdx::NULL)
     }
@@ -7449,8 +7461,8 @@ impl<T: OpArgType> EmitArg<T> for T {
 impl EmitArg<bytecode::Label> for BlockIdx {
     fn emit(
         self,
-        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> Instruction,
-    ) -> (Instruction, OpArg, BlockIdx) {
+        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> RealInstruction,
+    ) -> (RealInstruction, OpArg, BlockIdx) {
         (f(OpArgMarker::marker()), OpArg::null(), self)
     }
 }
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 82b9921911c..c6c5c2deb2c 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -5,7 +5,7 @@ use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
         Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
-        InstrDisplayContext, Instruction, Label, OpArg, PyCodeLocationInfoKind,
+        InstrDisplayContext, Instruction, Label, OpArg, PseudoInstruction, PyCodeLocationInfoKind,
         encode_exception_table, encode_load_attr_arg, encode_load_super_attr_arg,
     },
     varint::{write_signed_varint, write_varint},
@@ -197,44 +197,44 @@ impl CodeInfo {
             for info in &mut block.instructions {
                 match info.instr {
                     // LOAD_ATTR_METHOD pseudo → LOAD_ATTR (with method flag=1)
-                    Instruction::LoadAttrMethod { idx } => {
+                    Instruction::Pseudo(PseudoInstruction::LoadAttrMethod { idx }) => {
                         let encoded = encode_load_attr_arg(idx.get(info.arg), true);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
+                        info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
                     }
                     // LOAD_ATTR → encode with method flag=0
-                    Instruction::LoadAttr { idx } => {
+                    Instruction::Real(Instruction::LoadAttr { idx }) => {
                         let encoded = encode_load_attr_arg(idx.get(info.arg), false);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
+                        info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
                     }
                     // POP_BLOCK pseudo → NOP
-                    Instruction::PopBlock => {
-                        info.instr = Instruction::Nop;
+                    Instruction::Pseudo(PseudoInstruction::PopBlock) => {
+                        info.instr = RealInstruction::Nop.into();
                     }
                     // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
-                    Instruction::LoadSuperMethod { idx } => {
+                    Instruction::Pseudo(Instruction::LoadSuperMethod { idx }) => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_ATTR pseudo → LOAD_SUPER_ATTR (flags=0b00: method=0, class=0)
-                    Instruction::LoadZeroSuperAttr { idx } => {
+                    Instruction::Pseudo(PseudoInstruction::LoadZeroSuperAttr { idx }) => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, false);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b01: method=1, class=0)
-                    Instruction::LoadZeroSuperMethod { idx } => {
+                    Instruction::Pseudo(PseudoInstruction::LoadZeroSuperMethod { idx }) => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, false);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
-                    Instruction::LoadSuperAttr { arg: idx } => {
+                    Instruction::Real(RealInstruction::LoadSuperAttr { arg: idx }) => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, true);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     _ => {}
                 }
@@ -277,14 +277,16 @@ impl CodeInfo {
 
                     // Convert JUMP pseudo to real instructions (direction depends on offset)
                     let op = match info.instr {
-                        Instruction::Jump { .. } if target != BlockIdx::NULL => {
+                        Instruction::Pseudo(PseudoInstruction::Jump { .. })
+                            if target != BlockIdx::NULL =>
+                        {
                             let target_offset = block_to_offset[target.idx()].0;
                             if target_offset > current_offset {
-                                Instruction::JumpForward {
+                                RealInstruction::JumpForward {
                                     target: Arg::marker(),
                                 }
                             } else {
-                                Instruction::JumpBackward {
+                                RealInstruction::JumpBackward {
                                     target: Arg::marker(),
                                 }
                             }
@@ -299,7 +301,7 @@ impl CodeInfo {
                     ));
                     instructions.extend(
                         extras
-                            .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
+                            .map(|byte| CodeUnit::new(RealInstruction::ExtendedArg, byte))
                             .chain([CodeUnit { op, arg: lo_arg }]),
                     );
                     current_offset += info.arg.instr_size() as u32;
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 5270b89f3ad..ba35dfd7f3c 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -14,7 +14,7 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
-pub use crate::bytecode::instruction::Instruction;
+pub use crate::bytecode::instruction::{Instruction, PseudoInstruction, RealInstruction};
 
 mod instruction;
 
@@ -117,7 +117,7 @@ pub const fn decode_load_super_attr_arg(oparg: u32) -> (u32, bool, bool) {
     (name_idx, load_method, has_class)
 }
 
-/// Oparg values for [`Instruction::ConvertValue`].
+/// Oparg values for [`RealInstruction::ConvertValue`].
 ///
 /// ## See also
 ///
@@ -161,7 +161,7 @@ impl fmt::Display for ConvertValueOparg {
             Self::Str => "1 (str)",
             Self::Repr => "2 (repr)",
             Self::Ascii => "3 (ascii)",
-            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
+            // We should never reach this. `FVC_NONE` are being handled by `RealInstruction::FormatSimple`
             Self::None => "",
         };
 
@@ -467,9 +467,9 @@ pub struct OpArgState {
 
 impl OpArgState {
     #[inline(always)]
-    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
+    pub fn get(&mut self, ins: CodeUnit) -> (RealInstruction, OpArg) {
         let arg = self.extend(ins.arg);
-        if ins.op != Instruction::ExtendedArg {
+        if ins.op != RealInstruction::ExtendedArg {
             self.reset();
         }
         (ins.op, arg)
@@ -605,7 +605,7 @@ impl<T: OpArgType> fmt::Debug for Arg<T> {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 #[repr(transparent)]
 // XXX: if you add a new instruction that stores a Label, make sure to add it in
-// Instruction::label_arg
+// RealInstruction::label_arg
 pub struct Label(pub u32);
 
 impl OpArgType for Label {
@@ -692,14 +692,14 @@ pub type NameIdx = u32;
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct CodeUnit {
-    pub op: Instruction,
+    pub op: RealInstruction,
     pub arg: OpArgByte,
 }
 
 const _: () = assert!(mem::size_of::<CodeUnit>() == 2);
 
 impl CodeUnit {
-    pub const fn new(op: Instruction, arg: OpArgByte) -> Self {
+    pub const fn new(op: RealInstruction, arg: OpArgByte) -> Self {
         Self { op, arg }
     }
 }
@@ -956,9 +956,9 @@ op_arg_enum!(
     /// # Examples
     ///
     /// ```rust
-    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
+    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, RealInstruction};
     /// let (op, _) = Arg::new(BinaryOperator::Add);
-    /// let instruction = Instruction::BinaryOp { op };
+    /// let instruction = RealInstruction::BinaryOp { op };
     /// ```
     ///
     /// See also:
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 89b5933022d..6ca6e3a97cc 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -244,20 +244,6 @@ pub enum RealInstruction {
     Resume {
         arg: Arg<u32>,
     } = 149,
-    // ===== LOAD_SUPER_* Pseudo Opcodes (136-138) =====
-    // These are converted to LoadSuperAttr during bytecode finalization.
-    // "Zero" variants are for 0-arg super() calls (has_class=false).
-    // Non-"Zero" variants are for 2-arg super(cls, self) calls (has_class=true).
-    /// 2-arg super(cls, self).method() - has_class=true, load_method=true
-    LoadSuperMethod {
-        idx: Arg<NameIdx>,
-    } = 136, // CPython uses pseudo-op 260
-    LoadZeroSuperAttr {
-        idx: Arg<NameIdx>,
-    } = 137, // CPython uses pseudo-op 261
-    LoadZeroSuperMethod {
-        idx: Arg<NameIdx>,
-    } = 138, // CPython uses pseudo-op 262
     // ==================== RustPython-only instructions (119-135) ====================
     // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
     // So we assign random IDs to these opcodes.
@@ -344,10 +330,6 @@ impl TryFrom<u8> for RealInstruction {
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
             u8::from(Self::SetExcInfo),
             u8::from(Self::Subscript),
-            // LOAD_SUPER_* pseudo opcodes (136-138)
-            u8::from(Self::LoadSuperMethod { idx: Arg::marker() }),
-            u8::from(Self::LoadZeroSuperAttr { idx: Arg::marker() }),
-            u8::from(Self::LoadZeroSuperMethod { idx: Arg::marker() }),
         ];
 
         if (cpython_start..=cpython_end).contains(&value)
@@ -366,8 +348,7 @@ impl RealInstruction {
     #[inline]
     pub const fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::Jump { target: l }
-            | Self::JumpBackward { target: l }
+            Self::JumpBackward { target: l }
             | Self::JumpBackwardNoInterrupt { target: l }
             | Self::JumpForward { target: l }
             | Self::JumpIfNotExcMatch(l)
@@ -395,8 +376,7 @@ impl RealInstruction {
     pub const fn unconditional_branch(&self) -> bool {
         matches!(
             self,
-            Self::Jump { .. }
-                | Self::JumpForward { .. }
+            Self::JumpForward { .. }
                 | Self::JumpBackward { .. }
                 | Self::JumpBackwardNoInterrupt { .. }
                 | Self::Continue { .. }
@@ -439,13 +419,10 @@ impl RealInstruction {
             Self::DeleteGlobal(_) => 0,
             Self::DeleteDeref(_) => 0,
             Self::LoadFromDictOrDeref(_) => 1,
-            Self::LoadClosure(_) => 1,
             Self::Subscript => -1,
             Self::StoreSubscr => -3,
             Self::DeleteSubscr => -2,
             Self::LoadAttr { .. } => 0,
-            // LoadAttrMethod: pop obj, push method + self_or_null
-            Self::LoadAttrMethod { .. } => 1,
             Self::StoreAttr { .. } => -2,
             Self::DeleteAttr { .. } => -1,
             Self::LoadConst { .. } => 1,
@@ -463,7 +440,6 @@ impl RealInstruction {
             Self::CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
             Self::Continue { .. } => 0,
             Self::Break { .. } => 0,
-            Self::Jump { .. } => 0,
             Self::PopJumpIfTrue { .. } => -1,
             Self::PopJumpIfFalse { .. } => -1,
             Self::JumpIfTrueOrPop { .. } => {
@@ -597,9 +573,6 @@ impl RealInstruction {
                 if load_method { -3 + 2 } else { -3 + 1 }
             }
             // Pseudo instructions (calculated before conversion)
-            Self::LoadSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
-            Self::LoadZeroSuperAttr { .. } => -3 + 1, // pop 3, push [attr]
-            Self::LoadZeroSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
             Self::Cache => 0,
             Self::BinarySlice => 0,
             Self::BinaryOpInplaceAddUnicode => 0,
@@ -747,7 +720,6 @@ impl RealInstruction {
             Self::ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
             Self::ImportName { idx } => w!(IMPORT_NAME, name = idx),
             Self::IsOp(inv) => w!(IS_OP, ?inv),
-            Self::Jump { target } => w!(JUMP, target),
             Self::JumpBackward { target } => w!(JUMP_BACKWARD, target),
             Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
             Self::JumpForward { target } => w!(JUMP_FORWARD, target),
@@ -769,10 +741,8 @@ impl RealInstruction {
                     write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
                 }
             }
-            Self::LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
             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),
@@ -789,9 +759,6 @@ impl RealInstruction {
                     "LOAD_SUPER_ATTR", encoded, attr_name, load_method, has_class
                 )
             }
-            Self::LoadSuperMethod { idx } => w!(LOAD_SUPER_METHOD, name = idx),
-            Self::LoadZeroSuperAttr { idx } => w!(LOAD_ZERO_SUPER_ATTR, name = idx),
-            Self::LoadZeroSuperMethod { idx } => w!(LOAD_ZERO_SUPER_METHOD, name = idx),
             Self::MakeFunction => w!(MAKE_FUNCTION),
             Self::MapAdd { i } => w!(MAP_ADD, i),
             Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
@@ -846,17 +813,59 @@ impl RealInstruction {
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u16)]
-enum PseudoInstruction {
-    Jump { target: Arg<Label> } = 256,
+pub enum PseudoInstruction {
+    Jump {
+        target: Arg<Label>,
+    } = 256,
+    JumpNoInterrupt {
+        target: Arg<Label>,
+    } = 257, // Placeholder
     LoadClosure(Arg<NameIdx>) = 258,
-    LoadAttrMethod { idx: Arg<NameIdx> } = 259,
-    PopBlock = 263,
+    LoadAttrMethod {
+        idx: Arg<NameIdx>,
+    } = 259,
+    // "Zero" variants are for 0-arg super() calls (has_class=false).
+    // Non-"Zero" variants are for 2-arg super(cls, self) calls (has_class=true).
+    /// 2-arg super(cls, self).method() - has_class=true, load_method=true
+    LoadSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 260,
+    LoadZeroSuperAttr {
+        idx: Arg<NameIdx>,
+    } = 261,
+    LoadZeroSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 262,
+    PopBlock = 263,           // Placeholder
+    SetupCleanup = 264,       // Placeholder
+    SetupFinally = 265,       // Placeholder
+    SetupWith = 266,          // Placeholder
+    StoreFastMaybeNull = 267, // Placeholder
+}
+
+impl InstructionMetadata for PseudoInstruction {
+    pub fn stack_effect(&self, _arg: OpArg, _jump: bool) -> i32 {
+        match self {
+            Self::Jump { .. } => 0,
+            Self::JumpNoInterrupt { .. } => 0,
+            Self::LoadClosure(_) => 1,
+            Self::LoadAttrMethod { .. } => 1, // pop obj, push method + self_or_null
+            Self::LoadSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
+            Self::LoadZeroSuperAttr { .. } => -3 + 1, // pop 3, push [attr]
+            Self::LoadZeroSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
+            Self::PopBlock => 0,
+            Self::SetupCleanup => 0,
+            Self::SetupFinally => 0,
+            Self::SetupWith => 0,
+            Self::StoreFastMaybeNull => 0,
+        }
+    }
 }
 
 const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum Instruction {
+pub enum Instruction {
     Real(RealInstruction),
     Pseudo(PseudoInstruction),
 }
@@ -872,3 +881,7 @@ impl From<PseudoInstruction> for Instruction {
         Self::Pseudo(value)
     }
 }
+
+pub trait InstructionMetadata {
+    fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;
+}

From 6f09ebe51b613f186d36a3d2eb545b71932403c2 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 12 Jan 2026 11:56:14 +0200
Subject: [PATCH 03/35] Base compiler-core

---
 crates/compiler-core/src/bytecode.rs          |   4 +-
 .../compiler-core/src/bytecode/instruction.rs | 195 ++++++++++++++----
 2 files changed, 156 insertions(+), 43 deletions(-)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index ba35dfd7f3c..9f801faf9cc 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -14,7 +14,9 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
-pub use crate::bytecode::instruction::{Instruction, PseudoInstruction, RealInstruction};
+pub use crate::bytecode::instruction::{
+    Instruction, InstructionMetadata, PseudoInstruction, RealInstruction,
+};
 
 mod instruction;
 
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 6ca6e3a97cc..a28bf5691f4 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -343,10 +343,9 @@ impl TryFrom<u8> for RealInstruction {
     }
 }
 
-impl RealInstruction {
-    /// Gets the label stored inside this instruction, if it exists
+impl InstructionMetadata for RealInstruction {
     #[inline]
-    pub const fn label_arg(&self) -> Option<Arg<Label>> {
+    fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
             Self::JumpBackward { target: l }
             | Self::JumpBackwardNoInterrupt { target: l }
@@ -364,16 +363,7 @@ impl RealInstruction {
         }
     }
 
-    /// Whether this is an unconditional branching
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction};
-    /// let jump_inst = RealInstruction::Jump { target: Arg::marker() };
-    /// assert!(jump_inst.unconditional_branch())
-    /// ```
-    pub const fn unconditional_branch(&self) -> bool {
+    fn unconditional_branch(&self) -> bool {
         matches!(
             self,
             Self::JumpForward { .. }
@@ -388,18 +378,7 @@ impl RealInstruction {
         )
     }
 
-    /// What effect this instruction has on the stack
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label};
-    /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = RealInstruction::Jump { target };
-    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// ```
-    ///
-    pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
+    fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
             Self::Nop => 0,
             Self::ImportName { .. } => -1,
@@ -602,22 +581,8 @@ impl RealInstruction {
         }
     }
 
-    pub fn display<'a>(
-        &'a self,
-        arg: OpArg,
-        ctx: &'a impl InstrDisplayContext,
-    ) -> impl fmt::Display + 'a {
-        struct FmtFn<F>(F);
-        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                (self.0)(f)
-            }
-        }
-        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
-    }
-
     #[allow(clippy::too_many_arguments)]
-    pub(crate) fn fmt_dis(
+    fn fmt_dis(
         &self,
         arg: OpArg,
         f: &mut fmt::Formatter<'_>,
@@ -836,15 +801,52 @@ pub enum PseudoInstruction {
     LoadZeroSuperMethod {
         idx: Arg<NameIdx>,
     } = 262,
-    PopBlock = 263,           // Placeholder
+    PopBlock = 263,
     SetupCleanup = 264,       // Placeholder
     SetupFinally = 265,       // Placeholder
     SetupWith = 266,          // Placeholder
     StoreFastMaybeNull = 267, // Placeholder
 }
 
+impl From<PseudoInstruction> for u16 {
+    #[inline]
+    fn from(ins: PseudoInstruction) -> Self {
+        // SAFETY: there's no padding bits
+        unsafe { core::mem::transmute::<PseudoInstruction, Self>(ins) }
+    }
+}
+
+impl TryFrom<u16> for PseudoInstruction {
+    type Error = MarshalError;
+
+    #[inline]
+    fn try_from(value: u16) -> Result<Self, MarshalError> {
+        let start = u16::from(Self::Jump {
+            target: Arg::marker(),
+        });
+        let end = u16::from(Self::StoreFastMaybeNull);
+
+        if (start..=end).contains(&value) {
+            Ok(unsafe { core::mem::transmute::<u16, Self>(value) })
+        } else {
+            Err(Self::Error::InvalidBytecode)
+        }
+    }
+}
+
 impl InstructionMetadata for PseudoInstruction {
-    pub fn stack_effect(&self, _arg: OpArg, _jump: bool) -> i32 {
+    fn label_arg(&self) -> Option<Arg<Label>> {
+        match self {
+            Self::Jump { target: l } => Some(*l),
+            _ => None,
+        }
+    }
+
+    fn unconditional_branch(&self) -> bool {
+        matches!(self, Self::Jump { .. },)
+    }
+
+    fn stack_effect(&self, _arg: OpArg, _jump: bool) -> i32 {
         match self {
             Self::Jump { .. } => 0,
             Self::JumpNoInterrupt { .. } => 0,
@@ -860,6 +862,18 @@ impl InstructionMetadata for PseudoInstruction {
             Self::StoreFastMaybeNull => 0,
         }
     }
+
+    fn fmt_dis(
+        &self,
+        _arg: OpArg,
+        _f: &mut fmt::Formatter<'_>,
+        _ctx: &impl InstrDisplayContext,
+        _expand_code_objects: bool,
+        _pad: usize,
+        _level: usize,
+    ) -> fmt::Result {
+        unimplemented!()
+    }
 }
 
 const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
@@ -882,6 +896,103 @@ impl From<PseudoInstruction> for Instruction {
     }
 }
 
+impl TryFrom<u8> for Instruction {
+    type Error = MarshalError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(RealInstruction::try_from(value)?.into())
+    }
+}
+
+impl TryFrom<u16> for Instruction {
+    type Error = MarshalError;
+
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match u8::try_from(value) {
+            Ok(v) => v.try_into(),
+            Err(_) => Ok(PseudoInstruction::try_from(value)?.into()),
+        }
+    }
+}
+
+macro_rules! inst_either {
+    (fn $name:ident ( &self $(, $arg:ident : $argty:ty )* ) -> $ret:ty ) => {
+        fn $name(&self $(, $arg : $argty )* ) -> $ret {
+            match self {
+                Self::Real(op) => op.$name($($arg),*),
+                Self::Pseudo(op) => op.$name($($arg),*),
+            }
+        }
+    };
+}
+
+impl InstructionMetadata for Instruction {
+    inst_either!(fn label_arg(&self) -> Option<Arg<Label>>);
+
+    inst_either!(fn unconditional_branch(&self) -> bool);
+
+    inst_either!(fn stack_effect(&self, arg: OpArg, jump: bool) -> i32);
+
+    inst_either!(fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize
+    ) -> fmt::Result);
+}
+
 pub trait InstructionMetadata {
+    /// Gets the label stored inside this instruction, if it exists.
+    fn label_arg(&self) -> Option<Arg<Label>>;
+
+    /// Whether this is an unconditional branching.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction};
+    /// let jump_inst = RealInstruction::Jump { target: Arg::marker() };
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
+    fn unconditional_branch(&self) -> bool;
+
+    /// What effect this instruction has on the stack
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label};
+    /// let (target, jump_arg) = Arg::new(Label(0xF));
+    /// let jump_instruction = RealInstruction::Jump { target };
+    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
+    /// ```
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;
+
+    #[allow(clippy::too_many_arguments)]
+    fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize,
+    ) -> fmt::Result;
+
+    fn display<'a>(
+        &'a self,
+        arg: OpArg,
+        ctx: &'a impl InstrDisplayContext,
+    ) -> impl fmt::Display + 'a {
+        struct FmtFn<F>(F);
+        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                (self.0)(f)
+            }
+        }
+        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
+    }
 }

From 68051753dec77a507c459f1f53c360767f8258fc Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 12 Jan 2026 16:59:41 +0200
Subject: [PATCH 04/35] save

---
 crates/codegen/src/compile.rs                 | 131 +++++++++++-------
 crates/codegen/src/ir.rs                      |  12 +-
 .../compiler-core/src/bytecode/instruction.rs |  14 ++
 3 files changed, 101 insertions(+), 56 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index fc9c2839a69..008b45d9525 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -34,16 +34,17 @@ use ruff_python_ast::{
     visitor::{Visitor, walk_expr},
 };
 use ruff_text_size::{Ranged, TextRange};
+use std::collections::HashSet;
+
 use rustpython_compiler_core::{
     Mode, OneIndexed, PositionEncoding, SourceFile, SourceLocation,
     bytecode::{
         self, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
-        ComparisonOperator, ConstantData, ConvertValueOparg, Invert, OpArg, OpArgType,
-        RealInstruction, UnpackExArgs,
+        ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, Invert, OpArg, OpArgType,
+        PseudoInstruction, RealInstruction, UnpackExArgs,
     },
 };
 use rustpython_wtf8::Wtf8Buf;
-use std::collections::HashSet;
 
 const MAXBLOCKS: usize = 20;
 
@@ -273,18 +274,41 @@ pub fn compile_expression(
     Ok(code)
 }
 
+// TODO: Unify Real and Pseudo arms
 macro_rules! emit {
-    ($c:expr, $inst:ty { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| $inst { $arg: x })
+    // Real
+    ($c:expr, RealInstruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
+        $c.emit_arg($arg, |x| {
+            Instruction::Real(RealInstruction::$op { $arg: x })
+        })
     };
-    ($c:expr, $inst:ty { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| $inst { $arg: x })
+    ($c:expr, RealInstruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
+        $c.emit_arg($arg_val, |x| {
+            Instruction::Real(RealInstruction::$op { $arg: x })
+        })
+    };
+    ($c:expr, RealInstruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
+        $c.emit_arg($arg_val, RealInstruction::$op)
     };
-    ($c:expr, $inst:ty( $arg_val:expr $(,)? )$(,)?) => {
-        $c.emit_arg($arg_val, $inst)
+    ($c:expr, RealInstruction::$op:ident$(,)?) => {
+        $c.emit_no_arg(Instruction::Real(RealInstruction::$op))
     };
-    ($c:expr, $inst:ty$(,)?) => {
-        $c.emit_no_arg($inst)
+    // Pseudo
+    ($c:expr, PseudoInstruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
+        $c.emit_arg($arg, |x| {
+            Instruction::Pseudo(PseudoInstruction::$op { $arg: x })
+        })
+    };
+    ($c:expr, PseudoInstruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
+        $c.emit_arg($arg_val, |x| {
+            Instruction::Pseudo(PseudoInstruction::$op { $arg: x })
+        })
+    };
+    ($c:expr, PseudoInstruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
+        $c.emit_arg($arg_val, Instruction::Pseudo(PseudoInstruction::$op))
+    };
+    ($c:expr, PseudoInstruction::$op:ident$(,)?) => {
+        $c.emit_no_arg(Instruction::Pseudo(PseudoInstruction::$op))
     };
 }
 
@@ -1181,7 +1205,7 @@ impl Compiler {
                 // Stack when entering: [..., __exit__, return_value (if preserve_tos)]
                 // Need to call __exit__(None, None, None)
 
-                emit!(self, RealInstruction::PopBlock);
+                emit!(self, PseudoInstruction::PopBlock);
 
                 // If preserving return value, swap it below __exit__
                 if preserve_tos {
@@ -2620,7 +2644,7 @@ impl Compiler {
 
                 // Check exception type:
                 self.compile_expression(exc_type)?;
-                emit!(self, PseudoInstruction::JumpIfNotExcMatch(next_handler));
+                emit!(self, RealInstruction::JumpIfNotExcMatch(next_handler));
 
                 // We have a match, store in name (except x as y)
                 if let Some(alias) = name {
@@ -3601,7 +3625,7 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, RealInstruction::LoadClosure(idx.to_u32()));
+                emit!(self, PseudoInstruction::LoadClosure(idx.to_u32()));
             }
 
             // Build tuple of closure variables
@@ -3793,7 +3817,7 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, RealInstruction::LoadClosure(classcell_idx.to_u32()));
+            emit!(self, PseudoInstruction::LoadClosure(classcell_idx.to_u32()));
             emit!(self, RealInstruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
             emit!(self, RealInstruction::StoreName(classcell));
@@ -5386,10 +5410,7 @@ impl Compiler {
             emit!(self, RealInstruction::PopTop);
             */
 
-            emit!(
-                self,
-                PseudoInstruction::JumpIfFalseOrPop { target: cleanup }
-            );
+            emit!(self, RealInstruction::JumpIfFalseOrPop { target: cleanup });
         }
 
         self.compile_expression(last_comparator)?;
@@ -5915,7 +5936,7 @@ impl Compiler {
                             emit!(self, RealInstruction::LoadSuperAttr { arg: idx });
                         }
                         SuperCallType::ZeroArg => {
-                            emit!(self, RealInstruction::LoadZeroSuperAttr { idx });
+                            emit!(self, PseudoInstruction::LoadZeroSuperAttr { idx });
                         }
                     }
                 } else {
@@ -6103,9 +6124,12 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<listcomp>",
-                    Some(RealInstruction::BuildList {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(
+                        RealInstruction::BuildList {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
                     generators,
                     &|compiler| {
                         compiler.compile_comprehension_element(elt)?;
@@ -6126,9 +6150,12 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<setcomp>",
-                    Some(RealInstruction::BuildSet {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(
+                        RealInstruction::BuildSet {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
                     generators,
                     &|compiler| {
                         compiler.compile_comprehension_element(elt)?;
@@ -6152,9 +6179,12 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<dictcomp>",
-                    Some(RealInstruction::BuildMap {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(
+                        RealInstruction::BuildMap {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
                     generators,
                     &|compiler| {
                         // changed evaluation order for Py38 named expression PEP 572
@@ -6356,10 +6386,10 @@ impl Compiler {
                 let idx = self.name(attr.as_str());
                 match super_type {
                     SuperCallType::TwoArg { .. } => {
-                        emit!(self, RealInstruction::LoadSuperMethod { idx });
+                        emit!(self, PseudoInstruction::LoadSuperMethod { idx });
                     }
                     SuperCallType::ZeroArg => {
-                        emit!(self, RealInstruction::LoadZeroSuperMethod { idx });
+                        emit!(self, PseudoInstruction::LoadZeroSuperMethod { idx });
                     }
                 }
                 self.compile_call_helper(0, args)?;
@@ -6368,7 +6398,7 @@ impl Compiler {
                 // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, RealInstruction::LoadAttrMethod { idx });
+                emit!(self, PseudoInstruction::LoadAttrMethod { idx });
                 self.compile_call_helper(0, args)?;
             }
         } else {
@@ -6514,7 +6544,7 @@ impl Compiler {
     fn compile_comprehension(
         &mut self,
         name: &str,
-        init_collection: Option<RealInstruction>,
+        init_collection: Option<Instruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         comprehension_type: ComprehensionType,
@@ -6598,7 +6628,7 @@ impl Compiler {
         let return_none = init_collection.is_none();
         // Create empty object of proper type:
         if let Some(init_collection) = init_collection {
-            self._emit(init_collection, OpArg(0), BlockIdx::NULL)
+            self._emit(init_collection.into(), OpArg(0), BlockIdx::NULL)
         }
 
         let mut loop_labels = vec![];
@@ -6737,7 +6767,7 @@ impl Compiler {
     /// This generates bytecode inline without creating a new code object
     fn compile_inlined_comprehension(
         &mut self,
-        init_collection: Option<RealInstruction>,
+        init_collection: Option<Instruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         _has_an_async_gen: bool,
@@ -6961,14 +6991,14 @@ impl Compiler {
         });
     }
 
-    fn emit_no_arg(&mut self, ins: RealInstruction) {
+    fn emit_no_arg(&mut self, ins: Instruction) {
         self._emit(ins, OpArg::null(), BlockIdx::NULL)
     }
 
     fn emit_arg<A: OpArgType, T: EmitArg<A>>(
         &mut self,
         arg: T,
-        f: impl FnOnce(OpArgMarker<A>) -> RealInstruction,
+        f: impl FnOnce(OpArgMarker<A>) -> Instruction,
     ) {
         let (op, arg, target) = arg.emit(f);
         self._emit(op, arg, target)
@@ -6983,19 +7013,19 @@ impl Compiler {
 
     fn emit_load_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| RealInstruction::LoadConst { idx })
+        self.emit_arg(idx, |idx| RealInstruction::LoadConst { idx }.into())
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| RealInstruction::ReturnConst { idx })
+        self.emit_arg(idx, |idx| RealInstruction::ReturnConst { idx }.into())
     }
 
     fn emit_return_value(&mut self) {
         if let Some(inst) = self.current_block().instructions.last_mut()
-            && let RealInstruction::LoadConst { idx } = inst.instr
+            && let Instruction::Real(RealInstruction::LoadConst { idx }) = inst.instr
         {
-            inst.instr = RealInstruction::ReturnConst { idx };
+            inst.instr = RealInstruction::ReturnConst { idx }.into();
             return;
         }
         emit!(self, RealInstruction::ReturnValue)
@@ -7446,24 +7476,23 @@ impl Compiler {
 trait EmitArg<Arg: OpArgType> {
     fn emit(
         self,
-        f: impl FnOnce(OpArgMarker<Arg>) -> RealInstruction,
-    ) -> (RealInstruction, OpArg, BlockIdx);
+        f: impl FnOnce(OpArgMarker<Arg>) -> Instruction,
+    ) -> (Instruction, OpArg, BlockIdx);
 }
+
 impl<T: OpArgType> EmitArg<T> for T {
-    fn emit(
-        self,
-        f: impl FnOnce(OpArgMarker<T>) -> RealInstruction,
-    ) -> (RealInstruction, OpArg, BlockIdx) {
+    fn emit(self, f: impl FnOnce(OpArgMarker<T>) -> Instruction) -> (Instruction, OpArg, BlockIdx) {
         let (marker, arg) = OpArgMarker::new(self);
-        (f(marker), arg, BlockIdx::NULL)
+        (f(marker).into(), arg, BlockIdx::NULL)
     }
 }
+
 impl EmitArg<bytecode::Label> for BlockIdx {
     fn emit(
         self,
-        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> RealInstruction,
-    ) -> (RealInstruction, OpArg, BlockIdx) {
-        (f(OpArgMarker::marker()), OpArg::null(), self)
+        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> Instruction,
+    ) -> (Instruction, OpArg, BlockIdx) {
+        (f(OpArgMarker::marker()).into(), OpArg::null(), self)
     }
 }
 
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index c6c5c2deb2c..baeb77cfdc8 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -1,12 +1,14 @@
 use core::ops;
 
 use crate::{IndexMap, IndexSet, error::InternalError};
+
 use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
         Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
-        InstrDisplayContext, Instruction, Label, OpArg, PseudoInstruction, PyCodeLocationInfoKind,
-        encode_exception_table, encode_load_attr_arg, encode_load_super_attr_arg,
+        InstrDisplayContext, Instruction, InstructionMetadata, Label, OpArg, PseudoInstruction,
+        PyCodeLocationInfoKind, RealInstruction, encode_exception_table, encode_load_attr_arg,
+        encode_load_super_attr_arg,
     },
     varint::{write_signed_varint, write_varint},
 };
@@ -203,7 +205,7 @@ impl CodeInfo {
                         info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
                     }
                     // LOAD_ATTR → encode with method flag=0
-                    Instruction::Real(Instruction::LoadAttr { idx }) => {
+                    Instruction::Real(RealInstruction::LoadAttr { idx }) => {
                         let encoded = encode_load_attr_arg(idx.get(info.arg), false);
                         info.arg = OpArg(encoded);
                         info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
@@ -213,7 +215,7 @@ impl CodeInfo {
                         info.instr = RealInstruction::Nop.into();
                     }
                     // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
-                    Instruction::Pseudo(Instruction::LoadSuperMethod { idx }) => {
+                    Instruction::Pseudo(PseudoInstruction::LoadSuperMethod { idx }) => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
                         info.arg = OpArg(encoded);
                         info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
@@ -291,7 +293,7 @@ impl CodeInfo {
                                 }
                             }
                         }
-                        other => other,
+                        other => other.expect_real(),
                     };
 
                     let (extras, lo_arg) = info.arg.split();
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index a28bf5691f4..9b851632898 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -944,6 +944,20 @@ impl InstructionMetadata for Instruction {
     ) -> fmt::Result);
 }
 
+impl Instruction {
+    pub const fn as_real(self) -> Option<RealInstruction> {
+        match self {
+            Self::Real(ins) => Some(ins),
+            _ => None,
+        }
+    }
+
+    pub const fn expect_real(self) -> RealInstruction {
+        self.as_real()
+            .expect("Expected Instruction::Real, found Instruction::Pseudo")
+    }
+}
+
 pub trait InstructionMetadata {
     /// Gets the label stored inside this instruction, if it exists.
     fn label_arg(&self) -> Option<Arg<Label>>;

From 046e17a36788a135c9c96aa1ba638a6403e90ce6 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 12 Jan 2026 17:53:50 +0200
Subject: [PATCH 05/35] Codegen compile

---
 crates/codegen/src/compile.rs | 51 ++++++++++++++++-------------------
 1 file changed, 23 insertions(+), 28 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 008b45d9525..9015b30ba61 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -278,37 +278,29 @@ pub fn compile_expression(
 macro_rules! emit {
     // Real
     ($c:expr, RealInstruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| {
-            Instruction::Real(RealInstruction::$op { $arg: x })
-        })
+        $c.emit_arg($arg, |x| RealInstruction::$op { $arg: x })
     };
     ($c:expr, RealInstruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| {
-            Instruction::Real(RealInstruction::$op { $arg: x })
-        })
+        $c.emit_arg($arg_val, |x| RealInstruction::$op { $arg: x })
     };
     ($c:expr, RealInstruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
         $c.emit_arg($arg_val, RealInstruction::$op)
     };
     ($c:expr, RealInstruction::$op:ident$(,)?) => {
-        $c.emit_no_arg(Instruction::Real(RealInstruction::$op))
+        $c.emit_no_arg(RealInstruction::$op)
     };
     // Pseudo
     ($c:expr, PseudoInstruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| {
-            Instruction::Pseudo(PseudoInstruction::$op { $arg: x })
-        })
+        $c.emit_arg($arg, |x| PseudoInstruction::$op { $arg: x })
     };
     ($c:expr, PseudoInstruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| {
-            Instruction::Pseudo(PseudoInstruction::$op { $arg: x })
-        })
+        $c.emit_arg($arg_val, |x| PseudoInstruction::$op { $arg: x })
     };
     ($c:expr, PseudoInstruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
-        $c.emit_arg($arg_val, Instruction::Pseudo(PseudoInstruction::$op))
+        $c.emit_arg($arg_val, PseudoInstruction::$op)
     };
     ($c:expr, PseudoInstruction::$op:ident$(,)?) => {
-        $c.emit_no_arg(Instruction::Pseudo(PseudoInstruction::$op))
+        $c.emit_no_arg(PseudoInstruction::$op)
     };
 }
 
@@ -6628,7 +6620,7 @@ impl Compiler {
         let return_none = init_collection.is_none();
         // Create empty object of proper type:
         if let Some(init_collection) = init_collection {
-            self._emit(init_collection.into(), OpArg(0), BlockIdx::NULL)
+            self._emit(init_collection, OpArg(0), BlockIdx::NULL)
         }
 
         let mut loop_labels = vec![];
@@ -6975,14 +6967,14 @@ impl Compiler {
     }
 
     // Low level helper functions:
-    fn _emit(&mut self, instr: Instruction, arg: OpArg, target: BlockIdx) {
+    fn _emit<I: Into<Instruction>>(&mut self, instr: I, arg: OpArg, target: BlockIdx) {
         let range = self.current_source_range;
         let source = self.source_file.to_source_code();
         let location = source.source_location(range.start(), PositionEncoding::Utf8);
         let end_location = source.source_location(range.end(), PositionEncoding::Utf8);
         let except_handler = self.current_except_handler();
         self.current_block().instructions.push(ir::InstructionInfo {
-            instr,
+            instr: instr.into(),
             arg,
             target,
             location,
@@ -6991,14 +6983,14 @@ impl Compiler {
         });
     }
 
-    fn emit_no_arg(&mut self, ins: Instruction) {
+    fn emit_no_arg<I: Into<Instruction>>(&mut self, ins: I) {
         self._emit(ins, OpArg::null(), BlockIdx::NULL)
     }
 
-    fn emit_arg<A: OpArgType, T: EmitArg<A>>(
+    fn emit_arg<A: OpArgType, T: EmitArg<A>, I: Into<Instruction>>(
         &mut self,
         arg: T,
-        f: impl FnOnce(OpArgMarker<A>) -> Instruction,
+        f: impl FnOnce(OpArgMarker<A>) -> I,
     ) {
         let (op, arg, target) = arg.emit(f);
         self._emit(op, arg, target)
@@ -7013,12 +7005,12 @@ impl Compiler {
 
     fn emit_load_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| RealInstruction::LoadConst { idx }.into())
+        self.emit_arg(idx, |idx| RealInstruction::LoadConst { idx })
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| RealInstruction::ReturnConst { idx }.into())
+        self.emit_arg(idx, |idx| RealInstruction::ReturnConst { idx })
     }
 
     fn emit_return_value(&mut self) {
@@ -7474,23 +7466,26 @@ impl Compiler {
 }
 
 trait EmitArg<Arg: OpArgType> {
-    fn emit(
+    fn emit<I: Into<Instruction>>(
         self,
-        f: impl FnOnce(OpArgMarker<Arg>) -> Instruction,
+        f: impl FnOnce(OpArgMarker<Arg>) -> I,
     ) -> (Instruction, OpArg, BlockIdx);
 }
 
 impl<T: OpArgType> EmitArg<T> for T {
-    fn emit(self, f: impl FnOnce(OpArgMarker<T>) -> Instruction) -> (Instruction, OpArg, BlockIdx) {
+    fn emit<I: Into<Instruction>>(
+        self,
+        f: impl FnOnce(OpArgMarker<T>) -> I,
+    ) -> (Instruction, OpArg, BlockIdx) {
         let (marker, arg) = OpArgMarker::new(self);
         (f(marker).into(), arg, BlockIdx::NULL)
     }
 }
 
 impl EmitArg<bytecode::Label> for BlockIdx {
-    fn emit(
+    fn emit<I: Into<Instruction>>(
         self,
-        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> Instruction,
+        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> I,
     ) -> (Instruction, OpArg, BlockIdx) {
         (f(OpArgMarker::marker()).into(), OpArg::null(), self)
     }

From d6276230a1691b7e2c0d80173eaaee3a2756024c Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 12 Jan 2026 18:40:49 +0200
Subject: [PATCH 06/35] Move LoadCloure back to RealInstruction

---
 crates/codegen/src/compile.rs                 |   4 +-
 .../compiler-core/src/bytecode/instruction.rs |   7 +-
 crates/vm/src/frame.rs                        | 256 ++++++++----------
 3 files changed, 125 insertions(+), 142 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 9015b30ba61..a421b38a0f4 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -3617,7 +3617,7 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, PseudoInstruction::LoadClosure(idx.to_u32()));
+                emit!(self, RealInstruction::LoadClosure(idx.to_u32()));
             }
 
             // Build tuple of closure variables
@@ -3809,7 +3809,7 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, PseudoInstruction::LoadClosure(classcell_idx.to_u32()));
+            emit!(self, RealInstruction::LoadClosure(classcell_idx.to_u32()));
             emit!(self, RealInstruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
             emit!(self, RealInstruction::StoreName(classcell));
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 9b851632898..07ed2d9dac5 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -275,6 +275,7 @@ pub enum RealInstruction {
     JumpIfNotExcMatch(Arg<Label>) = 131,
     SetExcInfo = 134,
     Subscript = 135,
+    LoadClosure(Arg<NameIdx>) = 253, // TODO: Move to pseudos
 }
 
 const _: () = assert!(mem::size_of::<RealInstruction>() == 1);
@@ -578,6 +579,7 @@ impl InstructionMetadata for RealInstruction {
             Self::StoreFastStoreFast { .. } => 0,
             Self::PopJumpIfNone { .. } => 0,
             Self::PopJumpIfNotNone { .. } => 0,
+            Self::LoadClosure(_) => 1,
         }
     }
 
@@ -771,6 +773,7 @@ impl InstructionMetadata for RealInstruction {
             Self::UnaryNot => w!(UNARY_NOT),
             Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
             Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
+            Self::LoadClosure(_) => w!(LOAD_CLOSURE),
             _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }
@@ -785,7 +788,7 @@ pub enum PseudoInstruction {
     JumpNoInterrupt {
         target: Arg<Label>,
     } = 257, // Placeholder
-    LoadClosure(Arg<NameIdx>) = 258,
+    Reserved258 = 258,
     LoadAttrMethod {
         idx: Arg<NameIdx>,
     } = 259,
@@ -850,7 +853,6 @@ impl InstructionMetadata for PseudoInstruction {
         match self {
             Self::Jump { .. } => 0,
             Self::JumpNoInterrupt { .. } => 0,
-            Self::LoadClosure(_) => 1,
             Self::LoadAttrMethod { .. } => 1, // pop obj, push method + self_or_null
             Self::LoadSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
             Self::LoadZeroSuperAttr { .. } => -3 + 1, // pop 3, push [attr]
@@ -860,6 +862,7 @@ impl InstructionMetadata for PseudoInstruction {
             Self::SetupFinally => 0,
             Self::SetupWith => 0,
             Self::StoreFastMaybeNull => 0,
+            Self::Reserved258 => 0,
         }
     }
 
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 5fb44d8a58b..439905becb4 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -7,7 +7,7 @@ use crate::{
         function::{PyCell, PyCellRef, PyFunction},
         tuple::{PyTuple, PyTupleRef},
     },
-    bytecode,
+    bytecode::{self, RealInstruction},
     convert::{IntoObject, ToPyResult},
     coroutine::Coro,
     exceptions::ExceptionCtor,
@@ -24,6 +24,7 @@ use core::iter::zip;
 use core::sync::atomic;
 use indexmap::IndexMap;
 use itertools::Itertools;
+
 use rustpython_common::{boxvec::BoxVec, lock::PyMutex, wtf8::Wtf8Buf};
 use rustpython_compiler_core::SourceLocation;
 
@@ -391,11 +392,11 @@ impl ExecutingFrame<'_> {
                     // Instruction::Reraise are reraise operations that should not add
                     // new traceback entries
                     let is_reraise = match op {
-                        bytecode::Instruction::RaiseVarargs { kind } => matches!(
+                        RealInstruction::RaiseVarargs { kind } => matches!(
                             kind.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
-                        bytecode::Instruction::Reraise { .. } => true,
+                        RealInstruction::Reraise { .. } => true,
                         _ => false,
                     };
 
@@ -439,13 +440,13 @@ impl ExecutingFrame<'_> {
         let lasti = self.lasti() as usize;
         if let Some(unit) = self.code.instructions.get(lasti) {
             match &unit.op {
-                bytecode::Instruction::Send { .. } => return Some(self.top_value()),
-                bytecode::Instruction::Resume { .. } => {
+                RealInstruction::Send { .. } => return Some(self.top_value()),
+                RealInstruction::Resume { .. } => {
                     // Check if previous instruction was YIELD_VALUE with arg >= 1
                     // This indicates yield-from/await context
                     if lasti > 0
                         && let Some(prev_unit) = self.code.instructions.get(lasti - 1)
-                        && let bytecode::Instruction::YieldValue { .. } = &prev_unit.op
+                        && let RealInstruction::YieldValue { .. } = &prev_unit.op
                     {
                         // YIELD_VALUE arg: 0 = direct yield, >= 1 = yield-from/await
                         // OpArgByte.0 is the raw byte value
@@ -550,7 +551,7 @@ impl ExecutingFrame<'_> {
     #[inline(always)]
     fn execute_instruction(
         &mut self,
-        instruction: bytecode::Instruction,
+        instruction: RealInstruction,
         arg: bytecode::OpArg,
         extend_arg: &mut bool,
         vm: &VirtualMachine,
@@ -584,7 +585,7 @@ impl ExecutingFrame<'_> {
         }
 
         match instruction {
-            bytecode::Instruction::BeforeAsyncWith => {
+            RealInstruction::BeforeAsyncWith => {
                 let mgr = self.pop_value();
                 let error_string = || -> String {
                     format!(
@@ -609,8 +610,8 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
-            bytecode::Instruction::BinarySubscr => {
+            RealInstruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
+            RealInstruction::BinarySubscr => {
                 let key = self.pop_value();
                 let container = self.pop_value();
                 let result = container.get_item(key.as_object(), vm)?;
@@ -618,30 +619,30 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
 
-            bytecode::Instruction::Break { target } => self.unwind_blocks(
+            RealInstruction::Break { target } => self.unwind_blocks(
                 vm,
                 UnwindReason::Break {
                     target: target.get(arg),
                 },
             ),
-            bytecode::Instruction::BuildListFromTuples { size } => {
+            RealInstruction::BuildListFromTuples { size } => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildList { size } => {
+            RealInstruction::BuildList { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildMapForCall { size } => {
+            RealInstruction::BuildMapForCall { size } => {
                 self.execute_build_map_for_call(vm, size.get(arg))
             }
-            bytecode::Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            bytecode::Instruction::BuildSetFromTuples { size } => {
+            RealInstruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
+            RealInstruction::BuildSetFromTuples { size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     // SAFETY: trust compiler
@@ -653,7 +654,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildSet { size } => {
+            RealInstruction::BuildSet { size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     set.add(element, vm)?;
@@ -661,11 +662,9 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildSlice { argc } => {
-                self.execute_build_slice(vm, argc.get(arg))
-            }
+            RealInstruction::BuildSlice { argc } => self.execute_build_slice(vm, argc.get(arg)),
             /*
-             bytecode::Instruction::ToBool => {
+             RealInstruction::ToBool => {
                  dbg!("Shouldn't be called outside of match statements for now")
                  let value = self.pop_value();
                  // call __bool__
@@ -674,7 +673,7 @@ impl ExecutingFrame<'_> {
                  Ok(None)
             }
             */
-            bytecode::Instruction::BuildString { size } => {
+            RealInstruction::BuildString { size } => {
                 let s: Wtf8Buf = self
                     .pop_multiple(size.get(arg) as usize)
                     .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
@@ -682,7 +681,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildTupleFromIter => {
+            RealInstruction::BuildTupleFromIter => {
                 if !self.top_value().class().is(vm.ctx.types.tuple_type) {
                     let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
                     let list_obj = vm.ctx.new_tuple(elements);
@@ -690,48 +689,48 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::BuildTupleFromTuples { size } => {
+            RealInstruction::BuildTupleFromTuples { size } => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildTuple { size } => {
+            RealInstruction::BuildTuple { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::Call { nargs } => {
+            RealInstruction::Call { nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallKw { nargs } => {
+            RealInstruction::CallKw { nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
+            RealInstruction::CallFunctionEx { has_kwargs } => {
                 // Stack: [callable, self_or_null, args_tuple, (kwargs_dict)?]
                 let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallIntrinsic1 { func } => {
+            RealInstruction::CallIntrinsic1 { func } => {
                 let value = self.pop_value();
                 let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
                 self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::CallIntrinsic2 { func } => {
+            RealInstruction::CallIntrinsic2 { func } => {
                 let value2 = self.pop_value();
                 let value1 = self.pop_value();
                 let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
                 self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::CheckEgMatch => {
+            RealInstruction::CheckEgMatch => {
                 let match_type = self.pop_value();
                 let exc_value = self.pop_value();
                 let (rest, matched) =
@@ -740,8 +739,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(matched);
                 Ok(None)
             }
-            bytecode::Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
-            bytecode::Instruction::ContainsOp(invert) => {
+            RealInstruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
+            RealInstruction::ContainsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
 
@@ -752,17 +751,17 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            bytecode::Instruction::Continue { target } => self.unwind_blocks(
+            RealInstruction::Continue { target } => self.unwind_blocks(
                 vm,
                 UnwindReason::Continue {
                     target: target.get(arg),
                 },
             ),
 
-            bytecode::Instruction::ConvertValue { oparg: conversion } => {
+            RealInstruction::ConvertValue { oparg: conversion } => {
                 self.convert_value(conversion.get(arg), vm)
             }
-            bytecode::Instruction::Copy { index } => {
+            RealInstruction::Copy { index } => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
@@ -778,12 +777,12 @@ impl ExecutingFrame<'_> {
                 self.push_value_opt(value);
                 Ok(None)
             }
-            bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            bytecode::Instruction::DeleteDeref(i) => {
+            RealInstruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
+            RealInstruction::DeleteDeref(i) => {
                 self.cells_frees[i.get(arg) as usize].set(None);
                 Ok(None)
             }
-            bytecode::Instruction::DeleteFast(idx) => {
+            RealInstruction::DeleteFast(idx) => {
                 let mut fastlocals = self.fastlocals.lock();
                 let idx = idx.get(arg) as usize;
                 if fastlocals[idx].is_none() {
@@ -798,7 +797,7 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            bytecode::Instruction::DeleteGlobal(idx) => {
+            RealInstruction::DeleteGlobal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 match self.globals.del_item(name, vm) {
                     Ok(()) => {}
@@ -809,7 +808,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteName(idx) => {
+            RealInstruction::DeleteName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let res = self.locals.mapping().ass_subscript(name, None, vm);
 
@@ -822,8 +821,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
-            bytecode::Instruction::DictUpdate { index } => {
+            RealInstruction::DeleteSubscr => self.execute_delete_subscript(vm),
+            RealInstruction::DictUpdate { index } => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
                 // The dict to update is at position TOS-i (before popping source)
@@ -859,7 +858,7 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::EndAsyncFor => {
+            RealInstruction::EndAsyncFor => {
                 // END_ASYNC_FOR pops (awaitable, exc) from stack
                 // Stack: [awaitable, exc] -> []
                 // exception_unwind pushes exception to stack before jumping to handler
@@ -879,19 +878,19 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            bytecode::Instruction::ExtendedArg => {
+            RealInstruction::ExtendedArg => {
                 *extend_arg = true;
                 Ok(None)
             }
-            bytecode::Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
-            bytecode::Instruction::FormatSimple => {
+            RealInstruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            RealInstruction::FormatSimple => {
                 let value = self.pop_value();
                 let formatted = vm.format(&value, vm.ctx.new_str(""))?;
                 self.push_value(formatted.into());
 
                 Ok(None)
             }
-            bytecode::Instruction::FormatWithSpec => {
+            RealInstruction::FormatWithSpec => {
                 let spec = self.pop_value();
                 let value = self.pop_value();
                 let formatted = vm.format(&value, spec.downcast::<PyStr>().unwrap())?;
@@ -899,13 +898,13 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::GetAIter => {
+            RealInstruction::GetAIter => {
                 let aiterable = self.pop_value();
                 let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
                 self.push_value(aiter);
                 Ok(None)
             }
-            bytecode::Instruction::GetANext => {
+            RealInstruction::GetANext => {
                 #[cfg(debug_assertions)] // remove when GetANext is fully implemented
                 let orig_stack_len = self.state.stack.len();
 
@@ -950,7 +949,7 @@ impl ExecutingFrame<'_> {
                 debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
                 Ok(None)
             }
-            bytecode::Instruction::GetAwaitable => {
+            RealInstruction::GetAwaitable => {
                 use crate::protocol::PyIter;
 
                 let awaited_obj = self.pop_value();
@@ -986,13 +985,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(awaitable);
                 Ok(None)
             }
-            bytecode::Instruction::GetIter => {
+            RealInstruction::GetIter => {
                 let iterated_obj = self.pop_value();
                 let iter_obj = iterated_obj.get_iter(vm)?;
                 self.push_value(iter_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::GetYieldFromIter => {
+            RealInstruction::GetYieldFromIter => {
                 // GET_YIELD_FROM_ITER: prepare iterator for yield from
                 // If iterable is a coroutine, ensure we're in a coroutine context
                 // If iterable is a generator, use it directly
@@ -1017,23 +1016,23 @@ impl ExecutingFrame<'_> {
                 self.push_value(iter);
                 Ok(None)
             }
-            bytecode::Instruction::GetLen => {
+            RealInstruction::GetLen => {
                 // STACK.append(len(STACK[-1]))
                 let obj = self.top_value();
                 let len = obj.length(vm)?;
                 self.push_value(vm.ctx.new_int(len).into());
                 Ok(None)
             }
-            bytecode::Instruction::ImportFrom { idx } => {
+            RealInstruction::ImportFrom { idx } => {
                 let obj = self.import_from(vm, idx.get(arg))?;
                 self.push_value(obj);
                 Ok(None)
             }
-            bytecode::Instruction::ImportName { idx } => {
+            RealInstruction::ImportName { idx } => {
                 self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
                 Ok(None)
             }
-            bytecode::Instruction::IsOp(invert) => {
+            RealInstruction::IsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 let res = a.is(&b);
@@ -1045,10 +1044,10 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            bytecode::Instruction::JumpIfFalseOrPop { target } => {
+            RealInstruction::JumpIfFalseOrPop { target } => {
                 self.jump_if_or_pop(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfNotExcMatch(target) => {
+            RealInstruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 if let Some(tuple_of_exceptions) = b.downcast_ref::<PyTuple>() {
@@ -1071,26 +1070,22 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfTrueOrPop { target } => {
+            RealInstruction::JumpIfTrueOrPop { target } => {
                 self.jump_if_or_pop(vm, target.get(arg), true)
             }
-            bytecode::Instruction::Jump { target } => {
-                self.jump(target.get(arg));
-                Ok(None)
-            }
-            bytecode::Instruction::JumpForward { target } => {
+            RealInstruction::JumpForward { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            bytecode::Instruction::JumpBackward { target } => {
+            RealInstruction::JumpBackward { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            bytecode::Instruction::JumpBackwardNoInterrupt { target } => {
+            RealInstruction::JumpBackwardNoInterrupt { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            bytecode::Instruction::ListAppend { i } => {
+            RealInstruction::ListAppend { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let list: &Py<PyList> = unsafe {
@@ -1100,23 +1095,13 @@ impl ExecutingFrame<'_> {
                 list.append(item);
                 Ok(None)
             }
-            bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            bytecode::Instruction::LoadAttrMethod { .. } => {
-                unreachable!("LoadAttrMethod is converted to LoadAttr during compilation")
-            }
-            bytecode::Instruction::LoadSuperAttr { arg: idx } => {
-                self.load_super_attr(vm, idx.get(arg))
-            }
-            bytecode::Instruction::LoadSuperMethod { .. }
-            | bytecode::Instruction::LoadZeroSuperAttr { .. }
-            | bytecode::Instruction::LoadZeroSuperMethod { .. } => {
-                unreachable!("LOAD_SUPER_* pseudo instructions are converted during compilation")
-            }
-            bytecode::Instruction::LoadBuildClass => {
+            RealInstruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
+            RealInstruction::LoadSuperAttr { arg: idx } => self.load_super_attr(vm, idx.get(arg)),
+            RealInstruction::LoadBuildClass => {
                 self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::LoadFromDictOrDeref(i) => {
+            RealInstruction::LoadFromDictOrDeref(i) => {
                 let i = i.get(arg) as usize;
                 let name = if i < self.code.cellvars.len() {
                     self.code.cellvars[i]
@@ -1132,16 +1117,16 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            bytecode::Instruction::LoadClosure(i) => {
+            RealInstruction::LoadClosure(i) => {
                 let value = self.cells_frees[i.get(arg) as usize].clone();
                 self.push_value(value.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadConst { idx } => {
+            RealInstruction::LoadConst { idx } => {
                 self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadDeref(i) => {
+            RealInstruction::LoadDeref(i) => {
                 let i = i.get(arg) as usize;
                 let x = self.cells_frees[i]
                     .get()
@@ -1149,7 +1134,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadFast(idx) => {
+            RealInstruction::LoadFast(idx) => {
                 #[cold]
                 fn reference_error(
                     varname: &'static PyStrInterned,
@@ -1167,7 +1152,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadFastAndClear(idx) => {
+            RealInstruction::LoadFastAndClear(idx) => {
                 // Load value and clear the slot (for inlined comprehensions)
                 // If slot is empty, push None (not an error - variable may not exist yet)
                 let idx = idx.get(arg) as usize;
@@ -1177,13 +1162,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadGlobal(idx) => {
+            RealInstruction::LoadGlobal(idx) => {
                 let name = &self.code.names[idx.get(arg) as usize];
                 let x = self.load_global_or_builtin(name, vm)?;
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadName(idx) => {
+            RealInstruction::LoadName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let result = self.locals.mapping().subscript(name, vm);
                 match result {
@@ -1195,8 +1180,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
-            bytecode::Instruction::MapAdd { i } => {
+            RealInstruction::MakeFunction => self.execute_make_function(vm),
+            RealInstruction::MapAdd { i } => {
                 let value = self.pop_value();
                 let key = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
@@ -1207,7 +1192,7 @@ impl ExecutingFrame<'_> {
                 dict.set_item(&*key, value, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::MatchClass(nargs) => {
+            RealInstruction::MatchClass(nargs) => {
                 // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
                 // nargs is the number of positional sub-patterns.
                 let kwd_attrs = self.pop_value();
@@ -1328,7 +1313,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::MatchKeys => {
+            RealInstruction::MatchKeys => {
                 // MATCH_KEYS doesn't pop subject and keys, only reads them
                 let keys_tuple = self.top_value(); // stack[-1]
                 let subject = self.nth_value(1); // stack[-2]
@@ -1394,7 +1379,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::MatchMapping => {
+            RealInstruction::MatchMapping => {
                 // Pop and push back the subject to keep it on stack
                 let subject = self.pop_value();
 
@@ -1405,7 +1390,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(is_mapping).into());
                 Ok(None)
             }
-            bytecode::Instruction::MatchSequence => {
+            RealInstruction::MatchSequence => {
                 // Pop and push back the subject to keep it on stack
                 let subject = self.pop_value();
 
@@ -1416,11 +1401,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(is_sequence).into());
                 Ok(None)
             }
-            bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::PopBlock => {
-                unreachable!("PopBlock is converted to Nop during compilation")
-            }
-            bytecode::Instruction::PopExcept => {
+            RealInstruction::Nop => Ok(None),
+            RealInstruction::PopExcept => {
                 // Pop prev_exc from value stack and restore it
                 let prev_exc = self.pop_value();
                 if vm.is_none(&prev_exc) {
@@ -1438,24 +1420,24 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::PopJumpIfFalse { target } => {
+            RealInstruction::PopJumpIfFalse { target } => {
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::PopJumpIfTrue { target } => {
+            RealInstruction::PopJumpIfTrue { target } => {
                 self.pop_jump_if(vm, target.get(arg), true)
             }
-            bytecode::Instruction::PopTop => {
+            RealInstruction::PopTop => {
                 // Pop value from stack and ignore.
                 self.pop_value();
                 Ok(None)
             }
-            bytecode::Instruction::PushNull => {
+            RealInstruction::PushNull => {
                 // Push NULL for self_or_null slot in call protocol
                 self.push_null();
                 Ok(None)
             }
-            bytecode::Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
-            bytecode::Instruction::Resume { arg: resume_arg } => {
+            RealInstruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
+            RealInstruction::Resume { arg: resume_arg } => {
                 // Resume execution after yield, await, or at function start
                 // In CPython, this checks instrumentation and eval breaker
                 // For now, we just check for signals/interrupts
@@ -1467,15 +1449,15 @@ impl ExecutingFrame<'_> {
                 // }
                 Ok(None)
             }
-            bytecode::Instruction::ReturnConst { idx } => {
+            RealInstruction::ReturnConst { idx } => {
                 let value = self.code.constants[idx.get(arg) as usize].clone().into();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::ReturnValue => {
+            RealInstruction::ReturnValue => {
                 let value = self.pop_value();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::SetAdd { i } => {
+            RealInstruction::SetAdd { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let set: &Py<PySet> = unsafe {
@@ -1485,7 +1467,7 @@ impl ExecutingFrame<'_> {
                 set.add(item, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::SetExcInfo => {
+            RealInstruction::SetExcInfo => {
                 // Set the current exception to TOS (for except* handlers)
                 // This updates sys.exc_info() so bare 'raise' will reraise the matched exception
                 let exc = self.top_value();
@@ -1494,7 +1476,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::PushExcInfo => {
+            RealInstruction::PushExcInfo => {
                 // Stack: [exc] -> [prev_exc, exc]
                 let exc = self.pop_value();
                 let prev_exc = vm
@@ -1511,7 +1493,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(exc);
                 Ok(None)
             }
-            bytecode::Instruction::CheckExcMatch => {
+            RealInstruction::CheckExcMatch => {
                 // Stack: [exc, type] -> [exc, bool]
                 let exc_type = self.pop_value();
                 let exc = self.top_value();
@@ -1521,7 +1503,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(result).into());
                 Ok(None)
             }
-            bytecode::Instruction::Reraise { depth } => {
+            RealInstruction::Reraise { depth } => {
                 // inst(RERAISE, (values[oparg], exc -- values[oparg]))
                 //
                 // Stack layout: [values..., exc] where len(values) == oparg
@@ -1548,11 +1530,11 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            bytecode::Instruction::SetFunctionAttribute { attr } => {
+            RealInstruction::SetFunctionAttribute { attr } => {
                 self.execute_set_function_attribute(vm, attr.get(arg))
             }
-            bytecode::Instruction::SetupAnnotations => self.setup_annotations(vm),
-            bytecode::Instruction::BeforeWith => {
+            RealInstruction::SetupAnnotations => self.setup_annotations(vm),
+            RealInstruction::BeforeWith => {
                 // TOS: context_manager
                 // Result: [..., __exit__, __enter__ result]
                 let context_manager = self.pop_value();
@@ -1581,18 +1563,18 @@ impl ExecutingFrame<'_> {
                 self.push_value(enter_res);
                 Ok(None)
             }
-            bytecode::Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            bytecode::Instruction::StoreDeref(i) => {
+            RealInstruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
+            RealInstruction::StoreDeref(i) => {
                 let value = self.pop_value();
                 self.cells_frees[i.get(arg) as usize].set(Some(value));
                 Ok(None)
             }
-            bytecode::Instruction::StoreFast(idx) => {
+            RealInstruction::StoreFast(idx) => {
                 let value = self.pop_value();
                 self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
                 Ok(None)
             }
-            bytecode::Instruction::StoreFastLoadFast {
+            RealInstruction::StoreFastLoadFast {
                 store_idx,
                 load_idx,
             } => {
@@ -1607,21 +1589,21 @@ impl ExecutingFrame<'_> {
                 self.push_value(load_value);
                 Ok(None)
             }
-            bytecode::Instruction::StoreGlobal(idx) => {
+            RealInstruction::StoreGlobal(idx) => {
                 let value = self.pop_value();
                 self.globals
                     .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::StoreName(idx) => {
+            RealInstruction::StoreName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let value = self.pop_value();
                 self.locals.mapping().ass_subscript(name, Some(value), vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::StoreSubscr => self.execute_store_subscript(vm),
-            bytecode::Instruction::Subscript => self.execute_subscript(vm),
-            bytecode::Instruction::Swap { index } => {
+            RealInstruction::StoreSubscr => self.execute_store_subscript(vm),
+            RealInstruction::Subscript => self.execute_subscript(vm),
+            RealInstruction::Swap { index } => {
                 let len = self.state.stack.len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
                 let i = len - 1; // TOS index
@@ -1638,20 +1620,18 @@ impl ExecutingFrame<'_> {
                 self.state.stack.swap(i, j);
                 Ok(None)
             }
-            bytecode::Instruction::ToBool => {
+            RealInstruction::ToBool => {
                 let obj = self.pop_value();
                 let bool_val = obj.try_to_bool(vm)?;
                 self.push_value(vm.ctx.new_bool(bool_val).into());
                 Ok(None)
             }
-            bytecode::Instruction::UnpackEx { args } => {
+            RealInstruction::UnpackEx { args } => {
                 let args = args.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
             }
-            bytecode::Instruction::UnpackSequence { size } => {
-                self.unpack_sequence(size.get(arg), vm)
-            }
-            bytecode::Instruction::WithExceptStart => {
+            RealInstruction::UnpackSequence { size } => self.unpack_sequence(size.get(arg), vm),
+            RealInstruction::WithExceptStart => {
                 // Stack: [..., __exit__, lasti, prev_exc, exc]
                 // Call __exit__(type, value, tb) and push result
                 // __exit__ is at TOS-3 (below lasti, prev_exc, and exc)
@@ -1674,7 +1654,7 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::YieldValue { arg: oparg } => {
+            RealInstruction::YieldValue { arg: oparg } => {
                 let value = self.pop_value();
                 // arg=0: direct yield (wrapped for async generators)
                 // arg=1: yield from await/yield-from (NOT wrapped)
@@ -1686,7 +1666,7 @@ impl ExecutingFrame<'_> {
                 };
                 Ok(Some(ExecutionResult::Yield(value)))
             }
-            bytecode::Instruction::Send { target } => {
+            RealInstruction::Send { target } => {
                 // Stack: (receiver, value) -> (receiver, retval)
                 // On StopIteration: replace value with stop value and jump to target
                 let exit_label = target.get(arg);
@@ -1710,7 +1690,7 @@ impl ExecutingFrame<'_> {
                     }
                 }
             }
-            bytecode::Instruction::EndSend => {
+            RealInstruction::EndSend => {
                 // Stack: (receiver, value) -> (value)
                 // Pops receiver, leaves value
                 let value = self.pop_value();
@@ -1718,7 +1698,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(value);
                 Ok(None)
             }
-            bytecode::Instruction::CleanupThrow => {
+            RealInstruction::CleanupThrow => {
                 // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) OR re-raise
                 // If StopIteration: pop all 3, extract value, push (None, value)
                 // Otherwise: pop all 3, return Err(exc) for unwind_blocks to handle
@@ -1756,19 +1736,19 @@ impl ExecutingFrame<'_> {
                     .map_err(|_| vm.new_type_error("exception expected".to_owned()))?;
                 Err(exc)
             }
-            bytecode::Instruction::UnaryInvert => {
+            RealInstruction::UnaryInvert => {
                 let a = self.pop_value();
                 let value = vm._invert(&a)?;
                 self.push_value(value);
                 Ok(None)
             }
-            bytecode::Instruction::UnaryNegative => {
+            RealInstruction::UnaryNegative => {
                 let a = self.pop_value();
                 let value = vm._neg(&a)?;
                 self.push_value(value);
                 Ok(None)
             }
-            bytecode::Instruction::UnaryNot => {
+            RealInstruction::UnaryNot => {
                 let obj = self.pop_value();
                 let value = obj.try_to_bool(vm)?;
                 self.push_value(vm.ctx.new_bool(!value).into());

From 697fe41c70b3d73d6eca271cc4b7d971e5ec351e Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 12 Jan 2026 21:52:27 +0200
Subject: [PATCH 07/35] Fix opcode.rs

---
 crates/stdlib/src/opcode.rs | 136 ++++++++++++++++++++----------------
 1 file changed, 77 insertions(+), 59 deletions(-)

diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index 3b0d8564ff6..d2e0f0ad45f 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -5,10 +5,11 @@ mod opcode {
     use crate::vm::{
         AsObject, PyObjectRef, PyResult, VirtualMachine,
         builtins::{PyInt, PyIntRef},
-        bytecode::Instruction,
+        bytecode::{Instruction, InstructionMetadata, PseudoInstruction, RealInstruction},
     };
     use core::ops::Deref;
 
+    #[derive(Clone, Copy)]
     struct Opcode(Instruction);
 
     impl Deref for Opcode {
@@ -19,13 +20,26 @@ mod opcode {
         }
     }
 
+    impl TryFrom<i32> for Opcode {
+        type Error = ();
+
+        fn try_from(value: i32) -> Result<Self, Self::Error> {
+            Ok(Self(
+                u16::try_from(value)
+                    .map_err(|_| ())?
+                    .try_into()
+                    .map_err(|_| ())?,
+            ))
+        }
+    }
+
     impl Opcode {
         // https://github.com/python/cpython/blob/bcee1c322115c581da27600f2ae55e5439c027eb/Include/opcode_ids.h#L238
         const HAVE_ARGUMENT: i32 = 44;
 
         pub fn try_from_pyint(raw: PyIntRef, vm: &VirtualMachine) -> PyResult<Self> {
             let instruction = raw
-                .try_to_primitive::<u8>(vm)
+                .try_to_primitive::<u16>(vm)
                 .and_then(|v| {
                     Instruction::try_from(v).map_err(|_| {
                         vm.new_exception_empty(vm.ctx.exceptions.value_error.to_owned())
@@ -36,13 +50,14 @@ mod opcode {
             Ok(Self(instruction))
         }
 
+        const fn inner(self) -> Instruction {
+            self.0
+        }
+
         /// Check if opcode is valid (can be converted to an Instruction)
         #[must_use]
         pub fn is_valid(opcode: i32) -> bool {
-            if !(0..=255).contains(&opcode) {
-                return false;
-            }
-            Instruction::try_from(opcode as u8).is_ok()
+            Self::try_from(opcode).is_ok()
         }
 
         /// Check if instruction has an argument
@@ -54,79 +69,82 @@ mod opcode {
         /// Check if instruction uses co_consts
         #[must_use]
         pub fn has_const(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::LoadConst { .. } | Instruction::ReturnConst { .. })
-                )
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(Instruction::Real(
+                    RealInstruction::LoadConst { .. } | RealInstruction::ReturnConst { .. }
+                ))
+            )
         }
 
         /// Check if instruction uses co_names
         #[must_use]
         pub fn has_name(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::DeleteAttr { .. }
-                        | Instruction::DeleteGlobal(_)
-                        | Instruction::DeleteName(_)
-                        | Instruction::ImportFrom { .. }
-                        | Instruction::ImportName { .. }
-                        | Instruction::LoadAttr { .. }
-                        | Instruction::LoadGlobal(_)
-                        | Instruction::LoadAttrMethod { .. }
-                        | Instruction::LoadName(_)
-                        | Instruction::StoreAttr { .. }
-                        | Instruction::StoreGlobal(_)
-                        | Instruction::StoreName(_))
-                )
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(Instruction::Real(
+                    RealInstruction::DeleteAttr { .. }
+                        | RealInstruction::DeleteGlobal(_)
+                        | RealInstruction::DeleteName(_)
+                        | RealInstruction::ImportFrom { .. }
+                        | RealInstruction::ImportName { .. }
+                        | RealInstruction::LoadAttr { .. }
+                        | RealInstruction::LoadGlobal(_)
+                        | RealInstruction::LoadName(_)
+                        | RealInstruction::StoreAttr { .. }
+                        | RealInstruction::StoreGlobal(_)
+                        | RealInstruction::StoreName(_)
+                ) | Instruction::Pseudo(PseudoInstruction::LoadAttrMethod { .. }))
+            )
         }
 
         /// Check if instruction is a jump
         #[must_use]
         pub fn has_jump(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::Break { .. }
-                        | Instruction::Continue { .. }
-                        | Instruction::ForIter { .. }
-                        | Instruction::JumpIfFalseOrPop { .. }
-                        | Instruction::JumpIfNotExcMatch(_)
-                        | Instruction::JumpIfTrueOrPop { .. }
-                        | Instruction::Jump { .. }
-                        | Instruction::PopJumpIfFalse { .. }
-                        | Instruction::PopJumpIfTrue { .. }
-                        | Instruction::Send { .. })
-                )
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(Instruction::Real(
+                    RealInstruction::Break { .. }
+                        | RealInstruction::Continue { .. }
+                        | RealInstruction::ForIter { .. }
+                        | RealInstruction::JumpIfFalseOrPop { .. }
+                        | RealInstruction::JumpIfNotExcMatch(_)
+                        | RealInstruction::JumpIfTrueOrPop { .. }
+                        | RealInstruction::PopJumpIfFalse { .. }
+                        | RealInstruction::PopJumpIfTrue { .. }
+                        | RealInstruction::Send { .. }
+                ) | Instruction::Pseudo(PseudoInstruction::Jump { .. }))
+            )
         }
 
         /// Check if instruction uses co_freevars/co_cellvars
         #[must_use]
         pub fn has_free(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::DeleteDeref(_)
-                        | Instruction::LoadFromDictOrDeref(_)
-                        | Instruction::LoadClosure(_)
-                        | Instruction::LoadDeref(_)
-                        | Instruction::StoreDeref(_))
-                )
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(Instruction::Real(
+                    RealInstruction::DeleteDeref(_)
+                        | RealInstruction::LoadFromDictOrDeref(_)
+                        | RealInstruction::LoadClosure(_)
+                        | RealInstruction::LoadDeref(_)
+                        | RealInstruction::StoreDeref(_)
+                ))
+            )
         }
 
         /// Check if instruction uses co_varnames (local variables)
         #[must_use]
         pub fn has_local(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::DeleteFast(_)
-                        | Instruction::LoadFast(_)
-                        | Instruction::LoadFastAndClear(_)
-                        | Instruction::StoreFast(_)
-                        | Instruction::StoreFastLoadFast { .. })
-                )
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(Instruction::Real(
+                    RealInstruction::DeleteFast(_)
+                        | RealInstruction::LoadFast(_)
+                        | RealInstruction::LoadFastAndClear(_)
+                        | RealInstruction::StoreFast(_)
+                        | RealInstruction::StoreFastLoadFast { .. }
+                ))
+            )
         }
 
         /// Check if instruction has exception info

From 33b455429f75853ddea9245bddaf518636ebde99 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:29:25 +0200
Subject: [PATCH 08/35] Fix `TryFrom<u8>` for RealInstruction

---
 crates/compiler-core/src/bytecode/instruction.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 07ed2d9dac5..ba8da3848b0 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -300,6 +300,9 @@ impl TryFrom<u8> for RealInstruction {
         // Resume has a non-contiguous opcode (149)
         let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
 
+        // 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 {
@@ -335,6 +338,7 @@ impl TryFrom<u8> for RealInstruction {
 
         if (cpython_start..=cpython_end).contains(&value)
             || value == resume_id
+            || value == load_closure
             || custom_ops.contains(&value)
         {
             Ok(unsafe { core::mem::transmute::<u8, Self>(value) })

From 614018686f1a6708a71915bcf192e6d95fcf61c2 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:34:16 +0200
Subject: [PATCH 09/35] Fix script

---
 Lib/_opcode_metadata.py             | 18 ++++++++++++------
 Lib/test/test__opcode.py            |  1 -
 scripts/generate_opcode_metadata.py | 11 +++++++----
 3 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 560523bfab2..3e98489419f 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -138,14 +138,20 @@
     'JUMP_IF_NOT_EXC_MATCH': 131,
     'SET_EXC_INFO': 134,
     'SUBSCRIPT': 135,
-    'LOAD_SUPER_METHOD': 136,
-    'LOAD_ZERO_SUPER_ATTR': 137,
-    'LOAD_ZERO_SUPER_METHOD': 138,
     'RESUME': 149,
-    'JUMP': 252,
     'LOAD_CLOSURE': 253,
-    'LOAD_ATTR_METHOD': 254,
-    'POP_BLOCK': 255,
+    'JUMP': 256,
+    'JUMP_NO_INTERRUPT': 257,
+    'RESERVED_258': 258,
+    'LOAD_ATTR_METHOD': 259,
+    'LOAD_SUPER_METHOD': 260,
+    'LOAD_ZERO_SUPER_ATTR': 261,
+    'LOAD_ZERO_SUPER_METHOD': 262,
+    'POP_BLOCK': 263,
+    'SETUP_CLEANUP': 264,
+    'SETUP_FINALLY': 265,
+    'SETUP_WITH': 266,
+    'STORE_FAST_MAYBE_NULL': 267,
 }
 
 # CPython 3.13 compatible: opcodes < 44 have no argument
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index dabe95f7167..60dcdc6cd70 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -16,7 +16,6 @@ def check_bool_function_result(self, func, ops, expected):
                 self.assertIsInstance(func(op), bool)
                 self.assertEqual(func(op), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Only supporting u8 ATM
     def test_invalid_opcodes(self):
         invalid = [-100, -1, 255, 512, 513, 1000]
         self.check_bool_function_result(_opcode.is_valid, invalid, False)
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index b7d6228ab75..cd3ebe2360e 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -37,10 +37,10 @@ def __lt__(self, other: typing.Self) -> bool:
         return self.id < other.id
 
 
-def extract_enum_body(contents: str) -> str:
-    res = re.search(r"pub enum Instruction \{(.+?)\n\}", contents, re.DOTALL)
+def extract_enum_body(contents: str, enum_name: str) -> str:
+    res = re.search(f"pub enum {enum_name} " + r"\{(.+?)\n\}", contents, re.DOTALL)
     if not res:
-        raise ValueError("Could not find Instruction enum")
+        raise ValueError(f"Could not find {enum_name} enum")
 
     return "\n".join(
         line.split("//")[0].strip()  # Remove any comment. i.e. "foo // some comment"
@@ -50,7 +50,10 @@ def extract_enum_body(contents: str) -> str:
 
 
 contents = BYTECODE_FILE.read_text()
-enum_body = extract_enum_body(contents)
+enum_body = "\n".join(
+    extract_enum_body(contents, enum_name)
+    for enum_name in ("RealInstruction", "PseudoInstruction")
+)
 opcodes = list(Opcode.from_str(enum_body))
 
 # Generate the output file

From 7acdc1aaf479df1dc1c7464e5b7027c0bc704ed9 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:36:44 +0200
Subject: [PATCH 10/35] Fix jit

---
 crates/jit/src/instructions.rs | 72 +++++++++++++++++-----------------
 crates/jit/tests/common.rs     | 24 ++++++------
 2 files changed, 47 insertions(+), 49 deletions(-)

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 1901d3e8a49..3bf8a07e662 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -4,8 +4,8 @@ use cranelift::codegen::ir::FuncRef;
 use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_compiler_core::bytecode::{
-    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction,
-    IntrinsicFunction1, Label, OpArg, OpArgState,
+    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, IntrinsicFunction1,
+    Label, OpArg, OpArgState, ReallInstruction,
 };
 use std::collections::HashMap;
 
@@ -210,12 +210,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
             // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
-                Instruction::ReturnValue
-                | Instruction::ReturnConst { .. }
-                | Instruction::Jump { .. }
-                | Instruction::JumpBackward { .. }
-                | Instruction::JumpBackwardNoInterrupt { .. }
-                | Instruction::JumpForward { .. } => {
+                ReallInstruction::ReturnValue
+                | ReallInstruction::ReturnConst { .. }
+                | ReallInstruction::JumpBackward { .. }
+                | ReallInstruction::JumpBackwardNoInterrupt { .. }
+                | ReallInstruction::JumpForward { .. } => {
                     in_unreachable_code = true;
                 }
                 _ => {}
@@ -290,11 +289,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         &mut self,
         func_ref: FuncRef,
         bytecode: &CodeObject<C>,
-        instruction: Instruction,
+        instruction: ReallInstruction,
         arg: OpArg,
     ) -> Result<(), JitCompileError> {
         match instruction {
-            Instruction::BinaryOp { op } => {
+            ReallInstruction::BinaryOp { op } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -455,12 +454,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::BuildTuple { size } => {
+            ReallInstruction::BuildTuple { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize);
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::Call { nargs } => {
+            ReallInstruction::Call { nargs } => {
                 let nargs = nargs.get(arg);
 
                 let mut args = Vec::new();
@@ -486,11 +485,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
-            Instruction::PushNull => {
+            ReallInstruction::PushNull => {
                 self.stack.push(JitValue::Null);
                 Ok(())
             }
-            Instruction::CallIntrinsic1 { func } => {
+            ReallInstruction::CallIntrinsic1 { func } => {
                 match func.get(arg) {
                     IntrinsicFunction1::UnaryPositive => {
                         match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
@@ -505,7 +504,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::CompareOp { op, .. } => {
+            ReallInstruction::CompareOp { op, .. } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -559,23 +558,22 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::ExtendedArg => Ok(()),
+            ReallInstruction::ExtendedArg => Ok(()),
 
-            Instruction::Jump { target }
-            | Instruction::JumpBackward { target }
-            | Instruction::JumpBackwardNoInterrupt { target }
-            | Instruction::JumpForward { target } => {
+            ReallInstruction::JumpBackward { target }
+            | ReallInstruction::JumpBackwardNoInterrupt { target }
+            | ReallInstruction::JumpForward { target } => {
                 let target_block = self.get_or_create_block(target.get(arg));
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
             }
-            Instruction::LoadConst { idx } => {
+            ReallInstruction::LoadConst { idx } => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.stack.push(val);
                 Ok(())
             }
-            Instruction::LoadFast(idx) => {
+            ReallInstruction::LoadFast(idx) => {
                 let local = self.variables[idx.get(arg) as usize]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
@@ -585,7 +583,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 ));
                 Ok(())
             }
-            Instruction::LoadGlobal(idx) => {
+            ReallInstruction::LoadGlobal(idx) => {
                 let name = &bytecode.names[idx.get(arg) as usize];
 
                 if name.as_ref() != bytecode.obj_name.as_ref() {
@@ -595,12 +593,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     Ok(())
                 }
             }
-            Instruction::Nop => Ok(()),
-            Instruction::PopBlock => {
+            ReallInstruction::Nop => Ok(()),
+            ReallInstruction::PopBlock => {
                 // TODO: block support
                 Ok(())
             }
-            Instruction::PopJumpIfFalse { target } => {
+            ReallInstruction::PopJumpIfFalse { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -613,7 +611,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::PopJumpIfTrue { target } => {
+            ReallInstruction::PopJumpIfTrue { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -626,41 +624,41 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::PopTop => {
+            ReallInstruction::PopTop => {
                 self.stack.pop();
                 Ok(())
             }
-            Instruction::Resume { arg: _resume_arg } => {
+            ReallInstruction::Resume { arg: _resume_arg } => {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
-            Instruction::ReturnConst { idx } => {
+            ReallInstruction::ReturnConst { idx } => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.return_value(val)
             }
-            Instruction::ReturnValue => {
+            ReallInstruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            Instruction::StoreFast(idx) => {
+            ReallInstruction::StoreFast(idx) => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.store_variable(idx.get(arg), val)
             }
-            Instruction::Swap { index } => {
+            ReallInstruction::Swap { index } => {
                 let len = self.stack.len();
                 let i = len - 1;
                 let j = len - 1 - index.get(arg) as usize;
                 self.stack.swap(i, j);
                 Ok(())
             }
-            Instruction::ToBool => {
+            ReallInstruction::ToBool => {
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let value = self.boolean_val(a)?;
                 self.stack.push(JitValue::Bool(value));
                 Ok(())
             }
-            Instruction::UnaryNot => {
+            ReallInstruction::UnaryNot => {
                 let boolean = match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::Bool(val) => val,
                     _ => return Err(JitCompileError::BadBytecode),
@@ -669,7 +667,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.push(JitValue::Bool(not_boolean));
                 Ok(())
             }
-            Instruction::UnaryNegative => {
+            ReallInstruction::UnaryNegative => {
                 match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::Int(val) => {
                         // Compile minus as 0 - val.
@@ -681,7 +679,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::UnpackSequence { size } => {
+            ReallInstruction::UnpackSequence { size } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
 
                 let elements = match val {
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index eabf27471b9..09fdb447ce1 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -1,6 +1,6 @@
 use core::ops::ControlFlow;
 use rustpython_compiler_core::bytecode::{
-    CodeObject, ConstantData, Instruction, OpArg, OpArgState,
+    CodeObject, ConstantData, OpArg, OpArgState, ReallInstruction,
 };
 use rustpython_jit::{CompiledCode, JitType};
 use std::collections::HashMap;
@@ -86,30 +86,30 @@ impl StackMachine {
 
     fn process_instruction(
         &mut self,
-        instruction: Instruction,
+        instruction: ReallInstruction,
         arg: OpArg,
         constants: &[ConstantData],
         names: &[String],
     ) -> ControlFlow<()> {
         match instruction {
-            Instruction::LoadConst { idx } => {
+            ReallInstruction::LoadConst { idx } => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
-            Instruction::LoadName(idx) => self
+            ReallInstruction::LoadName(idx) => self
                 .stack
                 .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            Instruction::StoreName(idx) => {
+            ReallInstruction::StoreName(idx) => {
                 let idx = idx.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
-            Instruction::StoreAttr { .. } => {
+            ReallInstruction::StoreAttr { .. } => {
                 // Do nothing except throw away the stack values
                 self.stack.pop().unwrap();
                 self.stack.pop().unwrap();
             }
-            Instruction::BuildMap { size, .. } => {
+            ReallInstruction::BuildMap { size, .. } => {
                 let mut map = HashMap::new();
                 for _ in 0..size.get(arg) {
                     let value = self.stack.pop().unwrap();
@@ -122,7 +122,7 @@ impl StackMachine {
                 }
                 self.stack.push(StackValue::Map(map));
             }
-            Instruction::MakeFunction => {
+            ReallInstruction::MakeFunction => {
                 let code = if let Some(StackValue::Code(code)) = self.stack.pop() {
                     code
                 } else {
@@ -134,7 +134,7 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
-            Instruction::SetFunctionAttribute { attr } => {
+            ReallInstruction::SetFunctionAttribute { attr } => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
                     func
@@ -164,13 +164,13 @@ impl StackMachine {
                     self.stack.push(StackValue::Function(func));
                 }
             }
-            Instruction::ReturnConst { idx } => {
+            ReallInstruction::ReturnConst { idx } => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into());
                 return ControlFlow::Break(());
             }
-            Instruction::ReturnValue => return ControlFlow::Break(()),
-            Instruction::ExtendedArg => {}
+            ReallInstruction::ReturnValue => return ControlFlow::Break(()),
+            ReallInstruction::ExtendedArg => {}
             _ => unimplemented!(
                 "instruction {:?} isn't yet supported in py_function!",
                 instruction

From 0fad43f9109051a6d1df4f57a25c3bc528163ceb Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:38:46 +0200
Subject: [PATCH 11/35] Fix typo

---
 crates/jit/src/instructions.rs | 68 +++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 34 deletions(-)

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 3bf8a07e662..3fb84a3b2d5 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -5,7 +5,7 @@ use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_compiler_core::bytecode::{
     self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, IntrinsicFunction1,
-    Label, OpArg, OpArgState, ReallInstruction,
+    Label, OpArg, OpArgState, RealInstruction,
 };
 use std::collections::HashMap;
 
@@ -210,11 +210,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
             // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
-                ReallInstruction::ReturnValue
-                | ReallInstruction::ReturnConst { .. }
-                | ReallInstruction::JumpBackward { .. }
-                | ReallInstruction::JumpBackwardNoInterrupt { .. }
-                | ReallInstruction::JumpForward { .. } => {
+                RealInstruction::ReturnValue
+                | RealInstruction::ReturnConst { .. }
+                | RealInstruction::JumpBackward { .. }
+                | RealInstruction::JumpBackwardNoInterrupt { .. }
+                | RealInstruction::JumpForward { .. } => {
                     in_unreachable_code = true;
                 }
                 _ => {}
@@ -289,11 +289,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         &mut self,
         func_ref: FuncRef,
         bytecode: &CodeObject<C>,
-        instruction: ReallInstruction,
+        instruction: RealInstruction,
         arg: OpArg,
     ) -> Result<(), JitCompileError> {
         match instruction {
-            ReallInstruction::BinaryOp { op } => {
+            RealInstruction::BinaryOp { op } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -454,12 +454,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            ReallInstruction::BuildTuple { size } => {
+            RealInstruction::BuildTuple { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize);
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            ReallInstruction::Call { nargs } => {
+            RealInstruction::Call { nargs } => {
                 let nargs = nargs.get(arg);
 
                 let mut args = Vec::new();
@@ -485,11 +485,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
-            ReallInstruction::PushNull => {
+            RealInstruction::PushNull => {
                 self.stack.push(JitValue::Null);
                 Ok(())
             }
-            ReallInstruction::CallIntrinsic1 { func } => {
+            RealInstruction::CallIntrinsic1 { func } => {
                 match func.get(arg) {
                     IntrinsicFunction1::UnaryPositive => {
                         match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
@@ -504,7 +504,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            ReallInstruction::CompareOp { op, .. } => {
+            RealInstruction::CompareOp { op, .. } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -558,22 +558,22 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            ReallInstruction::ExtendedArg => Ok(()),
+            RealInstruction::ExtendedArg => Ok(()),
 
-            ReallInstruction::JumpBackward { target }
-            | ReallInstruction::JumpBackwardNoInterrupt { target }
-            | ReallInstruction::JumpForward { target } => {
+            RealInstruction::JumpBackward { target }
+            | RealInstruction::JumpBackwardNoInterrupt { target }
+            | RealInstruction::JumpForward { target } => {
                 let target_block = self.get_or_create_block(target.get(arg));
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
             }
-            ReallInstruction::LoadConst { idx } => {
+            RealInstruction::LoadConst { idx } => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.stack.push(val);
                 Ok(())
             }
-            ReallInstruction::LoadFast(idx) => {
+            RealInstruction::LoadFast(idx) => {
                 let local = self.variables[idx.get(arg) as usize]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
@@ -583,7 +583,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 ));
                 Ok(())
             }
-            ReallInstruction::LoadGlobal(idx) => {
+            RealInstruction::LoadGlobal(idx) => {
                 let name = &bytecode.names[idx.get(arg) as usize];
 
                 if name.as_ref() != bytecode.obj_name.as_ref() {
@@ -593,12 +593,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     Ok(())
                 }
             }
-            ReallInstruction::Nop => Ok(()),
-            ReallInstruction::PopBlock => {
+            RealInstruction::Nop => Ok(()),
+            RealInstruction::PopBlock => {
                 // TODO: block support
                 Ok(())
             }
-            ReallInstruction::PopJumpIfFalse { target } => {
+            RealInstruction::PopJumpIfFalse { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -611,7 +611,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            ReallInstruction::PopJumpIfTrue { target } => {
+            RealInstruction::PopJumpIfTrue { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -624,41 +624,41 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            ReallInstruction::PopTop => {
+            RealInstruction::PopTop => {
                 self.stack.pop();
                 Ok(())
             }
-            ReallInstruction::Resume { arg: _resume_arg } => {
+            RealInstruction::Resume { arg: _resume_arg } => {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
-            ReallInstruction::ReturnConst { idx } => {
+            RealInstruction::ReturnConst { idx } => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.return_value(val)
             }
-            ReallInstruction::ReturnValue => {
+            RealInstruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            ReallInstruction::StoreFast(idx) => {
+            RealInstruction::StoreFast(idx) => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.store_variable(idx.get(arg), val)
             }
-            ReallInstruction::Swap { index } => {
+            RealInstruction::Swap { index } => {
                 let len = self.stack.len();
                 let i = len - 1;
                 let j = len - 1 - index.get(arg) as usize;
                 self.stack.swap(i, j);
                 Ok(())
             }
-            ReallInstruction::ToBool => {
+            RealInstruction::ToBool => {
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let value = self.boolean_val(a)?;
                 self.stack.push(JitValue::Bool(value));
                 Ok(())
             }
-            ReallInstruction::UnaryNot => {
+            RealInstruction::UnaryNot => {
                 let boolean = match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::Bool(val) => val,
                     _ => return Err(JitCompileError::BadBytecode),
@@ -667,7 +667,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.push(JitValue::Bool(not_boolean));
                 Ok(())
             }
-            ReallInstruction::UnaryNegative => {
+            RealInstruction::UnaryNegative => {
                 match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::Int(val) => {
                         // Compile minus as 0 - val.
@@ -679,7 +679,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            ReallInstruction::UnpackSequence { size } => {
+            RealInstruction::UnpackSequence { size } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
 
                 let elements = match val {

From 24f5161535eaaf6133944477261d5e31474128c2 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:39:15 +0200
Subject: [PATCH 12/35] Fix typo

---
 crates/jit/tests/common.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 09fdb447ce1..51648b4929a 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -1,6 +1,6 @@
 use core::ops::ControlFlow;
 use rustpython_compiler_core::bytecode::{
-    CodeObject, ConstantData, OpArg, OpArgState, ReallInstruction,
+    CodeObject, ConstantData, OpArg, OpArgState, RealInstruction,
 };
 use rustpython_jit::{CompiledCode, JitType};
 use std::collections::HashMap;
@@ -86,30 +86,30 @@ impl StackMachine {
 
     fn process_instruction(
         &mut self,
-        instruction: ReallInstruction,
+        instruction: RealInstruction,
         arg: OpArg,
         constants: &[ConstantData],
         names: &[String],
     ) -> ControlFlow<()> {
         match instruction {
-            ReallInstruction::LoadConst { idx } => {
+            RealInstruction::LoadConst { idx } => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
-            ReallInstruction::LoadName(idx) => self
+            RealInstruction::LoadName(idx) => self
                 .stack
                 .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            ReallInstruction::StoreName(idx) => {
+            RealInstruction::StoreName(idx) => {
                 let idx = idx.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
-            ReallInstruction::StoreAttr { .. } => {
+            RealInstruction::StoreAttr { .. } => {
                 // Do nothing except throw away the stack values
                 self.stack.pop().unwrap();
                 self.stack.pop().unwrap();
             }
-            ReallInstruction::BuildMap { size, .. } => {
+            RealInstruction::BuildMap { size, .. } => {
                 let mut map = HashMap::new();
                 for _ in 0..size.get(arg) {
                     let value = self.stack.pop().unwrap();
@@ -122,7 +122,7 @@ impl StackMachine {
                 }
                 self.stack.push(StackValue::Map(map));
             }
-            ReallInstruction::MakeFunction => {
+            RealInstruction::MakeFunction => {
                 let code = if let Some(StackValue::Code(code)) = self.stack.pop() {
                     code
                 } else {
@@ -134,7 +134,7 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
-            ReallInstruction::SetFunctionAttribute { attr } => {
+            RealInstruction::SetFunctionAttribute { attr } => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
                     func
@@ -164,13 +164,13 @@ impl StackMachine {
                     self.stack.push(StackValue::Function(func));
                 }
             }
-            ReallInstruction::ReturnConst { idx } => {
+            RealInstruction::ReturnConst { idx } => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into());
                 return ControlFlow::Break(());
             }
-            ReallInstruction::ReturnValue => return ControlFlow::Break(()),
-            ReallInstruction::ExtendedArg => {}
+            RealInstruction::ReturnValue => return ControlFlow::Break(()),
+            RealInstruction::ExtendedArg => {}
             _ => unimplemented!(
                 "instruction {:?} isn't yet supported in py_function!",
                 instruction

From 6e914107d22ff69a464ad47bb038424fc59ee309 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:41:03 +0200
Subject: [PATCH 13/35] Remove popblock

---
 crates/jit/src/instructions.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 3fb84a3b2d5..e3d0b244914 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -594,10 +594,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 }
             }
             RealInstruction::Nop => Ok(()),
-            RealInstruction::PopBlock => {
-                // TODO: block support
-                Ok(())
-            }
             RealInstruction::PopJumpIfFalse { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;

From 87519534096b58eeaa3f1d128672f41752583538 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:51:28 +0200
Subject: [PATCH 14/35] Fix docs

---
 crates/compiler-core/src/bytecode/instruction.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index ba8da3848b0..bd33d68c5a6 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -975,7 +975,7 @@ pub trait InstructionMetadata {
     ///
     /// ```
     /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction};
-    /// let jump_inst = RealInstruction::Jump { target: Arg::marker() };
+    /// let jump_inst = RealInstruction::JumpForward { target: Arg::marker() };
     /// assert!(jump_inst.unconditional_branch())
     /// ```
     fn unconditional_branch(&self) -> bool;
@@ -987,7 +987,7 @@ pub trait InstructionMetadata {
     /// ```
     /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label};
     /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = RealInstruction::Jump { target };
+    /// let jump_instruction = RealInstruction::JumpForward { target };
     /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
     /// ```
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;

From 8b73441dbf83db51443e9d3f33bff1a9e130324b Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 13:58:08 +0200
Subject: [PATCH 15/35] Fix more docs

---
 crates/compiler-core/src/bytecode/instruction.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index bd33d68c5a6..b809db31a05 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -974,7 +974,7 @@ pub trait InstructionMetadata {
     /// # Examples
     ///
     /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction};
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, InstructionMetadata};
     /// let jump_inst = RealInstruction::JumpForward { target: Arg::marker() };
     /// assert!(jump_inst.unconditional_branch())
     /// ```
@@ -985,7 +985,7 @@ pub trait InstructionMetadata {
     /// # Examples
     ///
     /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label};
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label, InstructionMetadata};
     /// let (target, jump_arg) = Arg::new(Label(0xF));
     /// let jump_instruction = RealInstruction::JumpForward { target };
     /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);

From d6e46f875c0376f98e52570f9baafb8c2e76eac3 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 14:22:51 +0200
Subject: [PATCH 16/35] ok word `argty`

---
 .cspell.dict/rust-more.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.cspell.dict/rust-more.txt b/.cspell.dict/rust-more.txt
index ff2013e81a7..dad762a8f23 100644
--- a/.cspell.dict/rust-more.txt
+++ b/.cspell.dict/rust-more.txt
@@ -1,4 +1,5 @@
 ahash
+argty
 arrayvec
 bidi
 biguint

From 0872cb6bc0e262e888eadf8ff99c9e390f43a087 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 15:16:46 +0200
Subject: [PATCH 17/35] Revert "ok word `argty`"

This reverts commit d6e46f875c0376f98e52570f9baafb8c2e76eac3.
---
 .cspell.dict/rust-more.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.cspell.dict/rust-more.txt b/.cspell.dict/rust-more.txt
index dad762a8f23..ff2013e81a7 100644
--- a/.cspell.dict/rust-more.txt
+++ b/.cspell.dict/rust-more.txt
@@ -1,5 +1,4 @@
 ahash
-argty
 arrayvec
 bidi
 biguint

From 0c7880d0099a63823ec2ef7d92c806bf5fcac06f Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 15:17:33 +0200
Subject: [PATCH 18/35] Rename argty -> arg_ty

---
 crates/compiler-core/src/bytecode/instruction.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index b809db31a05..b76fccaa4b0 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -923,8 +923,8 @@ impl TryFrom<u16> for Instruction {
 }
 
 macro_rules! inst_either {
-    (fn $name:ident ( &self $(, $arg:ident : $argty:ty )* ) -> $ret:ty ) => {
-        fn $name(&self $(, $arg : $argty )* ) -> $ret {
+    (fn $name:ident ( &self $(, $arg:ident : $arg_ty:ty )* ) -> $ret:ty ) => {
+        fn $name(&self $(, $arg : $arg_ty )* ) -> $ret {
             match self {
                 Self::Real(op) => op.$name($($arg),*),
                 Self::Pseudo(op) => op.$name($($arg),*),

From 761fa4a51a1b30976dc41cf7eea2e7aa69cecb76 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 15:19:45 +0200
Subject: [PATCH 19/35] Simplify `emit` macro

---
 crates/codegen/src/compile.rs | 38 ++++++++++++++---------------------
 1 file changed, 15 insertions(+), 23 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index a421b38a0f4..e99844d8fca 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -274,33 +274,25 @@ pub fn compile_expression(
     Ok(code)
 }
 
-// TODO: Unify Real and Pseudo arms
 macro_rules! emit {
-    // Real
-    ($c:expr, RealInstruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| RealInstruction::$op { $arg: x })
+    // Struct variant with single identifier (e.g., Foo::A { arg })
+    ($c:expr, $enum:ident :: $op:ident { $arg:ident $(,)? } $(,)?) => {
+        $c.emit_arg($arg, |x| $enum::$op { $arg: x })
     };
-    ($c:expr, RealInstruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| RealInstruction::$op { $arg: x })
-    };
-    ($c:expr, RealInstruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
-        $c.emit_arg($arg_val, RealInstruction::$op)
-    };
-    ($c:expr, RealInstruction::$op:ident$(,)?) => {
-        $c.emit_no_arg(RealInstruction::$op)
-    };
-    // Pseudo
-    ($c:expr, PseudoInstruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| PseudoInstruction::$op { $arg: x })
-    };
-    ($c:expr, PseudoInstruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| PseudoInstruction::$op { $arg: x })
+
+    // Struct variant with explicit value (e.g., Foo::A { arg: 42 })
+    ($c:expr, $enum:ident :: $op:ident { $arg:ident : $arg_val:expr $(,)? } $(,)?) => {
+        $c.emit_arg($arg_val, |x| $enum::$op { $arg: x })
     };
-    ($c:expr, PseudoInstruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
-        $c.emit_arg($arg_val, PseudoInstruction::$op)
+
+    // Tuple variant (e.g., Foo::B(42))
+    ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
+        $c.emit_arg($arg_val, $enum::$op)
     };
-    ($c:expr, PseudoInstruction::$op:ident$(,)?) => {
-        $c.emit_no_arg(PseudoInstruction::$op)
+
+    // No-arg variant (e.g., Foo::C)
+    ($c:expr, $enum:ident :: $op:ident $(,)?) => {
+        $c.emit_no_arg($enum::$op)
     };
 }
 

From 4eed13725474e00d02ae57f1cb169db7756bee05 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 16:40:23 +0200
Subject: [PATCH 20/35] Trigger CI


From 8f777d2f3877bf651d5868c2815cd295073e935b Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 17:12:39 +0200
Subject: [PATCH 21/35] Trigger CI


From bff25eb202d3ef17d44ce9ec672acb316638c65f Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 13 Jan 2026 19:33:20 +0200
Subject: [PATCH 22/35] Trigger CI


From 118ecf3904b922d439ec0a56d8b658cfeeab4bfd Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 10:06:42 +0200
Subject: [PATCH 23/35] Move docs

---
 .../compiler-core/src/bytecode/instruction.rs | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index a3db781270f..b6b4847737c 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -369,6 +369,15 @@ impl InstructionMetadata for RealInstruction {
         }
     }
 
+    /// Whether this is an unconditional branching.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, InstructionMetadata};
+    /// let jump_inst = RealInstruction::JumpForward { target: Arg::marker() };
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
     fn unconditional_branch(&self) -> bool {
         matches!(
             self,
@@ -384,6 +393,16 @@ impl InstructionMetadata for RealInstruction {
         )
     }
 
+    /// What effect this instruction has on the stack.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label, InstructionMetadata};
+    /// let (target, jump_arg) = Arg::new(Label(0xF));
+    /// let jump_instruction = RealInstruction::JumpForward { target };
+    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
+    /// ```
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
             Self::Nop => 0,
@@ -970,27 +989,8 @@ pub trait InstructionMetadata {
     /// Gets the label stored inside this instruction, if it exists.
     fn label_arg(&self) -> Option<Arg<Label>>;
 
-    /// Whether this is an unconditional branching.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, InstructionMetadata};
-    /// let jump_inst = RealInstruction::JumpForward { target: Arg::marker() };
-    /// assert!(jump_inst.unconditional_branch())
-    /// ```
     fn unconditional_branch(&self) -> bool;
 
-    /// What effect this instruction has on the stack
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label, InstructionMetadata};
-    /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = RealInstruction::JumpForward { target };
-    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// ```
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;
 
     #[allow(clippy::too_many_arguments)]

From c517585859777d74e5baa5342c1826cc42ebffbf Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 10:13:03 +0200
Subject: [PATCH 24/35] Fix oparg docs

---
 crates/compiler-core/src/bytecode/oparg.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index 35ba656d8b9..8277811859d 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -142,7 +142,7 @@ impl fmt::Display for ConvertValueOparg {
             Self::Str => "1 (str)",
             Self::Repr => "2 (repr)",
             Self::Ascii => "3 (ascii)",
-            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
+            // We should never reach this. `FVC_NONE` are being handled by `RealInstruction::FormatSimple`
             Self::None => "",
         };
 
@@ -364,9 +364,9 @@ op_arg_enum!(
     /// # Examples
     ///
     /// ```rust
-    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
+    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, RealInstruction};
     /// let (op, _) = Arg::new(BinaryOperator::Add);
-    /// let instruction = Instruction::BinaryOp { op };
+    /// let instruction = RealInstruction::BinaryOp { op };
     /// ```
     ///
     /// See also:

From 78958aae6d6155e16c3a55a027e58259328e9c07 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 10:29:04 +0200
Subject: [PATCH 25/35] Revert "Move docs"

This reverts commit 118ecf3904b922d439ec0a56d8b658cfeeab4bfd.
---
 .../compiler-core/src/bytecode/instruction.rs | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index b6b4847737c..a3db781270f 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -369,15 +369,6 @@ impl InstructionMetadata for RealInstruction {
         }
     }
 
-    /// Whether this is an unconditional branching.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, InstructionMetadata};
-    /// let jump_inst = RealInstruction::JumpForward { target: Arg::marker() };
-    /// assert!(jump_inst.unconditional_branch())
-    /// ```
     fn unconditional_branch(&self) -> bool {
         matches!(
             self,
@@ -393,16 +384,6 @@ impl InstructionMetadata for RealInstruction {
         )
     }
 
-    /// What effect this instruction has on the stack.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label, InstructionMetadata};
-    /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = RealInstruction::JumpForward { target };
-    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// ```
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
             Self::Nop => 0,
@@ -989,8 +970,27 @@ pub trait InstructionMetadata {
     /// Gets the label stored inside this instruction, if it exists.
     fn label_arg(&self) -> Option<Arg<Label>>;
 
+    /// Whether this is an unconditional branching.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, InstructionMetadata};
+    /// let jump_inst = RealInstruction::JumpForward { target: Arg::marker() };
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
     fn unconditional_branch(&self) -> bool;
 
+    /// What effect this instruction has on the stack
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label, InstructionMetadata};
+    /// let (target, jump_arg) = Arg::new(Label(0xF));
+    /// let jump_instruction = RealInstruction::JumpForward { target };
+    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
+    /// ```
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;
 
     #[allow(clippy::too_many_arguments)]

From 8ae98b2c3e7c9ded336601e80e714b70fba3a8af Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 10:40:47 +0200
Subject: [PATCH 26/35] Remove `Eq` & `ParitalEq` for RealInstruction

---
 crates/compiler-core/src/bytecode/instruction.rs | 11 ++++++-----
 crates/compiler-core/src/bytecode/oparg.rs       |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index a3db781270f..890b0b2460c 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -15,7 +15,7 @@ use crate::{
 /// A Single bytecode instruction.
 /// Instructions are ordered to match CPython 3.13 opcode numbers exactly.
 /// HAVE_ARGUMENT = 44: opcodes 0-43 have no argument, 44+ have arguments.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug)]
 #[repr(u8)]
 pub enum RealInstruction {
     // ==================== No-argument instructions (opcode < 44) ====================
@@ -784,7 +784,7 @@ impl InstructionMetadata for RealInstruction {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug)]
 #[repr(u16)]
 pub enum PseudoInstruction {
     Jump {
@@ -816,6 +816,8 @@ pub enum PseudoInstruction {
     StoreFastMaybeNull = 267, // Placeholder
 }
 
+const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
+
 impl From<PseudoInstruction> for u16 {
     #[inline]
     fn from(ins: PseudoInstruction) -> Self {
@@ -884,9 +886,8 @@ impl InstructionMetadata for PseudoInstruction {
     }
 }
 
-const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug)]
+#[repr(u16)]
 pub enum Instruction {
     Real(RealInstruction),
     Pseudo(PseudoInstruction),
diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index 8277811859d..2d15704028d 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -80,7 +80,7 @@ impl OpArgState {
     #[inline(always)]
     pub fn get(&mut self, ins: CodeUnit) -> (RealInstruction, OpArg) {
         let arg = self.extend(ins.arg);
-        if ins.op != RealInstruction::ExtendedArg {
+        if !matches!(ins.op, RealInstruction::ExtendedArg) {
             self.reset();
         }
         (ins.op, arg)

From 1453726d4ff12281633588bf4e3397b46349abc8 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 11:39:40 +0200
Subject: [PATCH 27/35] Simplify `match` arms

---
 crates/codegen/src/ir.rs                      | 62 +++++++++++++------
 .../compiler-core/src/bytecode/instruction.rs | 28 ++++++++-
 2 files changed, 70 insertions(+), 20 deletions(-)

diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index baeb77cfdc8..9ca7a5fc184 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -197,48 +197,74 @@ impl CodeInfo {
             .filter(|b| b.next != BlockIdx::NULL || !b.instructions.is_empty())
         {
             for info in &mut block.instructions {
-                match info.instr {
+                // Special case for:
+                // - `RealInstruction::LoadAttr`
+                // - `RealInstruction::LoadSuperAttr`
+
+                if let Some(instr) = info.instr.real() {
+                    match instr {
+                        // LOAD_ATTR → encode with method flag=0
+                        RealInstruction::LoadAttr { idx } => {
+                            let encoded = encode_load_attr_arg(idx.get(info.arg), false);
+                            info.arg = OpArg(encoded);
+                            info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
+                        }
+                        // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
+                        RealInstruction::LoadSuperAttr { arg: idx } => {
+                            let encoded =
+                                encode_load_super_attr_arg(idx.get(info.arg), false, true);
+                            info.arg = OpArg(encoded);
+                            info.instr =
+                                RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                        }
+                        _ => {}
+                    }
+
+                    continue;
+                }
+
+                let instr = info.instr.expect_pseudo();
+
+                match instr {
                     // LOAD_ATTR_METHOD pseudo → LOAD_ATTR (with method flag=1)
-                    Instruction::Pseudo(PseudoInstruction::LoadAttrMethod { idx }) => {
+                    PseudoInstruction::LoadAttrMethod { idx } => {
                         let encoded = encode_load_attr_arg(idx.get(info.arg), true);
                         info.arg = OpArg(encoded);
                         info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
                     }
-                    // LOAD_ATTR → encode with method flag=0
-                    Instruction::Real(RealInstruction::LoadAttr { idx }) => {
-                        let encoded = encode_load_attr_arg(idx.get(info.arg), false);
-                        info.arg = OpArg(encoded);
-                        info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
-                    }
                     // POP_BLOCK pseudo → NOP
-                    Instruction::Pseudo(PseudoInstruction::PopBlock) => {
+                    PseudoInstruction::PopBlock => {
                         info.instr = RealInstruction::Nop.into();
                     }
                     // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
-                    Instruction::Pseudo(PseudoInstruction::LoadSuperMethod { idx }) => {
+                    PseudoInstruction::LoadSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
                         info.arg = OpArg(encoded);
                         info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_ATTR pseudo → LOAD_SUPER_ATTR (flags=0b00: method=0, class=0)
-                    Instruction::Pseudo(PseudoInstruction::LoadZeroSuperAttr { idx }) => {
+                    PseudoInstruction::LoadZeroSuperAttr { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, false);
                         info.arg = OpArg(encoded);
                         info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b01: method=1, class=0)
-                    Instruction::Pseudo(PseudoInstruction::LoadZeroSuperMethod { idx }) => {
+                    PseudoInstruction::LoadZeroSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, false);
                         info.arg = OpArg(encoded);
                         info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
-                    // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
-                    Instruction::Real(RealInstruction::LoadSuperAttr { arg: idx }) => {
-                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, true);
-                        info.arg = OpArg(encoded);
-                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                    PseudoInstruction::Jump { .. } => {
+                        // PseudoInstruction::Jump instructions are handled later
+                    }
+                    PseudoInstruction::JumpNoInterrupt { .. }
+                    | PseudoInstruction::Reserved258
+                    | PseudoInstruction::SetupCleanup
+                    | PseudoInstruction::SetupFinally
+                    | PseudoInstruction::SetupWith
+                    | PseudoInstruction::StoreFastMaybeNull => {
+                        unimplemented!("Got a placeholder pseudo instruction ({instr:?})")
                     }
-                    _ => {}
                 }
             }
         }
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 890b0b2460c..93ecdd5035d 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -954,17 +954,41 @@ impl InstructionMetadata for Instruction {
 }
 
 impl Instruction {
-    pub const fn as_real(self) -> Option<RealInstruction> {
+    /// Gets the inner value of [`Self::Real`].
+    pub const fn real(self) -> Option<RealInstruction> {
         match self {
             Self::Real(ins) => Some(ins),
             _ => None,
         }
     }
 
+    /// Gets the inner value of [`Self::Pseudo`].
+    pub const fn pseudo(self) -> Option<PseudoInstruction> {
+        match self {
+            Self::Pseudo(ins) => Some(ins),
+            _ => None,
+        }
+    }
+
+    /// Same as [`Self::real`] but panics if wasn't called on [`Self::Real`].
+    ///
+    /// # Panics
+    ///
+    /// If was called on something else other than [`Self::Real`].
     pub const fn expect_real(self) -> RealInstruction {
-        self.as_real()
+        self.real()
             .expect("Expected Instruction::Real, found Instruction::Pseudo")
     }
+
+    /// Same as [`Self::pseudo`] but panics if wasn't called on [`Self::Pseudo`].
+    ///
+    /// # Panics
+    ///
+    /// If was called on something else other than [`Self::Pseudo`].
+    pub const fn expect_pseudo(self) -> PseudoInstruction {
+        self.pseudo()
+            .expect("Expected Instruction::Pseudo, found Instruction::Real")
+    }
 }
 
 pub trait InstructionMetadata {

From f207284cbdde177684f575b7c427425c567bb053 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 12:29:11 +0200
Subject: [PATCH 28/35] Trigger CI


From a1555dc4695e508178dcf27973face9aeb3dd425 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 14:11:16 +0200
Subject: [PATCH 29/35] Trigger CI


From c443f8e8c00c24bfc671ab8eb70ff400f8ae756e Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 14:13:22 +0200
Subject: [PATCH 30/35] Remove `repr(u16)` for `Instruction`

---
 crates/compiler-core/src/bytecode/instruction.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 93ecdd5035d..409d5074213 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -887,7 +887,6 @@ impl InstructionMetadata for PseudoInstruction {
 }
 
 #[derive(Clone, Copy, Debug)]
-#[repr(u16)]
 pub enum Instruction {
     Real(RealInstruction),
     Pseudo(PseudoInstruction),

From 453212e3101148588ec70a757c6aeeb42620d642 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 15:52:03 +0200
Subject: [PATCH 31/35] Fix doc

---
 crates/compiler-core/src/bytecode/instruction.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 409d5074213..07db43dbe06 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -13,8 +13,7 @@ use crate::{
 };
 
 /// A Single bytecode instruction.
-/// Instructions are ordered to match CPython 3.13 opcode numbers exactly.
-/// HAVE_ARGUMENT = 44: opcodes 0-43 have no argument, 44+ have arguments.
+/// All instructions above 44 have an argument.
 #[derive(Clone, Copy, Debug)]
 #[repr(u8)]
 pub enum RealInstruction {

From 1f8722a9ad18bde3dc5b0b54e426b697ce5c5b35 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 17:37:28 +0200
Subject: [PATCH 32/35] Rename the enums

---
 crates/codegen/src/compile.rs                 | 848 +++++++++---------
 crates/codegen/src/ir.rs                      |  39 +-
 crates/compiler-core/src/bytecode.rs          |   6 +-
 .../compiler-core/src/bytecode/instruction.rs |  62 +-
 crates/compiler-core/src/bytecode/oparg.rs    |  14 +-
 crates/jit/src/instructions.rs                |  68 +-
 crates/jit/tests/common.rs                    |  24 +-
 crates/stdlib/src/opcode.rs                   |  88 +-
 crates/vm/src/frame.rs                        | 244 +++--
 9 files changed, 694 insertions(+), 699 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index e99844d8fca..0f52a519f22 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -39,9 +39,9 @@ use std::collections::HashSet;
 use rustpython_compiler_core::{
     Mode, OneIndexed, PositionEncoding, SourceFile, SourceLocation,
     bytecode::{
-        self, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
+        self, AnyInstruction, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
         ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, Invert, OpArg, OpArgType,
-        PseudoInstruction, RealInstruction, UnpackExArgs,
+        PseudoInstruction, UnpackExArgs,
     },
 };
 use rustpython_wtf8::Wtf8Buf;
@@ -503,12 +503,12 @@ impl Compiler {
             };
             match ctx {
                 ExprContext::Load => {
-                    emit!(self, RealInstruction::BuildSlice { argc });
-                    emit!(self, RealInstruction::Subscript);
+                    emit!(self, Instruction::BuildSlice { argc });
+                    emit!(self, Instruction::Subscript);
                 }
                 ExprContext::Store => {
-                    emit!(self, RealInstruction::BuildSlice { argc });
-                    emit!(self, RealInstruction::StoreSubscr);
+                    emit!(self, Instruction::BuildSlice { argc });
+                    emit!(self, Instruction::StoreSubscr);
                 }
                 _ => unreachable!(),
             }
@@ -518,9 +518,9 @@ impl Compiler {
 
             // Emit appropriate instruction based on context
             match ctx {
-                ExprContext::Load => emit!(self, RealInstruction::Subscript),
-                ExprContext::Store => emit!(self, RealInstruction::StoreSubscr),
-                ExprContext::Del => emit!(self, RealInstruction::DeleteSubscr),
+                ExprContext::Load => emit!(self, Instruction::Subscript),
+                ExprContext::Store => emit!(self, Instruction::StoreSubscr),
+                ExprContext::Del => emit!(self, Instruction::DeleteSubscr),
                 ExprContext::Invalid => {
                     return Err(self.error(CodegenErrorType::SyntaxError(
                         "Invalid expression context".to_owned(),
@@ -554,28 +554,28 @@ impl Compiler {
             match collection_type {
                 CollectionType::Tuple => {
                     if size > 1 || pushed > 0 {
-                        emit!(self, RealInstruction::BuildTupleFromTuples { size });
+                        emit!(self, Instruction::BuildTupleFromTuples { size });
                     }
                     // If size == 1 and pushed == 0, the single tuple is already on the stack
                 }
                 CollectionType::List => {
-                    emit!(self, RealInstruction::BuildListFromTuples { size });
+                    emit!(self, Instruction::BuildListFromTuples { size });
                 }
                 CollectionType::Set => {
-                    emit!(self, RealInstruction::BuildSetFromTuples { size });
+                    emit!(self, Instruction::BuildSetFromTuples { size });
                 }
             }
         } else {
             // No starred elements
             match collection_type {
                 CollectionType::Tuple => {
-                    emit!(self, RealInstruction::BuildTuple { size });
+                    emit!(self, Instruction::BuildTuple { size });
                 }
                 CollectionType::List => {
-                    emit!(self, RealInstruction::BuildList { size });
+                    emit!(self, Instruction::BuildList { size });
                 }
                 CollectionType::Set => {
-                    emit!(self, RealInstruction::BuildSet { size });
+                    emit!(self, Instruction::BuildSet { size });
                 }
             }
         }
@@ -808,7 +808,7 @@ impl Compiler {
                         )));
                     }
                 };
-                self.emit_arg(idx, RealInstruction::LoadDeref);
+                self.emit_arg(idx, Instruction::LoadDeref);
 
                 // Load first parameter (typically 'self').
                 // Safety: can_optimize_super_call() ensures argcount > 0, and
@@ -998,7 +998,7 @@ impl Compiler {
         self.current_source_range = TextRange::default();
         emit!(
             self,
-            RealInstruction::Resume {
+            Instruction::Resume {
                 arg: bytecode::ResumeType::AtFuncStart as u32
             }
         );
@@ -1154,9 +1154,9 @@ impl Compiler {
             FBlockType::ForLoop => {
                 // Pop the iterator
                 if preserve_tos {
-                    emit!(self, RealInstruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { index: 2 });
                 }
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             }
 
             FBlockType::TryExcept => {
@@ -1176,13 +1176,13 @@ impl Compiler {
                 // Note: No lasti here - it's only pushed for cleanup handler exceptions
                 // We need to pop: exc, prev_exc (via PopExcept)
                 if preserve_tos {
-                    emit!(self, RealInstruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { index: 2 });
                 }
-                emit!(self, RealInstruction::PopTop); // exc
+                emit!(self, Instruction::PopTop); // exc
                 if preserve_tos {
-                    emit!(self, RealInstruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { index: 2 });
                 }
-                emit!(self, RealInstruction::PopExcept); // prev_exc is restored
+                emit!(self, Instruction::PopExcept); // prev_exc is restored
             }
 
             FBlockType::With | FBlockType::AsyncWith => {
@@ -1193,36 +1193,36 @@ impl Compiler {
 
                 // If preserving return value, swap it below __exit__
                 if preserve_tos {
-                    emit!(self, RealInstruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { index: 2 });
                 }
                 // Stack after swap: [..., return_value, __exit__] or [..., __exit__]
 
                 // Call __exit__(None, None, None)
                 // Call protocol: [callable, self_or_null, arg1, arg2, arg3]
-                emit!(self, RealInstruction::PushNull);
+                emit!(self, Instruction::PushNull);
                 // Stack: [..., __exit__, NULL]
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
                 // Stack: [..., __exit__, NULL, None, None, None]
-                emit!(self, RealInstruction::Call { nargs: 3 });
+                emit!(self, Instruction::Call { nargs: 3 });
 
                 // For async with, await the result
                 if matches!(info.fb_type, FBlockType::AsyncWith) {
-                    emit!(self, RealInstruction::GetAwaitable);
+                    emit!(self, Instruction::GetAwaitable);
                     self.emit_load_const(ConstantData::None);
                     self.compile_yield_from_sequence(true)?;
                 }
 
                 // Pop the __exit__ result
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             }
 
             FBlockType::HandlerCleanup => {
                 if preserve_tos {
-                    emit!(self, RealInstruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { index: 2 });
                 }
-                emit!(self, RealInstruction::PopExcept);
+                emit!(self, Instruction::PopExcept);
 
                 // If there's an exception name, clean it up
                 if let FBlockDatum::ExceptionName(ref name) = info.fb_datum {
@@ -1234,9 +1234,9 @@ impl Compiler {
 
             FBlockType::PopValue => {
                 if preserve_tos {
-                    emit!(self, RealInstruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { index: 2 });
                 }
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             }
         }
         Ok(())
@@ -1503,11 +1503,11 @@ impl Compiler {
                 value: value.into(),
             });
             let doc = self.name("__doc__");
-            emit!(self, RealInstruction::StoreGlobal(doc))
+            emit!(self, Instruction::StoreGlobal(doc))
         }
 
         if Self::find_ann(statements) {
-            emit!(self, RealInstruction::SetupAnnotations);
+            emit!(self, Instruction::SetupAnnotations);
         }
 
         self.compile_statements(statements)?;
@@ -1527,7 +1527,7 @@ impl Compiler {
         self.symbol_table_stack.push(symbol_table);
 
         if Self::find_ann(body) {
-            emit!(self, RealInstruction::SetupAnnotations);
+            emit!(self, Instruction::SetupAnnotations);
         }
 
         if let Some((last, body)) = body.split_last() {
@@ -1536,12 +1536,12 @@ impl Compiler {
                     self.compile_expression(value)?;
                     emit!(
                         self,
-                        RealInstruction::CallIntrinsic1 {
+                        Instruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::Print
                         }
                     );
 
-                    emit!(self, RealInstruction::PopTop);
+                    emit!(self, Instruction::PopTop);
                 } else {
                     self.compile_statement(statement)?;
                 }
@@ -1549,15 +1549,15 @@ impl Compiler {
 
             if let Stmt::Expr(StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, RealInstruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 emit!(
                     self,
-                    RealInstruction::CallIntrinsic1 {
+                    Instruction::CallIntrinsic1 {
                         func: bytecode::IntrinsicFunction1::Print
                     }
                 );
 
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             } else {
                 self.compile_statement(last)?;
                 self.emit_load_const(ConstantData::None);
@@ -1582,12 +1582,12 @@ impl Compiler {
         if let Some(last_statement) = body.last() {
             match last_statement {
                 Stmt::Expr(_) => {
-                    self.current_block().instructions.pop(); // pop RealInstruction::PopTop
+                    self.current_block().instructions.pop(); // pop Instruction::PopTop
                 }
                 Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
                     let pop_instructions = self.current_block().instructions.pop();
-                    let store_inst = compiler_unwrap_option(self, pop_instructions); // pop RealInstruction::Store
-                    emit!(self, RealInstruction::Copy { index: 1_u32 });
+                    let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -1728,40 +1728,40 @@ impl Compiler {
                     NameUsage::Load => {
                         // Special case for class scope
                         if self.ctx.in_class && !self.ctx.in_func() {
-                            RealInstruction::LoadFromDictOrDeref
+                            Instruction::LoadFromDictOrDeref
                         } else {
-                            RealInstruction::LoadDeref
+                            Instruction::LoadDeref
                         }
                     }
-                    NameUsage::Store => RealInstruction::StoreDeref,
-                    NameUsage::Delete => RealInstruction::DeleteDeref,
+                    NameUsage::Store => Instruction::StoreDeref,
+                    NameUsage::Delete => Instruction::DeleteDeref,
                 };
                 self.emit_arg(idx, op);
             }
             NameOp::Fast => {
                 let idx = self.get_local_var_index(&name)?;
                 let op = match usage {
-                    NameUsage::Load => RealInstruction::LoadFast,
-                    NameUsage::Store => RealInstruction::StoreFast,
-                    NameUsage::Delete => RealInstruction::DeleteFast,
+                    NameUsage::Load => Instruction::LoadFast,
+                    NameUsage::Store => Instruction::StoreFast,
+                    NameUsage::Delete => Instruction::DeleteFast,
                 };
                 self.emit_arg(idx, op);
             }
             NameOp::Global => {
                 let idx = self.get_global_name_index(&name);
                 let op = match usage {
-                    NameUsage::Load => RealInstruction::LoadGlobal,
-                    NameUsage::Store => RealInstruction::StoreGlobal,
-                    NameUsage::Delete => RealInstruction::DeleteGlobal,
+                    NameUsage::Load => Instruction::LoadGlobal,
+                    NameUsage::Store => Instruction::StoreGlobal,
+                    NameUsage::Delete => Instruction::DeleteGlobal,
                 };
                 self.emit_arg(idx, op);
             }
             NameOp::Name => {
                 let idx = self.get_global_name_index(&name);
                 let op = match usage {
-                    NameUsage::Load => RealInstruction::LoadName,
-                    NameUsage::Store => RealInstruction::StoreName,
-                    NameUsage::Delete => RealInstruction::DeleteName,
+                    NameUsage::Load => Instruction::LoadName,
+                    NameUsage::Store => Instruction::StoreName,
+                    NameUsage::Delete => Instruction::DeleteName,
                 };
                 self.emit_arg(idx, op);
             }
@@ -1804,11 +1804,11 @@ impl Compiler {
                     });
                     self.emit_load_const(ConstantData::None);
                     let idx = self.name(&name.name);
-                    emit!(self, RealInstruction::ImportName { idx });
+                    emit!(self, Instruction::ImportName { idx });
                     if let Some(alias) = &name.asname {
                         for part in name.name.split('.').skip(1) {
                             let idx = self.name(part);
-                            emit!(self, RealInstruction::LoadAttr { idx });
+                            emit!(self, Instruction::LoadAttr { idx });
                         }
                         self.store_name(alias.as_str())?
                     } else {
@@ -1851,13 +1851,13 @@ impl Compiler {
 
                 let module_name = module.as_ref().map_or("", |s| s.as_str());
                 let module_idx = self.name(module_name);
-                emit!(self, RealInstruction::ImportName { idx: module_idx });
+                emit!(self, Instruction::ImportName { idx: module_idx });
 
                 if import_star {
                     // from .... import *
                     emit!(
                         self,
-                        RealInstruction::CallIntrinsic1 {
+                        Instruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::ImportStar
                         }
                     );
@@ -1868,7 +1868,7 @@ impl Compiler {
                         let name = &name;
                         let idx = self.name(name.name.as_str());
                         // import symbol from module:
-                        emit!(self, RealInstruction::ImportFrom { idx });
+                        emit!(self, Instruction::ImportFrom { idx });
 
                         // Store module under proper name:
                         if let Some(alias) = &name.asname {
@@ -1879,14 +1879,14 @@ impl Compiler {
                     }
 
                     // Pop module from stack:
-                    emit!(self, RealInstruction::PopTop);
+                    emit!(self, Instruction::PopTop);
                 }
             }
             Stmt::Expr(StmtExpr { value, .. }) => {
                 self.compile_expression(value)?;
 
                 // Pop result of stack, since we not use it:
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             }
             Stmt::Global(_) | Stmt::Nonlocal(_) => {
                 // Handled during symbol table construction.
@@ -1980,7 +1980,7 @@ impl Compiler {
                     None => bytecode::RaiseKind::BareRaise,
                 };
                 self.set_source_range(*range);
-                emit!(self, RealInstruction::RaiseVarargs { kind });
+                emit!(self, Instruction::RaiseVarargs { kind });
             }
             Stmt::Try(StmtTry {
                 body,
@@ -2039,20 +2039,20 @@ impl Compiler {
                     self.compile_jump_if(test, true, after_block)?;
 
                     let assertion_error = self.name("AssertionError");
-                    emit!(self, RealInstruction::LoadGlobal(assertion_error));
-                    emit!(self, RealInstruction::PushNull);
+                    emit!(self, Instruction::LoadGlobal(assertion_error));
+                    emit!(self, Instruction::PushNull);
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
-                            emit!(self, RealInstruction::Call { nargs: 1 });
+                            emit!(self, Instruction::Call { nargs: 1 });
                         }
                         None => {
-                            emit!(self, RealInstruction::Call { nargs: 0 });
+                            emit!(self, Instruction::Call { nargs: 0 });
                         }
                     }
                     emit!(
                         self,
-                        RealInstruction::RaiseVarargs {
+                        Instruction::RaiseVarargs {
                             kind: bytecode::RaiseKind::Raise,
                         }
                     );
@@ -2105,7 +2105,7 @@ impl Compiler {
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, RealInstruction::Copy { index: 1_u32 });
+                        emit!(self, Instruction::Copy { index: 1_u32 });
                     }
                     self.compile_store(target)?;
                 }
@@ -2174,10 +2174,10 @@ impl Compiler {
                 }
 
                 // Build tuple of 3 elements and call intrinsic
-                emit!(self, RealInstruction::BuildTuple { size: 3 });
+                emit!(self, Instruction::BuildTuple { size: 3 });
                 emit!(
                     self,
-                    RealInstruction::CallIntrinsic1 {
+                    Instruction::CallIntrinsic1 {
                         func: bytecode::IntrinsicFunction1::TypeAlias
                     }
                 );
@@ -2196,7 +2196,7 @@ impl Compiler {
                 self.check_forbidden_name(attr.as_str(), NameUsage::Delete)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, RealInstruction::DeleteAttr { idx });
+                emit!(self, Instruction::DeleteAttr { idx });
             }
             Expr::Subscript(ExprSubscript {
                 value, slice, ctx, ..
@@ -2263,7 +2263,7 @@ impl Compiler {
     fn prepare_decorators(&mut self, decorator_list: &[Decorator]) -> CompileResult<()> {
         for decorator in decorator_list {
             self.compile_expression(&decorator.expression)?;
-            emit!(self, RealInstruction::PushNull);
+            emit!(self, Instruction::PushNull);
         }
         Ok(())
     }
@@ -2274,7 +2274,7 @@ impl Compiler {
     /// applying decorators bottom-up (innermost first).
     fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
         for _ in decorator_list {
-            emit!(self, RealInstruction::Call { nargs: 1 });
+            emit!(self, Instruction::Call { nargs: 1 });
         }
     }
 
@@ -2299,14 +2299,14 @@ impl Compiler {
         if allow_starred && matches!(expr, Expr::Starred(_)) {
             if let Expr::Starred(starred) = expr {
                 self.compile_expression(&starred.value)?;
-                emit!(self, RealInstruction::UnpackSequence { size: 1 });
+                emit!(self, Instruction::UnpackSequence { size: 1 });
             }
         } else {
             self.compile_expression(expr)?;
         }
 
         // Return value
-        emit!(self, RealInstruction::ReturnValue);
+        emit!(self, Instruction::ReturnValue);
 
         // Exit scope and create closure
         let code = self.exit_scope();
@@ -2314,10 +2314,10 @@ impl Compiler {
 
         // Create type params function with closure
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
-        emit!(self, RealInstruction::PushNull);
+        emit!(self, Instruction::PushNull);
 
         // Call the function immediately
-        emit!(self, RealInstruction::Call { nargs: 0 });
+        emit!(self, Instruction::Call { nargs: 0 });
 
         Ok(())
     }
@@ -2351,11 +2351,11 @@ impl Compiler {
                         } else {
                             bytecode::IntrinsicFunction2::TypeVarWithBound
                         };
-                        emit!(self, RealInstruction::CallIntrinsic2 { func: intrinsic });
+                        emit!(self, Instruction::CallIntrinsic2 { func: intrinsic });
                     } else {
                         emit!(
                             self,
-                            RealInstruction::CallIntrinsic1 {
+                            Instruction::CallIntrinsic1 {
                                 func: bytecode::IntrinsicFunction1::TypeVar
                             }
                         );
@@ -2366,13 +2366,13 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
                         emit!(
                             self,
-                            RealInstruction::CallIntrinsic2 {
+                            Instruction::CallIntrinsic2 {
                                 func: bytecode::IntrinsicFunction2::SetTypeparamDefault
                             }
                         );
                     }
 
-                    emit!(self, RealInstruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
@@ -2381,7 +2381,7 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        RealInstruction::CallIntrinsic1 {
+                        Instruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::ParamSpec
                         }
                     );
@@ -2391,13 +2391,13 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
                         emit!(
                             self,
-                            RealInstruction::CallIntrinsic2 {
+                            Instruction::CallIntrinsic2 {
                                 func: bytecode::IntrinsicFunction2::SetTypeparamDefault
                             }
                         );
                     }
 
-                    emit!(self, RealInstruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
@@ -2406,7 +2406,7 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        RealInstruction::CallIntrinsic1 {
+                        Instruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::TypeVarTuple
                         }
                     );
@@ -2417,20 +2417,20 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, true)?;
                         emit!(
                             self,
-                            RealInstruction::CallIntrinsic2 {
+                            Instruction::CallIntrinsic2 {
                                 func: bytecode::IntrinsicFunction2::SetTypeparamDefault
                             }
                         );
                     }
 
-                    emit!(self, RealInstruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
             };
         }
         emit!(
             self,
-            RealInstruction::BuildTuple {
+            Instruction::BuildTuple {
                 size: u32::try_from(type_params.len()).unwrap(),
             }
         );
@@ -2532,7 +2532,7 @@ impl Compiler {
                 // PUSH_EXC_INFO first, THEN push FinallyEnd fblock
                 // Stack after unwind (no lasti): [exc] (depth = current_depth + 1)
                 // Stack after PUSH_EXC_INFO: [prev_exc, exc] (depth = current_depth + 2)
-                emit!(self, RealInstruction::PushExcInfo);
+                emit!(self, Instruction::PushExcInfo);
                 if let Some(cleanup) = finally_cleanup_block {
                     // FinallyEnd fblock must be pushed AFTER PUSH_EXC_INFO
                     // Depth = current_depth + 1 (only prev_exc remains after RERAISE pops exc)
@@ -2552,7 +2552,7 @@ impl Compiler {
                 // which then properly restores prev_exc before going to outer handler
                 emit!(
                     self,
-                    RealInstruction::RaiseVarargs {
+                    Instruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack
                     }
                 );
@@ -2563,11 +2563,11 @@ impl Compiler {
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, RealInstruction::Copy { index: 3_u32 });
-                emit!(self, RealInstruction::PopExcept);
+                emit!(self, Instruction::Copy { index: 3_u32 });
+                emit!(self, Instruction::PopExcept);
                 emit!(
                     self,
-                    RealInstruction::RaiseVarargs {
+                    Instruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack
                     }
                 );
@@ -2613,7 +2613,7 @@ impl Compiler {
 
         // Exception is on top of stack now, pushed by unwind_blocks
         // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopExcept
-        emit!(self, RealInstruction::PushExcInfo);
+        emit!(self, Instruction::PushExcInfo);
         for handler in handlers {
             let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
                 type_, name, body, ..
@@ -2624,23 +2624,23 @@ impl Compiler {
             // check if this handler can handle the exception:
             if let Some(exc_type) = type_ {
                 // Duplicate exception for test:
-                emit!(self, RealInstruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
 
                 // Check exception type:
                 self.compile_expression(exc_type)?;
-                emit!(self, RealInstruction::JumpIfNotExcMatch(next_handler));
+                emit!(self, Instruction::JumpIfNotExcMatch(next_handler));
 
                 // We have a match, store in name (except x as y)
                 if let Some(alias) = name {
                     self.store_name(alias.as_str())?
                 } else {
                     // Drop exception from top of stack:
-                    emit!(self, RealInstruction::PopTop);
+                    emit!(self, Instruction::PopTop);
                 }
             } else {
                 // Catch all!
                 // Drop exception from top of stack:
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             }
 
             // If name is bound, we need a cleanup handler for RERAISE
@@ -2697,7 +2697,7 @@ impl Compiler {
                 // which does COPY 3; POP_EXCEPT; RERAISE
                 emit!(
                     self,
-                    RealInstruction::RaiseVarargs {
+                    Instruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack,
                     }
                 );
@@ -2710,7 +2710,7 @@ impl Compiler {
             // POP_BLOCK (HandlerCleanup) then POP_BLOCK (SETUP_CLEANUP)
             // followed by POP_EXCEPT
             self.pop_fblock(FBlockType::ExceptionHandler);
-            emit!(self, RealInstruction::PopExcept);
+            emit!(self, Instruction::PopExcept);
 
             // Delete the exception variable if it was bound (normal path)
             if let Some(alias) = name {
@@ -2750,7 +2750,7 @@ impl Compiler {
         // NOTE: We emit RERAISE 0 BEFORE popping fblock so it is within cleanup handler scope
         emit!(
             self,
-            RealInstruction::RaiseVarargs {
+            Instruction::RaiseVarargs {
                 kind: bytecode::RaiseKind::ReraiseFromStack,
             }
         );
@@ -2765,11 +2765,11 @@ impl Compiler {
         // POP_EXCEPT: pop prev_exc from stack and restore -> [prev_exc, lasti, exc]
         // RERAISE 1: reraise with lasti
         self.switch_to_block(cleanup_block);
-        emit!(self, RealInstruction::Copy { index: 3_u32 });
-        emit!(self, RealInstruction::PopExcept);
+        emit!(self, Instruction::Copy { index: 3_u32 });
+        emit!(self, Instruction::PopExcept);
         emit!(
             self,
-            RealInstruction::RaiseVarargs {
+            Instruction::RaiseVarargs {
                 kind: bytecode::RaiseKind::ReraiseFromStack,
             }
         );
@@ -2832,7 +2832,7 @@ impl Compiler {
 
             // PUSH_EXC_INFO: [lasti, exc] -> [lasti, prev_exc, exc]
             // Sets exc as current VM exception, saves prev_exc for restoration
-            emit!(self, RealInstruction::PushExcInfo);
+            emit!(self, Instruction::PushExcInfo);
 
             // Run finally body
             self.compile_statements(finalbody)?;
@@ -2844,7 +2844,7 @@ impl Compiler {
             // Stack: [lasti, prev_exc, exc] - exception is on top
             emit!(
                 self,
-                RealInstruction::RaiseVarargs {
+                Instruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack,
                 }
             );
@@ -2860,13 +2860,13 @@ impl Compiler {
         if let Some(cleanup) = finally_cleanup_block {
             self.switch_to_block(cleanup);
             // COPY 3: copy the exception from position 3
-            emit!(self, RealInstruction::Copy { index: 3_u32 });
+            emit!(self, Instruction::Copy { index: 3_u32 });
             // POP_EXCEPT: restore prev_exc as current exception
-            emit!(self, RealInstruction::PopExcept);
+            emit!(self, Instruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
             emit!(
                 self,
-                RealInstruction::RaiseVarargs {
+                Instruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack,
                 }
             );
@@ -2931,7 +2931,7 @@ impl Compiler {
         // Stack: [exc] (from exception table)
 
         // PUSH_EXC_INFO
-        emit!(self, RealInstruction::PushExcInfo);
+        emit!(self, Instruction::PushExcInfo);
         // Stack: [prev_exc, exc]
 
         // Push EXCEPTION_GROUP_HANDLER fblock
@@ -2951,10 +2951,10 @@ impl Compiler {
             // first handler creates list and copies exc
             if i == 0 {
                 // ADDOP_I(c, loc, BUILD_LIST, 0);
-                emit!(self, RealInstruction::BuildList { size: 0 });
+                emit!(self, Instruction::BuildList { size: 0 });
                 // Stack: [prev_exc, exc, []]
                 // ADDOP_I(c, loc, COPY, 2);
-                emit!(self, RealInstruction::Copy { index: 2 });
+                emit!(self, Instruction::Copy { index: 2 });
                 // Stack: [prev_exc, exc, [], exc_copy]
                 // Now stack is: [prev_exc, orig, list, rest]
             }
@@ -2979,17 +2979,17 @@ impl Compiler {
             // Stack: [prev_exc, orig, list, rest, type]
 
             // ADDOP(c, loc, CHECK_EG_MATCH);
-            emit!(self, RealInstruction::CheckEgMatch);
+            emit!(self, Instruction::CheckEgMatch);
             // Stack: [prev_exc, orig, list, new_rest, match]
 
             // ADDOP_I(c, loc, COPY, 1);
             // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
-            emit!(self, RealInstruction::Copy { index: 1 });
+            emit!(self, Instruction::Copy { index: 1 });
             self.emit_load_const(ConstantData::None);
-            emit!(self, RealInstruction::IsOp(bytecode::Invert::No)); // is None?
+            emit!(self, Instruction::IsOp(bytecode::Invert::No)); // is None?
             emit!(
                 self,
-                RealInstruction::PopJumpIfTrue {
+                Instruction::PopJumpIfTrue {
                     target: no_match_block
                 }
             );
@@ -3001,13 +3001,13 @@ impl Compiler {
             // Set matched exception as current exception (for __context__ in handler body)
             // This ensures that exceptions raised in the handler get the matched part
             // as their __context__, not the original full exception group
-            emit!(self, RealInstruction::SetExcInfo);
+            emit!(self, Instruction::SetExcInfo);
 
             // Store match to name or pop
             if let Some(alias) = name {
                 self.store_name(alias.as_str())?;
             } else {
-                emit!(self, RealInstruction::PopTop); // pop match
+                emit!(self, Instruction::PopTop); // pop match
             }
             // Stack: [prev_exc, orig, list, new_rest]
 
@@ -3056,11 +3056,11 @@ impl Compiler {
             // After pop: [prev_exc, orig, list, new_rest, lasti] (len=5)
             // nth_value(i) = stack[len - i - 1], we need stack[2] = list
             // stack[5 - i - 1] = 2 -> i = 2
-            emit!(self, RealInstruction::ListAppend { i: 2 });
+            emit!(self, Instruction::ListAppend { i: 2 });
             // Stack: [prev_exc, orig, list, new_rest, lasti]
 
             // POP_TOP - pop lasti
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
             // Stack: [prev_exc, orig, list, new_rest]
 
             // JUMP except_with_error
@@ -3069,7 +3069,7 @@ impl Compiler {
 
             // No match - pop match (None)
             self.switch_to_block(no_match_block);
-            emit!(self, RealInstruction::PopTop); // pop match (None)
+            emit!(self, Instruction::PopTop); // pop match (None)
             // Stack: [prev_exc, orig, list, new_rest]
             // Falls through to next_block
 
@@ -3085,7 +3085,7 @@ impl Compiler {
                 // PEEK(1) = stack[len-1] after pop
                 // RustPython nth_value(i) = stack[len-i-1] after pop
                 // For LIST_APPEND 1: stack[len-1] = stack[len-i-1] -> i = 0
-                emit!(self, RealInstruction::ListAppend { i: 0 });
+                emit!(self, Instruction::ListAppend { i: 0 });
                 // Stack: [prev_exc, orig, list]
                 emit!(
                     self,
@@ -3107,22 +3107,22 @@ impl Compiler {
         // Takes 2 args (orig, list) and produces result
         emit!(
             self,
-            RealInstruction::CallIntrinsic2 {
+            Instruction::CallIntrinsic2 {
                 func: bytecode::IntrinsicFunction2::PrepReraiseStar
             }
         );
         // Stack: [prev_exc, result]
 
         // COPY 1
-        emit!(self, RealInstruction::Copy { index: 1 });
+        emit!(self, Instruction::Copy { index: 1 });
         // Stack: [prev_exc, result, result]
 
         // POP_JUMP_IF_NOT_NONE reraise
         self.emit_load_const(ConstantData::None);
-        emit!(self, RealInstruction::IsOp(bytecode::Invert::Yes)); // is not None?
+        emit!(self, Instruction::IsOp(bytecode::Invert::Yes)); // is not None?
         emit!(
             self,
-            RealInstruction::PopJumpIfTrue {
+            Instruction::PopJumpIfTrue {
                 target: reraise_block
             }
         );
@@ -3130,12 +3130,12 @@ impl Compiler {
 
         // Nothing to reraise
         // POP_TOP - pop result (None)
-        emit!(self, RealInstruction::PopTop);
+        emit!(self, Instruction::PopTop);
         // Stack: [prev_exc]
 
         // POP_BLOCK - no-op for us with exception tables (fblocks handle this)
         // POP_EXCEPT - restore previous exception context
-        emit!(self, RealInstruction::PopExcept);
+        emit!(self, Instruction::PopExcept);
         // Stack: []
 
         if !finalbody.is_empty() {
@@ -3150,15 +3150,15 @@ impl Compiler {
 
         // POP_BLOCK - no-op for us
         // SWAP 2
-        emit!(self, RealInstruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { index: 2 });
         // Stack: [result, prev_exc]
 
         // POP_EXCEPT
-        emit!(self, RealInstruction::PopExcept);
+        emit!(self, Instruction::PopExcept);
         // Stack: [result]
 
         // RERAISE 0
-        emit!(self, RealInstruction::Reraise { depth: 0 });
+        emit!(self, Instruction::Reraise { depth: 0 });
 
         // try-else path
         // NOTE: When we reach here in compilation, the nothing-to-reraise path above
@@ -3221,7 +3221,7 @@ impl Compiler {
             }
             emit!(
                 self,
-                RealInstruction::BuildTuple {
+                Instruction::BuildTuple {
                     size: defaults.len().to_u32()
                 }
             );
@@ -3246,7 +3246,7 @@ impl Compiler {
             }
             emit!(
                 self,
-                RealInstruction::BuildMap {
+                Instruction::BuildMap {
                     size: kw_with_defaults.len().to_u32(),
                 }
             );
@@ -3316,13 +3316,13 @@ impl Compiler {
 
         // Handle docstring if present
         if let Some(doc) = doc_str {
-            emit!(self, RealInstruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             self.emit_load_const(ConstantData::Str {
                 value: doc.to_string().into(),
             });
-            emit!(self, RealInstruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { index: 2 });
             let doc_attr = self.name("__doc__");
-            emit!(self, RealInstruction::StoreAttr { idx: doc_attr });
+            emit!(self, Instruction::StoreAttr { idx: doc_attr });
         }
 
         Ok(())
@@ -3428,7 +3428,7 @@ impl Compiler {
 
             // Load defaults/kwdefaults with LOAD_FAST
             for i in 0..num_typeparam_args {
-                emit!(self, RealInstruction::LoadFast(i as u32));
+                emit!(self, Instruction::LoadFast(i as u32));
             }
         }
 
@@ -3439,7 +3439,7 @@ impl Compiler {
             annotations_flag = bytecode::MakeFunctionFlags::ANNOTATIONS;
             emit!(
                 self,
-                RealInstruction::BuildMap {
+                Instruction::BuildMap {
                     size: num_annotations,
                 }
             );
@@ -3453,18 +3453,18 @@ impl Compiler {
         if is_generic {
             // SWAP to get function on top
             // Stack: [type_params_tuple, function] -> [function, type_params_tuple]
-            emit!(self, RealInstruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { index: 2 });
 
             // Call INTRINSIC_SET_FUNCTION_TYPE_PARAMS
             emit!(
                 self,
-                RealInstruction::CallIntrinsic2 {
+                Instruction::CallIntrinsic2 {
                     func: bytecode::IntrinsicFunction2::SetFunctionTypeParams,
                 }
             );
 
             // Return the function object from type params scope
-            emit!(self, RealInstruction::ReturnValue);
+            emit!(self, Instruction::ReturnValue);
 
             // Set argcount for type params scope
             self.current_code_info().metadata.argcount = num_typeparam_args as u32;
@@ -3484,31 +3484,31 @@ impl Compiler {
                 match num_typeparam_args {
                     1 => {
                         // Stack: [arg1, closure]
-                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, arg1]
-                        emit!(self, RealInstruction::PushNull); // [closure, arg1, NULL]
-                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, NULL, arg1]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]
+                        emit!(self, Instruction::PushNull); // [closure, arg1, NULL]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]
                     }
                     2 => {
                         // Stack: [arg1, arg2, closure]
-                        emit!(self, RealInstruction::Swap { index: 3 }); // [closure, arg2, arg1]
-                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, arg1, arg2]
-                        emit!(self, RealInstruction::PushNull); // [closure, arg1, arg2, NULL]
-                        emit!(self, RealInstruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]
-                        emit!(self, RealInstruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]
+                        emit!(self, Instruction::Swap { index: 3 }); // [closure, arg2, arg1]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1, arg2]
+                        emit!(self, Instruction::PushNull); // [closure, arg1, arg2, NULL]
+                        emit!(self, Instruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]
                     }
                     _ => unreachable!("only defaults and kwdefaults are supported"),
                 }
                 emit!(
                     self,
-                    RealInstruction::Call {
+                    Instruction::Call {
                         nargs: num_typeparam_args as u32
                     }
                 );
             } else {
                 // Stack: [closure]
-                emit!(self, RealInstruction::PushNull);
+                emit!(self, Instruction::PushNull);
                 // Stack: [closure, NULL]
-                emit!(self, RealInstruction::Call { nargs: 0 });
+                emit!(self, Instruction::Call { nargs: 0 });
             }
         }
 
@@ -3609,13 +3609,13 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, RealInstruction::LoadClosure(idx.to_u32()));
+                emit!(self, Instruction::LoadClosure(idx.to_u32()));
             }
 
             // Build tuple of closure variables
             emit!(
                 self,
-                RealInstruction::BuildTuple {
+                Instruction::BuildTuple {
                     size: code.freevars.len().to_u32(),
                 }
             );
@@ -3627,7 +3627,7 @@ impl Compiler {
         });
 
         // Create function with no flags
-        emit!(self, RealInstruction::MakeFunction);
+        emit!(self, Instruction::MakeFunction);
 
         // Now set attributes one by one using SET_FUNCTION_ATTRIBUTE
         // Note: The order matters! Values must be on stack before calling SET_FUNCTION_ATTRIBUTE
@@ -3636,7 +3636,7 @@ impl Compiler {
         if has_freevars {
             emit!(
                 self,
-                RealInstruction::SetFunctionAttribute {
+                Instruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::CLOSURE
                 }
             );
@@ -3646,7 +3646,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::ANNOTATIONS) {
             emit!(
                 self,
-                RealInstruction::SetFunctionAttribute {
+                Instruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::ANNOTATIONS
                 }
             );
@@ -3656,7 +3656,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
             emit!(
                 self,
-                RealInstruction::SetFunctionAttribute {
+                Instruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
                 }
             );
@@ -3666,7 +3666,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
             emit!(
                 self,
-                RealInstruction::SetFunctionAttribute {
+                Instruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::DEFAULTS
                 }
             );
@@ -3676,7 +3676,7 @@ impl Compiler {
         if flags.contains(bytecode::MakeFunctionFlags::TYPE_PARAMS) {
             emit!(
                 self,
-                RealInstruction::SetFunctionAttribute {
+                Instruction::SetFunctionAttribute {
                     attr: bytecode::MakeFunctionFlags::TYPE_PARAMS
                 }
             );
@@ -3746,22 +3746,22 @@ impl Compiler {
 
         // Load (global) __name__ and store as __module__
         let dunder_name = self.name("__name__");
-        emit!(self, RealInstruction::LoadGlobal(dunder_name));
+        emit!(self, Instruction::LoadGlobal(dunder_name));
         let dunder_module = self.name("__module__");
-        emit!(self, RealInstruction::StoreName(dunder_module));
+        emit!(self, Instruction::StoreName(dunder_module));
 
         // Store __qualname__
         self.emit_load_const(ConstantData::Str {
             value: qualname.into(),
         });
         let qualname_name = self.name("__qualname__");
-        emit!(self, RealInstruction::StoreName(qualname_name));
+        emit!(self, Instruction::StoreName(qualname_name));
 
         // Store __doc__ only if there's an explicit docstring
         if let Some(doc) = doc_str {
             self.emit_load_const(ConstantData::Str { value: doc.into() });
             let doc_name = self.name("__doc__");
-            emit!(self, RealInstruction::StoreName(doc_name));
+            emit!(self, Instruction::StoreName(doc_name));
         }
 
         // Store __firstlineno__ (new in Python 3.12+)
@@ -3769,22 +3769,22 @@ impl Compiler {
             value: BigInt::from(firstlineno),
         });
         let firstlineno_name = self.name("__firstlineno__");
-        emit!(self, RealInstruction::StoreName(firstlineno_name));
+        emit!(self, Instruction::StoreName(firstlineno_name));
 
         // Set __type_params__ if we have type parameters
         if type_params.is_some() {
             // Load .type_params from enclosing scope
             let dot_type_params = self.name(".type_params");
-            emit!(self, RealInstruction::LoadName(dot_type_params));
+            emit!(self, Instruction::LoadName(dot_type_params));
 
             // Store as __type_params__
             let dunder_type_params = self.name("__type_params__");
-            emit!(self, RealInstruction::StoreName(dunder_type_params));
+            emit!(self, Instruction::StoreName(dunder_type_params));
         }
 
         // Setup annotations if needed
         if Self::find_ann(body) {
-            emit!(self, RealInstruction::SetupAnnotations);
+            emit!(self, Instruction::SetupAnnotations);
         }
 
         // 3. Compile the class body
@@ -3801,10 +3801,10 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, RealInstruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, RealInstruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
+            emit!(self, Instruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
-            emit!(self, RealInstruction::StoreName(classcell));
+            emit!(self, Instruction::StoreName(classcell));
         } else {
             self.emit_load_const(ConstantData::None);
         }
@@ -3846,7 +3846,7 @@ impl Compiler {
             // Compile type parameters and store as .type_params
             self.compile_type_params(type_params.unwrap())?;
             let dot_type_params = self.name(".type_params");
-            emit!(self, RealInstruction::StoreName(dot_type_params));
+            emit!(self, Instruction::StoreName(dot_type_params));
         }
 
         // Step 2: Compile class body (always done, whether generic or not)
@@ -3867,22 +3867,22 @@ impl Compiler {
             let dot_generic_base = self.name(".generic_base");
 
             // Create .generic_base
-            emit!(self, RealInstruction::LoadName(dot_type_params));
+            emit!(self, Instruction::LoadName(dot_type_params));
             emit!(
                 self,
-                RealInstruction::CallIntrinsic1 {
+                Instruction::CallIntrinsic1 {
                     func: bytecode::IntrinsicFunction1::SubscriptGeneric
                 }
             );
-            emit!(self, RealInstruction::StoreName(dot_generic_base));
+            emit!(self, Instruction::StoreName(dot_generic_base));
 
             // Generate class creation code
-            emit!(self, RealInstruction::LoadBuildClass);
-            emit!(self, RealInstruction::PushNull);
+            emit!(self, Instruction::LoadBuildClass);
+            emit!(self, Instruction::PushNull);
 
             // Set up the class function with type params
             let mut func_flags = bytecode::MakeFunctionFlags::empty();
-            emit!(self, RealInstruction::LoadName(dot_type_params));
+            emit!(self, Instruction::LoadName(dot_type_params));
             func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
 
             // Create class function with closure
@@ -3910,20 +3910,17 @@ impl Compiler {
                 };
 
                 // Add .generic_base as final base
-                emit!(self, RealInstruction::LoadName(dot_generic_base));
+                emit!(self, Instruction::LoadName(dot_generic_base));
 
                 // Build args tuple
                 if unpack {
                     // Starred: gather_elements produced tuples on stack
-                    emit!(self, RealInstruction::BuildTuple { size: 1 }); // (.generic_base,)
-                    emit!(
-                        self,
-                        RealInstruction::BuildTupleFromTuples { size: size + 1 }
-                    );
+                    emit!(self, Instruction::BuildTuple { size: 1 }); // (.generic_base,)
+                    emit!(self, Instruction::BuildTupleFromTuples { size: size + 1 });
                 } else {
                     // No starred: individual elements on stack
                     // size includes class_func + name + bases count, +1 for .generic_base
-                    emit!(self, RealInstruction::BuildTuple { size: size + 1 });
+                    emit!(self, Instruction::BuildTuple { size: size + 1 });
                 }
 
                 // Build kwargs if needed
@@ -3931,7 +3928,7 @@ impl Compiler {
                 if has_kwargs {
                     self.compile_keywords(&arguments.unwrap().keywords)?;
                 }
-                emit!(self, RealInstruction::CallFunctionEx { has_kwargs });
+                emit!(self, Instruction::CallFunctionEx { has_kwargs });
             } else {
                 // Simple case: no starred bases, no **kwargs
                 // Compile bases normally
@@ -3945,7 +3942,7 @@ impl Compiler {
                 };
 
                 // Load .generic_base as the last base
-                emit!(self, RealInstruction::LoadName(dot_generic_base));
+                emit!(self, Instruction::LoadName(dot_generic_base));
 
                 let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;
 
@@ -3968,14 +3965,14 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        RealInstruction::CallKw {
+                        Instruction::CallKw {
                             nargs: nargs
                                 + u32::try_from(arguments.keywords.len())
                                     .expect("too many keyword arguments")
                         }
                     );
                 } else {
-                    emit!(self, RealInstruction::Call { nargs });
+                    emit!(self, Instruction::Call { nargs });
                 }
             }
 
@@ -3987,12 +3984,12 @@ impl Compiler {
 
             // Execute the type params function
             self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
-            emit!(self, RealInstruction::PushNull);
-            emit!(self, RealInstruction::Call { nargs: 0 });
+            emit!(self, Instruction::PushNull);
+            emit!(self, Instruction::Call { nargs: 0 });
         } else {
             // Non-generic class: standard path
-            emit!(self, RealInstruction::LoadBuildClass);
-            emit!(self, RealInstruction::PushNull);
+            emit!(self, Instruction::LoadBuildClass);
+            emit!(self, Instruction::PushNull);
 
             // Create class function with closure
             self.make_closure(class_code, bytecode::MakeFunctionFlags::empty())?;
@@ -4001,7 +3998,7 @@ impl Compiler {
             if let Some(arguments) = arguments {
                 self.compile_call_helper(2, arguments)?;
             } else {
-                emit!(self, RealInstruction::Call { nargs: 2 });
+                emit!(self, Instruction::Call { nargs: 2 });
             }
         }
 
@@ -4092,12 +4089,12 @@ impl Compiler {
             if self.ctx.func != FunctionContext::AsyncFunction {
                 return Err(self.error(CodegenErrorType::InvalidAsyncWith));
             }
-            emit!(self, RealInstruction::BeforeAsyncWith);
-            emit!(self, RealInstruction::GetAwaitable);
+            emit!(self, Instruction::BeforeAsyncWith);
+            emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         } else {
-            emit!(self, RealInstruction::BeforeWith);
+            emit!(self, Instruction::BeforeWith);
         }
 
         // Stack: [..., __exit__, enter_result]
@@ -4125,7 +4122,7 @@ impl Compiler {
                 self.compile_store(var)?;
             }
             None => {
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             }
         }
         // Stack: [..., __exit__]
@@ -4152,17 +4149,17 @@ impl Compiler {
         // Stack: [..., __exit__]
         // Call __exit__(None, None, None)
         self.set_source_range(with_range);
-        emit!(self, RealInstruction::PushNull);
+        emit!(self, Instruction::PushNull);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
-        emit!(self, RealInstruction::Call { nargs: 3 });
+        emit!(self, Instruction::Call { nargs: 3 });
         if is_async {
-            emit!(self, RealInstruction::GetAwaitable);
+            emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         }
-        emit!(self, RealInstruction::PopTop); // Pop __exit__ result
+        emit!(self, Instruction::PopTop); // Pop __exit__ result
         emit!(
             self,
             PseudoInstruction::Jump {
@@ -4195,24 +4192,24 @@ impl Compiler {
         )?;
 
         // PUSH_EXC_INFO: [exc] -> [prev_exc, exc]
-        emit!(self, RealInstruction::PushExcInfo);
+        emit!(self, Instruction::PushExcInfo);
 
         // WITH_EXCEPT_START: call __exit__(type, value, tb)
         // Stack: [..., __exit__, lasti, prev_exc, exc]
         // __exit__ is at TOS-3, call with exception info
-        emit!(self, RealInstruction::WithExceptStart);
+        emit!(self, Instruction::WithExceptStart);
 
         if is_async {
-            emit!(self, RealInstruction::GetAwaitable);
+            emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         }
 
         // TO_BOOL + POP_JUMP_IF_TRUE: check if exception is suppressed
-        emit!(self, RealInstruction::ToBool);
+        emit!(self, Instruction::ToBool);
         emit!(
             self,
-            RealInstruction::PopJumpIfTrue {
+            Instruction::PopJumpIfTrue {
                 target: suppress_block
             }
         );
@@ -4224,17 +4221,17 @@ impl Compiler {
         self.pop_fblock(FBlockType::ExceptionHandler);
 
         // Not suppressed: RERAISE 2
-        emit!(self, RealInstruction::Reraise { depth: 2 });
+        emit!(self, Instruction::Reraise { depth: 2 });
 
         // ===== Suppress block =====
         // Exception was suppressed, clean up stack
         // Stack: [..., __exit__, lasti, prev_exc, exc, True]
         // Need to pop: True, exc, prev_exc, __exit__
         self.switch_to_block(suppress_block);
-        emit!(self, RealInstruction::PopTop); // pop True (TO_BOOL result)
-        emit!(self, RealInstruction::PopExcept); // pop exc and restore prev_exc
-        emit!(self, RealInstruction::PopTop); // pop __exit__
-        emit!(self, RealInstruction::PopTop); // pop lasti
+        emit!(self, Instruction::PopTop); // pop True (TO_BOOL result)
+        emit!(self, Instruction::PopExcept); // pop exc and restore prev_exc
+        emit!(self, Instruction::PopTop); // pop __exit__
+        emit!(self, Instruction::PopTop); // pop lasti
         emit!(
             self,
             PseudoInstruction::Jump {
@@ -4253,9 +4250,9 @@ impl Compiler {
         // to be in the exception table for these instructions.
         // If we cleared fblock, exceptions here would propagate uncaught.
         self.switch_to_block(cleanup_block);
-        emit!(self, RealInstruction::Copy { index: 3 });
-        emit!(self, RealInstruction::PopExcept);
-        emit!(self, RealInstruction::Reraise { depth: 1 });
+        emit!(self, Instruction::Copy { index: 3 });
+        emit!(self, Instruction::PopExcept);
+        emit!(self, Instruction::Reraise { depth: 1 });
 
         // ===== After block =====
         self.switch_to_block(after_block);
@@ -4283,7 +4280,7 @@ impl Compiler {
             if self.ctx.func != FunctionContext::AsyncFunction {
                 return Err(self.error(CodegenErrorType::InvalidAsyncFor));
             }
-            emit!(self, RealInstruction::GetAIter);
+            emit!(self, Instruction::GetAIter);
 
             self.switch_to_block(for_block);
 
@@ -4301,21 +4298,21 @@ impl Compiler {
                 false,            // no lasti needed
             )?;
 
-            emit!(self, RealInstruction::GetANext);
+            emit!(self, Instruction::GetANext);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
             self.compile_store(target)?;
             // Note: PopBlock is no longer emitted (exception table handles this)
         } else {
             // Retrieve Iterator
-            emit!(self, RealInstruction::GetIter);
+            emit!(self, Instruction::GetIter);
 
             self.switch_to_block(for_block);
 
             // Push fblock for for loop
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
-            emit!(self, RealInstruction::ForIter { target: else_block });
+            emit!(self, Instruction::ForIter { target: else_block });
 
             // Start of loop iteration, set targets:
             self.compile_store(target)?;
@@ -4332,7 +4329,7 @@ impl Compiler {
         self.pop_fblock(FBlockType::ForLoop);
 
         if is_async {
-            emit!(self, RealInstruction::EndAsyncFor);
+            emit!(self, Instruction::EndAsyncFor);
         }
         self.compile_statements(orelse)?;
 
@@ -4391,7 +4388,7 @@ impl Compiler {
             JumpOp::PopJumpIfFalse => {
                 emit!(
                     self,
-                    RealInstruction::PopJumpIfFalse {
+                    Instruction::PopJumpIfFalse {
                         target: pc.fail_pop[pops]
                     }
                 );
@@ -4412,7 +4409,7 @@ impl Compiler {
         for &label in pc.fail_pop.iter().skip(1).rev() {
             self.switch_to_block(label);
             // Emit the POP instruction.
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
         }
         // Finally, use the first label.
         self.switch_to_block(pc.fail_pop[0]);
@@ -4433,7 +4430,7 @@ impl Compiler {
             // Emit a SWAP instruction with the current count.
             emit!(
                 self,
-                RealInstruction::Swap {
+                Instruction::Swap {
                     index: u32::try_from(count).unwrap()
                 }
             );
@@ -4456,7 +4453,7 @@ impl Compiler {
         match n {
             // If no name is provided, simply pop the top of the stack.
             None => {
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
                 Ok(())
             }
             Some(name) => {
@@ -4498,7 +4495,7 @@ impl Compiler {
                         before: u8::try_from(i).unwrap(),
                         after: u8::try_from(n - i - 1).unwrap(),
                     };
-                    emit!(self, RealInstruction::UnpackEx { args });
+                    emit!(self, Instruction::UnpackEx { args });
                     seen_star = true;
                 } else {
                     // TODO: Fix error msg
@@ -4510,7 +4507,7 @@ impl Compiler {
         if !seen_star {
             emit!(
                 self,
-                RealInstruction::UnpackSequence {
+                Instruction::UnpackSequence {
                     size: u32::try_from(n).unwrap()
                 }
             );
@@ -4556,33 +4553,33 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, RealInstruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             if i < star {
                 // For indices before the star, use a nonnegative index equal to i.
                 self.emit_load_const(ConstantData::Integer { value: i.into() });
             } else {
                 // For indices after the star, compute a nonnegative index:
                 // index = len(subject) - (size - i)
-                emit!(self, RealInstruction::GetLen);
+                emit!(self, Instruction::GetLen);
                 self.emit_load_const(ConstantData::Integer {
                     value: (patterns.len() - i).into(),
                 });
                 // Subtract to compute the correct index.
                 emit!(
                     self,
-                    RealInstruction::BinaryOp {
+                    Instruction::BinaryOp {
                         op: BinaryOperator::Subtract
                     }
                 );
             }
             // Use BINARY_OP/NB_SUBSCR to extract the element.
-            emit!(self, RealInstruction::BinarySubscr);
+            emit!(self, Instruction::BinarySubscr);
             // Compile the subpattern in irrefutable mode.
             self.compile_pattern_subpattern(pattern, pc)?;
         }
         // Pop the subject off the stack.
         pc.on_top -= 1;
-        emit!(self, RealInstruction::PopTop);
+        emit!(self, Instruction::PopTop);
         Ok(())
     }
 
@@ -4629,7 +4626,7 @@ impl Compiler {
 
         // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
         pc.on_top += 1;
-        emit!(self, RealInstruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { index: 1_u32 });
         // Compile the sub-pattern.
         self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
         // After success, decrement the on_top counter.
@@ -4728,16 +4725,13 @@ impl Compiler {
             elements: attr_names,
         });
         // 2. Emit MATCH_CLASS with nargs.
-        emit!(
-            self,
-            RealInstruction::MatchClass(u32::try_from(nargs).unwrap())
-        );
+        emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
         // 3. Duplicate the top of the stack.
-        emit!(self, RealInstruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { index: 1_u32 });
         // 4. Load None.
         self.emit_load_const(ConstantData::None);
         // 5. Compare with IS_OP 1.
-        emit!(self, RealInstruction::IsOp(Invert::Yes));
+        emit!(self, Instruction::IsOp(Invert::Yes));
 
         // At this point the TOS is a tuple of (nargs + n_attrs) attributes (or None).
         pc.on_top += 1;
@@ -4747,7 +4741,7 @@ impl Compiler {
         let total = nargs + n_attrs;
         emit!(
             self,
-            RealInstruction::UnpackSequence {
+            Instruction::UnpackSequence {
                 size: u32::try_from(total).unwrap()
             }
         );
@@ -4769,7 +4763,7 @@ impl Compiler {
             pc.on_top -= 1;
 
             if is_true_wildcard {
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
                 continue; // Don't compile wildcard patterns
             }
 
@@ -4810,7 +4804,7 @@ impl Compiler {
         // Stack: [subject]
         pc.on_top += 1;
 
-        emit!(self, RealInstruction::MatchMapping);
+        emit!(self, Instruction::MatchMapping);
         // Stack: [subject, is_mapping]
 
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -4820,19 +4814,19 @@ impl Compiler {
         if size == 0 && star_target.is_none() {
             // If the pattern is just "{}", we're done! Pop the subject
             pc.on_top -= 1;
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
             return Ok(());
         }
 
         // Length check for patterns with keys
         if size > 0 {
             // Check if the mapping has at least 'size' keys
-            emit!(self, RealInstruction::GetLen);
+            emit!(self, Instruction::GetLen);
             self.emit_load_const(ConstantData::Integer { value: size.into() });
             // Stack: [subject, len, size]
             emit!(
                 self,
-                RealInstruction::CompareOp {
+                Instruction::CompareOp {
                     op: ComparisonOperator::GreaterOrEqual
                 }
             );
@@ -4889,28 +4883,28 @@ impl Compiler {
         // Stack: [subject, key1, key2, ..., key_n]
 
         // Build tuple of keys (empty tuple if size==0)
-        emit!(self, RealInstruction::BuildTuple { size });
+        emit!(self, Instruction::BuildTuple { size });
         // Stack: [subject, keys_tuple]
 
         // Match keys
-        emit!(self, RealInstruction::MatchKeys);
+        emit!(self, Instruction::MatchKeys);
         // Stack: [subject, keys_tuple, values_or_none]
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, RealInstruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { index: 1_u32 });
         // Stack: [subject, keys_tuple, values_tuple, values_tuple_copy]
 
         // Check if copy is None (consumes the copy like POP_JUMP_IF_NONE)
         self.emit_load_const(ConstantData::None);
-        emit!(self, RealInstruction::IsOp(Invert::Yes));
+        emit!(self, Instruction::IsOp(Invert::Yes));
 
         // Stack: [subject, keys_tuple, values_tuple, bool]
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         // Stack: [subject, keys_tuple, values_tuple]
 
         // Unpack values (the original values_tuple)
-        emit!(self, RealInstruction::UnpackSequence { size });
+        emit!(self, Instruction::UnpackSequence { size });
         // Stack after unpack: [subject, keys_tuple, ...unpacked values...]
         pc.on_top += size as usize; // Unpacked size values, tuple replaced by values
         pc.on_top -= 1;
@@ -4932,16 +4926,16 @@ impl Compiler {
             // Stack: [subject, keys_tuple]
 
             // Build rest dict exactly
-            emit!(self, RealInstruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { size: 0 });
             // Stack: [subject, keys_tuple, {}]
-            emit!(self, RealInstruction::Swap { index: 3 });
+            emit!(self, Instruction::Swap { index: 3 });
             // Stack: [{}, keys_tuple, subject]
-            emit!(self, RealInstruction::DictUpdate { index: 2 });
+            emit!(self, Instruction::DictUpdate { index: 2 });
             // Stack after DICT_UPDATE: [rest_dict, keys_tuple]
             // DICT_UPDATE consumes source (subject) and leaves dict in place
 
             // Unpack keys and delete from rest_dict
-            emit!(self, RealInstruction::UnpackSequence { size });
+            emit!(self, Instruction::UnpackSequence { size });
             // Stack: [rest_dict, k1, k2, ..., kn] (if size==0, nothing pushed)
 
             // Delete each key from rest_dict (skipped when size==0)
@@ -4951,14 +4945,14 @@ impl Compiler {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
                 emit!(
                     self,
-                    RealInstruction::Copy {
+                    Instruction::Copy {
                         index: 1 + remaining
                     }
                 );
                 // Stack: [rest_dict, k1, ..., kn, rest_dict]
-                emit!(self, RealInstruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap { index: 2 });
                 // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
-                emit!(self, RealInstruction::DeleteSubscr);
+                emit!(self, Instruction::DeleteSubscr);
                 // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
                 remaining -= 1;
             }
@@ -4975,8 +4969,8 @@ impl Compiler {
             // Non-rest pattern: just clean up the stack
 
             // Pop them as we're not using them
-            emit!(self, RealInstruction::PopTop); // Pop keys_tuple
-            emit!(self, RealInstruction::PopTop); // Pop subject
+            emit!(self, Instruction::PopTop); // Pop keys_tuple
+            emit!(self, Instruction::PopTop); // Pop subject
         }
 
         Ok(())
@@ -5008,7 +5002,7 @@ impl Compiler {
             pc.fail_pop.clear();
             pc.on_top = 0;
             // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, RealInstruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -5064,7 +5058,7 @@ impl Compiler {
         // In Rust, old_pc is a local clone, so we need not worry about that.
 
         // No alternative matched: pop the subject and fail.
-        emit!(self, RealInstruction::PopTop);
+        emit!(self, Instruction::PopTop);
         self.jump_to_fail_pop(pc, JumpOp::Jump)?;
 
         // Use the label "end".
@@ -5086,7 +5080,7 @@ impl Compiler {
 
         // Old context and control will be dropped automatically.
         // Finally, pop the copy of the subject.
-        emit!(self, RealInstruction::PopTop);
+        emit!(self, Instruction::PopTop);
         Ok(())
     }
 
@@ -5127,29 +5121,29 @@ impl Compiler {
 
         // Keep the subject on top during the sequence and length checks.
         pc.on_top += 1;
-        emit!(self, RealInstruction::MatchSequence);
+        emit!(self, Instruction::MatchSequence);
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
 
         if star.is_none() {
             // No star: len(subject) == size
-            emit!(self, RealInstruction::GetLen);
+            emit!(self, Instruction::GetLen);
             self.emit_load_const(ConstantData::Integer { value: size.into() });
             emit!(
                 self,
-                RealInstruction::CompareOp {
+                Instruction::CompareOp {
                     op: ComparisonOperator::Equal
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         } else if size > 1 {
             // Star exists: len(subject) >= size - 1
-            emit!(self, RealInstruction::GetLen);
+            emit!(self, Instruction::GetLen);
             self.emit_load_const(ConstantData::Integer {
                 value: (size - 1).into(),
             });
             emit!(
                 self,
-                RealInstruction::CompareOp {
+                Instruction::CompareOp {
                     op: ComparisonOperator::GreaterOrEqual
                 }
             );
@@ -5160,7 +5154,7 @@ impl Compiler {
         pc.on_top -= 1;
         if only_wildcard {
             // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
         } else if star_wildcard {
             self.pattern_helper_sequence_subscr(patterns, star.unwrap(), pc)?;
         } else {
@@ -5178,11 +5172,11 @@ impl Compiler {
         self.compile_expression(&p.value)?;
         emit!(
             self,
-            RealInstruction::CompareOp {
+            Instruction::CompareOp {
                 op: bytecode::ComparisonOperator::Equal
             }
         );
-        // emit!(self, RealInstruction::ToBool);
+        // emit!(self, Instruction::ToBool);
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         Ok(())
     }
@@ -5199,7 +5193,7 @@ impl Compiler {
             Singleton::True => ConstantData::Boolean { value: true },
         });
         // Compare using the "Is" operator.
-        emit!(self, RealInstruction::IsOp(Invert::No));
+        emit!(self, Instruction::IsOp(Invert::No));
         // Jump to the failure label if the comparison is false.
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         Ok(())
@@ -5255,7 +5249,7 @@ impl Compiler {
         for (i, m) in cases.iter().enumerate().take(case_count) {
             // Only copy the subject if not on the last case
             if i != case_count - 1 {
-                emit!(self, RealInstruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -5274,17 +5268,17 @@ impl Compiler {
                 self.ensure_fail_pop(pattern_context, 0)?;
                 // Compile the guard expression
                 self.compile_expression(guard)?;
-                emit!(self, RealInstruction::ToBool);
+                emit!(self, Instruction::ToBool);
                 emit!(
                     self,
-                    RealInstruction::PopJumpIfFalse {
+                    Instruction::PopJumpIfFalse {
                         target: pattern_context.fail_pop[0]
                     }
                 );
             }
 
             if i != case_count - 1 {
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             }
 
             self.compile_statements(&m.body)?;
@@ -5295,16 +5289,16 @@ impl Compiler {
         if has_default {
             let m = &cases[num_cases - 1];
             if num_cases == 1 {
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::PopTop);
             } else {
-                emit!(self, RealInstruction::Nop);
+                emit!(self, Instruction::Nop);
             }
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, RealInstruction::Copy { index: 1_u32 });
-                emit!(self, RealInstruction::PopJumpIfFalse { target: end });
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::PopJumpIfFalse { target: end });
+                emit!(self, Instruction::PopTop);
             }
             self.compile_statements(&m.body)?;
         }
@@ -5322,18 +5316,18 @@ impl Compiler {
     fn compile_addcompare(&mut self, op: &CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
-            CmpOp::Eq => emit!(self, RealInstruction::CompareOp { op: Equal }),
-            CmpOp::NotEq => emit!(self, RealInstruction::CompareOp { op: NotEqual }),
-            CmpOp::Lt => emit!(self, RealInstruction::CompareOp { op: Less }),
-            CmpOp::LtE => emit!(self, RealInstruction::CompareOp { op: LessOrEqual }),
-            CmpOp::Gt => emit!(self, RealInstruction::CompareOp { op: Greater }),
+            CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
+            CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
+            CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
+            CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
+            CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
             CmpOp::GtE => {
-                emit!(self, RealInstruction::CompareOp { op: GreaterOrEqual })
+                emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
             }
-            CmpOp::In => emit!(self, RealInstruction::ContainsOp(Invert::No)),
-            CmpOp::NotIn => emit!(self, RealInstruction::ContainsOp(Invert::Yes)),
-            CmpOp::Is => emit!(self, RealInstruction::IsOp(Invert::No)),
-            CmpOp::IsNot => emit!(self, RealInstruction::IsOp(Invert::Yes)),
+            CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
+            CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
+            CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
+            CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
         }
     }
 
@@ -5381,20 +5375,20 @@ impl Compiler {
             self.compile_expression(comparator)?;
 
             // store rhs for the next comparison in chain
-            emit!(self, RealInstruction::Swap { index: 2 });
-            emit!(self, RealInstruction::Copy { index: 2 });
+            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Copy { index: 2 });
 
             self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
             /*
-            emit!(self, RealInstruction::Copy { index: 1 });
-            // emit!(self, RealInstruction::ToBool); // TODO: Uncomment this
-            emit!(self, RealInstruction::PopJumpIfFalse { target: cleanup });
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::Copy { index: 1 });
+            // emit!(self, Instruction::ToBool); // TODO: Uncomment this
+            emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
+            emit!(self, Instruction::PopTop);
             */
 
-            emit!(self, RealInstruction::JumpIfFalseOrPop { target: cleanup });
+            emit!(self, Instruction::JumpIfFalseOrPop { target: cleanup });
         }
 
         self.compile_expression(last_comparator)?;
@@ -5405,8 +5399,8 @@ impl Compiler {
 
         // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
         self.switch_to_block(cleanup);
-        emit!(self, RealInstruction::Swap { index: 2 });
-        emit!(self, RealInstruction::PopTop);
+        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::PopTop);
 
         self.switch_to_block(end);
         Ok(())
@@ -5429,7 +5423,7 @@ impl Compiler {
                     // *args: *Ts (where Ts is a TypeVarTuple).
                     // Do [annotation_value] = [*Ts].
                     self.compile_expression(value)?;
-                    emit!(self, RealInstruction::UnpackSequence { size: 1 });
+                    emit!(self, Instruction::UnpackSequence { size: 1 });
                     Ok(())
                 }
                 _ => self.compile_expression(annotation),
@@ -5463,14 +5457,14 @@ impl Compiler {
         if let Expr::Name(ExprName { id, .. }) = &target {
             // Store as dict entry in __annotations__ dict:
             let annotations = self.name("__annotations__");
-            emit!(self, RealInstruction::LoadName(annotations));
+            emit!(self, Instruction::LoadName(annotations));
             self.emit_load_const(ConstantData::Str {
                 value: self.mangle(id.as_str()).into_owned().into(),
             });
-            emit!(self, RealInstruction::StoreSubscr);
+            emit!(self, Instruction::StoreSubscr);
         } else {
             // Drop annotation if not assigned to simple identifier.
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
         }
 
         Ok(())
@@ -5488,7 +5482,7 @@ impl Compiler {
                 self.check_forbidden_name(attr.as_str(), NameUsage::Store)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, RealInstruction::StoreAttr { idx });
+                emit!(self, Instruction::StoreAttr { idx });
             }
             Expr::List(ExprList { elts, .. }) | Expr::Tuple(ExprTuple { elts, .. }) => {
                 let mut seen_star = false;
@@ -5510,7 +5504,7 @@ impl Compiler {
                                     )
                                 })?;
                             let args = bytecode::UnpackExArgs { before, after };
-                            emit!(self, RealInstruction::UnpackEx { args });
+                            emit!(self, Instruction::UnpackEx { args });
                         }
                     }
                 }
@@ -5518,7 +5512,7 @@ impl Compiler {
                 if !seen_star {
                     emit!(
                         self,
-                        RealInstruction::UnpackSequence {
+                        Instruction::UnpackSequence {
                             size: elts.len().to_u32(),
                         }
                     );
@@ -5573,18 +5567,18 @@ impl Compiler {
                 // But we can't use compile_subscript directly because we need DUP_TOP2
                 self.compile_expression(value)?;
                 self.compile_expression(slice)?;
-                emit!(self, RealInstruction::Copy { index: 2_u32 });
-                emit!(self, RealInstruction::Copy { index: 2_u32 });
-                emit!(self, RealInstruction::Subscript);
+                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Subscript);
                 AugAssignKind::Subscript
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
                 let attr = attr.as_str();
                 self.check_forbidden_name(attr, NameUsage::Store)?;
                 self.compile_expression(value)?;
-                emit!(self, RealInstruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 let idx = self.name(attr);
-                emit!(self, RealInstruction::LoadAttr { idx });
+                emit!(self, Instruction::LoadAttr { idx });
                 AugAssignKind::Attr { idx }
             }
             _ => {
@@ -5602,14 +5596,14 @@ impl Compiler {
             }
             AugAssignKind::Subscript => {
                 // stack: CONTAINER SLICE RESULT
-                emit!(self, RealInstruction::Swap { index: 3 });
-                emit!(self, RealInstruction::Swap { index: 2 });
-                emit!(self, RealInstruction::StoreSubscr);
+                emit!(self, Instruction::Swap { index: 3 });
+                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::StoreSubscr);
             }
             AugAssignKind::Attr { idx } => {
                 // stack: CONTAINER RESULT
-                emit!(self, RealInstruction::Swap { index: 2 });
-                emit!(self, RealInstruction::StoreAttr { idx });
+                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::StoreAttr { idx });
             }
         }
 
@@ -5634,7 +5628,7 @@ impl Compiler {
         };
 
         let op = if inplace { bin_op.as_inplace() } else { bin_op };
-        emit!(self, RealInstruction::BinaryOp { op })
+        emit!(self, Instruction::BinaryOp { op })
     }
 
     /// Implement boolean short circuit evaluation logic.
@@ -5712,14 +5706,14 @@ impl Compiler {
                 if condition {
                     emit!(
                         self,
-                        RealInstruction::PopJumpIfTrue {
+                        Instruction::PopJumpIfTrue {
                             target: target_block,
                         }
                     );
                 } else {
                     emit!(
                         self,
-                        RealInstruction::PopJumpIfFalse {
+                        Instruction::PopJumpIfFalse {
                             target: target_block,
                         }
                     );
@@ -5739,12 +5733,12 @@ impl Compiler {
         for value in values {
             self.compile_expression(value)?;
 
-            emit!(self, RealInstruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             match op {
                 BoolOp::And => {
                     emit!(
                         self,
-                        RealInstruction::PopJumpIfFalse {
+                        Instruction::PopJumpIfFalse {
                             target: after_block,
                         }
                     );
@@ -5752,14 +5746,14 @@ impl Compiler {
                 BoolOp::Or => {
                     emit!(
                         self,
-                        RealInstruction::PopJumpIfTrue {
+                        Instruction::PopJumpIfTrue {
                             target: after_block,
                         }
                     );
                 }
             }
 
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
         }
 
         // If all values did not qualify, take the value of the last value:
@@ -5778,11 +5772,11 @@ impl Compiler {
             self.compile_expression(&item.value)?;
             size += 1;
         }
-        emit!(self, RealInstruction::BuildMap { size });
+        emit!(self, Instruction::BuildMap { size });
 
         for item in unpacked {
             self.compile_expression(&item.value)?;
-            emit!(self, RealInstruction::DictUpdate { index: 1 });
+            emit!(self, Instruction::DictUpdate { index: 1 });
         }
 
         Ok(())
@@ -5809,7 +5803,7 @@ impl Compiler {
 
         // send:
         self.switch_to_block(send_block);
-        emit!(self, RealInstruction::Send { target: exit_block });
+        emit!(self, Instruction::Send { target: exit_block });
 
         // SETUP_FINALLY fail - set up exception handler for YIELD_VALUE
         // Stack at this point: [receiver, yielded_value]
@@ -5825,7 +5819,7 @@ impl Compiler {
         )?;
 
         // YIELD_VALUE with arg=1 (yield-from/await mode - not wrapped for async gen)
-        emit!(self, RealInstruction::YieldValue { arg: 1 });
+        emit!(self, Instruction::YieldValue { arg: 1 });
 
         // POP_BLOCK (implicit - pop fblock before RESUME)
         self.pop_fblock(FBlockType::TryExcept);
@@ -5833,7 +5827,7 @@ impl Compiler {
         // RESUME
         emit!(
             self,
-            RealInstruction::Resume {
+            Instruction::Resume {
                 arg: if is_await {
                     bytecode::ResumeType::AfterAwait as u32
                 } else {
@@ -5850,14 +5844,14 @@ impl Compiler {
         // CLEANUP_THROW: [sub_iter, last_sent_val, exc] -> [None, value]
         // After: stack is [None, value], fall through to exit
         self.switch_to_block(fail_block);
-        emit!(self, RealInstruction::CleanupThrow);
+        emit!(self, Instruction::CleanupThrow);
         // Fall through to exit block
 
         // exit: END_SEND
         // Stack: [receiver, value] (from SEND) or [None, value] (from CLEANUP_THROW)
         // END_SEND: [receiver/None, value] -> [value]
         self.switch_to_block(exit_block);
-        emit!(self, RealInstruction::EndSend);
+        emit!(self, Instruction::EndSend);
 
         Ok(())
     }
@@ -5894,16 +5888,16 @@ impl Compiler {
                 match op {
                     UnaryOp::UAdd => emit!(
                         self,
-                        RealInstruction::CallIntrinsic1 {
+                        Instruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::UnaryPositive
                         }
                     ),
-                    UnaryOp::USub => emit!(self, RealInstruction::UnaryNegative),
+                    UnaryOp::USub => emit!(self, Instruction::UnaryNegative),
                     UnaryOp::Not => {
-                        emit!(self, RealInstruction::ToBool);
-                        emit!(self, RealInstruction::UnaryNot);
+                        emit!(self, Instruction::ToBool);
+                        emit!(self, Instruction::UnaryNot);
                     }
-                    UnaryOp::Invert => emit!(self, RealInstruction::UnaryInvert),
+                    UnaryOp::Invert => emit!(self, Instruction::UnaryInvert),
                 };
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
@@ -5917,7 +5911,7 @@ impl Compiler {
                         SuperCallType::TwoArg { .. } => {
                             // LoadSuperAttr (pseudo) - will be converted to real LoadSuperAttr
                             // with flags=0b10 (has_class=true, load_method=false) in ir.rs
-                            emit!(self, RealInstruction::LoadSuperAttr { arg: idx });
+                            emit!(self, Instruction::LoadSuperAttr { arg: idx });
                         }
                         SuperCallType::ZeroArg => {
                             emit!(self, PseudoInstruction::LoadZeroSuperAttr { idx });
@@ -5927,7 +5921,7 @@ impl Compiler {
                     // Normal attribute access
                     self.compile_expression(value)?;
                     let idx = self.name(attr.as_str());
-                    emit!(self, RealInstruction::LoadAttr { idx });
+                    emit!(self, Instruction::LoadAttr { idx });
                 }
             }
             Expr::Compare(ExprCompare {
@@ -5972,7 +5966,7 @@ impl Compiler {
                     Some(_) => BuildSliceArgCount::Three,
                     None => BuildSliceArgCount::Two,
                 };
-                emit!(self, RealInstruction::BuildSlice { argc });
+                emit!(self, Instruction::BuildSlice { argc });
             }
             Expr::Yield(ExprYield { value, .. }) => {
                 if !self.ctx.in_func() {
@@ -5984,10 +5978,10 @@ impl Compiler {
                     Option::None => self.emit_load_const(ConstantData::None),
                 };
                 // arg=0: direct yield (wrapped for async generators)
-                emit!(self, RealInstruction::YieldValue { arg: 0 });
+                emit!(self, Instruction::YieldValue { arg: 0 });
                 emit!(
                     self,
-                    RealInstruction::Resume {
+                    Instruction::Resume {
                         arg: bytecode::ResumeType::AfterYield as u32
                     }
                 );
@@ -5997,7 +5991,7 @@ impl Compiler {
                     return Err(self.error(CodegenErrorType::InvalidAwait));
                 }
                 self.compile_expression(value)?;
-                emit!(self, RealInstruction::GetAwaitable);
+                emit!(self, Instruction::GetAwaitable);
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(true)?;
             }
@@ -6013,7 +6007,7 @@ impl Compiler {
                 }
                 self.mark_generator();
                 self.compile_expression(value)?;
-                emit!(self, RealInstruction::GetYieldFromIter);
+                emit!(self, Instruction::GetYieldFromIter);
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(false)?;
             }
@@ -6041,7 +6035,7 @@ impl Compiler {
                     for element in &defaults {
                         self.compile_expression(element)?;
                     }
-                    emit!(self, RealInstruction::BuildTuple { size });
+                    emit!(self, Instruction::BuildTuple { size });
                 }
 
                 // Prepare keyword-only defaults
@@ -6063,7 +6057,7 @@ impl Compiler {
                     }
                     emit!(
                         self,
-                        RealInstruction::BuildMap {
+                        Instruction::BuildMap {
                             size: default_kw_count.to_u32(),
                         }
                     );
@@ -6109,7 +6103,7 @@ impl Compiler {
                 self.compile_comprehension(
                     "<listcomp>",
                     Some(
-                        RealInstruction::BuildList {
+                        Instruction::BuildList {
                             size: OpArgMarker::marker(),
                         }
                         .into(),
@@ -6119,7 +6113,7 @@ impl Compiler {
                         compiler.compile_comprehension_element(elt)?;
                         emit!(
                             compiler,
-                            RealInstruction::ListAppend {
+                            Instruction::ListAppend {
                                 i: generators.len().to_u32(),
                             }
                         );
@@ -6135,7 +6129,7 @@ impl Compiler {
                 self.compile_comprehension(
                     "<setcomp>",
                     Some(
-                        RealInstruction::BuildSet {
+                        Instruction::BuildSet {
                             size: OpArgMarker::marker(),
                         }
                         .into(),
@@ -6145,7 +6139,7 @@ impl Compiler {
                         compiler.compile_comprehension_element(elt)?;
                         emit!(
                             compiler,
-                            RealInstruction::SetAdd {
+                            Instruction::SetAdd {
                                 i: generators.len().to_u32(),
                             }
                         );
@@ -6164,7 +6158,7 @@ impl Compiler {
                 self.compile_comprehension(
                     "<dictcomp>",
                     Some(
-                        RealInstruction::BuildMap {
+                        Instruction::BuildMap {
                             size: OpArgMarker::marker(),
                         }
                         .into(),
@@ -6177,7 +6171,7 @@ impl Compiler {
 
                         emit!(
                             compiler,
-                            RealInstruction::MapAdd {
+                            Instruction::MapAdd {
                                 i: generators.len().to_u32(),
                             }
                         );
@@ -6209,14 +6203,14 @@ impl Compiler {
 
                         compiler.mark_generator();
                         // arg=0: direct yield (wrapped for async generators)
-                        emit!(compiler, RealInstruction::YieldValue { arg: 0 });
+                        emit!(compiler, Instruction::YieldValue { arg: 0 });
                         emit!(
                             compiler,
-                            RealInstruction::Resume {
+                            Instruction::Resume {
                                 arg: bytecode::ResumeType::AfterYield as u32
                             }
                         );
-                        emit!(compiler, RealInstruction::PopTop);
+                        emit!(compiler, Instruction::PopTop);
 
                         Ok(())
                     },
@@ -6265,7 +6259,7 @@ impl Compiler {
                 range: _,
             }) => {
                 self.compile_expression(value)?;
-                emit!(self, RealInstruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 self.compile_store(target)?;
             }
             Expr::FString(fstring) => {
@@ -6348,12 +6342,12 @@ impl Compiler {
                         sub_size += 1;
                     }
                 }
-                emit!(self, RealInstruction::BuildMap { size: sub_size });
+                emit!(self, Instruction::BuildMap { size: sub_size });
                 size += 1;
             }
         }
         if size > 1 {
-            emit!(self, RealInstruction::BuildMapForCall { size });
+            emit!(self, Instruction::BuildMapForCall { size });
         }
         Ok(())
     }
@@ -6389,7 +6383,7 @@ impl Compiler {
             // Regular call: push func, then NULL for self_or_null slot
             // Stack layout: [func, NULL, args...] - same as method call [func, self, args...]
             self.compile_expression(func)?;
-            emit!(self, RealInstruction::PushNull);
+            emit!(self, Instruction::PushNull);
             self.compile_call_helper(0, args)?;
         }
         Ok(())
@@ -6420,9 +6414,9 @@ impl Compiler {
         if unpack || has_double_star {
             // Create a tuple with positional args:
             if unpack {
-                emit!(self, RealInstruction::BuildTupleFromTuples { size });
+                emit!(self, Instruction::BuildTupleFromTuples { size });
             } else {
-                emit!(self, RealInstruction::BuildTuple { size });
+                emit!(self, Instruction::BuildTuple { size });
             }
 
             // Create an optional map with kw-args:
@@ -6430,7 +6424,7 @@ impl Compiler {
             if has_kwargs {
                 self.compile_keywords(&arguments.keywords)?;
             }
-            emit!(self, RealInstruction::CallFunctionEx { has_kwargs });
+            emit!(self, Instruction::CallFunctionEx { has_kwargs });
         } else if !arguments.keywords.is_empty() {
             // No **kwargs in this branch (has_double_star is false),
             // so all keywords have arg.is_some()
@@ -6458,9 +6452,9 @@ impl Compiler {
             let nargs = positional
                 .checked_add(keyword_count)
                 .expect("too many arguments");
-            emit!(self, RealInstruction::CallKw { nargs });
+            emit!(self, Instruction::CallKw { nargs });
         } else {
-            emit!(self, RealInstruction::Call { nargs: count });
+            emit!(self, Instruction::Call { nargs: count });
         }
 
         Ok(())
@@ -6479,7 +6473,7 @@ impl Compiler {
 
             loop {
                 if iter.peek().is_none_or(|e| matches!(e, Expr::Starred(_))) {
-                    emit!(self, RealInstruction::BuildTuple { size: run_size });
+                    emit!(self, Instruction::BuildTuple { size: run_size });
                     run_size = 0;
                     size += 1;
                 }
@@ -6491,7 +6485,7 @@ impl Compiler {
                         // tuple, since any side-effects during the conversion
                         // should be made visible before evaluating remaining
                         // expressions.
-                        emit!(self, RealInstruction::BuildTupleFromIter);
+                        emit!(self, Instruction::BuildTupleFromIter);
                         size += 1;
                     }
                     Some(element) => {
@@ -6528,7 +6522,7 @@ impl Compiler {
     fn compile_comprehension(
         &mut self,
         name: &str,
-        init_collection: Option<Instruction>,
+        init_collection: Option<AnyInstruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         comprehension_type: ComprehensionType,
@@ -6622,23 +6616,23 @@ impl Compiler {
 
             if loop_labels.is_empty() {
                 // Load iterator onto stack (passed as first argument):
-                emit!(self, RealInstruction::LoadFast(arg0));
+                emit!(self, Instruction::LoadFast(arg0));
             } else {
                 // Evaluate iterated item:
                 self.compile_expression(&generator.iter)?;
 
                 // Get iterator / turn item into an iterator
                 if generator.is_async {
-                    emit!(self, RealInstruction::GetAIter);
+                    emit!(self, Instruction::GetAIter);
                 } else {
-                    emit!(self, RealInstruction::GetIter);
+                    emit!(self, Instruction::GetIter);
                 }
             }
 
             loop_labels.push((loop_block, after_block, generator.is_async));
             self.switch_to_block(loop_block);
             if generator.is_async {
-                emit!(self, RealInstruction::GetANext);
+                emit!(self, Instruction::GetANext);
 
                 let current_depth = (init_collection.is_some() as u32)
                     + u32::try_from(loop_labels.len()).unwrap()
@@ -6658,7 +6652,7 @@ impl Compiler {
             } else {
                 emit!(
                     self,
-                    RealInstruction::ForIter {
+                    Instruction::ForIter {
                         target: after_block,
                     }
                 );
@@ -6678,8 +6672,8 @@ impl Compiler {
 
             self.switch_to_block(after_block);
             if is_async {
-                emit!(self, RealInstruction::EndAsyncFor);
-                emit!(self, RealInstruction::PopTop);
+                emit!(self, Instruction::EndAsyncFor);
+                emit!(self, Instruction::PopTop);
             }
         }
 
@@ -6695,7 +6689,7 @@ impl Compiler {
 
         // Create comprehension function with closure
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
-        emit!(self, RealInstruction::PushNull);
+        emit!(self, Instruction::PushNull);
 
         // Evaluate iterated item:
         self.compile_expression(&generators[0].iter)?;
@@ -6703,15 +6697,15 @@ impl Compiler {
         // Get iterator / turn item into an iterator
         // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
         if generators[0].is_async {
-            emit!(self, RealInstruction::GetAIter);
+            emit!(self, Instruction::GetAIter);
         } else {
-            emit!(self, RealInstruction::GetIter);
+            emit!(self, Instruction::GetIter);
         };
 
         // Call just created <listcomp> function:
-        emit!(self, RealInstruction::Call { nargs: 1 });
+        emit!(self, Instruction::Call { nargs: 1 });
         if is_async_list_set_dict_comprehension {
-            emit!(self, RealInstruction::GetAwaitable);
+            emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
             self.compile_yield_from_sequence(true)?;
         }
@@ -6751,7 +6745,7 @@ impl Compiler {
     /// This generates bytecode inline without creating a new code object
     fn compile_inlined_comprehension(
         &mut self,
-        init_collection: Option<Instruction>,
+        init_collection: Option<AnyInstruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         _has_an_async_gen: bool,
@@ -6777,22 +6771,22 @@ impl Compiler {
         self.compile_expression(&generators[0].iter)?;
         // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
         if generators[0].is_async {
-            emit!(self, RealInstruction::GetAIter);
+            emit!(self, Instruction::GetAIter);
         } else {
-            emit!(self, RealInstruction::GetIter);
+            emit!(self, Instruction::GetIter);
         }
 
         // Step 2: Save local variables that will be shadowed by the comprehension
         for name in &pushed_locals {
             let idx = self.varname(name)?;
-            emit!(self, RealInstruction::LoadFastAndClear(idx));
+            emit!(self, Instruction::LoadFastAndClear(idx));
         }
 
         // Step 3: SWAP iterator to TOS (above saved locals)
         if !pushed_locals.is_empty() {
             emit!(
                 self,
-                RealInstruction::Swap {
+                Instruction::Swap {
                     index: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
@@ -6803,7 +6797,7 @@ impl Compiler {
         if let Some(init_collection) = init_collection {
             self._emit(init_collection, OpArg(0), BlockIdx::NULL);
             // SWAP to get iterator on top
-            emit!(self, RealInstruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { index: 2 });
         }
 
         // Set up exception handler for cleanup on exception
@@ -6837,9 +6831,9 @@ impl Compiler {
                 // For nested loops, compile the iterator expression
                 self.compile_expression(&generator.iter)?;
                 if generator.is_async {
-                    emit!(self, RealInstruction::GetAIter);
+                    emit!(self, Instruction::GetAIter);
                 } else {
-                    emit!(self, RealInstruction::GetIter);
+                    emit!(self, Instruction::GetIter);
                 }
             }
 
@@ -6847,14 +6841,14 @@ impl Compiler {
             self.switch_to_block(loop_block);
 
             if generator.is_async {
-                emit!(self, RealInstruction::GetANext);
+                emit!(self, Instruction::GetANext);
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(true)?;
                 self.compile_store(&generator.target)?;
             } else {
                 emit!(
                     self,
-                    RealInstruction::ForIter {
+                    Instruction::ForIter {
                         target: after_block,
                     }
                 );
@@ -6875,10 +6869,10 @@ impl Compiler {
             emit!(self, PseudoInstruction::Jump { target: loop_block });
             self.switch_to_block(after_block);
             if is_async {
-                emit!(self, RealInstruction::EndAsyncFor);
+                emit!(self, Instruction::EndAsyncFor);
             }
             // Pop the iterator
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
         }
 
         // Step 8: Clean up - restore saved locals
@@ -6892,24 +6886,24 @@ impl Compiler {
             self.switch_to_block(cleanup_block);
             // Stack: [saved_locals..., collection, exception]
             // Swap to get collection out from under exception
-            emit!(self, RealInstruction::Swap { index: 2 });
-            emit!(self, RealInstruction::PopTop); // Pop incomplete collection
+            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::PopTop); // Pop incomplete collection
 
             // Restore locals
             emit!(
                 self,
-                RealInstruction::Swap {
+                Instruction::Swap {
                     index: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
             for name in pushed_locals.iter().rev() {
                 let idx = self.varname(name)?;
-                emit!(self, RealInstruction::StoreFast(idx));
+                emit!(self, Instruction::StoreFast(idx));
             }
             // Re-raise the exception
             emit!(
                 self,
-                RealInstruction::RaiseVarargs {
+                Instruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack
                 }
             );
@@ -6922,7 +6916,7 @@ impl Compiler {
         if !pushed_locals.is_empty() {
             emit!(
                 self,
-                RealInstruction::Swap {
+                Instruction::Swap {
                     index: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
@@ -6931,7 +6925,7 @@ impl Compiler {
         // Restore saved locals
         for name in pushed_locals.iter().rev() {
             let idx = self.varname(name)?;
-            emit!(self, RealInstruction::StoreFast(idx));
+            emit!(self, Instruction::StoreFast(idx));
         }
 
         Ok(())
@@ -6959,7 +6953,7 @@ impl Compiler {
     }
 
     // Low level helper functions:
-    fn _emit<I: Into<Instruction>>(&mut self, instr: I, arg: OpArg, target: BlockIdx) {
+    fn _emit<I: Into<AnyInstruction>>(&mut self, instr: I, arg: OpArg, target: BlockIdx) {
         let range = self.current_source_range;
         let source = self.source_file.to_source_code();
         let location = source.source_location(range.start(), PositionEncoding::Utf8);
@@ -6975,11 +6969,11 @@ impl Compiler {
         });
     }
 
-    fn emit_no_arg<I: Into<Instruction>>(&mut self, ins: I) {
+    fn emit_no_arg<I: Into<AnyInstruction>>(&mut self, ins: I) {
         self._emit(ins, OpArg::null(), BlockIdx::NULL)
     }
 
-    fn emit_arg<A: OpArgType, T: EmitArg<A>, I: Into<Instruction>>(
+    fn emit_arg<A: OpArgType, T: EmitArg<A>, I: Into<AnyInstruction>>(
         &mut self,
         arg: T,
         f: impl FnOnce(OpArgMarker<A>) -> I,
@@ -6997,22 +6991,22 @@ impl Compiler {
 
     fn emit_load_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| RealInstruction::LoadConst { idx })
+        self.emit_arg(idx, |idx| Instruction::LoadConst { idx })
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| RealInstruction::ReturnConst { idx })
+        self.emit_arg(idx, |idx| Instruction::ReturnConst { idx })
     }
 
     fn emit_return_value(&mut self) {
         if let Some(inst) = self.current_block().instructions.last_mut()
-            && let Instruction::Real(RealInstruction::LoadConst { idx }) = inst.instr
+            && let AnyInstruction::Real(Instruction::LoadConst { idx }) = inst.instr
         {
-            inst.instr = RealInstruction::ReturnConst { idx }.into();
+            inst.instr = Instruction::ReturnConst { idx }.into();
             return;
         }
-        emit!(self, RealInstruction::ReturnValue)
+        emit!(self, Instruction::ReturnValue)
     }
 
     fn current_code_info(&mut self) -> &mut ir::CodeInfo {
@@ -7125,22 +7119,22 @@ impl Compiler {
             match action {
                 UnwindAction::With { is_async } => {
                     // compiler_call_exit_with_nones
-                    emit!(self, RealInstruction::PushNull);
+                    emit!(self, Instruction::PushNull);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
-                    emit!(self, RealInstruction::Call { nargs: 3 });
+                    emit!(self, Instruction::Call { nargs: 3 });
 
                     if is_async {
-                        emit!(self, RealInstruction::GetAwaitable);
+                        emit!(self, Instruction::GetAwaitable);
                         self.emit_load_const(ConstantData::None);
                         self.compile_yield_from_sequence(true)?;
                     }
 
-                    emit!(self, RealInstruction::PopTop);
+                    emit!(self, Instruction::PopTop);
                 }
                 UnwindAction::HandlerCleanup => {
-                    emit!(self, RealInstruction::PopExcept);
+                    emit!(self, Instruction::PopExcept);
                 }
                 UnwindAction::FinallyTry { body, fblock_idx } => {
                     // compile finally body inline
@@ -7160,26 +7154,26 @@ impl Compiler {
                     // Stack when in FinallyEnd: [..., prev_exc, exc]
                     // Note: No lasti here - it's only pushed for cleanup handler exceptions
                     // We need to pop: exc, prev_exc (via PopExcept)
-                    emit!(self, RealInstruction::PopTop); // exc
-                    emit!(self, RealInstruction::PopExcept); // prev_exc is restored
+                    emit!(self, Instruction::PopTop); // exc
+                    emit!(self, Instruction::PopExcept); // prev_exc is restored
                 }
                 UnwindAction::PopValue => {
                     // Pop the return value - continue/break cancels the pending return
-                    emit!(self, RealInstruction::PopTop);
+                    emit!(self, Instruction::PopTop);
                 }
             }
         }
 
         // For break in a for loop, pop the iterator
         if is_break && is_for_loop {
-            emit!(self, RealInstruction::PopTop);
+            emit!(self, Instruction::PopTop);
         }
 
         // Jump to target
         if is_break {
-            emit!(self, RealInstruction::Break { target: exit_block });
+            emit!(self, Instruction::Break { target: exit_block });
         } else {
-            emit!(self, RealInstruction::Continue { target: loop_block });
+            emit!(self, Instruction::Continue { target: loop_block });
         }
 
         Ok(())
@@ -7330,7 +7324,7 @@ impl Compiler {
             .try_into()
             .expect("BuildString size overflowed");
         if part_count > 1 {
-            emit!(self, RealInstruction::BuildString { size: part_count });
+            emit!(self, Instruction::BuildString { size: part_count });
         }
 
         Ok(())
@@ -7421,7 +7415,7 @@ impl Compiler {
                         ConvertValueOparg::Str
                         | ConvertValueOparg::Repr
                         | ConvertValueOparg::Ascii => {
-                            emit!(self, RealInstruction::ConvertValue { oparg: conversion })
+                            emit!(self, Instruction::ConvertValue { oparg: conversion })
                         }
                     }
 
@@ -7429,10 +7423,10 @@ impl Compiler {
                         Some(format_spec) => {
                             self.compile_fstring_elements(flags, &format_spec.elements)?;
 
-                            emit!(self, RealInstruction::FormatWithSpec);
+                            emit!(self, Instruction::FormatWithSpec);
                         }
                         None => {
-                            emit!(self, RealInstruction::FormatSimple);
+                            emit!(self, Instruction::FormatSimple);
                         }
                     }
                 }
@@ -7447,7 +7441,7 @@ impl Compiler {
         } else if element_count > 1 {
             emit!(
                 self,
-                RealInstruction::BuildString {
+                Instruction::BuildString {
                     size: element_count
                 }
             );
@@ -7458,27 +7452,27 @@ impl Compiler {
 }
 
 trait EmitArg<Arg: OpArgType> {
-    fn emit<I: Into<Instruction>>(
+    fn emit<I: Into<AnyInstruction>>(
         self,
         f: impl FnOnce(OpArgMarker<Arg>) -> I,
-    ) -> (Instruction, OpArg, BlockIdx);
+    ) -> (AnyInstruction, OpArg, BlockIdx);
 }
 
 impl<T: OpArgType> EmitArg<T> for T {
-    fn emit<I: Into<Instruction>>(
+    fn emit<I: Into<AnyInstruction>>(
         self,
         f: impl FnOnce(OpArgMarker<T>) -> I,
-    ) -> (Instruction, OpArg, BlockIdx) {
+    ) -> (AnyInstruction, OpArg, BlockIdx) {
         let (marker, arg) = OpArgMarker::new(self);
         (f(marker).into(), arg, BlockIdx::NULL)
     }
 }
 
 impl EmitArg<bytecode::Label> for BlockIdx {
-    fn emit<I: Into<Instruction>>(
+    fn emit<I: Into<AnyInstruction>>(
         self,
         f: impl FnOnce(OpArgMarker<bytecode::Label>) -> I,
-    ) -> (Instruction, OpArg, BlockIdx) {
+    ) -> (AnyInstruction, OpArg, BlockIdx) {
         (f(OpArgMarker::marker()).into(), OpArg::null(), self)
     }
 }
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 9ca7a5fc184..8935f2063c3 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -5,9 +5,9 @@ use crate::{IndexMap, IndexSet, error::InternalError};
 use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
-        Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
-        InstrDisplayContext, Instruction, InstructionMetadata, Label, OpArg, PseudoInstruction,
-        PyCodeLocationInfoKind, RealInstruction, encode_exception_table, encode_load_attr_arg,
+        AnyInstruction, Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData,
+        ExceptionTableEntry, InstrDisplayContext, Instruction, InstructionMetadata, Label, OpArg,
+        PseudoInstruction, PyCodeLocationInfoKind, encode_exception_table, encode_load_attr_arg,
         encode_load_super_attr_arg,
     },
     varint::{write_signed_varint, write_varint},
@@ -87,7 +87,7 @@ impl ops::IndexMut<BlockIdx> for Vec<Block> {
 
 #[derive(Debug, Clone)]
 pub struct InstructionInfo {
-    pub instr: Instruction,
+    pub instr: AnyInstruction,
     pub arg: OpArg,
     pub target: BlockIdx,
     pub location: SourceLocation,
@@ -198,24 +198,23 @@ impl CodeInfo {
         {
             for info in &mut block.instructions {
                 // Special case for:
-                // - `RealInstruction::LoadAttr`
-                // - `RealInstruction::LoadSuperAttr`
+                // - `Instruction::LoadAttr`
+                // - `Instruction::LoadSuperAttr`
 
                 if let Some(instr) = info.instr.real() {
                     match instr {
                         // LOAD_ATTR → encode with method flag=0
-                        RealInstruction::LoadAttr { idx } => {
+                        Instruction::LoadAttr { idx } => {
                             let encoded = encode_load_attr_arg(idx.get(info.arg), false);
                             info.arg = OpArg(encoded);
-                            info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
+                            info.instr = Instruction::LoadAttr { idx: Arg::marker() }.into();
                         }
                         // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
-                        RealInstruction::LoadSuperAttr { arg: idx } => {
+                        Instruction::LoadSuperAttr { arg: idx } => {
                             let encoded =
                                 encode_load_super_attr_arg(idx.get(info.arg), false, true);
                             info.arg = OpArg(encoded);
-                            info.instr =
-                                RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                            info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                         }
                         _ => {}
                     }
@@ -230,29 +229,29 @@ impl CodeInfo {
                     PseudoInstruction::LoadAttrMethod { idx } => {
                         let encoded = encode_load_attr_arg(idx.get(info.arg), true);
                         info.arg = OpArg(encoded);
-                        info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
+                        info.instr = Instruction::LoadAttr { idx: Arg::marker() }.into();
                     }
                     // POP_BLOCK pseudo → NOP
                     PseudoInstruction::PopBlock => {
-                        info.instr = RealInstruction::Nop.into();
+                        info.instr = Instruction::Nop.into();
                     }
                     // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
                     PseudoInstruction::LoadSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
                         info.arg = OpArg(encoded);
-                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_ATTR pseudo → LOAD_SUPER_ATTR (flags=0b00: method=0, class=0)
                     PseudoInstruction::LoadZeroSuperAttr { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, false);
                         info.arg = OpArg(encoded);
-                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b01: method=1, class=0)
                     PseudoInstruction::LoadZeroSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, false);
                         info.arg = OpArg(encoded);
-                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     PseudoInstruction::Jump { .. } => {
                         // PseudoInstruction::Jump instructions are handled later
@@ -305,16 +304,16 @@ impl CodeInfo {
 
                     // Convert JUMP pseudo to real instructions (direction depends on offset)
                     let op = match info.instr {
-                        Instruction::Pseudo(PseudoInstruction::Jump { .. })
+                        AnyInstruction::Pseudo(PseudoInstruction::Jump { .. })
                             if target != BlockIdx::NULL =>
                         {
                             let target_offset = block_to_offset[target.idx()].0;
                             if target_offset > current_offset {
-                                RealInstruction::JumpForward {
+                                Instruction::JumpForward {
                                     target: Arg::marker(),
                                 }
                             } else {
-                                RealInstruction::JumpBackward {
+                                Instruction::JumpBackward {
                                     target: Arg::marker(),
                                 }
                             }
@@ -329,7 +328,7 @@ impl CodeInfo {
                     ));
                     instructions.extend(
                         extras
-                            .map(|byte| CodeUnit::new(RealInstruction::ExtendedArg, byte))
+                            .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
                             .chain([CodeUnit { op, arg: lo_arg }]),
                     );
                     current_offset += info.arg.instr_size() as u32;
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index f2d7fd2938d..a0054b28877 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -16,7 +16,7 @@ use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
 pub use crate::bytecode::{
     instruction::{
-        Arg, Instruction, InstructionMetadata, PseudoInstruction, RealInstruction,
+        AnyInstruction, Arg, Instruction, InstructionMetadata, PseudoInstruction,
         decode_load_attr_arg, decode_load_super_attr_arg, encode_load_attr_arg,
         encode_load_super_attr_arg,
     },
@@ -303,14 +303,14 @@ bitflags! {
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct CodeUnit {
-    pub op: RealInstruction,
+    pub op: Instruction,
     pub arg: OpArgByte,
 }
 
 const _: () = assert!(mem::size_of::<CodeUnit>() == 2);
 
 impl CodeUnit {
-    pub const fn new(op: RealInstruction, arg: OpArgByte) -> Self {
+    pub const fn new(op: Instruction, arg: OpArgByte) -> Self {
         Self { op, arg }
     }
 }
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 07db43dbe06..a3f53082655 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -12,11 +12,15 @@ use crate::{
     marshal::MarshalError,
 };
 
-/// A Single bytecode instruction.
-/// All instructions above 44 have an argument.
+/// A Single bytecode instruction that are executed by the VM.
+///
+/// Currently aligned with CPython 3.13.
+///
+/// ## See also
+/// - [CPython opcode IDs](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Include/opcode_ids.h)
 #[derive(Clone, Copy, Debug)]
 #[repr(u8)]
-pub enum RealInstruction {
+pub enum Instruction {
     // ==================== No-argument instructions (opcode < 44) ====================
     Cache = 0, // Placeholder
     BeforeAsyncWith = 1,
@@ -275,20 +279,21 @@ pub enum RealInstruction {
     JumpIfNotExcMatch(Arg<Label>) = 131,
     SetExcInfo = 134,
     Subscript = 135,
+    // Pseudos (needs to be moved to `PseudoInstruction` enum.
     LoadClosure(Arg<NameIdx>) = 253, // TODO: Move to pseudos
 }
 
-const _: () = assert!(mem::size_of::<RealInstruction>() == 1);
+const _: () = assert!(mem::size_of::<Instruction>() == 1);
 
-impl From<RealInstruction> for u8 {
+impl From<Instruction> for u8 {
     #[inline]
-    fn from(ins: RealInstruction) -> Self {
+    fn from(ins: Instruction) -> Self {
         // SAFETY: there's no padding bits
-        unsafe { core::mem::transmute::<RealInstruction, Self>(ins) }
+        unsafe { mem::transmute::<Instruction, Self>(ins) }
     }
 }
 
-impl TryFrom<u8> for RealInstruction {
+impl TryFrom<u8> for Instruction {
     type Error = MarshalError;
 
     #[inline]
@@ -341,14 +346,14 @@ impl TryFrom<u8> for RealInstruction {
             || value == load_closure
             || custom_ops.contains(&value)
         {
-            Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
+            Ok(unsafe { mem::transmute::<u8, Self>(value) })
         } else {
             Err(Self::Error::InvalidBytecode)
         }
     }
 }
 
-impl InstructionMetadata for RealInstruction {
+impl InstructionMetadata for Instruction {
     #[inline]
     fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
@@ -783,6 +788,7 @@ impl InstructionMetadata for RealInstruction {
     }
 }
 
+/// Instructions used by the compiler. They are not executed by the VM.
 #[derive(Clone, Copy, Debug)]
 #[repr(u16)]
 pub enum PseudoInstruction {
@@ -821,7 +827,7 @@ impl From<PseudoInstruction> for u16 {
     #[inline]
     fn from(ins: PseudoInstruction) -> Self {
         // SAFETY: there's no padding bits
-        unsafe { core::mem::transmute::<PseudoInstruction, Self>(ins) }
+        unsafe { mem::transmute::<PseudoInstruction, Self>(ins) }
     }
 }
 
@@ -836,7 +842,7 @@ impl TryFrom<u16> for PseudoInstruction {
         let end = u16::from(Self::StoreFastMaybeNull);
 
         if (start..=end).contains(&value) {
-            Ok(unsafe { core::mem::transmute::<u16, Self>(value) })
+            Ok(unsafe { mem::transmute::<u16, Self>(value) })
         } else {
             Err(Self::Error::InvalidBytecode)
         }
@@ -886,32 +892,32 @@ impl InstructionMetadata for PseudoInstruction {
 }
 
 #[derive(Clone, Copy, Debug)]
-pub enum Instruction {
-    Real(RealInstruction),
+pub enum AnyInstruction {
+    Real(Instruction),
     Pseudo(PseudoInstruction),
 }
 
-impl From<RealInstruction> for Instruction {
-    fn from(value: RealInstruction) -> Self {
+impl From<Instruction> for AnyInstruction {
+    fn from(value: Instruction) -> Self {
         Self::Real(value)
     }
 }
 
-impl From<PseudoInstruction> for Instruction {
+impl From<PseudoInstruction> for AnyInstruction {
     fn from(value: PseudoInstruction) -> Self {
         Self::Pseudo(value)
     }
 }
 
-impl TryFrom<u8> for Instruction {
+impl TryFrom<u8> for AnyInstruction {
     type Error = MarshalError;
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
-        Ok(RealInstruction::try_from(value)?.into())
+        Ok(Instruction::try_from(value)?.into())
     }
 }
 
-impl TryFrom<u16> for Instruction {
+impl TryFrom<u16> for AnyInstruction {
     type Error = MarshalError;
 
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -933,7 +939,7 @@ macro_rules! inst_either {
     };
 }
 
-impl InstructionMetadata for Instruction {
+impl InstructionMetadata for AnyInstruction {
     inst_either!(fn label_arg(&self) -> Option<Arg<Label>>);
 
     inst_either!(fn unconditional_branch(&self) -> bool);
@@ -951,9 +957,9 @@ impl InstructionMetadata for Instruction {
     ) -> fmt::Result);
 }
 
-impl Instruction {
+impl AnyInstruction {
     /// Gets the inner value of [`Self::Real`].
-    pub const fn real(self) -> Option<RealInstruction> {
+    pub const fn real(self) -> Option<Instruction> {
         match self {
             Self::Real(ins) => Some(ins),
             _ => None,
@@ -973,7 +979,7 @@ impl Instruction {
     /// # Panics
     ///
     /// If was called on something else other than [`Self::Real`].
-    pub const fn expect_real(self) -> RealInstruction {
+    pub const fn expect_real(self) -> Instruction {
         self.real()
             .expect("Expected Instruction::Real, found Instruction::Pseudo")
     }
@@ -998,8 +1004,8 @@ pub trait InstructionMetadata {
     /// # Examples
     ///
     /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, InstructionMetadata};
-    /// let jump_inst = RealInstruction::JumpForward { target: Arg::marker() };
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, InstructionMetadata};
+    /// let jump_inst = Instruction::JumpForward { target: Arg::marker() };
     /// assert!(jump_inst.unconditional_branch())
     /// ```
     fn unconditional_branch(&self) -> bool;
@@ -1009,9 +1015,9 @@ pub trait InstructionMetadata {
     /// # Examples
     ///
     /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, RealInstruction, Label, InstructionMetadata};
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label, InstructionMetadata};
     /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = RealInstruction::JumpForward { target };
+    /// let jump_instruction = Instruction::JumpForward { target };
     /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
     /// ```
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;
diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index 2d15704028d..c662a0a9260 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -2,7 +2,7 @@ use bitflags::bitflags;
 
 use core::{fmt, num::NonZeroU8};
 
-use crate::bytecode::{CodeUnit, instruction::RealInstruction};
+use crate::bytecode::{CodeUnit, instruction::Instruction};
 
 pub trait OpArgType: Copy {
     fn from_op_arg(x: u32) -> Option<Self>;
@@ -78,9 +78,9 @@ pub struct OpArgState {
 
 impl OpArgState {
     #[inline(always)]
-    pub fn get(&mut self, ins: CodeUnit) -> (RealInstruction, OpArg) {
+    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
         let arg = self.extend(ins.arg);
-        if !matches!(ins.op, RealInstruction::ExtendedArg) {
+        if !matches!(ins.op, Instruction::ExtendedArg) {
             self.reset();
         }
         (ins.op, arg)
@@ -98,7 +98,7 @@ impl OpArgState {
     }
 }
 
-/// Oparg values for [`RealInstruction::ConvertValue`].
+/// Oparg values for [`Instruction::ConvertValue`].
 ///
 /// ## See also
 ///
@@ -142,7 +142,7 @@ impl fmt::Display for ConvertValueOparg {
             Self::Str => "1 (str)",
             Self::Repr => "2 (repr)",
             Self::Ascii => "3 (ascii)",
-            // We should never reach this. `FVC_NONE` are being handled by `RealInstruction::FormatSimple`
+            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
             Self::None => "",
         };
 
@@ -364,9 +364,9 @@ op_arg_enum!(
     /// # Examples
     ///
     /// ```rust
-    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, RealInstruction};
+    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
     /// let (op, _) = Arg::new(BinaryOperator::Add);
-    /// let instruction = RealInstruction::BinaryOp { op };
+    /// let instruction = Instruction::BinaryOp { op };
     /// ```
     ///
     /// See also:
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index e3d0b244914..64cbb2fd062 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -4,8 +4,8 @@ use cranelift::codegen::ir::FuncRef;
 use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_compiler_core::bytecode::{
-    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, IntrinsicFunction1,
-    Label, OpArg, OpArgState, RealInstruction,
+    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction,
+    IntrinsicFunction1, Label, OpArg, OpArgState,
 };
 use std::collections::HashMap;
 
@@ -210,11 +210,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
             // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
-                RealInstruction::ReturnValue
-                | RealInstruction::ReturnConst { .. }
-                | RealInstruction::JumpBackward { .. }
-                | RealInstruction::JumpBackwardNoInterrupt { .. }
-                | RealInstruction::JumpForward { .. } => {
+                Instruction::ReturnValue
+                | Instruction::ReturnConst { .. }
+                | Instruction::JumpBackward { .. }
+                | Instruction::JumpBackwardNoInterrupt { .. }
+                | Instruction::JumpForward { .. } => {
                     in_unreachable_code = true;
                 }
                 _ => {}
@@ -289,11 +289,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         &mut self,
         func_ref: FuncRef,
         bytecode: &CodeObject<C>,
-        instruction: RealInstruction,
+        instruction: Instruction,
         arg: OpArg,
     ) -> Result<(), JitCompileError> {
         match instruction {
-            RealInstruction::BinaryOp { op } => {
+            Instruction::BinaryOp { op } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -454,12 +454,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            RealInstruction::BuildTuple { size } => {
+            Instruction::BuildTuple { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize);
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            RealInstruction::Call { nargs } => {
+            Instruction::Call { nargs } => {
                 let nargs = nargs.get(arg);
 
                 let mut args = Vec::new();
@@ -485,11 +485,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
-            RealInstruction::PushNull => {
+            Instruction::PushNull => {
                 self.stack.push(JitValue::Null);
                 Ok(())
             }
-            RealInstruction::CallIntrinsic1 { func } => {
+            Instruction::CallIntrinsic1 { func } => {
                 match func.get(arg) {
                     IntrinsicFunction1::UnaryPositive => {
                         match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
@@ -504,7 +504,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            RealInstruction::CompareOp { op, .. } => {
+            Instruction::CompareOp { op, .. } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -558,22 +558,22 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            RealInstruction::ExtendedArg => Ok(()),
+            Instruction::ExtendedArg => Ok(()),
 
-            RealInstruction::JumpBackward { target }
-            | RealInstruction::JumpBackwardNoInterrupt { target }
-            | RealInstruction::JumpForward { target } => {
+            Instruction::JumpBackward { target }
+            | Instruction::JumpBackwardNoInterrupt { target }
+            | Instruction::JumpForward { target } => {
                 let target_block = self.get_or_create_block(target.get(arg));
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
             }
-            RealInstruction::LoadConst { idx } => {
+            Instruction::LoadConst { idx } => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.stack.push(val);
                 Ok(())
             }
-            RealInstruction::LoadFast(idx) => {
+            Instruction::LoadFast(idx) => {
                 let local = self.variables[idx.get(arg) as usize]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
@@ -583,7 +583,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 ));
                 Ok(())
             }
-            RealInstruction::LoadGlobal(idx) => {
+            Instruction::LoadGlobal(idx) => {
                 let name = &bytecode.names[idx.get(arg) as usize];
 
                 if name.as_ref() != bytecode.obj_name.as_ref() {
@@ -593,8 +593,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     Ok(())
                 }
             }
-            RealInstruction::Nop => Ok(()),
-            RealInstruction::PopJumpIfFalse { target } => {
+            Instruction::Nop => Ok(()),
+            Instruction::PopJumpIfFalse { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -607,7 +607,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            RealInstruction::PopJumpIfTrue { target } => {
+            Instruction::PopJumpIfTrue { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -620,41 +620,41 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            RealInstruction::PopTop => {
+            Instruction::PopTop => {
                 self.stack.pop();
                 Ok(())
             }
-            RealInstruction::Resume { arg: _resume_arg } => {
+            Instruction::Resume { arg: _resume_arg } => {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
-            RealInstruction::ReturnConst { idx } => {
+            Instruction::ReturnConst { idx } => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.return_value(val)
             }
-            RealInstruction::ReturnValue => {
+            Instruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            RealInstruction::StoreFast(idx) => {
+            Instruction::StoreFast(idx) => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.store_variable(idx.get(arg), val)
             }
-            RealInstruction::Swap { index } => {
+            Instruction::Swap { index } => {
                 let len = self.stack.len();
                 let i = len - 1;
                 let j = len - 1 - index.get(arg) as usize;
                 self.stack.swap(i, j);
                 Ok(())
             }
-            RealInstruction::ToBool => {
+            Instruction::ToBool => {
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let value = self.boolean_val(a)?;
                 self.stack.push(JitValue::Bool(value));
                 Ok(())
             }
-            RealInstruction::UnaryNot => {
+            Instruction::UnaryNot => {
                 let boolean = match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::Bool(val) => val,
                     _ => return Err(JitCompileError::BadBytecode),
@@ -663,7 +663,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.push(JitValue::Bool(not_boolean));
                 Ok(())
             }
-            RealInstruction::UnaryNegative => {
+            Instruction::UnaryNegative => {
                 match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::Int(val) => {
                         // Compile minus as 0 - val.
@@ -675,7 +675,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            RealInstruction::UnpackSequence { size } => {
+            Instruction::UnpackSequence { size } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
 
                 let elements = match val {
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 51648b4929a..eabf27471b9 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -1,6 +1,6 @@
 use core::ops::ControlFlow;
 use rustpython_compiler_core::bytecode::{
-    CodeObject, ConstantData, OpArg, OpArgState, RealInstruction,
+    CodeObject, ConstantData, Instruction, OpArg, OpArgState,
 };
 use rustpython_jit::{CompiledCode, JitType};
 use std::collections::HashMap;
@@ -86,30 +86,30 @@ impl StackMachine {
 
     fn process_instruction(
         &mut self,
-        instruction: RealInstruction,
+        instruction: Instruction,
         arg: OpArg,
         constants: &[ConstantData],
         names: &[String],
     ) -> ControlFlow<()> {
         match instruction {
-            RealInstruction::LoadConst { idx } => {
+            Instruction::LoadConst { idx } => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
-            RealInstruction::LoadName(idx) => self
+            Instruction::LoadName(idx) => self
                 .stack
                 .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            RealInstruction::StoreName(idx) => {
+            Instruction::StoreName(idx) => {
                 let idx = idx.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
-            RealInstruction::StoreAttr { .. } => {
+            Instruction::StoreAttr { .. } => {
                 // Do nothing except throw away the stack values
                 self.stack.pop().unwrap();
                 self.stack.pop().unwrap();
             }
-            RealInstruction::BuildMap { size, .. } => {
+            Instruction::BuildMap { size, .. } => {
                 let mut map = HashMap::new();
                 for _ in 0..size.get(arg) {
                     let value = self.stack.pop().unwrap();
@@ -122,7 +122,7 @@ impl StackMachine {
                 }
                 self.stack.push(StackValue::Map(map));
             }
-            RealInstruction::MakeFunction => {
+            Instruction::MakeFunction => {
                 let code = if let Some(StackValue::Code(code)) = self.stack.pop() {
                     code
                 } else {
@@ -134,7 +134,7 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
-            RealInstruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute { attr } => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
                     func
@@ -164,13 +164,13 @@ impl StackMachine {
                     self.stack.push(StackValue::Function(func));
                 }
             }
-            RealInstruction::ReturnConst { idx } => {
+            Instruction::ReturnConst { idx } => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into());
                 return ControlFlow::Break(());
             }
-            RealInstruction::ReturnValue => return ControlFlow::Break(()),
-            RealInstruction::ExtendedArg => {}
+            Instruction::ReturnValue => return ControlFlow::Break(()),
+            Instruction::ExtendedArg => {}
             _ => unimplemented!(
                 "instruction {:?} isn't yet supported in py_function!",
                 instruction
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index d2e0f0ad45f..fcde0de36ef 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -5,15 +5,15 @@ mod opcode {
     use crate::vm::{
         AsObject, PyObjectRef, PyResult, VirtualMachine,
         builtins::{PyInt, PyIntRef},
-        bytecode::{Instruction, InstructionMetadata, PseudoInstruction, RealInstruction},
+        bytecode::{AnyInstruction, Instruction, InstructionMetadata, PseudoInstruction},
     };
     use core::ops::Deref;
 
     #[derive(Clone, Copy)]
-    struct Opcode(Instruction);
+    struct Opcode(AnyInstruction);
 
     impl Deref for Opcode {
-        type Target = Instruction;
+        type Target = AnyInstruction;
 
         fn deref(&self) -> &Self::Target {
             &self.0
@@ -41,7 +41,7 @@ mod opcode {
             let instruction = raw
                 .try_to_primitive::<u16>(vm)
                 .and_then(|v| {
-                    Instruction::try_from(v).map_err(|_| {
+                    AnyInstruction::try_from(v).map_err(|_| {
                         vm.new_exception_empty(vm.ctx.exceptions.value_error.to_owned())
                     })
                 })
@@ -50,11 +50,11 @@ mod opcode {
             Ok(Self(instruction))
         }
 
-        const fn inner(self) -> Instruction {
+        const fn inner(self) -> AnyInstruction {
             self.0
         }
 
-        /// Check if opcode is valid (can be converted to an Instruction)
+        /// Check if opcode is valid (can be converted to an AnyInstruction)
         #[must_use]
         pub fn is_valid(opcode: i32) -> bool {
             Self::try_from(opcode).is_ok()
@@ -71,8 +71,8 @@ mod opcode {
         pub fn has_const(opcode: i32) -> bool {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
-                Ok(Instruction::Real(
-                    RealInstruction::LoadConst { .. } | RealInstruction::ReturnConst { .. }
+                Ok(AnyInstruction::Real(
+                    Instruction::LoadConst { .. } | Instruction::ReturnConst { .. }
                 ))
             )
         }
@@ -82,19 +82,19 @@ mod opcode {
         pub fn has_name(opcode: i32) -> bool {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
-                Ok(Instruction::Real(
-                    RealInstruction::DeleteAttr { .. }
-                        | RealInstruction::DeleteGlobal(_)
-                        | RealInstruction::DeleteName(_)
-                        | RealInstruction::ImportFrom { .. }
-                        | RealInstruction::ImportName { .. }
-                        | RealInstruction::LoadAttr { .. }
-                        | RealInstruction::LoadGlobal(_)
-                        | RealInstruction::LoadName(_)
-                        | RealInstruction::StoreAttr { .. }
-                        | RealInstruction::StoreGlobal(_)
-                        | RealInstruction::StoreName(_)
-                ) | Instruction::Pseudo(PseudoInstruction::LoadAttrMethod { .. }))
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteAttr { .. }
+                        | Instruction::DeleteGlobal(_)
+                        | Instruction::DeleteName(_)
+                        | Instruction::ImportFrom { .. }
+                        | Instruction::ImportName { .. }
+                        | Instruction::LoadAttr { .. }
+                        | Instruction::LoadGlobal(_)
+                        | Instruction::LoadName(_)
+                        | Instruction::StoreAttr { .. }
+                        | Instruction::StoreGlobal(_)
+                        | Instruction::StoreName(_)
+                ) | AnyInstruction::Pseudo(PseudoInstruction::LoadAttrMethod { .. }))
             )
         }
 
@@ -103,17 +103,17 @@ mod opcode {
         pub fn has_jump(opcode: i32) -> bool {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
-                Ok(Instruction::Real(
-                    RealInstruction::Break { .. }
-                        | RealInstruction::Continue { .. }
-                        | RealInstruction::ForIter { .. }
-                        | RealInstruction::JumpIfFalseOrPop { .. }
-                        | RealInstruction::JumpIfNotExcMatch(_)
-                        | RealInstruction::JumpIfTrueOrPop { .. }
-                        | RealInstruction::PopJumpIfFalse { .. }
-                        | RealInstruction::PopJumpIfTrue { .. }
-                        | RealInstruction::Send { .. }
-                ) | Instruction::Pseudo(PseudoInstruction::Jump { .. }))
+                Ok(AnyInstruction::Real(
+                    Instruction::Break { .. }
+                        | Instruction::Continue { .. }
+                        | Instruction::ForIter { .. }
+                        | Instruction::JumpIfFalseOrPop { .. }
+                        | Instruction::JumpIfNotExcMatch(_)
+                        | Instruction::JumpIfTrueOrPop { .. }
+                        | Instruction::PopJumpIfFalse { .. }
+                        | Instruction::PopJumpIfTrue { .. }
+                        | Instruction::Send { .. }
+                ) | AnyInstruction::Pseudo(PseudoInstruction::Jump { .. }))
             )
         }
 
@@ -122,12 +122,12 @@ mod opcode {
         pub fn has_free(opcode: i32) -> bool {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
-                Ok(Instruction::Real(
-                    RealInstruction::DeleteDeref(_)
-                        | RealInstruction::LoadFromDictOrDeref(_)
-                        | RealInstruction::LoadClosure(_)
-                        | RealInstruction::LoadDeref(_)
-                        | RealInstruction::StoreDeref(_)
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteDeref(_)
+                        | Instruction::LoadFromDictOrDeref(_)
+                        | Instruction::LoadClosure(_)
+                        | Instruction::LoadDeref(_)
+                        | Instruction::StoreDeref(_)
                 ))
             )
         }
@@ -137,12 +137,12 @@ mod opcode {
         pub fn has_local(opcode: i32) -> bool {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
-                Ok(Instruction::Real(
-                    RealInstruction::DeleteFast(_)
-                        | RealInstruction::LoadFast(_)
-                        | RealInstruction::LoadFastAndClear(_)
-                        | RealInstruction::StoreFast(_)
-                        | RealInstruction::StoreFastLoadFast { .. }
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteFast(_)
+                        | Instruction::LoadFast(_)
+                        | Instruction::LoadFastAndClear(_)
+                        | Instruction::StoreFast(_)
+                        | Instruction::StoreFastLoadFast { .. }
                 ))
             )
         }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 439905becb4..4ab5f361df7 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -7,7 +7,7 @@ use crate::{
         function::{PyCell, PyCellRef, PyFunction},
         tuple::{PyTuple, PyTupleRef},
     },
-    bytecode::{self, RealInstruction},
+    bytecode::{self, Instruction},
     convert::{IntoObject, ToPyResult},
     coroutine::Coro,
     exceptions::ExceptionCtor,
@@ -342,7 +342,7 @@ impl ExecutingFrame<'_> {
                 Ok(Some(value)) => {
                     break Ok(value);
                 }
-                // Instruction raised an exception
+                // AnyInstruction raised an exception
                 Err(exception) => {
                     #[cold]
                     fn handle_exception(
@@ -388,15 +388,15 @@ impl ExecutingFrame<'_> {
                     }
 
                     // Check if this is a RERAISE instruction
-                    // Both Instruction::Raise { kind: Reraise/ReraiseFromStack } and
-                    // Instruction::Reraise are reraise operations that should not add
+                    // Both AnyInstruction::Raise { kind: Reraise/ReraiseFromStack } and
+                    // AnyInstruction::Reraise are reraise operations that should not add
                     // new traceback entries
                     let is_reraise = match op {
-                        RealInstruction::RaiseVarargs { kind } => matches!(
+                        Instruction::RaiseVarargs { kind } => matches!(
                             kind.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
-                        RealInstruction::Reraise { .. } => true,
+                        Instruction::Reraise { .. } => true,
                         _ => false,
                     };
 
@@ -440,13 +440,13 @@ impl ExecutingFrame<'_> {
         let lasti = self.lasti() as usize;
         if let Some(unit) = self.code.instructions.get(lasti) {
             match &unit.op {
-                RealInstruction::Send { .. } => return Some(self.top_value()),
-                RealInstruction::Resume { .. } => {
+                Instruction::Send { .. } => return Some(self.top_value()),
+                Instruction::Resume { .. } => {
                     // Check if previous instruction was YIELD_VALUE with arg >= 1
                     // This indicates yield-from/await context
                     if lasti > 0
                         && let Some(prev_unit) = self.code.instructions.get(lasti - 1)
-                        && let RealInstruction::YieldValue { .. } = &prev_unit.op
+                        && let Instruction::YieldValue { .. } = &prev_unit.op
                     {
                         // YIELD_VALUE arg: 0 = direct yield, >= 1 = yield-from/await
                         // OpArgByte.0 is the raw byte value
@@ -551,7 +551,7 @@ impl ExecutingFrame<'_> {
     #[inline(always)]
     fn execute_instruction(
         &mut self,
-        instruction: RealInstruction,
+        instruction: Instruction,
         arg: bytecode::OpArg,
         extend_arg: &mut bool,
         vm: &VirtualMachine,
@@ -585,7 +585,7 @@ impl ExecutingFrame<'_> {
         }
 
         match instruction {
-            RealInstruction::BeforeAsyncWith => {
+            Instruction::BeforeAsyncWith => {
                 let mgr = self.pop_value();
                 let error_string = || -> String {
                     format!(
@@ -610,8 +610,8 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            RealInstruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
-            RealInstruction::BinarySubscr => {
+            Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
+            Instruction::BinarySubscr => {
                 let key = self.pop_value();
                 let container = self.pop_value();
                 let result = container.get_item(key.as_object(), vm)?;
@@ -619,30 +619,30 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
 
-            RealInstruction::Break { target } => self.unwind_blocks(
+            Instruction::Break { target } => self.unwind_blocks(
                 vm,
                 UnwindReason::Break {
                     target: target.get(arg),
                 },
             ),
-            RealInstruction::BuildListFromTuples { size } => {
+            Instruction::BuildListFromTuples { size } => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            RealInstruction::BuildList { size } => {
+            Instruction::BuildList { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            RealInstruction::BuildMapForCall { size } => {
+            Instruction::BuildMapForCall { size } => {
                 self.execute_build_map_for_call(vm, size.get(arg))
             }
-            RealInstruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            RealInstruction::BuildSetFromTuples { size } => {
+            Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
+            Instruction::BuildSetFromTuples { size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     // SAFETY: trust compiler
@@ -654,7 +654,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            RealInstruction::BuildSet { size } => {
+            Instruction::BuildSet { size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     set.add(element, vm)?;
@@ -662,9 +662,9 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            RealInstruction::BuildSlice { argc } => self.execute_build_slice(vm, argc.get(arg)),
+            Instruction::BuildSlice { argc } => self.execute_build_slice(vm, argc.get(arg)),
             /*
-             RealInstruction::ToBool => {
+             Instruction::ToBool => {
                  dbg!("Shouldn't be called outside of match statements for now")
                  let value = self.pop_value();
                  // call __bool__
@@ -673,7 +673,7 @@ impl ExecutingFrame<'_> {
                  Ok(None)
             }
             */
-            RealInstruction::BuildString { size } => {
+            Instruction::BuildString { size } => {
                 let s: Wtf8Buf = self
                     .pop_multiple(size.get(arg) as usize)
                     .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
@@ -681,7 +681,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
-            RealInstruction::BuildTupleFromIter => {
+            Instruction::BuildTupleFromIter => {
                 if !self.top_value().class().is(vm.ctx.types.tuple_type) {
                     let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
                     let list_obj = vm.ctx.new_tuple(elements);
@@ -689,48 +689,48 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            RealInstruction::BuildTupleFromTuples { size } => {
+            Instruction::BuildTupleFromTuples { size } => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            RealInstruction::BuildTuple { size } => {
+            Instruction::BuildTuple { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            RealInstruction::Call { nargs } => {
+            Instruction::Call { nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            RealInstruction::CallKw { nargs } => {
+            Instruction::CallKw { nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            RealInstruction::CallFunctionEx { has_kwargs } => {
+            Instruction::CallFunctionEx { has_kwargs } => {
                 // Stack: [callable, self_or_null, args_tuple, (kwargs_dict)?]
                 let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
                 self.execute_call(args, vm)
             }
-            RealInstruction::CallIntrinsic1 { func } => {
+            Instruction::CallIntrinsic1 { func } => {
                 let value = self.pop_value();
                 let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
                 self.push_value(result);
                 Ok(None)
             }
-            RealInstruction::CallIntrinsic2 { func } => {
+            Instruction::CallIntrinsic2 { func } => {
                 let value2 = self.pop_value();
                 let value1 = self.pop_value();
                 let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
                 self.push_value(result);
                 Ok(None)
             }
-            RealInstruction::CheckEgMatch => {
+            Instruction::CheckEgMatch => {
                 let match_type = self.pop_value();
                 let exc_value = self.pop_value();
                 let (rest, matched) =
@@ -739,8 +739,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(matched);
                 Ok(None)
             }
-            RealInstruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
-            RealInstruction::ContainsOp(invert) => {
+            Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
+            Instruction::ContainsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
 
@@ -751,17 +751,17 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            RealInstruction::Continue { target } => self.unwind_blocks(
+            Instruction::Continue { target } => self.unwind_blocks(
                 vm,
                 UnwindReason::Continue {
                     target: target.get(arg),
                 },
             ),
 
-            RealInstruction::ConvertValue { oparg: conversion } => {
+            Instruction::ConvertValue { oparg: conversion } => {
                 self.convert_value(conversion.get(arg), vm)
             }
-            RealInstruction::Copy { index } => {
+            Instruction::Copy { index } => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
@@ -777,12 +777,12 @@ impl ExecutingFrame<'_> {
                 self.push_value_opt(value);
                 Ok(None)
             }
-            RealInstruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            RealInstruction::DeleteDeref(i) => {
+            Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
+            Instruction::DeleteDeref(i) => {
                 self.cells_frees[i.get(arg) as usize].set(None);
                 Ok(None)
             }
-            RealInstruction::DeleteFast(idx) => {
+            Instruction::DeleteFast(idx) => {
                 let mut fastlocals = self.fastlocals.lock();
                 let idx = idx.get(arg) as usize;
                 if fastlocals[idx].is_none() {
@@ -797,7 +797,7 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            RealInstruction::DeleteGlobal(idx) => {
+            Instruction::DeleteGlobal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 match self.globals.del_item(name, vm) {
                     Ok(()) => {}
@@ -808,7 +808,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            RealInstruction::DeleteName(idx) => {
+            Instruction::DeleteName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let res = self.locals.mapping().ass_subscript(name, None, vm);
 
@@ -821,8 +821,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            RealInstruction::DeleteSubscr => self.execute_delete_subscript(vm),
-            RealInstruction::DictUpdate { index } => {
+            Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
+            Instruction::DictUpdate { index } => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
                 // The dict to update is at position TOS-i (before popping source)
@@ -858,7 +858,7 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            RealInstruction::EndAsyncFor => {
+            Instruction::EndAsyncFor => {
                 // END_ASYNC_FOR pops (awaitable, exc) from stack
                 // Stack: [awaitable, exc] -> []
                 // exception_unwind pushes exception to stack before jumping to handler
@@ -878,19 +878,19 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            RealInstruction::ExtendedArg => {
+            Instruction::ExtendedArg => {
                 *extend_arg = true;
                 Ok(None)
             }
-            RealInstruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
-            RealInstruction::FormatSimple => {
+            Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            Instruction::FormatSimple => {
                 let value = self.pop_value();
                 let formatted = vm.format(&value, vm.ctx.new_str(""))?;
                 self.push_value(formatted.into());
 
                 Ok(None)
             }
-            RealInstruction::FormatWithSpec => {
+            Instruction::FormatWithSpec => {
                 let spec = self.pop_value();
                 let value = self.pop_value();
                 let formatted = vm.format(&value, spec.downcast::<PyStr>().unwrap())?;
@@ -898,13 +898,13 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            RealInstruction::GetAIter => {
+            Instruction::GetAIter => {
                 let aiterable = self.pop_value();
                 let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
                 self.push_value(aiter);
                 Ok(None)
             }
-            RealInstruction::GetANext => {
+            Instruction::GetANext => {
                 #[cfg(debug_assertions)] // remove when GetANext is fully implemented
                 let orig_stack_len = self.state.stack.len();
 
@@ -949,7 +949,7 @@ impl ExecutingFrame<'_> {
                 debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
                 Ok(None)
             }
-            RealInstruction::GetAwaitable => {
+            Instruction::GetAwaitable => {
                 use crate::protocol::PyIter;
 
                 let awaited_obj = self.pop_value();
@@ -985,13 +985,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(awaitable);
                 Ok(None)
             }
-            RealInstruction::GetIter => {
+            Instruction::GetIter => {
                 let iterated_obj = self.pop_value();
                 let iter_obj = iterated_obj.get_iter(vm)?;
                 self.push_value(iter_obj.into());
                 Ok(None)
             }
-            RealInstruction::GetYieldFromIter => {
+            Instruction::GetYieldFromIter => {
                 // GET_YIELD_FROM_ITER: prepare iterator for yield from
                 // If iterable is a coroutine, ensure we're in a coroutine context
                 // If iterable is a generator, use it directly
@@ -1016,23 +1016,23 @@ impl ExecutingFrame<'_> {
                 self.push_value(iter);
                 Ok(None)
             }
-            RealInstruction::GetLen => {
+            Instruction::GetLen => {
                 // STACK.append(len(STACK[-1]))
                 let obj = self.top_value();
                 let len = obj.length(vm)?;
                 self.push_value(vm.ctx.new_int(len).into());
                 Ok(None)
             }
-            RealInstruction::ImportFrom { idx } => {
+            Instruction::ImportFrom { idx } => {
                 let obj = self.import_from(vm, idx.get(arg))?;
                 self.push_value(obj);
                 Ok(None)
             }
-            RealInstruction::ImportName { idx } => {
+            Instruction::ImportName { idx } => {
                 self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
                 Ok(None)
             }
-            RealInstruction::IsOp(invert) => {
+            Instruction::IsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 let res = a.is(&b);
@@ -1044,10 +1044,10 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            RealInstruction::JumpIfFalseOrPop { target } => {
+            Instruction::JumpIfFalseOrPop { target } => {
                 self.jump_if_or_pop(vm, target.get(arg), false)
             }
-            RealInstruction::JumpIfNotExcMatch(target) => {
+            Instruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 if let Some(tuple_of_exceptions) = b.downcast_ref::<PyTuple>() {
@@ -1070,22 +1070,22 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            RealInstruction::JumpIfTrueOrPop { target } => {
+            Instruction::JumpIfTrueOrPop { target } => {
                 self.jump_if_or_pop(vm, target.get(arg), true)
             }
-            RealInstruction::JumpForward { target } => {
+            Instruction::JumpForward { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            RealInstruction::JumpBackward { target } => {
+            Instruction::JumpBackward { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            RealInstruction::JumpBackwardNoInterrupt { target } => {
+            Instruction::JumpBackwardNoInterrupt { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            RealInstruction::ListAppend { i } => {
+            Instruction::ListAppend { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let list: &Py<PyList> = unsafe {
@@ -1095,13 +1095,13 @@ impl ExecutingFrame<'_> {
                 list.append(item);
                 Ok(None)
             }
-            RealInstruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            RealInstruction::LoadSuperAttr { arg: idx } => self.load_super_attr(vm, idx.get(arg)),
-            RealInstruction::LoadBuildClass => {
+            Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
+            Instruction::LoadSuperAttr { arg: idx } => self.load_super_attr(vm, idx.get(arg)),
+            Instruction::LoadBuildClass => {
                 self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
             }
-            RealInstruction::LoadFromDictOrDeref(i) => {
+            Instruction::LoadFromDictOrDeref(i) => {
                 let i = i.get(arg) as usize;
                 let name = if i < self.code.cellvars.len() {
                     self.code.cellvars[i]
@@ -1117,16 +1117,16 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            RealInstruction::LoadClosure(i) => {
+            Instruction::LoadClosure(i) => {
                 let value = self.cells_frees[i.get(arg) as usize].clone();
                 self.push_value(value.into());
                 Ok(None)
             }
-            RealInstruction::LoadConst { idx } => {
+            Instruction::LoadConst { idx } => {
                 self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)
             }
-            RealInstruction::LoadDeref(i) => {
+            Instruction::LoadDeref(i) => {
                 let i = i.get(arg) as usize;
                 let x = self.cells_frees[i]
                     .get()
@@ -1134,7 +1134,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            RealInstruction::LoadFast(idx) => {
+            Instruction::LoadFast(idx) => {
                 #[cold]
                 fn reference_error(
                     varname: &'static PyStrInterned,
@@ -1152,7 +1152,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            RealInstruction::LoadFastAndClear(idx) => {
+            Instruction::LoadFastAndClear(idx) => {
                 // Load value and clear the slot (for inlined comprehensions)
                 // If slot is empty, push None (not an error - variable may not exist yet)
                 let idx = idx.get(arg) as usize;
@@ -1162,13 +1162,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            RealInstruction::LoadGlobal(idx) => {
+            Instruction::LoadGlobal(idx) => {
                 let name = &self.code.names[idx.get(arg) as usize];
                 let x = self.load_global_or_builtin(name, vm)?;
                 self.push_value(x);
                 Ok(None)
             }
-            RealInstruction::LoadName(idx) => {
+            Instruction::LoadName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let result = self.locals.mapping().subscript(name, vm);
                 match result {
@@ -1180,8 +1180,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            RealInstruction::MakeFunction => self.execute_make_function(vm),
-            RealInstruction::MapAdd { i } => {
+            Instruction::MakeFunction => self.execute_make_function(vm),
+            Instruction::MapAdd { i } => {
                 let value = self.pop_value();
                 let key = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
@@ -1192,7 +1192,7 @@ impl ExecutingFrame<'_> {
                 dict.set_item(&*key, value, vm)?;
                 Ok(None)
             }
-            RealInstruction::MatchClass(nargs) => {
+            Instruction::MatchClass(nargs) => {
                 // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
                 // nargs is the number of positional sub-patterns.
                 let kwd_attrs = self.pop_value();
@@ -1313,7 +1313,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            RealInstruction::MatchKeys => {
+            Instruction::MatchKeys => {
                 // MATCH_KEYS doesn't pop subject and keys, only reads them
                 let keys_tuple = self.top_value(); // stack[-1]
                 let subject = self.nth_value(1); // stack[-2]
@@ -1379,7 +1379,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            RealInstruction::MatchMapping => {
+            Instruction::MatchMapping => {
                 // Pop and push back the subject to keep it on stack
                 let subject = self.pop_value();
 
@@ -1390,7 +1390,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(is_mapping).into());
                 Ok(None)
             }
-            RealInstruction::MatchSequence => {
+            Instruction::MatchSequence => {
                 // Pop and push back the subject to keep it on stack
                 let subject = self.pop_value();
 
@@ -1401,8 +1401,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(is_sequence).into());
                 Ok(None)
             }
-            RealInstruction::Nop => Ok(None),
-            RealInstruction::PopExcept => {
+            Instruction::Nop => Ok(None),
+            Instruction::PopExcept => {
                 // Pop prev_exc from value stack and restore it
                 let prev_exc = self.pop_value();
                 if vm.is_none(&prev_exc) {
@@ -1420,24 +1420,20 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            RealInstruction::PopJumpIfFalse { target } => {
-                self.pop_jump_if(vm, target.get(arg), false)
-            }
-            RealInstruction::PopJumpIfTrue { target } => {
-                self.pop_jump_if(vm, target.get(arg), true)
-            }
-            RealInstruction::PopTop => {
+            Instruction::PopJumpIfFalse { target } => self.pop_jump_if(vm, target.get(arg), false),
+            Instruction::PopJumpIfTrue { target } => self.pop_jump_if(vm, target.get(arg), true),
+            Instruction::PopTop => {
                 // Pop value from stack and ignore.
                 self.pop_value();
                 Ok(None)
             }
-            RealInstruction::PushNull => {
+            Instruction::PushNull => {
                 // Push NULL for self_or_null slot in call protocol
                 self.push_null();
                 Ok(None)
             }
-            RealInstruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
-            RealInstruction::Resume { arg: resume_arg } => {
+            Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
+            Instruction::Resume { arg: resume_arg } => {
                 // Resume execution after yield, await, or at function start
                 // In CPython, this checks instrumentation and eval breaker
                 // For now, we just check for signals/interrupts
@@ -1449,15 +1445,15 @@ impl ExecutingFrame<'_> {
                 // }
                 Ok(None)
             }
-            RealInstruction::ReturnConst { idx } => {
+            Instruction::ReturnConst { idx } => {
                 let value = self.code.constants[idx.get(arg) as usize].clone().into();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            RealInstruction::ReturnValue => {
+            Instruction::ReturnValue => {
                 let value = self.pop_value();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            RealInstruction::SetAdd { i } => {
+            Instruction::SetAdd { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let set: &Py<PySet> = unsafe {
@@ -1467,7 +1463,7 @@ impl ExecutingFrame<'_> {
                 set.add(item, vm)?;
                 Ok(None)
             }
-            RealInstruction::SetExcInfo => {
+            Instruction::SetExcInfo => {
                 // Set the current exception to TOS (for except* handlers)
                 // This updates sys.exc_info() so bare 'raise' will reraise the matched exception
                 let exc = self.top_value();
@@ -1476,7 +1472,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            RealInstruction::PushExcInfo => {
+            Instruction::PushExcInfo => {
                 // Stack: [exc] -> [prev_exc, exc]
                 let exc = self.pop_value();
                 let prev_exc = vm
@@ -1493,7 +1489,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(exc);
                 Ok(None)
             }
-            RealInstruction::CheckExcMatch => {
+            Instruction::CheckExcMatch => {
                 // Stack: [exc, type] -> [exc, bool]
                 let exc_type = self.pop_value();
                 let exc = self.top_value();
@@ -1503,7 +1499,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(result).into());
                 Ok(None)
             }
-            RealInstruction::Reraise { depth } => {
+            Instruction::Reraise { depth } => {
                 // inst(RERAISE, (values[oparg], exc -- values[oparg]))
                 //
                 // Stack layout: [values..., exc] where len(values) == oparg
@@ -1530,11 +1526,11 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            RealInstruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute { attr } => {
                 self.execute_set_function_attribute(vm, attr.get(arg))
             }
-            RealInstruction::SetupAnnotations => self.setup_annotations(vm),
-            RealInstruction::BeforeWith => {
+            Instruction::SetupAnnotations => self.setup_annotations(vm),
+            Instruction::BeforeWith => {
                 // TOS: context_manager
                 // Result: [..., __exit__, __enter__ result]
                 let context_manager = self.pop_value();
@@ -1563,18 +1559,18 @@ impl ExecutingFrame<'_> {
                 self.push_value(enter_res);
                 Ok(None)
             }
-            RealInstruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            RealInstruction::StoreDeref(i) => {
+            Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
+            Instruction::StoreDeref(i) => {
                 let value = self.pop_value();
                 self.cells_frees[i.get(arg) as usize].set(Some(value));
                 Ok(None)
             }
-            RealInstruction::StoreFast(idx) => {
+            Instruction::StoreFast(idx) => {
                 let value = self.pop_value();
                 self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
                 Ok(None)
             }
-            RealInstruction::StoreFastLoadFast {
+            Instruction::StoreFastLoadFast {
                 store_idx,
                 load_idx,
             } => {
@@ -1589,21 +1585,21 @@ impl ExecutingFrame<'_> {
                 self.push_value(load_value);
                 Ok(None)
             }
-            RealInstruction::StoreGlobal(idx) => {
+            Instruction::StoreGlobal(idx) => {
                 let value = self.pop_value();
                 self.globals
                     .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
                 Ok(None)
             }
-            RealInstruction::StoreName(idx) => {
+            Instruction::StoreName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let value = self.pop_value();
                 self.locals.mapping().ass_subscript(name, Some(value), vm)?;
                 Ok(None)
             }
-            RealInstruction::StoreSubscr => self.execute_store_subscript(vm),
-            RealInstruction::Subscript => self.execute_subscript(vm),
-            RealInstruction::Swap { index } => {
+            Instruction::StoreSubscr => self.execute_store_subscript(vm),
+            Instruction::Subscript => self.execute_subscript(vm),
+            Instruction::Swap { index } => {
                 let len = self.state.stack.len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
                 let i = len - 1; // TOS index
@@ -1620,18 +1616,18 @@ impl ExecutingFrame<'_> {
                 self.state.stack.swap(i, j);
                 Ok(None)
             }
-            RealInstruction::ToBool => {
+            Instruction::ToBool => {
                 let obj = self.pop_value();
                 let bool_val = obj.try_to_bool(vm)?;
                 self.push_value(vm.ctx.new_bool(bool_val).into());
                 Ok(None)
             }
-            RealInstruction::UnpackEx { args } => {
+            Instruction::UnpackEx { args } => {
                 let args = args.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
             }
-            RealInstruction::UnpackSequence { size } => self.unpack_sequence(size.get(arg), vm),
-            RealInstruction::WithExceptStart => {
+            Instruction::UnpackSequence { size } => self.unpack_sequence(size.get(arg), vm),
+            Instruction::WithExceptStart => {
                 // Stack: [..., __exit__, lasti, prev_exc, exc]
                 // Call __exit__(type, value, tb) and push result
                 // __exit__ is at TOS-3 (below lasti, prev_exc, and exc)
@@ -1654,7 +1650,7 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            RealInstruction::YieldValue { arg: oparg } => {
+            Instruction::YieldValue { arg: oparg } => {
                 let value = self.pop_value();
                 // arg=0: direct yield (wrapped for async generators)
                 // arg=1: yield from await/yield-from (NOT wrapped)
@@ -1666,7 +1662,7 @@ impl ExecutingFrame<'_> {
                 };
                 Ok(Some(ExecutionResult::Yield(value)))
             }
-            RealInstruction::Send { target } => {
+            Instruction::Send { target } => {
                 // Stack: (receiver, value) -> (receiver, retval)
                 // On StopIteration: replace value with stop value and jump to target
                 let exit_label = target.get(arg);
@@ -1690,7 +1686,7 @@ impl ExecutingFrame<'_> {
                     }
                 }
             }
-            RealInstruction::EndSend => {
+            Instruction::EndSend => {
                 // Stack: (receiver, value) -> (value)
                 // Pops receiver, leaves value
                 let value = self.pop_value();
@@ -1698,7 +1694,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(value);
                 Ok(None)
             }
-            RealInstruction::CleanupThrow => {
+            Instruction::CleanupThrow => {
                 // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) OR re-raise
                 // If StopIteration: pop all 3, extract value, push (None, value)
                 // Otherwise: pop all 3, return Err(exc) for unwind_blocks to handle
@@ -1736,19 +1732,19 @@ impl ExecutingFrame<'_> {
                     .map_err(|_| vm.new_type_error("exception expected".to_owned()))?;
                 Err(exc)
             }
-            RealInstruction::UnaryInvert => {
+            Instruction::UnaryInvert => {
                 let a = self.pop_value();
                 let value = vm._invert(&a)?;
                 self.push_value(value);
                 Ok(None)
             }
-            RealInstruction::UnaryNegative => {
+            Instruction::UnaryNegative => {
                 let a = self.pop_value();
                 let value = vm._neg(&a)?;
                 self.push_value(value);
                 Ok(None)
             }
-            RealInstruction::UnaryNot => {
+            Instruction::UnaryNot => {
                 let obj = self.pop_value();
                 let value = obj.try_to_bool(vm)?;
                 self.push_value(vm.ctx.new_bool(!value).into());

From 0096a65ed5ec01168f68de283001186cfbdfdddf Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 17:41:03 +0200
Subject: [PATCH 33/35] Restore fmt_dis for LoadClousure

---
 crates/compiler-core/src/bytecode/instruction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index a3f53082655..3ebb3666ae2 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -719,6 +719,7 @@ 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),
@@ -782,7 +783,6 @@ impl InstructionMetadata for Instruction {
             Self::UnaryNot => w!(UNARY_NOT),
             Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
             Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
-            Self::LoadClosure(_) => w!(LOAD_CLOSURE),
             _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }

From 045d5763723e2ebdd5ff0578f3ad5267911623a6 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 17:45:34 +0200
Subject: [PATCH 34/35] Fix script

---
 scripts/generate_opcode_metadata.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index cd3ebe2360e..dc913e1a7ee 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -52,7 +52,7 @@ def extract_enum_body(contents: str, enum_name: str) -> str:
 contents = BYTECODE_FILE.read_text()
 enum_body = "\n".join(
     extract_enum_body(contents, enum_name)
-    for enum_name in ("RealInstruction", "PseudoInstruction")
+    for enum_name in ("Instruction", "PseudoInstruction")
 )
 opcodes = list(Opcode.from_str(enum_body))
 

From b00f81f83a2ba057ed10ce814004cfad3ae73d94 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 17:46:49 +0200
Subject: [PATCH 35/35] Fix commet

---
 crates/vm/src/frame.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 4ab5f361df7..bd4d01de9f5 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -342,7 +342,7 @@ impl ExecutingFrame<'_> {
                 Ok(Some(value)) => {
                     break Ok(value);
                 }
-                // AnyInstruction raised an exception
+                // Instruction raised an exception
                 Err(exception) => {
                     #[cold]
                     fn handle_exception(