Fix opcode.rs

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