From 423fc3db24041722974c017c640f304a18ef04b3 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 11:17:44 +0200
Subject: [PATCH 01/15] Sort `Instruction` enum. Variants hold 1 element

---
 crates/compiler-core/src/bytecode.rs | 351 +++++++++------------------
 1 file changed, 117 insertions(+), 234 deletions(-)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 144054860e..a391e09451 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -549,263 +549,146 @@ pub type NameIdx = u32;
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum Instruction {
-    Nop,
-    /// Importing by name
-    ImportName {
-        idx: Arg<NameIdx>,
-    },
-    /// Importing without name
-    ImportNameless,
-    /// from ... import ...
-    ImportFrom {
-        idx: Arg<NameIdx>,
-    },
-    LoadFast(Arg<NameIdx>),
-    LoadNameAny(Arg<NameIdx>),
-    LoadGlobal(Arg<NameIdx>),
-    LoadDeref(Arg<NameIdx>),
-    LoadClassDeref(Arg<NameIdx>),
-    StoreFast(Arg<NameIdx>),
-    StoreLocal(Arg<NameIdx>),
-    StoreGlobal(Arg<NameIdx>),
-    StoreDeref(Arg<NameIdx>),
+    BeforeAsyncWith,
+    BinaryOperation(Arg<BinaryOperator>),
+    BinaryOperationInplace(Arg<BinaryOperator>),
+    BinarySubscript,
+    Break(Arg<Label>),
+    BuildList(Arg<u32>),
+    BuildListFromTuples(Arg<u32>),
+    BuildMap(Arg<u32>),
+    BuildMapForCall(Arg<u32>),
+    BuildSet(Arg<u32>),
+    BuildSetFromTuples(Arg<u32>),
+    /// When holds `true` it will build a slice with a third step argument.
+    BuildSlice(Arg<bool>),
+    BuildString(Arg<u32>),
+    BuildTuple(Arg<u32>),
+    BuildTupleFromIter,
+    BuildTupleFromTuples(Arg<u32>),
+    CallFunctionEx(Arg<bool>),
+    CallFunctionKeyword(Arg<u32>),
+    CallFunctionPositional(Arg<u32>),
+    CallIntrinsic1(Arg<IntrinsicFunction1>),
+    CallIntrinsic2(Arg<IntrinsicFunction2>),
+    CallMethodEx(Arg<bool>),
+    CallMethodKeyword(Arg<u32>),
+    CallMethodPositional(Arg<u32>),
+    CompareOperation(Arg<ComparisonOperator>),
+    /// Performs `in` comparison, or `not in` if `invert` is 1.
+    ContainsOp(Arg<Invert>),
+    Continue(Arg<Label>),
+    CopyItem(Arg<u32>),
+    DeleteAttr(Arg<NameIdx>),
+    DeleteDeref(Arg<NameIdx>),
     DeleteFast(Arg<NameIdx>),
-    DeleteLocal(Arg<NameIdx>),
     DeleteGlobal(Arg<NameIdx>),
-    DeleteDeref(Arg<NameIdx>),
-    LoadClosure(Arg<NameIdx>),
-    Subscript,
-    StoreSubscript,
+    DeleteLocal(Arg<NameIdx>),
     DeleteSubscript,
-    /// Performs `is` comparison, or `is not` if `invert` is 1.
-    IsOp(Arg<Invert>),
-    /// Performs `in` comparison, or `not in` if `invert` is 1.
-    ContainsOp(Arg<Invert>),
-    StoreAttr {
-        idx: Arg<NameIdx>,
-    },
-    DeleteAttr {
-        idx: Arg<NameIdx>,
-    },
-    LoadConst {
-        /// index into constants vec
-        idx: Arg<u32>,
-    },
-    UnaryOperation {
-        op: Arg<UnaryOperator>,
-    },
-    BinaryOperation {
-        op: Arg<BinaryOperator>,
-    },
-    BinaryOperationInplace {
-        op: Arg<BinaryOperator>,
-    },
-    BinarySubscript,
-    LoadAttr {
-        idx: Arg<NameIdx>,
-    },
-    CompareOperation {
-        op: Arg<ComparisonOperator>,
-    },
-    CopyItem {
-        index: Arg<u32>,
-    },
-    Pop,
-    Swap {
-        index: Arg<u32>,
-    },
-    ToBool,
+    DictUpdate(Arg<u32>),
+    EndAsyncFor,
+    /// Marker bytecode for the end of a finally sequence.
+    /// When this bytecode is executed, the eval loop does one of those things:
+    /// - Continue at a certain bytecode position
+    /// - Propagate the exception
+    /// - Return from a function
+    /// - Do nothing at all, just continue
+    EndFinally,
+    /// Enter a finally block, without returning, excepting, just because we are there.
+    EnterFinally,
+    ExtendedArg,
+    ForIter(Arg<Label>),
+    FormatValue(Arg<ConversionFlag>),
+    GetAIter,
+    GetANext,
+    GetAwaitable,
     GetIter,
     GetLen,
-    CallIntrinsic1 {
-        func: Arg<IntrinsicFunction1>,
-    },
-    CallIntrinsic2 {
-        func: Arg<IntrinsicFunction2>,
-    },
-    Continue {
-        target: Arg<Label>,
-    },
-    Break {
-        target: Arg<Label>,
-    },
+    /// from ... import ...
+    ImportFrom(Arg<NameIdx>),
+    /// Importing by name
+    ImportName(Arg<NameIdx>),
+    /// Importing without name
+    ImportNameless,
+    /// Performs `is` comparison, or `is not` if `invert` is 1.
+    IsOp(Arg<Invert>),
+    Jump(Arg<Label>),
+    /// Peek at the top of the stack, and jump if this value is false.
+    /// Otherwise, pop top of stack.
+    JumpIfFalseOrPop(Arg<Label>),
     /// Performs exception matching for except.
     /// Tests whether the STACK[-2] is an exception matching STACK[-1].
     /// Pops STACK[-1] and pushes the boolean result of the test.
     JumpIfNotExcMatch(Arg<Label>),
-    Jump {
-        target: Arg<Label>,
-    },
-    /// Pop the top of the stack, and jump if this value is true.
-    PopJumpIfTrue {
-        target: Arg<Label>,
-    },
-    /// Pop the top of the stack, and jump if this value is false.
-    PopJumpIfFalse {
-        target: Arg<Label>,
-    },
     /// Peek at the top of the stack, and jump if this value is true.
     /// Otherwise, pop top of stack.
-    JumpIfTrueOrPop {
-        target: Arg<Label>,
-    },
-    /// Peek at the top of the stack, and jump if this value is false.
-    /// Otherwise, pop top of stack.
-    JumpIfFalseOrPop {
-        target: Arg<Label>,
-    },
+    JumpIfTrueOrPop(Arg<Label>),
+    ListAppend(Arg<u32>),
+    LoadAttr(Arg<NameIdx>),
+    LoadBuildClass,
+    LoadClassDeref(Arg<NameIdx>),
+    LoadClosure(Arg<NameIdx>),
+    /// Holds an index into constants vec.
+    LoadConst(Arg<u32>),
+    LoadDeref(Arg<NameIdx>),
+    LoadFast(Arg<NameIdx>),
+    LoadGlobal(Arg<NameIdx>),
+    LoadMethod(Arg<NameIdx>),
+    LoadNameAny(Arg<NameIdx>),
     MakeFunction,
-    SetFunctionAttribute {
-        attr: Arg<MakeFunctionFlags>,
-    },
-    CallFunctionPositional {
-        nargs: Arg<u32>,
-    },
-    CallFunctionKeyword {
-        nargs: Arg<u32>,
-    },
-    CallFunctionEx {
-        has_kwargs: Arg<bool>,
-    },
-    LoadMethod {
-        idx: Arg<NameIdx>,
-    },
-    CallMethodPositional {
-        nargs: Arg<u32>,
-    },
-    CallMethodKeyword {
-        nargs: Arg<u32>,
-    },
-    CallMethodEx {
-        has_kwargs: Arg<bool>,
-    },
-    ForIter {
-        target: Arg<Label>,
-    },
-    ReturnValue,
-    ReturnConst {
-        idx: Arg<u32>,
-    },
-    YieldValue,
-    YieldFrom,
-
+    MapAdd(Arg<u32>),
+    MatchClass(Arg<u32>),
+    MatchKeys,
+    MatchMapping,
+    MatchSequence,
+    Nop,
+    Pop,
+    PopBlock,
+    PopException,
+    /// Pop the top of the stack, and jump if this value is false.
+    PopJumpIfFalse(Arg<Label>),
+    /// Pop the top of the stack, and jump if this value is true.
+    PopJumpIfTrue(Arg<Label>),
+    PrintExpr,
+    Raise(Arg<RaiseKind>),
     /// Resume execution (e.g., at function start, after yield, etc.)
-    Resume {
-        arg: Arg<u32>,
-    },
-
+    Resume(Arg<u32>),
+    ReturnConst(Arg<u32>),
+    ReturnValue,
+    Reverse(Arg<u32>),
+    SetAdd(Arg<u32>),
+    SetFunctionAttribute(Arg<MakeFunctionFlags>),
     SetupAnnotation,
-    SetupLoop,
-
+    SetupAsyncWith(Arg<Label>),
+    SetupExcept(Arg<Label>),
     /// Setup a finally handler, which will be called whenever one of this events occurs:
     /// - the block is popped
     /// - the function returns
     /// - an exception is returned
-    SetupFinally {
-        handler: Arg<Label>,
-    },
-
-    /// Enter a finally block, without returning, excepting, just because we are there.
-    EnterFinally,
-
-    /// Marker bytecode for the end of a finally sequence.
-    /// When this bytecode is executed, the eval loop does one of those things:
-    /// - Continue at a certain bytecode position
-    /// - Propagate the exception
-    /// - Return from a function
-    /// - Do nothing at all, just continue
-    EndFinally,
-
-    SetupExcept {
-        handler: Arg<Label>,
-    },
-    SetupWith {
-        end: Arg<Label>,
-    },
-    WithCleanupStart,
+    SetupFinally(Arg<Label>),
+    SetupLoop,
+    SetupWith(Arg<Label>),
+    StoreAttr(Arg<NameIdx>),
+    StoreDeref(Arg<NameIdx>),
+    StoreFast(Arg<NameIdx>),
+    StoreGlobal(Arg<NameIdx>),
+    StoreLocal(Arg<NameIdx>),
+    StoreSubscript,
+    Subscript,
+    Swap(Arg<u32>),
+    ToBool,
+    UnaryOperation(Arg<UnaryOperator>),
+    UnpackEx(Arg<UnpackExArgs>),
+    UnpackSequence(Arg<u32>),
     WithCleanupFinish,
-    PopBlock,
-    Raise {
-        kind: Arg<RaiseKind>,
-    },
-    BuildString {
-        size: Arg<u32>,
-    },
-    BuildTuple {
-        size: Arg<u32>,
-    },
-    BuildTupleFromTuples {
-        size: Arg<u32>,
-    },
-    BuildTupleFromIter,
-    BuildList {
-        size: Arg<u32>,
-    },
-    BuildListFromTuples {
-        size: Arg<u32>,
-    },
-    BuildSet {
-        size: Arg<u32>,
-    },
-    BuildSetFromTuples {
-        size: Arg<u32>,
-    },
-    BuildMap {
-        size: Arg<u32>,
-    },
-    BuildMapForCall {
-        size: Arg<u32>,
-    },
-    DictUpdate {
-        index: Arg<u32>,
-    },
-    BuildSlice {
-        /// whether build a slice with a third step argument
-        step: Arg<bool>,
-    },
-    ListAppend {
-        i: Arg<u32>,
-    },
-    SetAdd {
-        i: Arg<u32>,
-    },
-    MapAdd {
-        i: Arg<u32>,
-    },
-
-    PrintExpr,
-    LoadBuildClass,
-    UnpackSequence {
-        size: Arg<u32>,
-    },
-    UnpackEx {
-        args: Arg<UnpackExArgs>,
-    },
-    FormatValue {
-        conversion: Arg<ConversionFlag>,
-    },
-    PopException,
-    Reverse {
-        amount: Arg<u32>,
-    },
-    GetAwaitable,
-    BeforeAsyncWith,
-    SetupAsyncWith {
-        end: Arg<Label>,
-    },
-    GetAIter,
-    GetANext,
-    EndAsyncFor,
-    MatchMapping,
-    MatchSequence,
-    MatchKeys,
-    MatchClass(Arg<u32>),
-    ExtendedArg,
+    WithCleanupStart,
+    YieldFrom,
+    YieldValue,
     // If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated
 }
 
 // This must be kept up to date to avoid marshaling errors
-const LAST_INSTRUCTION: Instruction = Instruction::ExtendedArg;
+const LAST_INSTRUCTION: Instruction = Instruction::YieldValue;
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
 

From ef456a7338441c34e3fbf8e762bde066c5c5c72f Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 11:27:49 +0200
Subject: [PATCH 02/15] Fix `fmt_dis`

