Implement code object eq/hash, co_lnotab, and invalid bytecode support

- Add Comparable and Hashable traits for PyCode, comparing key
  attributes (name, argcount, flags, bytecode, consts, etc.)
- Add deprecated co_lnotab property with DeprecationWarning,
  converting linetable to the old 2-byte pair format
- Fill all 256 Instruction discriminants (add _Unused variants for
  gaps 121-127 and 212-233) so transmute from any u8 is defined
- Raise SystemError for unknown opcodes in the VM dispatch loop
- Remove @unittest.expectedFailure from test_shrinking_localsplus,
  test_co_lnotab_is_deprecated, test_invalid_bytecode
- Restore @requires_debug_ranges() for
  test_co_positions_artificial_instructions

Author: youknowone

Lib/test/test_code.py

@@ -330,8 +330,6 @@ def func():
         with self.assertRaises(ValueError):
             co.replace(co_nlocals=co.co_nlocals + 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_shrinking_localsplus(self):
         # Check that PyCode_NewWithPosOnlyArgs resizes both
         # localsplusnames and localspluskinds, if an argument is a cell.
@@ -347,17 +345,13 @@ def func():
         new_code = code = func.__code__.replace(co_linetable=b'')
         self.assertEqual(list(new_code.co_lines()), [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_co_lnotab_is_deprecated(self):  # TODO: remove in 3.14
         def func():
             pass
 
         with self.assertWarns(DeprecationWarning):
             func.__code__.co_lnotab
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_invalid_bytecode(self):
         def foo():
             pass
@@ -373,9 +367,7 @@ def foo():
         with self.assertRaisesRegex(SystemError, msg):
             foo()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    # @requires_debug_ranges()
+    @requires_debug_ranges()
     def test_co_positions_artificial_instructions(self):
         import dis
 

crates/compiler-core/src/bytecode/instruction.rs

@@ -302,6 +302,14 @@ pub enum Instruction {
     YieldValue {
         arg: Arg<u32>,
     } = 120,
+    // Unused opcodes 121-127 (reserved for future use)
+    _Unused121 = 121,
+    _Unused122 = 122,
+    _Unused123 = 123,
+    _Unused124 = 124,
+    _Unused125 = 125,
+    _Unused126 = 126,
+    _Unused127 = 127,
     // CPython 3.14 RESUME (128)
     Resume {
         context: Arg<u32>,
@@ -390,6 +398,29 @@ pub enum Instruction {
     UnpackSequenceList = 209,                   // Placeholder
     UnpackSequenceTuple = 210,                  // Placeholder
     UnpackSequenceTwoTuple = 211,               // Placeholder
+    // Unused opcodes 212-233 (reserved for future use)
+    _Unused212 = 212,
+    _Unused213 = 213,
+    _Unused214 = 214,
+    _Unused215 = 215,
+    _Unused216 = 216,
+    _Unused217 = 217,
+    _Unused218 = 218,
+    _Unused219 = 219,
+    _Unused220 = 220,
+    _Unused221 = 221,
+    _Unused222 = 222,
+    _Unused223 = 223,
+    _Unused224 = 224,
+    _Unused225 = 225,
+    _Unused226 = 226,
+    _Unused227 = 227,
+    _Unused228 = 228,
+    _Unused229 = 229,
+    _Unused230 = 230,
+    _Unused231 = 231,
+    _Unused232 = 232,
+    _Unused233 = 233,
     // CPython 3.14 instrumented opcodes (234-254)
     InstrumentedEndFor = 234,
     InstrumentedPopIter = 235,
@@ -430,36 +461,47 @@ impl TryFrom<u8> for Instruction {
 
     #[inline]
     fn try_from(value: u8) -> Result<Self, MarshalError> {
-        // CPython-compatible opcodes (0-120)
-        let cpython_start = u8::from(Self::Cache);
-        let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
-
-        // Resume has a non-contiguous opcode (128)
-        let resume_id = u8::from(Self::Resume {
-            context: Arg::marker(),
-        });
-        let enter_executor_id = u8::from(Self::EnterExecutor);
-
-        let specialized_start = u8::from(Self::BinaryOpAddFloat);
-        let specialized_end = u8::from(Self::UnpackSequenceTwoTuple);
-
-        let instrumented_start = u8::from(Self::InstrumentedEndFor);
-        let instrumented_end = u8::from(Self::InstrumentedLine);
-
-        // No RustPython-only opcodes anymore - all opcodes match CPython 3.14
-        let custom_ops: &[u8] = &[];
+        // All 256 values are valid Instruction discriminants.
+        Ok(unsafe { mem::transmute::<u8, Self>(value) })
+    }
+}
 
-        if (cpython_start..=cpython_end).contains(&value)
-            || value == resume_id
-            || value == enter_executor_id
-            || custom_ops.contains(&value)
-            || (specialized_start..=specialized_end).contains(&value)
-            || (instrumented_start..=instrumented_end).contains(&value)
-        {
-            Ok(unsafe { mem::transmute::<u8, Self>(value) })
-        } else {
-            Err(Self::Error::InvalidBytecode)
-        }
+impl Instruction {
+    /// Returns `true` if this opcode is a known, valid instruction.
+    /// Unused/reserved opcodes return `false`.
+    pub fn is_valid(self) -> bool {
+        !matches!(
+            self,
+            Self::_Unused121
+                | Self::_Unused122
+                | Self::_Unused123
+                | Self::_Unused124
+                | Self::_Unused125
+                | Self::_Unused126
+                | Self::_Unused127
+                | Self::_Unused212
+                | Self::_Unused213
+                | Self::_Unused214
+                | Self::_Unused215
+                | Self::_Unused216
+                | Self::_Unused217
+                | Self::_Unused218
+                | Self::_Unused219
+                | Self::_Unused220
+                | Self::_Unused221
+                | Self::_Unused222
+                | Self::_Unused223
+                | Self::_Unused224
+                | Self::_Unused225
+                | Self::_Unused226
+                | Self::_Unused227
+                | Self::_Unused228
+                | Self::_Unused229
+                | Self::_Unused230
+                | Self::_Unused231
+                | Self::_Unused232
+                | Self::_Unused233
+        )
     }
 }
 
@@ -1081,6 +1123,7 @@ impl InstructionMetadata for Instruction {
             Self::UnpackSequenceTwoTuple => (2, 1),
             Self::WithExceptStart => (6, 5),
             Self::YieldValue { .. } => (1, 1),
+            _ => (0, 0), // Unused/reserved opcodes
         };
 
         debug_assert!((0..=i32::MAX).contains(&pushed));

crates/vm/src/builtins/code.rs

@@ -10,7 +10,7 @@ use crate::{
     convert::{ToPyException, ToPyObject},
     frozen,
     function::OptionalArg,
-    types::{Constructor, Representable},
+    types::{Comparable, Constructor, Hashable, Representable},
 };
 use alloc::fmt;
 use core::{
@@ -447,6 +447,75 @@ impl Representable for PyCode {
     }
 }
 
+impl Comparable for PyCode {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: crate::types::PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<crate::function::PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+            let a = &zelf.code;
+            let b = &other.code;
+            let eq = a.obj_name == b.obj_name
+                && a.arg_count == b.arg_count
+                && a.posonlyarg_count == b.posonlyarg_count
+                && a.kwonlyarg_count == b.kwonlyarg_count
+                && a.flags == b.flags
+                && a.first_line_number == b.first_line_number
+                && a.instructions.original_bytes() == b.instructions.original_bytes()
+                && a.linetable == b.linetable
+                && a.exceptiontable == b.exceptiontable
+                && a.names == b.names
+                && a.varnames == b.varnames
+                && a.freevars == b.freevars
+                && a.cellvars == b.cellvars
+                && {
+                    let a_consts: Vec<_> = a.constants.iter().map(|c| c.0.clone()).collect();
+                    let b_consts: Vec<_> = b.constants.iter().map(|c| c.0.clone()).collect();
+                    if a_consts.len() != b_consts.len() {
+                        false
+                    } else {
+                        let mut eq = true;
+                        for (ac, bc) in a_consts.iter().zip(b_consts.iter()) {
+                            if !vm.bool_eq(ac, bc)? {
+                                eq = false;
+                                break;
+                            }
+                        }
+                        eq
+                    }
+                };
+            Ok(eq.into())
+        })
+    }
+}
+
+impl Hashable for PyCode {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<crate::common::hash::PyHash> {
+        let code = &zelf.code;
+        // Hash a tuple of key attributes, matching CPython's code_hash
+        let tuple = vm.ctx.new_tuple(vec![
+            vm.ctx.new_str(code.obj_name.as_str()).into(),
+            vm.ctx.new_int(code.arg_count).into(),
+            vm.ctx.new_int(code.posonlyarg_count).into(),
+            vm.ctx.new_int(code.kwonlyarg_count).into(),
+            vm.ctx.new_int(code.varnames.len()).into(),
+            vm.ctx.new_int(code.flags.bits()).into(),
+            vm.ctx
+                .new_int(code.first_line_number.map_or(0, |n| n.get()) as i64)
+                .into(),
+            vm.ctx.new_bytes(code.instructions.original_bytes()).into(),
+            {
+                let consts: Vec<_> = code.constants.iter().map(|c| c.0.clone()).collect();
+                vm.ctx.new_tuple(consts).into()
+            },
+        ]);
+        tuple.as_object().hash(vm)
+    }
+}
+
 // Arguments for code object constructor
 #[derive(FromArgs)]
 pub struct PyCodeNewArgs {
@@ -595,7 +664,7 @@ impl Constructor for PyCode {
     }
 }
 
-#[pyclass(with(Representable, Constructor), flags(HAS_WEAKREF))]
+#[pyclass(with(Representable, Constructor, Comparable, Hashable), flags(HAS_WEAKREF))]
 impl PyCode {
     #[pygetset]
     const fn co_posonlyargcount(&self) -> usize {
@@ -721,6 +790,63 @@ impl PyCode {
         vm.ctx.new_bytes(self.code.exceptiontable.to_vec())
     }
 
+    #[pygetset]
+    pub fn co_lnotab(&self, vm: &VirtualMachine) -> PyResult<crate::builtins::PyBytesRef> {
+        crate::warn::warn(
+            vm.ctx
+                .new_str("co_lnotab is deprecated, use co_lines instead.")
+                .into(),
+            Some(vm.ctx.exceptions.deprecation_warning.to_owned()),
+            1,
+            None,
+            vm,
+        )?;
+        // Convert linetable to the old lnotab format: pairs of (addr_incr, line_incr)
+        let linetable = self.code.linetable.as_ref();
+        let mut lnotab = Vec::new();
+        if !linetable.is_empty() {
+            let first_line = self.code.first_line_number.map_or(0, |n| n.get() as i32);
+            let mut range = PyCodeAddressRange::new(linetable, first_line);
+            let mut prev_addr: i32 = 0;
+            let mut prev_line = first_line;
+            while range.advance() {
+                let addr = range.ar_start;
+                let line = range.ar_line;
+                if line == -1 {
+                    continue;
+                }
+                let mut addr_incr = addr - prev_addr;
+                let mut line_incr = line - prev_line;
+                // Emit addr_incr in chunks of 255
+                while addr_incr > 255 {
+                    lnotab.push(255u8);
+                    lnotab.push(0u8);
+                    addr_incr -= 255;
+                }
+                // Emit line_incr in chunks (signed, -128..127 per step)
+                while line_incr > 127 {
+                    lnotab.push(addr_incr as u8);
+                    lnotab.push(127u8);
+                    line_incr -= 127;
+                    addr_incr = 0;
+                }
+                while line_incr < -128 {
+                    lnotab.push(addr_incr as u8);
+                    lnotab.push((-128i8) as u8);
+                    line_incr += 128;
+                    addr_incr = 0;
+                }
+                if addr_incr != 0 || line_incr != 0 {
+                    lnotab.push(addr_incr as u8);
+                    lnotab.push(line_incr as u8);
+                }
+                prev_addr = addr;
+                prev_line = line;
+            }
+        }
+        Ok(vm.ctx.new_bytes(lnotab))
+    }
+
     #[pymethod]
     pub fn co_lines(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         // TODO: Implement lazy iterator (lineiterator) like CPython for better performance

crates/vm/src/frame.rs

@@ -5984,7 +5984,14 @@ impl ExecutingFrame<'_> {
                 result
             }
             _ => {
-                unreachable!("{instruction:?} instruction should not be executed")
+                if !instruction.is_valid() {
+                    Err(vm.new_system_error(format!(
+                        "unknown opcode {}",
+                        u8::from(instruction)
+                    )))
+                } else {
+                    unreachable!("{instruction:?} instruction should not be executed")
+                }
             }
         }
     }