From c23b891ac4cd937dd7749b8e2cfca6fff7253ad0 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 15:23:32 +0200
Subject: [PATCH 1/7] Move `Instruction` to its own file

---
 crates/compiler-core/src/bytecode.rs          | 771 +----------------
 .../compiler-core/src/bytecode/instruction.rs | 814 ++++++++++++++++++
 2 files changed, 818 insertions(+), 767 deletions(-)
 create mode 100644 crates/compiler-core/src/bytecode/instruction.rs

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 010e414cc89..61707b7757e 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -14,6 +14,10 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
+pub use crate::bytecode::instruction::Instruction;
+
+mod instruction;
+
 /// Exception table entry for zero-cost exception handling
 /// Format: (start, size, target, depth<<1|lasti)
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -670,356 +674,6 @@ op_arg_enum!(
 
 pub type NameIdx = u32;
 
-/// 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)]
-#[repr(u8)]
-pub enum Instruction {
-    // ==================== No-argument instructions (opcode < 44) ====================
-    Cache = 0, // Placeholder
-    BeforeAsyncWith = 1,
-    BeforeWith = 2,
-    BinaryOpInplaceAddUnicode = 3, // Placeholder
-    BinarySlice = 4,               // Placeholder
-    BinarySubscr = 5,
-    CheckEgMatch = 6,
-    CheckExcMatch = 7,
-    CleanupThrow = 8,
-    DeleteSubscr = 9,
-    EndAsyncFor = 10,
-    EndFor = 11, // Placeholder
-    EndSend = 12,
-    ExitInitCheck = 13, // Placeholder
-    FormatSimple = 14,
-    FormatWithSpec = 15,
-    GetAIter = 16,
-    Reserved = 17,
-    GetANext = 18,
-    GetIter = 19,
-    GetLen = 20,
-    GetYieldFromIter = 21,
-    InterpreterExit = 22,    // Placeholder
-    LoadAssertionError = 23, // Placeholder
-    LoadBuildClass = 24,
-    LoadLocals = 25, // Placeholder
-    MakeFunction = 26,
-    MatchKeys = 27,
-    MatchMapping = 28,
-    MatchSequence = 29,
-    Nop = 30,
-    PopExcept = 31,
-    PopTop = 32,
-    PushExcInfo = 33,
-    PushNull = 34,        // Placeholder
-    ReturnGenerator = 35, // Placeholder
-    ReturnValue = 36,
-    SetupAnnotations = 37,
-    StoreSlice = 38, // Placeholder
-    StoreSubscr = 39,
-    ToBool = 40,
-    UnaryInvert = 41,
-    UnaryNegative = 42,
-    UnaryNot = 43,
-    WithExceptStart = 44,
-    // ==================== With-argument instructions (opcode > 44) ====================
-    BinaryOp {
-        op: Arg<BinaryOperator>,
-    } = 45,
-    BuildConstKeyMap {
-        size: Arg<u32>,
-    } = 46, // Placeholder
-    BuildList {
-        size: Arg<u32>,
-    } = 47,
-    BuildMap {
-        size: Arg<u32>,
-    } = 48,
-    BuildSet {
-        size: Arg<u32>,
-    } = 49,
-    BuildSlice {
-        argc: Arg<BuildSliceArgCount>,
-    } = 50,
-    BuildString {
-        size: Arg<u32>,
-    } = 51,
-    BuildTuple {
-        size: Arg<u32>,
-    } = 52,
-    Call {
-        nargs: Arg<u32>,
-    } = 53,
-    CallFunctionEx {
-        has_kwargs: Arg<bool>,
-    } = 54,
-    CallIntrinsic1 {
-        func: Arg<IntrinsicFunction1>,
-    } = 55,
-    CallIntrinsic2 {
-        func: Arg<IntrinsicFunction2>,
-    } = 56,
-    CallKw {
-        nargs: Arg<u32>,
-    } = 57,
-    CompareOp {
-        op: Arg<ComparisonOperator>,
-    } = 58,
-    ContainsOp(Arg<Invert>) = 59,
-    ConvertValue {
-        oparg: Arg<ConvertValueOparg>,
-    } = 60,
-    CopyItem {
-        index: Arg<u32>,
-    } = 61,
-    CopyFreeVars {
-        count: Arg<u32>,
-    } = 62, // Placeholder
-    DeleteAttr {
-        idx: Arg<NameIdx>,
-    } = 63,
-    DeleteDeref(Arg<NameIdx>) = 64,
-    DeleteFast(Arg<NameIdx>) = 65,
-    DeleteGlobal(Arg<NameIdx>) = 66,
-    DeleteName(Arg<NameIdx>) = 67,
-    DictMerge {
-        index: Arg<u32>,
-    } = 68, // Placeholder
-    DictUpdate {
-        index: Arg<u32>,
-    } = 69,
-    EnterExecutor = 70, // Placeholder
-    ExtendedArg = 71,
-    ForIter {
-        target: Arg<Label>,
-    } = 72,
-    GetAwaitable = 73, // TODO: Make this instruction to hold an oparg
-    ImportFrom {
-        idx: Arg<NameIdx>,
-    } = 74,
-    ImportName {
-        idx: Arg<NameIdx>,
-    } = 75,
-    IsOp(Arg<Invert>) = 76,
-    JumpBackward {
-        target: Arg<Label>,
-    } = 77, // Placeholder
-    JumpBackwardNoInterrupt {
-        target: Arg<Label>,
-    } = 78, // Placeholder
-    JumpForward {
-        target: Arg<Label>,
-    } = 79, // Placeholder
-    ListAppend {
-        i: Arg<u32>,
-    } = 80,
-    ListExtend {
-        i: Arg<u32>,
-    } = 81, // Placeholder
-    LoadAttr {
-        idx: Arg<NameIdx>,
-    } = 82,
-    LoadConst {
-        idx: Arg<u32>,
-    } = 83,
-    LoadDeref(Arg<NameIdx>) = 84,
-    LoadFast(Arg<NameIdx>) = 85,
-    LoadFastAndClear(Arg<NameIdx>) = 86,
-    LoadFastCheck(Arg<NameIdx>) = 87, // Placeholder
-    LoadFastLoadFast {
-        arg: Arg<u32>,
-    } = 88, // Placeholder
-    LoadFromDictOrDeref(Arg<NameIdx>) = 89, // Placeholder
-    LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
-    LoadGlobal(Arg<NameIdx>) = 91,
-    LoadName(Arg<NameIdx>) = 92,
-    LoadSuperAttr {
-        arg: Arg<u32>,
-    } = 93, // Placeholder
-    MakeCell(Arg<NameIdx>) = 94, // Placeholder
-    MapAdd {
-        i: Arg<u32>,
-    } = 95,
-    MatchClass(Arg<u32>) = 96,
-    PopJumpIfFalse {
-        target: Arg<Label>,
-    } = 97,
-    PopJumpIfNone {
-        target: Arg<Label>,
-    } = 98, // Placeholder
-    PopJumpIfNotNone {
-        target: Arg<Label>,
-    } = 99, // Placeholder
-    PopJumpIfTrue {
-        target: Arg<Label>,
-    } = 100,
-    RaiseVarargs {
-        kind: Arg<RaiseKind>,
-    } = 101,
-    Reraise {
-        depth: Arg<u32>,
-    } = 102,
-    ReturnConst {
-        idx: Arg<u32>,
-    } = 103,
-    Send {
-        target: Arg<Label>,
-    } = 104,
-    SetAdd {
-        i: Arg<u32>,
-    } = 105,
-    SetFunctionAttribute {
-        attr: Arg<MakeFunctionFlags>,
-    } = 106,
-    SetUpdate {
-        i: Arg<u32>,
-    } = 107, // Placeholder
-    StoreAttr {
-        idx: Arg<NameIdx>,
-    } = 108,
-    StoreDeref(Arg<NameIdx>) = 109,
-    StoreFast(Arg<NameIdx>) = 110,
-    StoreFastLoadFast {
-        store_idx: Arg<NameIdx>,
-        load_idx: Arg<NameIdx>,
-    } = 111,
-    StoreFastStoreFast {
-        arg: Arg<u32>,
-    } = 112, // Placeholder
-    StoreGlobal(Arg<NameIdx>) = 113,
-    StoreName(Arg<NameIdx>) = 114,
-    Swap {
-        index: Arg<u32>,
-    } = 115,
-    UnpackEx {
-        args: Arg<UnpackExArgs>,
-    } = 116,
-    UnpackSequence {
-        size: Arg<u32>,
-    } = 117,
-    YieldValue {
-        arg: Arg<u32>,
-    } = 118,
-    Resume {
-        arg: Arg<u32>,
-    } = 149,
-    // ==================== 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.
-    Break {
-        target: Arg<Label>,
-    } = 119,
-    BuildListFromTuples {
-        size: Arg<u32>,
-    } = 120,
-    BuildMapForCall {
-        size: Arg<u32>,
-    } = 121,
-    BuildSetFromTuples {
-        size: Arg<u32>,
-    } = 122,
-    BuildTupleFromIter = 123,
-    BuildTupleFromTuples {
-        size: Arg<u32>,
-    } = 124,
-    Continue {
-        target: Arg<Label>,
-    } = 128,
-    JumpIfFalseOrPop {
-        target: Arg<Label>,
-    } = 129,
-    JumpIfTrueOrPop {
-        target: Arg<Label>,
-    } = 130,
-    JumpIfNotExcMatch(Arg<Label>) = 131,
-    LoadClassDeref(Arg<NameIdx>) = 132,
-    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);
-
-impl From<Instruction> for u8 {
-    #[inline]
-    fn from(ins: Instruction) -> Self {
-        // SAFETY: there's no padding bits
-        unsafe { core::mem::transmute::<Instruction, Self>(ins) }
-    }
-}
-
-impl TryFrom<u8> for Instruction {
-    type Error = MarshalError;
-
-    #[inline]
-    fn try_from(value: u8) -> Result<Self, MarshalError> {
-        // CPython-compatible opcodes (0-118)
-        let cpython_start = u8::from(Self::Cache);
-        let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
-
-        // Resume has a non-contiguous opcode (149)
-        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
-
-        // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
-        let custom_ops: &[u8] = &[
-            u8::from(Self::Break {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::BuildListFromTuples {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildMapForCall {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildSetFromTuples {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildTupleFromIter),
-            u8::from(Self::BuildTupleFromTuples {
-                size: Arg::marker(),
-            }),
-            // 125, 126, 127 are unused
-            u8::from(Self::Continue {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::JumpIfFalseOrPop {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::JumpIfTrueOrPop {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
-            u8::from(Self::LoadClassDeref(Arg::marker())),
-            u8::from(Self::SetExcInfo),
-            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 {
-            Err(Self::Error::InvalidBytecode)
-        }
-    }
-}
-
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct CodeUnit {
@@ -1087,8 +741,6 @@ impl Deref for CodeUnits {
     }
 }
 
-use self::Instruction::*;
-
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
     pub struct MakeFunctionFlags: u8 {
@@ -1729,421 +1381,6 @@ impl<C: Constant> fmt::Display for CodeObject<C> {
     }
 }
 
-impl Instruction {
-    /// Gets the label stored inside this instruction, if it exists
-    #[inline]
-    pub const fn label_arg(&self) -> Option<Arg<Label>> {
-        match self {
-            Jump { target: l }
-            | JumpBackward { target: l }
-            | JumpBackwardNoInterrupt { target: l }
-            | JumpForward { target: l }
-            | JumpIfNotExcMatch(l)
-            | PopJumpIfTrue { target: l }
-            | PopJumpIfFalse { target: l }
-            | JumpIfTrueOrPop { target: l }
-            | JumpIfFalseOrPop { target: l }
-            | ForIter { target: l }
-            | Break { target: l }
-            | Continue { target: l }
-            | Send { target: l } => Some(*l),
-            _ => None,
-        }
-    }
-
-    /// Whether this is an unconditional branching
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
-    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
-    /// assert!(jump_inst.unconditional_branch())
-    /// ```
-    pub const fn unconditional_branch(&self) -> bool {
-        matches!(
-            self,
-            Jump { .. }
-                | JumpForward { .. }
-                | JumpBackward { .. }
-                | JumpBackwardNoInterrupt { .. }
-                | Continue { .. }
-                | Break { .. }
-                | ReturnValue
-                | ReturnConst { .. }
-                | RaiseVarargs { .. }
-                | Reraise { .. }
-        )
-    }
-
-    /// What effect this instruction has on the stack
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label};
-    /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = Instruction::Jump { target };
-    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// ```
-    ///
-    pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
-        match self {
-            Nop => 0,
-            ImportName { .. } => -1,
-            ImportFrom { .. } => 1,
-            LoadFast(_) | LoadFastAndClear(_) | LoadName(_) | LoadGlobal(_) | LoadDeref(_)
-            | LoadClassDeref(_) => 1,
-            StoreFast(_) | StoreName(_) | StoreGlobal(_) | StoreDeref(_) => -1,
-            StoreFastLoadFast { .. } => 0, // pop 1, push 1
-            DeleteFast(_) | DeleteName(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
-            LoadClosure(_) => 1,
-            Subscript => -1,
-            StoreSubscr => -3,
-            DeleteSubscr => -2,
-            LoadAttr { .. } => 0,
-            // LoadAttrMethod: pop obj, push method + self_or_null
-            LoadAttrMethod { .. } => 1,
-            StoreAttr { .. } => -2,
-            DeleteAttr { .. } => -1,
-            LoadConst { .. } => 1,
-            Reserved => 0,
-            BinaryOp { .. } | CompareOp { .. } => -1,
-            BinarySubscr => -1,
-            CopyItem { .. } => 1,
-            PopTop => -1,
-            Swap { .. } => 0,
-            ToBool => 0,
-            GetIter => 0,
-            GetLen => 1,
-            CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
-            CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
-            Continue { .. } => 0,
-            Break { .. } => 0,
-            Jump { .. } => 0,
-            PopJumpIfTrue { .. } | PopJumpIfFalse { .. } => -1,
-            JumpIfTrueOrPop { .. } | JumpIfFalseOrPop { .. } => {
-                if jump {
-                    0
-                } else {
-                    -1
-                }
-            }
-            MakeFunction => {
-                // CPython 3.13 style: MakeFunction only pops code object
-                -1 + 1 // pop code, push function
-            }
-            SetFunctionAttribute { .. } => {
-                // pops attribute value and function, pushes function back
-                -2 + 1
-            }
-            // Call: pops nargs + self_or_null + callable, pushes result
-            Call { nargs } => -(nargs.get(arg) as i32) - 2 + 1,
-            // CallKw: pops kw_names_tuple + nargs + self_or_null + callable, pushes result
-            CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 2 + 1,
-            // CallFunctionEx: pops kwargs(if any) + args_tuple + self_or_null + callable, pushes result
-            CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 2 + 1,
-            CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
-            ConvertValue { .. } => 0,
-            FormatSimple => 0,
-            FormatWithSpec => -1,
-            ForIter { .. } => {
-                if jump {
-                    -1
-                } else {
-                    1
-                }
-            }
-            IsOp(_) | ContainsOp(_) => -1,
-            JumpIfNotExcMatch(_) => -2,
-            ReturnValue => -1,
-            ReturnConst { .. } => 0,
-            Resume { .. } => 0,
-            YieldValue { .. } => 0,
-            // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
-            Send { .. } => 0,
-            // END_SEND: (receiver, value) -> (value)
-            EndSend => -1,
-            // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) = 3 pop, 2 push = -1
-            CleanupThrow => -1,
-            SetExcInfo => 0,
-            PushExcInfo => 1,    // [exc] -> [prev_exc, exc]
-            CheckExcMatch => 0,  // [exc, type] -> [exc, bool] (pops type, pushes bool)
-            Reraise { .. } => 0, // Exception raised, stack effect doesn't matter
-            SetupAnnotations => 0,
-            BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
-            WithExceptStart => 1, // push __exit__ result
-            PopBlock => 0,
-            RaiseVarargs { kind } => {
-                // Stack effects for different raise kinds:
-                // - Reraise (0): gets from VM state, no stack pop
-                // - Raise (1): pops 1 exception
-                // - RaiseCause (2): pops 2 (exception + cause)
-                // - ReraiseFromStack (3): pops 1 exception from stack
-                match kind.get(arg) {
-                    RaiseKind::BareRaise => 0,
-                    RaiseKind::Raise => -1,
-                    RaiseKind::RaiseCause => -2,
-                    RaiseKind::ReraiseFromStack => -1,
-                }
-            }
-            BuildString { size }
-            | BuildTuple { size, .. }
-            | BuildTupleFromTuples { size, .. }
-            | BuildList { size, .. }
-            | BuildListFromTuples { size, .. }
-            | BuildSet { size, .. }
-            | BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
-            BuildTupleFromIter => 0,
-            BuildMap { size } => {
-                let nargs = size.get(arg) * 2;
-                -(nargs as i32) + 1
-            }
-            BuildMapForCall { size } => {
-                let nargs = size.get(arg);
-                -(nargs as i32) + 1
-            }
-            DictUpdate { .. } => -1,
-            BuildSlice { argc } => {
-                // push 1
-                // pops either 2/3
-                // Default to Two (2 args) if arg is invalid
-                1 - (argc
-                    .try_get(arg)
-                    .unwrap_or(BuildSliceArgCount::Two)
-                    .argc()
-                    .get() as i32)
-            }
-            ListAppend { .. } | SetAdd { .. } => -1,
-            MapAdd { .. } => -2,
-            LoadBuildClass => 1,
-            UnpackSequence { size } => -1 + size.get(arg) as i32,
-            UnpackEx { args } => {
-                let UnpackExArgs { before, after } = args.get(arg);
-                -1 + before as i32 + 1 + after as i32
-            }
-            PopExcept => 0,
-            GetAwaitable => 0,
-            BeforeAsyncWith => 1,
-            GetAIter => 0,
-            GetANext => 1,
-            EndAsyncFor => -2,                 // pops (awaitable, exc) from stack
-            MatchMapping | MatchSequence => 1, // Push bool result
-            MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
-            MatchClass(_) => -2,
-            ExtendedArg => 0,
-            UnaryInvert => 0,
-            UnaryNegative => 0,
-            UnaryNot => 0,
-            GetYieldFromIter => 0,
-            PushNull => 1, // Push NULL for call protocol
-            _ => 0,
-        }
-    }
-
-    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)]
-    fn fmt_dis(
-        &self,
-        arg: OpArg,
-        f: &mut fmt::Formatter<'_>,
-        ctx: &impl InstrDisplayContext,
-        expand_code_objects: bool,
-        pad: usize,
-        level: usize,
-    ) -> fmt::Result {
-        macro_rules! w {
-            ($variant:ident) => {
-                write!(f, stringify!($variant))
-            };
-            ($variant:ident, $map:ident = $arg_marker:expr) => {{
-                let arg = $arg_marker.get(arg);
-                write!(f, "{:pad$}({}, {})", stringify!($variant), arg, $map(arg))
-            }};
-            ($variant:ident, $arg_marker:expr) => {
-                write!(f, "{:pad$}({})", stringify!($variant), $arg_marker.get(arg))
-            };
-            ($variant:ident, ?$arg_marker:expr) => {
-                write!(
-                    f,
-                    "{:pad$}({:?})",
-                    stringify!($variant),
-                    $arg_marker.get(arg)
-                )
-            };
-        }
-
-        let varname = |i: u32| ctx.get_varname(i as usize);
-        let name = |i: u32| ctx.get_name(i as usize);
-        let cell_name = |i: u32| ctx.get_cell_name(i as usize);
-
-        let fmt_const =
-            |op: &str, arg: OpArg, f: &mut fmt::Formatter<'_>, idx: &Arg<u32>| -> fmt::Result {
-                let value = ctx.get_constant(idx.get(arg) as usize);
-                match value.borrow_constant() {
-                    BorrowedConstant::Code { code } if expand_code_objects => {
-                        write!(f, "{op:pad$}({code:?}):")?;
-                        code.display_inner(f, true, level + 1)?;
-                        Ok(())
-                    }
-                    c => {
-                        write!(f, "{op:pad$}(")?;
-                        c.fmt_display(f)?;
-                        write!(f, ")")
-                    }
-                }
-            };
-
-        match self {
-            BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
-            BeforeWith => w!(BEFORE_WITH),
-            BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
-            BinarySubscr => w!(BINARY_SUBSCR),
-            Break { target } => w!(BREAK, target),
-            BuildList { size } => w!(BUILD_LIST, size),
-            BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
-            BuildMap { size } => w!(BUILD_MAP, size),
-            BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
-            BuildSet { size } => w!(BUILD_SET, size),
-            BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
-            BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
-            BuildString { size } => w!(BUILD_STRING, size),
-            BuildTuple { size } => w!(BUILD_TUPLE, size),
-            BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
-            BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
-            Call { nargs } => w!(CALL, nargs),
-            CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
-            CallKw { nargs } => w!(CALL_KW, nargs),
-            CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
-            CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
-            CheckEgMatch => w!(CHECK_EG_MATCH),
-            CheckExcMatch => w!(CHECK_EXC_MATCH),
-            CleanupThrow => w!(CLEANUP_THROW),
-            CompareOp { op } => w!(COMPARE_OP, ?op),
-            ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
-            Continue { target } => w!(CONTINUE, target),
-            ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
-            CopyItem { index } => w!(COPY, index),
-            DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
-            DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
-            DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
-            DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
-            DeleteName(idx) => w!(DELETE_NAME, name = idx),
-            DeleteSubscr => w!(DELETE_SUBSCR),
-            DictUpdate { index } => w!(DICT_UPDATE, index),
-            EndAsyncFor => w!(END_ASYNC_FOR),
-            EndSend => w!(END_SEND),
-            ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
-            ForIter { target } => w!(FOR_ITER, target),
-            FormatSimple => w!(FORMAT_SIMPLE),
-            FormatWithSpec => w!(FORMAT_WITH_SPEC),
-            GetAIter => w!(GET_AITER),
-            GetANext => w!(GET_ANEXT),
-            GetAwaitable => w!(GET_AWAITABLE),
-            Reserved => w!(RESERVED),
-            GetIter => w!(GET_ITER),
-            GetLen => w!(GET_LEN),
-            ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
-            ImportName { idx } => w!(IMPORT_NAME, name = idx),
-            IsOp(inv) => w!(IS_OP, ?inv),
-            Jump { target } => w!(JUMP, target),
-            JumpBackward { target } => w!(JUMP_BACKWARD, target),
-            JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
-            JumpForward { target } => w!(JUMP_FORWARD, target),
-            JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
-            JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
-            JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
-            ListAppend { i } => w!(LIST_APPEND, i),
-            LoadAttr { idx } => {
-                let encoded = idx.get(arg);
-                let (name_idx, is_method) = decode_load_attr_arg(encoded);
-                let attr_name = name(name_idx);
-                if is_method {
-                    write!(
-                        f,
-                        "{:pad$}({}, {}, method=true)",
-                        "LOAD_ATTR", encoded, attr_name
-                    )
-                } else {
-                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
-                }
-            }
-            LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
-            LoadBuildClass => w!(LOAD_BUILD_CLASS),
-            LoadClassDeref(idx) => w!(LOAD_CLASSDEREF, cell_name = idx),
-            LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
-            LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
-            LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
-            LoadFast(idx) => w!(LOAD_FAST, varname = idx),
-            LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
-            LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
-            LoadName(idx) => w!(LOAD_NAME, name = idx),
-            MakeFunction => w!(MAKE_FUNCTION),
-            MapAdd { i } => w!(MAP_ADD, i),
-            MatchClass(arg) => w!(MATCH_CLASS, arg),
-            MatchKeys => w!(MATCH_KEYS),
-            MatchMapping => w!(MATCH_MAPPING),
-            MatchSequence => w!(MATCH_SEQUENCE),
-            Nop => w!(NOP),
-            PopBlock => w!(POP_BLOCK),
-            PopExcept => w!(POP_EXCEPT),
-            PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
-            PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
-            PopTop => w!(POP_TOP),
-            PushExcInfo => w!(PUSH_EXC_INFO),
-            PushNull => w!(PUSH_NULL),
-            RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
-            Reraise { depth } => w!(RERAISE, depth),
-            Resume { arg } => w!(RESUME, arg),
-            ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
-            ReturnValue => w!(RETURN_VALUE),
-            Send { target } => w!(SEND, target),
-            SetAdd { i } => w!(SET_ADD, i),
-            SetExcInfo => w!(SET_EXC_INFO),
-            SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
-            SetupAnnotations => w!(SETUP_ANNOTATIONS),
-            StoreAttr { idx } => w!(STORE_ATTR, name = idx),
-            StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
-            StoreFast(idx) => w!(STORE_FAST, varname = idx),
-            StoreFastLoadFast {
-                store_idx,
-                load_idx,
-            } => {
-                write!(f, "STORE_FAST_LOAD_FAST")?;
-                write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
-            }
-            StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
-            StoreName(idx) => w!(STORE_NAME, name = idx),
-            StoreSubscr => w!(STORE_SUBSCR),
-            Subscript => w!(SUBSCRIPT),
-            Swap { index } => w!(SWAP, index),
-            ToBool => w!(TO_BOOL),
-            UnpackEx { args } => w!(UNPACK_EX, args),
-            UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
-            WithExceptStart => w!(WITH_EXCEPT_START),
-            UnaryInvert => w!(UNARY_INVERT),
-            UnaryNegative => w!(UNARY_NEGATIVE),
-            UnaryNot => w!(UNARY_NOT),
-            YieldValue { arg } => w!(YIELD_VALUE, arg),
-            GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
-            _ => w!(RUSTPYTHON_PLACEHOLDER),
-        }
-    }
-}
-
 pub trait InstrDisplayContext {
     type Constant: Constant;
 
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
new file mode 100644
index 00000000000..94c3413fecc
--- /dev/null
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -0,0 +1,814 @@
+use alloc::fmt;
+use std::mem;
+
+use crate::{
+    bytecode::{
+        Arg,
+        BinaryOperator,
+        BorrowedConstant,
+        BuildSliceArgCount,
+        ComparisonOperator,
+        Constant,
+        ConvertValueOparg,
+        // a
+        InstrDisplayContext,
+        IntrinsicFunction1,
+        IntrinsicFunction2,
+        Invert,
+        Label,
+        MakeFunctionFlags,
+        NameIdx,
+        OpArg,
+        RaiseKind,
+        UnpackExArgs,
+        decode_load_attr_arg,
+    },
+    marshal::MarshalError,
+};
+
+/// 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)]
+#[repr(u8)]
+pub enum Instruction {
+    // ==================== No-argument instructions (opcode < 44) ====================
+    Cache = 0, // Placeholder
+    BeforeAsyncWith = 1,
+    BeforeWith = 2,
+    BinaryOpInplaceAddUnicode = 3, // Placeholder
+    BinarySlice = 4,               // Placeholder
+    BinarySubscr = 5,
+    CheckEgMatch = 6,
+    CheckExcMatch = 7,
+    CleanupThrow = 8,
+    DeleteSubscr = 9,
+    EndAsyncFor = 10,
+    EndFor = 11, // Placeholder
+    EndSend = 12,
+    ExitInitCheck = 13, // Placeholder
+    FormatSimple = 14,
+    FormatWithSpec = 15,
+    GetAIter = 16,
+    Reserved = 17,
+    GetANext = 18,
+    GetIter = 19,
+    GetLen = 20,
+    GetYieldFromIter = 21,
+    InterpreterExit = 22,    // Placeholder
+    LoadAssertionError = 23, // Placeholder
+    LoadBuildClass = 24,
+    LoadLocals = 25, // Placeholder
+    MakeFunction = 26,
+    MatchKeys = 27,
+    MatchMapping = 28,
+    MatchSequence = 29,
+    Nop = 30,
+    PopExcept = 31,
+    PopTop = 32,
+    PushExcInfo = 33,
+    PushNull = 34,        // Placeholder
+    ReturnGenerator = 35, // Placeholder
+    ReturnValue = 36,
+    SetupAnnotations = 37,
+    StoreSlice = 38, // Placeholder
+    StoreSubscr = 39,
+    ToBool = 40,
+    UnaryInvert = 41,
+    UnaryNegative = 42,
+    UnaryNot = 43,
+    WithExceptStart = 44,
+    // ==================== With-argument instructions (opcode > 44) ====================
+    BinaryOp {
+        op: Arg<BinaryOperator>,
+    } = 45,
+    BuildConstKeyMap {
+        size: Arg<u32>,
+    } = 46, // Placeholder
+    BuildList {
+        size: Arg<u32>,
+    } = 47,
+    BuildMap {
+        size: Arg<u32>,
+    } = 48,
+    BuildSet {
+        size: Arg<u32>,
+    } = 49,
+    BuildSlice {
+        argc: Arg<BuildSliceArgCount>,
+    } = 50,
+    BuildString {
+        size: Arg<u32>,
+    } = 51,
+    BuildTuple {
+        size: Arg<u32>,
+    } = 52,
+    Call {
+        nargs: Arg<u32>,
+    } = 53,
+    CallFunctionEx {
+        has_kwargs: Arg<bool>,
+    } = 54,
+    CallIntrinsic1 {
+        func: Arg<IntrinsicFunction1>,
+    } = 55,
+    CallIntrinsic2 {
+        func: Arg<IntrinsicFunction2>,
+    } = 56,
+    CallKw {
+        nargs: Arg<u32>,
+    } = 57,
+    CompareOp {
+        op: Arg<ComparisonOperator>,
+    } = 58,
+    ContainsOp(Arg<Invert>) = 59,
+    ConvertValue {
+        oparg: Arg<ConvertValueOparg>,
+    } = 60,
+    Copy {
+        index: Arg<u32>,
+    } = 61,
+    CopyFreeVars {
+        count: Arg<u32>,
+    } = 62, // Placeholder
+    DeleteAttr {
+        idx: Arg<NameIdx>,
+    } = 63,
+    DeleteDeref(Arg<NameIdx>) = 64,
+    DeleteFast(Arg<NameIdx>) = 65,
+    DeleteGlobal(Arg<NameIdx>) = 66,
+    DeleteName(Arg<NameIdx>) = 67,
+    DictMerge {
+        index: Arg<u32>,
+    } = 68, // Placeholder
+    DictUpdate {
+        index: Arg<u32>,
+    } = 69,
+    EnterExecutor = 70, // Placeholder
+    ExtendedArg = 71,
+    ForIter {
+        target: Arg<Label>,
+    } = 72,
+    GetAwaitable = 73, // TODO: Make this instruction to hold an oparg
+    ImportFrom {
+        idx: Arg<NameIdx>,
+    } = 74,
+    ImportName {
+        idx: Arg<NameIdx>,
+    } = 75,
+    IsOp(Arg<Invert>) = 76,
+    JumpBackward {
+        target: Arg<Label>,
+    } = 77, // Placeholder
+    JumpBackwardNoInterrupt {
+        target: Arg<Label>,
+    } = 78, // Placeholder
+    JumpForward {
+        target: Arg<Label>,
+    } = 79, // Placeholder
+    ListAppend {
+        i: Arg<u32>,
+    } = 80,
+    ListExtend {
+        i: Arg<u32>,
+    } = 81, // Placeholder
+    LoadAttr {
+        idx: Arg<NameIdx>,
+    } = 82,
+    LoadConst {
+        idx: Arg<u32>,
+    } = 83,
+    LoadDeref(Arg<NameIdx>) = 84,
+    LoadFast(Arg<NameIdx>) = 85,
+    LoadFastAndClear(Arg<NameIdx>) = 86,
+    LoadFastCheck(Arg<NameIdx>) = 87, // Placeholder
+    LoadFastLoadFast {
+        arg: Arg<u32>,
+    } = 88, // Placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>) = 89, // Placeholder
+    LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
+    LoadGlobal(Arg<NameIdx>) = 91,
+    LoadName(Arg<NameIdx>) = 92,
+    LoadSuperAttr {
+        arg: Arg<u32>,
+    } = 93, // Placeholder
+    MakeCell(Arg<NameIdx>) = 94, // Placeholder
+    MapAdd {
+        i: Arg<u32>,
+    } = 95,
+    MatchClass(Arg<u32>) = 96,
+    PopJumpIfFalse {
+        target: Arg<Label>,
+    } = 97,
+    PopJumpIfNone {
+        target: Arg<Label>,
+    } = 98, // Placeholder
+    PopJumpIfNotNone {
+        target: Arg<Label>,
+    } = 99, // Placeholder
+    PopJumpIfTrue {
+        target: Arg<Label>,
+    } = 100,
+    RaiseVarargs {
+        kind: Arg<RaiseKind>,
+    } = 101,
+    Reraise {
+        depth: Arg<u32>,
+    } = 102,
+    ReturnConst {
+        idx: Arg<u32>,
+    } = 103,
+    Send {
+        target: Arg<Label>,
+    } = 104,
+    SetAdd {
+        i: Arg<u32>,
+    } = 105,
+    SetFunctionAttribute {
+        attr: Arg<MakeFunctionFlags>,
+    } = 106,
+    SetUpdate {
+        i: Arg<u32>,
+    } = 107, // Placeholder
+    StoreAttr {
+        idx: Arg<NameIdx>,
+    } = 108,
+    StoreDeref(Arg<NameIdx>) = 109,
+    StoreFast(Arg<NameIdx>) = 110,
+    StoreFastLoadFast {
+        store_idx: Arg<NameIdx>,
+        load_idx: Arg<NameIdx>,
+    } = 111,
+    StoreFastStoreFast {
+        arg: Arg<u32>,
+    } = 112, // Placeholder
+    StoreGlobal(Arg<NameIdx>) = 113,
+    StoreName(Arg<NameIdx>) = 114,
+    Swap {
+        index: Arg<u32>,
+    } = 115,
+    UnpackEx {
+        args: Arg<UnpackExArgs>,
+    } = 116,
+    UnpackSequence {
+        size: Arg<u32>,
+    } = 117,
+    YieldValue {
+        arg: Arg<u32>,
+    } = 118,
+    Resume {
+        arg: Arg<u32>,
+    } = 149,
+    // ==================== 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.
+    Break {
+        target: Arg<Label>,
+    } = 119,
+    BuildListFromTuples {
+        size: Arg<u32>,
+    } = 120,
+    BuildMapForCall {
+        size: Arg<u32>,
+    } = 121,
+    BuildSetFromTuples {
+        size: Arg<u32>,
+    } = 122,
+    BuildTupleFromIter = 123,
+    BuildTupleFromTuples {
+        size: Arg<u32>,
+    } = 124,
+    Continue {
+        target: Arg<Label>,
+    } = 128,
+    JumpIfFalseOrPop {
+        target: Arg<Label>,
+    } = 129,
+    JumpIfTrueOrPop {
+        target: Arg<Label>,
+    } = 130,
+    JumpIfNotExcMatch(Arg<Label>) = 131,
+    LoadClassDeref(Arg<NameIdx>) = 132,
+    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);
+
+impl From<Instruction> for u8 {
+    #[inline]
+    fn from(ins: Instruction) -> Self {
+        // SAFETY: there's no padding bits
+        unsafe { core::mem::transmute::<Instruction, Self>(ins) }
+    }
+}
+
+impl TryFrom<u8> for Instruction {
+    type Error = MarshalError;
+
+    #[inline]
+    fn try_from(value: u8) -> Result<Self, MarshalError> {
+        // CPython-compatible opcodes (0-118)
+        let cpython_start = u8::from(Self::Cache);
+        let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
+
+        // Resume has a non-contiguous opcode (149)
+        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+
+        // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
+        let custom_ops: &[u8] = &[
+            u8::from(Self::Break {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::BuildListFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildMapForCall {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildSetFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildTupleFromIter),
+            u8::from(Self::BuildTupleFromTuples {
+                size: Arg::marker(),
+            }),
+            // 125, 126, 127 are unused
+            u8::from(Self::Continue {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfFalseOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfTrueOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
+            u8::from(Self::LoadClassDeref(Arg::marker())),
+            u8::from(Self::SetExcInfo),
+            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 {
+            Err(Self::Error::InvalidBytecode)
+        }
+    }
+}
+
+impl Instruction {
+    /// Gets the label stored inside this instruction, if it exists
+    #[inline]
+    pub const fn label_arg(&self) -> Option<Arg<Label>> {
+        match self {
+            Self::Jump { target: l }
+            | Self::JumpBackward { target: l }
+            | Self::JumpBackwardNoInterrupt { target: l }
+            | Self::JumpForward { target: l }
+            | Self::JumpIfNotExcMatch(l)
+            | Self::PopJumpIfTrue { target: l }
+            | Self::PopJumpIfFalse { target: l }
+            | Self::JumpIfTrueOrPop { target: l }
+            | Self::JumpIfFalseOrPop { target: l }
+            | Self::ForIter { target: l }
+            | Self::Break { target: l }
+            | Self::Continue { target: l }
+            | Self::Send { target: l } => Some(*l),
+            _ => None,
+        }
+    }
+
+    /// Whether this is an unconditional branching
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
+    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
+    pub const fn unconditional_branch(&self) -> bool {
+        matches!(
+            self,
+            Self::Jump { .. }
+                | Self::JumpForward { .. }
+                | Self::JumpBackward { .. }
+                | Self::JumpBackwardNoInterrupt { .. }
+                | Self::Continue { .. }
+                | Self::Break { .. }
+                | Self::ReturnValue
+                | Self::ReturnConst { .. }
+                | Self::RaiseVarargs { .. }
+                | Self::Reraise { .. }
+        )
+    }
+
+    /// What effect this instruction has on the stack
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label};
+    /// let (target, jump_arg) = Arg::new(Label(0xF));
+    /// let jump_instruction = Instruction::Jump { target };
+    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
+    /// ```
+    ///
+    pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
+        match self {
+            Self::Nop => 0,
+            Self::ImportName { .. } => -1,
+            Self::ImportFrom { .. } => 1,
+            Self::LoadFast(_) => 1,
+            Self::LoadFastAndClear(_) => 1,
+            Self::LoadName(_) => 1,
+            Self::LoadGlobal(_) => 1,
+            Self::LoadDeref(_) => 1,
+            Self::LoadClassDeref(_) => 1,
+            Self::StoreFast(_) => -1,
+            Self::StoreName(_) => -1,
+            Self::StoreGlobal(_) => -1,
+            Self::StoreDeref(_) => -1,
+            Self::StoreFastLoadFast { .. } => 0, // pop 1, push 1
+            Self::DeleteFast(_) => 0,
+            Self::DeleteName(_) => 0,
+            Self::DeleteGlobal(_) => 0,
+            Self::DeleteDeref(_) => 0,
+            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,
+            Self::Reserved => 0,
+            Self::BinaryOp { .. } => -1,
+            Self::CompareOp { .. } => -1,
+            Self::BinarySubscr => -1,
+            Self::Copy { .. } => 1,
+            Self::PopTop => -1,
+            Self::Swap { .. } => 0,
+            Self::ToBool => 0,
+            Self::GetIter => 0,
+            Self::GetLen => 1,
+            Self::CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
+            Self::CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
+            Self::Continue { .. } => 0,
+            Self::Break { .. } => 0,
+            Self::Jump { .. } => 0,
+            Self::PopJumpIfTrue { .. } => -1,
+            Self::PopJumpIfFalse { .. } => -1,
+            Self::JumpIfTrueOrPop { .. } => {
+                if jump {
+                    0
+                } else {
+                    -1
+                }
+            }
+            Self::JumpIfFalseOrPop { .. } => {
+                if jump {
+                    0
+                } else {
+                    -1
+                }
+            }
+            Self::MakeFunction => {
+                // CPython 3.13 style: MakeFunction only pops code object
+                -1 + 1 // pop code, push function
+            }
+            Self::SetFunctionAttribute { .. } => {
+                // pops attribute value and function, pushes function back
+                -2 + 1
+            }
+            // Call: pops nargs + self_or_null + callable, pushes result
+            Self::Call { nargs } => -(nargs.get(arg) as i32) - 2 + 1,
+            // CallKw: pops kw_names_tuple + nargs + self_or_null + callable, pushes result
+            Self::CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 2 + 1,
+            // CallFunctionEx: pops kwargs(if any) + args_tuple + self_or_null + callable, pushes result
+            Self::CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 2 + 1,
+            Self::CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
+            Self::ConvertValue { .. } => 0,
+            Self::FormatSimple => 0,
+            Self::FormatWithSpec => -1,
+            Self::ForIter { .. } => {
+                if jump {
+                    -1
+                } else {
+                    1
+                }
+            }
+            Self::IsOp(_) => -1,
+            Self::ContainsOp(_) => -1,
+            Self::JumpIfNotExcMatch(_) => -2,
+            Self::ReturnValue => -1,
+            Self::ReturnConst { .. } => 0,
+            Self::Resume { .. } => 0,
+            Self::YieldValue { .. } => 0,
+            // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
+            Self::Send { .. } => 0,
+            // END_SEND: (receiver, value) -> (value)
+            Self::EndSend => -1,
+            // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) = 3 pop, 2 push = -1
+            Self::CleanupThrow => -1,
+            Self::SetExcInfo => 0,
+            Self::PushExcInfo => 1,    // [exc] -> [prev_exc, exc]
+            Self::CheckExcMatch => 0,  // [exc, type] -> [exc, bool] (pops type, pushes bool)
+            Self::Reraise { .. } => 0, // Exception raised, stack effect doesn't matter
+            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
+                // - Raise (1): pops 1 exception
+                // - RaiseCause (2): pops 2 (exception + cause)
+                // - ReraiseFromStack (3): pops 1 exception from stack
+                match kind.get(arg) {
+                    RaiseKind::BareRaise => 0,
+                    RaiseKind::Raise => -1,
+                    RaiseKind::RaiseCause => -2,
+                    RaiseKind::ReraiseFromStack => -1,
+                }
+            }
+            Self::BuildString { size } => -(size.get(arg) as i32) + 1,
+            Self::BuildTuple { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildTupleFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildList { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildListFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildSet { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildTupleFromIter => 0,
+            Self::BuildMap { size } => {
+                let nargs = size.get(arg) * 2;
+                -(nargs as i32) + 1
+            }
+            Self::BuildMapForCall { size } => {
+                let nargs = size.get(arg);
+                -(nargs as i32) + 1
+            }
+            Self::DictUpdate { .. } => -1,
+            Self::BuildSlice { argc } => {
+                // push 1
+                // pops either 2/3
+                // Default to Two (2 args) if arg is invalid
+                1 - (argc
+                    .try_get(arg)
+                    .unwrap_or(BuildSliceArgCount::Two)
+                    .argc()
+                    .get() as i32)
+            }
+            Self::ListAppend { .. } => -1,
+            Self::SetAdd { .. } => -1,
+            Self::MapAdd { .. } => -2,
+            Self::LoadBuildClass => 1,
+            Self::UnpackSequence { size } => -1 + size.get(arg) as i32,
+            Self::UnpackEx { args } => {
+                let UnpackExArgs { before, after } = args.get(arg);
+                -1 + before as i32 + 1 + after as i32
+            }
+            Self::PopExcept => 0,
+            Self::GetAwaitable => 0,
+            Self::BeforeAsyncWith => 1,
+            Self::GetAIter => 0,
+            Self::GetANext => 1,
+            Self::EndAsyncFor => -2,  // pops (awaitable, exc) from stack
+            Self::MatchMapping => 1,  // Push bool result
+            Self::MatchSequence => 1, // Push bool result
+            Self::MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
+            Self::MatchClass(_) => -2,
+            Self::ExtendedArg => 0,
+            Self::UnaryInvert => 0,
+            Self::UnaryNegative => 0,
+            Self::UnaryNot => 0,
+            Self::GetYieldFromIter => 0,
+            Self::PushNull => 1, // Push NULL for call protocol
+            _ => 0,
+        }
+    }
+
+    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(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize,
+    ) -> fmt::Result {
+        macro_rules! w {
+            ($variant:ident) => {
+                write!(f, stringify!($variant))
+            };
+            ($variant:ident, $map:ident = $arg_marker:expr) => {{
+                let arg = $arg_marker.get(arg);
+                write!(f, "{:pad$}({}, {})", stringify!($variant), arg, $map(arg))
+            }};
+            ($variant:ident, $arg_marker:expr) => {
+                write!(f, "{:pad$}({})", stringify!($variant), $arg_marker.get(arg))
+            };
+            ($variant:ident, ?$arg_marker:expr) => {
+                write!(
+                    f,
+                    "{:pad$}({:?})",
+                    stringify!($variant),
+                    $arg_marker.get(arg)
+                )
+            };
+        }
+
+        let varname = |i: u32| ctx.get_varname(i as usize);
+        let name = |i: u32| ctx.get_name(i as usize);
+        let cell_name = |i: u32| ctx.get_cell_name(i as usize);
+
+        let fmt_const =
+            |op: &str, arg: OpArg, f: &mut fmt::Formatter<'_>, idx: &Arg<u32>| -> fmt::Result {
+                let value = ctx.get_constant(idx.get(arg) as usize);
+                match value.borrow_constant() {
+                    BorrowedConstant::Code { code } if expand_code_objects => {
+                        write!(f, "{op:pad$}({code:?}):")?;
+                        code.display_inner(f, true, level + 1)?;
+                        Ok(())
+                    }
+                    c => {
+                        write!(f, "{op:pad$}(")?;
+                        c.fmt_display(f)?;
+                        write!(f, ")")
+                    }
+                }
+            };
+
+        match self {
+            Self::BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
+            Self::BeforeWith => w!(BEFORE_WITH),
+            Self::BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
+            Self::BinarySubscr => w!(BINARY_SUBSCR),
+            Self::Break { target } => w!(BREAK, target),
+            Self::BuildList { size } => w!(BUILD_LIST, size),
+            Self::BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
+            Self::BuildMap { size } => w!(BUILD_MAP, size),
+            Self::BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
+            Self::BuildSet { size } => w!(BUILD_SET, size),
+            Self::BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
+            Self::BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
+            Self::BuildString { size } => w!(BUILD_STRING, size),
+            Self::BuildTuple { size } => w!(BUILD_TUPLE, size),
+            Self::BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
+            Self::BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
+            Self::Call { nargs } => w!(CALL, nargs),
+            Self::CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
+            Self::CallKw { nargs } => w!(CALL_KW, nargs),
+            Self::CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
+            Self::CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
+            Self::CheckEgMatch => w!(CHECK_EG_MATCH),
+            Self::CheckExcMatch => w!(CHECK_EXC_MATCH),
+            Self::CleanupThrow => w!(CLEANUP_THROW),
+            Self::CompareOp { op } => w!(COMPARE_OP, ?op),
+            Self::ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
+            Self::Continue { target } => w!(CONTINUE, target),
+            Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
+            Self::Copy { index } => w!(COPY, index),
+            Self::DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
+            Self::DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
+            Self::DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
+            Self::DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
+            Self::DeleteName(idx) => w!(DELETE_NAME, name = idx),
+            Self::DeleteSubscr => w!(DELETE_SUBSCR),
+            Self::DictUpdate { index } => w!(DICT_UPDATE, index),
+            Self::EndAsyncFor => w!(END_ASYNC_FOR),
+            Self::EndSend => w!(END_SEND),
+            Self::ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
+            Self::ForIter { target } => w!(FOR_ITER, target),
+            Self::FormatSimple => w!(FORMAT_SIMPLE),
+            Self::FormatWithSpec => w!(FORMAT_WITH_SPEC),
+            Self::GetAIter => w!(GET_AITER),
+            Self::GetANext => w!(GET_ANEXT),
+            Self::GetAwaitable => w!(GET_AWAITABLE),
+            Self::Reserved => w!(RESERVED),
+            Self::GetIter => w!(GET_ITER),
+            Self::GetLen => w!(GET_LEN),
+            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),
+            Self::JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
+            Self::JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
+            Self::JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
+            Self::ListAppend { i } => w!(LIST_APPEND, i),
+            Self::LoadAttr { idx } => {
+                let encoded = idx.get(arg);
+                let (name_idx, is_method) = decode_load_attr_arg(encoded);
+                let attr_name = name(name_idx);
+                if is_method {
+                    write!(
+                        f,
+                        "{:pad$}({}, {}, method=true)",
+                        "LOAD_ATTR", encoded, attr_name
+                    )
+                } else {
+                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
+                }
+            }
+            Self::LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
+            Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
+            Self::LoadClassDeref(idx) => w!(LOAD_CLASSDEREF, cell_name = idx),
+            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),
+            Self::LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
+            Self::LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
+            Self::LoadName(idx) => w!(LOAD_NAME, name = idx),
+            Self::MakeFunction => w!(MAKE_FUNCTION),
+            Self::MapAdd { i } => w!(MAP_ADD, i),
+            Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
+            Self::MatchKeys => w!(MATCH_KEYS),
+            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),
+            Self::PopTop => w!(POP_TOP),
+            Self::PushExcInfo => w!(PUSH_EXC_INFO),
+            Self::PushNull => w!(PUSH_NULL),
+            Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
+            Self::Reraise { depth } => w!(RERAISE, depth),
+            Self::Resume { arg } => w!(RESUME, arg),
+            Self::ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
+            Self::ReturnValue => w!(RETURN_VALUE),
+            Self::Send { target } => w!(SEND, target),
+            Self::SetAdd { i } => w!(SET_ADD, i),
+            Self::SetExcInfo => w!(SET_EXC_INFO),
+            Self::SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
+            Self::SetupAnnotations => w!(SETUP_ANNOTATIONS),
+            Self::StoreAttr { idx } => w!(STORE_ATTR, name = idx),
+            Self::StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
+            Self::StoreFast(idx) => w!(STORE_FAST, varname = idx),
+            Self::StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
+                write!(f, "STORE_FAST_LOAD_FAST")?;
+                write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
+            }
+            Self::StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
+            Self::StoreName(idx) => w!(STORE_NAME, name = idx),
+            Self::StoreSubscr => w!(STORE_SUBSCR),
+            Self::Subscript => w!(SUBSCRIPT),
+            Self::Swap { index } => w!(SWAP, index),
+            Self::ToBool => w!(TO_BOOL),
+            Self::UnpackEx { args } => w!(UNPACK_EX, args),
+            Self::UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
+            Self::WithExceptStart => w!(WITH_EXCEPT_START),
+            Self::UnaryInvert => w!(UNARY_INVERT),
+            Self::UnaryNegative => w!(UNARY_NEGATIVE),
+            Self::UnaryNot => w!(UNARY_NOT),
+            Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
+            Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
+            _ => w!(RUSTPYTHON_PLACEHOLDER),
+        }
+    }
+}

From 8ac2d00b4ced5d23395b2c8b6ee203512fcf0c8c Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 15:39:11 +0200
Subject: [PATCH 2/7] Fix codegen and frame.rs

---
 crates/codegen/src/compile.rs | 62 +++++++++++++++++------------------
 crates/vm/src/frame.rs        |  2 +-
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index bbc8d4235fc..42031e4ca20 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -1382,7 +1382,7 @@ impl Compiler {
 
             if let Stmt::Expr(StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -1420,7 +1420,7 @@ impl Compiler {
                 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::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -1938,7 +1938,7 @@ impl Compiler {
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, Instruction::CopyItem { index: 1_u32 });
+                        emit!(self, Instruction::Copy { index: 1_u32 });
                     }
                     self.compile_store(target)?;
                 }
@@ -2205,7 +2205,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
@@ -2230,7 +2230,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
@@ -2256,7 +2256,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
             };
@@ -2396,7 +2396,7 @@ impl Compiler {
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::CopyItem { index: 3_u32 });
+                emit!(self, Instruction::Copy { index: 3_u32 });
                 emit!(self, Instruction::PopExcept);
                 emit!(
                     self,
@@ -2457,7 +2457,7 @@ impl Compiler {
             // check if this handler can handle the exception:
             if let Some(exc_type) = type_ {
                 // Duplicate exception for test:
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
 
                 // Check exception type:
                 self.compile_expression(exc_type)?;
@@ -2598,7 +2598,7 @@ 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::CopyItem { index: 3_u32 });
+        emit!(self, Instruction::Copy { index: 3_u32 });
         emit!(self, Instruction::PopExcept);
         emit!(
             self,
@@ -2693,7 +2693,7 @@ 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::CopyItem { index: 3_u32 });
+            emit!(self, Instruction::Copy { index: 3_u32 });
             // POP_EXCEPT: restore prev_exc as current exception
             emit!(self, Instruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
@@ -2787,7 +2787,7 @@ impl Compiler {
                 emit!(self, Instruction::BuildList { size: 0 });
                 // Stack: [prev_exc, exc, []]
                 // ADDOP_I(c, loc, COPY, 2);
-                emit!(self, Instruction::CopyItem { index: 2 });
+                emit!(self, Instruction::Copy { index: 2 });
                 // Stack: [prev_exc, exc, [], exc_copy]
                 // Now stack is: [prev_exc, orig, list, rest]
             }
@@ -2817,7 +2817,7 @@ impl Compiler {
 
             // ADDOP_I(c, loc, COPY, 1);
             // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
-            emit!(self, Instruction::CopyItem { index: 1 });
+            emit!(self, Instruction::Copy { index: 1 });
             self.emit_load_const(ConstantData::None);
             emit!(self, Instruction::IsOp(bytecode::Invert::No)); // is None?
             emit!(
@@ -2947,7 +2947,7 @@ impl Compiler {
         // Stack: [prev_exc, result]
 
         // COPY 1
-        emit!(self, Instruction::CopyItem { index: 1 });
+        emit!(self, Instruction::Copy { index: 1 });
         // Stack: [prev_exc, result, result]
 
         // POP_JUMP_IF_NOT_NONE reraise
@@ -3149,7 +3149,7 @@ impl Compiler {
 
         // Handle docstring if present
         if let Some(doc) = doc_str {
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             self.emit_load_const(ConstantData::Str {
                 value: doc.to_string().into(),
             });
@@ -3633,7 +3633,7 @@ impl Compiler {
 
         if let Some(classcell_idx) = classcell_idx {
             emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
             emit!(self, Instruction::StoreName(classcell));
         } else {
@@ -4081,7 +4081,7 @@ 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::CopyItem { index: 3 });
+        emit!(self, Instruction::Copy { index: 3 });
         emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
@@ -4384,7 +4384,7 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, Instruction::CopyItem { 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() });
@@ -4457,7 +4457,7 @@ impl Compiler {
 
         // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
         pc.on_top += 1;
-        emit!(self, Instruction::CopyItem { 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.
@@ -4558,7 +4558,7 @@ impl Compiler {
         // 2. Emit MATCH_CLASS with nargs.
         emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
         // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::CopyItem { 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.
@@ -4723,7 +4723,7 @@ impl Compiler {
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, Instruction::CopyItem { 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)
@@ -4776,7 +4776,7 @@ impl Compiler {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
                 emit!(
                     self,
-                    Instruction::CopyItem {
+                    Instruction::Copy {
                         index: 1 + remaining
                     }
                 );
@@ -4833,7 +4833,7 @@ impl Compiler {
             pc.fail_pop.clear();
             pc.on_top = 0;
             // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -5080,7 +5080,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::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -5127,7 +5127,7 @@ impl Compiler {
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 emit!(self, Instruction::PopJumpIfFalse { target: end });
                 emit!(self, Instruction::PopTop);
             }
@@ -5207,13 +5207,13 @@ impl Compiler {
 
             // store rhs for the next comparison in chain
             emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::CopyItem { 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, Instruction::CopyItem { index: 1 });
+            emit!(self, Instruction::Copy { index: 1 });
             // emit!(self, Instruction::ToBool); // TODO: Uncomment this
             emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
             emit!(self, Instruction::PopTop);
@@ -5398,8 +5398,8 @@ 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::CopyItem { index: 2_u32 });
-                emit!(self, Instruction::CopyItem { index: 2_u32 });
+                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { index: 2_u32 });
                 emit!(self, Instruction::Subscript);
                 AugAssignKind::Subscript
             }
@@ -5407,7 +5407,7 @@ impl Compiler {
                 let attr = attr.as_str();
                 self.check_forbidden_name(attr, NameUsage::Store)?;
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 let idx = self.name(attr);
                 emit!(self, Instruction::LoadAttr { idx });
                 AugAssignKind::Attr { idx }
@@ -5564,7 +5564,7 @@ impl Compiler {
         for value in values {
             self.compile_expression(value)?;
 
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             match op {
                 BoolOp::And => {
                     emit!(
@@ -6062,7 +6062,7 @@ impl Compiler {
                 range: _,
             }) => {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 self.compile_store(target)?;
             }
             Expr::FString(fstring) => {
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index dd5fc685643..fca6920df34 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -762,7 +762,7 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::ConvertValue { oparg: conversion } => {
                 self.convert_value(conversion.get(arg), vm)
             }
-            bytecode::Instruction::CopyItem { index } => {
+            bytecode::Instruction::Copy { index } => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython

From 437fe307b97e00ea134e075182468685039ee960 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 15:39:26 +0200
Subject: [PATCH 3/7] Adjust script

---
 scripts/generate_opcode_metadata.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index 5c0c3811259..b7d6228ab75 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -10,7 +10,9 @@
 import typing
 
 ROOT = pathlib.Path(__file__).parents[1]
-BYTECODE_FILE = ROOT / "crates" / "compiler-core" / "src" / "bytecode.rs"
+BYTECODE_FILE = (
+    ROOT / "crates" / "compiler-core" / "src" / "bytecode" / "instruction.rs"
+)
 OPCODE_METADATA_FILE = ROOT / "Lib" / "_opcode_metadata.py"
 
 
@@ -20,10 +22,7 @@ class Opcode(typing.NamedTuple):
 
     @property
     def cpython_name(self) -> str:
-        if self.rust_name == "CopyItem":
-            return "COPY"
-        name = self.rust_name
-        name = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", name)
+        name = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", self.rust_name)
         return re.sub(r"(\D)(\d+)$", r"\1_\2", name).upper()
 
     @classmethod

From d2d3aa045f8a97f02c75aa76d54116b94b23e995 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 15:43:32 +0200
Subject: [PATCH 4/7] Remove comment

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

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 94c3413fecc..80f1b53f718 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -3,25 +3,9 @@ use std::mem;
 
 use crate::{
     bytecode::{
-        Arg,
-        BinaryOperator,
-        BorrowedConstant,
-        BuildSliceArgCount,
-        ComparisonOperator,
-        Constant,
-        ConvertValueOparg,
-        // a
-        InstrDisplayContext,
-        IntrinsicFunction1,
-        IntrinsicFunction2,
-        Invert,
-        Label,
-        MakeFunctionFlags,
-        NameIdx,
-        OpArg,
-        RaiseKind,
-        UnpackExArgs,
-        decode_load_attr_arg,
+        Arg, BinaryOperator, BorrowedConstant, BuildSliceArgCount, ComparisonOperator, Constant,
+        ConvertValueOparg, InstrDisplayContext, IntrinsicFunction1, IntrinsicFunction2, Invert,
+        Label, MakeFunctionFlags, NameIdx, OpArg, RaiseKind, UnpackExArgs, decode_load_attr_arg,
     },
     marshal::MarshalError,
 };

From 25c3348687b9d8351d5e05fe601aa962a8c83d87 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 16:26:40 +0200
Subject: [PATCH 5/7] Fix

---
 .../compiler-core/src/bytecode/instruction.rs | 36 +++++++++++++++----
 1 file changed, 30 insertions(+), 6 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 80f1b53f718..24cccbb3ed2 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -169,7 +169,7 @@ pub enum Instruction {
     LoadFastLoadFast {
         arg: Arg<u32>,
     } = 88, // Placeholder
-    LoadFromDictOrDeref(Arg<NameIdx>) = 89, // Placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>) = 89,
     LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
     LoadGlobal(Arg<NameIdx>) = 91,
     LoadName(Arg<NameIdx>) = 92,
@@ -272,7 +272,6 @@ pub enum Instruction {
         target: Arg<Label>,
     } = 130,
     JumpIfNotExcMatch(Arg<Label>) = 131,
-    LoadClassDeref(Arg<NameIdx>) = 132,
     SetExcInfo = 134,
     Subscript = 135,
     // ===== Pseudo Opcodes (252+) ======
@@ -337,7 +336,6 @@ impl TryFrom<u8> for Instruction {
                 target: Arg::marker(),
             }),
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
-            u8::from(Self::LoadClassDeref(Arg::marker())),
             u8::from(Self::SetExcInfo),
             u8::from(Self::Subscript),
         ];
@@ -428,7 +426,6 @@ impl Instruction {
             Self::LoadName(_) => 1,
             Self::LoadGlobal(_) => 1,
             Self::LoadDeref(_) => 1,
-            Self::LoadClassDeref(_) => 1,
             Self::StoreFast(_) => -1,
             Self::StoreName(_) => -1,
             Self::StoreGlobal(_) => -1,
@@ -438,6 +435,7 @@ impl Instruction {
             Self::DeleteName(_) => 0,
             Self::DeleteGlobal(_) => 0,
             Self::DeleteDeref(_) => 0,
+            Self::LoadFromDictOrDeref(_) => 1,
             Self::LoadClosure(_) => 1,
             Self::Subscript => -1,
             Self::StoreSubscr => -3,
@@ -590,7 +588,33 @@ impl Instruction {
             Self::UnaryNot => 0,
             Self::GetYieldFromIter => 0,
             Self::PushNull => 1, // Push NULL for call protocol
-            _ => 0,
+            Self::Cache => 0,
+            Self::BinarySlice => 0,
+            Self::BinaryOpInplaceAddUnicode => 0,
+            Self::EndFor => 0,
+            Self::ExitInitCheck => 0,
+            Self::InterpreterExit => 0,
+            Self::LoadAssertionError => 0,
+            Self::LoadLocals => 0,
+            Self::ReturnGenerator => 0,
+            Self::StoreSlice => 0,
+            Self::DictMerge { .. } => 0,
+            Self::BuildConstKeyMap { .. } => 0,
+            Self::CopyFreeVars { .. } => 0,
+            Self::EnterExecutor => 0,
+            Self::JumpBackwardNoInterrupt { .. } => 0,
+            Self::JumpBackward { .. } => 0,
+            Self::JumpForward { .. } => 0,
+            Self::ListExtend { .. } => 0,
+            Self::LoadFastCheck(_) => 0,
+            Self::LoadFastLoadFast { .. } => 0,
+            Self::LoadFromDictOrGlobals(_) => 0,
+            Self::SetUpdate { .. } => 0,
+            Self::MakeCell(_) => 0,
+            Self::LoadSuperAttr { .. } => 0,
+            Self::StoreFastStoreFast { .. } => 0,
+            Self::PopJumpIfNone { .. } => 0,
+            Self::PopJumpIfNotNone { .. } => 0,
         }
     }
 
@@ -736,7 +760,7 @@ impl Instruction {
             }
             Self::LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
             Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
-            Self::LoadClassDeref(idx) => w!(LOAD_CLASSDEREF, cell_name = idx),
+            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),

From 08136148e8466f4f5bfe5a87f24006c55f984ae3 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 16:54:14 +0200
Subject: [PATCH 6/7] Trigger CI


From 9b00a69e792163f8f785ce37e3f0ab68c7ed6f6c Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 23:28:25 +0200
Subject: [PATCH 7/7] Trigger CI