---
 crates/compiler-core/src/bytecode.rs | 111 +++++++++++++--------------
 1 file changed, 55 insertions(+), 56 deletions(-)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index a391e09451..78fbb65143 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -1530,9 +1530,9 @@ impl Instruction {
 
         match self {
             Nop => w!(Nop),
-            ImportName { idx } => w!(ImportName, name = idx),
+            ImportName(idx) => w!(ImportName, name = idx),
             ImportNameless => w!(ImportNameless),
-            ImportFrom { idx } => w!(ImportFrom, name = idx),
+            ImportFrom(idx) => w!(ImportFrom, name = idx),
             LoadFast(idx) => w!(LoadFast, varname = idx),
             LoadNameAny(idx) => w!(LoadNameAny, name = idx),
             LoadGlobal(idx) => w!(LoadGlobal, name = idx),
@@ -1553,81 +1553,80 @@ impl Instruction {
             Subscript => w!(Subscript),
             StoreSubscript => w!(StoreSubscript),
             DeleteSubscript => w!(DeleteSubscript),
-            StoreAttr { idx } => w!(StoreAttr, name = idx),
-            DeleteAttr { idx } => w!(DeleteAttr, name = idx),
-            LoadConst { idx } => fmt_const("LoadConst", arg, f, idx),
-            UnaryOperation { op } => w!(UnaryOperation, ?op),
-            BinaryOperation { op } => w!(BinaryOperation, ?op),
-            BinaryOperationInplace { op } => w!(BinaryOperationInplace, ?op),
+            StoreAttr(idx) => w!(StoreAttr, name = idx),
+            DeleteAttr(idx) => w!(DeleteAttr, name = idx),
+            LoadConst(idx) => fmt_const("LoadConst", arg, f, idx),
+            UnaryOperation(op) => w!(UnaryOperation, ?op),
+            BinaryOperation(op) => w!(BinaryOperation, ?op),
+            BinaryOperationInplace(op) => w!(BinaryOperationInplace, ?op),
             BinarySubscript => w!(BinarySubscript),
-            LoadAttr { idx } => w!(LoadAttr, name = idx),
-            CompareOperation { op } => w!(CompareOperation, ?op),
-            CopyItem { index } => w!(CopyItem, index),
+            LoadAttr(idx) => w!(LoadAttr, name = idx),
+            CompareOperation(op) => w!(CompareOperation, ?op),
+            CopyItem(index) => w!(CopyItem, index),
             Pop => w!(Pop),
-            Swap { index } => w!(Swap, index),
+            Swap(index) => w!(Swap, index),
             ToBool => w!(ToBool),
             GetIter => w!(GetIter),
-            // GET_LEN
             GetLen => w!(GetLen),
-            CallIntrinsic1 { func } => w!(CallIntrinsic1, ?func),
-            CallIntrinsic2 { func } => w!(CallIntrinsic2, ?func),
-            Continue { target } => w!(Continue, target),
-            Break { target } => w!(Break, target),
-            Jump { target } => w!(Jump, target),
-            PopJumpIfTrue { target } => w!(PopJumpIfTrue, target),
-            PopJumpIfFalse { target } => w!(PopJumpIfFalse, target),
-            JumpIfTrueOrPop { target } => w!(JumpIfTrueOrPop, target),
-            JumpIfFalseOrPop { target } => w!(JumpIfFalseOrPop, target),
+            CallIntrinsic1(func) => w!(CallIntrinsic1, ?func),
+            CallIntrinsic2(func) => w!(CallIntrinsic2, ?func),
+            Continue(target) => w!(Continue, target),
+            Break(target) => w!(Break, target),
+            Jump(target) => w!(Jump, target),
+            PopJumpIfTrue(target) => w!(PopJumpIfTrue, target),
+            PopJumpIfFalse(target) => w!(PopJumpIfFalse, target),
+            JumpIfTrueOrPop(target) => w!(JumpIfTrueOrPop, target),
+            JumpIfFalseOrPop(target) => w!(JumpIfFalseOrPop, target),
             MakeFunction => w!(MakeFunction),
-            SetFunctionAttribute { attr } => w!(SetFunctionAttribute, ?attr),
-            CallFunctionPositional { nargs } => w!(CallFunctionPositional, nargs),
-            CallFunctionKeyword { nargs } => w!(CallFunctionKeyword, nargs),
-            CallFunctionEx { has_kwargs } => w!(CallFunctionEx, has_kwargs),
-            LoadMethod { idx } => w!(LoadMethod, name = idx),
-            CallMethodPositional { nargs } => w!(CallMethodPositional, nargs),
-            CallMethodKeyword { nargs } => w!(CallMethodKeyword, nargs),
-            CallMethodEx { has_kwargs } => w!(CallMethodEx, has_kwargs),
-            ForIter { target } => w!(ForIter, target),
+            SetFunctionAttribute(attr) => w!(SetFunctionAttribute, ?attr),
+            CallFunctionPositional(nargs) => w!(CallFunctionPositional, nargs),
+            CallFunctionKeyword(nargs) => w!(CallFunctionKeyword, nargs),
+            CallFunctionEx(has_kwargs) => w!(CallFunctionEx, has_kwargs),
+            LoadMethod(idx) => w!(LoadMethod, name = idx),
+            CallMethodPositional(nargs) => w!(CallMethodPositional, nargs),
+            CallMethodKeyword(nargs) => w!(CallMethodKeyword, nargs),
+            CallMethodEx(has_kwargs) => w!(CallMethodEx, has_kwargs),
+            ForIter(target) => w!(ForIter, target),
             ReturnValue => w!(ReturnValue),
-            ReturnConst { idx } => fmt_const("ReturnConst", arg, f, idx),
-            Resume { arg } => w!(Resume, arg),
+            ReturnConst(idx) => fmt_const("ReturnConst", arg, f, idx),
+            Resume(arg) => w!(Resume, arg),
             YieldValue => w!(YieldValue),
             YieldFrom => w!(YieldFrom),
             SetupAnnotation => w!(SetupAnnotation),
             SetupLoop => w!(SetupLoop),
-            SetupExcept { handler } => w!(SetupExcept, handler),
-            SetupFinally { handler } => w!(SetupFinally, handler),
+            SetupExcept(handler) => w!(SetupExcept, handler),
+            SetupFinally(handler) => w!(SetupFinally, handler),
             EnterFinally => w!(EnterFinally),
             EndFinally => w!(EndFinally),
-            SetupWith { end } => w!(SetupWith, end),
+            SetupWith(end) => w!(SetupWith, end),
             WithCleanupStart => w!(WithCleanupStart),
             WithCleanupFinish => w!(WithCleanupFinish),
             BeforeAsyncWith => w!(BeforeAsyncWith),
-            SetupAsyncWith { end } => w!(SetupAsyncWith, end),
+            SetupAsyncWith(end) => w!(SetupAsyncWith, end),
             PopBlock => w!(PopBlock),
-            Raise { kind } => w!(Raise, ?kind),
-            BuildString { size } => w!(BuildString, size),
-            BuildTuple { size } => w!(BuildTuple, size),
-            BuildTupleFromTuples { size } => w!(BuildTupleFromTuples, size),
+            Raise(kind) => w!(Raise, ?kind),
+            BuildString(size) => w!(BuildString, size),
+            BuildTuple(size) => w!(BuildTuple, size),
+            BuildTupleFromTuples(size) => w!(BuildTupleFromTuples, size),
             BuildTupleFromIter => w!(BuildTupleFromIter),
-            BuildList { size } => w!(BuildList, size),
-            BuildListFromTuples { size } => w!(BuildListFromTuples, size),
-            BuildSet { size } => w!(BuildSet, size),
-            BuildSetFromTuples { size } => w!(BuildSetFromTuples, size),
-            BuildMap { size } => w!(BuildMap, size),
-            BuildMapForCall { size } => w!(BuildMapForCall, size),
-            DictUpdate { index } => w!(DictUpdate, index),
-            BuildSlice { step } => w!(BuildSlice, step),
-            ListAppend { i } => w!(ListAppend, i),
-            SetAdd { i } => w!(SetAdd, i),
-            MapAdd { i } => w!(MapAdd, i),
+            BuildList(size) => w!(BuildList, size),
+            BuildListFromTuples(size) => w!(BuildListFromTuples, size),
+            BuildSet(size) => w!(BuildSet, size),
+            BuildSetFromTuples(size) => w!(BuildSetFromTuples, size),
+            BuildMap(size) => w!(BuildMap, size),
+            BuildMapForCall(size) => w!(BuildMapForCall, size),
+            DictUpdate(index) => w!(DictUpdate, index),
+            BuildSlice(step) => w!(BuildSlice, step),
+            ListAppend(i) => w!(ListAppend, i),
+            SetAdd(i) => w!(SetAdd, i),
+            MapAdd(i) => w!(MapAdd, i),
             PrintExpr => w!(PrintExpr),
             LoadBuildClass => w!(LoadBuildClass),
-            UnpackSequence { size } => w!(UnpackSequence, size),
-            UnpackEx { args } => w!(UnpackEx, args),
-            FormatValue { conversion } => w!(FormatValue, ?conversion),
+            UnpackSequence(size) => w!(UnpackSequence, size),
+            UnpackEx(args) => w!(UnpackEx, args),
+            FormatValue(conversion) => w!(FormatValue, ?conversion),
             PopException => w!(PopException),
-            Reverse { amount } => w!(Reverse, amount),
+            Reverse(amount) => w!(Reverse, amount),
             GetAwaitable => w!(GetAwaitable),
             GetAIter => w!(GetAIter),
             GetANext => w!(GetANext),

From e2a1dfa3a27dd5410d096562a706d04d51b7eb12 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 11:48:41 +0200
Subject: [PATCH 03/15] Fix `stack_effect`

---
 crates/compiler-core/src/bytecode.rs | 372 +++++++++++++--------------
 1 file changed, 186 insertions(+), 186 deletions(-)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 78fbb65143..ef3fe8b20b 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -1341,124 +1341,124 @@ impl Instruction {
     ///
     pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
-            Nop => 0,
-            ImportName { .. } | ImportNameless => -1,
-            ImportFrom { .. } => 1,
-            LoadFast(_) | LoadNameAny(_) | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) => 1,
-            StoreFast(_) | StoreLocal(_) | StoreGlobal(_) | StoreDeref(_) => -1,
+            BeforeAsyncWith => 1,
+            BinaryOperation(_) | BinaryOperationInplace(_) | CompareOperation(_) => -1,
+            BinarySubscript => -1,
+            Break(_) => 0,
+            BuildList(size)
+            | BuildListFromTuples(size)
+            | BuildSet(size)
+            | BuildSetFromTuples(size)
+            | BuildString(size)
+            | BuildTuple(size)
+            | BuildTupleFromTuples(size) => -(size.get(arg) as i32) + 1,
+            BuildMap(size) => {
+                let nargs = size.get(arg) * 2;
+                -(nargs as i32) + 1
+            }
+            BuildMapForCall(size) => {
+                let nargs = size.get(arg);
+                -(nargs as i32) + 1
+            }
+            BuildSlice(step) => -2 - (step.get(arg) as i32) + 1,
+            BuildTupleFromIter => 0,
+            CallFunctionEx(has_kwargs) => -1 - (has_kwargs.get(arg) as i32) - 1 + 1,
+            CallFunctionKeyword(nargs) => -1 - (nargs.get(arg) as i32) - 1 + 1,
+            CallFunctionPositional(nargs) => -(nargs.get(arg) as i32) - 1 + 1,
+            CallIntrinsic1(_) => 0,  // Takes 1, pushes 1
+            CallIntrinsic2(_) => -1, // Takes 2, pushes 1
+            CallMethodEx(has_kwargs) => -1 - (has_kwargs.get(arg) as i32) - 3 + 1,
+            CallMethodKeyword(nargs) => -1 - (nargs.get(arg) as i32) - 3 + 1,
+            CallMethodPositional(nargs) => -(nargs.get(arg) as i32) - 3 + 1,
+            ContainsOp(_) | IsOp(_) => -1,
+            Continue(_) => 0,
+            CopyItem(_) => 1,
+            DeleteAttr(_) => -1,
             DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
-            LoadClosure(_) => 1,
-            Subscript => -1,
-            StoreSubscript => -3,
             DeleteSubscript => -2,
-            LoadAttr { .. } => 0,
-            StoreAttr { .. } => -2,
-            DeleteAttr { .. } => -1,
-            LoadConst { .. } => 1,
-            UnaryOperation { .. } => 0,
-            BinaryOperation { .. } | BinaryOperationInplace { .. } | CompareOperation { .. } => -1,
-            BinarySubscript => -1,
-            CopyItem { .. } => 1,
-            Pop => -1,
-            Swap { .. } => 0,
-            ToBool => 0,
-            GetIter => 0,
-            GetLen => 1,
-            CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
-            CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
-            Continue { .. } => 0,
-            Break { .. } => 0,
-            Jump { .. } => 0,
-            PopJumpIfTrue { .. } | PopJumpIfFalse { .. } => -1,
-            JumpIfTrueOrPop { .. } | JumpIfFalseOrPop { .. } => {
+            DictUpdate(_) => -1,
+            EndAsyncFor => -2,
+            EndFinally | EnterFinally | SetupAnnotation | SetupFinally(_) | SetupLoop => 0,
+            ExtendedArg => 0,
+            ForIter(_) => {
                 if jump {
-                    0
-                } else {
                     -1
+                } else {
+                    1
                 }
             }
+            FormatValue(_) => -1,
+            GetAIter => 0,
+            GetANext => 1,
+            GetAwaitable => 0,
+            GetIter => 0,
+            GetLen => 1,
+            ImportFrom(_) => 1,
+            ImportName(_) | ImportNameless => -1,
+            Jump(_) => 0,
+            JumpIfNotExcMatch(_) => -2,
+            ListAppend(_) | SetAdd(_) => -1,
+            LoadAttr(_) => 0,
+            LoadBuildClass => 1,
+            LoadClassDeref(_) | LoadDeref(_) | LoadFast(_) | LoadGlobal(_) | LoadNameAny(_) => 1,
+            LoadClosure(_) => 1,
+            LoadConst(_) => 1,
+            LoadMethod(_) => -1 + 3,
             MakeFunction => {
                 // CPython 3.13 style: MakeFunction only pops code object
                 -1 + 1 // pop code, push function
             }
-            SetFunctionAttribute { .. } => {
+            MapAdd(_) => -2,
+            MatchClass(_) => -2,
+            MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
+            MatchMapping | MatchSequence => 1, // Push bool result
+            Nop => 0,
+            Pop => -1,
+            PopBlock => 0,
+            PopException => 0,
+            PopJumpIfFalse(_) | PopJumpIfTrue(_) => -1,
+            PrintExpr => -1,
+            Raise(kind) => -(kind.get(arg) as u8 as i32),
+            Resume(_) => 0,
+            ReturnConst(_) => 0,
+            ReturnValue => -1,
+            Reverse(_) => 0,
+            SetFunctionAttribute(_) => {
                 // pops attribute value and function, pushes function back
                 -2 + 1
             }
-            CallFunctionPositional { nargs } => -(nargs.get(arg) as i32) - 1 + 1,
-            CallMethodPositional { nargs } => -(nargs.get(arg) as i32) - 3 + 1,
-            CallFunctionKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 1 + 1,
-            CallMethodKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 3 + 1,
-            CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 1 + 1,
-            CallMethodEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 3 + 1,
-            LoadMethod { .. } => -1 + 3,
-            ForIter { .. } => {
+            SetupAsyncWith(_) => {
                 if jump {
                     -1
                 } else {
-                    1
+                    0
                 }
             }
-            IsOp(_) | ContainsOp(_) => -1,
-            JumpIfNotExcMatch(_) => -2,
-            ReturnValue => -1,
-            ReturnConst { .. } => 0,
-            Resume { .. } => 0,
-            YieldValue => 0,
-            YieldFrom => -1,
-            SetupAnnotation | SetupLoop | SetupFinally { .. } | EnterFinally | EndFinally => 0,
-            SetupExcept { .. } => jump as i32,
-            SetupWith { .. } => (!jump) as i32,
-            WithCleanupStart => 0,
+            SetupExcept(_) => jump as i32,
+            SetupWith(_) => (!jump) as i32,
+            StoreAttr(_) => -2,
+            StoreDeref(_) | StoreFast(_) | StoreGlobal(_) | StoreLocal(_) => -1,
+            StoreSubscript => -3,
+            Subscript => -1,
+            Swap(_) => 0,
+            ToBool => 0,
+            UnaryOperation(_) => 0,
+            UnpackSequence(size) => -1 + size.get(arg) as i32,
             WithCleanupFinish => -1,
-            PopBlock => 0,
-            Raise { kind } => -(kind.get(arg) as u8 as i32),
-            BuildString { size }
-            | BuildTuple { size, .. }
-            | BuildTupleFromTuples { size, .. }
-            | BuildList { size, .. }
-            | BuildListFromTuples { size, .. }
-            | BuildSet { size, .. }
-            | BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
-            BuildTupleFromIter => 0,
-            BuildMap { size } => {
-                let nargs = size.get(arg) * 2;
-                -(nargs as i32) + 1
-            }
-            BuildMapForCall { size } => {
-                let nargs = size.get(arg);
-                -(nargs as i32) + 1
-            }
-            DictUpdate { .. } => -1,
-            BuildSlice { step } => -2 - (step.get(arg) as i32) + 1,
-            ListAppend { .. } | SetAdd { .. } => -1,
-            MapAdd { .. } => -2,
-            PrintExpr => -1,
-            LoadBuildClass => 1,
-            UnpackSequence { size } => -1 + size.get(arg) as i32,
-            UnpackEx { args } => {
-                let UnpackExArgs { before, after } = args.get(arg);
-                -1 + before as i32 + 1 + after as i32
-            }
-            FormatValue { .. } => -1,
-            PopException => 0,
-            Reverse { .. } => 0,
-            GetAwaitable => 0,
-            BeforeAsyncWith => 1,
-            SetupAsyncWith { .. } => {
+            WithCleanupStart => 0,
+            YieldFrom => -1,
+            YieldValue => 0,
+            JumpIfFalseOrPop(_) | JumpIfTrueOrPop(_) => {
                 if jump {
-                    -1
-                } else {
                     0
+                } else {
+                    -1
                 }
             }
-            GetAIter => 0,
-            GetANext => 1,
-            EndAsyncFor => -2,
-            MatchMapping | MatchSequence => 1, // Push bool result
-            MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
-            MatchClass(_) => -2,
-            ExtendedArg => 0,
+            UnpackEx(args) => {
+                let UnpackExArgs { before, after } = args.get(arg);
+                -1 + before as i32 + 1 + after as i32
+            }
         }
     }
 
@@ -1529,113 +1529,113 @@ impl Instruction {
             };
 
         match self {
-            Nop => w!(Nop),
-            ImportName(idx) => w!(ImportName, name = idx),
-            ImportNameless => w!(ImportNameless),
-            ImportFrom(idx) => w!(ImportFrom, name = idx),
-            LoadFast(idx) => w!(LoadFast, varname = idx),
-            LoadNameAny(idx) => w!(LoadNameAny, name = idx),
-            LoadGlobal(idx) => w!(LoadGlobal, name = idx),
-            LoadDeref(idx) => w!(LoadDeref, cell_name = idx),
-            LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
-            StoreFast(idx) => w!(StoreFast, varname = idx),
-            StoreLocal(idx) => w!(StoreLocal, name = idx),
-            StoreGlobal(idx) => w!(StoreGlobal, name = idx),
-            StoreDeref(idx) => w!(StoreDeref, cell_name = idx),
-            DeleteFast(idx) => w!(DeleteFast, varname = idx),
-            DeleteLocal(idx) => w!(DeleteLocal, name = idx),
-            DeleteGlobal(idx) => w!(DeleteGlobal, name = idx),
-            DeleteDeref(idx) => w!(DeleteDeref, cell_name = idx),
-            LoadClosure(i) => w!(LoadClosure, cell_name = i),
-            IsOp(inv) => w!(IS_OP, ?inv),
-            ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
-            JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
-            Subscript => w!(Subscript),
-            StoreSubscript => w!(StoreSubscript),
-            DeleteSubscript => w!(DeleteSubscript),
-            StoreAttr(idx) => w!(StoreAttr, name = idx),
-            DeleteAttr(idx) => w!(DeleteAttr, name = idx),
-            LoadConst(idx) => fmt_const("LoadConst", arg, f, idx),
-            UnaryOperation(op) => w!(UnaryOperation, ?op),
+            BeforeAsyncWith => w!(BeforeAsyncWith),
             BinaryOperation(op) => w!(BinaryOperation, ?op),
             BinaryOperationInplace(op) => w!(BinaryOperationInplace, ?op),
             BinarySubscript => w!(BinarySubscript),
-            LoadAttr(idx) => w!(LoadAttr, name = idx),
+            Break(target) => w!(Break, target),
+            BuildList(size) => w!(BuildList, size),
+            BuildListFromTuples(size) => w!(BuildListFromTuples, size),
+            BuildMap(size) => w!(BuildMap, size),
+            BuildMapForCall(size) => w!(BuildMapForCall, size),
+            BuildSet(size) => w!(BuildSet, size),
+            BuildSetFromTuples(size) => w!(BuildSetFromTuples, size),
+            BuildSlice(step) => w!(BuildSlice, step),
+            BuildString(size) => w!(BuildString, size),
+            BuildTuple(size) => w!(BuildTuple, size),
+            BuildTupleFromIter => w!(BuildTupleFromIter),
+            BuildTupleFromTuples(size) => w!(BuildTupleFromTuples, size),
+            CallFunctionEx(has_kwargs) => w!(CallFunctionEx, has_kwargs),
+            CallFunctionKeyword(nargs) => w!(CallFunctionKeyword, nargs),
+            CallFunctionPositional(nargs) => w!(CallFunctionPositional, nargs),
+            CallIntrinsic1(func) => w!(CallIntrinsic1, ?func),
+            CallIntrinsic2(func) => w!(CallIntrinsic2, ?func),
+            CallMethodEx(has_kwargs) => w!(CallMethodEx, has_kwargs),
+            CallMethodKeyword(nargs) => w!(CallMethodKeyword, nargs),
+            CallMethodPositional(nargs) => w!(CallMethodPositional, nargs),
             CompareOperation(op) => w!(CompareOperation, ?op),
+            ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
+            Continue(target) => w!(Continue, target),
             CopyItem(index) => w!(CopyItem, index),
-            Pop => w!(Pop),
-            Swap(index) => w!(Swap, index),
-            ToBool => w!(ToBool),
+            DeleteAttr(idx) => w!(DeleteAttr, name = idx),
+            DeleteDeref(idx) => w!(DeleteDeref, cell_name = idx),
+            DeleteFast(idx) => w!(DeleteFast, varname = idx),
+            DeleteGlobal(idx) => w!(DeleteGlobal, name = idx),
+            DeleteLocal(idx) => w!(DeleteLocal, name = idx),
+            DeleteSubscript => w!(DeleteSubscript),
+            DictUpdate(index) => w!(DictUpdate, index),
+            EndAsyncFor => w!(EndAsyncFor),
+            EndFinally => w!(EndFinally),
+            EnterFinally => w!(EnterFinally),
+            ExtendedArg => w!(ExtendedArg, Arg::<u32>::marker()),
+            ForIter(target) => w!(ForIter, target),
+            FormatValue(conversion) => w!(FormatValue, ?conversion),
+            GetAIter => w!(GetAIter),
+            GetANext => w!(GetANext),
+            GetAwaitable => w!(GetAwaitable),
             GetIter => w!(GetIter),
             GetLen => w!(GetLen),
-            CallIntrinsic1(func) => w!(CallIntrinsic1, ?func),
-            CallIntrinsic2(func) => w!(CallIntrinsic2, ?func),
-            Continue(target) => w!(Continue, target),
-            Break(target) => w!(Break, target),
+            ImportFrom(idx) => w!(ImportFrom, name = idx),
+            ImportName(idx) => w!(ImportName, name = idx),
+            ImportNameless => w!(ImportNameless),
+            IsOp(inv) => w!(IS_OP, ?inv),
             Jump(target) => w!(Jump, target),
-            PopJumpIfTrue(target) => w!(PopJumpIfTrue, target),
-            PopJumpIfFalse(target) => w!(PopJumpIfFalse, target),
-            JumpIfTrueOrPop(target) => w!(JumpIfTrueOrPop, target),
             JumpIfFalseOrPop(target) => w!(JumpIfFalseOrPop, target),
-            MakeFunction => w!(MakeFunction),
-            SetFunctionAttribute(attr) => w!(SetFunctionAttribute, ?attr),
-            CallFunctionPositional(nargs) => w!(CallFunctionPositional, nargs),
-            CallFunctionKeyword(nargs) => w!(CallFunctionKeyword, nargs),
-            CallFunctionEx(has_kwargs) => w!(CallFunctionEx, has_kwargs),
+            JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
+            JumpIfTrueOrPop(target) => w!(JumpIfTrueOrPop, target),
+            ListAppend(i) => w!(ListAppend, i),
+            LoadAttr(idx) => w!(LoadAttr, name = idx),
+            LoadBuildClass => w!(LoadBuildClass),
+            LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
+            LoadClosure(i) => w!(LoadClosure, cell_name = i),
+            LoadConst(idx) => fmt_const("LoadConst", arg, f, idx),
+            LoadDeref(idx) => w!(LoadDeref, cell_name = idx),
+            LoadFast(idx) => w!(LoadFast, varname = idx),
+            LoadGlobal(idx) => w!(LoadGlobal, name = idx),
             LoadMethod(idx) => w!(LoadMethod, name = idx),
-            CallMethodPositional(nargs) => w!(CallMethodPositional, nargs),
-            CallMethodKeyword(nargs) => w!(CallMethodKeyword, nargs),
-            CallMethodEx(has_kwargs) => w!(CallMethodEx, has_kwargs),
-            ForIter(target) => w!(ForIter, target),
-            ReturnValue => w!(ReturnValue),
-            ReturnConst(idx) => fmt_const("ReturnConst", arg, f, idx),
+            LoadNameAny(idx) => w!(LoadNameAny, name = idx),
+            MakeFunction => w!(MakeFunction),
+            MapAdd(i) => w!(MapAdd, i),
+            MatchClass(arg) => w!(MatchClass, arg),
+            MatchKeys => w!(MatchKeys),
+            MatchMapping => w!(MatchMapping),
+            MatchSequence => w!(MatchSequence),
+            Nop => w!(Nop),
+            Pop => w!(Pop),
+            PopBlock => w!(PopBlock),
+            PopException => w!(PopException),
+            PopJumpIfFalse(target) => w!(PopJumpIfFalse, target),
+            PopJumpIfTrue(target) => w!(PopJumpIfTrue, target),
+            PrintExpr => w!(PrintExpr),
+            Raise(kind) => w!(Raise, ?kind),
             Resume(arg) => w!(Resume, arg),
-            YieldValue => w!(YieldValue),
-            YieldFrom => w!(YieldFrom),
+            ReturnConst(idx) => fmt_const("ReturnConst", arg, f, idx),
+            ReturnValue => w!(ReturnValue),
+            Reverse(amount) => w!(Reverse, amount),
+            SetAdd(i) => w!(SetAdd, i),
+            SetFunctionAttribute(attr) => w!(SetFunctionAttribute, ?attr),
             SetupAnnotation => w!(SetupAnnotation),
-            SetupLoop => w!(SetupLoop),
+            SetupAsyncWith(end) => w!(SetupAsyncWith, end),
             SetupExcept(handler) => w!(SetupExcept, handler),
             SetupFinally(handler) => w!(SetupFinally, handler),
-            EnterFinally => w!(EnterFinally),
-            EndFinally => w!(EndFinally),
+            SetupLoop => w!(SetupLoop),
             SetupWith(end) => w!(SetupWith, end),
-            WithCleanupStart => w!(WithCleanupStart),
-            WithCleanupFinish => w!(WithCleanupFinish),
-            BeforeAsyncWith => w!(BeforeAsyncWith),
-            SetupAsyncWith(end) => w!(SetupAsyncWith, end),
-            PopBlock => w!(PopBlock),
-            Raise(kind) => w!(Raise, ?kind),
-            BuildString(size) => w!(BuildString, size),
-            BuildTuple(size) => w!(BuildTuple, size),
-            BuildTupleFromTuples(size) => w!(BuildTupleFromTuples, size),
-            BuildTupleFromIter => w!(BuildTupleFromIter),
-            BuildList(size) => w!(BuildList, size),
-            BuildListFromTuples(size) => w!(BuildListFromTuples, size),
-            BuildSet(size) => w!(BuildSet, size),
-            BuildSetFromTuples(size) => w!(BuildSetFromTuples, size),
-            BuildMap(size) => w!(BuildMap, size),
-            BuildMapForCall(size) => w!(BuildMapForCall, size),
-            DictUpdate(index) => w!(DictUpdate, index),
-            BuildSlice(step) => w!(BuildSlice, step),
-            ListAppend(i) => w!(ListAppend, i),
-            SetAdd(i) => w!(SetAdd, i),
-            MapAdd(i) => w!(MapAdd, i),
-            PrintExpr => w!(PrintExpr),
-            LoadBuildClass => w!(LoadBuildClass),
-            UnpackSequence(size) => w!(UnpackSequence, size),
+            StoreAttr(idx) => w!(StoreAttr, name = idx),
+            StoreDeref(idx) => w!(StoreDeref, cell_name = idx),
+            StoreFast(idx) => w!(StoreFast, varname = idx),
+            StoreGlobal(idx) => w!(StoreGlobal, name = idx),
+            StoreLocal(idx) => w!(StoreLocal, name = idx),
+            StoreSubscript => w!(StoreSubscript),
+            Subscript => w!(Subscript),
+            Swap(index) => w!(Swap, index),
+            ToBool => w!(ToBool),
+            UnaryOperation(op) => w!(UnaryOperation, ?op),
             UnpackEx(args) => w!(UnpackEx, args),
-            FormatValue(conversion) => w!(FormatValue, ?conversion),
-            PopException => w!(PopException),
-            Reverse(amount) => w!(Reverse, amount),
-            GetAwaitable => w!(GetAwaitable),
-            GetAIter => w!(GetAIter),
-            GetANext => w!(GetANext),
-            EndAsyncFor => w!(EndAsyncFor),
-            MatchMapping => w!(MatchMapping),
-            MatchSequence => w!(MatchSequence),
-            MatchKeys => w!(MatchKeys),
-            MatchClass(arg) => w!(MatchClass, arg),
-            ExtendedArg => w!(ExtendedArg, Arg::<u32>::marker()),
+            UnpackSequence(size) => w!(UnpackSequence, size),
+            WithCleanupFinish => w!(WithCleanupFinish),
+            WithCleanupStart => w!(WithCleanupStart),
+            YieldFrom => w!(YieldFrom),
+            YieldValue => w!(YieldValue),
         }
     }
 }

From 0eed077ceb6d507d601c06ce87b4ee985387d583 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 11:51:21 +0200
Subject: [PATCH 04/15] Fix `label_arg`

---
 crates/compiler-core/src/bytecode.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index ef3fe8b20b..134b8b41f4 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -1287,19 +1287,19 @@ impl Instruction {
     #[inline]
     pub const fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Jump { target: l }
-            | JumpIfNotExcMatch(l)
-            | PopJumpIfTrue { target: l }
-            | PopJumpIfFalse { target: l }
-            | JumpIfTrueOrPop { target: l }
-            | JumpIfFalseOrPop { target: l }
-            | ForIter { target: l }
-            | SetupFinally { handler: l }
-            | SetupExcept { handler: l }
-            | SetupWith { end: l }
-            | SetupAsyncWith { end: l }
-            | Break { target: l }
-            | Continue { target: l } => Some(*l),
+            Break(label)
+            | Continue(label)
+            | ForIter(label)
+            | Jump(label)
+            | JumpIfFalseOrPop(label)
+            | JumpIfNotExcMatch(label)
+            | JumpIfTrueOrPop(label)
+            | PopJumpIfFalse(label)
+            | PopJumpIfTrue(label)
+            | SetupAsyncWith(label)
+            | SetupExcept(label)
+            | SetupFinally(label)
+            | SetupWith(label) => Some(*label),
             _ => None,
         }
     }

From e844cef4f0d846876a35754f4f1c138db79cacb1 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 12:50:38 +0200
Subject: [PATCH 05/15] Fix codegen compile

---
 crates/codegen/src/compile.rs | 623 +++++++++++-----------------------
 1 file changed, 190 insertions(+), 433 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 4a4f17edcf..1f11cd95c7 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -456,12 +456,12 @@ impl Compiler {
             match ctx {
                 ExprContext::Load => {
                     // CPython uses BINARY_SLICE
-                    emit!(self, Instruction::BuildSlice { step: n == 3 });
+                    emit!(self, Instruction::BuildSlice(n == 3));
                     emit!(self, Instruction::Subscript);
                 }
                 ExprContext::Store => {
                     // CPython uses STORE_SLICE
-                    emit!(self, Instruction::BuildSlice { step: n == 3 });
+                    emit!(self, Instruction::BuildSlice(n == 3));
                     emit!(self, Instruction::StoreSubscript);
                 }
                 _ => unreachable!(),
@@ -508,28 +508,28 @@ impl Compiler {
             match collection_type {
                 CollectionType::Tuple => {
                     if size > 1 || pushed > 0 {
-                        emit!(self, Instruction::BuildTupleFromTuples { size });
+                        emit!(self, Instruction::BuildTupleFromTuples(size));
                     }
                     // If size == 1 and pushed == 0, the single tuple is already on the stack
                 }
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildListFromTuples { size });
+                    emit!(self, Instruction::BuildListFromTuples(size));
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSetFromTuples { size });
+                    emit!(self, Instruction::BuildSetFromTuples(size));
                 }
             }
         } else {
             // No starred elements
             match collection_type {
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size });
+                    emit!(self, Instruction::BuildTuple(size));
                 }
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size });
+                    emit!(self, Instruction::BuildList(size));
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size });
+                    emit!(self, Instruction::BuildSet(size));
                 }
             }
         }
@@ -795,9 +795,7 @@ impl Compiler {
         self.current_source_range = TextRange::default();
         emit!(
             self,
-            Instruction::Resume {
-                arg: bytecode::ResumeType::AtFuncStart as u32
-            }
+            Instruction::Resume(bytecode::ResumeType::AtFuncStart as u32)
         );
 
         if scope_type == CompilerScope::Module {
@@ -1063,7 +1061,7 @@ impl Compiler {
 
             if let Stmt::Expr(StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::CopyItem(1_u32));
                 emit!(self, Instruction::PrintExpr);
             } else {
                 self.compile_statement(last)?;
@@ -1094,7 +1092,7 @@ impl Compiler {
                 Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
                     let pop_instructions = self.current_block().instructions.pop();
                     let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::CopyItem(1_u32));
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -1313,11 +1311,11 @@ impl Compiler {
                     });
                     self.emit_load_const(ConstantData::None);
                     let idx = self.name(&name.name);
-                    emit!(self, Instruction::ImportName { idx });
+                    emit!(self, Instruction::ImportName(idx));
                     if let Some(alias) = &name.asname {
                         for part in name.name.split('.').skip(1) {
                             let idx = self.name(part);
-                            emit!(self, Instruction::LoadAttr { idx });
+                            emit!(self, Instruction::LoadAttr(idx));
                         }
                         self.store_name(alias.as_str())?
                     } else {
@@ -1360,7 +1358,7 @@ impl Compiler {
                     elements: from_list,
                 });
                 if let Some(idx) = module_idx {
-                    emit!(self, Instruction::ImportName { idx });
+                    emit!(self, Instruction::ImportName(idx));
                 } else {
                     emit!(self, Instruction::ImportNameless);
                 }
@@ -1369,9 +1367,7 @@ impl Compiler {
                     // from .... import *
                     emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
-                            func: bytecode::IntrinsicFunction1::ImportStar
-                        }
+                        Instruction::CallIntrinsic1(bytecode::IntrinsicFunction1::ImportStar)
                     );
                 } else {
                     // from mod import a, b as c
@@ -1380,7 +1376,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(idx));
 
                         // Store module under proper name:
                         if let Some(alias) = &name.asname {
@@ -1424,12 +1420,7 @@ impl Compiler {
 
                         self.compile_jump_if(test, false, next_block)?;
                         self.compile_statements(body)?;
-                        emit!(
-                            self,
-                            Instruction::Jump {
-                                target: after_block
-                            }
-                        );
+                        emit!(self, Instruction::Jump(after_block));
 
                         for clause in rest {
                             self.switch_to_block(next_block);
@@ -1440,12 +1431,7 @@ impl Compiler {
                                 unreachable!() // must be elif
                             }
                             self.compile_statements(&clause.body)?;
-                            emit!(
-                                self,
-                                Instruction::Jump {
-                                    target: after_block
-                                }
-                            );
+                            emit!(self, Instruction::Jump(after_block));
                         }
 
                         self.switch_to_block(next_block);
@@ -1489,7 +1475,7 @@ impl Compiler {
                     }
                     None => bytecode::RaiseKind::Reraise,
                 };
-                emit!(self, Instruction::Raise { kind });
+                emit!(self, Instruction::Raise(kind));
             }
             Stmt::Try(StmtTry {
                 body,
@@ -1552,18 +1538,13 @@ impl Compiler {
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
-                            emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
+                            emit!(self, Instruction::CallFunctionPositional(1));
                         }
                         None => {
-                            emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+                            emit!(self, Instruction::CallFunctionPositional(0));
                         }
                     }
-                    emit!(
-                        self,
-                        Instruction::Raise {
-                            kind: bytecode::RaiseKind::Raise,
-                        }
-                    );
+                    emit!(self, Instruction::Raise(bytecode::RaiseKind::Raise));
 
                     self.switch_to_block(after_block);
                 }
