From 59a847179d20c36dd0acbcc0079e4e10bd6d545f Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 1 Mar 2026 11:01:16 +0100
Subject: [PATCH 01/22] Align real opcodes

---
 .../compiler-core/src/bytecode/instruction.rs | 206 +++++++++++-------
 1 file changed, 124 insertions(+), 82 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index c1c5e8cd847..7269b4efc64 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -79,28 +79,28 @@ pub enum Instruction {
     ///
     /// Stack: [value, expression_str, format_spec?] -> [interpolation]
     BuildInterpolation {
-        oparg: Arg<u32>,
+        format: Arg<u32>,
     } = 45,
     BuildList {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 46,
     BuildMap {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 47,
     BuildSet {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 48,
     BuildSlice {
         argc: Arg<BuildSliceArgCount>,
     } = 49,
     BuildString {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 50,
     BuildTuple {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 51,
     Call {
-        nargs: Arg<u32>,
+        argc: Arg<u32>,
     } = 52,
     CallIntrinsic1 {
         func: Arg<IntrinsicFunction1>,
@@ -109,57 +109,69 @@ pub enum Instruction {
         func: Arg<IntrinsicFunction2>,
     } = 54,
     CallKw {
-        nargs: Arg<u32>,
+        argc: Arg<u32>,
     } = 55,
     CompareOp {
-        op: Arg<ComparisonOperator>,
+        opnmae: Arg<ComparisonOperator>,
     } = 56,
-    ContainsOp(Arg<Invert>) = 57,
+    ContainsOp {
+        invert: Arg<Invert>,
+    } = 57,
     ConvertValue {
         oparg: Arg<ConvertValueOparg>,
     } = 58,
     Copy {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 59,
     CopyFreeVars {
-        count: Arg<u32>,
+        n: Arg<u32>,
     } = 60,
     DeleteAttr {
-        idx: Arg<NameIdx>,
+        nami: Arg<NameIdx>,
     } = 61,
-    DeleteDeref(Arg<NameIdx>) = 62,
-    DeleteFast(Arg<NameIdx>) = 63,
-    DeleteGlobal(Arg<NameIdx>) = 64,
-    DeleteName(Arg<NameIdx>) = 65,
+    DeleteDeref {
+        i: Arg<NameIdx>,
+    } = 62,
+    DeleteFast {
+        var_num: Arg<NameIdx>,
+    } = 63,
+    DeleteGlobal {
+        namei: Arg<NameIdx>,
+    } = 64,
+    DeleteName {
+        namei: Arg<NameIdx>,
+    } = 65,
     DictMerge {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 66,
     DictUpdate {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 67,
     EndAsyncFor = 68,
     ExtendedArg = 69,
     ForIter {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 70,
     GetAwaitable {
-        arg: Arg<u32>,
+        r#where: Arg<u32>,
     } = 71,
     ImportFrom {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 72,
     ImportName {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 73,
-    IsOp(Arg<Invert>) = 74,
+    IsOp {
+        invert: Arg<Invert>,
+    } = 74,
     JumpBackward {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 75,
     JumpBackwardNoInterrupt {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 76, // Placeholder
     JumpForward {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 77,
     ListAppend {
         i: Arg<u32>,
@@ -168,101 +180,131 @@ pub enum Instruction {
         i: Arg<u32>,
     } = 79,
     LoadAttr {
-        idx: Arg<LoadAttr>,
+        namei: Arg<LoadAttr>,
     } = 80,
     LoadCommonConstant {
         idx: Arg<CommonConstant>,
     } = 81,
     LoadConst {
-        idx: Arg<u32>,
+        consti: Arg<u32>,
     } = 82,
-    LoadDeref(Arg<NameIdx>) = 83,
-    LoadFast(Arg<NameIdx>) = 84,
-    LoadFastAndClear(Arg<NameIdx>) = 85,
-    LoadFastBorrow(Arg<NameIdx>) = 86,
+    LoadDeref {
+        i: Arg<NameIdx>,
+    } = 83,
+    LoadFast {
+        var_num: Arg<NameIdx>,
+    } = 84,
+    LoadFastAndClear {
+        var_num: Arg<NameIdx>,
+    } = 85,
+    LoadFastBorrow {
+        var_num: Arg<NameIdx>,
+    } = 86,
     LoadFastBorrowLoadFastBorrow {
-        arg: Arg<u32>,
+        var_nums: Arg<u32>,
     } = 87,
-    LoadFastCheck(Arg<NameIdx>) = 88,
+    LoadFastCheck {
+        var_num: Arg<NameIdx>,
+    } = 88,
     LoadFastLoadFast {
-        arg: Arg<u32>,
+        var_nums: Arg<u32>,
     } = 89,
-    LoadFromDictOrDeref(Arg<NameIdx>) = 90,
-    LoadFromDictOrGlobals(Arg<NameIdx>) = 91,
-    LoadGlobal(Arg<NameIdx>) = 92,
-    LoadName(Arg<NameIdx>) = 93,
+    LoadFromDictOrDeref {
+        i: Arg<NameIdx>,
+    } = 90,
+    LoadFromDictOrGlobals {
+        i: Arg<NameIdx>,
+    } = 91,
+    LoadGlobal {
+        namei: Arg<NameIdx>,
+    } = 92,
+    LoadName {
+        namei: Arg<NameIdx>,
+    } = 93,
     LoadSmallInt {
-        idx: Arg<u32>,
+        i: Arg<u32>,
     } = 94,
     LoadSpecial {
         method: Arg<SpecialMethod>,
     } = 95,
     LoadSuperAttr {
-        arg: Arg<LoadSuperAttr>,
+        nami: Arg<LoadSuperAttr>,
     } = 96,
-    MakeCell(Arg<NameIdx>) = 97,
+    MakeCell {
+        i: Arg<NameIdx>,
+    } = 97,
     MapAdd {
         i: Arg<u32>,
     } = 98,
-    MatchClass(Arg<u32>) = 99,
+    MatchClass {
+        count: Arg<u32>,
+    } = 99,
     PopJumpIfFalse {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 100,
     PopJumpIfNone {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 101,
     PopJumpIfNotNone {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 102,
     PopJumpIfTrue {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 103,
     RaiseVarargs {
-        kind: Arg<RaiseKind>,
+        argc: Arg<RaiseKind>,
     } = 104,
     Reraise {
         depth: Arg<u32>,
     } = 105,
     Send {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 106,
     SetAdd {
         i: Arg<u32>,
     } = 107,
     SetFunctionAttribute {
-        attr: Arg<MakeFunctionFlags>,
+        flag: Arg<MakeFunctionFlags>,
     } = 108,
     SetUpdate {
         i: Arg<u32>,
     } = 109,
     StoreAttr {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 110,
-    StoreDeref(Arg<NameIdx>) = 111,
-    StoreFast(Arg<NameIdx>) = 112,
+    StoreDeref {
+        i: Arg<NameIdx>,
+    } = 111,
+    StoreFast {
+        var_num: Arg<NameIdx>,
+    } = 112,
     StoreFastLoadFast {
         var_nums: Arg<StoreFastLoadFast>,
     } = 113,
     StoreFastStoreFast {
-        arg: Arg<u32>,
+        var_nums: Arg<u32>,
     } = 114,
-    StoreGlobal(Arg<NameIdx>) = 115,
-    StoreName(Arg<NameIdx>) = 116,
+    StoreGlobal {
+        namei: Arg<NameIdx>,
+    } = 115,
+    StoreName {
+        namei: Arg<NameIdx>,
+    } = 116,
     Swap {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 117,
     UnpackEx {
-        args: Arg<UnpackExArgs>,
+        counts: Arg<UnpackExArgs>,
     } = 118,
     UnpackSequence {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 119,
     YieldValue {
         arg: Arg<u32>,
     } = 120,
     // CPython 3.14 RESUME (128)
     Resume {
-        arg: Arg<u32>,
+        context: Arg<u32>,
     } = 128,
     // CPython 3.14 specialized opcodes (129-211)
     BinaryOpAddFloat = 129,                     // Placeholder
@@ -349,28 +391,28 @@ pub enum Instruction {
     UnpackSequenceTuple = 210,                  // Placeholder
     UnpackSequenceTwoTuple = 211,               // Placeholder
     // CPython 3.14 instrumented opcodes (234-254)
-    InstrumentedEndFor = 234,      // Placeholder
-    InstrumentedPopIter = 235,     // Placeholder
-    InstrumentedEndSend = 236,     // Placeholder
-    InstrumentedForIter = 237,     // Placeholder
-    InstrumentedInstruction = 238, // Placeholder
-    InstrumentedJumpForward = 239, // Placeholder
+    InstrumentedEndFor = 234,
+    InstrumentedPopIter = 235,
+    InstrumentedEndSend = 236,
+    InstrumentedForIter = 237,
+    InstrumentedInstruction = 238,
+    InstrumentedJumpForward = 239,
     InstrumentedNotTaken = 240,
-    InstrumentedPopJumpIfTrue = 241,    // Placeholder
-    InstrumentedPopJumpIfFalse = 242,   // Placeholder
-    InstrumentedPopJumpIfNone = 243,    // Placeholder
-    InstrumentedPopJumpIfNotNone = 244, // Placeholder
-    InstrumentedResume = 245,           // Placeholder
-    InstrumentedReturnValue = 246,      // Placeholder
-    InstrumentedYieldValue = 247,       // Placeholder
-    InstrumentedEndAsyncFor = 248,      // Placeholder
-    InstrumentedLoadSuperAttr = 249,    // Placeholder
-    InstrumentedCall = 250,             // Placeholder
-    InstrumentedCallKw = 251,           // Placeholder
-    InstrumentedCallFunctionEx = 252,   // Placeholder
-    InstrumentedJumpBackward = 253,     // Placeholder
-    InstrumentedLine = 254,             // Placeholder
-    EnterExecutor = 255,                // Placeholder
+    InstrumentedPopJumpIfTrue = 241,
+    InstrumentedPopJumpIfFalse = 242,
+    InstrumentedPopJumpIfNone = 243,
+    InstrumentedPopJumpIfNotNone = 244,
+    InstrumentedResume = 245,
+    InstrumentedReturnValue = 246,
+    InstrumentedYieldValue = 247,
+    InstrumentedEndAsyncFor = 248,
+    InstrumentedLoadSuperAttr = 249,
+    InstrumentedCall = 250,
+    InstrumentedCallKw = 251,
+    InstrumentedCallFunctionEx = 252,
+    InstrumentedJumpBackward = 253,
+    InstrumentedLine = 254,
+    EnterExecutor = 255, // Placeholder
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);

From 5c99d269c06d7c1b21cdc3cc878d0606eae77fe0 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 1 Mar 2026 11:04:41 +0100
Subject: [PATCH 02/22] Align pseudoes

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

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 7269b4efc64..d8ddcc46687 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -1253,16 +1253,16 @@ impl InstructionMetadata for Instruction {
 pub enum PseudoInstruction {
     // CPython 3.14.2 pseudo instructions (256-266)
     AnnotationsPlaceholder = 256,
-    Jump { target: Arg<Label> } = 257,
-    JumpIfFalse { target: Arg<Label> } = 258,
-    JumpIfTrue { target: Arg<Label> } = 259,
-    JumpNoInterrupt { target: Arg<Label> } = 260,
-    LoadClosure(Arg<NameIdx>) = 261,
+    Jump { delta: Arg<Label> } = 257,
+    JumpIfFalse { delta: Arg<Label> } = 258,
+    JumpIfTrue { delta: Arg<Label> } = 259,
+    JumpNoInterrupt { delta: Arg<Label> } = 260,
+    LoadClosure { i: Arg<NameIdx> } = 261,
     PopBlock = 262,
-    SetupCleanup { target: Arg<Label> } = 263,
-    SetupFinally { target: Arg<Label> } = 264,
-    SetupWith { target: Arg<Label> } = 265,
-    StoreFastMaybeNull(Arg<NameIdx>) = 266,
+    SetupCleanup { delta: Arg<Label> } = 263,
+    SetupFinally { delta: Arg<Label> } = 264,
+    SetupWith { delta: Arg<Label> } = 265,
+    StoreFastMaybeNull { var_num: Arg<NameIdx> } = 266,
 }
 
 const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);

From 511bc2edc6bb4c53eeee540d9a4fd26d411de85c Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 1 Mar 2026 11:29:45 +0100
Subject: [PATCH 03/22] fix fmt_dis

---
 .../compiler-core/src/bytecode/instruction.rs | 238 +++++++++---------
 1 file changed, 120 insertions(+), 118 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index d8ddcc46687..15d28058843 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -112,7 +112,7 @@ pub enum Instruction {
         argc: Arg<u32>,
     } = 55,
     CompareOp {
-        opnmae: Arg<ComparisonOperator>,
+        opname: Arg<ComparisonOperator>,
     } = 56,
     ContainsOp {
         invert: Arg<Invert>,
@@ -127,7 +127,7 @@ pub enum Instruction {
         n: Arg<u32>,
     } = 60,
     DeleteAttr {
-        nami: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 61,
     DeleteDeref {
         i: Arg<NameIdx>,
@@ -228,7 +228,7 @@ pub enum Instruction {
         method: Arg<SpecialMethod>,
     } = 95,
     LoadSuperAttr {
-        nami: Arg<LoadSuperAttr>,
+        namei: Arg<LoadSuperAttr>,
     } = 96,
     MakeCell {
         i: Arg<NameIdx>,
@@ -525,27 +525,27 @@ impl Instruction {
             Self::InstrumentedCallFunctionEx => Self::CallFunctionEx,
             Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr { arg: Arg::marker() },
             Self::InstrumentedJumpForward => Self::JumpForward {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedJumpBackward => Self::JumpBackward {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedForIter => Self::ForIter {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedEndFor => Self::EndFor,
             Self::InstrumentedEndSend => Self::EndSend,
             Self::InstrumentedPopJumpIfTrue => Self::PopJumpIfTrue {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedPopJumpIfFalse => Self::PopJumpIfFalse {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedPopJumpIfNone => Self::PopJumpIfNone {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedPopJumpIfNotNone => Self::PopJumpIfNotNone {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedNotTaken => Self::NotTaken,
             Self::InstrumentedPopIter => Self::PopIter,
@@ -593,7 +593,7 @@ impl Instruction {
             | Self::BinaryOpSubtractInt => 5,
 
             // LOAD_GLOBAL / STORE_ATTR: 4 cache entries
-            Self::LoadGlobal(_)
+            Self::LoadGlobal { .. }
             | Self::LoadGlobalBuiltin
             | Self::LoadGlobalModule
             | Self::StoreAttr { .. }
@@ -640,7 +640,7 @@ impl Instruction {
             | Self::CompareOpFloat
             | Self::CompareOpInt
             | Self::CompareOpStr
-            | Self::ContainsOp(_)
+            | Self::ContainsOp { .. }
             | Self::ContainsOpDict
             | Self::ContainsOpSet
             | Self::ForIter { .. }
@@ -678,15 +678,15 @@ impl InstructionMetadata for Instruction {
     #[inline]
     fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::JumpBackward { target: l }
-            | Self::JumpBackwardNoInterrupt { target: l }
-            | Self::JumpForward { target: l }
-            | Self::PopJumpIfTrue { target: l }
-            | Self::PopJumpIfFalse { target: l }
-            | Self::PopJumpIfNone { target: l }
-            | Self::PopJumpIfNotNone { target: l }
-            | Self::ForIter { target: l }
-            | Self::Send { target: l } => Some(*l),
+            Self::JumpBackward { delta: l }
+            | Self::JumpBackwardNoInterrupt { delta: l }
+            | Self::JumpForward { delta: l }
+            | Self::PopJumpIfTrue { delta: l }
+            | Self::PopJumpIfFalse { delta: l }
+            | Self::PopJumpIfNone { delta: l }
+            | Self::PopJumpIfNotNone { delta: l }
+            | Self::ForIter { delta: l }
+            | Self::Send { delta: l } => Some(*l),
             _ => None,
         }
     }
@@ -776,17 +776,17 @@ impl InstructionMetadata for Instruction {
             Self::CompareOpFloat => (1, 2),
             Self::CompareOpInt => (1, 2),
             Self::CompareOpStr => (1, 2),
-            Self::ContainsOp(_) => (1, 2),
+            Self::ContainsOp { .. } => (1, 2),
             Self::ContainsOpDict => (1, 2),
             Self::ContainsOpSet => (1, 2),
             Self::ConvertValue { .. } => (1, 1),
             Self::Copy { .. } => (2 + (oparg - 1), 1 + (oparg - 1)),
             Self::CopyFreeVars { .. } => (0, 0),
             Self::DeleteAttr { .. } => (0, 1),
-            Self::DeleteDeref(_) => (0, 0),
-            Self::DeleteFast(_) => (0, 0),
-            Self::DeleteGlobal(_) => (0, 0),
-            Self::DeleteName(_) => (0, 0),
+            Self::DeleteDeref { .. } => (0, 0),
+            Self::DeleteFast { .. } => (0, 0),
+            Self::DeleteGlobal { .. } => (0, 0),
+            Self::DeleteName { .. } => (0, 0),
             Self::DeleteSubscr => (0, 2),
             Self::DictMerge { .. } => (4 + (oparg - 1), 5 + (oparg - 1)),
             Self::DictUpdate { .. } => (1 + (oparg - 1), 2 + (oparg - 1)),
@@ -833,7 +833,7 @@ impl InstructionMetadata for Instruction {
             Self::InstrumentedReturnValue => (1, 1),
             Self::InstrumentedYieldValue => (1, 1),
             Self::InterpreterExit => (0, 1),
-            Self::IsOp(_) => (1, 2),
+            Self::IsOp { .. } => (1, 2),
             Self::JumpBackward { .. } => (0, 0),
             Self::JumpBackwardJit => (0, 0),
             Self::JumpBackwardNoInterrupt { .. } => (0, 0),
@@ -860,26 +860,26 @@ impl InstructionMetadata for Instruction {
             Self::LoadConst { .. } => (1, 0),
             Self::LoadConstImmortal => (1, 0),
             Self::LoadConstMortal => (1, 0),
-            Self::LoadDeref(_) => (1, 0),
-            Self::LoadFast(_) => (1, 0),
-            Self::LoadFastAndClear(_) => (1, 0),
-            Self::LoadFastBorrow(_) => (1, 0),
+            Self::LoadDeref { .. } => (1, 0),
+            Self::LoadFast { .. } => (1, 0),
+            Self::LoadFastAndClear { .. } => (1, 0),
+            Self::LoadFastBorrow { .. } => (1, 0),
             Self::LoadFastBorrowLoadFastBorrow { .. } => (2, 0),
-            Self::LoadFastCheck(_) => (1, 0),
+            Self::LoadFastCheck { .. } => (1, 0),
             Self::LoadFastLoadFast { .. } => (2, 0),
-            Self::LoadFromDictOrDeref(_) => (1, 1),
-            Self::LoadFromDictOrGlobals(_) => (1, 1),
-            Self::LoadGlobal(_) => (1 + (oparg & 1), 0),
+            Self::LoadFromDictOrDeref { .. } => (1, 1),
+            Self::LoadFromDictOrGlobals { .. } => (1, 1),
+            Self::LoadGlobal { .. } => (1 + (oparg & 1), 0),
             Self::LoadGlobalBuiltin => (1 + (oparg & 1), 0),
             Self::LoadGlobalModule => (1 + (oparg & 1), 0),
             Self::LoadLocals => (1, 0),
-            Self::LoadName(_) => (1, 0),
+            Self::LoadName { .. } => (1, 0),
             Self::LoadSmallInt { .. } => (1, 0),
             Self::LoadSpecial { .. } => (1, 1),
             Self::LoadSuperAttr { .. } => (1 + (oparg & 1), 3),
             Self::LoadSuperAttrAttr => (1, 3),
             Self::LoadSuperAttrMethod => (2, 3),
-            Self::MakeCell(_) => (0, 0),
+            Self::MakeCell { .. } => (0, 0),
             Self::MakeFunction { .. } => (1, 1),
             Self::MapAdd { .. } => (1 + (oparg - 1), 3 + (oparg - 1)),
             Self::MatchClass { .. } => (1, 3),
@@ -914,12 +914,12 @@ impl InstructionMetadata for Instruction {
             Self::StoreAttrInstanceValue => (0, 2),
             Self::StoreAttrSlot => (0, 2),
             Self::StoreAttrWithHint => (0, 2),
-            Self::StoreDeref(_) => (0, 1),
-            Self::StoreFast(_) => (0, 1),
+            Self::StoreDeref { .. } => (0, 1),
+            Self::StoreFast { .. } => (0, 1),
             Self::StoreFastLoadFast { .. } => (1, 1),
             Self::StoreFastStoreFast { .. } => (0, 2),
-            Self::StoreGlobal(_) => (0, 1),
-            Self::StoreName(_) => (0, 1),
+            Self::StoreGlobal { .. } => (0, 1),
+            Self::StoreName { .. } => (0, 1),
             Self::StoreSlice => (0, 4),
             Self::StoreSubscr => (0, 3),
             Self::StoreSubscrDict => (0, 3),
@@ -1006,58 +1006,58 @@ impl InstructionMetadata for Instruction {
             Self::BinarySlice => w!(BINARY_SLICE),
             Self::BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
             Self::BinaryOpInplaceAddUnicode => w!(BINARY_OP_INPLACE_ADD_UNICODE),
-            Self::BuildList { size } => w!(BUILD_LIST, size),
-            Self::BuildMap { size } => w!(BUILD_MAP, size),
-            Self::BuildSet { size } => w!(BUILD_SET, size),
+            Self::BuildList { count } => w!(BUILD_LIST, count),
+            Self::BuildMap { count } => w!(BUILD_MAP, count),
+            Self::BuildSet { count } => w!(BUILD_SET, count),
             Self::BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
-            Self::BuildString { size } => w!(BUILD_STRING, size),
-            Self::BuildTuple { size } => w!(BUILD_TUPLE, size),
-            Self::Call { nargs } => w!(CALL, nargs),
+            Self::BuildString { count } => w!(BUILD_STRING, count),
+            Self::BuildTuple { count } => w!(BUILD_TUPLE, count),
+            Self::Call { argc } => w!(CALL, argc),
             Self::CallFunctionEx => w!(CALL_FUNCTION_EX),
-            Self::CallKw { nargs } => w!(CALL_KW, nargs),
+            Self::CallKw { argc } => w!(CALL_KW, argc),
             Self::CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
             Self::CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
             Self::Cache => w!(CACHE),
             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::CompareOp { opname } => w!(COMPARE_OP, ?opname),
+            Self::ContainsOp { invert } => w!(CONTAINS_OP, ?invert),
             Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
-            Self::Copy { index } => w!(COPY, index),
-            Self::CopyFreeVars { count } => w!(COPY_FREE_VARS, count),
-            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::Copy { i } => w!(COPY, i),
+            Self::CopyFreeVars { n } => w!(COPY_FREE_VARS, n),
+            Self::DeleteAttr { namei } => w!(DELETE_ATTR, name = namei),
+            Self::DeleteDeref { i } => w!(DELETE_DEREF, cell_name = i),
+            Self::DeleteFast { var_num } => w!(DELETE_FAST, varname = var_num),
+            Self::DeleteGlobal { namei } => w!(DELETE_GLOBAL, name = nmaei),
+            Self::DeleteName { namei } => w!(DELETE_NAME, name = namei),
             Self::DeleteSubscr => w!(DELETE_SUBSCR),
-            Self::DictMerge { index } => w!(DICT_MERGE, index),
-            Self::DictUpdate { index } => w!(DICT_UPDATE, index),
+            Self::DictMerge { i } => w!(DICT_MERGE, i),
+            Self::DictUpdate { i } => w!(DICT_UPDATE, i),
             Self::EndAsyncFor => w!(END_ASYNC_FOR),
             Self::EndSend => w!(END_SEND),
             Self::ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
             Self::ExitInitCheck => w!(EXIT_INIT_CHECK),
-            Self::ForIter { target } => w!(FOR_ITER, target),
+            Self::ForIter { delta } => w!(FOR_ITER, delta),
             Self::FormatSimple => w!(FORMAT_SIMPLE),
             Self::FormatWithSpec => w!(FORMAT_WITH_SPEC),
             Self::GetAIter => w!(GET_AITER),
             Self::GetANext => w!(GET_ANEXT),
-            Self::GetAwaitable { arg } => w!(GET_AWAITABLE, arg),
+            Self::GetAwaitable { r#where } => w!(GET_AWAITABLE, r#where),
             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::ImportFrom { namei } => w!(IMPORT_FROM, name = namei),
+            Self::ImportName { namei } => w!(IMPORT_NAME, name = namei),
             Self::InterpreterExit => w!(INTERPRETER_EXIT),
-            Self::IsOp(inv) => w!(IS_OP, ?inv),
-            Self::JumpBackward { target } => w!(JUMP_BACKWARD, target),
-            Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
-            Self::JumpForward { target } => w!(JUMP_FORWARD, target),
+            Self::IsOp { invert } => w!(IS_OP, ?invert),
+            Self::JumpBackward { delta } => w!(JUMP_BACKWARD, delta),
+            Self::JumpBackwardNoInterrupt { delta } => w!(JUMP_BACKWARD_NO_INTERRUPT, delta),
+            Self::JumpForward { delta } => w!(JUMP_FORWARD, delta),
             Self::ListAppend { i } => w!(LIST_APPEND, i),
             Self::ListExtend { i } => w!(LIST_EXTEND, i),
-            Self::LoadAttr { idx } => {
-                let oparg = idx.get(arg);
+            Self::LoadAttr { namei } => {
+                let oparg = namei.get(arg);
                 let oparg_u32 = u32::from(oparg);
                 let attr_name = name(oparg.name_idx());
                 if oparg.is_method() {
@@ -1072,24 +1072,24 @@ impl InstructionMetadata for Instruction {
             }
             Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
             Self::LoadCommonConstant { idx } => w!(LOAD_COMMON_CONSTANT, ?idx),
-            Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
-            Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
-            Self::LoadSmallInt { idx } => w!(LOAD_SMALL_INT, 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::LoadFastBorrow(idx) => w!(LOAD_FAST_BORROW, varname = idx),
-            Self::LoadFastCheck(idx) => w!(LOAD_FAST_CHECK, varname = idx),
-            Self::LoadFastLoadFast { arg: packed } => {
-                let oparg = packed.get(arg);
+            Self::LoadFromDictOrDeref { i } => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
+            Self::LoadConst { consti } => fmt_const("LOAD_CONST", arg, f, consti),
+            Self::LoadSmallInt { i } => w!(LOAD_SMALL_INT, i),
+            Self::LoadDeref { i } => w!(LOAD_DEREF, cell_name = i),
+            Self::LoadFast { var_num } => w!(LOAD_FAST, varname = var_num),
+            Self::LoadFastAndClear { var_num } => w!(LOAD_FAST_AND_CLEAR, varname = var_num),
+            Self::LoadFastBorrow { var_num } => w!(LOAD_FAST_BORROW, varname = var_num),
+            Self::LoadFastCheck { var_num } => w!(LOAD_FAST_CHECK, varname = var_num),
+            Self::LoadFastLoadFast { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 15;
                 let name1 = varname(idx1);
                 let name2 = varname(idx2);
                 write!(f, "{:pad$}({}, {})", "LOAD_FAST_LOAD_FAST", name1, name2)
             }
-            Self::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
+            Self::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 15;
                 let name1 = varname(idx1);
@@ -1100,9 +1100,9 @@ impl InstructionMetadata for Instruction {
                     "LOAD_FAST_BORROW_LOAD_FAST_BORROW", name1, name2
                 )
             }
-            Self::LoadFromDictOrGlobals(idx) => w!(LOAD_FROM_DICT_OR_GLOBALS, name = idx),
-            Self::LoadGlobal(idx) => {
-                let oparg = idx.get(arg);
+            Self::LoadFromDictOrGlobals { i } => w!(LOAD_FROM_DICT_OR_GLOBALS, name = i),
+            Self::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
                 let name_idx = oparg >> 1;
                 if (oparg & 1) != 0 {
                     write!(
@@ -1159,10 +1159,10 @@ impl InstructionMetadata for Instruction {
                 }
             }
             Self::LoadLocals => w!(LOAD_LOCALS),
-            Self::LoadName(idx) => w!(LOAD_NAME, name = idx),
+            Self::LoadName { namei } => w!(LOAD_NAME, name = namei),
             Self::LoadSpecial { method } => w!(LOAD_SPECIAL, method),
-            Self::LoadSuperAttr { arg: idx } => {
-                let oparg = idx.get(arg);
+            Self::LoadSuperAttr { namei } => {
+                let oparg = namei.get(arg);
                 write!(
                     f,
                     "{:pad$}({}, {}, method={}, class={})",
@@ -1173,38 +1173,38 @@ impl InstructionMetadata for Instruction {
                     oparg.has_class()
                 )
             }
-            Self::MakeCell(idx) => w!(MAKE_CELL, cell_name = idx),
+            Self::MakeCell { i } => w!(MAKE_CELL, cell_name = i),
             Self::MakeFunction => w!(MAKE_FUNCTION),
             Self::MapAdd { i } => w!(MAP_ADD, i),
-            Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
+            Self::MatchClass { count } => w!(MATCH_CLASS, count),
             Self::MatchKeys => w!(MATCH_KEYS),
             Self::MatchMapping => w!(MATCH_MAPPING),
             Self::MatchSequence => w!(MATCH_SEQUENCE),
             Self::Nop => w!(NOP),
             Self::NotTaken => w!(NOT_TAKEN),
             Self::PopExcept => w!(POP_EXCEPT),
-            Self::PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
-            Self::PopJumpIfNone { target } => w!(POP_JUMP_IF_NONE, target),
-            Self::PopJumpIfNotNone { target } => w!(POP_JUMP_IF_NOT_NONE, target),
-            Self::PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
+            Self::PopJumpIfFalse { delta } => w!(POP_JUMP_IF_FALSE, delta),
+            Self::PopJumpIfNone { delta } => w!(POP_JUMP_IF_NONE, delta),
+            Self::PopJumpIfNotNone { delta } => w!(POP_JUMP_IF_NOT_NONE, delta),
+            Self::PopJumpIfTrue { delta } => w!(POP_JUMP_IF_TRUE, delta),
             Self::PopTop => w!(POP_TOP),
             Self::EndFor => w!(END_FOR),
             Self::PopIter => w!(POP_ITER),
             Self::PushExcInfo => w!(PUSH_EXC_INFO),
             Self::PushNull => w!(PUSH_NULL),
-            Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
+            Self::RaiseVarargs { argc } => w!(RAISE_VARARGS, ?argc),
             Self::Reraise { depth } => w!(RERAISE, depth),
-            Self::Resume { arg } => w!(RESUME, arg),
+            Self::Resume { context } => w!(RESUME, context),
             Self::ReturnValue => w!(RETURN_VALUE),
             Self::ReturnGenerator => w!(RETURN_GENERATOR),
-            Self::Send { target } => w!(SEND, target),
+            Self::Send { delta } => w!(SEND, delta),
             Self::SetAdd { i } => w!(SET_ADD, i),
-            Self::SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
+            Self::SetFunctionAttribute { flag } => w!(SET_FUNCTION_ATTRIBUTE, ?flag),
             Self::SetupAnnotations => w!(SETUP_ANNOTATIONS),
             Self::SetUpdate { i } => w!(SET_UPDATE, i),
-            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::StoreAttr { namei } => w!(STORE_ATTR, name = namei),
+            Self::StoreDeref { i } => w!(STORE_DEREF, cell_name = i),
+            Self::StoreFast { var_num } => w!(STORE_FAST, varname = var_num),
             Self::StoreFastLoadFast { var_nums } => {
                 let oparg = var_nums.get(arg);
                 let store_idx = oparg.store_idx();
@@ -1212,8 +1212,8 @@ impl InstructionMetadata for Instruction {
                 write!(f, "STORE_FAST_LOAD_FAST")?;
                 write!(f, " ({}, {})", store_idx, load_idx)
             }
-            Self::StoreFastStoreFast { arg: packed } => {
-                let oparg = packed.get(arg);
+            Self::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 15;
                 write!(
@@ -1224,14 +1224,14 @@ impl InstructionMetadata for Instruction {
                     varname(idx2)
                 )
             }
-            Self::StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
-            Self::StoreName(idx) => w!(STORE_NAME, name = idx),
+            Self::StoreGlobal { namei } => w!(STORE_GLOBAL, name = namei),
+            Self::StoreName { namei } => w!(STORE_NAME, name = namei),
             Self::StoreSlice => w!(STORE_SLICE),
             Self::StoreSubscr => w!(STORE_SUBSCR),
-            Self::Swap { index } => w!(SWAP, index),
+            Self::Swap { i } => w!(SWAP, i),
             Self::ToBool => w!(TO_BOOL),
-            Self::UnpackEx { args } => w!(UNPACK_EX, args),
-            Self::UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
+            Self::UnpackEx { counts } => w!(UNPACK_EX, counts),
+            Self::UnpackSequence { count } => w!(UNPACK_SEQUENCE, count),
             Self::WithExceptStart => w!(WITH_EXCEPT_START),
             Self::UnaryInvert => w!(UNARY_INVERT),
             Self::UnaryNegative => w!(UNARY_NEGATIVE),
@@ -1239,7 +1239,7 @@ impl InstructionMetadata for Instruction {
             Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
             Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
             Self::BuildTemplate => w!(BUILD_TEMPLATE),
-            Self::BuildInterpolation { oparg } => w!(BUILD_INTERPOLATION, oparg),
+            Self::BuildInterpolation { format } => w!(BUILD_INTERPOLATION, format),
             _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }
@@ -1281,7 +1281,9 @@ impl TryFrom<u16> for PseudoInstruction {
     #[inline]
     fn try_from(value: u16) -> Result<Self, MarshalError> {
         let start = u16::from(Self::AnnotationsPlaceholder);
-        let end = u16::from(Self::StoreFastMaybeNull(Arg::marker()));
+        let end = u16::from(Self::StoreFastMaybeNull {
+            var_num: Arg::marker(),
+        });
 
         if (start..=end).contains(&value) {
             Ok(unsafe { mem::transmute::<u16, Self>(value) })
@@ -1305,13 +1307,13 @@ impl PseudoInstruction {
 impl InstructionMetadata for PseudoInstruction {
     fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::Jump { target: l }
-            | Self::JumpIfFalse { target: l }
-            | Self::JumpIfTrue { target: l }
-            | Self::JumpNoInterrupt { target: l }
-            | Self::SetupCleanup { target: l }
-            | Self::SetupFinally { target: l }
-            | Self::SetupWith { target: l } => Some(*l),
+            Self::Jump { delta: l }
+            | Self::JumpIfFalse { delta: l }
+            | Self::JumpIfTrue { delta: l }
+            | Self::JumpNoInterrupt { delta: l }
+            | Self::SetupCleanup { delta: l }
+            | Self::SetupFinally { delta: l }
+            | Self::SetupWith { delta: l } => Some(*l),
             _ => None,
         }
     }
@@ -1333,14 +1335,14 @@ impl InstructionMetadata for PseudoInstruction {
             Self::JumpIfFalse { .. } => (1, 1),
             Self::JumpIfTrue { .. } => (1, 1),
             Self::JumpNoInterrupt { .. } => (0, 0),
-            Self::LoadClosure(_) => (1, 0),
+            Self::LoadClosure { .. } => (1, 0),
             Self::PopBlock => (0, 0),
             // Normal path effect is 0 (these are NOPs on fall-through).
             // Handler entry effects are computed directly in max_stackdepth().
             Self::SetupCleanup { .. } => (0, 0),
             Self::SetupFinally { .. } => (0, 0),
             Self::SetupWith { .. } => (0, 0),
-            Self::StoreFastMaybeNull(_) => (0, 1),
+            Self::StoreFastMaybeNull { .. } => (0, 1),
         };
 
         debug_assert!((0..=i32::MAX).contains(&pushed));

From 6b9966ba70206b2ffc446120169f1abbb8ac6ec2 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 1 Mar 2026 11:31:39 +0100
Subject: [PATCH 04/22] Compiler compiles

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

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 15d28058843..b9a6868a295 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -435,7 +435,9 @@ impl TryFrom<u8> for Instruction {
         let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
 
         // Resume has a non-contiguous opcode (128)
-        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+        let resume_id = u8::from(Self::Resume {
+            context: Arg::marker(),
+        });
         let enter_executor_id = u8::from(Self::EnterExecutor);
 
         let specialized_start = u8::from(Self::BinaryOpAddFloat);
@@ -513,17 +515,21 @@ impl Instruction {
     /// only the opcode byte matters since `replace_op` preserves the arg byte.
     pub fn to_base(self) -> Option<Self> {
         Some(match self {
-            Self::InstrumentedResume => Self::Resume { arg: Arg::marker() },
+            Self::InstrumentedResume => Self::Resume {
+                context: Arg::marker(),
+            },
             Self::InstrumentedReturnValue => Self::ReturnValue,
             Self::InstrumentedYieldValue => Self::YieldValue { arg: Arg::marker() },
             Self::InstrumentedCall => Self::Call {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             Self::InstrumentedCallKw => Self::CallKw {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             Self::InstrumentedCallFunctionEx => Self::CallFunctionEx,
-            Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr { arg: Arg::marker() },
+            Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr {
+                namei: Arg::marker(),
+            },
             Self::InstrumentedJumpForward => Self::JumpForward {
                 delta: Arg::marker(),
             },
@@ -1029,7 +1035,7 @@ impl InstructionMetadata for Instruction {
             Self::DeleteAttr { namei } => w!(DELETE_ATTR, name = namei),
             Self::DeleteDeref { i } => w!(DELETE_DEREF, cell_name = i),
             Self::DeleteFast { var_num } => w!(DELETE_FAST, varname = var_num),
-            Self::DeleteGlobal { namei } => w!(DELETE_GLOBAL, name = nmaei),
+            Self::DeleteGlobal { namei } => w!(DELETE_GLOBAL, name = namei),
             Self::DeleteName { namei } => w!(DELETE_NAME, name = namei),
             Self::DeleteSubscr => w!(DELETE_SUBSCR),
             Self::DictMerge { i } => w!(DICT_MERGE, i),

From ac64b1a40b1df661c6b7b9b306bd5a7684142b86 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 1 Mar 2026 11:38:25 +0100
Subject: [PATCH 05/22] Fix some of ir

---
 crates/codegen/src/ir.rs | 63 +++++++++++++++++++++++++---------------
 1 file changed, 39 insertions(+), 24 deletions(-)

diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 4363ffaa768..df1d0bc9c33 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -387,19 +387,19 @@ impl CodeInfo {
                         op = match op {
                             Instruction::JumpForward { .. } if target_offset <= current_offset => {
                                 Instruction::JumpBackward {
-                                    target: Arg::marker(),
+                                    delta: Arg::marker(),
                                 }
                             }
                             Instruction::JumpBackward { .. } if target_offset > current_offset => {
                                 Instruction::JumpForward {
-                                    target: Arg::marker(),
+                                    delta: Arg::marker(),
                                 }
                             }
                             Instruction::JumpBackwardNoInterrupt { .. }
                                 if target_offset > current_offset =>
                             {
                                 Instruction::JumpForward {
-                                    target: Arg::marker(),
+                                    delta: Arg::marker(),
                                 }
                             }
                             _ => op,
@@ -630,7 +630,10 @@ impl CodeInfo {
                 }
 
                 // Replace BUILD_TUPLE with LOAD_CONST
-                block.instructions[i].instr = Instruction::LoadConst { idx: Arg::marker() }.into();
+                block.instructions[i].instr = Instruction::LoadConst {
+                    consti: Arg::marker(),
+                }
+                .into();
                 block.instructions[i].arg = OpArg::new(const_idx as u32);
 
                 i += 1;
@@ -657,13 +660,15 @@ impl CodeInfo {
 
                     match (curr_instr, next_instr) {
                         // LoadFast + LoadFast -> LoadFastLoadFast (if both indices < 16)
-                        (Instruction::LoadFast(_), Instruction::LoadFast(_)) => {
+                        (Instruction::LoadFast { .. }, Instruction::LoadFast { .. }) => {
                             let idx1 = u32::from(curr.arg);
                             let idx2 = u32::from(next.arg);
                             if idx1 < 16 && idx2 < 16 {
                                 let packed = (idx1 << 4) | idx2;
                                 Some((
-                                    Instruction::LoadFastLoadFast { arg: Arg::marker() },
+                                    Instruction::LoadFastLoadFast {
+                                        var_nums: Arg::marker(),
+                                    },
                                     OpArg::new(packed),
                                 ))
                             } else {
@@ -671,13 +676,15 @@ impl CodeInfo {
                             }
                         }
                         // StoreFast + StoreFast -> StoreFastStoreFast (if both indices < 16)
-                        (Instruction::StoreFast(_), Instruction::StoreFast(_)) => {
+                        (Instruction::StoreFast { .. }, Instruction::StoreFast { .. }) => {
                             let idx1 = u32::from(curr.arg);
                             let idx2 = u32::from(next.arg);
                             if idx1 < 16 && idx2 < 16 {
                                 let packed = (idx1 << 4) | idx2;
                                 Some((
-                                    Instruction::StoreFastStoreFast { arg: Arg::marker() },
+                                    Instruction::StoreFastStoreFast {
+                                        var_nums: Arg::marker(),
+                                    },
                                     OpArg::new(packed),
                                 ))
                             } else {
@@ -710,7 +717,7 @@ impl CodeInfo {
                 let curr = &block.instructions[i];
                 let next = &block.instructions[i + 1];
 
-                let (Some(Instruction::LoadGlobal(_)), Some(Instruction::PushNull)) =
+                let (Some(Instruction::LoadGlobal { .. }), Some(Instruction::PushNull)) =
                     (curr.instr.real(), next.instr.real())
                 else {
                     i += 1;
@@ -753,7 +760,7 @@ impl CodeInfo {
                 // Check if it's in small int range: -5 to 256 (_PY_IS_SMALL_INT)
                 if let Some(small) = value.to_i32().filter(|v| (-5..=256).contains(v)) {
                     // Convert LOAD_CONST to LOAD_SMALL_INT
-                    instr.instr = Instruction::LoadSmallInt { idx: Arg::marker() }.into();
+                    instr.instr = Instruction::LoadSmallInt { i: Arg::marker() }.into();
                     // The arg is the i32 value stored as u32 (two's complement)
                     instr.arg = OpArg::new(small as u32);
                 }
@@ -893,7 +900,7 @@ impl CodeInfo {
 
                 // Push values to stack with source instruction index
                 let source = match instr {
-                    Instruction::LoadFast(_) | Instruction::LoadFastLoadFast { .. } => i,
+                    Instruction::LoadFast { .. } | Instruction::LoadFastLoadFast { .. } => i,
                     _ => NOT_LOCAL,
                 };
                 for _ in 0..pushes {
@@ -921,12 +928,17 @@ impl CodeInfo {
                     continue;
                 };
                 match instr {
-                    Instruction::LoadFast(_) => {
-                        info.instr = Instruction::LoadFastBorrow(Arg::marker()).into();
+                    Instruction::LoadFast { .. } => {
+                        info.instr = Instruction::LoadFastBorrow {
+                            var_num: Arg::marker(),
+                        }
+                        .into();
                     }
                     Instruction::LoadFastLoadFast { .. } => {
-                        info.instr =
-                            Instruction::LoadFastBorrowLoadFastBorrow { arg: Arg::marker() }.into();
+                        info.instr = Instruction::LoadFastBorrowLoadFastBorrow {
+                            var_nums: Arg::marker(),
+                        }
+                        .into();
                     }
                     _ => {}
                 }
@@ -1413,7 +1425,7 @@ fn push_cold_blocks_to_end(blocks: &mut Vec<Block>) {
         };
         jump_block.instructions.push(InstructionInfo {
             instr: PseudoInstruction::JumpNoInterrupt {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             }
             .into(),
             arg: OpArg::new(0),
@@ -1564,12 +1576,12 @@ fn normalize_jumps(blocks: &mut [Block]) {
                 AnyInstruction::Pseudo(PseudoInstruction::Jump { .. }) => {
                     if target_pos > source_pos {
                         Instruction::JumpForward {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     } else {
                         Instruction::JumpBackward {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     }
@@ -1577,12 +1589,12 @@ fn normalize_jumps(blocks: &mut [Block]) {
                 AnyInstruction::Pseudo(PseudoInstruction::JumpNoInterrupt { .. }) => {
                     if target_pos > source_pos {
                         Instruction::JumpForward {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     } else {
                         Instruction::JumpBackwardNoInterrupt {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     }
@@ -1748,10 +1760,13 @@ pub(crate) fn convert_pseudo_ops(blocks: &mut [Block], varnames_len: u32) {
                     info.instr = Instruction::Nop.into();
                 }
                 // LOAD_CLOSURE → LOAD_FAST (with varnames offset)
-                PseudoInstruction::LoadClosure(idx) => {
-                    let new_idx = varnames_len + idx.get(info.arg);
+                PseudoInstruction::LoadClosure { i } => {
+                    let new_idx = varnames_len + i.get(info.arg);
                     info.arg = OpArg::new(new_idx);
-                    info.instr = Instruction::LoadFast(Arg::marker()).into();
+                    info.instr = Instruction::LoadFast {
+                        var_num: Arg::marker(),
+                    }
+                    .into();
                 }
                 // Jump pseudo ops are resolved during block linearization
                 PseudoInstruction::Jump { .. } | PseudoInstruction::JumpNoInterrupt { .. } => {}
@@ -1759,7 +1774,7 @@ pub(crate) fn convert_pseudo_ops(blocks: &mut [Block], varnames_len: u32) {
                 PseudoInstruction::AnnotationsPlaceholder
                 | PseudoInstruction::JumpIfFalse { .. }
                 | PseudoInstruction::JumpIfTrue { .. }
-                | PseudoInstruction::StoreFastMaybeNull(_) => {
+                | PseudoInstruction::StoreFastMaybeNull { .. } => {
                     unreachable!("Unexpected pseudo instruction in convert_pseudo_ops: {pseudo:?}")
                 }
             }

From 927daa11f73d3f938747c2b31db18e7bbcdd36bb Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 1 Mar 2026 13:05:38 +0100
Subject: [PATCH 06/22] Fix some of compile.rs

---
 crates/codegen/src/compile.rs | 784 ++++++++++++++++++----------------
 1 file changed, 422 insertions(+), 362 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 72ce4c7350b..a0bc08d03c8 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -572,13 +572,13 @@ impl Compiler {
             let total_size = n + pushed;
             match collection_type {
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size: total_size });
+                    emit!(self, Instruction::BuildList { count: total_size });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size: total_size });
+                    emit!(self, Instruction::BuildSet { count: total_size });
                 }
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size: total_size });
+                    emit!(self, Instruction::BuildTuple { count: total_size });
                 }
             }
             return Ok(());
@@ -594,13 +594,13 @@ impl Compiler {
                 if !sequence_built {
                     match collection_type {
                         CollectionType::List => {
-                            emit!(self, Instruction::BuildList { size: i + pushed });
+                            emit!(self, Instruction::BuildList { count: i + pushed });
                         }
                         CollectionType::Set => {
-                            emit!(self, Instruction::BuildSet { size: i + pushed });
+                            emit!(self, Instruction::BuildSet { count: i + pushed });
                         }
                         CollectionType::Tuple => {
-                            emit!(self, Instruction::BuildList { size: i + pushed });
+                            emit!(self, Instruction::BuildList { count: i + pushed });
                         }
                     }
                     sequence_built = true;
@@ -647,13 +647,13 @@ impl Compiler {
         if !sequence_built {
             match collection_type {
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size: i + pushed });
+                    emit!(self, Instruction::BuildList { count: i + pushed });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size: i + pushed });
+                    emit!(self, Instruction::BuildSet { count: i + pushed });
                 }
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size: i + pushed });
+                    emit!(self, Instruction::BuildTuple { count: i + pushed });
                 }
             }
         } else if collection_type == CollectionType::Tuple {
@@ -1164,7 +1164,7 @@ impl Compiler {
 
         self.current_block().instructions.push(ir::InstructionInfo {
             instr: Instruction::Resume {
-                arg: OpArgMarker::marker(),
+                context: OpArgMarker::marker(),
             }
             .into(),
             arg: OpArg::new(u32::from(bytecode::ResumeType::AtFuncStart)),
@@ -1283,7 +1283,7 @@ impl Compiler {
     /// if format > VALUE_WITH_FAKE_GLOBALS (2): raise NotImplementedError
     fn emit_format_validation(&mut self) -> CompileResult<()> {
         // Load format parameter (first local variable, index 0)
-        emit!(self, Instruction::LoadFast(0));
+        emit!(self, Instruction::LoadFast { var_num: 0 });
 
         // Load VALUE_WITH_FAKE_GLOBALS constant (2)
         self.emit_load_const(ConstantData::Integer { value: 2.into() });
@@ -1292,13 +1292,13 @@ impl Compiler {
         emit!(
             self,
             Instruction::CompareOp {
-                op: ComparisonOperator::Greater
+                opname: ComparisonOperator::Greater
             }
         );
 
         // Jump to body if format <= 2 (comparison is false)
         let body_block = self.new_block();
-        emit!(self, Instruction::PopJumpIfFalse { target: body_block });
+        emit!(self, Instruction::PopJumpIfFalse { delta: body_block });
 
         // Raise NotImplementedError
         emit!(
@@ -1310,7 +1310,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::RaiseVarargs {
-                kind: bytecode::RaiseKind::Raise
+                argc: bytecode::RaiseKind::Raise
             }
         );
 
@@ -1378,7 +1378,7 @@ impl Compiler {
             FBlockType::ForLoop => {
                 // Pop the iterator
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopIter);
             }
@@ -1397,11 +1397,11 @@ impl Compiler {
             FBlockType::FinallyEnd => {
                 // codegen_unwind_fblock(FINALLY_END)
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopTop); // exc_value
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, PseudoInstruction::PopBlock);
                 emit!(self, Instruction::PopExcept);
@@ -1415,7 +1415,7 @@ impl Compiler {
 
                 // If preserving return value, swap it below __exit__
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 // Stack after swap: [..., return_value, __exit__] or [..., __exit__]
 
@@ -1427,11 +1427,11 @@ impl Compiler {
                 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, Instruction::Call { argc: 3 });
 
                 // For async with, await the result
                 if matches!(info.fb_type, FBlockType::AsyncWith) {
-                    emit!(self, Instruction::GetAwaitable { arg: 2 });
+                    emit!(self, Instruction::GetAwaitable { r#where: 2 });
                     self.emit_load_const(ConstantData::None);
                     let _ = self.compile_yield_from_sequence(true)?;
                 }
@@ -1447,7 +1447,7 @@ impl Compiler {
                     emit!(self, PseudoInstruction::PopBlock);
                 }
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 // PopBlock for outer SETUP_CLEANUP (ExceptionHandler)
                 emit!(self, PseudoInstruction::PopBlock);
@@ -1463,7 +1463,7 @@ impl Compiler {
 
             FBlockType::PopValue => {
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopTop);
             }
@@ -1704,7 +1704,7 @@ impl Compiler {
 
                 // PEP 649: Initialize __conditional_annotations__ set after __annotate__
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
             }
@@ -1743,7 +1743,7 @@ impl Compiler {
 
                 // PEP 649: Initialize __conditional_annotations__ set after __annotate__
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
             }
@@ -1768,7 +1768,7 @@ impl Compiler {
 
             if let ast::Stmt::Expr(ast::StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -1807,7 +1807,7 @@ impl Compiler {
                 ast::Stmt::FunctionDef(_) | ast::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 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -2035,15 +2035,15 @@ impl Compiler {
                     NameUsage::Load => {
                         // Load __classdict__ first (it's a free variable in annotation scope)
                         let classdict_idx = self.get_free_var_index("__classdict__")?;
-                        self.emit_arg(classdict_idx, Instruction::LoadDeref);
-                        self.emit_arg(idx, Instruction::LoadFromDictOrGlobals);
+                        emit!(self, Instruction::LoadDeref { i: classdict_idx });
+                        emit!(self, Instruction::LoadFromDictOrGlobals { i: idx });
                     }
                     // Store/Delete in annotation scope should use Name ops
                     NameUsage::Store => {
-                        self.emit_arg(idx, Instruction::StoreName);
+                        emit!(self, Instruction::StoreName { namei: idx });
                     }
                     NameUsage::Delete => {
-                        self.emit_arg(idx, Instruction::DeleteName);
+                        emit!(self, Instruction::DeleteName { namei: idx });
                     }
                 }
             }
@@ -2085,15 +2085,15 @@ impl Compiler {
                         value: num_traits::Zero::zero(),
                     });
                     self.emit_load_const(ConstantData::None);
-                    let idx = self.name(&name.name);
-                    emit!(self, Instruction::ImportName { idx });
+                    let namei = self.name(&name.name);
+                    emit!(self, Instruction::ImportName { namei });
                     if let Some(alias) = &name.asname {
                         let parts: Vec<&str> = name.name.split('.').skip(1).collect();
                         for (i, part) in parts.iter().enumerate() {
-                            let idx = self.name(part);
-                            emit!(self, Instruction::ImportFrom { idx });
+                            let namei = self.name(part);
+                            emit!(self, Instruction::ImportFrom { namei });
                             if i < parts.len() - 1 {
-                                emit!(self, Instruction::Swap { index: 2 });
+                                emit!(self, Instruction::Swap { i: 2 });
                                 emit!(self, Instruction::PopTop);
                             }
                         }
@@ -2141,7 +2141,7 @@ 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, Instruction::ImportName { namei: module_idx });
 
                 if import_star {
                     // from .... import *
@@ -2159,7 +2159,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, Instruction::ImportFrom { namei: idx });
 
                         // Store module under proper name:
                         if let Some(alias) = &name.asname {
@@ -2212,12 +2212,7 @@ impl Compiler {
 
                         self.compile_jump_if(test, false, next_block)?;
                         self.compile_statements(body)?;
-                        emit!(
-                            self,
-                            PseudoInstruction::Jump {
-                                target: after_block
-                            }
-                        );
+                        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
                         for clause in rest {
                             self.switch_to_block(next_block);
@@ -2228,12 +2223,7 @@ impl Compiler {
                                 unreachable!() // must be elif
                             }
                             self.compile_statements(&clause.body)?;
-                            emit!(
-                                self,
-                                PseudoInstruction::Jump {
-                                    target: after_block
-                                }
-                            );
+                            emit!(self, PseudoInstruction::Jump { delta: after_block });
                         }
 
                         self.switch_to_block(next_block);
@@ -2283,7 +2273,7 @@ impl Compiler {
                     None => bytecode::RaiseKind::BareRaise,
                 };
                 self.set_source_range(*range);
-                emit!(self, Instruction::RaiseVarargs { kind });
+                emit!(self, Instruction::RaiseVarargs { argc: kind });
                 // Start a new block so dead code after raise doesn't
                 // corrupt the except stack in label_exception_targets
                 let dead = self.new_block();
@@ -2357,16 +2347,16 @@ impl Compiler {
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
-                            emit!(self, Instruction::Call { nargs: 1 });
+                            emit!(self, Instruction::Call { argc: 1 });
                         }
                         None => {
-                            emit!(self, Instruction::Call { nargs: 0 });
+                            emit!(self, Instruction::Call { argc: 0 });
                         }
                     }
                     emit!(
                         self,
                         Instruction::RaiseVarargs {
-                            kind: bytecode::RaiseKind::Raise,
+                            argc: bytecode::RaiseKind::Raise,
                         }
                     );
 
@@ -2426,7 +2416,7 @@ impl Compiler {
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, Instruction::Copy { index: 1_u32 });
+                        emit!(self, Instruction::Copy { i: 1 });
                     }
                     self.compile_store(target)?;
                 }
@@ -2518,22 +2508,22 @@ impl Compiler {
                     // Stack: [type_params_tuple, value_closure]
 
                     // Swap so unpack_sequence reverse gives correct order
-                    emit!(self, Instruction::Swap { index: 2_u32 });
+                    emit!(self, Instruction::Swap { i: 2 });
                     // Stack: [value_closure, type_params_tuple]
 
                     // Build tuple and return from TypeParams scope
-                    emit!(self, Instruction::BuildTuple { size: 2 });
+                    emit!(self, Instruction::BuildTuple { count: 2 });
                     emit!(self, Instruction::ReturnValue);
 
                     let code = self.exit_scope();
                     self.ctx = prev_ctx;
                     self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
                     emit!(self, Instruction::PushNull);
-                    emit!(self, Instruction::Call { nargs: 0 });
+                    emit!(self, Instruction::Call { argc: 0 });
 
                     // Unpack: (value_closure, type_params_tuple)
                     // UnpackSequence reverses → stack: [name, type_params_tuple, value_closure]
-                    emit!(self, Instruction::UnpackSequence { size: 2 });
+                    emit!(self, Instruction::UnpackSequence { count: 2 });
                 } else {
                     // Push None for type_params
                     self.emit_load_const(ConstantData::None);
@@ -2571,7 +2561,7 @@ impl Compiler {
                 }
 
                 // Build tuple of 3 elements and call intrinsic
-                emit!(self, Instruction::BuildTuple { size: 3 });
+                emit!(self, Instruction::BuildTuple { count: 3 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -2592,8 +2582,8 @@ impl Compiler {
             }
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::DeleteAttr { idx });
+                let namei = self.name(attr.as_str());
+                emit!(self, Instruction::DeleteAttr { namei });
             }
             ast::Expr::Subscript(ast::ExprSubscript {
                 value, slice, ctx, ..
@@ -2672,7 +2662,7 @@ impl Compiler {
     /// applying decorators bottom-up (innermost first).
     fn apply_decorators(&mut self, decorator_list: &[ast::Decorator]) {
         for _ in decorator_list {
-            emit!(self, Instruction::Call { nargs: 1 });
+            emit!(self, Instruction::Call { argc: 1 });
         }
     }
 
@@ -2716,7 +2706,7 @@ impl Compiler {
         if allow_starred && matches!(expr, ast::Expr::Starred(_)) {
             if let ast::Expr::Starred(starred) = expr {
                 self.compile_expression(&starred.value)?;
-                emit!(self, Instruction::UnpackSequence { size: 1 });
+                emit!(self, Instruction::UnpackSequence { count: 1 });
             }
         } else {
             self.compile_expression(expr)?;
@@ -2785,7 +2775,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
                 ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, default, .. }) => {
@@ -2810,7 +2800,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
                 ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
@@ -2838,7 +2828,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
             };
@@ -2846,7 +2836,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::BuildTuple {
-                size: u32::try_from(type_params.len()).unwrap(),
+                count: u32::try_from(type_params.len()).unwrap(),
             }
         );
         Ok(())
@@ -2892,7 +2882,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: setup_target
+                    delta: setup_target
                 }
             );
             // Store finally body in fb_datum for unwind_fblock to compile inline
@@ -2936,7 +2926,7 @@ impl Compiler {
             }
 
             // Jump to end (skip exception path blocks)
-            emit!(self, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: end_block });
 
             if let Some(finally_except) = finally_except_block {
                 // Restore sub_tables for exception path compilation
@@ -2949,7 +2939,7 @@ impl Compiler {
                 self.switch_to_block(finally_except);
                 // SETUP_CLEANUP before PUSH_EXC_INFO
                 if let Some(cleanup) = finally_cleanup_block {
-                    emit!(self, PseudoInstruction::SetupCleanup { target: cleanup });
+                    emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
                 }
                 emit!(self, Instruction::PushExcInfo);
                 if let Some(cleanup) = finally_cleanup_block {
@@ -2969,7 +2959,7 @@ impl Compiler {
                 // Stack: [prev_exc, exc] -> COPY 2 -> [prev_exc, exc, prev_exc]
                 // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
                 // Stack after POP_EXCEPT: [prev_exc, exc]
-                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { i: 2 });
                 emit!(self, Instruction::PopExcept);
 
                 // RERAISE 0: re-raise the original exception to outer handler
@@ -2978,7 +2968,7 @@ impl Compiler {
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::Copy { index: 3_u32 });
+                emit!(self, Instruction::Copy { i: 3 });
                 emit!(self, Instruction::PopExcept);
                 emit!(self, Instruction::Reraise { depth: 1 });
             }
@@ -2991,14 +2981,14 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupFinally {
-                target: handler_block
+                delta: handler_block
             }
         );
         self.push_fblock(FBlockType::TryExcept, handler_block, handler_block)?;
         self.compile_statements(body)?;
         emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(FBlockType::TryExcept);
-        emit!(self, PseudoInstruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { delta: else_block });
 
         // except handlers:
         self.switch_to_block(handler_block);
@@ -3012,7 +3002,7 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupCleanup {
-                target: cleanup_block
+                delta: cleanup_block
             }
         );
         self.push_fblock(FBlockType::ExceptionHandler, cleanup_block, cleanup_block)?;
@@ -3043,7 +3033,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: next_handler
+                        delta: next_handler
                     }
                 );
                 // Stack: [prev_exc, exc]
@@ -3065,12 +3055,7 @@ impl Compiler {
             let handler_cleanup_block = if name.is_some() {
                 // SETUP_CLEANUP(cleanup_end) for named handler
                 let cleanup_end = self.new_block();
-                emit!(
-                    self,
-                    PseudoInstruction::SetupCleanup {
-                        target: cleanup_end
-                    }
-                );
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup_end });
                 self.push_fblock_full(
                     FBlockType::HandlerCleanup,
                     cleanup_end,
@@ -3098,7 +3083,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::JumpNoInterrupt {
-                    target: handler_normal_exit,
+                    delta: handler_normal_exit,
                 }
             );
 
@@ -3149,7 +3134,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::JumpNoInterrupt {
-                    target: finally_block,
+                    delta: finally_block,
                 }
             );
 
@@ -3178,7 +3163,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::Copy { index: 3_u32 });
+        emit!(self, Instruction::Copy { i: 3 });
         emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
@@ -3206,7 +3191,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, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: end_block });
         }
 
         // finally (exception path)
@@ -3225,7 +3210,7 @@ impl Compiler {
             // SETUP_CLEANUP for finally body
             // Exceptions during finally body need to go to cleanup block
             if let Some(cleanup) = finally_cleanup_block {
-                emit!(self, PseudoInstruction::SetupCleanup { target: cleanup });
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
             }
             emit!(self, Instruction::PushExcInfo);
             if let Some(cleanup) = finally_cleanup_block {
@@ -3247,7 +3232,7 @@ impl Compiler {
             // Stack: [lasti, prev_exc, exc] -> COPY 2 -> [lasti, prev_exc, exc, prev_exc]
             // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
             // Stack after POP_EXCEPT: [lasti, prev_exc, exc]
-            emit!(self, Instruction::Copy { index: 2_u32 });
+            emit!(self, Instruction::Copy { i: 2 });
             emit!(self, Instruction::PopExcept);
 
             // RERAISE 0: re-raise the original exception to outer handler
@@ -3261,7 +3246,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::Copy { index: 3_u32 });
+            emit!(self, Instruction::Copy { i: 3 });
             // POP_EXCEPT: restore prev_exc as current exception
             emit!(self, Instruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
@@ -3305,7 +3290,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: finally_block
+                    delta: finally_block
                 }
             );
             self.push_fblock_full(
@@ -3320,14 +3305,14 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupFinally {
-                target: handler_block
+                delta: handler_block
             }
         );
         self.push_fblock(FBlockType::TryExcept, handler_block, handler_block)?;
         self.compile_statements(body)?;
         emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(FBlockType::TryExcept);
-        emit!(self, PseudoInstruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { delta: else_block });
 
         // Exception handler entry
         self.switch_to_block(handler_block);
@@ -3344,9 +3329,9 @@ impl Compiler {
 
         // Initialize handler stack before the loop
         // BUILD_LIST 0 + COPY 2 to set up [prev_exc, orig, list, rest]
-        emit!(self, Instruction::BuildList { size: 0 });
+        emit!(self, Instruction::BuildList { count: 0 });
         // Stack: [prev_exc, exc, []]
-        emit!(self, Instruction::Copy { index: 2 });
+        emit!(self, Instruction::Copy { i: 2 });
         // Stack: [prev_exc, orig, list, rest]
 
         let n = handlers.len();
@@ -3358,7 +3343,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::Jump {
-                    target: reraise_star_block
+                    delta: reraise_star_block
                 }
             );
         }
@@ -3398,11 +3383,11 @@ impl Compiler {
 
             // ADDOP_I(c, loc, COPY, 1);
             // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
-            emit!(self, Instruction::Copy { index: 1 });
+            emit!(self, Instruction::Copy { i: 1 });
             emit!(
                 self,
                 Instruction::PopJumpIfNone {
-                    target: no_match_block
+                    delta: no_match_block
                 }
             );
 
@@ -3423,7 +3408,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupCleanup {
-                    target: handler_except_block
+                    delta: handler_except_block
                 }
             );
             self.push_fblock_full(
@@ -3452,7 +3437,7 @@ impl Compiler {
             }
 
             // Jump to next handler
-            emit!(self, PseudoInstruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { delta: next_block });
 
             // Handler raised an exception (cleanup_end label)
             self.switch_to_block(handler_except_block);
@@ -3480,7 +3465,7 @@ impl Compiler {
 
             // JUMP except_with_error
             // We directly JUMP to next_block since no_match_block falls through to it
-            emit!(self, PseudoInstruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { delta: next_block });
 
             // No match - pop match (None)
             self.switch_to_block(no_match_block);
@@ -3505,7 +3490,7 @@ impl Compiler {
                 emit!(
                     self,
                     PseudoInstruction::Jump {
-                        target: reraise_star_block
+                        delta: reraise_star_block
                     }
                 );
             }
@@ -3529,14 +3514,14 @@ impl Compiler {
         // Stack: [prev_exc, result]
 
         // COPY 1
-        emit!(self, Instruction::Copy { index: 1 });
+        emit!(self, Instruction::Copy { i: 1 });
         // Stack: [prev_exc, result, result]
 
         // POP_JUMP_IF_NOT_NONE reraise
         emit!(
             self,
             Instruction::PopJumpIfNotNone {
-                target: reraise_block
+                delta: reraise_block
             }
         );
         // Stack: [prev_exc, result]
@@ -3556,7 +3541,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, PseudoInstruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { delta: end_block });
 
         // Reraise the result
         self.switch_to_block(reraise_block);
@@ -3564,7 +3549,7 @@ impl Compiler {
 
         // POP_BLOCK - no-op for us
         // SWAP 2
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { i: 2 });
         // Stack: [result, prev_exc]
 
         // POP_EXCEPT
@@ -3583,7 +3568,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: finally_block
+                    delta: finally_block
                 }
             );
             self.push_fblock_full(
@@ -3602,7 +3587,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, PseudoInstruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { delta: end_block });
 
         self.switch_to_block(end_block);
         if !finalbody.is_empty() {
@@ -3611,7 +3596,7 @@ impl Compiler {
 
             // Compile finally body inline for normal path
             self.compile_statements(finalbody)?;
-            emit!(self, PseudoInstruction::Jump { target: exit_block });
+            emit!(self, PseudoInstruction::Jump { delta: exit_block });
 
             // Restore sub_tables for exception path compilation
             if let Some(cursor) = sub_table_cursor
@@ -3625,7 +3610,7 @@ impl Compiler {
             emit!(self, Instruction::PushExcInfo);
 
             if let Some(cleanup) = finally_cleanup_block {
-                emit!(self, PseudoInstruction::SetupCleanup { target: cleanup });
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
                 self.push_fblock(FBlockType::FinallyEnd, cleanup, cleanup)?;
             }
 
@@ -3636,13 +3621,13 @@ impl Compiler {
                 self.pop_fblock(FBlockType::FinallyEnd);
             }
 
-            emit!(self, Instruction::Copy { index: 2_u32 });
+            emit!(self, Instruction::Copy { i: 2 });
             emit!(self, Instruction::PopExcept);
             emit!(self, Instruction::Reraise { depth: 0 });
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::Copy { index: 3_u32 });
+                emit!(self, Instruction::Copy { i: 3 });
                 emit!(self, Instruction::PopExcept);
                 emit!(self, Instruction::Reraise { depth: 1 });
             }
@@ -3676,7 +3661,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildTuple {
-                    size: defaults.len().to_u32()
+                    count: defaults.len().to_u32()
                 }
             );
             funcflags |= bytecode::MakeFunctionFlags::DEFAULTS;
@@ -3701,7 +3686,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: kw_with_defaults.len().to_u32(),
+                    count: kw_with_defaults.len().to_u32(),
                 }
             );
             funcflags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
@@ -3845,7 +3830,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::BuildMap {
-                size: num_annotations,
+                count: num_annotations,
             }
         );
         emit!(self, Instruction::ReturnValue);
@@ -3975,7 +3960,7 @@ impl Compiler {
         if has_conditional {
             // PEP 649: Build dict incrementally, checking conditional annotations
             // Start with empty dict
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
 
             // Process each annotation
             for (idx, (name, annotation)) in annotations.iter().enumerate() {
@@ -3988,25 +3973,30 @@ impl Compiler {
                 // Class scope: LoadDeref (freevars), Module scope: LoadGlobal
                 if parent_scope_type == CompilerScope::Class {
                     let idx = self.get_free_var_index("__conditional_annotations__")?;
-                    emit!(self, Instruction::LoadDeref(idx));
+                    emit!(self, Instruction::LoadDeref { i: idx });
                 } else {
                     let cond_annotations_name = self.name("__conditional_annotations__");
                     self.emit_load_global(cond_annotations_name, false);
                 }
                 // CONTAINS_OP (in)
-                emit!(self, Instruction::ContainsOp(bytecode::Invert::No));
+                emit!(
+                    self,
+                    Instruction::ContainsOp {
+                        invert: bytecode::Invert::No
+                    }
+                );
                 // POP_JUMP_IF_FALSE not_set
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: not_set_block
+                        delta: not_set_block
                     }
                 );
 
                 // Annotation value
                 self.compile_annotation(annotation)?;
                 // COPY dict to TOS
-                emit!(self, Instruction::Copy { index: 2 });
+                emit!(self, Instruction::Copy { i: 2 });
                 // LOAD_CONST name
                 self.emit_load_const(ConstantData::Str {
                     value: self.mangle(name).into_owned().into(),
@@ -4036,7 +4026,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: num_annotations,
+                    count: num_annotations,
                 }
             );
             emit!(self, Instruction::ReturnValue);
@@ -4143,7 +4133,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, Instruction::LoadFast { var_num: i as u32 });
             }
         }
 
@@ -4162,7 +4152,7 @@ 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, Instruction::Swap { i: 2 });
 
             // Call INTRINSIC_SET_FUNCTION_TYPE_PARAMS
             emit!(
@@ -4194,31 +4184,31 @@ impl Compiler {
                 match num_typeparam_args {
                     1 => {
                         // Stack: [arg1, closure]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, arg1]
                         emit!(self, Instruction::PushNull); // [closure, arg1, NULL]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]
+                        emit!(self, Instruction::Swap { i: 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::Swap { i: 3 }); // [closure, arg2, arg1]
+                        emit!(self, Instruction::Swap { i: 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, Instruction::Swap { i: 3 }); // [closure, NULL, arg2, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, NULL, arg1, arg2]
                     }
                     _ => unreachable!("only defaults and kwdefaults are supported"),
                 }
                 emit!(
                     self,
                     Instruction::Call {
-                        nargs: num_typeparam_args as u32
+                        argc: num_typeparam_args as u32
                     }
                 );
             } else {
                 // Stack: [closure]
                 emit!(self, Instruction::PushNull);
                 // Stack: [closure, NULL]
-                emit!(self, Instruction::Call { nargs: 0 });
+                emit!(self, Instruction::Call { argc: 0 });
             }
         }
 
@@ -4323,14 +4313,14 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, PseudoInstruction::LoadClosure(idx.to_u32()));
+                emit!(self, PseudoInstruction::LoadClosure { i: idx.to_u32() });
             }
 
             // Build tuple of closure variables
             emit!(
                 self,
                 Instruction::BuildTuple {
-                    size: code.freevars.len().to_u32(),
+                    count: code.freevars.len().to_u32(),
                 }
             );
         }
@@ -4351,7 +4341,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::CLOSURE
+                    flag: bytecode::MakeFunctionFlags::CLOSURE
                 }
             );
         }
@@ -4361,7 +4351,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::ANNOTATIONS
+                    flag: bytecode::MakeFunctionFlags::ANNOTATIONS
                 }
             );
         }
@@ -4371,7 +4361,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::ANNOTATE
+                    flag: bytecode::MakeFunctionFlags::ANNOTATE
                 }
             );
         }
@@ -4381,7 +4371,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
+                    flag: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
                 }
             );
         }
@@ -4391,7 +4381,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::DEFAULTS
+                    flag: bytecode::MakeFunctionFlags::DEFAULTS
                 }
             );
         }
@@ -4401,7 +4391,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::TYPE_PARAMS
+                    flag: bytecode::MakeFunctionFlags::TYPE_PARAMS
                 }
             );
         }
@@ -4485,20 +4475,30 @@ impl Compiler {
         let dunder_name = self.name("__name__");
         self.emit_load_global(dunder_name, false);
         let dunder_module = self.name("__module__");
-        emit!(self, Instruction::StoreName(dunder_module));
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: 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,
+            Instruction::StoreName {
+                namei: 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, Instruction::StoreName { namei: doc_name });
         }
 
         // Store __firstlineno__ (new in Python 3.12+)
@@ -4506,24 +4506,39 @@ impl Compiler {
             value: BigInt::from(firstlineno),
         });
         let firstlineno_name = self.name("__firstlineno__");
-        emit!(self, Instruction::StoreName(firstlineno_name));
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: 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,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
 
             // Store as __type_params__
             let dunder_type_params = self.name("__type_params__");
-            emit!(self, Instruction::StoreName(dunder_type_params));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dunder_type_params
+                }
+            );
         }
 
         // PEP 649: Initialize __classdict__ cell for class annotation scope
         if self.current_symbol_table().needs_classdict {
             emit!(self, Instruction::LoadLocals);
             let classdict_idx = self.get_cell_var_index("__classdict__")?;
-            emit!(self, Instruction::StoreDeref(classdict_idx));
+            emit!(self, Instruction::StoreDeref { i: classdict_idx });
         }
 
         // Handle class annotations based on future_annotations flag
@@ -4534,7 +4549,7 @@ impl Compiler {
             } else {
                 // PEP 649: Initialize __conditional_annotations__ set if needed for class
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
 
@@ -4557,10 +4572,15 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, PseudoInstruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(
+                self,
+                PseudoInstruction::LoadClosure {
+                    i: classcell_idx.to_u32()
+                }
+            );
+            emit!(self, Instruction::Copy { i: 1 });
             let classcell = self.name("__classcell__");
-            emit!(self, Instruction::StoreName(classcell));
+            emit!(self, Instruction::StoreName { namei: classcell });
         } else {
             self.emit_load_const(ConstantData::None);
         }
@@ -4613,7 +4633,12 @@ 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,
+                Instruction::StoreName {
+                    namei: dot_type_params
+                }
+            );
         }
 
         // Step 2: Compile class body (always done, whether generic or not)
@@ -4634,14 +4659,24 @@ impl Compiler {
             let dot_generic_base = self.name(".generic_base");
 
             // Create .generic_base
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
             emit!(
                 self,
                 Instruction::CallIntrinsic1 {
                     func: bytecode::IntrinsicFunction1::SubscriptGeneric
                 }
             );
-            emit!(self, Instruction::StoreName(dot_generic_base));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dot_generic_base
+                }
+            );
 
             // Generate class creation code
             emit!(self, Instruction::LoadBuildClass);
@@ -4649,7 +4684,12 @@ impl Compiler {
 
             // Set up the class function with type params
             let mut func_flags = bytecode::MakeFunctionFlags::empty();
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
             func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
 
             // Create class function with closure
@@ -4672,7 +4712,7 @@ impl Compiler {
                 // Need to build: args tuple = (class_func, name, *bases, .generic_base)
 
                 // Build a list starting with class_func and name (2 elements already on stack)
-                emit!(self, Instruction::BuildList { size: 2 });
+                emit!(self, Instruction::BuildList { count: 2 });
 
                 // Add bases to the list
                 if let Some(arguments) = arguments {
@@ -4690,7 +4730,12 @@ impl Compiler {
                 }
 
                 // Add .generic_base as final element
-                emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: dot_generic_base
+                    }
+                );
                 emit!(self, Instruction::ListAppend { i: 0 });
 
                 // Convert list to tuple
@@ -4721,7 +4766,12 @@ impl Compiler {
                 };
 
                 // Load .generic_base as the last base
-                emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: dot_generic_base
+                    }
+                );
 
                 let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;
 
@@ -4745,13 +4795,13 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::CallKw {
-                            nargs: nargs
+                            argc: nargs
                                 + u32::try_from(arguments.keywords.len())
                                     .expect("too many keyword arguments")
                         }
                     );
                 } else {
-                    emit!(self, Instruction::Call { nargs });
+                    emit!(self, Instruction::Call { argc: nargs });
                 }
             }
 
@@ -4765,7 +4815,7 @@ 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, Instruction::Call { argc: 0 });
         } else {
             // Non-generic class: standard path
             emit!(self, Instruction::LoadBuildClass);
@@ -4778,7 +4828,7 @@ impl Compiler {
             if let Some(arguments) = arguments {
                 self.codegen_call_helper(2, arguments, self.current_source_range)?;
             } else {
-                emit!(self, Instruction::Call { nargs: 2 });
+                emit!(self, Instruction::Call { argc: 2 });
             }
         }
 
@@ -4810,12 +4860,7 @@ impl Compiler {
         let was_in_loop = self.ctx.loop_data.replace((while_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: while_block,
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: while_block });
         self.switch_to_block(else_block);
 
         // Pop fblock
@@ -4877,7 +4922,7 @@ impl Compiler {
         self.set_source_range(with_range);
 
         // Stack: [cm]
-        emit!(self, Instruction::Copy { index: 1_u32 }); // [cm, cm]
+        emit!(self, Instruction::Copy { i: 1 }); // [cm, cm]
 
         if is_async {
             if self.ctx.func != FunctionContext::AsyncFunction {
@@ -4890,7 +4935,7 @@ impl Compiler {
                     method: SpecialMethod::AExit
                 }
             ); // [cm, bound_aexit]
-            emit!(self, Instruction::Swap { index: 2_u32 }); // [bound_aexit, cm]
+            emit!(self, Instruction::Swap { i: 2 }); // [bound_aexit, cm]
             emit!(
                 self,
                 Instruction::LoadSpecial {
@@ -4899,8 +4944,8 @@ impl Compiler {
             ); // [bound_aexit, bound_aenter]
             // bound_aenter is already bound, call with NULL self_or_null
             emit!(self, Instruction::PushNull); // [bound_aexit, bound_aenter, NULL]
-            emit!(self, Instruction::Call { nargs: 0 }); // [bound_aexit, awaitable]
-            emit!(self, Instruction::GetAwaitable { arg: 1 });
+            emit!(self, Instruction::Call { argc: 0 }); // [bound_aexit, awaitable]
+            emit!(self, Instruction::GetAwaitable { r#where: 1 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         } else {
@@ -4911,7 +4956,7 @@ impl Compiler {
                     method: SpecialMethod::Exit
                 }
             ); // [cm, bound_exit]
-            emit!(self, Instruction::Swap { index: 2_u32 }); // [bound_exit, cm]
+            emit!(self, Instruction::Swap { i: 2 }); // [bound_exit, cm]
             emit!(
                 self,
                 Instruction::LoadSpecial {
@@ -4920,7 +4965,7 @@ impl Compiler {
             ); // [bound_exit, bound_enter]
             // bound_enter is already bound, call with NULL self_or_null
             emit!(self, Instruction::PushNull); // [bound_exit, bound_enter, NULL]
-            emit!(self, Instruction::Call { nargs: 0 }); // [bound_exit, enter_result]
+            emit!(self, Instruction::Call { argc: 0 }); // [bound_exit, enter_result]
         }
 
         // Stack: [..., __exit__, enter_result]
@@ -4929,7 +4974,7 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupWith {
-                target: exc_handler_block
+                delta: exc_handler_block
             }
         );
         self.push_fblock(
@@ -4981,19 +5026,14 @@ impl Compiler {
         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, Instruction::Call { argc: 3 });
         if is_async {
-            emit!(self, Instruction::GetAwaitable { arg: 2 });
+            emit!(self, Instruction::GetAwaitable { r#where: 2 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         }
         emit!(self, Instruction::PopTop); // Pop __exit__ result
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: after_block
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
         // ===== Exception handler path =====
         // Stack at entry (after unwind): [..., __exit__, lasti, exc]
@@ -5007,7 +5047,7 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupCleanup {
-                target: cleanup_block
+                delta: cleanup_block
             }
         );
         self.push_fblock(FBlockType::ExceptionHandler, exc_handler_block, after_block)?;
@@ -5021,7 +5061,7 @@ impl Compiler {
         emit!(self, Instruction::WithExceptStart);
 
         if is_async {
-            emit!(self, Instruction::GetAwaitable { arg: 2 });
+            emit!(self, Instruction::GetAwaitable { r#where: 2 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         }
@@ -5031,7 +5071,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::PopJumpIfTrue {
-                target: suppress_block
+                delta: suppress_block
             }
         );
 
@@ -5054,12 +5094,7 @@ impl Compiler {
         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 {
-                target: after_block
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
         // ===== Cleanup block (for nested exception during __exit__) =====
         // Stack: [..., __exit__, lasti, prev_exc, lasti2, exc2]
@@ -5072,7 +5107,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::Copy { index: 3 });
+        emit!(self, Instruction::Copy { i: 3 });
         emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
@@ -5114,7 +5149,7 @@ impl Compiler {
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
             // SETUP_FINALLY to guard the __anext__ call
-            emit!(self, PseudoInstruction::SetupFinally { target: else_block });
+            emit!(self, PseudoInstruction::SetupFinally { delta: else_block });
             emit!(self, Instruction::GetANext);
             self.emit_load_const(ConstantData::None);
             end_async_for_target = self.compile_yield_from_sequence(true)?;
@@ -5133,7 +5168,7 @@ impl Compiler {
             // Push fblock for for loop
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
-            emit!(self, Instruction::ForIter { target: else_block });
+            emit!(self, Instruction::ForIter { delta: else_block });
 
             // Start of loop iteration, set targets:
             self.compile_store(target)?;
@@ -5142,7 +5177,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, PseudoInstruction::Jump { target: for_block });
+        emit!(self, PseudoInstruction::Jump { delta: for_block });
 
         self.switch_to_block(else_block);
 
@@ -5215,7 +5250,7 @@ impl Compiler {
                 emit!(
                     self,
                     PseudoInstruction::Jump {
-                        target: pc.fail_pop[pops]
+                        delta: pc.fail_pop[pops]
                     }
                 );
             }
@@ -5223,7 +5258,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: pc.fail_pop[pops]
+                        delta: pc.fail_pop[pops]
                     }
                 );
             }
@@ -5265,7 +5300,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(count).unwrap()
+                    i: u32::try_from(count).unwrap()
                 }
             );
             count -= 1;
@@ -5325,11 +5360,11 @@ impl Compiler {
                         todo!();
                         // return self.compiler_error(loc, "too many expressions in star-unpacking sequence pattern");
                     }
-                    let args = UnpackExArgs {
+                    let counts = UnpackExArgs {
                         before: u8::try_from(i).unwrap(),
                         after: u8::try_from(n - i - 1).unwrap(),
                     };
-                    emit!(self, Instruction::UnpackEx { args });
+                    emit!(self, Instruction::UnpackEx { counts });
                     seen_star = true;
                 } else {
                     // TODO: Fix error msg
@@ -5342,7 +5377,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::UnpackSequence {
-                    size: u32::try_from(n).unwrap()
+                    count: u32::try_from(n).unwrap()
                 }
             );
         }
@@ -5387,7 +5422,7 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { i: 1 });
             if i < star {
                 // For indices before the star, use a nonnegative index equal to i.
                 self.emit_load_const(ConstantData::Integer { value: i.into() });
@@ -5465,7 +5500,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, Instruction::Copy { i: 1 });
         // Compile the sub-pattern.
         self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
         // After success, decrement the on_top counter.
@@ -5561,13 +5596,23 @@ impl Compiler {
             elements: attr_names,
         });
         // 2. Emit MATCH_CLASS with nargs.
-        emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
+        emit!(
+            self,
+            Instruction::MatchClass {
+                count: u32::try_from(nargs).unwrap()
+            }
+        );
         // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // 4. Load None.
         self.emit_load_const(ConstantData::None);
         // 5. Compare with IS_OP 1.
-        emit!(self, Instruction::IsOp(Invert::Yes));
+        emit!(
+            self,
+            Instruction::IsOp {
+                invert: Invert::Yes
+            }
+        );
 
         // At this point the TOS is a tuple of (nargs + n_attrs) attributes (or None).
         pc.on_top += 1;
@@ -5578,7 +5623,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::UnpackSequence {
-                size: u32::try_from(total).unwrap()
+                count: u32::try_from(total).unwrap()
             }
         );
         pc.on_top += total;
@@ -5663,7 +5708,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::GreaterOrEqual
+                    opname: ComparisonOperator::GreaterOrEqual
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -5719,7 +5764,7 @@ impl Compiler {
         // Stack: [subject, key1, key2, ..., key_n]
 
         // Build tuple of keys (empty tuple if size==0)
-        emit!(self, Instruction::BuildTuple { size });
+        emit!(self, Instruction::BuildTuple { count: size });
         // Stack: [subject, keys_tuple]
 
         // Match keys
@@ -5728,19 +5773,24 @@ impl Compiler {
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // 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,
+            Instruction::IsOp {
+                invert: 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, Instruction::UnpackSequence { count: 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;
@@ -5762,16 +5812,16 @@ impl Compiler {
             // Stack: [subject, keys_tuple]
 
             // Build rest dict exactly
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
             // Stack: [subject, keys_tuple, {}]
-            emit!(self, Instruction::Swap { index: 3 });
+            emit!(self, Instruction::Swap { i: 3 });
             // Stack: [{}, keys_tuple, subject]
-            emit!(self, Instruction::DictUpdate { index: 2 });
+            emit!(self, Instruction::DictUpdate { i: 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, Instruction::UnpackSequence { count: size });
             // Stack: [rest_dict, k1, k2, ..., kn] (if size==0, nothing pushed)
 
             // Delete each key from rest_dict (skipped when size==0)
@@ -5779,14 +5829,9 @@ impl Compiler {
             let mut remaining = size;
             while remaining > 0 {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
-                emit!(
-                    self,
-                    Instruction::Copy {
-                        index: 1 + remaining
-                    }
-                );
+                emit!(self, Instruction::Copy { i: 1 + remaining });
                 // Stack: [rest_dict, k1, ..., kn, rest_dict]
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap { i: 2 });
                 // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
                 emit!(self, Instruction::DeleteSubscr);
                 // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
@@ -5842,7 +5887,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, Instruction::Copy { i: 1 });
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -5886,7 +5931,7 @@ impl Compiler {
                 }
             }
             // Emit a jump to the common end label and reset any failure jump targets.
-            emit!(self, PseudoInstruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { delta: end });
             self.emit_and_reset_fail_pop(pc)?;
         }
 
@@ -5971,7 +6016,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::Equal
+                    opname: ComparisonOperator::Equal
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -5984,7 +6029,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::GreaterOrEqual
+                    opname: ComparisonOperator::GreaterOrEqual
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -6013,7 +6058,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::CompareOp {
-                op: bytecode::ComparisonOperator::Equal
+                opname: bytecode::ComparisonOperator::Equal
             }
         );
         // emit!(self, Instruction::ToBool);
@@ -6033,7 +6078,7 @@ impl Compiler {
             ast::Singleton::True => ConstantData::Boolean { value: true },
         });
         // Compare using the "Is" operator.
-        emit!(self, Instruction::IsOp(Invert::No));
+        emit!(self, Instruction::IsOp { invert: Invert::No });
         // Jump to the failure label if the comparison is false.
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         Ok(())
@@ -6089,7 +6134,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, Instruction::Copy { i: 1 });
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -6112,7 +6157,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: pattern_context.fail_pop[0]
+                        delta: pattern_context.fail_pop[0]
                     }
                 );
             }
@@ -6122,7 +6167,7 @@ impl Compiler {
             }
 
             self.compile_statements(&m.body)?;
-            emit!(self, PseudoInstruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { delta: end });
             self.emit_and_reset_fail_pop(pattern_context)?;
         }
 
@@ -6136,8 +6181,8 @@ impl Compiler {
             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::Copy { i: 1 });
+                emit!(self, Instruction::PopJumpIfFalse { delta: end });
                 emit!(self, Instruction::PopTop);
             }
             self.compile_statements(&m.body)?;
@@ -6162,18 +6207,38 @@ impl Compiler {
     fn compile_addcompare(&mut self, op: &ast::CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
-            ast::CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
-            ast::CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
-            ast::CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
-            ast::CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
-            ast::CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
+            ast::CmpOp::Eq => emit!(self, Instruction::CompareOp { opname: Equal }),
+            ast::CmpOp::NotEq => emit!(self, Instruction::CompareOp { opname: NotEqual }),
+            ast::CmpOp::Lt => emit!(self, Instruction::CompareOp { opname: Less }),
+            ast::CmpOp::LtE => emit!(
+                self,
+                Instruction::CompareOp {
+                    opname: LessOrEqual
+                }
+            ),
+            ast::CmpOp::Gt => emit!(self, Instruction::CompareOp { opname: Greater }),
             ast::CmpOp::GtE => {
-                emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
+                emit!(
+                    self,
+                    Instruction::CompareOp {
+                        opname: GreaterOrEqual
+                    }
+                )
             }
-            ast::CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
-            ast::CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
-            ast::CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
-            ast::CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
+            ast::CmpOp::In => emit!(self, Instruction::ContainsOp { invert: Invert::No }),
+            ast::CmpOp::NotIn => emit!(
+                self,
+                Instruction::ContainsOp {
+                    invert: Invert::Yes
+                }
+            ),
+            ast::CmpOp::Is => emit!(self, Instruction::IsOp { invert: Invert::No }),
+            ast::CmpOp::IsNot => emit!(
+                self,
+                Instruction::IsOp {
+                    invert: Invert::Yes
+                }
+            ),
         }
     }
 
@@ -6225,14 +6290,14 @@ impl Compiler {
 
             // store rhs for the next comparison in chain
             self.set_source_range(compare_range);
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::Copy { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
+            emit!(self, Instruction::Copy { i: 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::PopJumpIfFalse { target: cleanup });
+            emit!(self, Instruction::Copy { i: 1 });
+            emit!(self, Instruction::PopJumpIfFalse { delta: cleanup });
             emit!(self, Instruction::PopTop);
         }
 
@@ -6241,11 +6306,11 @@ impl Compiler {
         self.compile_addcompare(last_op);
 
         let end = self.new_block();
-        emit!(self, PseudoInstruction::Jump { target: end });
+        emit!(self, PseudoInstruction::Jump { delta: 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::Swap { i: 2 });
         emit!(self, Instruction::PopTop);
 
         self.switch_to_block(end);
@@ -6269,7 +6334,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, Instruction::UnpackSequence { count: 1 });
                     Ok(())
                 }
                 _ => self.compile_expression(annotation),
@@ -6305,7 +6370,12 @@ impl Compiler {
                 self.compile_annotation(annotation)?;
                 // Load __annotations__
                 let annotations_name = self.name("__annotations__");
-                emit!(self, Instruction::LoadName(annotations_name));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: annotations_name
+                    }
+                );
                 // Load the variable name
                 self.emit_load_const(ConstantData::Str {
                     value: self.mangle(id.as_str()).into_owned().into(),
@@ -6335,7 +6405,7 @@ impl Compiler {
                         self.emit_load_const(ConstantData::Integer {
                             value: annotation_index.into(),
                         });
-                        emit!(self, Instruction::SetAdd { i: 0_u32 });
+                        emit!(self, Instruction::SetAdd { i: 0 });
                         emit!(self, Instruction::PopTop);
                     }
                 }
@@ -6355,8 +6425,8 @@ impl Compiler {
             }
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::StoreAttr { idx });
+                let namei = self.name(attr.as_str());
+                emit!(self, Instruction::StoreAttr { namei });
             }
             ast::Expr::List(ast::ExprList { elts, .. })
             | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
@@ -6378,8 +6448,8 @@ impl Compiler {
                                         target.range(),
                                     )
                                 })?;
-                            let args = bytecode::UnpackExArgs { before, after };
-                            emit!(self, Instruction::UnpackEx { args });
+                            let counts = bytecode::UnpackExArgs { before, after };
+                            emit!(self, Instruction::UnpackEx { counts });
                         }
                     }
                 }
@@ -6388,7 +6458,7 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::UnpackSequence {
-                            size: elts.len().to_u32(),
+                            count: elts.len().to_u32(),
                         }
                     );
                 }
@@ -6442,8 +6512,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::Copy { index: 2_u32 });
-                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { i: 2 });
+                emit!(self, Instruction::Copy { i: 2 });
                 emit!(
                     self,
                     Instruction::BinaryOp {
@@ -6455,7 +6525,7 @@ impl Compiler {
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 let attr = attr.as_str();
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 let idx = self.name(attr);
                 self.emit_load_attr(idx);
                 AugAssignKind::Attr { idx }
@@ -6475,14 +6545,14 @@ impl Compiler {
             }
             AugAssignKind::Subscript => {
                 // stack: CONTAINER SLICE RESULT
-                emit!(self, Instruction::Swap { index: 3 });
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap { i: 3 });
+                emit!(self, Instruction::Swap { i: 2 });
                 emit!(self, Instruction::StoreSubscr);
             }
             AugAssignKind::Attr { idx } => {
                 // stack: CONTAINER RESULT
-                emit!(self, Instruction::Swap { index: 2 });
-                emit!(self, Instruction::StoreAttr { idx });
+                emit!(self, Instruction::Swap { i: 2 });
+                emit!(self, Instruction::StoreAttr { namei: idx });
             }
         }
 
@@ -6586,14 +6656,14 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::PopJumpIfTrue {
-                            target: target_block,
+                            delta: target_block,
                         }
                     );
                 } else {
                     emit!(
                         self,
                         Instruction::PopJumpIfFalse {
-                            target: target_block,
+                            delta: target_block,
                         }
                     );
                 }
@@ -6656,13 +6726,13 @@ impl Compiler {
     /// Emit `Copy 1` + conditional jump for short-circuit evaluation.
     /// For `And`, emits `PopJumpIfFalse`; for `Or`, emits `PopJumpIfTrue`.
     fn emit_short_circuit_test(&mut self, op: &ast::BoolOp, target: BlockIdx) {
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         match op {
             ast::BoolOp::And => {
-                emit!(self, Instruction::PopJumpIfFalse { target });
+                emit!(self, Instruction::PopJumpIfFalse { delta: target });
             }
             ast::BoolOp::Or => {
-                emit!(self, Instruction::PopJumpIfTrue { target });
+                emit!(self, Instruction::PopJumpIfTrue { delta: target });
             }
         }
     }
@@ -6679,7 +6749,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: u32::try_from(items.len()).expect("too many dict items"),
+                    count: u32::try_from(items.len()).expect("too many dict items"),
                 }
             );
             return Ok(());
@@ -6697,9 +6767,9 @@ impl Compiler {
             () => {
                 #[allow(unused_assignments)]
                 if elements > 0 {
-                    emit!(self, Instruction::BuildMap { size: elements });
+                    emit!(self, Instruction::BuildMap { count: elements });
                     if have_dict {
-                        emit!(self, Instruction::DictUpdate { index: 1 });
+                        emit!(self, Instruction::DictUpdate { i: 1 });
                     } else {
                         have_dict = true;
                     }
@@ -6718,17 +6788,17 @@ impl Compiler {
                 // ** unpacking entry
                 flush_pending!();
                 if !have_dict {
-                    emit!(self, Instruction::BuildMap { size: 0 });
+                    emit!(self, Instruction::BuildMap { count: 0 });
                     have_dict = true;
                 }
                 self.compile_expression(&item.value)?;
-                emit!(self, Instruction::DictUpdate { index: 1 });
+                emit!(self, Instruction::DictUpdate { i: 1 });
             }
         }
 
         flush_pending!();
         if !have_dict {
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
         }
 
         Ok(())
@@ -6755,10 +6825,10 @@ impl Compiler {
 
         // send:
         self.switch_to_block(send_block);
-        emit!(self, Instruction::Send { target: exit_block });
+        emit!(self, Instruction::Send { delta: exit_block });
 
         // SETUP_FINALLY fail - set up exception handler for YIELD_VALUE
-        emit!(self, PseudoInstruction::SetupFinally { target: fail_block });
+        emit!(self, PseudoInstruction::SetupFinally { delta: fail_block });
         self.push_fblock(
             FBlockType::TryExcept, // Use TryExcept for exception handler
             send_block,
@@ -6776,7 +6846,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::Resume {
-                arg: if is_await {
+                context: if is_await {
                     u32::from(bytecode::ResumeType::AfterAwait)
                 } else {
                     u32::from(bytecode::ResumeType::AfterYieldFrom)
@@ -6787,7 +6857,7 @@ impl Compiler {
         // JUMP_BACKWARD_NO_INTERRUPT send
         emit!(
             self,
-            PseudoInstruction::JumpNoInterrupt { target: send_block }
+            PseudoInstruction::JumpNoInterrupt { delta: send_block }
         );
 
         // fail: CLEANUP_THROW
@@ -6938,7 +7008,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::Resume {
-                        arg: u32::from(bytecode::ResumeType::AfterYield)
+                        context: u32::from(bytecode::ResumeType::AfterYield)
                     }
                 );
             }
@@ -6947,7 +7017,7 @@ impl Compiler {
                     return Err(self.error(CodegenErrorType::InvalidAwait));
                 }
                 self.compile_expression(value)?;
-                emit!(self, Instruction::GetAwaitable { arg: 0 });
+                emit!(self, Instruction::GetAwaitable { r#where: 0 });
                 self.emit_load_const(ConstantData::None);
                 let _ = self.compile_yield_from_sequence(true)?;
             }
@@ -6991,7 +7061,7 @@ impl Compiler {
                     for element in &defaults {
                         self.compile_expression(element)?;
                     }
-                    emit!(self, Instruction::BuildTuple { size });
+                    emit!(self, Instruction::BuildTuple { count: size });
                 }
 
                 // Prepare keyword-only defaults
@@ -7014,7 +7084,7 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::BuildMap {
-                            size: default_kw_count.to_u32(),
+                            count: default_kw_count.to_u32(),
                         }
                     );
                 }
@@ -7057,7 +7127,7 @@ impl Compiler {
                     "<listcomp>",
                     Some(
                         Instruction::BuildList {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -7083,7 +7153,7 @@ impl Compiler {
                     "<setcomp>",
                     Some(
                         Instruction::BuildSet {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -7112,7 +7182,7 @@ impl Compiler {
                     "<dictcomp>",
                     Some(
                         Instruction::BuildMap {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -7160,7 +7230,7 @@ impl Compiler {
                         emit!(
                             compiler,
                             Instruction::Resume {
-                                arg: u32::from(bytecode::ResumeType::AfterYield)
+                                context: u32::from(bytecode::ResumeType::AfterYield)
                             }
                         );
                         emit!(compiler, Instruction::PopTop);
@@ -7190,12 +7260,7 @@ impl Compiler {
 
                 // True case
                 self.compile_expression(body)?;
-                emit!(
-                    self,
-                    PseudoInstruction::Jump {
-                        target: after_block,
-                    }
-                );
+                emit!(self, PseudoInstruction::Jump { delta: after_block });
 
                 // False case
                 self.switch_to_block(else_block);
@@ -7212,7 +7277,7 @@ impl Compiler {
                 range: _,
             }) => {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 self.compile_store(target)?;
             }
             ast::Expr::FString(fstring) => {
@@ -7295,14 +7360,14 @@ impl Compiler {
                         sub_size += 1;
                     }
                 }
-                emit!(self, Instruction::BuildMap { size: sub_size });
+                emit!(self, Instruction::BuildMap { count: sub_size });
                 size += 1;
             }
         }
         if size > 1 {
             // Merge all dicts: first dict is accumulator, merge rest into it
             for _ in 1..size {
-                emit!(self, Instruction::DictMerge { index: 1 });
+                emit!(self, Instruction::DictMerge { i: 1 });
             }
         }
         Ok(())
@@ -7371,7 +7436,7 @@ impl Compiler {
         let big = n * 2 > 8; // STACK_USE_GUIDELINE approximation
 
         if big {
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
         }
 
         for kw in &keywords[begin..end] {
@@ -7387,7 +7452,7 @@ impl Compiler {
         }
 
         if !big {
-            emit!(self, Instruction::BuildMap { size: n.to_u32() });
+            emit!(self, Instruction::BuildMap { count: n.to_u32() });
         }
 
         Ok(())
@@ -7437,12 +7502,12 @@ impl Compiler {
                     elements: kwarg_names,
                 });
 
-                let nargs = additional_positional + nelts.to_u32() + nkwelts.to_u32();
-                emit!(self, Instruction::CallKw { nargs });
+                let argc = additional_positional + nelts.to_u32() + nkwelts.to_u32();
+                emit!(self, Instruction::CallKw { argc });
             } else {
                 self.set_source_range(call_range);
-                let nargs = additional_positional + nelts.to_u32();
-                emit!(self, Instruction::Call { nargs });
+                let argc = additional_positional + nelts.to_u32();
+                emit!(self, Instruction::Call { argc });
             }
         } else {
             // ex_call path: has * or ** args
@@ -7484,19 +7549,19 @@ impl Compiler {
                             // Pack up preceding keywords using codegen_subkwargs
                             self.codegen_subkwargs(&arguments.keywords, i - nseen, i)?;
                             if have_dict {
-                                emit!(self, Instruction::DictMerge { index: 1 });
+                                emit!(self, Instruction::DictMerge { i: 1 });
                             }
                             have_dict = true;
                             nseen = 0;
                         }
 
                         if !have_dict {
-                            emit!(self, Instruction::BuildMap { size: 0 });
+                            emit!(self, Instruction::BuildMap { count: 0 });
                             have_dict = true;
                         }
 
                         self.compile_expression(&keyword.value)?;
-                        emit!(self, Instruction::DictMerge { index: 1 });
+                        emit!(self, Instruction::DictMerge { i: 1 });
                     } else {
                         nseen += 1;
                     }
@@ -7506,7 +7571,7 @@ impl Compiler {
                 if nseen > 0 {
                     self.codegen_subkwargs(&arguments.keywords, nkwelts - nseen, nkwelts)?;
                     if have_dict {
-                        emit!(self, Instruction::DictMerge { index: 1 });
+                        emit!(self, Instruction::DictMerge { i: 1 });
                     }
                     have_dict = true;
                 }
@@ -7633,7 +7698,7 @@ impl Compiler {
 
             if loop_labels.is_empty() {
                 // Load iterator onto stack (passed as first argument):
-                emit!(self, Instruction::LoadFast(arg0));
+                emit!(self, Instruction::LoadFast { var_num: arg0 });
             } else {
                 // Evaluate iterated item:
                 self.compile_expression(&generator.iter)?;
@@ -7649,12 +7714,7 @@ impl Compiler {
             self.switch_to_block(loop_block);
             let mut end_async_for_target = BlockIdx::NULL;
             if generator.is_async {
-                emit!(
-                    self,
-                    PseudoInstruction::SetupFinally {
-                        target: after_block
-                    }
-                );
+                emit!(self, PseudoInstruction::SetupFinally { delta: after_block });
                 emit!(self, Instruction::GetANext);
                 self.push_fblock(
                     FBlockType::AsyncComprehensionGenerator,
@@ -7669,12 +7729,7 @@ impl Compiler {
                 self.pop_fblock(FBlockType::AsyncComprehensionGenerator);
                 self.compile_store(&generator.target)?;
             } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::ForIter { delta: after_block });
                 self.compile_store(&generator.target)?;
             }
             loop_labels.push((
@@ -7696,10 +7751,10 @@ impl Compiler {
         for (loop_block, if_cleanup_block, after_block, is_async, end_async_for_target) in
             loop_labels.iter().rev().copied()
         {
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(if_cleanup_block);
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(after_block);
             if is_async {
@@ -7739,9 +7794,9 @@ impl Compiler {
         };
 
         // Call just created <listcomp> function:
-        emit!(self, Instruction::Call { nargs: 1 });
+        emit!(self, Instruction::Call { argc: 1 });
         if is_async_list_set_dict_comprehension {
-            emit!(self, Instruction::GetAwaitable { arg: 0 });
+            emit!(self, Instruction::GetAwaitable { r#where: 0 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         }
@@ -7814,8 +7869,8 @@ impl Compiler {
 
         // 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));
+            let var_num = self.varname(name)?;
+            emit!(self, Instruction::LoadFastAndClear { var_num });
         }
 
         // Step 3: SWAP iterator to TOS (above saved locals)
@@ -7823,7 +7878,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
         }
@@ -7833,7 +7888,7 @@ impl Compiler {
         if let Some(init_collection) = init_collection {
             self._emit(init_collection, OpArg::new(0), BlockIdx::NULL);
             // SWAP to get iterator on top
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
         }
 
         // Set up exception handler for cleanup on exception
@@ -7844,7 +7899,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: cleanup_block
+                    delta: cleanup_block
                 }
             );
             self.push_fblock(FBlockType::TryExcept, cleanup_block, end_block)?;
@@ -7876,12 +7931,7 @@ impl Compiler {
                 end_async_for_target = self.compile_yield_from_sequence(true)?;
                 self.compile_store(&generator.target)?;
             } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::ForIter { delta: after_block });
                 self.compile_store(&generator.target)?;
             }
             loop_labels.push((
@@ -7905,10 +7955,10 @@ impl Compiler {
         for (loop_block, if_cleanup_block, after_block, is_async, end_async_for_target) in
             loop_labels.iter().rev().copied()
         {
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(if_cleanup_block);
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(after_block);
             if is_async {
@@ -7928,25 +7978,25 @@ impl Compiler {
             self.pop_fblock(FBlockType::TryExcept);
 
             // Normal path: jump past cleanup
-            emit!(self, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: 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::Swap { i: 2 });
             emit!(self, Instruction::PopTop); // Pop incomplete collection
 
             // Restore locals
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: 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));
+                let var_num = self.varname(name)?;
+                emit!(self, Instruction::StoreFast { var_num });
             }
             // Re-raise the exception
             emit!(self, Instruction::Reraise { depth: 0 });
@@ -7960,15 +8010,15 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
         }
 
         // Restore saved locals
         for name in pushed_locals.iter().rev() {
-            let idx = self.varname(name)?;
-            emit!(self, Instruction::StoreFast(idx));
+            let var_num = self.varname(name)?;
+            emit!(self, Instruction::StoreFast { var_num });
         }
 
         Ok(())
@@ -8036,7 +8086,7 @@ 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, |consti| Instruction::LoadConst { consti })
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
@@ -8055,7 +8105,7 @@ impl Compiler {
             .name_idx(name_idx)
             .is_method(false)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadAttr { idx: arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadAttr { namei })
     }
 
     /// Emit LOAD_ATTR with method flag set (for method calls).
@@ -8065,14 +8115,14 @@ impl Compiler {
             .name_idx(name_idx)
             .is_method(true)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadAttr { idx: arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadAttr { namei })
     }
 
     /// Emit LOAD_GLOBAL.
     /// Encodes: (name_idx << 1) | push_null_bit
     fn emit_load_global(&mut self, name_idx: u32, push_null: bool) {
         let encoded = (name_idx << 1) | u32::from(push_null);
-        self.emit_arg(encoded, Instruction::LoadGlobal);
+        self.emit_arg(encoded, |namei| Instruction::LoadGlobal { namei });
     }
 
     /// Emit LOAD_SUPER_ATTR for 2-arg super().attr access.
@@ -8083,7 +8133,7 @@ impl Compiler {
             .is_load_method(false)
             .has_class(true)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 2-arg super().method() call.
@@ -8094,7 +8144,7 @@ impl Compiler {
             .is_load_method(true)
             .has_class(true)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 0-arg super().attr access.
@@ -8105,7 +8155,7 @@ impl Compiler {
             .is_load_method(false)
             .has_class(false)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 0-arg super().method() call.
@@ -8116,7 +8166,7 @@ impl Compiler {
             .is_load_method(true)
             .has_class(false)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     fn emit_return_value(&mut self) {
@@ -8262,10 +8312,10 @@ impl Compiler {
                     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, Instruction::Call { argc: 3 });
 
                     if is_async {
-                        emit!(self, Instruction::GetAwaitable { arg: 2 });
+                        emit!(self, Instruction::GetAwaitable { r#where: 2 });
                         self.emit_load_const(ConstantData::None);
                         let _ = self.compile_yield_from_sequence(true)?;
                     }
@@ -8328,7 +8378,7 @@ impl Compiler {
 
         // Jump to target
         let target = if is_break { exit_block } else { loop_block };
-        emit!(self, PseudoInstruction::Jump { target });
+        emit!(self, PseudoInstruction::Jump { delta: target });
 
         Ok(())
     }
@@ -8447,7 +8497,7 @@ impl Compiler {
             .try_into()
             .expect("BuildString size overflowed");
         if part_count > 1 {
-            emit!(self, Instruction::BuildString { size: part_count });
+            emit!(self, Instruction::BuildString { count: part_count });
         }
 
         Ok(())
@@ -8570,7 +8620,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildString {
-                    size: element_count
+                    count: element_count
                 }
             );
         }
@@ -8604,7 +8654,12 @@ impl Compiler {
         // Stack currently has all interpolations from compile_tstring_into calls
 
         // 1. Build interpolations tuple from the interpolations on the stack
-        emit!(self, Instruction::BuildTuple { size: interp_count });
+        emit!(
+            self,
+            Instruction::BuildTuple {
+                count: interp_count
+            }
+        );
 
         // 2. Load all string parts
         let string_count: u32 = all_strings
@@ -8616,10 +8671,15 @@ impl Compiler {
         }
 
         // 3. Build strings tuple
-        emit!(self, Instruction::BuildTuple { size: string_count });
+        emit!(
+            self,
+            Instruction::BuildTuple {
+                count: string_count
+            }
+        );
 
         // 4. Swap so strings is below interpolations: [interps, strings] -> [strings, interps]
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { i: 2 });
 
         // 5. Build the Template
         emit!(self, Instruction::BuildTemplate);
@@ -8685,8 +8745,8 @@ impl Compiler {
 
                     // Emit BUILD_INTERPOLATION
                     // oparg encoding: (conversion << 2) | has_format_spec
-                    let oparg = (conversion << 2) | u32::from(has_format_spec);
-                    emit!(self, Instruction::BuildInterpolation { oparg });
+                    let format = (conversion << 2) | u32::from(has_format_spec);
+                    emit!(self, Instruction::BuildInterpolation { format });
 
                     *interp_count += 1;
                 }

From 88450949b9f5cd281f2b2893604279fab9e892aa Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 1 Mar 2026 13:18:37 +0100
Subject: [PATCH 07/22] codegen compiles

---
 crates/codegen/src/compile.rs | 54 ++++++++++++++++-------------------
 1 file changed, 25 insertions(+), 29 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index a0bc08d03c8..93ff35f8cbe 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -948,7 +948,7 @@ impl Compiler {
                         )));
                     }
                 };
-                self.emit_arg(idx, Instruction::LoadDeref);
+                emit!(self, Instruction::LoadDeref { i: idx });
 
                 // Load first parameter (typically 'self').
                 // Safety: can_optimize_super_call() ensures argcount > 0, and
@@ -1690,7 +1690,7 @@ impl Compiler {
                 value: value.into(),
             });
             let doc = self.name("__doc__");
-            emit!(self, Instruction::StoreGlobal(doc))
+            emit!(self, Instruction::StoreGlobal { namei: doc })
         }
 
         // Handle annotations based on future_annotations flag
@@ -1972,61 +1972,57 @@ impl Compiler {
         // Generate appropriate instructions based on operation type
         match op_type {
             NameOp::Deref => {
-                let idx = match actual_scope {
+                let i = match actual_scope {
                     SymbolScope::Free => self.get_free_var_index(&name)?,
                     SymbolScope::Cell => self.get_cell_var_index(&name)?,
                     _ => unreachable!("Invalid scope for Deref operation"),
                 };
 
-                let op = match usage {
+                match usage {
                     NameUsage::Load => {
                         // ClassBlock (not inlined comp): LOAD_LOCALS first, then LOAD_FROM_DICT_OR_DEREF
                         if self.ctx.in_class && !self.ctx.in_func() {
                             emit!(self, Instruction::LoadLocals);
-                            Instruction::LoadFromDictOrDeref
+                            emit!(self, Instruction::LoadFromDictOrDeref { i });
                         // can_see_class_scope: LOAD_DEREF(__classdict__) first
                         } else if can_see_class_scope {
                             let classdict_idx = self.get_free_var_index("__classdict__")?;
-                            self.emit_arg(classdict_idx, Instruction::LoadDeref);
-                            Instruction::LoadFromDictOrDeref
+                            emit!(self, Instruction::LoadDeref { i: classdict_idx });
+                            emit!(self, Instruction::LoadFromDictOrDeref { i });
                         } else {
-                            Instruction::LoadDeref
+                            emit!(self, Instruction::LoadDeref { i });
                         }
                     }
-                    NameUsage::Store => Instruction::StoreDeref,
-                    NameUsage::Delete => Instruction::DeleteDeref,
+                    NameUsage::Store => emit!(self, Instruction::StoreDeref { i }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteDeref { i }),
                 };
-                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,
+                let var_num = self.get_local_var_index(&name)?;
+                match usage {
+                    NameUsage::Load => emit!(self, Instruction::LoadFast { var_num }),
+                    NameUsage::Store => emit!(self, Instruction::StoreFast { var_num }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteFast { var_num }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::Global => {
-                let idx = self.get_global_name_index(&name);
-                let op = match usage {
+                let namei = self.get_global_name_index(&name);
+                match usage {
                     NameUsage::Load => {
-                        self.emit_load_global(idx, false);
+                        self.emit_load_global(namei, false);
                         return Ok(());
                     }
-                    NameUsage::Store => Instruction::StoreGlobal,
-                    NameUsage::Delete => Instruction::DeleteGlobal,
+                    NameUsage::Store => emit!(self, Instruction::StoreGlobal { namei }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteGlobal { namei }),
                 };
-                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,
+                let namei = self.get_global_name_index(&name);
+                match usage {
+                    NameUsage::Load => emit!(self, Instruction::LoadName { namei }),
+                    NameUsage::Store => emit!(self, Instruction::StoreName { namei }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteName { namei }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::DictOrGlobals => {
                 // PEP 649: First check classdict (from __classdict__ freevar), then globals

From bf1dcfa11a8411f5a588bb68883b3359bd50cf6d Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 09:52:12 +0100
Subject: [PATCH 08/22] VM compiles

---
 crates/vm/src/builtins/frame.rs |   2 +-
 crates/vm/src/frame.rs          | 178 ++++++++++++++++----------------
 2 files changed, 89 insertions(+), 91 deletions(-)

diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
index 6f906e531d5..e1e66245987 100644
--- a/crates/vm/src/builtins/frame.rs
+++ b/crates/vm/src/builtins/frame.rs
@@ -295,7 +295,7 @@ pub(crate) mod stack_analysis {
                             stacks[next_i] = next_stack;
                         }
                     }
-                    Instruction::LoadGlobal(_) => {
+                    Instruction::LoadGlobal { .. } => {
                         next_stack = push_value(next_stack, Kind::Object as i64);
                         if oparg & 1 != 0 {
                             next_stack = push_value(next_stack, Kind::Null as i64);
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 132ad61a65b..c8209709bf6 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -732,8 +732,8 @@ impl ExecutingFrame<'_> {
                     // new traceback entries.
                     // EndAsyncFor and CleanupThrow also re-raise non-matching exceptions.
                     let is_reraise = match op {
-                        Instruction::RaiseVarargs { kind } => matches!(
-                            kind.get(arg),
+                        Instruction::RaiseVarargs { argc } => matches!(
+                            argc.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
                         Instruction::Reraise { .. }
@@ -746,9 +746,9 @@ impl ExecutingFrame<'_> {
                     // need contextualization even if the exception has prior traceback
                     let is_new_raise = matches!(
                         op,
-                        Instruction::RaiseVarargs { kind }
+                        Instruction::RaiseVarargs { argc }
                             if matches!(
-                                kind.get(arg),
+                                argc.get(arg),
                                 bytecode::RaiseKind::Raise | bytecode::RaiseKind::RaiseCause
                             )
                     );
@@ -1122,17 +1122,17 @@ impl ExecutingFrame<'_> {
                 self.push_value(result);
                 Ok(None)
             }
-            Instruction::BuildList { size } => {
-                let sz = size.get(arg) as usize;
+            Instruction::BuildList { count } => {
+                let sz = count.get(arg) as usize;
                 let elements = self.pop_multiple(sz).collect();
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            Instruction::BuildSet { size } => {
+            Instruction::BuildMap { count } => self.execute_build_map(vm, count.get(arg)),
+            Instruction::BuildSet { count } => {
                 let set = PySet::default().into_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
+                for element in self.pop_multiple(count.get(arg) as usize) {
                     set.add(element, vm)?;
                 }
                 self.push_value(set.into());
@@ -1149,16 +1149,16 @@ impl ExecutingFrame<'_> {
                  Ok(None)
             }
             */
-            Instruction::BuildString { size } => {
+            Instruction::BuildString { count } => {
                 let s: Wtf8Buf = self
-                    .pop_multiple(size.get(arg) as usize)
+                    .pop_multiple(count.get(arg) as usize)
                     .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
                     .collect();
                 self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
-            Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+            Instruction::BuildTuple { count } => {
+                let elements = self.pop_multiple(count.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
@@ -1179,10 +1179,10 @@ impl ExecutingFrame<'_> {
                 self.push_value(template.into_pyobject(vm));
                 Ok(None)
             }
-            Instruction::BuildInterpolation { oparg } => {
+            Instruction::BuildInterpolation { format } => {
                 // oparg encoding: (conversion << 2) | has_format_spec
                 // Stack: [value, expression_str, (format_spec)?] -> [interpolation]
-                let oparg_val = oparg.get(arg);
+                let oparg_val = format.get(arg);
                 let has_format_spec = (oparg_val & 1) != 0;
                 let conversion_code = oparg_val >> 2;
 
@@ -1213,14 +1213,14 @@ impl ExecutingFrame<'_> {
                 self.push_value(interpolation.into_pyobject(vm));
                 Ok(None)
             }
-            Instruction::Call { nargs } => {
+            Instruction::Call { argc } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
-                let args = self.collect_positional_args(nargs.get(arg));
+                let args = self.collect_positional_args(argc.get(arg));
                 self.execute_call(args, vm)
             }
-            Instruction::CallKw { nargs } => {
+            Instruction::CallKw { argc } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
-                let args = self.collect_keyword_args(nargs.get(arg));
+                let args = self.collect_keyword_args(argc.get(arg));
                 self.execute_call(args, vm)
             }
             Instruction::CallFunctionEx => {
@@ -1259,8 +1259,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(matched);
                 Ok(None)
             }
-            Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
-            Instruction::ContainsOp(invert) => {
+            Instruction::CompareOp { opname } => self.execute_compare(vm, opname.get(arg)),
+            Instruction::ContainsOp { invert } => {
                 let b = self.pop_value();
                 let a = self.pop_value();
 
@@ -1271,14 +1271,12 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            Instruction::ConvertValue { oparg: conversion } => {
-                self.convert_value(conversion.get(arg), vm)
-            }
-            Instruction::Copy { index } => {
+            Instruction::ConvertValue { oparg } => self.convert_value(oparg.get(arg), vm),
+            Instruction::Copy { i } => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
-                let idx = index.get(arg) as usize;
+                let idx = i.get(arg) as usize;
                 let stack_len = self.state.stack.len();
                 if stack_len < idx {
                     eprintln!("CopyItem ERROR: stack_len={}, idx={}", stack_len, idx);
@@ -1294,14 +1292,14 @@ impl ExecutingFrame<'_> {
                 // Free vars are already set up at frame creation time in RustPython
                 Ok(None)
             }
-            Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            Instruction::DeleteDeref(i) => {
+            Instruction::DeleteAttr { namei } => self.delete_attr(vm, namei.get(arg)),
+            Instruction::DeleteDeref { i } => {
                 self.state.cells_frees[i.get(arg) as usize].set(None);
                 Ok(None)
             }
-            Instruction::DeleteFast(idx) => {
+            Instruction::DeleteFast { var_num } => {
                 let fastlocals = unsafe { self.fastlocals.borrow_mut() };
-                let idx = idx.get(arg) as usize;
+                let idx = var_num.get(arg) as usize;
                 if fastlocals[idx].is_none() {
                     return Err(vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
@@ -1315,8 +1313,8 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            Instruction::DeleteGlobal(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::DeleteGlobal { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 match self.globals.del_item(name, vm) {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
@@ -1326,8 +1324,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            Instruction::DeleteName(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::DeleteName { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 let res = self.locals.mapping().ass_subscript(name, None, vm);
 
                 match res {
@@ -1340,12 +1338,12 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
-            Instruction::DictUpdate { index } => {
+            Instruction::DictUpdate { i } => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
                 // The dict to update is at position TOS-i (before popping source)
 
-                let idx = index.get(arg);
+                let idx = i.get(arg);
 
                 // Pop the source from TOS
                 let source = self.pop_value();
@@ -1376,9 +1374,9 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            Instruction::DictMerge { index } => {
+            Instruction::DictMerge { i } => {
                 let source = self.pop_value();
-                let idx = index.get(arg);
+                let idx = i.get(arg);
 
                 // Get the dict to merge into (same logic as DICT_UPDATE)
                 let dict_ref = if idx <= 1 {
@@ -1518,7 +1516,7 @@ impl ExecutingFrame<'_> {
                 debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
                 Ok(None)
             }
-            Instruction::GetAwaitable { arg: oparg } => {
+            Instruction::GetAwaitable { r#where: oparg } => {
                 let iterable = self.pop_value();
 
                 let iter = match crate::coroutine::get_awaitable_iter(iterable.clone(), vm) {
@@ -1601,16 +1599,16 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_int(len).into());
                 Ok(None)
             }
-            Instruction::ImportFrom { idx } => {
-                let obj = self.import_from(vm, idx.get(arg))?;
+            Instruction::ImportFrom { namei } => {
+                let obj = self.import_from(vm, namei.get(arg))?;
                 self.push_value(obj);
                 Ok(None)
             }
-            Instruction::ImportName { idx } => {
-                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
+            Instruction::ImportName { namei } => {
+                self.import(vm, Some(self.code.names[namei.get(arg) as usize]))?;
                 Ok(None)
             }
-            Instruction::IsOp(invert) => {
+            Instruction::IsOp { invert } => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 let res = a.is(&b);
@@ -1670,8 +1668,8 @@ impl ExecutingFrame<'_> {
                 })?;
                 Ok(None)
             }
-            Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            Instruction::LoadSuperAttr { arg: idx } => self.load_super_attr(vm, idx.get(arg)),
+            Instruction::LoadAttr { namei } => self.load_attr(vm, namei.get(arg)),
+            Instruction::LoadSuperAttr { namei } => self.load_super_attr(vm, namei.get(arg)),
             Instruction::LoadBuildClass => {
                 let build_class =
                     if let Some(builtins_dict) = self.builtins.downcast_ref::<PyDict>() {
@@ -1706,7 +1704,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(locals);
                 Ok(None)
             }
-            Instruction::LoadFromDictOrDeref(i) => {
+            Instruction::LoadFromDictOrDeref { i } => {
                 // Pop dict from stack (locals or classdict depending on context)
                 let class_dict = self.pop_value();
                 let i = i.get(arg) as usize;
@@ -1733,10 +1731,10 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            Instruction::LoadFromDictOrGlobals(idx) => {
+            Instruction::LoadFromDictOrGlobals { i } => {
                 // PEP 649: Pop dict from stack (classdict), check there first, then globals
                 let dict = self.pop_value();
-                let name = self.code.names[idx.get(arg) as usize];
+                let name = self.code.names[i.get(arg) as usize];
 
                 // Only treat KeyError as "not found", propagate other exceptions
                 let value = if let Some(dict_obj) = dict.downcast_ref::<PyDict>() {
@@ -1756,8 +1754,8 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            Instruction::LoadConst { idx } => {
-                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
+            Instruction::LoadConst { consti } => {
+                self.push_value(self.code.constants[consti.get(arg) as usize].clone().into());
                 Ok(None)
             }
             Instruction::LoadCommonConstant { idx } => {
@@ -1776,13 +1774,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(value);
                 Ok(None)
             }
-            Instruction::LoadSmallInt { idx } => {
+            Instruction::LoadSmallInt { i } => {
                 // Push small integer (-5..=256) directly without constant table lookup
-                let value = vm.ctx.new_int(idx.get(arg) as i32);
+                let value = vm.ctx.new_int(i.get(arg) as i32);
                 self.push_value(value.into());
                 Ok(None)
             }
-            Instruction::LoadDeref(i) => {
+            Instruction::LoadDeref { i } => {
                 let idx = i.get(arg) as usize;
                 let x = self.state.cells_frees[idx]
                     .get()
@@ -1790,7 +1788,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFast(idx) => {
+            Instruction::LoadFast { var_num } => {
                 #[cold]
                 fn reference_error(
                     varname: &'static PyStrInterned,
@@ -1801,27 +1799,27 @@ impl ExecutingFrame<'_> {
                         format!("local variable '{varname}' referenced before assignment").into(),
                     )
                 }
-                let idx = idx.get(arg) as usize;
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow() }[idx]
                     .clone()
                     .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastAndClear(idx) => {
+            Instruction::LoadFastAndClear { var_num } => {
                 // 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;
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow_mut() }[idx]
                     .take()
                     .unwrap_or_else(|| vm.ctx.none());
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastCheck(idx) => {
+            Instruction::LoadFastCheck { var_num } => {
                 // Same as LoadFast but explicitly checks for unbound locals
                 // (LoadFast in RustPython already does this check)
-                let idx = idx.get(arg) as usize;
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow() }[idx]
                     .clone()
                     .ok_or_else(|| {
@@ -1837,10 +1835,10 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastLoadFast { arg: packed } => {
+            Instruction::LoadFastLoadFast { var_nums } => {
                 // Load two local variables at once
                 // oparg encoding: (idx1 << 4) | idx2
-                let oparg = packed.get(arg);
+                let oparg = var_nums.get(arg);
                 let idx1 = (oparg >> 4) as usize;
                 let idx2 = (oparg & 15) as usize;
                 let fastlocals = unsafe { self.fastlocals.borrow() };
@@ -1870,8 +1868,8 @@ impl ExecutingFrame<'_> {
             }
             // TODO: Implement true borrow optimization (skip Arc::clone).
             // Currently this just clones like LoadFast.
-            Instruction::LoadFastBorrow(idx) => {
-                let idx = idx.get(arg) as usize;
+            Instruction::LoadFastBorrow { var_num } => {
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow() }[idx]
                     .clone()
                     .ok_or_else(|| {
@@ -1887,8 +1885,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
+            Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = (oparg >> 4) as usize;
                 let idx2 = (oparg & 15) as usize;
                 let fastlocals = unsafe { self.fastlocals.borrow() };
@@ -1916,8 +1914,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(x2);
                 Ok(None)
             }
-            Instruction::LoadGlobal(idx) => {
-                let oparg = idx.get(arg);
+            Instruction::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
                 let name = &self.code.names[(oparg >> 1) as usize];
                 let x = self.load_global_or_builtin(name, vm)?;
                 self.push_value(x);
@@ -1926,8 +1924,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            Instruction::LoadName(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::LoadName { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 let result = self.locals.mapping().subscript(name, vm);
                 match result {
                     Ok(x) => self.push_value(x),
@@ -1968,7 +1966,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::MakeFunction => self.execute_make_function(vm),
-            Instruction::MakeCell(_) => {
+            Instruction::MakeCell { .. } => {
                 // Cell creation is handled at frame creation time in RustPython
                 Ok(None)
             }
@@ -1983,14 +1981,14 @@ impl ExecutingFrame<'_> {
                 dict.set_item(&*key, value, vm)?;
                 Ok(None)
             }
-            Instruction::MatchClass(nargs) => {
+            Instruction::MatchClass { count } => {
                 // 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();
                 let kwd_attrs = kwd_attrs.downcast_ref::<PyTuple>().unwrap();
                 let cls = self.pop_value();
                 let subject = self.pop_value();
-                let nargs_val = nargs.get(arg) as usize;
+                let nargs_val = count.get(arg) as usize;
 
                 // Check if subject is an instance of cls
                 if subject.is_instance(cls.as_ref(), vm)? {
@@ -2261,7 +2259,7 @@ impl ExecutingFrame<'_> {
                 self.push_null();
                 Ok(None)
             }
-            Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
+            Instruction::RaiseVarargs { argc } => self.execute_raise(vm, argc.get(arg)),
             Instruction::Resume { .. } => {
                 // Check if bytecode needs re-instrumentation
                 let global_ver = vm
@@ -2383,20 +2381,20 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            Instruction::SetFunctionAttribute { attr } => {
-                self.execute_set_function_attribute(vm, attr.get(arg))
+            Instruction::SetFunctionAttribute { flag } => {
+                self.execute_set_function_attribute(vm, flag.get(arg))
             }
             Instruction::SetupAnnotations => self.setup_annotations(vm),
-            Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            Instruction::StoreDeref(i) => {
+            Instruction::StoreAttr { namei } => self.store_attr(vm, namei.get(arg)),
+            Instruction::StoreDeref { i } => {
                 let value = self.pop_value();
                 self.state.cells_frees[i.get(arg) as usize].set(Some(value));
                 Ok(None)
             }
-            Instruction::StoreFast(idx) => {
+            Instruction::StoreFast { var_num } => {
                 let value = self.pop_value();
                 let fastlocals = unsafe { self.fastlocals.borrow_mut() };
-                fastlocals[idx.get(arg) as usize] = Some(value);
+                fastlocals[var_num.get(arg) as usize] = Some(value);
                 Ok(None)
             }
             Instruction::StoreFastLoadFast { var_nums } => {
@@ -2410,8 +2408,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(load_value);
                 Ok(None)
             }
-            Instruction::StoreFastStoreFast { arg: packed } => {
-                let oparg = packed.get(arg);
+            Instruction::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = (oparg >> 4) as usize;
                 let idx2 = (oparg & 15) as usize;
                 let value1 = self.pop_value();
@@ -2421,14 +2419,14 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx2] = Some(value2);
                 Ok(None)
             }
-            Instruction::StoreGlobal(idx) => {
+            Instruction::StoreGlobal { namei } => {
                 let value = self.pop_value();
                 self.globals
-                    .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
+                    .set_item(self.code.names[namei.get(arg) as usize], value, vm)?;
                 Ok(None)
             }
-            Instruction::StoreName(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::StoreName { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 let value = self.pop_value();
                 self.locals.mapping().ass_subscript(name, Some(value), vm)?;
                 Ok(None)
@@ -2450,7 +2448,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::StoreSubscr => self.execute_store_subscript(vm),
-            Instruction::Swap { index } => {
+            Instruction::Swap { i: index } => {
                 let len = self.state.stack.len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
                 let i = len - 1; // TOS index
@@ -2473,11 +2471,11 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(bool_val).into());
                 Ok(None)
             }
-            Instruction::UnpackEx { args } => {
-                let args = args.get(arg);
+            Instruction::UnpackEx { counts } => {
+                let args = counts.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
             }
-            Instruction::UnpackSequence { size } => self.unpack_sequence(size.get(arg), vm),
+            Instruction::UnpackSequence { count } => self.unpack_sequence(count.get(arg), vm),
             Instruction::WithExceptStart => {
                 // Stack: [..., __exit__, lasti, prev_exc, exc]
                 // Call __exit__(type, value, tb) and push result

From 18b0dfa266fdfbfe31094d318fd30138dca7b147 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 09:57:05 +0100
Subject: [PATCH 09/22] Fix compiler-core

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

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index a72f4b970bb..754447956fa 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -577,7 +577,9 @@ impl Instruction {
             | Self::LoadAttrNondescriptorWithValues
             | Self::LoadAttrProperty
             | Self::LoadAttrSlot
-            | Self::LoadAttrWithHint => Self::LoadAttr { idx: Arg::marker() },
+            | Self::LoadAttrWithHint => Self::LoadAttr {
+                namei: Arg::marker(),
+            },
             // BINARY_OP specializations
             Self::BinaryOpAddFloat
             | Self::BinaryOpAddInt
@@ -615,11 +617,11 @@ impl Instruction {
             | Self::CallStr1
             | Self::CallTuple1
             | Self::CallType1 => Self::Call {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             // CALL_KW specializations
             Self::CallKwBoundMethod | Self::CallKwNonPy | Self::CallKwPy => Self::CallKw {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             // TO_BOOL specializations
             Self::ToBoolAlwaysTrue
@@ -629,48 +631,56 @@ impl Instruction {
             | Self::ToBoolNone
             | Self::ToBoolStr => Self::ToBool,
             // COMPARE_OP specializations
-            Self::CompareOpFloat | Self::CompareOpInt | Self::CompareOpStr => {
-                Self::CompareOp { op: Arg::marker() }
-            }
+            Self::CompareOpFloat | Self::CompareOpInt | Self::CompareOpStr => Self::CompareOp {
+                opname: Arg::marker(),
+            },
             // CONTAINS_OP specializations
-            Self::ContainsOpDict | Self::ContainsOpSet => Self::ContainsOp(Arg::marker()),
+            Self::ContainsOpDict | Self::ContainsOpSet => Self::ContainsOp {
+                invert: Arg::marker(),
+            },
             // FOR_ITER specializations
             Self::ForIterGen | Self::ForIterList | Self::ForIterRange | Self::ForIterTuple => {
                 Self::ForIter {
-                    target: Arg::marker(),
+                    delta: Arg::marker(),
                 }
             }
             // LOAD_GLOBAL specializations
-            Self::LoadGlobalBuiltin | Self::LoadGlobalModule => Self::LoadGlobal(Arg::marker()),
+            Self::LoadGlobalBuiltin | Self::LoadGlobalModule => Self::LoadGlobal {
+                namei: Arg::marker(),
+            },
             // STORE_ATTR specializations
             Self::StoreAttrInstanceValue | Self::StoreAttrSlot | Self::StoreAttrWithHint => {
-                Self::StoreAttr { idx: Arg::marker() }
+                Self::StoreAttr {
+                    namei: Arg::marker(),
+                }
             }
             // LOAD_SUPER_ATTR specializations
-            Self::LoadSuperAttrAttr | Self::LoadSuperAttrMethod => {
-                Self::LoadSuperAttr { arg: Arg::marker() }
-            }
+            Self::LoadSuperAttrAttr | Self::LoadSuperAttrMethod => Self::LoadSuperAttr {
+                namei: Arg::marker(),
+            },
             // STORE_SUBSCR specializations
             Self::StoreSubscrDict | Self::StoreSubscrListInt => Self::StoreSubscr,
             // UNPACK_SEQUENCE specializations
             Self::UnpackSequenceList | Self::UnpackSequenceTuple | Self::UnpackSequenceTwoTuple => {
                 Self::UnpackSequence {
-                    size: Arg::marker(),
+                    count: Arg::marker(),
                 }
             }
             // SEND specializations
             Self::SendGen => Self::Send {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             // LOAD_CONST specializations
-            Self::LoadConstImmortal | Self::LoadConstMortal => {
-                Self::LoadConst { idx: Arg::marker() }
-            }
+            Self::LoadConstImmortal | Self::LoadConstMortal => Self::LoadConst {
+                consti: Arg::marker(),
+            },
             // RESUME specializations
-            Self::ResumeCheck => Self::Resume { arg: Arg::marker() },
+            Self::ResumeCheck => Self::Resume {
+                context: Arg::marker(),
+            },
             // JUMP_BACKWARD specializations
             Self::JumpBackwardJit | Self::JumpBackwardNoJit => Self::JumpBackward {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             // Instrumented opcodes map back to their base
             _ => match self.to_base() {

From 96dd420b5e2783e6cd601eeeceec8315b230a383 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:00:29 +0100
Subject: [PATCH 10/22] fix merge

---
 crates/vm/src/frame.rs | 40 +++++++++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 15 deletions(-)

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 17ddba35634..a56d92e88bd 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1257,7 +1257,7 @@ impl ExecutingFrame<'_> {
             Instruction::Call { argc } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
                 let args = self.collect_positional_args(argc.get(arg));
-                let nargs_val = nargs.get(arg);
+                let nargs_val = argc.get(arg);
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_adaptive_counter(cache_base);
@@ -1271,7 +1271,6 @@ impl ExecutingFrame<'_> {
                     self.specialize_call(vm, nargs_val, instr_idx, cache_base);
                 }
                 let args = self.collect_positional_args(nargs_val);
->>>>>>> upstream/main
                 self.execute_call(args, vm)
             }
             Instruction::CallKw { argc } => {
@@ -1919,7 +1918,7 @@ impl ExecutingFrame<'_> {
             // Borrow optimization not yet active; falls back to clone.
             // push_borrowed() is available but disabled until stack
             // lifetime issues at yield/exception points are resolved.
-            Instruction::LoadFastBorrow{var_num} => {
+            Instruction::LoadFastBorrow { var_num } => {
                 let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow() }[idx]
                     .clone()
@@ -2698,9 +2697,12 @@ impl ExecutingFrame<'_> {
                 } else {
                     // De-optimize
                     unsafe {
-                        self.code
-                            .instructions
-                            .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                        self.code.instructions.replace_op(
+                            instr_idx,
+                            Instruction::LoadAttr {
+                                namei: Arg::marker(),
+                            },
+                        );
                         self.code
                             .instructions
                             .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -2728,7 +2730,9 @@ impl ExecutingFrame<'_> {
                                 unsafe {
                                     self.code.instructions.replace_op(
                                         instr_idx,
-                                        Instruction::LoadAttr { idx: Arg::marker() },
+                                        Instruction::LoadAttr {
+                                            namei: Arg::marker(),
+                                        },
                                     );
                                     self.code
                                         .instructions
@@ -2753,9 +2757,12 @@ impl ExecutingFrame<'_> {
                 }
                 // De-optimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -2785,9 +2792,12 @@ impl ExecutingFrame<'_> {
                 }
                 // De-optimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -2921,7 +2931,7 @@ impl ExecutingFrame<'_> {
                         self.code.instructions.replace_op(
                             instr_idx,
                             Instruction::Call {
-                                nargs: Arg::marker(),
+                                argc: Arg::marker(),
                             },
                         );
                         self.code
@@ -2959,7 +2969,7 @@ impl ExecutingFrame<'_> {
                         self.code.instructions.replace_op(
                             instr_idx,
                             Instruction::Call {
-                                nargs: Arg::marker(),
+                                argc: Arg::marker(),
                             },
                         );
                         self.code

From ede9094f0c49d7d8cdbaae97730bd099fc21a0ff Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:02:09 +0100
Subject: [PATCH 11/22] fix more merge

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

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index a56d92e88bd..01a39bdbf25 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1256,7 +1256,6 @@ impl ExecutingFrame<'_> {
             }
             Instruction::Call { argc } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
-                let args = self.collect_positional_args(argc.get(arg));
                 let nargs_val = argc.get(arg);
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;

From 0bf36db7651fd4a3ea04261e7a22e739fed1746b Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:05:17 +0100
Subject: [PATCH 12/22] fix stdlib

---
 crates/stdlib/src/_opcode.rs | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/crates/stdlib/src/_opcode.rs b/crates/stdlib/src/_opcode.rs
index f2b447e78b6..ba1e6120fc0 100644
--- a/crates/stdlib/src/_opcode.rs
+++ b/crates/stdlib/src/_opcode.rs
@@ -82,16 +82,16 @@ mod _opcode {
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
                     Instruction::DeleteAttr { .. }
-                        | Instruction::DeleteGlobal(_)
-                        | Instruction::DeleteName(_)
+                        | Instruction::DeleteGlobal { .. }
+                        | Instruction::DeleteName { .. }
                         | Instruction::ImportFrom { .. }
                         | Instruction::ImportName { .. }
                         | Instruction::LoadAttr { .. }
-                        | Instruction::LoadGlobal(_)
-                        | Instruction::LoadName(_)
+                        | Instruction::LoadGlobal { .. }
+                        | Instruction::LoadName { .. }
                         | Instruction::StoreAttr { .. }
-                        | Instruction::StoreGlobal(_)
-                        | Instruction::StoreName(_)
+                        | Instruction::StoreGlobal { .. }
+                        | Instruction::StoreName { .. }
                 ))
             )
         }
@@ -116,10 +116,10 @@ mod _opcode {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
-                    Instruction::DeleteDeref(_)
-                        | Instruction::LoadFromDictOrDeref(_)
-                        | Instruction::LoadDeref(_)
-                        | Instruction::StoreDeref(_)
+                    Instruction::DeleteDeref { .. }
+                        | Instruction::LoadFromDictOrDeref { .. }
+                        | Instruction::LoadDeref { .. }
+                        | Instruction::StoreDeref { .. }
                 ))
             )
         }
@@ -130,10 +130,10 @@ mod _opcode {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
-                    Instruction::DeleteFast(_)
-                        | Instruction::LoadFast(_)
-                        | Instruction::LoadFastAndClear(_)
-                        | Instruction::StoreFast(_)
+                    Instruction::DeleteFast { .. }
+                        | Instruction::LoadFast { .. }
+                        | Instruction::LoadFastAndClear { .. }
+                        | Instruction::StoreFast { .. }
                         | Instruction::StoreFastLoadFast { .. }
                 ))
             )

From aad0560a5a698e23100b9f005f055240173b1883 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:12:52 +0100
Subject: [PATCH 13/22] Fix some jit

---
 crates/jit/src/instructions.rs | 45 +++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 2fa72c6e375..1ae309b84a7 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -512,13 +512,13 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize);
+            Instruction::BuildTuple { count } => {
+                let elements = self.pop_multiple(count.get(arg) as usize);
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::Call { nargs } => {
-                let nargs = nargs.get(arg);
+            Instruction::Call { argc } => {
+                let nargs = argc.get(arg);
 
                 let mut args = Vec::new();
                 for _ in 0..nargs {
@@ -562,8 +562,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::CompareOp { op, .. } => {
-                let op = op.get(arg);
+            Instruction::CompareOp { opname } => {
+                let op = opname.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -627,9 +627,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
             }
-            Instruction::LoadConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+            Instruction::LoadConst { consti } => {
+                let val = self.prepare_const(
+                    bytecode.constants[consti.get(arg) as usize].borrow_constant(),
+                )?;
                 self.stack.push(val);
                 Ok(())
             }
@@ -639,8 +640,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.push(JitValue::Int(val));
                 Ok(())
             }
-            Instruction::LoadFast(idx) | Instruction::LoadFastBorrow(idx) => {
-                let local = self.variables[idx.get(arg) as usize]
+            Instruction::LoadFast { namei } | Instruction::LoadFastBorrow { namei } => {
+                let local = self.variables[namei.get(arg) as usize]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
                 self.stack.push(JitValue::from_type_and_value(
@@ -649,9 +650,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 ));
                 Ok(())
             }
-            Instruction::LoadFastLoadFast { arg: packed }
-            | Instruction::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
+            Instruction::LoadFastLoadFast { var_num }
+            | Instruction::LoadFastBorrowLoadFastBorrow { var_nums: var_num } => {
+                let oparg = var_num.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 0xF;
                 for idx in [idx1, idx2] {
@@ -665,8 +666,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 }
                 Ok(())
             }
-            Instruction::LoadGlobal(idx) => {
-                let oparg = idx.get(arg);
+            Instruction::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
                 let name = &bytecode.names[(oparg >> 1) as usize];
 
                 if name.as_ref() != bytecode.obj_name.as_ref() {
@@ -714,7 +715,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.pop();
                 Ok(())
             }
-            Instruction::Resume { arg: _resume_arg } => {
+            Instruction::Resume { .. } => {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
@@ -722,11 +723,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            Instruction::StoreFast(idx) => {
+            Instruction::StoreFast { namei } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(idx.get(arg), val)
+                self.store_variable(namei.get(arg), val)
             }
-            Instruction::Swap { index } => {
+            Instruction::Swap { i: index } => {
                 let len = self.stack.len();
                 let i = len - 1;
                 let j = len - 1 - index.get(arg) as usize;
@@ -760,7 +761,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::UnpackSequence { size } => {
+            Instruction::UnpackSequence { count } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
 
                 let elements = match val {
@@ -768,7 +769,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => return Err(JitCompileError::NotSupported),
                 };
 
-                if elements.len() != size.get(arg) as usize {
+                if elements.len() != count.get(arg) as usize {
                     return Err(JitCompileError::NotSupported);
                 }
 

From 8af88fe9ed86dc454d1a325c6bda846bf0649eaa Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:17:44 +0100
Subject: [PATCH 14/22] Fix more jit

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

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 1ae309b84a7..5bf4057b340 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -634,14 +634,14 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.push(val);
                 Ok(())
             }
-            Instruction::LoadSmallInt { idx } => {
-                let small_int = idx.get(arg) as i64;
+            Instruction::LoadSmallInt { i } => {
+                let small_int = i.get(arg) as i64;
                 let val = self.builder.ins().iconst(types::I64, small_int);
                 self.stack.push(JitValue::Int(val));
                 Ok(())
             }
-            Instruction::LoadFast { namei } | Instruction::LoadFastBorrow { namei } => {
-                let local = self.variables[namei.get(arg) as usize]
+            Instruction::LoadFast { var_num } | Instruction::LoadFastBorrow { var_num } => {
+                let local = self.variables[var_num.get(arg) as usize]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
                 self.stack.push(JitValue::from_type_and_value(
@@ -650,9 +650,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 ));
                 Ok(())
             }
-            Instruction::LoadFastLoadFast { var_num }
-            | Instruction::LoadFastBorrowLoadFastBorrow { var_nums: var_num } => {
-                let oparg = var_num.get(arg);
+            Instruction::LoadFastLoadFast { var_nums }
+            | Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 0xF;
                 for idx in [idx1, idx2] {
@@ -723,9 +723,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            Instruction::StoreFast { namei } => {
+            Instruction::StoreFast { var_num } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(namei.get(arg), val)
+                self.store_variable(var_num.get(arg), val)
             }
             Instruction::Swap { i: index } => {
                 let len = self.stack.len();

From 358d466b9becb16a076854dbe6e6c7d476da7bad Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:23:10 +0100
Subject: [PATCH 15/22] Fix some jit tests

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

diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 79b47c1bb16..cd7937f45ea 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -76,17 +76,17 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
         let (instruction, arg) = op_arg_state.get(word);
 
         match instruction {
-            Instruction::LoadConst { idx } => {
-                stack.push((true, idx.get(arg) as usize));
+            Instruction::LoadConst { consti } => {
+                stack.push((true, consti.get(arg) as usize));
             }
-            Instruction::LoadName(idx) => {
-                stack.push((false, idx.get(arg) as usize));
+            Instruction::LoadName { namei } => {
+                stack.push((false, namei.get(arg) as usize));
             }
-            Instruction::LoadGlobal(idx) => {
-                stack.push((false, (idx.get(arg) >> 1) as usize));
+            Instruction::LoadGlobal { namei } => {
+                stack.push((false, (namei.get(arg) >> 1) as usize));
             }
-            Instruction::BuildMap { size, .. } => {
-                let count = size.get(arg) as usize;
+            Instruction::BuildMap { count } => {
+                let count = count.get(arg) as usize;
                 // Stack has key-value pairs in order: k1, v1, k2, v2, ...
                 // So we need count * 2 items from the stack
                 let start = stack.len().saturating_sub(count * 2);
@@ -139,7 +139,7 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
                 return annotations;
             }
             Instruction::Resume { .. }
-            | Instruction::LoadFast(_)
+            | Instruction::LoadFast { .. }
             | Instruction::CompareOp { .. }
             | Instruction::ExtendedArg
             | Instruction::Cache
@@ -192,13 +192,13 @@ impl StackMachine {
             Instruction::Resume { .. } | Instruction::Cache | Instruction::NotTaken => {
                 // No-op for JIT tests
             }
-            Instruction::LoadConst { idx } => {
-                let idx = idx.get(arg);
+            Instruction::LoadConst { consti } => {
+                let idx = consti.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
-            Instruction::LoadName(idx) => self
+            Instruction::LoadName { namei } => self
                 .stack
-                .push(StackValue::String(names[idx.get(arg) as usize].clone())),
+                .push(StackValue::String(names[namei.get(arg) as usize].clone())),
             Instruction::StoreName(idx) => {
                 let idx = idx.get(arg);
                 self.locals
@@ -209,9 +209,9 @@ impl StackMachine {
                 self.stack.pop().unwrap();
                 self.stack.pop().unwrap();
             }
-            Instruction::BuildMap { size, .. } => {
+            Instruction::BuildMap { count } => {
                 let mut map = HashMap::new();
-                for _ in 0..size.get(arg) {
+                for _ in 0..count.get(arg) {
                     let value = self.stack.pop().unwrap();
                     let name = if let Some(StackValue::String(name)) = self.stack.pop() {
                         Wtf8Buf::from(name)
@@ -234,7 +234,7 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
-            Instruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute { flag } => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
                     func
@@ -243,7 +243,7 @@ impl StackMachine {
                 };
                 let attr_value = self.stack.pop().expect("Expected attribute value on stack");
 
-                let flags = attr.get(arg);
+                let flags = flag.get(arg);
 
                 // Handle ANNOTATE flag (PEP 649 style - Python 3.14+)
                 // The attr_value is a function that returns annotations when called

From cf22b78217653f5bf3cf03c18b2e490f36ac84ed Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:25:31 +0100
Subject: [PATCH 16/22] More jit fixes

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

diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index cd7937f45ea..095bb87d7be 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -199,8 +199,8 @@ impl StackMachine {
             Instruction::LoadName { namei } => self
                 .stack
                 .push(StackValue::String(names[namei.get(arg) as usize].clone())),
-            Instruction::StoreName(idx) => {
-                let idx = idx.get(arg);
+            Instruction::StoreName { namei } => {
+                let idx = namei.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }

From 64a3ef8300a2ccce7daa84b168028386174ecbb6 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:32:14 +0100
Subject: [PATCH 17/22] Make sure no instruction is emitted using `Foo(val)`

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

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 93ff35f8cbe..6d3f807ae12 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -312,7 +312,7 @@ macro_rules! emit {
 
     // Tuple variant (e.g., Foo::B(42))
     ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
-        $c.emit_arg($arg_val, $enum::$op)
+        panic!("No inatruction should be defined as `Instruction::Foo(value)` use `Instruction::Foo { x: value }` instead")
     };
 
     // No-arg variant (e.g., Foo::C)

From de0a702afb1be709821461c71439e62d0b49f547 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:33:41 +0100
Subject: [PATCH 18/22] Add comment

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

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 6d3f807ae12..790416ce270 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -310,7 +310,7 @@ macro_rules! emit {
         $c.emit_arg($arg_val, |x| $enum::$op { $arg: x })
     };
 
-    // Tuple variant (e.g., Foo::B(42))
+    // Tuple variant (e.g., Foo::B(42)). Should never be reached, here for validation.
     ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
         panic!("No inatruction should be defined as `Instruction::Foo(value)` use `Instruction::Foo { x: value }` instead")
     };

From ffe71f93bda98311c013ef27000673e3d7f610a1 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 15:45:42 +0100
Subject: [PATCH 19/22] Fix typo

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

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 790416ce270..6f7d8c15236 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -312,7 +312,7 @@ macro_rules! emit {
 
     // Tuple variant (e.g., Foo::B(42)). Should never be reached, here for validation.
     ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
-        panic!("No inatruction should be defined as `Instruction::Foo(value)` use `Instruction::Foo { x: value }` instead")
+        panic!("No instruction should be defined as `Instruction::Foo(value)` use `Instruction::Foo { x: value }` instead")
     };
 
     // No-arg variant (e.g., Foo::C)

From a828ab13013543ec0d61b80823563ffd718a1702 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 2 Mar 2026 15:47:03 +0100
Subject: [PATCH 20/22] Add `consti` to known words

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

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 7681760ea65..41746996ceb 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -38,6 +38,7 @@ CODEUNIT
 CONIN
 CONOUT
 constevaluator
+consti
 CONVFUNC
 convparam
 copyslot

From 7865718eff3de5a93a51c4590f99b584ef1c0ed2 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 3 Mar 2026 13:47:39 +0100
Subject: [PATCH 21/22] Fix more

---
 crates/vm/src/frame.rs | 102 +++++++++++++++++++++++++++--------------
 1 file changed, 68 insertions(+), 34 deletions(-)

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 9a9c7b806db..957b5df729b 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -2655,7 +2655,7 @@ impl ExecutingFrame<'_> {
                             .write_cache_u16(cache_base, counter - 1);
                     }
                 } else {
-                    self.specialize_store_attr(vm, idx.get(arg), instr_idx, cache_base);
+                    self.specialize_store_attr(vm, namei.get(arg), instr_idx, cache_base);
                 }
                 self.store_attr(vm, namei.get(arg))
             }
@@ -2903,7 +2903,7 @@ impl ExecutingFrame<'_> {
                     self.code.instructions.replace_op(
                         instr_idx,
                         Instruction::Send {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         },
                     );
                     self.code
@@ -3154,9 +3154,12 @@ impl ExecutingFrame<'_> {
                 }
                 // Deoptimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3185,9 +3188,12 @@ impl ExecutingFrame<'_> {
                     return Ok(None);
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3230,9 +3236,12 @@ impl ExecutingFrame<'_> {
                     return Ok(None);
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3263,9 +3272,12 @@ impl ExecutingFrame<'_> {
                     return Ok(None);
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3296,9 +3308,12 @@ impl ExecutingFrame<'_> {
                     // Slot is None → AttributeError (fall through to slow path)
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3328,9 +3343,12 @@ impl ExecutingFrame<'_> {
                     }
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3356,9 +3374,12 @@ impl ExecutingFrame<'_> {
                 }
                 // Deoptimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::StoreAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::StoreAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3385,9 +3406,12 @@ impl ExecutingFrame<'_> {
                 // Deoptimize
                 let attr_idx = u32::from(arg);
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::StoreAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::StoreAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -4344,7 +4368,9 @@ impl ExecutingFrame<'_> {
                 unsafe {
                     self.code.instructions.replace_op(
                         self.lasti() as usize - 1,
-                        Instruction::LoadSuperAttr { arg: Arg::marker() },
+                        Instruction::LoadSuperAttr {
+                            namei: Arg::marker(),
+                        },
                     );
                     let cache_base = self.lasti() as usize;
                     self.code
@@ -4422,7 +4448,9 @@ impl ExecutingFrame<'_> {
                 unsafe {
                     self.code.instructions.replace_op(
                         self.lasti() as usize - 1,
-                        Instruction::LoadSuperAttr { arg: Arg::marker() },
+                        Instruction::LoadSuperAttr {
+                            namei: Arg::marker(),
+                        },
                     );
                     let cache_base = self.lasti() as usize;
                     self.code
@@ -7021,9 +7049,12 @@ impl ExecutingFrame<'_> {
         let instr_idx = self.lasti() as usize - 1;
         let cache_base = instr_idx + 1;
         unsafe {
-            self.code
-                .instructions
-                .replace_op(instr_idx, Instruction::CompareOp { op: Arg::marker() });
+            self.code.instructions.replace_op(
+                instr_idx,
+                Instruction::CompareOp {
+                    opname: Arg::marker(),
+                },
+            );
             self.code
                 .instructions
                 .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -7221,9 +7252,12 @@ impl ExecutingFrame<'_> {
         let instr_idx = self.lasti() as usize - 1;
         let cache_base = instr_idx + 1;
         unsafe {
-            self.code
-                .instructions
-                .replace_op(instr_idx, Instruction::LoadGlobal(Arg::marker()));
+            self.code.instructions.replace_op(
+                instr_idx,
+                Instruction::LoadGlobal {
+                    namei: Arg::marker(),
+                },
+            );
             self.code
                 .instructions
                 .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);

From 0ae8b08e93a7b6d9c6c8b440bb857a29fa0ab69d Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 3 Mar 2026 13:50:36 +0100
Subject: [PATCH 22/22] Fix bad merge

---
 crates/vm/src/frame.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 957b5df729b..fc4cefc147c 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1413,8 +1413,21 @@ impl ExecutingFrame<'_> {
                 self.execute_call(args, vm)
             }
             Instruction::CallKw { argc } => {
+                let nargs = argc.get(arg);
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let counter = self.code.instructions.read_cache_u16(cache_base);
+                if counter > 0 {
+                    unsafe {
+                        self.code
+                            .instructions
+                            .write_cache_u16(cache_base, counter - 1);
+                    }
+                } else {
+                    self.specialize_call_kw(vm, nargs, instr_idx, cache_base);
+                }
                 // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
-                let args = self.collect_keyword_args(argc.get(arg));
+                let args = self.collect_keyword_args(nargs);
                 self.execute_call(args, vm)
             }
             Instruction::CallFunctionEx => {