Fix test__opcode.py

ShaharNaveh · ShaharNaveh · commit 5f8f38d2bdcc · 2026-03-17T14:23:38.000+01:00
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
@@ -38,7 +38,6 @@ def test_is_valid(self):
         opcodes = [dis.opmap[opname] for opname in names]
         self.check_bool_function_result(_opcode.is_valid, opcodes, True)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; KeyError: 'BINARY_OP_ADD_INT'
     def test_opmaps(self):
         def check_roundtrip(name, map):
             return self.assertEqual(opcode.opname[map[name]], name)
@@ -116,7 +115,6 @@ def test_stack_effect_jump(self):
 
 
 class SpecializationStatsTests(unittest.TestCase):
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'load_attr' not found in []
     def test_specialization_stats(self):
         stat_names = ["success", "failure", "hit", "deferred", "miss", "deopt"]
         specialized_opcodes = [
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
@@ -462,7 +462,7 @@ impl TryFrom<u8> for Instruction {
 impl Instruction {
     /// Returns `true` if this is any instrumented opcode
     /// (regular INSTRUMENTED_*, INSTRUMENTED_LINE, or INSTRUMENTED_INSTRUCTION).
-    pub fn is_instrumented(self) -> bool {
+    pub const fn is_instrumented(self) -> bool {
         self.to_base().is_some()
             || matches!(self, Self::InstrumentedLine | Self::InstrumentedInstruction)
     }
@@ -509,7 +509,7 @@ impl Instruction {
     ///
     /// The returned base opcode uses `Arg::marker()` for typed fields —
     /// only the opcode byte matters since `replace_op` preserves the arg byte.
-    pub fn to_base(self) -> Option<Self> {
+    pub const fn to_base(self) -> Option<Self> {
         Some(match self {
             Self::InstrumentedResume => Self::Resume {
                 context: Arg::marker(),
@@ -555,11 +555,10 @@ impl Instruction {
             _ => return None,
         })
     }
-
-    /// Map a specialized opcode back to its adaptive (base) variant.
+    /// Map a specialized or instrumented opcode back to its adaptive (base) variant.
     /// `_PyOpcode_Deopt`
-    pub fn deoptimize(self) -> Self {
-        match self {
+    pub const fn deopt(self) -> Option<Self> {
+        Some(match self {
             // RESUME specializations
             Self::ResumeCheck => Self::Resume {
                 context: Arg::marker(),
@@ -678,17 +677,27 @@ impl Instruction {
             Self::CallKwBoundMethod | Self::CallKwPy | Self::CallKwNonPy => Self::CallKw {
                 argc: Arg::marker(),
             },
-            // Instrumented opcodes map back to their base
-            _ => match self.to_base() {
-                Some(base) => base,
-                None => self,
-            },
+            _ => return None,
+        })
+    }
+
+    /// Map a specialized opcode back to its adaptive (base) variant.
+    pub const fn deoptimize(self) -> Self {
+        match self.deopt() {
+            Some(v) => v,
+            None => {
+                // Instrumented opcodes map back to their base
+                match self.to_base() {
+                    Some(v) => v,
+                    None => self,
+                }
+            }
         }
     }
 
     /// Number of CACHE code units that follow this instruction.
     /// _PyOpcode_Caches
-    pub fn cache_entries(self) -> usize {
+    pub const fn cache_entries(self) -> usize {
         match self {
             // LOAD_ATTR: 9 cache entries
             Self::LoadAttr { .. }
diff --git a/crates/stdlib/src/_opcode.rs b/crates/stdlib/src/_opcode.rs
@@ -197,6 +197,11 @@ mod _opcode {
 
         let opcode = Opcode::try_from_pyint(args.opcode, vm)?;
 
+        // Raise ValueError if specialized.
+        if opcode.inner().real().is_some_and(|op| op.deopt().is_some()) {
+            return Err(vm.new_value_error("invalid opcode or oparg"));
+        }
+
         let _ = jump; // Python API accepts jump but it's not used
         Ok(opcode.stack_effect(oparg))
     }