@@ -1587,7 +1568,7 @@ impl Compiler {
 
                 match found_loop {
                     Some(exit_block) => {
-                        emit!(self, Instruction::Break { target: exit_block });
+                        emit!(self, Instruction::Break(exit_block));
                     }
                     None => {
                         return Err(
@@ -1615,7 +1596,7 @@ impl Compiler {
 
                 match found_loop {
                     Some(loop_block) => {
-                        emit!(self, Instruction::Continue { target: loop_block });
+                        emit!(self, Instruction::Continue(loop_block));
                     }
                     None => {
                         return Err(
@@ -1656,7 +1637,7 @@ impl Compiler {
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, Instruction::CopyItem { index: 1_u32 });
+                        emit!(self, Instruction::CopyItem(1_u32));
                     }
                     self.compile_store(target)?;
                 }
@@ -1725,12 +1706,10 @@ impl Compiler {
                 }
 
                 // Build tuple of 3 elements and call intrinsic
-                emit!(self, Instruction::BuildTuple { size: 3 });
+                emit!(self, Instruction::BuildTuple(3));
                 emit!(
                     self,
-                    Instruction::CallIntrinsic1 {
-                        func: bytecode::IntrinsicFunction1::TypeAlias
-                    }
+                    Instruction::CallIntrinsic1(bytecode::IntrinsicFunction1::TypeAlias)
                 );
                 self.store_name(&name_string)?;
             }
@@ -1747,7 +1726,7 @@ impl Compiler {
                 self.check_forbidden_name(attr.as_str(), NameUsage::Delete)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, Instruction::DeleteAttr { idx });
+                emit!(self, Instruction::DeleteAttr(idx));
             }
             Expr::Subscript(ExprSubscript {
                 value, slice, ctx, ..
@@ -1819,7 +1798,7 @@ impl Compiler {
     fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
         // Apply decorators:
         for _ in decorator_list {
-            emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
+            emit!(self, Instruction::CallFunctionPositional(1));
         }
     }
 
@@ -1844,7 +1823,7 @@ impl Compiler {
         if allow_starred && matches!(expr, Expr::Starred(_)) {
             if let Expr::Starred(starred) = expr {
                 self.compile_expression(&starred.value)?;
-                emit!(self, Instruction::UnpackSequence { size: 1 });
+                emit!(self, Instruction::UnpackSequence(1));
             }
         } else {
             self.compile_expression(expr)?;
@@ -1861,7 +1840,7 @@ impl Compiler {
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
 
         // Call the function immediately
-        emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+        emit!(self, Instruction::CallFunctionPositional(0));
 
         Ok(())
     }
@@ -1895,13 +1874,11 @@ impl Compiler {
                         } else {
                             bytecode::IntrinsicFunction2::TypeVarWithBound
                         };
-                        emit!(self, Instruction::CallIntrinsic2 { func: intrinsic });
+                        emit!(self, Instruction::CallIntrinsic2(intrinsic));
                     } else {
                         emit!(
                             self,
-                            Instruction::CallIntrinsic1 {
-                                func: bytecode::IntrinsicFunction1::TypeVar
-                            }
+                            Instruction::CallIntrinsic1(bytecode::IntrinsicFunction1::TypeVar)
                         );
                     }
 
@@ -1911,13 +1888,13 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
                         emit!(
                             self,
-                            Instruction::CallIntrinsic2 {
-                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
-                            }
+                            Instruction::CallIntrinsic2(
+                                bytecode::IntrinsicFunction2::SetTypeparamDefault
+                            )
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::CopyItem(1_u32));
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
@@ -1926,9 +1903,7 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
-                            func: bytecode::IntrinsicFunction1::ParamSpec
-                        }
+                        Instruction::CallIntrinsic1(bytecode::IntrinsicFunction1::ParamSpec)
                     );
 
                     // Handle default value if present (PEP 695)
@@ -1937,13 +1912,13 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
                         emit!(
                             self,
-                            Instruction::CallIntrinsic2 {
-                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
-                            }
+                            Instruction::CallIntrinsic2(
+                                bytecode::IntrinsicFunction2::SetTypeparamDefault
+                            )
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::CopyItem(1_u32));
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
@@ -1952,9 +1927,7 @@ impl Compiler {
                     });
                     emit!(
                         self,
-                        Instruction::CallIntrinsic1 {
-                            func: bytecode::IntrinsicFunction1::TypeVarTuple
-                        }
+                        Instruction::CallIntrinsic1(bytecode::IntrinsicFunction1::TypeVarTuple)
                     );
 
                     // Handle default value if present (PEP 695)
@@ -1964,22 +1937,20 @@ impl Compiler {
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, true)?;
                         emit!(
                             self,
-                            Instruction::CallIntrinsic2 {
-                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
-                            }
+                            Instruction::CallIntrinsic2(
+                                bytecode::IntrinsicFunction2::SetTypeparamDefault
+                            )
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::CopyItem(1_u32));
                     self.store_name(name.as_ref())?;
                 }
             };
         }
         emit!(
             self,
-            Instruction::BuildTuple {
-                size: u32::try_from(type_params.len()).unwrap(),
-            }
+            Instruction::BuildTuple(u32::try_from(type_params.len()).unwrap())
         );
         Ok(())
     }
@@ -1996,26 +1967,16 @@ impl Compiler {
 
         // Setup a finally block if we have a finally statement.
         if !finalbody.is_empty() {
-            emit!(
-                self,
-                Instruction::SetupFinally {
-                    handler: finally_block,
-                }
-            );
+            emit!(self, Instruction::SetupFinally(finally_block));
         }
 
         let else_block = self.new_block();
 
         // try:
-        emit!(
-            self,
-            Instruction::SetupExcept {
-                handler: handler_block,
-            }
-        );
+        emit!(self, Instruction::SetupExcept(handler_block));
         self.compile_statements(body)?;
         emit!(self, Instruction::PopBlock);
-        emit!(self, Instruction::Jump { target: else_block });
+        emit!(self, Instruction::Jump(else_block));
 
         // except handlers:
         self.switch_to_block(handler_block);
@@ -2030,7 +1991,7 @@ impl Compiler {
             // check if this handler can handle the exception:
             if let Some(exc_type) = type_ {
                 // Duplicate exception for test:
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::CopyItem(1_u32));
 
                 // Check exception type:
                 self.compile_expression(exc_type)?;
@@ -2067,12 +2028,7 @@ impl Compiler {
                 emit!(self, Instruction::EnterFinally);
             }
 
-            emit!(
-                self,
-                Instruction::Jump {
-                    target: finally_block,
-                }
-            );
+            emit!(self, Instruction::Jump(finally_block));
 
             // Emit a new label for the next handler
             self.switch_to_block(next_handler);
@@ -2080,12 +2036,7 @@ impl Compiler {
 
         // If code flows here, we have an unhandled exception,
         // raise the exception again!
-        emit!(
-            self,
-            Instruction::Raise {
-                kind: bytecode::RaiseKind::Reraise,
-            }
-        );
+        emit!(self, Instruction::Raise(bytecode::RaiseKind::Reraise));
 
         // We successfully ran the try block:
         // else:
@@ -2143,12 +2094,7 @@ impl Compiler {
             for default in &defaults {
                 self.compile_expression(default)?;
             }
-            emit!(
-                self,
-                Instruction::BuildTuple {
-                    size: defaults.len().to_u32()
-                }
-            );
+            emit!(self, Instruction::BuildTuple(defaults.len().to_u32()));
             funcflags |= bytecode::MakeFunctionFlags::DEFAULTS;
         }
 
@@ -2168,12 +2114,7 @@ impl Compiler {
                 });
                 self.compile_expression(default)?;
             }
-            emit!(
-                self,
-                Instruction::BuildMap {
-                    size: kw_with_defaults.len().to_u32(),
-                }
-            );
+            emit!(self, Instruction::BuildMap(kw_with_defaults.len().to_u32()));
             funcflags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
         }
 
@@ -2238,13 +2179,13 @@ impl Compiler {
 
         // Handle docstring if present
         if let Some(doc) = doc_str {
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::CopyItem(1_u32));
             self.emit_load_const(ConstantData::Str {
                 value: doc.to_string().into(),
             });
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap(2));
             let doc_attr = self.name("__doc__");
-            emit!(self, Instruction::StoreAttr { idx: doc_attr });
+            emit!(self, Instruction::StoreAttr(doc_attr));
         }
 
         Ok(())
@@ -2321,7 +2262,7 @@ impl Compiler {
 
             // SWAP if we have both
             if num_typeparam_args == 2 {
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap(2));
             }
 
             // Enter type params scope
@@ -2364,12 +2305,7 @@ impl Compiler {
         let num_annotations = self.visit_annotations(parameters, returns)?;
         if num_annotations > 0 {
             annotations_flag = bytecode::MakeFunctionFlags::ANNOTATIONS;
-            emit!(
-                self,
-                Instruction::BuildMap {
-                    size: num_annotations,
-                }
-            );
+            emit!(self, Instruction::BuildMap(num_annotations,));
         }
 
         // Compile function body
@@ -2380,14 +2316,12 @@ 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(2));
 
             // Call INTRINSIC_SET_FUNCTION_TYPE_PARAMS
             emit!(
                 self,
-                Instruction::CallIntrinsic2 {
-                    func: bytecode::IntrinsicFunction2::SetFunctionTypeParams,
-                }
+                Instruction::CallIntrinsic2(bytecode::IntrinsicFunction2::SetFunctionTypeParams)
             );
 
             // Return the function object from type params scope
@@ -2404,21 +2338,14 @@ impl Compiler {
 
             // Call the closure
             if num_typeparam_args > 0 {
+                emit!(self, Instruction::Swap((num_typeparam_args + 1) as u32));
                 emit!(
                     self,
-                    Instruction::Swap {
-                        index: (num_typeparam_args + 1) as u32
-                    }
-                );
-                emit!(
-                    self,
-                    Instruction::CallFunctionPositional {
-                        nargs: num_typeparam_args as u32
-                    }
+                    Instruction::CallFunctionPositional(num_typeparam_args as u32)
                 );
             } else {
                 // No arguments, just call the closure
-                emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+                emit!(self, Instruction::CallFunctionPositional(0));
             }
         }
 
@@ -2521,12 +2448,7 @@ impl Compiler {
             }
 
             // Build tuple of closure variables
-            emit!(
-                self,
-                Instruction::BuildTuple {
-                    size: code.freevars.len().to_u32(),
-                }
-            );
+            emit!(self, Instruction::BuildTuple(code.freevars.len().to_u32()));
         }
 
         // load code object and create function
@@ -2545,9 +2467,7 @@ impl Compiler {
             // Closure tuple is already on stack
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::CLOSURE
-                }
+                Instruction::SetFunctionAttribute(bytecode::MakeFunctionFlags::CLOSURE)
             );
         }
 
@@ -2556,9 +2476,7 @@ impl Compiler {
             // Annotations dict is already on stack
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::ANNOTATIONS
-                }
+                Instruction::SetFunctionAttribute(bytecode::MakeFunctionFlags::ANNOTATIONS)
             );
         }
 
@@ -2567,9 +2485,7 @@ impl Compiler {
             // kwdefaults dict is already on stack
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
-                }
+                Instruction::SetFunctionAttribute(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS)
             );
         }
 
@@ -2578,9 +2494,7 @@ impl Compiler {
             // defaults tuple is already on stack
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::DEFAULTS
-                }
+                Instruction::SetFunctionAttribute(bytecode::MakeFunctionFlags::DEFAULTS)
             );
         }
 
@@ -2589,9 +2503,7 @@ impl Compiler {
             // type_params tuple is already on stack
             emit!(
                 self,
-                Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::TYPE_PARAMS
-                }
+                Instruction::SetFunctionAttribute(bytecode::MakeFunctionFlags::TYPE_PARAMS)
             );
         }
 
