From afde078a1e31a2c6f275626fc89dcfa75b3fa223 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 3 Feb 2026 10:30:48 +0200
Subject: [PATCH 1/4] Use `num_enum` crate for oparg types

---
 Cargo.lock                                    |   1 +
 crates/compiler-core/Cargo.toml               |   1 +
 .../compiler-core/src/bytecode/instruction.rs |   6 +-
 crates/compiler-core/src/bytecode/oparg.rs    | 609 ++++++++----------
 4 files changed, 282 insertions(+), 335 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 480207932ae..ee6419bd262 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3162,6 +3162,7 @@ dependencies = [
  "lz4_flex",
  "malachite-bigint",
  "num-complex",
+ "num_enum",
  "ruff_source_file",
  "rustpython-wtf8",
 ]
diff --git a/crates/compiler-core/Cargo.toml b/crates/compiler-core/Cargo.toml
index f4e619b95a4..6a03f02c24f 100644
--- a/crates/compiler-core/Cargo.toml
+++ b/crates/compiler-core/Cargo.toml
@@ -17,6 +17,7 @@ bitflags = { workspace = true }
 itertools = { workspace = true }
 malachite-bigint = { workspace = true }
 num-complex = { workspace = true }
+num_enum = { workspace = true }
 
 lz4_flex = "0.12"
 
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index ee36220b538..99080c95a68 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -1247,7 +1247,7 @@ impl<T: OpArgType> Arg<T> {
 
     #[inline]
     pub fn new(arg: T) -> (Self, OpArg) {
-        (Self(PhantomData), OpArg(arg.to_op_arg()))
+        (Self(PhantomData), OpArg(arg.into()))
     }
 
     #[inline]
@@ -1265,7 +1265,7 @@ impl<T: OpArgType> Arg<T> {
 
     #[inline(always)]
     pub fn try_get(self, arg: OpArg) -> Result<T, MarshalError> {
-        T::from_op_arg(arg.0)
+        T::try_from(arg.0).map_err(|_| MarshalError::InvalidBytecode)
     }
 
     /// # Safety
@@ -1273,7 +1273,7 @@ impl<T: OpArgType> Arg<T> {
     #[inline(always)]
     pub unsafe fn get_unchecked(self, arg: OpArg) -> T {
         // SAFETY: requirements forwarded from caller
-        unsafe { T::from_op_arg(arg.0).unwrap_unchecked() }
+        unsafe { T::try_from(arg.0).unwrap_unchecked() }
     }
 }
 
diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index 724fd6fcd10..c8125d7aaec 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -1,17 +1,14 @@
 use bitflags::bitflags;
+use num_enum::{IntoPrimitive, TryFromPrimitive};
 
-use core::{fmt, num::NonZeroU8};
+use core::fmt;
 
 use crate::{
     bytecode::{CodeUnit, instruction::Instruction},
     marshal::MarshalError,
 };
 
-pub trait OpArgType: Copy {
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError>;
-
-    fn to_op_arg(self) -> u32;
-}
+pub trait OpArgType: Copy + Into<u32> + TryFrom<u32> {}
 
 /// Opcode argument that may be extended by a prior ExtendedArg.
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -112,8 +109,9 @@ impl OpArgState {
 /// ## See also
 ///
 /// - [CPython FVC_* flags](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Include/ceval.h#L129-L132)
-#[repr(u8)]
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Eq, Hash, IntoPrimitive, PartialEq, TryFromPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+#[repr(u32)]
 pub enum ConvertValueOparg {
     /// No conversion.
     ///
@@ -121,6 +119,8 @@ pub enum ConvertValueOparg {
     /// f"{x}"
     /// f"{x:4}"
     /// ```
+    // Ruff `ConversionFlag::None` is `-1i8`, when its converted to `u8` its value is `u8::MAX`.
+    #[num_enum(alternatives = [255])]
     None = 0,
     /// Converts by calling `str(<value>)`.
     ///
@@ -159,28 +159,11 @@ impl fmt::Display for ConvertValueOparg {
     }
 }
 
-impl OpArgType for ConvertValueOparg {
-    #[inline]
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-        Ok(match x {
-            // Ruff `ConversionFlag::None` is `-1i8`,
-            // when its converted to `u8` its value is `u8::MAX`
-            0 | 255 => Self::None,
-            1 => Self::Str,
-            2 => Self::Repr,
-            3 => Self::Ascii,
-            _ => return Err(MarshalError::InvalidBytecode),
-        })
-    }
-
-    #[inline]
-    fn to_op_arg(self) -> u32 {
-        self as u32
-    }
-}
+impl OpArgType for ConvertValueOparg {}
 
 /// Resume type for the RESUME instruction
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, IntoPrimitive, TryFromPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 #[repr(u32)]
 pub enum ResumeType {
     AtFuncStart = 0,
@@ -189,145 +172,105 @@ pub enum ResumeType {
     AfterAwait = 3,
 }
 
-impl OpArgType for u32 {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-        Ok(x)
-    }
+pub type NameIdx = u32;
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self
+impl OpArgType for u32 {}
+//impl OpArgType for bool {}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+#[repr(transparent)]
+pub struct Label(pub u32);
+
+impl Label {
+    pub const fn new(value: u32) -> Self {
+        Self(value)
     }
 }
 
-impl OpArgType for bool {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-        Ok(x != 0)
+impl From<u32> for Label {
+    fn from(value: u32) -> Self {
+        Self::new(value)
     }
+}
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self as u32
+impl From<Label> for u32 {
+    fn from(value: Label) -> Self {
+        value.0
     }
 }
 
-macro_rules! op_arg_enum_impl {
-    (enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
-        impl OpArgType for $name {
-            fn to_op_arg(self) -> u32 {
-                self as u32
-            }
+impl OpArgType for Label {}
 
-            fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-                Ok(match u8::try_from(x).map_err(|_| MarshalError::InvalidBytecode)? {
-                    $($value => Self::$var,)*
-                    _ => return Err(MarshalError::InvalidBytecode),
-                })
-            }
-        }
-    };
+impl fmt::Display for Label {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
 }
 
-macro_rules! op_arg_enum {
-    ($(#[$attr:meta])* $vis:vis enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
-        $(#[$attr])*
-        $vis enum $name {
-            $($(#[$var_attr])* $var = $value,)*
-        }
-
-        op_arg_enum_impl!(enum $name {
-            $($(#[$var_attr])* $var = $value,)*
-        });
-    };
+/// The kind of Raise that occurred.
+#[derive(Copy, Clone, Debug, PartialEq, TryFromPrimitive, IntoPrimitive, Eq)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+#[repr(u32)]
+pub enum RaiseKind {
+    /// Bare `raise` statement with no arguments.
+    /// Gets the current exception from VM state (topmost_exception).
+    /// Maps to RAISE_VARARGS with oparg=0.
+    BareRaise = 0,
+    /// `raise exc` - exception is on the stack.
+    /// Maps to RAISE_VARARGS with oparg=1.
+    Raise = 1,
+    /// `raise exc from cause` - exception and cause are on the stack.
+    /// Maps to RAISE_VARARGS with oparg=2.
+    RaiseCause = 2,
+    /// Reraise exception from the stack top.
+    /// Used in exception handler cleanup blocks (finally, except).
+    /// Gets exception from stack, not from VM state.
+    /// Maps to the RERAISE opcode.
+    ReraiseFromStack = 3,
 }
 
-pub type NameIdx = u32;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
-#[repr(transparent)]
-pub struct Label(pub u32);
-
-impl OpArgType for Label {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-        Ok(Self(x))
-    }
+impl OpArgType for RaiseKind {}
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self.0
-    }
+/// Intrinsic function for CALL_INTRINSIC_1
+#[derive(Copy, Clone, Debug, PartialEq, Eq, IntoPrimitive, TryFromPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+#[repr(u32)]
+pub enum IntrinsicFunction1 {
+    // Invalid = 0,
+    Print = 1,
+    /// Import * operation
+    ImportStar = 2,
+    /// Convert StopIteration to RuntimeError in async context
+    StopIterationError = 3,
+    AsyncGenWrap = 4,
+    UnaryPositive = 5,
+    /// Convert list to tuple
+    ListToTuple = 6,
+    /// Type parameter related
+    TypeVar = 7,
+    ParamSpec = 8,
+    TypeVarTuple = 9,
+    /// Generic subscript for PEP 695
+    SubscriptGeneric = 10,
+    TypeAlias = 11,
 }
 
-impl fmt::Display for Label {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
+impl OpArgType for IntrinsicFunction1 {}
+
+/// Intrinsic function for CALL_INTRINSIC_2
+#[derive(Copy, Clone, Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+#[repr(u32)]
+pub enum IntrinsicFunction2 {
+    PrepReraiseStar = 1,
+    TypeVarWithBound = 2,
+    TypeVarWithConstraint = 3,
+    SetFunctionTypeParams = 4,
+    /// Set default value for type parameter (PEP 695)
+    SetTypeparamDefault = 5,
 }
 
-op_arg_enum!(
-    /// The kind of Raise that occurred.
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum RaiseKind {
-        /// Bare `raise` statement with no arguments.
-        /// Gets the current exception from VM state (topmost_exception).
-        /// Maps to RAISE_VARARGS with oparg=0.
-        BareRaise = 0,
-        /// `raise exc` - exception is on the stack.
-        /// Maps to RAISE_VARARGS with oparg=1.
-        Raise = 1,
-        /// `raise exc from cause` - exception and cause are on the stack.
-        /// Maps to RAISE_VARARGS with oparg=2.
-        RaiseCause = 2,
-        /// Reraise exception from the stack top.
-        /// Used in exception handler cleanup blocks (finally, except).
-        /// Gets exception from stack, not from VM state.
-        /// Maps to the RERAISE opcode.
-        ReraiseFromStack = 3,
-    }
-);
-
-op_arg_enum!(
-    /// Intrinsic function for CALL_INTRINSIC_1
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum IntrinsicFunction1 {
-        // Invalid = 0,
-        Print = 1,
-        /// Import * operation
-        ImportStar = 2,
-        /// Convert StopIteration to RuntimeError in async context
-        StopIterationError = 3,
-        AsyncGenWrap = 4,
-        UnaryPositive = 5,
-        /// Convert list to tuple
-        ListToTuple = 6,
-        /// Type parameter related
-        TypeVar = 7,
-        ParamSpec = 8,
-        TypeVarTuple = 9,
-        /// Generic subscript for PEP 695
-        SubscriptGeneric = 10,
-        TypeAlias = 11,
-    }
-);
-
-op_arg_enum!(
-    /// Intrinsic function for CALL_INTRINSIC_2
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum IntrinsicFunction2 {
-        PrepReraiseStar = 1,
-        TypeVarWithBound = 2,
-        TypeVarWithConstraint = 3,
-        SetFunctionTypeParams = 4,
-        /// Set default value for type parameter (PEP 695)
-        SetTypeparamDefault = 5,
-    }
-);
+impl OpArgType for IntrinsicFunction2 {}
 
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
@@ -342,106 +285,110 @@ bitflags! {
     }
 }
 
-impl OpArgType for MakeFunctionFlags {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-        Self::from_bits(x as u8).ok_or(MarshalError::InvalidBytecode)
-    }
+impl TryFrom<u32> for MakeFunctionFlags {
+    type Error = MarshalError;
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self.bits().into()
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        Self::from_bits(value as u8).ok_or(Self::Error::InvalidBytecode)
     }
 }
 
-op_arg_enum!(
-    /// The possible comparison operators
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum ComparisonOperator {
-        // be intentional with bits so that we can do eval_ord with just a bitwise and
-        // bits: | Equal | Greater | Less |
-        Less = 0b001,
-        Greater = 0b010,
-        NotEqual = 0b011,
-        Equal = 0b100,
-        LessOrEqual = 0b101,
-        GreaterOrEqual = 0b110,
+impl From<MakeFunctionFlags> for u32 {
+    fn from(value: MakeFunctionFlags) -> Self {
+        value.bits().into()
     }
-);
+}
 
-op_arg_enum!(
-    /// The possible Binary operators
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
-    /// let (op, _) = Arg::new(BinaryOperator::Add);
-    /// let instruction = Instruction::BinaryOp { op };
-    /// ```
-    ///
-    /// See also:
-    /// - [_PyEval_BinaryOps](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Python/ceval.c#L316-L343)
-    #[repr(u8)]
-    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-    pub enum BinaryOperator {
-        /// `+`
-        Add = 0,
-        /// `&`
-        And = 1,
-        /// `//`
-        FloorDivide = 2,
-        /// `<<`
-        Lshift = 3,
-        /// `@`
-        MatrixMultiply = 4,
-        /// `*`
-        Multiply = 5,
-        /// `%`
-        Remainder = 6,
-        /// `|`
-        Or = 7,
-        /// `**`
-        Power = 8,
-        /// `>>`
-        Rshift = 9,
-        /// `-`
-        Subtract = 10,
-        /// `/`
-        TrueDivide = 11,
-        /// `^`
-        Xor = 12,
-        /// `+=`
-        InplaceAdd = 13,
-        /// `&=`
-        InplaceAnd = 14,
-        /// `//=`
-        InplaceFloorDivide = 15,
-        /// `<<=`
-        InplaceLshift = 16,
-        /// `@=`
-        InplaceMatrixMultiply = 17,
-        /// `*=`
-        InplaceMultiply = 18,
-        /// `%=`
-        InplaceRemainder = 19,
-        /// `|=`
-        InplaceOr = 20,
-        /// `**=`
-        InplacePower = 21,
-        /// `>>=`
-        InplaceRshift = 22,
-        /// `-=`
-        InplaceSubtract = 23,
-        /// `/=`
-        InplaceTrueDivide = 24,
-        /// `^=`
-        InplaceXor = 25,
-        /// `[]` subscript
-        Subscr = 26,
-    }
-);
+impl OpArgType for MakeFunctionFlags {}
+
+/// The possible comparison operators
+#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+#[repr(u32)]
+pub enum ComparisonOperator {
+    // be intentional with bits so that we can do eval_ord with just a bitwise and
+    // bits: | Equal | Greater | Less |
+    Less = 0b001,
+    Greater = 0b010,
+    NotEqual = 0b011,
+    Equal = 0b100,
+    LessOrEqual = 0b101,
+    GreaterOrEqual = 0b110,
+}
+
+impl OpArgType for ComparisonOperator {}
+
+/// The possible Binary operators
+///
+/// # Examples
+///
+/// ```rust
+/// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
+/// let (op, _) = Arg::new(BinaryOperator::Add);
+/// let instruction = Instruction::BinaryOp { op };
+/// ```
+///
+/// See also:
+/// - [_PyEval_BinaryOps](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Python/ceval.c#L316-L343)
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+pub enum BinaryOperator {
+    /// `+`
+    Add = 0,
+    /// `&`
+    And = 1,
+    /// `//`
+    FloorDivide = 2,
+    /// `<<`
+    Lshift = 3,
+    /// `@`
+    MatrixMultiply = 4,
+    /// `*`
+    Multiply = 5,
+    /// `%`
+    Remainder = 6,
+    /// `|`
+    Or = 7,
+    /// `**`
+    Power = 8,
+    /// `>>`
+    Rshift = 9,
+    /// `-`
+    Subtract = 10,
+    /// `/`
+    TrueDivide = 11,
+    /// `^`
+    Xor = 12,
+    /// `+=`
+    InplaceAdd = 13,
+    /// `&=`
+    InplaceAnd = 14,
+    /// `//=`
+    InplaceFloorDivide = 15,
+    /// `<<=`
+    InplaceLshift = 16,
+    /// `@=`
+    InplaceMatrixMultiply = 17,
+    /// `*=`
+    InplaceMultiply = 18,
+    /// `%=`
+    InplaceRemainder = 19,
+    /// `|=`
+    InplaceOr = 20,
+    /// `**=`
+    InplacePower = 21,
+    /// `>>=`
+    InplaceRshift = 22,
+    /// `-=`
+    InplaceSubtract = 23,
+    /// `/=`
+    InplaceTrueDivide = 24,
+    /// `^=`
+    InplaceXor = 25,
+    /// `[]` subscript
+    Subscr = 26,
+}
 
 impl BinaryOperator {
     /// Get the "inplace" version of the operator.
@@ -476,6 +423,8 @@ impl BinaryOperator {
     }
 }
 
+impl OpArgType for BinaryOperator {}
+
 impl fmt::Display for BinaryOperator {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let op = match self {
@@ -511,39 +460,41 @@ impl fmt::Display for BinaryOperator {
     }
 }
 
-op_arg_enum!(
-    /// Whether or not to invert the operation.
-    #[repr(u8)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum Invert {
-        /// ```py
-        /// foo is bar
-        /// x in lst
-        /// ```
-        No = 0,
-        /// ```py
-        /// foo is not bar
-        /// x not in lst
-        /// ```
-        Yes = 1,
-    }
-);
-
-op_arg_enum!(
-    /// Special method for LOAD_SPECIAL opcode (context managers).
-    #[repr(u8)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum SpecialMethod {
-        /// `__enter__` for sync context manager
-        Enter = 0,
-        /// `__exit__` for sync context manager
-        Exit = 1,
-        /// `__aenter__` for async context manager
-        AEnter = 2,
-        /// `__aexit__` for async context manager
-        AExit = 3,
-    }
-);
+/// Whether or not to invert the operation.
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+pub enum Invert {
+    /// ```py
+    /// foo is bar
+    /// x in lst
+    /// ```
+    No = 0,
+    /// ```py
+    /// foo is not bar
+    /// x not in lst
+    /// ```
+    Yes = 1,
+}
+
+impl OpArgType for Invert {}
+
+/// Special method for LOAD_SPECIAL opcode (context managers).
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+pub enum SpecialMethod {
+    /// `__enter__` for sync context manager
+    Enter = 0,
+    /// `__exit__` for sync context manager
+    Exit = 1,
+    /// `__aenter__` for async context manager
+    AEnter = 2,
+    /// `__aexit__` for async context manager
+    AExit = 3,
+}
+
+impl OpArgType for SpecialMethod {}
 
 impl fmt::Display for SpecialMethod {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -557,24 +508,25 @@ impl fmt::Display for SpecialMethod {
     }
 }
 
-op_arg_enum!(
-    /// Common constants for LOAD_COMMON_CONSTANT opcode.
-    /// pycore_opcode_utils.h CONSTANT_*
-    #[repr(u8)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum CommonConstant {
-        /// `AssertionError` exception type
-        AssertionError = 0,
-        /// `NotImplementedError` exception type
-        NotImplementedError = 1,
-        /// Built-in `tuple` type
-        BuiltinTuple = 2,
-        /// Built-in `all` function
-        BuiltinAll = 3,
-        /// Built-in `any` function
-        BuiltinAny = 4,
-    }
-);
+/// Common constants for LOAD_COMMON_CONSTANT opcode.
+/// pycore_opcode_utils.h CONSTANT_*
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+pub enum CommonConstant {
+    /// `AssertionError` exception type
+    AssertionError = 0,
+    /// `NotImplementedError` exception type
+    NotImplementedError = 1,
+    /// Built-in `tuple` type
+    BuiltinTuple = 2,
+    /// Built-in `all` function
+    BuiltinAll = 3,
+    /// Built-in `any` function
+    BuiltinAny = 4,
+}
+
+impl OpArgType for CommonConstant {}
 
 impl fmt::Display for CommonConstant {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -590,46 +542,21 @@ impl fmt::Display for CommonConstant {
 }
 
 /// Specifies if a slice is built with either 2 or 3 arguments.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive)]
+#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 pub enum BuildSliceArgCount {
     /// ```py
     /// x[5:10]
     /// ```
-    Two,
+    Two = 2,
     /// ```py
     /// x[5:10:2]
     /// ```
-    Three,
+    Three = 3,
 }
 
-impl OpArgType for BuildSliceArgCount {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-        Ok(match x {
-            2 => Self::Two,
-            3 => Self::Three,
-            _ => return Err(MarshalError::InvalidBytecode),
-        })
-    }
-
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        u32::from(self.argc().get())
-    }
-}
-
-impl BuildSliceArgCount {
-    /// Get the numeric value of `Self`.
-    #[must_use]
-    pub const fn argc(self) -> NonZeroU8 {
-        let inner = match self {
-            Self::Two => 2,
-            Self::Three => 3,
-        };
-        // Safety: `inner` can be either 2 or 3.
-        unsafe { NonZeroU8::new_unchecked(inner) }
-    }
-}
+impl OpArgType for BuildSliceArgCount {}
 
 #[derive(Copy, Clone)]
 pub struct UnpackExArgs {
@@ -637,21 +564,39 @@ pub struct UnpackExArgs {
     pub after: u8,
 }
 
-impl OpArgType for UnpackExArgs {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Result<Self, MarshalError> {
-        let [before, after, ..] = x.to_le_bytes();
-        Ok(Self { before, after })
+impl From<u32> for UnpackExArgs {
+    fn from(value: u32) -> Self {
+        let [before, after, ..] = value.to_le_bytes();
+        Self { before, after }
     }
+}
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        u32::from_le_bytes([self.before, self.after, 0, 0])
+impl From<UnpackExArgs> for u32 {
+    fn from(value: UnpackExArgs) -> Self {
+        Self::from_le_bytes([value.before, value.after, 0, 0])
     }
 }
 
+impl OpArgType for UnpackExArgs {}
+
 impl fmt::Display for UnpackExArgs {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "before: {}, after: {}", self.before, self.after)
     }
 }
+
+/// Helper function for `num_enum` derive macro.
+///
+/// # Examples
+///
+/// ```rust
+/// #[derive(TryFromPrimitive)]
+/// #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+/// #[repr(u8)]
+/// enum Foo {
+///   A = 1,
+///   B = 2
+/// }
+fn new_invalid_bytecode<T>(_: T) -> MarshalError {
+    MarshalError::InvalidBytecode
+}

From e7616e51fd2f13663bc6d83bb64dbbd768280dab Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 3 Feb 2026 12:30:09 +0200
Subject: [PATCH 2/4] Fix doctest

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

diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index c8125d7aaec..679838f5a65 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -589,7 +589,11 @@ impl fmt::Display for UnpackExArgs {
 ///
 /// # Examples
 ///
-/// ```rust
+/// ```ignore
+/// use num_enum::TryFromPrimitive;
+///
+/// use rustpython_compiler_core::marshal::MarshalError;
+///
 /// #[derive(TryFromPrimitive)]
 /// #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 /// #[repr(u8)]

From 8c6ee34cc723a187ef573ed32d7c361b338a3779 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 5 Feb 2026 13:51:18 +0200
Subject: [PATCH 3/4] Make opargs `#[repr(u8)]`

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

diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index 679838f5a65..35231c59574 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -104,14 +104,34 @@ impl OpArgState {
     }
 }
 
+macro_rules! impl_oparg_enum_traits {
+    ($name:ty) => {
+        impl From<$name> for u32 {
+            fn from(value: $name) -> Self {
+                Self::from(u8::from(value))
+            }
+        }
+
+        impl TryFrom<u32> for $name {
+            type Error = $crate::marshal::MarshalError;
+
+            fn try_from(value: u32) -> Result<Self, Self::Error> {
+                u8::try_from(value)
+                    .map_err(|_| Self::Error::InvalidBytecode)
+                    .map(TryInto::try_into)?
+            }
+        }
+    };
+}
+
 /// Oparg values for [`Instruction::ConvertValue`].
 ///
 /// ## See also
 ///
 /// - [CPython FVC_* flags](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Include/ceval.h#L129-L132)
+#[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, Hash, IntoPrimitive, PartialEq, TryFromPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
-#[repr(u32)]
 pub enum ConvertValueOparg {
     /// No conversion.
     ///
@@ -145,6 +165,8 @@ pub enum ConvertValueOparg {
     Ascii = 3,
 }
 
+impl_oparg_enum_traits!(ConvertValueOparg);
+
 impl fmt::Display for ConvertValueOparg {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let out = match self {
@@ -162,9 +184,9 @@ impl fmt::Display for ConvertValueOparg {
 impl OpArgType for ConvertValueOparg {}
 
 /// Resume type for the RESUME instruction
+#[repr(u8)]
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, IntoPrimitive, TryFromPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
-#[repr(u32)]
 pub enum ResumeType {
     AtFuncStart = 0,
     AfterYield = 1,
@@ -208,9 +230,9 @@ impl fmt::Display for Label {
 }
 
 /// The kind of Raise that occurred.
+#[repr(u8)]
 #[derive(Copy, Clone, Debug, PartialEq, TryFromPrimitive, IntoPrimitive, Eq)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
-#[repr(u32)]
 pub enum RaiseKind {
     /// Bare `raise` statement with no arguments.
     /// Gets the current exception from VM state (topmost_exception).
@@ -229,12 +251,13 @@ pub enum RaiseKind {
     ReraiseFromStack = 3,
 }
 
+impl_oparg_enum_traits!(RaiseKind);
 impl OpArgType for RaiseKind {}
 
 /// Intrinsic function for CALL_INTRINSIC_1
+#[repr(u8)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, IntoPrimitive, TryFromPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
-#[repr(u32)]
 pub enum IntrinsicFunction1 {
     // Invalid = 0,
     Print = 1,
@@ -255,12 +278,13 @@ pub enum IntrinsicFunction1 {
     TypeAlias = 11,
 }
 
+impl_oparg_enum_traits!(IntrinsicFunction1);
 impl OpArgType for IntrinsicFunction1 {}
 
 /// Intrinsic function for CALL_INTRINSIC_2
+#[repr(u8)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
-#[repr(u32)]
 pub enum IntrinsicFunction2 {
     PrepReraiseStar = 1,
     TypeVarWithBound = 2,
@@ -270,6 +294,7 @@ pub enum IntrinsicFunction2 {
     SetTypeparamDefault = 5,
 }
 
+impl_oparg_enum_traits!(IntrinsicFunction2);
 impl OpArgType for IntrinsicFunction2 {}
 
 bitflags! {
@@ -301,10 +326,10 @@ impl From<MakeFunctionFlags> for u32 {
 
 impl OpArgType for MakeFunctionFlags {}
 
-/// The possible comparison operators
+/// The possible comparison operators.
+#[repr(u8)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
-#[repr(u32)]
 pub enum ComparisonOperator {
     // be intentional with bits so that we can do eval_ord with just a bitwise and
     // bits: | Equal | Greater | Less |
@@ -316,6 +341,7 @@ pub enum ComparisonOperator {
     GreaterOrEqual = 0b110,
 }
 
+impl_oparg_enum_traits!(ComparisonOperator);
 impl OpArgType for ComparisonOperator {}
 
 /// The possible Binary operators
@@ -330,7 +356,7 @@ impl OpArgType for ComparisonOperator {}
 ///
 /// See also:
 /// - [_PyEval_BinaryOps](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Python/ceval.c#L316-L343)
-#[repr(u32)]
+#[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 pub enum BinaryOperator {
@@ -423,6 +449,7 @@ impl BinaryOperator {
     }
 }
 
+impl_oparg_enum_traits!(BinaryOperator);
 impl OpArgType for BinaryOperator {}
 
 impl fmt::Display for BinaryOperator {
@@ -461,7 +488,7 @@ impl fmt::Display for BinaryOperator {
 }
 
 /// Whether or not to invert the operation.
-#[repr(u32)]
+#[repr(u8)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 pub enum Invert {
@@ -477,10 +504,11 @@ pub enum Invert {
     Yes = 1,
 }
 
+impl_oparg_enum_traits!(Invert);
 impl OpArgType for Invert {}
 
 /// Special method for LOAD_SPECIAL opcode (context managers).
-#[repr(u32)]
+#[repr(u8)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 pub enum SpecialMethod {
@@ -494,6 +522,7 @@ pub enum SpecialMethod {
     AExit = 3,
 }
 
+impl_oparg_enum_traits!(SpecialMethod);
 impl OpArgType for SpecialMethod {}
 
 impl fmt::Display for SpecialMethod {
@@ -510,7 +539,7 @@ impl fmt::Display for SpecialMethod {
 
 /// Common constants for LOAD_COMMON_CONSTANT opcode.
 /// pycore_opcode_utils.h CONSTANT_*
-#[repr(u32)]
+#[repr(u8)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 pub enum CommonConstant {
@@ -526,6 +555,7 @@ pub enum CommonConstant {
     BuiltinAny = 4,
 }
 
+impl_oparg_enum_traits!(CommonConstant);
 impl OpArgType for CommonConstant {}
 
 impl fmt::Display for CommonConstant {
@@ -542,7 +572,7 @@ impl fmt::Display for CommonConstant {
 }
 
 /// Specifies if a slice is built with either 2 or 3 arguments.
-#[repr(u32)]
+#[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive)]
 #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
 pub enum BuildSliceArgCount {
@@ -556,6 +586,8 @@ pub enum BuildSliceArgCount {
     Three = 3,
 }
 
+impl_oparg_enum_traits!(BuildSliceArgCount);
+
 impl OpArgType for BuildSliceArgCount {}
 
 #[derive(Copy, Clone)]
@@ -594,9 +626,9 @@ impl fmt::Display for UnpackExArgs {
 ///
 /// use rustpython_compiler_core::marshal::MarshalError;
 ///
+/// #[repr(u8)]
 /// #[derive(TryFromPrimitive)]
 /// #[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
-/// #[repr(u8)]
 /// enum Foo {
 ///   A = 1,
 ///   B = 2

From c1f1d7a8a47e2c0b5e2ec69baa3a0d08732895ad Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 5 Feb 2026 23:50:59 +0200
Subject: [PATCH 4/4] BuildSliceArgCount optimized

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

diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index c0f5b82c47b..7d2fca03988 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -572,21 +572,48 @@ impl fmt::Display for CommonConstant {
 }
 
 /// Specifies if a slice is built with either 2 or 3 arguments.
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive)]
-#[num_enum(error_type(name = MarshalError, constructor = new_invalid_bytecode))]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum BuildSliceArgCount {
     /// ```py
     /// x[5:10]
     /// ```
-    Two = 2,
+    Two,
     /// ```py
     /// x[5:10:2]
     /// ```
-    Three = 3,
+    Three,
 }
 
-impl_oparg_enum_traits!(BuildSliceArgCount);
+impl TryFrom<u8> for BuildSliceArgCount {
+    type Error = MarshalError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(match value {
+            2 => Self::Two,
+            3 => Self::Three,
+            _ => return Err(Self::Error::InvalidBytecode),
+        })
+    }
+}
+
+impl TryFrom<u32> for BuildSliceArgCount {
+    type Error = MarshalError;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        u8::try_from(value)
+            .map_err(|_| Self::Error::InvalidBytecode)
+            .map(TryInto::try_into)?
+    }
+}
+
+impl From<BuildSliceArgCount> for u32 {
+    fn from(value: BuildSliceArgCount) -> Self {
+        match value {
+            BuildSliceArgCount::Two => 2,
+            BuildSliceArgCount::Three => 3,
+        }
+    }
+}
 
 impl OpArgType for BuildSliceArgCount {}