@@ -2713,7 +2625,7 @@ impl Compiler {
 
         if let Some(classcell_idx) = classcell_idx {
             emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::CopyItem(1_u32));
             let classcell = self.name("__classcell__");
             emit!(self, Instruction::StoreLocal(classcell));
         } else {
@@ -2780,9 +2692,7 @@ impl Compiler {
             emit!(self, Instruction::LoadNameAny(dot_type_params));
             emit!(
                 self,
-                Instruction::CallIntrinsic1 {
-                    func: bytecode::IntrinsicFunction1::SubscriptGeneric
-                }
+                Instruction::CallIntrinsic1(bytecode::IntrinsicFunction1::SubscriptGeneric)
             );
             emit!(self, Instruction::StoreLocal(dot_generic_base));
 
@@ -2827,14 +2737,14 @@ impl Compiler {
                 }
                 emit!(
                     self,
-                    Instruction::CallFunctionKeyword {
-                        nargs: nargs
+                    Instruction::CallFunctionKeyword(
+                        nargs
                             + u32::try_from(arguments.keywords.len())
                                 .expect("too many keyword arguments")
-                    }
+                    )
                 );
             } else {
-                emit!(self, Instruction::CallFunctionPositional { nargs });
+                emit!(self, Instruction::CallFunctionPositional(nargs));
             }
 
             // Return the created class
@@ -2845,7 +2755,7 @@ impl Compiler {
 
             // Execute the type params function
             self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
-            emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+            emit!(self, Instruction::CallFunctionPositional(0));
         } else {
             // Non-generic class: standard path
             emit!(self, Instruction::LoadBuildClass);
@@ -2894,12 +2804,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,
-            Instruction::Jump {
-                target: while_block,
-            }
-        );
+        emit!(self, Instruction::Jump(while_block));
         self.switch_to_block(else_block);
 
         // Pop fblock
@@ -2934,13 +2839,11 @@ impl Compiler {
                 emit!(self, Instruction::YieldFrom);
                 emit!(
                     self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterAwait as u32
-                    }
+                    Instruction::Resume(bytecode::ResumeType::AfterAwait as u32)
                 );
-                emit!(self, Instruction::SetupAsyncWith { end: final_block });
+                emit!(self, Instruction::SetupAsyncWith(final_block));
             } else {
-                emit!(self, Instruction::SetupWith { end: final_block });
+                emit!(self, Instruction::SetupWith(final_block));
             }
 
             match &item.optional_vars {
@@ -2981,9 +2884,7 @@ impl Compiler {
             emit!(self, Instruction::YieldFrom);
             emit!(
                 self,
-                Instruction::Resume {
-                    arg: bytecode::ResumeType::AfterAwait as u32
-                }
+                Instruction::Resume(bytecode::ResumeType::AfterAwait as u32)
             );
         }
 
@@ -3018,20 +2919,13 @@ impl Compiler {
             // Push fblock for async for loop
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
-            emit!(
-                self,
-                Instruction::SetupExcept {
-                    handler: else_block,
-                }
-            );
+            emit!(self, Instruction::SetupExcept(else_block,));
             emit!(self, Instruction::GetANext);
             self.emit_load_const(ConstantData::None);
             emit!(self, Instruction::YieldFrom);
             emit!(
                 self,
-                Instruction::Resume {
-                    arg: bytecode::ResumeType::AfterAwait as u32
-                }
+                Instruction::Resume(bytecode::ResumeType::AfterAwait as u32)
             );
             self.compile_store(target)?;
             emit!(self, Instruction::PopBlock);
@@ -3044,7 +2938,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(else_block));
 
             // Start of loop iteration, set targets:
             self.compile_store(target)?;
@@ -3053,7 +2947,7 @@ impl Compiler {
         let was_in_loop = self.ctx.loop_data.replace((for_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
-        emit!(self, Instruction::Jump { target: for_block });
+        emit!(self, Instruction::Jump(for_block));
 
         self.switch_to_block(else_block);
 
@@ -3111,20 +3005,10 @@ impl Compiler {
         // Emit a jump using the jump target stored at index `pops`.
         match op {
             JumpOp::Jump => {
-                emit!(
-                    self,
-                    Instruction::Jump {
-                        target: pc.fail_pop[pops]
-                    }
-                );
+                emit!(self, Instruction::Jump(pc.fail_pop[pops]));
             }
             JumpOp::PopJumpIfFalse => {
-                emit!(
-                    self,
-                    Instruction::PopJumpIfFalse {
-                        target: pc.fail_pop[pops]
-                    }
-                );
+                emit!(self, Instruction::PopJumpIfFalse(pc.fail_pop[pops]));
             }
         }
         Ok(())
@@ -3161,12 +3045,7 @@ impl Compiler {
         // For count=3, swap TOS with item 2 positions down, then with item 1 position down
         while count > 1 {
             // Emit a SWAP instruction with the current count.
-            emit!(
-                self,
-                Instruction::Swap {
-                    index: u32::try_from(count).unwrap()
-                }
-            );
+            emit!(self, Instruction::Swap(u32::try_from(count).unwrap()));
             count -= 1;
         }
         Ok(())
@@ -3228,7 +3107,7 @@ impl Compiler {
                         before: u8::try_from(i).unwrap(),
                         after: u8::try_from(n - i - 1).unwrap(),
                     };
-                    emit!(self, Instruction::UnpackEx { args });
+                    emit!(self, Instruction::UnpackEx(args));
                     seen_star = true;
                 } else {
                     // TODO: Fix error msg
@@ -3238,12 +3117,7 @@ impl Compiler {
             }
         }
         if !seen_star {
-            emit!(
-                self,
-                Instruction::UnpackSequence {
-                    size: u32::try_from(n).unwrap()
-                }
-            );
+            emit!(self, Instruction::UnpackSequence(u32::try_from(n).unwrap()));
         }
         Ok(())
     }
@@ -3286,7 +3160,7 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::CopyItem(1_u32));
             if i < star {
                 // For indices before the star, use a nonnegative index equal to i.
                 self.emit_load_const(ConstantData::Integer { value: i.into() });
@@ -3298,12 +3172,7 @@ impl Compiler {
                     value: (patterns.len() - i).into(),
                 });
                 // Subtract to compute the correct index.
-                emit!(
-                    self,
-                    Instruction::BinaryOperation {
-                        op: BinaryOperator::Subtract
-                    }
-                );
+                emit!(self, Instruction::BinaryOperation(BinaryOperator::Subtract));
             }
             // Use BINARY_OP/NB_SUBSCR to extract the element.
             emit!(self, Instruction::BinarySubscript);
@@ -3359,7 +3228,7 @@ impl Compiler {
 
         // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
         pc.on_top += 1;
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
+        emit!(self, Instruction::CopyItem(1_u32));
         // Compile the sub-pattern.
         self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
         // After success, decrement the on_top counter.
@@ -3460,7 +3329,7 @@ impl Compiler {
         // 2. Emit MATCH_CLASS with nargs.
         emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
         // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
+        emit!(self, Instruction::CopyItem(1_u32));
         // 4. Load None.
         self.emit_load_const(ConstantData::None);
         // 5. Compare with IS_OP 1.
@@ -3474,9 +3343,7 @@ impl Compiler {
         let total = nargs + n_attrs;
         emit!(
             self,
-            Instruction::UnpackSequence {
-                size: u32::try_from(total).unwrap()
-            }
+            Instruction::UnpackSequence(u32::try_from(total).unwrap())
         );
         pc.on_top += total;
         pc.on_top -= 1;
@@ -3559,9 +3426,7 @@ impl Compiler {
             // Stack: [subject, len, size]
             emit!(
                 self,
-                Instruction::CompareOperation {
-                    op: ComparisonOperator::GreaterOrEqual
-                }
+                Instruction::CompareOperation(ComparisonOperator::GreaterOrEqual)
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
             // Stack: [subject]
@@ -3616,7 +3481,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(size));
         // Stack: [subject, keys_tuple]
 
         // Match keys
@@ -3625,7 +3490,7 @@ impl Compiler {
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
+        emit!(self, Instruction::CopyItem(1_u32));
         // Stack: [subject, keys_tuple, values_tuple, values_tuple_copy]
 
         // Check if copy is None (consumes the copy like POP_JUMP_IF_NONE)
@@ -3637,7 +3502,7 @@ impl Compiler {
         // Stack: [subject, keys_tuple, values_tuple]
 
         // Unpack values (the original values_tuple)
-        emit!(self, Instruction::UnpackSequence { size });
+        emit!(self, Instruction::UnpackSequence(size));
         // Stack after unpack: [subject, keys_tuple, ...unpacked values...]
         pc.on_top += size as usize; // Unpacked size values, tuple replaced by values
         pc.on_top -= 1;
@@ -3659,16 +3524,16 @@ impl Compiler {
             // Stack: [subject, keys_tuple]
 
             // Build rest dict exactly
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap(0));
             // Stack: [subject, keys_tuple, {}]
-            emit!(self, Instruction::Swap { index: 3 });
+            emit!(self, Instruction::Swap(3));
             // Stack: [{}, keys_tuple, subject]
-            emit!(self, Instruction::DictUpdate { index: 2 });
+            emit!(self, Instruction::DictUpdate(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(size));
             // Stack: [rest_dict, k1, k2, ..., kn] (if size==0, nothing pushed)
 
             // Delete each key from rest_dict (skipped when size==0)
@@ -3676,14 +3541,9 @@ impl Compiler {
             let mut remaining = size;
             while remaining > 0 {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
-                emit!(
-                    self,
-                    Instruction::CopyItem {
-                        index: 1 + remaining
-                    }
-                );
+                emit!(self, Instruction::CopyItem(1 + remaining));
                 // Stack: [rest_dict, k1, ..., kn, rest_dict]
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap(2));
                 // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
                 emit!(self, Instruction::DeleteSubscript);
                 // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
@@ -3735,7 +3595,7 @@ impl Compiler {
             pc.fail_pop.clear();
             pc.on_top = 0;
             // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::CopyItem(1_u32));
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -3779,7 +3639,7 @@ impl Compiler {
                 }
             }
             // Emit a jump to the common end label and reset any failure jump targets.
-            emit!(self, Instruction::Jump { target: end });
+            emit!(self, Instruction::Jump(end));
             self.emit_and_reset_fail_pop(pc)?;
         }
 
@@ -3863,9 +3723,7 @@ impl Compiler {
             self.emit_load_const(ConstantData::Integer { value: size.into() });
             emit!(
                 self,
-                Instruction::CompareOperation {
-                    op: ComparisonOperator::Equal
-                }
+                Instruction::CompareOperation(ComparisonOperator::Equal)
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         } else if size > 1 {
@@ -3876,9 +3734,7 @@ impl Compiler {
             });
             emit!(
                 self,
-                Instruction::CompareOperation {
-                    op: ComparisonOperator::GreaterOrEqual
-                }
+                Instruction::CompareOperation(ComparisonOperator::GreaterOrEqual)
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         }
@@ -3905,9 +3761,7 @@ impl Compiler {
         self.compile_expression(&p.value)?;
         emit!(
             self,
-            Instruction::CompareOperation {
-                op: bytecode::ComparisonOperator::Equal
-            }
+            Instruction::CompareOperation(bytecode::ComparisonOperator::Equal)
         );
         // emit!(self, Instruction::ToBool);
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -3982,7 +3836,7 @@ impl Compiler {
         for (i, m) in cases.iter().enumerate().take(case_count) {
             // Only copy the subject if not on the last case
             if i != case_count - 1 {
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::CopyItem(1_u32));
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -4004,9 +3858,7 @@ impl Compiler {
                 emit!(self, Instruction::ToBool);
                 emit!(
                     self,
-                    Instruction::PopJumpIfFalse {
-                        target: pattern_context.fail_pop[0]
-                    }
+                    Instruction::PopJumpIfFalse(pattern_context.fail_pop[0])
                 );
             }
 
@@ -4015,7 +3867,7 @@ impl Compiler {
             }
 
             self.compile_statements(&m.body)?;
-            emit!(self, Instruction::Jump { target: end });
+            emit!(self, Instruction::Jump(end));
             self.emit_and_reset_fail_pop(pattern_context)?;
         }
 
@@ -4029,7 +3881,7 @@ impl Compiler {
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::JumpIfFalseOrPop { target: end });
+                emit!(self, Instruction::JumpIfFalseOrPop(end));
             }
             self.compile_statements(&m.body)?;
         }
@@ -4056,14 +3908,12 @@ impl Compiler {
 
         use bytecode::ComparisonOperator::*;
         let compile_cmpop = |c: &mut Self, op: &CmpOp| match op {
-            CmpOp::Eq => emit!(c, Instruction::CompareOperation { op: Equal }),
-            CmpOp::NotEq => emit!(c, Instruction::CompareOperation { op: NotEqual }),
-            CmpOp::Lt => emit!(c, Instruction::CompareOperation { op: Less }),
-            CmpOp::LtE => emit!(c, Instruction::CompareOperation { op: LessOrEqual }),
-            CmpOp::Gt => emit!(c, Instruction::CompareOperation { op: Greater }),
-            CmpOp::GtE => {
-                emit!(c, Instruction::CompareOperation { op: GreaterOrEqual })
-            }
+            CmpOp::Eq => emit!(c, Instruction::CompareOperation(Equal)),
+            CmpOp::NotEq => emit!(c, Instruction::CompareOperation(NotEqual)),
+            CmpOp::Lt => emit!(c, Instruction::CompareOperation(Less)),
+            CmpOp::LtE => emit!(c, Instruction::CompareOperation(LessOrEqual)),
+            CmpOp::Gt => emit!(c, Instruction::CompareOperation(Greater)),
+            CmpOp::GtE => emit!(c, Instruction::CompareOperation(GreaterOrEqual)),
             CmpOp::In => emit!(c, Instruction::ContainsOp(Invert::No)),
             CmpOp::NotIn => emit!(c, Instruction::ContainsOp(Invert::Yes)),
             CmpOp::Is => emit!(c, Instruction::IsOp(Invert::No)),
@@ -4093,19 +3943,14 @@ impl Compiler {
         for (op, val) in mid_ops.iter().zip(mid_exprs) {
             self.compile_expression(val)?;
             // store rhs for the next comparison in chain
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::CopyItem { index: 2_u32 });
+            emit!(self, Instruction::Swap(2));
+            emit!(self, Instruction::CopyItem(2_u32));
 
             compile_cmpop(self, op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
             if let Some((break_block, _)) = end_blocks {
-                emit!(
-                    self,
-                    Instruction::JumpIfFalseOrPop {
-                        target: break_block,
-                    }
-                );
+                emit!(self, Instruction::JumpIfFalseOrPop(break_block));
             }
         }
 
@@ -4114,16 +3959,11 @@ impl Compiler {
         compile_cmpop(self, last_op);
 
         if let Some((break_block, after_block)) = end_blocks {
-            emit!(
-                self,
-                Instruction::Jump {
-                    target: after_block,
-                }
-            );
+            emit!(self, Instruction::Jump(after_block));
 
             // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
             self.switch_to_block(break_block);
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap(2));
             emit!(self, Instruction::Pop);
 
             self.switch_to_block(after_block);
@@ -4150,7 +3990,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(1));
                     Ok(())
                 }
                 _ => self.compile_expression(annotation),
@@ -4209,7 +4049,7 @@ impl Compiler {
                 self.check_forbidden_name(attr.as_str(), NameUsage::Store)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, Instruction::StoreAttr { idx });
+                emit!(self, Instruction::StoreAttr(idx));
             }
             Expr::List(ExprList { elts, .. }) | Expr::Tuple(ExprTuple { elts, .. }) => {
                 let mut seen_star = false;
@@ -4231,18 +4071,13 @@ impl Compiler {
                                     )
                                 })?;
                             let args = bytecode::UnpackExArgs { before, after };
-                            emit!(self, Instruction::UnpackEx { args });
+                            emit!(self, Instruction::UnpackEx(args));
                         }
                     }
                 }
 
                 if !seen_star {
-                    emit!(
-                        self,
-                        Instruction::UnpackSequence {
-                            size: elts.len().to_u32(),
-                        }
-                    );
+                    emit!(self, Instruction::UnpackSequence(elts.len().to_u32()));
                 }
 
                 for element in elts {
@@ -4294,8 +4129,8 @@ impl Compiler {
                 // But we can't use compile_subscript directly because we need DUP_TOP2
                 self.compile_expression(value)?;
                 self.compile_expression(slice)?;
-                emit!(self, Instruction::CopyItem { index: 2_u32 });
-                emit!(self, Instruction::CopyItem { index: 2_u32 });
+                emit!(self, Instruction::CopyItem(2_u32));
+                emit!(self, Instruction::CopyItem(2_u32));
                 emit!(self, Instruction::Subscript);
                 AugAssignKind::Subscript
             }
@@ -4303,9 +4138,9 @@ impl Compiler {
                 let attr = attr.as_str();
                 self.check_forbidden_name(attr, NameUsage::Store)?;
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::CopyItem(1_u32));
                 let idx = self.name(attr);
-                emit!(self, Instruction::LoadAttr { idx });
+                emit!(self, Instruction::LoadAttr(idx));
                 AugAssignKind::Attr { idx }
             }
             _ => {
@@ -4323,14 +4158,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(3));
+                emit!(self, Instruction::Swap(2));
                 emit!(self, Instruction::StoreSubscript);
             }
             AugAssignKind::Attr { idx } => {
                 // stack: CONTAINER RESULT
-                emit!(self, Instruction::Swap { index: 2 });
-                emit!(self, Instruction::StoreAttr { idx });
+                emit!(self, Instruction::Swap(2));
+                emit!(self, Instruction::StoreAttr(idx));
             }
         }
 
@@ -4354,9 +4189,9 @@ impl Compiler {
             Operator::BitAnd => bytecode::BinaryOperator::And,
         };
         if inplace {
-            emit!(self, Instruction::BinaryOperationInplace { op })
+            emit!(self, Instruction::BinaryOperationInplace(op))
         } else {
-            emit!(self, Instruction::BinaryOperation { op })
+            emit!(self, Instruction::BinaryOperation(op))
         }
     }
 
@@ -4433,19 +4268,9 @@ impl Compiler {
                 // Fall back case which always will work!
                 self.compile_expression(expression)?;
                 if condition {
-                    emit!(
-                        self,
-                        Instruction::PopJumpIfTrue {
-                            target: target_block,
-                        }
-                    );
+                    emit!(self, Instruction::PopJumpIfTrue(target_block));
                 } else {
-                    emit!(
-                        self,
-                        Instruction::PopJumpIfFalse {
-                            target: target_block,
-                        }
-                    );
+                    emit!(self, Instruction::PopJumpIfFalse(target_block));
                 }
             }
         }
@@ -4463,20 +4288,10 @@ impl Compiler {
 
             match op {
                 BoolOp::And => {
-                    emit!(
-                        self,
-                        Instruction::JumpIfFalseOrPop {
-                            target: after_block,
-                        }
-                    );
+                    emit!(self, Instruction::JumpIfFalseOrPop(after_block));
                 }
                 BoolOp::Or => {
-                    emit!(
-                        self,
-                        Instruction::JumpIfTrueOrPop {
-                            target: after_block,
-                        }
-                    );
+                    emit!(self, Instruction::JumpIfTrueOrPop(after_block));
                 }
             }
         }
@@ -4497,11 +4312,11 @@ impl Compiler {
             self.compile_expression(&item.value)?;
             size += 1;
         }
-        emit!(self, Instruction::BuildMap { size });
+        emit!(self, Instruction::BuildMap(size));
 
         for item in unpacked {
             self.compile_expression(&item.value)?;
-            emit!(self, Instruction::DictUpdate { index: 1 });
+            emit!(self, Instruction::DictUpdate(1));
         }
 
         Ok(())
@@ -4542,12 +4357,12 @@ impl Compiler {
                     UnaryOp::Not => bytecode::UnaryOperator::Not,
                     UnaryOp::Invert => bytecode::UnaryOperator::Invert,
                 };
-                emit!(self, Instruction::UnaryOperation { op });
+                emit!(self, Instruction::UnaryOperation(op));
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, Instruction::LoadAttr { idx });
+                emit!(self, Instruction::LoadAttr(idx));
             }
             Expr::Compare(ExprCompare {
                 left,
@@ -4588,7 +4403,7 @@ impl Compiler {
                     self.compile_expression(step)?;
                 }
                 let step = step.is_some();
-                emit!(self, Instruction::BuildSlice { step });
+                emit!(self, Instruction::BuildSlice(step));
             }
             Expr::Yield(ExprYield { value, .. }) => {
                 if !self.ctx.in_func() {
@@ -4602,9 +4417,7 @@ impl Compiler {
                 emit!(self, Instruction::YieldValue);
                 emit!(
                     self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterYield as u32
-                    }
+                    Instruction::Resume(bytecode::ResumeType::AfterYield as u32)
                 );
             }
             Expr::Await(ExprAwait { value, .. }) => {
@@ -4617,9 +4430,7 @@ impl Compiler {
                 emit!(self, Instruction::YieldFrom);
                 emit!(
                     self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterAwait as u32
-                    }
+                    Instruction::Resume(bytecode::ResumeType::AfterAwait as u32)
                 );
             }
             Expr::YieldFrom(ExprYieldFrom { value, .. }) => {
@@ -4639,9 +4450,7 @@ impl Compiler {
                 emit!(self, Instruction::YieldFrom);
                 emit!(
                     self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterYieldFrom as u32
-                    }
+                    Instruction::Resume(bytecode::ResumeType::AfterYieldFrom as u32)
                 );
             }
             Expr::Name(ExprName { id, .. }) => self.load_name(id.as_str())?,
@@ -4668,7 +4477,7 @@ impl Compiler {
                     for element in &defaults {
                         self.compile_expression(element)?;
                     }
-                    emit!(self, Instruction::BuildTuple { size });
+                    emit!(self, Instruction::BuildTuple(size));
                 }
 
                 // Prepare keyword-only defaults
@@ -4688,12 +4497,7 @@ impl Compiler {
                         });
                         self.compile_expression(default)?;
                     }
-                    emit!(
-                        self,
-                        Instruction::BuildMap {
-                            size: default_kw_count.to_u32(),
-                        }
-                    );
+                    emit!(self, Instruction::BuildMap(default_kw_count.to_u32()));
                 }
 
                 self.enter_function(&name, params)?;
@@ -4733,18 +4537,11 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<listcomp>",
-                    Some(Instruction::BuildList {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(Instruction::BuildList(OpArgMarker::marker())),
                     generators,
                     &|compiler| {
                         compiler.compile_comprehension_element(elt)?;
-                        emit!(
-                            compiler,
-                            Instruction::ListAppend {
-                                i: generators.len().to_u32(),
-                            }
-                        );
+                        emit!(compiler, Instruction::ListAppend(generators.len().to_u32()));
                         Ok(())
                     },
                     ComprehensionType::List,
@@ -4756,18 +4553,11 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<setcomp>",
-                    Some(Instruction::BuildSet {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(Instruction::BuildSet(OpArgMarker::marker())),
                     generators,
                     &|compiler| {
                         compiler.compile_comprehension_element(elt)?;
-                        emit!(
-                            compiler,
-                            Instruction::SetAdd {
-                                i: generators.len().to_u32(),
-                            }
-                        );
+                        emit!(compiler, Instruction::SetAdd(generators.len().to_u32()));
                         Ok(())
                     },
                     ComprehensionType::Set,
@@ -4782,21 +4572,14 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<dictcomp>",
-                    Some(Instruction::BuildMap {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(Instruction::BuildMap(OpArgMarker::marker())),
                     generators,
                     &|compiler| {
                         // changed evaluation order for Py38 named expression PEP 572
                         compiler.compile_expression(key)?;
                         compiler.compile_expression(value)?;
 
-                        emit!(
-                            compiler,
-                            Instruction::MapAdd {
-                                i: generators.len().to_u32(),
-                            }
-                        );
+                        emit!(compiler, Instruction::MapAdd(generators.len().to_u32()));
 
                         Ok(())
                     },
@@ -4817,9 +4600,7 @@ impl Compiler {
                         emit!(compiler, Instruction::YieldValue);
                         emit!(
                             compiler,
-                            Instruction::Resume {
-                                arg: bytecode::ResumeType::AfterYield as u32
-                            }
+                            Instruction::Resume(bytecode::ResumeType::AfterYield as u32)
                         );
                         emit!(compiler, Instruction::Pop);
 
@@ -4848,12 +4629,7 @@ impl Compiler {
 
                 // True case
                 self.compile_expression(body)?;
-                emit!(
-                    self,
-                    Instruction::Jump {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::Jump(after_block));
 
                 // False case
                 self.switch_to_block(else_block);
@@ -4870,7 +4646,7 @@ impl Compiler {
                 range: _,
             }) => {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::CopyItem(1_u32));
                 self.compile_store(target)?;
             }
             Expr::FString(fstring) => {
@@ -4953,12 +4729,12 @@ impl Compiler {
                         sub_size += 1;
                     }
                 }
-                emit!(self, Instruction::BuildMap { size: sub_size });
+                emit!(self, Instruction::BuildMap(sub_size));
                 size += 1;
             }
         }
         if size > 1 {
-            emit!(self, Instruction::BuildMapForCall { size });
+            emit!(self, Instruction::BuildMapForCall(size));
         }
         Ok(())
     }
@@ -4967,7 +4743,7 @@ impl Compiler {
         let method = if let Expr::Attribute(ExprAttribute { value, attr, .. }) = &func {
             self.compile_expression(value)?;
             let idx = self.name(attr.as_str());
-            emit!(self, Instruction::LoadMethod { idx });
+            emit!(self, Instruction::LoadMethod(idx));
             true
         } else {
             self.compile_expression(func)?;
@@ -4985,19 +4761,19 @@ impl Compiler {
     fn compile_normal_call(&mut self, ty: CallType) {
         match ty {
             CallType::Positional { nargs } => {
-                emit!(self, Instruction::CallFunctionPositional { nargs })
+                emit!(self, Instruction::CallFunctionPositional(nargs))
             }
-            CallType::Keyword { nargs } => emit!(self, Instruction::CallFunctionKeyword { nargs }),
-            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallFunctionEx { has_kwargs }),
+            CallType::Keyword { nargs } => emit!(self, Instruction::CallFunctionKeyword(nargs)),
+            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallFunctionEx(has_kwargs)),
         }
     }
     fn compile_method_call(&mut self, ty: CallType) {
         match ty {
             CallType::Positional { nargs } => {
-                emit!(self, Instruction::CallMethodPositional { nargs })
+                emit!(self, Instruction::CallMethodPositional(nargs))
             }
-            CallType::Keyword { nargs } => emit!(self, Instruction::CallMethodKeyword { nargs }),
-            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallMethodEx { has_kwargs }),
+            CallType::Keyword { nargs } => emit!(self, Instruction::CallMethodKeyword(nargs)),
+            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallMethodEx(has_kwargs)),
         }
     }
 
@@ -5021,9 +4797,9 @@ impl Compiler {
         let call = if unpack || has_double_star {
             // Create a tuple with positional args:
             if unpack {
-                emit!(self, Instruction::BuildTupleFromTuples { size });
+                emit!(self, Instruction::BuildTupleFromTuples(size));
             } else {
-                emit!(self, Instruction::BuildTuple { size });
+                emit!(self, Instruction::BuildTuple(size));
             }
 
             // Create an optional map with kw-args:
@@ -5070,7 +4846,7 @@ impl Compiler {
 
             loop {
                 if iter.peek().is_none_or(|e| matches!(e, Expr::Starred(_))) {
-                    emit!(self, Instruction::BuildTuple { size: run_size });
+                    emit!(self, Instruction::BuildTuple(run_size));
                     run_size = 0;
                     size += 1;
                 }
@@ -5214,30 +4990,18 @@ impl Compiler {
             loop_labels.push((loop_block, after_block));
             self.switch_to_block(loop_block);
             if generator.is_async {
-                emit!(
-                    self,
-                    Instruction::SetupExcept {
-                        handler: after_block,
-                    }
-                );
+                emit!(self, Instruction::SetupExcept(after_block));
                 emit!(self, Instruction::GetANext);
                 self.emit_load_const(ConstantData::None);
                 emit!(self, Instruction::YieldFrom);
                 emit!(
                     self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterAwait as u32
-                    }
+                    Instruction::Resume(bytecode::ResumeType::AfterAwait as u32)
                 );
                 self.compile_store(&generator.target)?;
                 emit!(self, Instruction::PopBlock);
             } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::ForIter(after_block));
                 self.compile_store(&generator.target)?;
             }
 
@@ -5251,7 +5015,7 @@ impl Compiler {
 
         for (loop_block, after_block) in loop_labels.iter().rev().copied() {
             // Repeat:
-            emit!(self, Instruction::Jump { target: loop_block });
+            emit!(self, Instruction::Jump(loop_block));
 
             // End of for loop:
             self.switch_to_block(after_block);
@@ -5286,7 +5050,7 @@ impl Compiler {
         };
 
         // Call just created <listcomp> function:
-        emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
+        emit!(self, Instruction::CallFunctionPositional(1));
         if is_async_list_set_dict_comprehension {
             // async, but not a generator and not an async for
             // in this case, we end up with an awaitable
@@ -5296,9 +5060,7 @@ impl Compiler {
             emit!(self, Instruction::YieldFrom);
             emit!(
                 self,
-                Instruction::Resume {
-                    arg: bytecode::ResumeType::AfterAwait as u32
-                }
+                Instruction::Resume(bytecode::ResumeType::AfterAwait as u32)
             );
         }
 
@@ -5365,19 +5127,19 @@ impl Compiler {
 
     fn emit_load_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::LoadConst { idx })
+        self.emit_arg(idx, |idx| Instruction::LoadConst(idx))
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::ReturnConst { idx })
+        self.emit_arg(idx, |idx| Instruction::ReturnConst(idx))
     }
 
     fn emit_return_value(&mut self) {
         if let Some(inst) = self.current_block().instructions.last_mut()
-            && let Instruction::LoadConst { idx } = inst.instr
+            && let Instruction::LoadConst(idx) = inst.instr
         {
-            inst.instr = Instruction::ReturnConst { idx };
+            inst.instr = Instruction::ReturnConst(idx);
             return;
         }
         emit!(self, Instruction::ReturnValue)
@@ -5575,7 +5337,7 @@ impl Compiler {
             .try_into()
             .expect("BuildString size overflowed");
         if part_count > 1 {
-            emit!(self, Instruction::BuildString { size: part_count });
+            emit!(self, Instruction::BuildString(part_count));
         }
 
         Ok(())
@@ -5671,7 +5433,7 @@ impl Compiler {
                         ConversionFlag::Ascii => bytecode::ConversionFlag::Ascii,
                         ConversionFlag::Repr => bytecode::ConversionFlag::Repr,
                     };
-                    emit!(self, Instruction::FormatValue { conversion });
+                    emit!(self, Instruction::FormatValue(conversion));
                 }
             }
         }
@@ -5682,12 +5444,7 @@ impl Compiler {
                 value: Wtf8Buf::new(),
             });
         } else if element_count > 1 {
-            emit!(
-                self,
-                Instruction::BuildString {
-                    size: element_count
-                }
-            );
+            emit!(self, Instruction::BuildString(element_count));
         }
 
         Ok(())

From 7659663bbdd419bada38ab184150cd04ca0c2570 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:03:17 +0200
Subject: [PATCH 06/15] Fix `execute_instruction`

---
 crates/vm/src/frame.rs | 115 ++++++++++++++++++++---------------------
 1 file changed, 56 insertions(+), 59 deletions(-)

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 148abacf6a..19ad4e432e 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -532,11 +532,11 @@ impl ExecutingFrame<'_> {
 
         match instruction {
             bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::LoadConst { idx } => {
+            bytecode::Instruction::LoadConst(idx) => {
                 self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)
             }
-            bytecode::Instruction::ImportName { idx } => {
+            bytecode::Instruction::ImportName(idx) => {
                 self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
                 Ok(None)
             }
@@ -544,7 +544,7 @@ impl ExecutingFrame<'_> {
                 self.import(vm, None)?;
                 Ok(None)
             }
-            bytecode::Instruction::ImportFrom { idx } => {
+            bytecode::Instruction::ImportFrom(idx) => {
                 let obj = self.import_from(vm, idx.get(arg))?;
                 self.push_value(obj);
                 Ok(None)
@@ -682,7 +682,7 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::Subscript => self.execute_subscript(vm),
             bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
             bytecode::Instruction::DeleteSubscript => self.execute_delete_subscript(vm),
-            bytecode::Instruction::CopyItem { index } => {
+            bytecode::Instruction::CopyItem(index) => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
@@ -702,7 +702,7 @@ impl ExecutingFrame<'_> {
                 self.pop_value();
                 Ok(None)
             }
-            bytecode::Instruction::Swap { index } => {
+            bytecode::Instruction::Swap(index) => {
                 let len = self.state.stack.len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
                 let i = len - 1; // TOS index
@@ -729,7 +729,7 @@ impl ExecutingFrame<'_> {
                  Ok(None)
             }
             */
-            bytecode::Instruction::BuildString { size } => {
+            bytecode::Instruction::BuildString(size) => {
                 let s = self
                     .pop_multiple(size.get(arg) as usize)
                     .as_slice()
@@ -740,20 +740,20 @@ impl ExecutingFrame<'_> {
                 self.push_value(str_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildList { size } => {
+            bytecode::Instruction::BuildList(size) => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildListFromTuples { size } => {
+            bytecode::Instruction::BuildListFromTuples(size) => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildSet { size } => {
+            bytecode::Instruction::BuildSet(size) => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     set.add(element, vm)?;
@@ -761,7 +761,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildSetFromTuples { size } => {
+            bytecode::Instruction::BuildSetFromTuples(size) => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     // SAFETY: trust compiler
@@ -773,13 +773,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildTuple { size } => {
+            bytecode::Instruction::BuildTuple(size) => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildTupleFromTuples { size } => {
+            bytecode::Instruction::BuildTupleFromTuples(size) => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_tuple(elements);
@@ -794,11 +794,12 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            bytecode::Instruction::BuildMapForCall { size } => {
+            bytecode::Instruction::BuildMap(size) => self.execute_build_map(vm, size.get(arg)),
+            bytecode::Instruction::BuildMapForCall(size) => {
                 self.execute_build_map_for_call(vm, size.get(arg))
             }
-            bytecode::Instruction::DictUpdate { index } => {
+
+            bytecode::Instruction::DictUpdate(index) => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
                 // The dict to update is at position TOS-i (before popping source)
@@ -834,10 +835,8 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::BuildSlice { step } => {
-                self.execute_build_slice(vm, step.get(arg))
-            }
-            bytecode::Instruction::ListAppend { i } => {
+            bytecode::Instruction::BuildSlice(step) => self.execute_build_slice(vm, step.get(arg)),
+            bytecode::Instruction::ListAppend(i) => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let list: &Py<PyList> = unsafe {
@@ -847,7 +846,7 @@ impl ExecutingFrame<'_> {
                 list.append(item);
                 Ok(None)
             }
-            bytecode::Instruction::SetAdd { i } => {
+            bytecode::Instruction::SetAdd(i) => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let set: &Py<PySet> = unsafe {
@@ -857,7 +856,7 @@ impl ExecutingFrame<'_> {
                 set.add(item, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::MapAdd { i } => {
+            bytecode::Instruction::MapAdd(i) => {
                 let value = self.pop_value();
                 let key = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
@@ -868,8 +867,8 @@ impl ExecutingFrame<'_> {
                 dict.set_item(&*key, value, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::BinaryOperation { op } => self.execute_bin_op(vm, op.get(arg)),
-            bytecode::Instruction::BinaryOperationInplace { op } => {
+            bytecode::Instruction::BinaryOperation(op) => self.execute_bin_op(vm, op.get(arg)),
+            bytecode::Instruction::BinaryOperationInplace(op) => {
                 self.execute_bin_op_inplace(vm, op.get(arg))
             }
             bytecode::Instruction::BinarySubscript => {
@@ -880,10 +879,10 @@ impl ExecutingFrame<'_> {
                     .push(container.get_item(key.as_object(), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            bytecode::Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            bytecode::Instruction::UnaryOperation { op } => self.execute_unary_op(vm, op.get(arg)),
+            bytecode::Instruction::LoadAttr(idx) => self.load_attr(vm, idx.get(arg)),
+            bytecode::Instruction::StoreAttr(idx) => self.store_attr(vm, idx.get(arg)),
+            bytecode::Instruction::DeleteAttr(idx) => self.delete_attr(vm, idx.get(arg)),
+            bytecode::Instruction::UnaryOperation(op) => self.execute_unary_op(vm, op.get(arg)),
             bytecode::Instruction::IsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
@@ -930,12 +929,12 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::CompareOperation { op } => self.execute_compare(vm, op.get(arg)),
+            bytecode::Instruction::CompareOperation(op) => self.execute_compare(vm, op.get(arg)),
             bytecode::Instruction::ReturnValue => {
                 let value = self.pop_value();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::ReturnConst { idx } => {
+            bytecode::Instruction::ReturnConst(idx) => {
                 let value = self.code.constants[idx.get(arg) as usize].clone().into();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
@@ -949,7 +948,7 @@ impl ExecutingFrame<'_> {
                 Ok(Some(ExecutionResult::Yield(value)))
             }
             bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
-            bytecode::Instruction::Resume { arg: resume_arg } => {
+            bytecode::Instruction::Resume(resume_arg) => {
                 // Resume execution after yield, await, or at function start
                 // In CPython, this checks instrumentation and eval breaker
                 // For now, we just check for signals/interrupts
@@ -966,13 +965,13 @@ impl ExecutingFrame<'_> {
                 self.push_block(BlockType::Loop);
                 Ok(None)
             }
-            bytecode::Instruction::SetupExcept { handler } => {
+            bytecode::Instruction::SetupExcept(handler) => {
                 self.push_block(BlockType::TryExcept {
                     handler: handler.get(arg),
                 });
                 Ok(None)
             }
-            bytecode::Instruction::SetupFinally { handler } => {
+            bytecode::Instruction::SetupFinally(handler) => {
                 self.push_block(BlockType::Finally {
                     handler: handler.get(arg),
                 });
@@ -1003,7 +1002,7 @@ impl ExecutingFrame<'_> {
                     );
                 }
             }
-            bytecode::Instruction::SetupWith { end } => {
+            bytecode::Instruction::SetupWith(end) => {
                 let context_manager = self.pop_value();
                 let error_string = || -> String {
                     format!(
@@ -1055,7 +1054,7 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::SetupAsyncWith { end } => {
+            bytecode::Instruction::SetupAsyncWith(end) => {
                 let enter_res = self.pop_value();
                 self.push_block(BlockType::Finally {
                     handler: end.get(arg),
@@ -1128,13 +1127,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(bool_val).into());
                 Ok(None)
             }
-            bytecode::Instruction::CallIntrinsic1 { func } => {
+            bytecode::Instruction::CallIntrinsic1(func) => {
                 let value = self.pop_value();
                 let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
                 self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::CallIntrinsic2 { func } => {
+            bytecode::Instruction::CallIntrinsic2(func) => {
                 let value2 = self.pop_value();
                 let value1 = self.pop_value();
                 let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
@@ -1224,24 +1223,24 @@ impl ExecutingFrame<'_> {
                     Err(exc.downcast().unwrap())
                 }
             }
-            bytecode::Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            bytecode::Instruction::ForIter(target) => self.execute_for_iter(vm, target.get(arg)),
             bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
-            bytecode::Instruction::SetFunctionAttribute { attr } => {
+            bytecode::Instruction::SetFunctionAttribute(attr) => {
                 self.execute_set_function_attribute(vm, attr.get(arg))
             }
-            bytecode::Instruction::CallFunctionPositional { nargs } => {
+            bytecode::Instruction::CallFunctionPositional(nargs) => {
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallFunctionKeyword { nargs } => {
+            bytecode::Instruction::CallFunctionKeyword(nargs) => {
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
+            bytecode::Instruction::CallFunctionEx(has_kwargs) => {
                 let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::LoadMethod { idx } => {
+            bytecode::Instruction::LoadMethod(idx) => {
                 let obj = self.pop_value();
                 let method_name = self.code.names[idx.get(arg) as usize];
                 let method = PyMethod::get(obj, method_name, vm)?;
@@ -1256,44 +1255,44 @@ impl ExecutingFrame<'_> {
                 self.push_value(func);
                 Ok(None)
             }
-            bytecode::Instruction::CallMethodPositional { nargs } => {
+            bytecode::Instruction::CallMethodPositional(nargs) => {
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_method_call(args, vm)
             }
-            bytecode::Instruction::CallMethodKeyword { nargs } => {
+            bytecode::Instruction::CallMethodKeyword(nargs) => {
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_method_call(args, vm)
             }
-            bytecode::Instruction::CallMethodEx { has_kwargs } => {
+            bytecode::Instruction::CallMethodEx(has_kwargs) => {
                 let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
                 self.execute_method_call(args, vm)
             }
-            bytecode::Instruction::Jump { target } => {
+            bytecode::Instruction::Jump(target) => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            bytecode::Instruction::PopJumpIfTrue { target } => {
+            bytecode::Instruction::PopJumpIfTrue(target) => {
                 self.pop_jump_if(vm, target.get(arg), true)
             }
-            bytecode::Instruction::PopJumpIfFalse { target } => {
+            bytecode::Instruction::PopJumpIfFalse(target) => {
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfTrueOrPop { target } => {
+            bytecode::Instruction::JumpIfTrueOrPop(target) => {
                 self.jump_if_or_pop(vm, target.get(arg), true)
             }
-            bytecode::Instruction::JumpIfFalseOrPop { target } => {
+            bytecode::Instruction::JumpIfFalseOrPop(target) => {
                 self.jump_if_or_pop(vm, target.get(arg), false)
             }
 
-            bytecode::Instruction::Raise { kind } => self.execute_raise(vm, kind.get(arg)),
+            bytecode::Instruction::Raise(kind) => self.execute_raise(vm, kind.get(arg)),
 
-            bytecode::Instruction::Break { target } => self.unwind_blocks(
+            bytecode::Instruction::Break(target) => self.unwind_blocks(
                 vm,
                 UnwindReason::Break {
                     target: target.get(arg),
                 },
             ),
-            bytecode::Instruction::Continue { target } => self.unwind_blocks(
+            bytecode::Instruction::Continue(target) => self.unwind_blocks(
                 vm,
                 UnwindReason::Continue {
                     target: target.get(arg),
@@ -1304,14 +1303,12 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::UnpackSequence { size } => {
-                self.unpack_sequence(size.get(arg), vm)
-            }
-            bytecode::Instruction::UnpackEx { args } => {
+            bytecode::Instruction::UnpackSequence(size) => self.unpack_sequence(size.get(arg), vm),
+            bytecode::Instruction::UnpackEx(args) => {
                 let args = args.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
             }
-            bytecode::Instruction::FormatValue { conversion } => {
+            bytecode::Instruction::FormatValue(conversion) => {
                 self.format_value(conversion.get(arg), vm)
             }
             bytecode::Instruction::PopException => {
@@ -1323,7 +1320,7 @@ impl ExecutingFrame<'_> {
                     self.fatal("block type must be ExceptHandler here.")
                 }
             }
-            bytecode::Instruction::Reverse { amount } => {
+            bytecode::Instruction::Reverse(amount) => {
                 let stack_len = self.state.stack.len();
                 self.state.stack[stack_len - amount.get(arg) as usize..stack_len].reverse();
                 Ok(None)

From 73b5b884912112727e83f1714622fb4d56d5c95e Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:14:01 +0200
Subject: [PATCH 07/15] Sort `execute_instruction` match arms

---
 crates/vm/src/frame.rs | 1576 ++++++++++++++++++++--------------------
 1 file changed, 788 insertions(+), 788 deletions(-)

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 19ad4e432e..bd05896cfe 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -531,104 +531,203 @@ impl ExecutingFrame<'_> {
         }
 
         match instruction {
-            bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::LoadConst(idx) => {
-                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
+            bytecode::Instruction::BeforeAsyncWith => {
+                let mgr = self.pop_value();
+                let error_string = || -> String {
+                    format!(
+                        "'{:.200}' object does not support the asynchronous context manager protocol",
+                        mgr.class().name(),
+                    )
+                };
+
+                let aenter_res = vm
+                    .get_special_method(&mgr, identifier!(vm, __aenter__))?
+                    .ok_or_else(|| vm.new_type_error(error_string()))?
+                    .invoke((), vm)?;
+                let aexit = mgr
+                    .get_attr(identifier!(vm, __aexit__), vm)
+                    .map_err(|_exc| {
+                        vm.new_type_error({
+                            format!("{} (missed __aexit__ method)", error_string())
+                        })
+                    })?;
+                self.push_value(aexit);
+                self.push_value(aenter_res);
+
                 Ok(None)
             }
-            bytecode::Instruction::ImportName(idx) => {
-                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
+            bytecode::Instruction::BinaryOperation(op) => self.execute_bin_op(vm, op.get(arg)),
+            bytecode::Instruction::BinaryOperationInplace(op) => {
+                self.execute_bin_op_inplace(vm, op.get(arg))
+            }
+            bytecode::Instruction::BinarySubscript => {
+                let key = self.pop_value();
+                let container = self.pop_value();
+                self.state
+                    .stack
+                    .push(container.get_item(key.as_object(), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::ImportNameless => {
-                self.import(vm, None)?;
+
+            bytecode::Instruction::Break(target) => self.unwind_blocks(
+                vm,
+                UnwindReason::Break {
+                    target: target.get(arg),
+                },
+            ),
+            bytecode::Instruction::BuildList(size) => {
+                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+                let list_obj = vm.ctx.new_list(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::ImportFrom(idx) => {
-                let obj = self.import_from(vm, idx.get(arg))?;
-                self.push_value(obj);
+            bytecode::Instruction::BuildListFromTuples(size) => {
+                // SAFETY: compiler guarantees `size` tuples are on the stack
+                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
+                let list_obj = vm.ctx.new_list(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadFast(idx) => {
-                #[cold]
-                fn reference_error(
-                    varname: &'static PyStrInterned,
-                    vm: &VirtualMachine,
-                ) -> PyBaseExceptionRef {
-                    vm.new_exception_msg(
-                        vm.ctx.exceptions.unbound_local_error.to_owned(),
-                        format!("local variable '{varname}' referenced before assignment",),
-                    )
+            bytecode::Instruction::BuildMap(size) => self.execute_build_map(vm, size.get(arg)),
+            bytecode::Instruction::BuildMapForCall(size) => {
+                self.execute_build_map_for_call(vm, size.get(arg))
+            }
+            bytecode::Instruction::BuildSet(size) => {
+                let set = PySet::default().into_ref(&vm.ctx);
+                for element in self.pop_multiple(size.get(arg) as usize) {
+                    set.add(element, vm)?;
                 }
-                let idx = idx.get(arg) as usize;
-                let x = self.fastlocals.lock()[idx]
-                    .clone()
-                    .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
-                self.push_value(x);
+                self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadNameAny(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
-                let result = self.locals.mapping().subscript(name, vm);
-                match result {
-                    Ok(x) => self.push_value(x),
-                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
-                        self.push_value(self.load_global_or_builtin(name, vm)?);
+            bytecode::Instruction::BuildSetFromTuples(size) => {
+                let set = PySet::default().into_ref(&vm.ctx);
+                for element in self.pop_multiple(size.get(arg) as usize) {
+                    // SAFETY: trust compiler
+                    let tup = unsafe { element.downcast_unchecked::<PyTuple>() };
+                    for item in tup.iter() {
+                        set.add(item.clone(), vm)?;
                     }
-                    Err(e) => return Err(e),
                 }
+                self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadGlobal(idx) => {
-                let name = &self.code.names[idx.get(arg) as usize];
-                let x = self.load_global_or_builtin(name, vm)?;
-                self.push_value(x);
+            bytecode::Instruction::BuildSlice(step) => self.execute_build_slice(vm, step.get(arg)),
+            /*
+             bytecode::Instruction::ToBool => {
+                 dbg!("Shouldn't be called outside of match statements for now")
+                 let value = self.pop_value();
+                 // call __bool__
+                 let result = value.try_to_bool(vm)?;
+                 self.push_value(vm.ctx.new_bool(result).into());
+                 Ok(None)
+            }
+            */
+            bytecode::Instruction::BuildString(size) => {
+                let s = self
+                    .pop_multiple(size.get(arg) as usize)
+                    .as_slice()
+                    .iter()
+                    .map(|pyobj| pyobj.downcast_ref::<PyStr>().unwrap())
+                    .collect::<Wtf8Buf>();
+                let str_obj = vm.ctx.new_str(s);
+                self.push_value(str_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadDeref(i) => {
-                let i = i.get(arg) as usize;
-                let x = self.cells_frees[i]
-                    .get()
-                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
-                self.push_value(x);
+            bytecode::Instruction::BuildTuple(size) => {
+                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+                let list_obj = vm.ctx.new_tuple(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadClassDeref(i) => {
-                let i = i.get(arg) as usize;
-                let name = if i < self.code.cellvars.len() {
-                    self.code.cellvars[i]
-                } else {
-                    self.code.freevars[i - self.code.cellvars.len()]
-                };
-                let value = self.locals.mapping().subscript(name, vm).ok();
-                self.push_value(match value {
-                    Some(v) => v,
-                    None => self.cells_frees[i]
-                        .get()
-                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?,
-                });
+            bytecode::Instruction::BuildTupleFromIter => {
+                if !self.top_value().class().is(vm.ctx.types.tuple_type) {
+                    let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
+                    let list_obj = vm.ctx.new_tuple(elements);
+                    self.push_value(list_obj.into());
+                }
                 Ok(None)
             }
-            bytecode::Instruction::StoreFast(idx) => {
-                let value = self.pop_value();
-                self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
+            bytecode::Instruction::BuildTupleFromTuples(size) => {
+                // SAFETY: compiler guarantees `size` tuples are on the stack
+                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
+                let list_obj = vm.ctx.new_tuple(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::StoreLocal(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            bytecode::Instruction::CallFunctionEx(has_kwargs) => {
+                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
+                self.execute_call(args, vm)
+            }
+            bytecode::Instruction::CallFunctionKeyword(nargs) => {
+                let args = self.collect_keyword_args(nargs.get(arg));
+                self.execute_call(args, vm)
+            }
+            bytecode::Instruction::CallFunctionPositional(nargs) => {
+                let args = self.collect_positional_args(nargs.get(arg));
+                self.execute_call(args, vm)
+            }
+            bytecode::Instruction::CallIntrinsic1(func) => {
                 let value = self.pop_value();
-                self.locals.mapping().ass_subscript(name, Some(value), vm)?;
+                let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
+                self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::StoreGlobal(idx) => {
-                let value = self.pop_value();
-                self.globals
-                    .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
+            bytecode::Instruction::CallIntrinsic2(func) => {
+                let value2 = self.pop_value();
+                let value1 = self.pop_value();
+                let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
+                self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::StoreDeref(i) => {
-                let value = self.pop_value();
-                self.cells_frees[i.get(arg) as usize].set(Some(value));
+            bytecode::Instruction::CallMethodEx(has_kwargs) => {
+                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
+                self.execute_method_call(args, vm)
+            }
+            bytecode::Instruction::CallMethodKeyword(nargs) => {
+                let args = self.collect_keyword_args(nargs.get(arg));
+                self.execute_method_call(args, vm)
+            }
+            bytecode::Instruction::CallMethodPositional(nargs) => {
+                let args = self.collect_positional_args(nargs.get(arg));
+                self.execute_method_call(args, vm)
+            }
+            bytecode::Instruction::CompareOperation(op) => self.execute_compare(vm, op.get(arg)),
+            bytecode::Instruction::ContainsOp(invert) => {
+                let b = self.pop_value();
+                let a = self.pop_value();
+
+                let value = match invert.get(arg) {
+                    bytecode::Invert::No => self._in(vm, &a, &b)?,
+                    bytecode::Invert::Yes => self._not_in(vm, &a, &b)?,
+                };
+                self.push_value(vm.ctx.new_bool(value).into());
+                Ok(None)
+            }
+            bytecode::Instruction::Continue(target) => self.unwind_blocks(
+                vm,
+                UnwindReason::Continue {
+                    target: target.get(arg),
+                },
+            ),
+            bytecode::Instruction::CopyItem(index) => {
+                // 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 value = self
+                    .state
+                    .stack
+                    .len()
+                    .checked_sub(idx)
+                    .map(|i| &self.state.stack[i])
+                    .unwrap();
+                self.push_value(value.clone());
+                Ok(None)
+            }
+            bytecode::Instruction::DeleteAttr(idx) => self.delete_attr(vm, idx.get(arg)),
+            bytecode::Instruction::DeleteDeref(i) => {
+                self.cells_frees[i.get(arg) as usize].set(None);
                 Ok(None)
             }
             bytecode::Instruction::DeleteFast(idx) => {
@@ -646,11 +745,9 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            bytecode::Instruction::DeleteLocal(idx) => {
+            bytecode::Instruction::DeleteGlobal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
-                let res = self.locals.mapping().ass_subscript(name, None, vm);
-
-                match res {
+                match self.globals.del_item(name, vm) {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
                         return Err(name_error(name, vm));
@@ -659,9 +756,11 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteGlobal(idx) => {
+            bytecode::Instruction::DeleteLocal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
-                match self.globals.del_item(name, vm) {
+                let res = self.locals.mapping().ass_subscript(name, None, vm);
+
+                match res {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
                         return Err(name_error(name, vm));
@@ -670,134 +769,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteDeref(i) => {
-                self.cells_frees[i.get(arg) as usize].set(None);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadClosure(i) => {
-                let value = self.cells_frees[i.get(arg) as usize].clone();
-                self.push_value(value.into());
-                Ok(None)
-            }
-            bytecode::Instruction::Subscript => self.execute_subscript(vm),
-            bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
             bytecode::Instruction::DeleteSubscript => self.execute_delete_subscript(vm),
-            bytecode::Instruction::CopyItem(index) => {
-                // 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 value = self
-                    .state
-                    .stack
-                    .len()
-                    .checked_sub(idx)
-                    .map(|i| &self.state.stack[i])
-                    .unwrap();
-                self.push_value(value.clone());
-                Ok(None)
-            }
-            bytecode::Instruction::Pop => {
-                // Pop value from stack and ignore.
-                self.pop_value();
-                Ok(None)
-            }
-            bytecode::Instruction::Swap(index) => {
-                let len = self.state.stack.len();
-                debug_assert!(len > 0, "stack underflow in SWAP");
-                let i = len - 1; // TOS index
-                let index_val = index.get(arg) as usize;
-                // CPython: SWAP(n) swaps TOS with PEEK(n) where PEEK(n) = stack_pointer[-n]
-                // This means swap TOS with the element at index (len - n)
-                debug_assert!(
-                    index_val <= len,
-                    "SWAP index {} exceeds stack size {}",
-                    index_val,
-                    len
-                );
-                let j = len - index_val;
-                self.state.stack.swap(i, j);
-                Ok(None)
-            }
-            /*
-             bytecode::Instruction::ToBool => {
-                 dbg!("Shouldn't be called outside of match statements for now")
-                 let value = self.pop_value();
-                 // call __bool__
-                 let result = value.try_to_bool(vm)?;
-                 self.push_value(vm.ctx.new_bool(result).into());
-                 Ok(None)
-            }
-            */
-            bytecode::Instruction::BuildString(size) => {
-                let s = self
-                    .pop_multiple(size.get(arg) as usize)
-                    .as_slice()
-                    .iter()
-                    .map(|pyobj| pyobj.downcast_ref::<PyStr>().unwrap())
-                    .collect::<Wtf8Buf>();
-                let str_obj = vm.ctx.new_str(s);
-                self.push_value(str_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildList(size) => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
-                let list_obj = vm.ctx.new_list(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildListFromTuples(size) => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_list(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildSet(size) => {
-                let set = PySet::default().into_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
-                    set.add(element, vm)?;
-                }
-                self.push_value(set.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildSetFromTuples(size) => {
-                let set = PySet::default().into_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
-                    // SAFETY: trust compiler
-                    let tup = unsafe { element.downcast_unchecked::<PyTuple>() };
-                    for item in tup.iter() {
-                        set.add(item.clone(), vm)?;
-                    }
-                }
-                self.push_value(set.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTuple(size) => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
-                let list_obj = vm.ctx.new_tuple(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTupleFromTuples(size) => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_tuple(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTupleFromIter => {
-                if !self.top_value().class().is(vm.ctx.types.tuple_type) {
-                    let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
-                    let list_obj = vm.ctx.new_tuple(elements);
-                    self.push_value(list_obj.into());
-                }
-                Ok(None)
-            }
-            bytecode::Instruction::BuildMap(size) => self.execute_build_map(vm, size.get(arg)),
-            bytecode::Instruction::BuildMapForCall(size) => {
-                self.execute_build_map_for_call(vm, size.get(arg))
-            }
 
             bytecode::Instruction::DictUpdate(index) => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
@@ -835,77 +807,167 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::BuildSlice(step) => self.execute_build_slice(vm, step.get(arg)),
-            bytecode::Instruction::ListAppend(i) => {
-                let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let list: &Py<PyList> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                list.append(item);
-                Ok(None)
+            bytecode::Instruction::EndAsyncFor => {
+                let exc = self.pop_value();
+                let except_block = self.pop_block(); // pushed by TryExcept unwind
+                debug_assert_eq!(except_block.level, self.state.stack.len());
+                let _async_iterator = self.pop_value(); // __anext__ provider in the loop
+                if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) {
+                    vm.take_exception().expect("Should have exception in stack");
+                    Ok(None)
+                } else {
+                    Err(exc.downcast().unwrap())
+                }
             }
-            bytecode::Instruction::SetAdd(i) => {
-                let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let set: &Py<PySet> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                set.add(item, vm)?;
+            bytecode::Instruction::EndFinally => {
+                // Pop the finally handler from the stack, and recall
+                // what was the reason we were in this finally clause.
+                let block = self.pop_block();
+
+                if let BlockType::FinallyHandler { reason, prev_exc } = block.typ {
+                    vm.set_exception(prev_exc);
+                    if let Some(reason) = reason {
+                        self.unwind_blocks(vm, reason)
+                    } else {
+                        Ok(None)
+                    }
+                } else {
+                    self.fatal(
+                        "Block type must be finally handler when reaching EndFinally instruction!",
+                    );
+                }
+            }
+            bytecode::Instruction::EnterFinally => {
+                self.push_block(BlockType::FinallyHandler {
+                    reason: None,
+                    prev_exc: vm.current_exception(),
+                });
                 Ok(None)
             }
-            bytecode::Instruction::MapAdd(i) => {
-                let value = self.pop_value();
-                let key = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let dict: &Py<PyDict> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                dict.set_item(&*key, value, vm)?;
+            bytecode::Instruction::ExtendedArg => {
+                *extend_arg = true;
                 Ok(None)
             }
-            bytecode::Instruction::BinaryOperation(op) => self.execute_bin_op(vm, op.get(arg)),
-            bytecode::Instruction::BinaryOperationInplace(op) => {
-                self.execute_bin_op_inplace(vm, op.get(arg))
+            bytecode::Instruction::ForIter(target) => self.execute_for_iter(vm, target.get(arg)),
+            bytecode::Instruction::FormatValue(conversion) => {
+                self.format_value(conversion.get(arg), vm)
             }
-            bytecode::Instruction::BinarySubscript => {
-                let key = self.pop_value();
-                let container = self.pop_value();
-                self.state
-                    .stack
-                    .push(container.get_item(key.as_object(), vm)?);
+            bytecode::Instruction::GetAIter => {
+                let aiterable = self.pop_value();
+                let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
+                self.push_value(aiter);
                 Ok(None)
             }
-            bytecode::Instruction::LoadAttr(idx) => self.load_attr(vm, idx.get(arg)),
-            bytecode::Instruction::StoreAttr(idx) => self.store_attr(vm, idx.get(arg)),
-            bytecode::Instruction::DeleteAttr(idx) => self.delete_attr(vm, idx.get(arg)),
-            bytecode::Instruction::UnaryOperation(op) => self.execute_unary_op(vm, op.get(arg)),
-            bytecode::Instruction::IsOp(invert) => {
-                let b = self.pop_value();
-                let a = self.pop_value();
-                let res = a.is(&b);
+            bytecode::Instruction::GetANext => {
+                #[cfg(debug_assertions)] // remove when GetANext is fully implemented
+                let orig_stack_len = self.state.stack.len();
 
-                let value = match invert.get(arg) {
-                    bytecode::Invert::No => res,
-                    bytecode::Invert::Yes => !res,
+                let aiter = self.top_value();
+                let awaitable = if aiter.class().is(vm.ctx.types.async_generator) {
+                    vm.call_special_method(aiter, identifier!(vm, __anext__), ())?
+                } else {
+                    if !aiter.has_attr("__anext__", vm).unwrap_or(false) {
+                        // TODO: __anext__ must be protocol
+                        let msg = format!(
+                            "'async for' requires an iterator with __anext__ method, got {:.100}",
+                            aiter.class().name()
+                        );
+                        return Err(vm.new_type_error(msg));
+                    }
+                    let next_iter =
+                        vm.call_special_method(aiter, identifier!(vm, __anext__), ())?;
+
+                    // _PyCoro_GetAwaitableIter in CPython
+                    fn get_awaitable_iter(next_iter: &PyObject, vm: &VirtualMachine) -> PyResult {
+                        let gen_is_coroutine = |_| {
+                            // TODO: cpython gen_is_coroutine
+                            true
+                        };
+                        if next_iter.class().is(vm.ctx.types.coroutine_type)
+                            || gen_is_coroutine(next_iter)
+                        {
+                            return Ok(next_iter.to_owned());
+                        }
+                        // TODO: error handling
+                        vm.call_special_method(next_iter, identifier!(vm, __await__), ())
+                    }
+                    get_awaitable_iter(&next_iter, vm).map_err(|_| {
+                        vm.new_type_error(format!(
+                            "'async for' received an invalid object from __anext__: {:.200}",
+                            next_iter.class().name()
+                        ))
+                    })?
                 };
-                self.push_value(vm.ctx.new_bool(value).into());
+                self.push_value(awaitable);
+                #[cfg(debug_assertions)]
+                debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
                 Ok(None)
             }
-            bytecode::Instruction::ContainsOp(invert) => {
-                let b = self.pop_value();
-                let a = self.pop_value();
+            bytecode::Instruction::GetAwaitable => {
+                let awaited_obj = self.pop_value();
+                let awaitable = if awaited_obj.downcastable::<PyCoroutine>() {
+                    awaited_obj
+                } else {
+                    let await_method = vm.get_method_or_type_error(
+                        awaited_obj.clone(),
+                        identifier!(vm, __await__),
+                        || {
+                            format!(
+                                "object {} can't be used in 'await' expression",
+                                awaited_obj.class().name(),
+                            )
+                        },
+                    )?;
+                    await_method.call((), vm)?
+                };
+                self.push_value(awaitable);
+                Ok(None)
+            }
+            bytecode::Instruction::GetIter => {
+                let iterated_obj = self.pop_value();
+                let iter_obj = iterated_obj.get_iter(vm)?;
+                self.push_value(iter_obj.into());
+                Ok(None)
+            }
+            bytecode::Instruction::GetLen => {
+                // STACK.append(len(STACK[-1]))
+                let obj = self.top_value();
+                let len = obj.length(vm)?;
+                self.push_value(vm.ctx.new_int(len).into());
+                Ok(None)
+            }
+            bytecode::Instruction::ImportFrom(idx) => {
+                let obj = self.import_from(vm, idx.get(arg))?;
+                self.push_value(obj);
+                Ok(None)
+            }
+            bytecode::Instruction::ImportName(idx) => {
+                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
+                Ok(None)
+            }
+            bytecode::Instruction::ImportNameless => {
+                self.import(vm, None)?;
+                Ok(None)
+            }
+            bytecode::Instruction::IsOp(invert) => {
+                let b = self.pop_value();
+                let a = self.pop_value();
+                let res = a.is(&b);
 
                 let value = match invert.get(arg) {
-                    bytecode::Invert::No => self._in(vm, &a, &b)?,
-                    bytecode::Invert::Yes => self._not_in(vm, &a, &b)?,
+                    bytecode::Invert::No => res,
+                    bytecode::Invert::Yes => !res,
                 };
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
+            bytecode::Instruction::Jump(target) => {
+                self.jump(target.get(arg));
+                Ok(None)
+            }
+            bytecode::Instruction::JumpIfFalseOrPop(target) => {
+                self.jump_if_or_pop(vm, target.get(arg), false)
+            }
             bytecode::Instruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
@@ -929,617 +991,555 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::CompareOperation(op) => self.execute_compare(vm, op.get(arg)),
-            bytecode::Instruction::ReturnValue => {
-                let value = self.pop_value();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
-            }
-            bytecode::Instruction::ReturnConst(idx) => {
-                let value = self.code.constants[idx.get(arg) as usize].clone().into();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
+            bytecode::Instruction::JumpIfTrueOrPop(target) => {
+                self.jump_if_or_pop(vm, target.get(arg), true)
             }
-            bytecode::Instruction::YieldValue => {
-                let value = self.pop_value();
-                let value = if self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
-                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
-                } else {
-                    value
+            bytecode::Instruction::ListAppend(i) => {
+                let item = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let list: &Py<PyList> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
                 };
-                Ok(Some(ExecutionResult::Yield(value)))
-            }
-            bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
-            bytecode::Instruction::Resume(resume_arg) => {
-                // Resume execution after yield, await, or at function start
-                // In CPython, this checks instrumentation and eval breaker
-                // For now, we just check for signals/interrupts
-                let _resume_type = resume_arg.get(arg);
-
-                // Check for interrupts if not resuming from yield_from
-                // if resume_type < bytecode::ResumeType::AfterYieldFrom as u32 {
-                //     vm.check_signals()?;
-                // }
+                list.append(item);
                 Ok(None)
             }
-            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
-            bytecode::Instruction::SetupLoop => {
-                self.push_block(BlockType::Loop);
+            bytecode::Instruction::LoadAttr(idx) => self.load_attr(vm, idx.get(arg)),
+            bytecode::Instruction::LoadBuildClass => {
+                self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::SetupExcept(handler) => {
-                self.push_block(BlockType::TryExcept {
-                    handler: handler.get(arg),
+            bytecode::Instruction::LoadClassDeref(i) => {
+                let i = i.get(arg) as usize;
+                let name = if i < self.code.cellvars.len() {
+                    self.code.cellvars[i]
+                } else {
+                    self.code.freevars[i - self.code.cellvars.len()]
+                };
+                let value = self.locals.mapping().subscript(name, vm).ok();
+                self.push_value(match value {
+                    Some(v) => v,
+                    None => self.cells_frees[i]
+                        .get()
+                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?,
                 });
                 Ok(None)
             }
-            bytecode::Instruction::SetupFinally(handler) => {
-                self.push_block(BlockType::Finally {
-                    handler: handler.get(arg),
-                });
+            bytecode::Instruction::LoadClosure(i) => {
+                let value = self.cells_frees[i.get(arg) as usize].clone();
+                self.push_value(value.into());
                 Ok(None)
             }
-            bytecode::Instruction::EnterFinally => {
-                self.push_block(BlockType::FinallyHandler {
-                    reason: None,
-                    prev_exc: vm.current_exception(),
-                });
+            bytecode::Instruction::LoadConst(idx) => {
+                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)
             }
-            bytecode::Instruction::EndFinally => {
-                // Pop the finally handler from the stack, and recall
-                // what was the reason we were in this finally clause.
-                let block = self.pop_block();
-
-                if let BlockType::FinallyHandler { reason, prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    if let Some(reason) = reason {
-                        self.unwind_blocks(vm, reason)
-                    } else {
-                        Ok(None)
-                    }
-                } else {
-                    self.fatal(
-                        "Block type must be finally handler when reaching EndFinally instruction!",
-                    );
-                }
+            bytecode::Instruction::LoadDeref(i) => {
+                let i = i.get(arg) as usize;
+                let x = self.cells_frees[i]
+                    .get()
+                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
+                self.push_value(x);
+                Ok(None)
             }
-            bytecode::Instruction::SetupWith(end) => {
-                let context_manager = self.pop_value();
-                let error_string = || -> String {
-                    format!(
-                        "'{:.200}' object does not support the context manager protocol",
-                        context_manager.class().name(),
+            bytecode::Instruction::LoadFast(idx) => {
+                #[cold]
+                fn reference_error(
+                    varname: &'static PyStrInterned,
+                    vm: &VirtualMachine,
+                ) -> PyBaseExceptionRef {
+                    vm.new_exception_msg(
+                        vm.ctx.exceptions.unbound_local_error.to_owned(),
+                        format!("local variable '{varname}' referenced before assignment"),
                     )
-                };
-                let enter_res = vm
-                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
-                    .ok_or_else(|| vm.new_type_error(error_string()))?
-                    .invoke((), vm)?;
-
-                let exit = context_manager
-                    .get_attr(identifier!(vm, __exit__), vm)
-                    .map_err(|_exc| {
-                        vm.new_type_error({
-                            format!("{} (missed __exit__ method)", error_string())
-                        })
-                    })?;
-                self.push_value(exit);
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
-                self.push_value(enter_res);
+                }
+                let idx = idx.get(arg) as usize;
+                let x = self.fastlocals.lock()[idx]
+                    .clone()
+                    .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
+                self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::BeforeAsyncWith => {
-                let mgr = self.pop_value();
-                let error_string = || -> String {
-                    format!(
-                        "'{:.200}' object does not support the asynchronous context manager protocol",
-                        mgr.class().name(),
-                    )
+            bytecode::Instruction::LoadGlobal(idx) => {
+                let name = &self.code.names[idx.get(arg) as usize];
+                let x = self.load_global_or_builtin(name, vm)?;
+                self.push_value(x);
+                Ok(None)
+            }
+            bytecode::Instruction::LoadMethod(idx) => {
+                let obj = self.pop_value();
+                let method_name = self.code.names[idx.get(arg) as usize];
+                let method = PyMethod::get(obj, method_name, vm)?;
+                let (target, is_method, func) = match method {
+                    PyMethod::Function { target, func } => (target, true, func),
+                    PyMethod::Attribute(val) => (vm.ctx.none(), false, val),
                 };
-
-                let aenter_res = vm
-                    .get_special_method(&mgr, identifier!(vm, __aenter__))?
-                    .ok_or_else(|| vm.new_type_error(error_string()))?
-                    .invoke((), vm)?;
-                let aexit = mgr
-                    .get_attr(identifier!(vm, __aexit__), vm)
-                    .map_err(|_exc| {
-                        vm.new_type_error({
-                            format!("{} (missed __aexit__ method)", error_string())
-                        })
-                    })?;
-                self.push_value(aexit);
-                self.push_value(aenter_res);
-
+                // TODO: figure out a better way to communicate PyMethod::Attribute - CPython uses
+                // target==NULL, maybe we could use a sentinel value or something?
+                self.push_value(target);
+                self.push_value(vm.ctx.new_bool(is_method).into());
+                self.push_value(func);
                 Ok(None)
             }
-            bytecode::Instruction::SetupAsyncWith(end) => {
-                let enter_res = self.pop_value();
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
-                self.push_value(enter_res);
+            bytecode::Instruction::LoadNameAny(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let result = self.locals.mapping().subscript(name, vm);
+                match result {
+                    Ok(x) => self.push_value(x),
+                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                        self.push_value(self.load_global_or_builtin(name, vm)?);
+                    }
+                    Err(e) => return Err(e),
+                }
                 Ok(None)
             }
-            bytecode::Instruction::WithCleanupStart => {
-                let block = self.current_block().unwrap();
-                let reason = match block.typ {
-                    BlockType::FinallyHandler { reason, .. } => reason,
-                    _ => self.fatal("WithCleanupStart expects a FinallyHandler block on stack"),
-                };
-                let exc = match reason {
-                    Some(UnwindReason::Raising { exception }) => Some(exception),
-                    _ => None,
+            bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
+            bytecode::Instruction::MapAdd(i) => {
+                let value = self.pop_value();
+                let key = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let dict: &Py<PyDict> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
                 };
+                dict.set_item(&*key, value, vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::MatchClass(nargs) => {
+                // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
+                // nargs is the number of positional sub-patterns.
+                let kwd_attrs = self.pop_value();
+                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 exit = self.top_value();
+                // Check if subject is an instance of cls
+                if subject.is_instance(cls.as_ref(), vm)? {
+                    let mut extracted = vec![];
 
-                let args = if let Some(exc) = exc {
-                    vm.split_exception(exc)
-                } else {
-                    (vm.ctx.none(), vm.ctx.none(), vm.ctx.none())
-                };
-                let exit_res = exit.call(args, vm)?;
-                self.replace_top(exit_res);
+                    // Get __match_args__ for positional arguments if nargs > 0
+                    if nargs_val > 0 {
+                        // Get __match_args__ from the class
+                        let match_args =
+                            vm.get_attribute_opt(cls.clone(), identifier!(vm, __match_args__))?;
+
+                        if let Some(match_args) = match_args {
+                            // Convert to tuple
+                            let match_args = match match_args.downcast_exact::<PyTuple>(vm) {
+                                Ok(tuple) => tuple,
+                                Err(match_args) => {
+                                    // __match_args__ must be a tuple
+                                    // Get type names for error message
+                                    let type_name = cls
+                                        .downcast::<crate::builtins::PyType>()
+                                        .map(|t| t.__name__(vm).as_str().to_owned())
+                                        .unwrap_or_else(|_| String::from("?"));
+                                    let match_args_type_name = match_args.class().__name__(vm);
+                                    return Err(vm.new_type_error(format!(
+                                        "{}.__match_args__ must be a tuple (got {})",
+                                        type_name, match_args_type_name
+                                    )));
+                                }
+                            };
+
+                            // Check if we have enough match args
+                            if match_args.len() < nargs_val {
+                                return Err(vm.new_type_error(format!(
+                                    "class pattern accepts at most {} positional sub-patterns ({} given)",
+                                    match_args.len(),
+                                    nargs_val
+                                )));
+                            }
+
+                            // Extract positional attributes
+                            for i in 0..nargs_val {
+                                let attr_name = &match_args[i];
+                                let attr_name_str = match attr_name.downcast_ref::<PyStr>() {
+                                    Some(s) => s,
+                                    None => {
+                                        return Err(vm.new_type_error(
+                                            "__match_args__ elements must be strings".to_string(),
+                                        ));
+                                    }
+                                };
+                                match subject.get_attr(attr_name_str, vm) {
+                                    Ok(value) => extracted.push(value),
+                                    Err(e)
+                                        if e.fast_isinstance(vm.ctx.exceptions.attribute_error) =>
+                                    {
+                                        // Missing attribute → non-match
+                                        self.push_value(vm.ctx.none());
+                                        return Ok(None);
+                                    }
+                                    Err(e) => return Err(e),
+                                }
+                            }
+                        } else {
+                            // No __match_args__, check if this is a type with MATCH_SELF behavior
+                            // For built-in types like bool, int, str, list, tuple, dict, etc.
+                            // they match the subject itself as the single positional argument
+                            let is_match_self_type = cls
+                                .downcast::<PyType>()
+                                .is_ok_and(|t| t.slots.flags.contains(PyTypeFlags::_MATCH_SELF));
+
+                            if is_match_self_type {
+                                if nargs_val == 1 {
+                                    // Match the subject itself as the single positional argument
+                                    extracted.push(subject.clone());
+                                } else if nargs_val > 1 {
+                                    // Too many positional arguments for MATCH_SELF
+                                    return Err(vm.new_type_error(
+                                        "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types"
+                                            .to_string(),
+                                    ));
+                                }
+                            } else {
+                                // No __match_args__ and not a MATCH_SELF type
+                                if nargs_val > 0 {
+                                    return Err(vm.new_type_error(
+                                        "class pattern defines no positional sub-patterns (__match_args__ missing)"
+                                            .to_string(),
+                                    ));
+                                }
+                            }
+                        }
+                    }
+
+                    // Extract keyword attributes
+                    for name in kwd_attrs {
+                        let name_str = name.downcast_ref::<PyStr>().unwrap();
+                        match subject.get_attr(name_str, vm) {
+                            Ok(value) => extracted.push(value),
+                            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => {
+                                self.push_value(vm.ctx.none());
+                                return Ok(None);
+                            }
+                            Err(e) => return Err(e),
+                        }
+                    }
 
+                    self.push_value(vm.ctx.new_tuple(extracted).into());
+                } else {
+                    // Not an instance, push None
+                    self.push_value(vm.ctx.none());
+                }
                 Ok(None)
             }
-            bytecode::Instruction::WithCleanupFinish => {
-                let block = self.pop_block();
-                let (reason, prev_exc) = match block.typ {
-                    BlockType::FinallyHandler { reason, prev_exc } => (reason, prev_exc),
-                    _ => self.fatal("WithCleanupFinish expects a FinallyHandler block on stack"),
-                };
+            bytecode::Instruction::MatchKeys => {
+                // MATCH_KEYS doesn't pop subject and keys, only reads them
+                let keys_tuple = self.top_value(); // stack[-1]
+                let subject = self.nth_value(1); // stack[-2]
 
-                vm.set_exception(prev_exc);
+                // Check if subject is a mapping and extract values for keys
+                if subject.class().slots.flags.contains(PyTypeFlags::MAPPING) {
+                    let keys = keys_tuple.downcast_ref::<PyTuple>().unwrap();
+                    let mut values = Vec::new();
+                    let mut all_match = true;
 
-                let suppress_exception = self.pop_value().try_to_bool(vm)?;
+                    // We use the two argument form of map.get(key, default) for two reasons:
+                    // - Atomically check for a key and get its value without error handling.
+                    // - Don't cause key creation or resizing in dict subclasses like
+                    //   collections.defaultdict that define __missing__ (or similar).
+                    // See CPython's _PyEval_MatchKeys
 
-                if suppress_exception {
-                    Ok(None)
-                } else if let Some(reason) = reason {
-                    self.unwind_blocks(vm, reason)
+                    if let Some(get_method) = vm
+                        .get_method(subject.to_owned(), vm.ctx.intern_str("get"))
+                        .transpose()?
+                    {
+                        // dummy = object()
+                        // CPython: dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);
+                        let dummy = vm
+                            .ctx
+                            .new_base_object(vm.ctx.types.object_type.to_owned(), None);
+
+                        for key in keys {
+                            // value = map.get(key, dummy)
+                            match get_method.call((key.as_object(), dummy.clone()), vm) {
+                                Ok(value) => {
+                                    // if value == dummy: key not in map!
+                                    if value.is(&dummy) {
+                                        all_match = false;
+                                        break;
+                                    }
+                                    values.push(value);
+                                }
+                                Err(e) => return Err(e),
+                            }
+                        }
+                    } else {
+                        // Fallback if .get() method is not available (shouldn't happen for mappings)
+                        for key in keys {
+                            match subject.get_item(key.as_object(), vm) {
+                                Ok(value) => values.push(value),
+                                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                                    all_match = false;
+                                    break;
+                                }
+                                Err(e) => return Err(e),
+                            }
+                        }
+                    }
+
+                    if all_match {
+                        // Push values tuple on successful match
+                        self.push_value(vm.ctx.new_tuple(values).into());
+                    } else {
+                        // No match - push None
+                        self.push_value(vm.ctx.none());
+                    }
                 } else {
-                    Ok(None)
+                    // Not a mapping - push None
+                    self.push_value(vm.ctx.none());
                 }
+                Ok(None)
             }
-            bytecode::Instruction::PopBlock => {
-                self.pop_block();
+            bytecode::Instruction::MatchMapping => {
+                // Pop and push back the subject to keep it on stack
+                let subject = self.pop_value();
+
+                // Check if the type has the MAPPING flag
+                let is_mapping = subject.class().slots.flags.contains(PyTypeFlags::MAPPING);
+
+                self.push_value(subject);
+                self.push_value(vm.ctx.new_bool(is_mapping).into());
                 Ok(None)
             }
-            bytecode::Instruction::GetIter => {
-                let iterated_obj = self.pop_value();
-                let iter_obj = iterated_obj.get_iter(vm)?;
-                self.push_value(iter_obj.into());
+            bytecode::Instruction::MatchSequence => {
+                // Pop and push back the subject to keep it on stack
+                let subject = self.pop_value();
+
+                // Check if the type has the SEQUENCE flag
+                let is_sequence = subject.class().slots.flags.contains(PyTypeFlags::SEQUENCE);
+
+                self.push_value(subject);
+                self.push_value(vm.ctx.new_bool(is_sequence).into());
                 Ok(None)
             }
-            bytecode::Instruction::GetLen => {
-                // STACK.append(len(STACK[-1]))
-                let obj = self.top_value();
-                let len = obj.length(vm)?;
-                self.push_value(vm.ctx.new_int(len).into());
+            bytecode::Instruction::Nop => Ok(None),
+            bytecode::Instruction::Pop => {
+                // Pop value from stack and ignore.
+                self.pop_value();
                 Ok(None)
             }
-            bytecode::Instruction::ToBool => {
-                let obj = self.pop_value();
-                let bool_val = obj.try_to_bool(vm)?;
-                self.push_value(vm.ctx.new_bool(bool_val).into());
+            bytecode::Instruction::PopBlock => {
+                self.pop_block();
                 Ok(None)
             }
-            bytecode::Instruction::CallIntrinsic1(func) => {
-                let value = self.pop_value();
-                let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
-                self.push_value(result);
-                Ok(None)
-            }
-            bytecode::Instruction::CallIntrinsic2(func) => {
-                let value2 = self.pop_value();
-                let value1 = self.pop_value();
-                let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
-                self.push_value(result);
-                Ok(None)
-            }
-            bytecode::Instruction::GetAwaitable => {
-                let awaited_obj = self.pop_value();
-                let awaitable = if awaited_obj.downcastable::<PyCoroutine>() {
-                    awaited_obj
-                } else {
-                    let await_method = vm.get_method_or_type_error(
-                        awaited_obj.clone(),
-                        identifier!(vm, __await__),
-                        || {
-                            format!(
-                                "object {} can't be used in 'await' expression",
-                                awaited_obj.class().name(),
-                            )
-                        },
-                    )?;
-                    await_method.call((), vm)?
-                };
-                self.push_value(awaitable);
-                Ok(None)
-            }
-            bytecode::Instruction::GetAIter => {
-                let aiterable = self.pop_value();
-                let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
-                self.push_value(aiter);
-                Ok(None)
-            }
-            bytecode::Instruction::GetANext => {
-                #[cfg(debug_assertions)] // remove when GetANext is fully implemented
-                let orig_stack_len = self.state.stack.len();
-
-                let aiter = self.top_value();
-                let awaitable = if aiter.class().is(vm.ctx.types.async_generator) {
-                    vm.call_special_method(aiter, identifier!(vm, __anext__), ())?
-                } else {
-                    if !aiter.has_attr("__anext__", vm).unwrap_or(false) {
-                        // TODO: __anext__ must be protocol
-                        let msg = format!(
-                            "'async for' requires an iterator with __anext__ method, got {:.100}",
-                            aiter.class().name()
-                        );
-                        return Err(vm.new_type_error(msg));
-                    }
-                    let next_iter =
-                        vm.call_special_method(aiter, identifier!(vm, __anext__), ())?;
-
-                    // _PyCoro_GetAwaitableIter in CPython
-                    fn get_awaitable_iter(next_iter: &PyObject, vm: &VirtualMachine) -> PyResult {
-                        let gen_is_coroutine = |_| {
-                            // TODO: cpython gen_is_coroutine
-                            true
-                        };
-                        if next_iter.class().is(vm.ctx.types.coroutine_type)
-                            || gen_is_coroutine(next_iter)
-                        {
-                            return Ok(next_iter.to_owned());
-                        }
-                        // TODO: error handling
-                        vm.call_special_method(next_iter, identifier!(vm, __await__), ())
-                    }
-                    get_awaitable_iter(&next_iter, vm).map_err(|_| {
-                        vm.new_type_error(format!(
-                            "'async for' received an invalid object from __anext__: {:.200}",
-                            next_iter.class().name()
-                        ))
-                    })?
-                };
-                self.push_value(awaitable);
-                #[cfg(debug_assertions)]
-                debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
-                Ok(None)
-            }
-            bytecode::Instruction::EndAsyncFor => {
-                let exc = self.pop_value();
-                let except_block = self.pop_block(); // pushed by TryExcept unwind
-                debug_assert_eq!(except_block.level, self.state.stack.len());
-                let _async_iterator = self.pop_value(); // __anext__ provider in the loop
-                if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) {
-                    vm.take_exception().expect("Should have exception in stack");
+            bytecode::Instruction::PopException => {
+                let block = self.pop_block();
+                if let BlockType::ExceptHandler { prev_exc } = block.typ {
+                    vm.set_exception(prev_exc);
                     Ok(None)
                 } else {
-                    Err(exc.downcast().unwrap())
+                    self.fatal("block type must be ExceptHandler here.")
                 }
             }
-            bytecode::Instruction::ForIter(target) => self.execute_for_iter(vm, target.get(arg)),
-            bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
-            bytecode::Instruction::SetFunctionAttribute(attr) => {
-                self.execute_set_function_attribute(vm, attr.get(arg))
-            }
-            bytecode::Instruction::CallFunctionPositional(nargs) => {
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::CallFunctionKeyword(nargs) => {
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::CallFunctionEx(has_kwargs) => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::LoadMethod(idx) => {
-                let obj = self.pop_value();
-                let method_name = self.code.names[idx.get(arg) as usize];
-                let method = PyMethod::get(obj, method_name, vm)?;
-                let (target, is_method, func) = match method {
-                    PyMethod::Function { target, func } => (target, true, func),
-                    PyMethod::Attribute(val) => (vm.ctx.none(), false, val),
-                };
-                // TODO: figure out a better way to communicate PyMethod::Attribute - CPython uses
-                // target==NULL, maybe we could use a sentinel value or something?
-                self.push_value(target);
-                self.push_value(vm.ctx.new_bool(is_method).into());
-                self.push_value(func);
-                Ok(None)
-            }
-            bytecode::Instruction::CallMethodPositional(nargs) => {
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodKeyword(nargs) => {
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodEx(has_kwargs) => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::Jump(target) => {
-                self.jump(target.get(arg));
-                Ok(None)
-            }
-            bytecode::Instruction::PopJumpIfTrue(target) => {
-                self.pop_jump_if(vm, target.get(arg), true)
-            }
             bytecode::Instruction::PopJumpIfFalse(target) => {
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfTrueOrPop(target) => {
-                self.jump_if_or_pop(vm, target.get(arg), true)
-            }
-            bytecode::Instruction::JumpIfFalseOrPop(target) => {
-                self.jump_if_or_pop(vm, target.get(arg), false)
+            bytecode::Instruction::PopJumpIfTrue(target) => {
+                self.pop_jump_if(vm, target.get(arg), true)
             }
+            bytecode::Instruction::PrintExpr => self.print_expr(vm),
 
             bytecode::Instruction::Raise(kind) => self.execute_raise(vm, kind.get(arg)),
+            bytecode::Instruction::Resume(resume_arg) => {
+                // Resume execution after yield, await, or at function start
+                // In CPython, this checks instrumentation and eval breaker
+                // For now, we just check for signals/interrupts
+                let _resume_type = resume_arg.get(arg);
 
-            bytecode::Instruction::Break(target) => self.unwind_blocks(
-                vm,
-                UnwindReason::Break {
-                    target: target.get(arg),
-                },
-            ),
-            bytecode::Instruction::Continue(target) => self.unwind_blocks(
-                vm,
-                UnwindReason::Continue {
-                    target: target.get(arg),
-                },
-            ),
-            bytecode::Instruction::PrintExpr => self.print_expr(vm),
-            bytecode::Instruction::LoadBuildClass => {
-                self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
+                // Check for interrupts if not resuming from yield_from
+                // if resume_type < bytecode::ResumeType::AfterYieldFrom as u32 {
+                //     vm.check_signals()?;
+                // }
                 Ok(None)
             }
-            bytecode::Instruction::UnpackSequence(size) => self.unpack_sequence(size.get(arg), vm),
-            bytecode::Instruction::UnpackEx(args) => {
-                let args = args.get(arg);
-                self.execute_unpack_ex(vm, args.before, args.after)
-            }
-            bytecode::Instruction::FormatValue(conversion) => {
-                self.format_value(conversion.get(arg), vm)
+            bytecode::Instruction::ReturnConst(idx) => {
+                let value = self.code.constants[idx.get(arg) as usize].clone().into();
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::PopException => {
-                let block = self.pop_block();
-                if let BlockType::ExceptHandler { prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    Ok(None)
-                } else {
-                    self.fatal("block type must be ExceptHandler here.")
-                }
+            bytecode::Instruction::ReturnValue => {
+                let value = self.pop_value();
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
             bytecode::Instruction::Reverse(amount) => {
                 let stack_len = self.state.stack.len();
                 self.state.stack[stack_len - amount.get(arg) as usize..stack_len].reverse();
                 Ok(None)
             }
-            bytecode::Instruction::ExtendedArg => {
-                *extend_arg = true;
+            bytecode::Instruction::SetAdd(i) => {
+                let item = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let set: &Py<PySet> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
+                };
+                set.add(item, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::MatchMapping => {
-                // Pop and push back the subject to keep it on stack
-                let subject = self.pop_value();
-
-                // Check if the type has the MAPPING flag
-                let is_mapping = subject.class().slots.flags.contains(PyTypeFlags::MAPPING);
-
-                self.push_value(subject);
-                self.push_value(vm.ctx.new_bool(is_mapping).into());
+            bytecode::Instruction::SetFunctionAttribute(attr) => {
+                self.execute_set_function_attribute(vm, attr.get(arg))
+            }
+            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
+            bytecode::Instruction::SetupAsyncWith(end) => {
+                let enter_res = self.pop_value();
+                self.push_block(BlockType::Finally {
+                    handler: end.get(arg),
+                });
+                self.push_value(enter_res);
                 Ok(None)
             }
-            bytecode::Instruction::MatchSequence => {
-                // Pop and push back the subject to keep it on stack
-                let subject = self.pop_value();
-
-                // Check if the type has the SEQUENCE flag
-                let is_sequence = subject.class().slots.flags.contains(PyTypeFlags::SEQUENCE);
-
-                self.push_value(subject);
-                self.push_value(vm.ctx.new_bool(is_sequence).into());
+            bytecode::Instruction::SetupExcept(handler) => {
+                self.push_block(BlockType::TryExcept {
+                    handler: handler.get(arg),
+                });
                 Ok(None)
             }
-            bytecode::Instruction::MatchKeys => {
-                // MATCH_KEYS doesn't pop subject and keys, only reads them
-                let keys_tuple = self.top_value(); // stack[-1]
-                let subject = self.nth_value(1); // stack[-2]
-
-                // Check if subject is a mapping and extract values for keys
-                if subject.class().slots.flags.contains(PyTypeFlags::MAPPING) {
-                    let keys = keys_tuple.downcast_ref::<PyTuple>().unwrap();
-                    let mut values = Vec::new();
-                    let mut all_match = true;
-
-                    // We use the two argument form of map.get(key, default) for two reasons:
-                    // - Atomically check for a key and get its value without error handling.
-                    // - Don't cause key creation or resizing in dict subclasses like
-                    //   collections.defaultdict that define __missing__ (or similar).
-                    // See CPython's _PyEval_MatchKeys
-
-                    if let Some(get_method) = vm
-                        .get_method(subject.to_owned(), vm.ctx.intern_str("get"))
-                        .transpose()?
-                    {
-                        // dummy = object()
-                        // CPython: dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);
-                        let dummy = vm
-                            .ctx
-                            .new_base_object(vm.ctx.types.object_type.to_owned(), None);
-
-                        for key in keys {
-                            // value = map.get(key, dummy)
-                            match get_method.call((key.as_object(), dummy.clone()), vm) {
-                                Ok(value) => {
-                                    // if value == dummy: key not in map!
-                                    if value.is(&dummy) {
-                                        all_match = false;
-                                        break;
-                                    }
-                                    values.push(value);
-                                }
-                                Err(e) => return Err(e),
-                            }
-                        }
-                    } else {
-                        // Fallback if .get() method is not available (shouldn't happen for mappings)
-                        for key in keys {
-                            match subject.get_item(key.as_object(), vm) {
-                                Ok(value) => values.push(value),
-                                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
-                                    all_match = false;
-                                    break;
-                                }
-                                Err(e) => return Err(e),
-                            }
-                        }
-                    }
-
-                    if all_match {
-                        // Push values tuple on successful match
-                        self.push_value(vm.ctx.new_tuple(values).into());
-                    } else {
-                        // No match - push None
-                        self.push_value(vm.ctx.none());
-                    }
-                } else {
-                    // Not a mapping - push None
-                    self.push_value(vm.ctx.none());
-                }
+            bytecode::Instruction::SetupFinally(handler) => {
+                self.push_block(BlockType::Finally {
+                    handler: handler.get(arg),
+                });
                 Ok(None)
             }
-            bytecode::Instruction::MatchClass(nargs) => {
-                // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
-                // nargs is the number of positional sub-patterns.
-                let kwd_attrs = self.pop_value();
-                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;
-
-                // Check if subject is an instance of cls
-                if subject.is_instance(cls.as_ref(), vm)? {
-                    let mut extracted = vec![];
-
-                    // Get __match_args__ for positional arguments if nargs > 0
-                    if nargs_val > 0 {
-                        // Get __match_args__ from the class
-                        let match_args =
-                            vm.get_attribute_opt(cls.clone(), identifier!(vm, __match_args__))?;
+            bytecode::Instruction::SetupLoop => {
+                self.push_block(BlockType::Loop);
+                Ok(None)
+            }
+            bytecode::Instruction::SetupWith(end) => {
+                let context_manager = self.pop_value();
+                let error_string = || -> String {
+                    format!(
+                        "'{:.200}' object does not support the context manager protocol",
+                        context_manager.class().name(),
+                    )
+                };
+                let enter_res = vm
+                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
+                    .ok_or_else(|| vm.new_type_error(error_string()))?
+                    .invoke((), vm)?;
 
-                        if let Some(match_args) = match_args {
-                            // Convert to tuple
-                            let match_args = match match_args.downcast_exact::<PyTuple>(vm) {
-                                Ok(tuple) => tuple,
-                                Err(match_args) => {
-                                    // __match_args__ must be a tuple
-                                    // Get type names for error message
-                                    let type_name = cls
-                                        .downcast::<crate::builtins::PyType>()
-                                        .map(|t| t.__name__(vm).as_str().to_owned())
-                                        .unwrap_or_else(|_| String::from("?"));
-                                    let match_args_type_name = match_args.class().__name__(vm);
-                                    return Err(vm.new_type_error(format!(
-                                        "{}.__match_args__ must be a tuple (got {})",
-                                        type_name, match_args_type_name
-                                    )));
-                                }
-                            };
+                let exit = context_manager
+                    .get_attr(identifier!(vm, __exit__), vm)
+                    .map_err(|_exc| {
+                        vm.new_type_error({
+                            format!("{} (missed __exit__ method)", error_string())
+                        })
+                    })?;
+                self.push_value(exit);
+                self.push_block(BlockType::Finally {
+                    handler: end.get(arg),
+                });
+                self.push_value(enter_res);
+                Ok(None)
+            }
+            bytecode::Instruction::StoreAttr(idx) => self.store_attr(vm, idx.get(arg)),
+            bytecode::Instruction::StoreDeref(i) => {
+                let value = self.pop_value();
+                self.cells_frees[i.get(arg) as usize].set(Some(value));
+                Ok(None)
+            }
+            bytecode::Instruction::StoreFast(idx) => {
+                let value = self.pop_value();
+                self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
+                Ok(None)
+            }
+            bytecode::Instruction::StoreGlobal(idx) => {
+                let value = self.pop_value();
+                self.globals
+                    .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::StoreLocal(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let value = self.pop_value();
+                self.locals.mapping().ass_subscript(name, Some(value), vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
+            bytecode::Instruction::Subscript => self.execute_subscript(vm),
+            bytecode::Instruction::Swap(index) => {
+                let len = self.state.stack.len();
+                debug_assert!(len > 0, "stack underflow in SWAP");
+                let i = len - 1; // TOS index
+                let index_val = index.get(arg) as usize;
+                // CPython: SWAP(n) swaps TOS with PEEK(n) where PEEK(n) = stack_pointer[-n]
+                // This means swap TOS with the element at index (len - n)
+                debug_assert!(
+                    index_val <= len,
+                    "SWAP index {} exceeds stack size {}",
+                    index_val,
+                    len
+                );
+                let j = len - index_val;
+                self.state.stack.swap(i, j);
+                Ok(None)
+            }
+            bytecode::Instruction::ToBool => {
+                let obj = self.pop_value();
+                let bool_val = obj.try_to_bool(vm)?;
+                self.push_value(vm.ctx.new_bool(bool_val).into());
+                Ok(None)
+            }
+            bytecode::Instruction::UnaryOperation(op) => self.execute_unary_op(vm, op.get(arg)),
+            bytecode::Instruction::UnpackEx(args) => {
+                let args = args.get(arg);
+                self.execute_unpack_ex(vm, args.before, args.after)
+            }
+            bytecode::Instruction::UnpackSequence(size) => self.unpack_sequence(size.get(arg), vm),
+            bytecode::Instruction::WithCleanupFinish => {
+                let block = self.pop_block();
+                let (reason, prev_exc) = match block.typ {
+                    BlockType::FinallyHandler { reason, prev_exc } => (reason, prev_exc),
+                    _ => self.fatal("WithCleanupFinish expects a FinallyHandler block on stack"),
+                };
 
-                            // Check if we have enough match args
-                            if match_args.len() < nargs_val {
-                                return Err(vm.new_type_error(format!(
-                                    "class pattern accepts at most {} positional sub-patterns ({} given)",
-                                    match_args.len(),
-                                    nargs_val
-                                )));
-                            }
+                vm.set_exception(prev_exc);
 
-                            // Extract positional attributes
-                            for i in 0..nargs_val {
-                                let attr_name = &match_args[i];
-                                let attr_name_str = match attr_name.downcast_ref::<PyStr>() {
-                                    Some(s) => s,
-                                    None => {
-                                        return Err(vm.new_type_error(
-                                            "__match_args__ elements must be strings".to_string(),
-                                        ));
-                                    }
-                                };
-                                match subject.get_attr(attr_name_str, vm) {
-                                    Ok(value) => extracted.push(value),
-                                    Err(e)
-                                        if e.fast_isinstance(vm.ctx.exceptions.attribute_error) =>
-                                    {
-                                        // Missing attribute → non-match
-                                        self.push_value(vm.ctx.none());
-                                        return Ok(None);
-                                    }
-                                    Err(e) => return Err(e),
-                                }
-                            }
-                        } else {
-                            // No __match_args__, check if this is a type with MATCH_SELF behavior
-                            // For built-in types like bool, int, str, list, tuple, dict, etc.
-                            // they match the subject itself as the single positional argument
-                            let is_match_self_type = cls
-                                .downcast::<PyType>()
-                                .is_ok_and(|t| t.slots.flags.contains(PyTypeFlags::_MATCH_SELF));
+                let suppress_exception = self.pop_value().try_to_bool(vm)?;
 
-                            if is_match_self_type {
-                                if nargs_val == 1 {
-                                    // Match the subject itself as the single positional argument
-                                    extracted.push(subject.clone());
-                                } else if nargs_val > 1 {
-                                    // Too many positional arguments for MATCH_SELF
-                                    return Err(vm.new_type_error(
-                                        "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types"
-                                            .to_string(),
-                                    ));
-                                }
-                            } else {
-                                // No __match_args__ and not a MATCH_SELF type
-                                if nargs_val > 0 {
-                                    return Err(vm.new_type_error(
-                                        "class pattern defines no positional sub-patterns (__match_args__ missing)"
-                                            .to_string(),
-                                    ));
-                                }
-                            }
-                        }
-                    }
+                if suppress_exception {
+                    Ok(None)
+                } else if let Some(reason) = reason {
+                    self.unwind_blocks(vm, reason)
+                } else {
+                    Ok(None)
+                }
+            }
+            bytecode::Instruction::WithCleanupStart => {
+                let block = self.current_block().unwrap();
+                let reason = match block.typ {
+                    BlockType::FinallyHandler { reason, .. } => reason,
+                    _ => self.fatal("WithCleanupStart expects a FinallyHandler block on stack"),
+                };
+                let exc = match reason {
+                    Some(UnwindReason::Raising { exception }) => Some(exception),
+                    _ => None,
+                };
 
-                    // Extract keyword attributes
-                    for name in kwd_attrs {
-                        let name_str = name.downcast_ref::<PyStr>().unwrap();
-                        match subject.get_attr(name_str, vm) {
-                            Ok(value) => extracted.push(value),
-                            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => {
-                                self.push_value(vm.ctx.none());
-                                return Ok(None);
-                            }
-                            Err(e) => return Err(e),
-                        }
-                    }
+                let exit = self.top_value();
 
-                    self.push_value(vm.ctx.new_tuple(extracted).into());
+                let args = if let Some(exc) = exc {
+                    vm.split_exception(exc)
                 } else {
-                    // Not an instance, push None
-                    self.push_value(vm.ctx.none());
-                }
+                    (vm.ctx.none(), vm.ctx.none(), vm.ctx.none())
+                };
+                let exit_res = exit.call(args, vm)?;
+                self.replace_top(exit_res);
+
                 Ok(None)
             }
+            bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
+            bytecode::Instruction::YieldValue => {
+                let value = self.pop_value();
+                let value = if self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
+                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
+                } else {
+                    value
+                };
+                Ok(Some(ExecutionResult::Yield(value)))
+            }
         }
     }
 

From f59c99f58a272cdefc505fa15f61e6a011f5d32c Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:34:42 +0200
Subject: [PATCH 08/15] Clippy

---
 crates/codegen/src/compile.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 1f11cd95c7..8f78377d06 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -236,12 +236,6 @@ pub fn compile_expression(
 }
 
 macro_rules! emit {
-    ($c:expr, Instruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| Instruction::$op { $arg: x })
-    };
-    ($c:expr, Instruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| Instruction::$op { $arg: x })
-    };
     ($c:expr, Instruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
         $c.emit_arg($arg_val, Instruction::$op)
     };
@@ -5127,12 +5121,12 @@ 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, Instruction::LoadConst)
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::ReturnConst(idx))
+        self.emit_arg(idx, Instruction::ReturnConst)
     }
 
     fn emit_return_value(&mut self) {

From 6d5210750a91c3aada3a8dda8838250e6089cb5f Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:41:02 +0200
Subject: [PATCH 09/15] Fix jit `add_instruction`

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

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 5acf4a53ed..782142945c 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -200,7 +200,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
             // If that was a return instruction, mark future instructions unreachable
             match instruction {
-                Instruction::ReturnValue | Instruction::ReturnConst { .. } => {
+                Instruction::ReturnValue | Instruction::ReturnConst(_) => {
                     in_unreachable_code = true;
                 }
                 _ => {}
@@ -276,7 +276,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
     ) -> Result<(), JitCompileError> {
         match instruction {
             Instruction::ExtendedArg => Ok(()),
-            Instruction::PopJumpIfFalse { target } => {
+            Instruction::PopJumpIfFalse(target) => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -289,7 +289,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::PopJumpIfTrue { target } => {
+            Instruction::PopJumpIfTrue(target) => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
                 let then_block = self.get_or_create_block(target.get(arg));
@@ -303,7 +303,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 Ok(())
             }
 
-            Instruction::Jump { target } => {
+            Instruction::Jump(target) => {
                 let target_block = self.get_or_create_block(target.get(arg));
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
@@ -328,12 +328,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.push(val);
                 Ok(())
             }
-            Instruction::BuildTuple { size } => {
+            Instruction::BuildTuple(size) => {
                 let elements = self.pop_multiple(size.get(arg) as usize);
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::UnpackSequence { size } => {
+            Instruction::UnpackSequence(size) => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
 
                 let elements = match val {
@@ -352,12 +352,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            Instruction::ReturnConst { idx } => {
+            Instruction::ReturnConst(idx) => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.return_value(val)
             }
-            Instruction::CompareOperation { op, .. } => {
+            Instruction::CompareOperation(op) => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -411,7 +411,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::UnaryOperation { op, .. } => {
+            Instruction::UnaryOperation(op) => {
                 let op = op.get(arg);
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 match (op, a) {
@@ -436,7 +436,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::BinaryOperation { op } | Instruction::BinaryOperationInplace { op } => {
+            Instruction::BinaryOperation(op) | Instruction::BinaryOperationInplace(op) => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -581,7 +581,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     Ok(())
                 }
             }
-            Instruction::CallFunctionPositional { nargs } => {
+            Instruction::CallFunctionPositional(nargs) => {
                 let nargs = nargs.get(arg);
 
                 let mut args = Vec::new();
@@ -602,7 +602,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 }
             }
             Instruction::Nop => Ok(()),
-            Instruction::Swap { index } => {
+            Instruction::Swap(index) => {
                 let len = self.stack.len();
                 let i = len - 1;
                 let j = len - 1 - index.get(arg) as usize;
@@ -613,7 +613,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.pop();
                 Ok(())
             }
-            Instruction::Resume { arg: _resume_arg } => {
+            Instruction::Resume(_resume_arg) => {
                 // TODO: Implement the resume instruction
                 Ok(())
             }

From d5abcdbd5bf2eda43ad249e80128e87f11ec444a Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:43:28 +0200
Subject: [PATCH 10/15] Sort match arms

---
 crates/jit/src/instructions.rs | 367 ++++++++++++++++-----------------
 1 file changed, 183 insertions(+), 184 deletions(-)

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 782142945c..6c27bb71a8 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -275,167 +275,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         arg: OpArg,
     ) -> Result<(), JitCompileError> {
         match instruction {
-            Instruction::ExtendedArg => Ok(()),
-            Instruction::PopJumpIfFalse(target) => {
-                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                let val = self.boolean_val(cond)?;
-                let then_block = self.get_or_create_block(target.get(arg));
-                let else_block = self.builder.create_block();
-
-                self.builder
-                    .ins()
-                    .brif(val, else_block, &[], then_block, &[]);
-                self.builder.switch_to_block(else_block);
-
-                Ok(())
-            }
-            Instruction::PopJumpIfTrue(target) => {
-                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                let val = self.boolean_val(cond)?;
-                let then_block = self.get_or_create_block(target.get(arg));
-                let else_block = self.builder.create_block();
-
-                self.builder
-                    .ins()
-                    .brif(val, then_block, &[], else_block, &[]);
-                self.builder.switch_to_block(else_block);
-
-                Ok(())
-            }
-
-            Instruction::Jump(target) => {
-                let target_block = self.get_or_create_block(target.get(arg));
-                self.builder.ins().jump(target_block, &[]);
-                Ok(())
-            }
-            Instruction::LoadFast(idx) => {
-                let local = self.variables[idx.get(arg) as usize]
-                    .as_ref()
-                    .ok_or(JitCompileError::BadBytecode)?;
-                self.stack.push(JitValue::from_type_and_value(
-                    local.ty.clone(),
-                    self.builder.use_var(local.var),
-                ));
-                Ok(())
-            }
-            Instruction::StoreFast(idx) => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(idx.get(arg), val)
-            }
-            Instruction::LoadConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.stack.push(val);
-                Ok(())
-            }
-            Instruction::BuildTuple(size) => {
-                let elements = self.pop_multiple(size.get(arg) as usize);
-                self.stack.push(JitValue::Tuple(elements));
-                Ok(())
-            }
-            Instruction::UnpackSequence(size) => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-
-                let elements = match val {
-                    JitValue::Tuple(elements) => elements,
-                    _ => return Err(JitCompileError::NotSupported),
-                };
-
-                if elements.len() != size.get(arg) as usize {
-                    return Err(JitCompileError::NotSupported);
-                }
-
-                self.stack.extend(elements.into_iter().rev());
-                Ok(())
-            }
-            Instruction::ReturnValue => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.return_value(val)
-            }
-            Instruction::ReturnConst(idx) => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.return_value(val)
-            }
-            Instruction::CompareOperation(op) => {
-                let op = op.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)?;
-
-                let a_type: Option<JitType> = a.to_jit_type();
-                let b_type: Option<JitType> = b.to_jit_type();
-
-                match (a, b) {
-                    (JitValue::Int(a), JitValue::Int(b))
-                    | (JitValue::Bool(a), JitValue::Bool(b))
-                    | (JitValue::Bool(a), JitValue::Int(b))
-                    | (JitValue::Int(a), JitValue::Bool(b)) => {
-                        let operand_one = match a_type.unwrap() {
-                            JitType::Bool => self.builder.ins().uextend(types::I64, a),
-                            _ => a,
-                        };
-
-                        let operand_two = match b_type.unwrap() {
-                            JitType::Bool => self.builder.ins().uextend(types::I64, b),
-                            _ => b,
-                        };
-
-                        let cond = match op {
-                            ComparisonOperator::Equal => IntCC::Equal,
-                            ComparisonOperator::NotEqual => IntCC::NotEqual,
-                            ComparisonOperator::Less => IntCC::SignedLessThan,
-                            ComparisonOperator::LessOrEqual => IntCC::SignedLessThanOrEqual,
-                            ComparisonOperator::Greater => IntCC::SignedGreaterThan,
-                            ComparisonOperator::GreaterOrEqual => IntCC::SignedGreaterThanOrEqual,
-                        };
-
-                        let val = self.builder.ins().icmp(cond, operand_one, operand_two);
-                        self.stack.push(JitValue::Bool(val));
-                        Ok(())
-                    }
-                    (JitValue::Float(a), JitValue::Float(b)) => {
-                        let cond = match op {
-                            ComparisonOperator::Equal => FloatCC::Equal,
-                            ComparisonOperator::NotEqual => FloatCC::NotEqual,
-                            ComparisonOperator::Less => FloatCC::LessThan,
-                            ComparisonOperator::LessOrEqual => FloatCC::LessThanOrEqual,
-                            ComparisonOperator::Greater => FloatCC::GreaterThan,
-                            ComparisonOperator::GreaterOrEqual => FloatCC::GreaterThanOrEqual,
-                        };
-
-                        let val = self.builder.ins().fcmp(cond, a, b);
-                        self.stack.push(JitValue::Bool(val));
-                        Ok(())
-                    }
-                    _ => Err(JitCompileError::NotSupported),
-                }
-            }
-            Instruction::UnaryOperation(op) => {
-                let op = op.get(arg);
-                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                match (op, a) {
-                    (UnaryOperator::Minus, JitValue::Int(val)) => {
-                        // Compile minus as 0 - a.
-                        let zero = self.builder.ins().iconst(types::I64, 0);
-                        let out = self.compile_sub(zero, val);
-                        self.stack.push(JitValue::Int(out));
-                        Ok(())
-                    }
-                    (UnaryOperator::Plus, JitValue::Int(val)) => {
-                        // Nothing to do
-                        self.stack.push(JitValue::Int(val));
-                        Ok(())
-                    }
-                    (UnaryOperator::Not, a) => {
-                        let boolean = self.boolean_val(a)?;
-                        let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
-                        self.stack.push(JitValue::Bool(not_boolean));
-                        Ok(())
-                    }
-                    _ => Err(JitCompileError::NotSupported),
-                }
-            }
             Instruction::BinaryOperation(op) | Instruction::BinaryOperationInplace(op) => {
                 let op = op.get(arg);
                 // the rhs is popped off first
@@ -561,26 +400,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::SetupLoop => {
-                let loop_head = self.builder.create_block();
-                self.builder.ins().jump(loop_head, &[]);
-                self.builder.switch_to_block(loop_head);
-                Ok(())
-            }
-            Instruction::PopBlock => {
-                // TODO: block support
+            Instruction::BuildTuple(size) => {
+                let elements = self.pop_multiple(size.get(arg) as usize);
+                self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::LoadGlobal(idx) => {
-                let name = &bytecode.names[idx.get(arg) as usize];
-
-                if name.as_ref() != bytecode.obj_name.as_ref() {
-                    Err(JitCompileError::NotSupported)
-                } else {
-                    self.stack.push(JitValue::FuncRef(func_ref));
-                    Ok(())
-                }
-            }
             Instruction::CallFunctionPositional(nargs) => {
                 let nargs = nargs.get(arg);
 
@@ -601,7 +425,150 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
+            Instruction::CompareOperation(op) => {
+                let op = op.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)?;
+
+                let a_type: Option<JitType> = a.to_jit_type();
+                let b_type: Option<JitType> = b.to_jit_type();
+
+                match (a, b) {
+                    (JitValue::Int(a), JitValue::Int(b))
+                    | (JitValue::Bool(a), JitValue::Bool(b))
+                    | (JitValue::Bool(a), JitValue::Int(b))
+                    | (JitValue::Int(a), JitValue::Bool(b)) => {
+                        let operand_one = match a_type.unwrap() {
+                            JitType::Bool => self.builder.ins().uextend(types::I64, a),
+                            _ => a,
+                        };
+
+                        let operand_two = match b_type.unwrap() {
+                            JitType::Bool => self.builder.ins().uextend(types::I64, b),
+                            _ => b,
+                        };
+
+                        let cond = match op {
+                            ComparisonOperator::Equal => IntCC::Equal,
+                            ComparisonOperator::NotEqual => IntCC::NotEqual,
+                            ComparisonOperator::Less => IntCC::SignedLessThan,
+                            ComparisonOperator::LessOrEqual => IntCC::SignedLessThanOrEqual,
+                            ComparisonOperator::Greater => IntCC::SignedGreaterThan,
+                            ComparisonOperator::GreaterOrEqual => IntCC::SignedGreaterThanOrEqual,
+                        };
+
+                        let val = self.builder.ins().icmp(cond, operand_one, operand_two);
+                        self.stack.push(JitValue::Bool(val));
+                        Ok(())
+                    }
+                    (JitValue::Float(a), JitValue::Float(b)) => {
+                        let cond = match op {
+                            ComparisonOperator::Equal => FloatCC::Equal,
+                            ComparisonOperator::NotEqual => FloatCC::NotEqual,
+                            ComparisonOperator::Less => FloatCC::LessThan,
+                            ComparisonOperator::LessOrEqual => FloatCC::LessThanOrEqual,
+                            ComparisonOperator::Greater => FloatCC::GreaterThan,
+                            ComparisonOperator::GreaterOrEqual => FloatCC::GreaterThanOrEqual,
+                        };
+
+                        let val = self.builder.ins().fcmp(cond, a, b);
+                        self.stack.push(JitValue::Bool(val));
+                        Ok(())
+                    }
+                    _ => Err(JitCompileError::NotSupported),
+                }
+            }
+            Instruction::ExtendedArg => Ok(()),
+            Instruction::Jump(target) => {
+                let target_block = self.get_or_create_block(target.get(arg));
+                self.builder.ins().jump(target_block, &[]);
+                Ok(())
+            }
+            Instruction::LoadConst { idx } => {
+                let val = self
+                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+                self.stack.push(val);
+                Ok(())
+            }
+            Instruction::LoadFast(idx) => {
+                let local = self.variables[idx.get(arg) as usize]
+                    .as_ref()
+                    .ok_or(JitCompileError::BadBytecode)?;
+                self.stack.push(JitValue::from_type_and_value(
+                    local.ty.clone(),
+                    self.builder.use_var(local.var),
+                ));
+                Ok(())
+            }
+            Instruction::LoadGlobal(idx) => {
+                let name = &bytecode.names[idx.get(arg) as usize];
+
+                if name.as_ref() != bytecode.obj_name.as_ref() {
+                    Err(JitCompileError::NotSupported)
+                } else {
+                    self.stack.push(JitValue::FuncRef(func_ref));
+                    Ok(())
+                }
+            }
             Instruction::Nop => Ok(()),
+            Instruction::Pop => {
+                self.stack.pop();
+                Ok(())
+            }
+            Instruction::PopBlock => {
+                // TODO: block support
+                Ok(())
+            }
+            Instruction::PopJumpIfFalse(target) => {
+                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                let val = self.boolean_val(cond)?;
+                let then_block = self.get_or_create_block(target.get(arg));
+                let else_block = self.builder.create_block();
+
+                self.builder
+                    .ins()
+                    .brif(val, else_block, &[], then_block, &[]);
+                self.builder.switch_to_block(else_block);
+
+                Ok(())
+            }
+            Instruction::PopJumpIfTrue(target) => {
+                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                let val = self.boolean_val(cond)?;
+                let then_block = self.get_or_create_block(target.get(arg));
+                let else_block = self.builder.create_block();
+
+                self.builder
+                    .ins()
+                    .brif(val, then_block, &[], else_block, &[]);
+                self.builder.switch_to_block(else_block);
+
+                Ok(())
+            }
+            Instruction::Resume(_resume_arg) => {
+                // TODO: Implement the resume instruction
+                Ok(())
+            }
+            Instruction::ReturnConst(idx) => {
+                let val = self
+                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+                self.return_value(val)
+            }
+            Instruction::ReturnValue => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.return_value(val)
+            }
+            Instruction::SetupLoop => {
+                let loop_head = self.builder.create_block();
+                self.builder.ins().jump(loop_head, &[]);
+                self.builder.switch_to_block(loop_head);
+                Ok(())
+            }
+            Instruction::StoreFast(idx) => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.store_variable(idx.get(arg), val)
+            }
             Instruction::Swap(index) => {
                 let len = self.stack.len();
                 let i = len - 1;
@@ -609,12 +576,44 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.swap(i, j);
                 Ok(())
             }
-            Instruction::Pop => {
-                self.stack.pop();
-                Ok(())
+            Instruction::UnaryOperation(op) => {
+                let op = op.get(arg);
+                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                match (op, a) {
+                    (UnaryOperator::Minus, JitValue::Int(val)) => {
+                        // Compile minus as 0 - a.
+                        let zero = self.builder.ins().iconst(types::I64, 0);
+                        let out = self.compile_sub(zero, val);
+                        self.stack.push(JitValue::Int(out));
+                        Ok(())
+                    }
+                    (UnaryOperator::Plus, JitValue::Int(val)) => {
+                        // Nothing to do
+                        self.stack.push(JitValue::Int(val));
+                        Ok(())
+                    }
+                    (UnaryOperator::Not, a) => {
+                        let boolean = self.boolean_val(a)?;
+                        let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
+                        self.stack.push(JitValue::Bool(not_boolean));
+                        Ok(())
+                    }
+                    _ => Err(JitCompileError::NotSupported),
+                }
             }
-            Instruction::Resume(_resume_arg) => {
-                // TODO: Implement the resume instruction
+            Instruction::UnpackSequence(size) => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+
+                let elements = match val {
+                    JitValue::Tuple(elements) => elements,
+                    _ => return Err(JitCompileError::NotSupported),
+                };
+
+                if elements.len() != size.get(arg) as usize {
+                    return Err(JitCompileError::NotSupported);
+                }
+
+                self.stack.extend(elements.into_iter().rev());
                 Ok(())
             }
             _ => Err(JitCompileError::NotSupported),

From 3a01e053c46c0ee61c587324efb49ad2e1164c41 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:49:09 +0200
Subject: [PATCH 11/15] Missed one

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

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 6c27bb71a8..a6abdfe800 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -485,7 +485,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
             }
-            Instruction::LoadConst { idx } => {
+            Instruction::LoadConst(idx) => {
                 let val = self
                     .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
                 self.stack.push(val);

From 845cdd947cdf1f87a4b864693e75419139ae140d Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:53:31 +0200
Subject: [PATCH 12/15] fix Jit's `process_instruction`

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

diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 5dafeaeb80..0d0d0ef00c 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -92,7 +92,7 @@ impl StackMachine {
         names: &[String],
     ) -> ControlFlow<()> {
         match instruction {
-            Instruction::LoadConst { idx } => {
+            Instruction::LoadConst(idx) => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
@@ -104,12 +104,12 @@ impl StackMachine {
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
-            Instruction::StoreAttr { .. } => {
+            Instruction::StoreAttr(_) => {
                 // Do nothing except throw away the stack values
                 self.stack.pop().unwrap();
                 self.stack.pop().unwrap();
             }
-            Instruction::BuildMap { size, .. } => {
+            Instruction::BuildMap(size) => {
                 let mut map = HashMap::new();
                 for _ in 0..size.get(arg) {
                     let value = self.stack.pop().unwrap();
@@ -134,7 +134,7 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
-            Instruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute(attr) => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
                     func
@@ -164,7 +164,7 @@ impl StackMachine {
                     self.stack.push(StackValue::Function(func));
                 }
             }
-            Instruction::ReturnConst { idx } => {
+            Instruction::ReturnConst(idx) => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into());
                 return ControlFlow::Break(());

From f35d02810e6a1c406fad00624fcc700d4f421471 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 13:54:53 +0200
Subject: [PATCH 13/15] Sort arms

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

diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 0d0d0ef00c..53fa035f96 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -92,23 +92,6 @@ impl StackMachine {
         names: &[String],
     ) -> ControlFlow<()> {
         match instruction {
-            Instruction::LoadConst(idx) => {
-                let idx = idx.get(arg);
-                self.stack.push(constants[idx as usize].clone().into())
-            }
-            Instruction::LoadNameAny(idx) => self
-                .stack
-                .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            Instruction::StoreLocal(idx) => {
-                let idx = idx.get(arg);
-                self.locals
-                    .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
-            }
-            Instruction::StoreAttr(_) => {
-                // Do nothing except throw away the stack values
-                self.stack.pop().unwrap();
-                self.stack.pop().unwrap();
-            }
             Instruction::BuildMap(size) => {
                 let mut map = HashMap::new();
                 for _ in 0..size.get(arg) {
@@ -122,6 +105,14 @@ impl StackMachine {
                 }
                 self.stack.push(StackValue::Map(map));
             }
+            Instruction::ExtendedArg => {}
+            Instruction::LoadConst(idx) => {
+                let idx = idx.get(arg);
+                self.stack.push(constants[idx as usize].clone().into())
+            }
+            Instruction::LoadNameAny(idx) => self
+                .stack
+                .push(StackValue::String(names[idx.get(arg) as usize].clone())),
             Instruction::MakeFunction => {
                 let code = if let Some(StackValue::Code(code)) = self.stack.pop() {
                     code
@@ -134,6 +125,12 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
+            Instruction::ReturnConst(idx) => {
+                let idx = idx.get(arg);
+                self.stack.push(constants[idx as usize].clone().into());
+                return ControlFlow::Break(());
+            }
+            Instruction::ReturnValue => return ControlFlow::Break(()),
             Instruction::SetFunctionAttribute(attr) => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
@@ -164,13 +161,16 @@ impl StackMachine {
                     self.stack.push(StackValue::Function(func));
                 }
             }
-            Instruction::ReturnConst(idx) => {
+            Instruction::StoreAttr(_) => {
+                // Do nothing except throw away the stack values
+                self.stack.pop().unwrap();
+                self.stack.pop().unwrap();
+            }
+            Instruction::StoreLocal(idx) => {
                 let idx = idx.get(arg);
-                self.stack.push(constants[idx as usize].clone().into());
-                return ControlFlow::Break(());
+                self.locals
+                    .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
-            Instruction::ReturnValue => return ControlFlow::Break(()),
-            Instruction::ExtendedArg => {}
             _ => unimplemented!(
                 "instruction {:?} isn't yet supported in py_function!",
                 instruction

From 65797233e6246413a500af1e3056c756c7920acb Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 14:01:31 +0200
Subject: [PATCH 14/15] Fix docs

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

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 134b8b41f4..abf446f4b8 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -1310,7 +1310,7 @@ impl Instruction {
     ///
     /// ```
     /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
-    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
+    /// let jump_inst = Instruction::Jump(Arg::marker());
     /// assert!(jump_inst.unconditional_branch())
     /// ```
     pub const fn unconditional_branch(&self) -> bool {
@@ -1332,9 +1332,9 @@ impl Instruction {
     /// ```
     /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label, UnaryOperator};
     /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = Instruction::Jump { target };
+    /// let jump_instruction = Instruction::Jump(target);
     /// let (op, invert_arg) = Arg::new(UnaryOperator::Invert);
-    /// let invert_instruction = Instruction::UnaryOperation { op };
+    /// let invert_instruction = Instruction::UnaryOperation(op);
     /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
     /// assert_eq!(invert_instruction.stack_effect(invert_arg, false), 0);
     /// ```

From 85b17afdc97b382878fd82e81e61a51c9c4bd811 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 29 Nov 2025 15:12:13 +0200
Subject: [PATCH 15/15] Add comments

---
 crates/compiler-core/src/bytecode.rs | 88 ++++++++++++++--------------
 1 file changed, 44 insertions(+), 44 deletions(-)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index abf446f4b8..2890b27223 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -550,42 +550,42 @@ pub type NameIdx = u32;
 #[repr(u8)]
 pub enum Instruction {
     BeforeAsyncWith,
-    BinaryOperation(Arg<BinaryOperator>),
-    BinaryOperationInplace(Arg<BinaryOperator>),
+    BinaryOperation(Arg<BinaryOperator>),        // op
+    BinaryOperationInplace(Arg<BinaryOperator>), // op
     BinarySubscript,
-    Break(Arg<Label>),
-    BuildList(Arg<u32>),
-    BuildListFromTuples(Arg<u32>),
-    BuildMap(Arg<u32>),
-    BuildMapForCall(Arg<u32>),
-    BuildSet(Arg<u32>),
-    BuildSetFromTuples(Arg<u32>),
+    Break(Arg<Label>),             // target
+    BuildList(Arg<u32>),           // size
+    BuildListFromTuples(Arg<u32>), // size
+    BuildMap(Arg<u32>),            // size
+    BuildMapForCall(Arg<u32>),     // size
+    BuildSet(Arg<u32>),            // size
+    BuildSetFromTuples(Arg<u32>),  // size
     /// When holds `true` it will build a slice with a third step argument.
-    BuildSlice(Arg<bool>),
-    BuildString(Arg<u32>),
-    BuildTuple(Arg<u32>),
+    BuildSlice(Arg<bool>), // step
+    BuildString(Arg<u32>),         // size
+    BuildTuple(Arg<u32>),          // size
     BuildTupleFromIter,
-    BuildTupleFromTuples(Arg<u32>),
+    BuildTupleFromTuples(Arg<u32>), // size
     CallFunctionEx(Arg<bool>),
     CallFunctionKeyword(Arg<u32>),
     CallFunctionPositional(Arg<u32>),
     CallIntrinsic1(Arg<IntrinsicFunction1>),
     CallIntrinsic2(Arg<IntrinsicFunction2>),
-    CallMethodEx(Arg<bool>),
-    CallMethodKeyword(Arg<u32>),
-    CallMethodPositional(Arg<u32>),
-    CompareOperation(Arg<ComparisonOperator>),
+    CallMethodEx(Arg<bool>),                   // has_kwargs
+    CallMethodKeyword(Arg<u32>),               // nargs
+    CallMethodPositional(Arg<u32>),            // nargs
+    CompareOperation(Arg<ComparisonOperator>), // op
     /// Performs `in` comparison, or `not in` if `invert` is 1.
     ContainsOp(Arg<Invert>),
-    Continue(Arg<Label>),
-    CopyItem(Arg<u32>),
-    DeleteAttr(Arg<NameIdx>),
+    Continue(Arg<Label>),     // target
+    CopyItem(Arg<u32>),       // index
+    DeleteAttr(Arg<NameIdx>), // idx
     DeleteDeref(Arg<NameIdx>),
     DeleteFast(Arg<NameIdx>),
     DeleteGlobal(Arg<NameIdx>),
     DeleteLocal(Arg<NameIdx>),
     DeleteSubscript,
-    DictUpdate(Arg<u32>),
+    DictUpdate(Arg<u32>), // index
     EndAsyncFor,
     /// Marker bytecode for the end of a finally sequence.
     /// When this bytecode is executed, the eval loop does one of those things:
@@ -597,7 +597,7 @@ pub enum Instruction {
     /// Enter a finally block, without returning, excepting, just because we are there.
     EnterFinally,
     ExtendedArg,
-    ForIter(Arg<Label>),
+    ForIter(Arg<Label>), // target
     FormatValue(Arg<ConversionFlag>),
     GetAIter,
     GetANext,
@@ -605,35 +605,35 @@ pub enum Instruction {
     GetIter,
     GetLen,
     /// from ... import ...
-    ImportFrom(Arg<NameIdx>),
+    ImportFrom(Arg<NameIdx>), // idx
     /// Importing by name
-    ImportName(Arg<NameIdx>),
+    ImportName(Arg<NameIdx>), // idx
     /// Importing without name
     ImportNameless,
     /// Performs `is` comparison, or `is not` if `invert` is 1.
     IsOp(Arg<Invert>),
-    Jump(Arg<Label>),
+    Jump(Arg<Label>), // target
     /// Peek at the top of the stack, and jump if this value is false.
     /// Otherwise, pop top of stack.
-    JumpIfFalseOrPop(Arg<Label>),
+    JumpIfFalseOrPop(Arg<Label>), // target
     /// Performs exception matching for except.
     /// Tests whether the STACK[-2] is an exception matching STACK[-1].
     /// Pops STACK[-1] and pushes the boolean result of the test.
-    JumpIfNotExcMatch(Arg<Label>),
+    JumpIfNotExcMatch(Arg<Label>), // target
     /// Peek at the top of the stack, and jump if this value is true.
     /// Otherwise, pop top of stack.
-    JumpIfTrueOrPop(Arg<Label>),
+    JumpIfTrueOrPop(Arg<Label>), // target
     ListAppend(Arg<u32>),
-    LoadAttr(Arg<NameIdx>),
+    LoadAttr(Arg<NameIdx>), // idx
     LoadBuildClass,
     LoadClassDeref(Arg<NameIdx>),
     LoadClosure(Arg<NameIdx>),
     /// Holds an index into constants vec.
-    LoadConst(Arg<u32>),
+    LoadConst(Arg<u32>), // idx
     LoadDeref(Arg<NameIdx>),
     LoadFast(Arg<NameIdx>),
     LoadGlobal(Arg<NameIdx>),
-    LoadMethod(Arg<NameIdx>),
+    LoadMethod(Arg<NameIdx>), // idx
     LoadNameAny(Arg<NameIdx>),
     MakeFunction,
     MapAdd(Arg<u32>),
@@ -646,40 +646,40 @@ pub enum Instruction {
     PopBlock,
     PopException,
     /// Pop the top of the stack, and jump if this value is false.
-    PopJumpIfFalse(Arg<Label>),
+    PopJumpIfFalse(Arg<Label>), // target
     /// Pop the top of the stack, and jump if this value is true.
-    PopJumpIfTrue(Arg<Label>),
+    PopJumpIfTrue(Arg<Label>), // target
     PrintExpr,
     Raise(Arg<RaiseKind>),
     /// Resume execution (e.g., at function start, after yield, etc.)
     Resume(Arg<u32>),
-    ReturnConst(Arg<u32>),
+    ReturnConst(Arg<u32>), // idx
     ReturnValue,
-    Reverse(Arg<u32>),
+    Reverse(Arg<u32>), // amount
     SetAdd(Arg<u32>),
-    SetFunctionAttribute(Arg<MakeFunctionFlags>),
+    SetFunctionAttribute(Arg<MakeFunctionFlags>), // attr
     SetupAnnotation,
-    SetupAsyncWith(Arg<Label>),
-    SetupExcept(Arg<Label>),
+    SetupAsyncWith(Arg<Label>), // end
+    SetupExcept(Arg<Label>),    // handler
     /// Setup a finally handler, which will be called whenever one of this events occurs:
     /// - the block is popped
     /// - the function returns
     /// - an exception is returned
-    SetupFinally(Arg<Label>),
+    SetupFinally(Arg<Label>), // handler
     SetupLoop,
-    SetupWith(Arg<Label>),
-    StoreAttr(Arg<NameIdx>),
+    SetupWith(Arg<Label>),   // end
+    StoreAttr(Arg<NameIdx>), // idx
     StoreDeref(Arg<NameIdx>),
     StoreFast(Arg<NameIdx>),
     StoreGlobal(Arg<NameIdx>),
     StoreLocal(Arg<NameIdx>),
     StoreSubscript,
     Subscript,
-    Swap(Arg<u32>),
+    Swap(Arg<u32>), // index
     ToBool,
     UnaryOperation(Arg<UnaryOperator>),
-    UnpackEx(Arg<UnpackExArgs>),
-    UnpackSequence(Arg<u32>),
+    UnpackEx(Arg<UnpackExArgs>), // args
+    UnpackSequence(Arg<u32>),    // size
     WithCleanupFinish,
     WithCleanupStart,
     YieldFrom,