RustPython · youknowone · Jan 14, 2026 · Jan 11, 2026 · Jan 11, 2026 · Jan 11, 2026
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
@@ -138,14 +138,20 @@
     'JUMP_IF_NOT_EXC_MATCH': 131,
     'SET_EXC_INFO': 134,
     'SUBSCRIPT': 135,
-    'LOAD_SUPER_METHOD': 136,
-    'LOAD_ZERO_SUPER_ATTR': 137,
-    'LOAD_ZERO_SUPER_METHOD': 138,
     'RESUME': 149,
-    'JUMP': 252,
     'LOAD_CLOSURE': 253,
-    'LOAD_ATTR_METHOD': 254,
-    'POP_BLOCK': 255,
+    'JUMP': 256,
+    'JUMP_NO_INTERRUPT': 257,
+    'RESERVED_258': 258,
+    'LOAD_ATTR_METHOD': 259,
+    'LOAD_SUPER_METHOD': 260,
+    'LOAD_ZERO_SUPER_ATTR': 261,
+    'LOAD_ZERO_SUPER_METHOD': 262,
+    'POP_BLOCK': 263,
+    'SETUP_CLEANUP': 264,
+    'SETUP_FINALLY': 265,
+    'SETUP_WITH': 266,
+    'STORE_FAST_MAYBE_NULL': 267,
 }
 
 # CPython 3.13 compatible: opcodes < 44 have no argument

diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
@@ -16,7 +16,6 @@ def check_bool_function_result(self, func, ops, expected):
                 self.assertIsInstance(func(op), bool)
                 self.assertEqual(func(op), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Only supporting u8 ATM
     def test_invalid_opcodes(self):
         invalid = [-100, -1, 255, 512, 513, 1000]
         self.check_bool_function_result(_opcode.is_valid, invalid, False)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
@@ -1,12 +1,14 @@
 use core::ops;
 
 use crate::{IndexMap, IndexSet, error::InternalError};
+
 use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
         Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
-        InstrDisplayContext, Instruction, Label, OpArg, PyCodeLocationInfoKind,
-        encode_exception_table, encode_load_attr_arg, encode_load_super_attr_arg,
+        InstrDisplayContext, Instruction, InstructionMetadata, Label, OpArg, PseudoInstruction,
+        PyCodeLocationInfoKind, RealInstruction, encode_exception_table, encode_load_attr_arg,
+        encode_load_super_attr_arg,
     },
     varint::{write_signed_varint, write_varint},
 };
@@ -195,48 +197,74 @@ impl CodeInfo {
             .filter(|b| b.next != BlockIdx::NULL || !b.instructions.is_empty())
         {
             for info in &mut block.instructions {
-                match info.instr {
+                // Special case for:
+                // - `RealInstruction::LoadAttr`
+                // - `RealInstruction::LoadSuperAttr`
+
+                if let Some(instr) = info.instr.real() {
+                    match instr {
+                        // LOAD_ATTR → encode with method flag=0
+                        RealInstruction::LoadAttr { idx } => {
+                            let encoded = encode_load_attr_arg(idx.get(info.arg), false);
+                            info.arg = OpArg(encoded);
+                            info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
+                        }
+                        // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
+                        RealInstruction::LoadSuperAttr { arg: idx } => {
+                            let encoded =
+                                encode_load_super_attr_arg(idx.get(info.arg), false, true);
+                            info.arg = OpArg(encoded);
+                            info.instr =
+                                RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                        }
+                        _ => {}
+                    }
+
+                    continue;
+                }
+
+                let instr = info.instr.expect_pseudo();
+
+                match instr {
                     // LOAD_ATTR_METHOD pseudo → LOAD_ATTR (with method flag=1)
-                    Instruction::LoadAttrMethod { idx } => {
+                    PseudoInstruction::LoadAttrMethod { idx } => {
                         let encoded = encode_load_attr_arg(idx.get(info.arg), true);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
-                    }
-                    // LOAD_ATTR → encode with method flag=0
-                    Instruction::LoadAttr { idx } => {
-                        let encoded = encode_load_attr_arg(idx.get(info.arg), false);
-                        info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
+                        info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
                     }
                     // POP_BLOCK pseudo → NOP
-                    Instruction::PopBlock => {
-                        info.instr = Instruction::Nop;
+                    PseudoInstruction::PopBlock => {
+                        info.instr = RealInstruction::Nop.into();
                     }
                     // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
-                    Instruction::LoadSuperMethod { idx } => {
+                    PseudoInstruction::LoadSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_ATTR pseudo → LOAD_SUPER_ATTR (flags=0b00: method=0, class=0)
-                    Instruction::LoadZeroSuperAttr { idx } => {
+                    PseudoInstruction::LoadZeroSuperAttr { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, false);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b01: method=1, class=0)
-                    Instruction::LoadZeroSuperMethod { idx } => {
+                    PseudoInstruction::LoadZeroSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, false);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
-                    // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
-                    Instruction::LoadSuperAttr { arg: idx } => {
-                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, true);
-                        info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                    PseudoInstruction::Jump { .. } => {
+                        // PseudoInstruction::Jump instructions are handled later
+                    }
+                    PseudoInstruction::JumpNoInterrupt { .. }
+                    | PseudoInstruction::Reserved258
+                    | PseudoInstruction::SetupCleanup
+                    | PseudoInstruction::SetupFinally
+                    | PseudoInstruction::SetupWith
+                    | PseudoInstruction::StoreFastMaybeNull => {
+                        unimplemented!("Got a placeholder pseudo instruction ({instr:?})")
                     }
-                    _ => {}
                 }
             }
         }
@@ -277,19 +305,21 @@ impl CodeInfo {
 
                     // Convert JUMP pseudo to real instructions (direction depends on offset)
                     let op = match info.instr {
-                        Instruction::Jump { .. } if target != BlockIdx::NULL => {
+                        Instruction::Pseudo(PseudoInstruction::Jump { .. })
+                            if target != BlockIdx::NULL =>
+                        {
                             let target_offset = block_to_offset[target.idx()].0;
                             if target_offset > current_offset {
-                                Instruction::JumpForward {
+                                RealInstruction::JumpForward {
                                     target: Arg::marker(),
                                 }
                             } else {
-                                Instruction::JumpBackward {
+                                RealInstruction::JumpBackward {
                                     target: Arg::marker(),
                                 }
                             }
                         }
-                        other => other,
+                        other => other.expect_real(),
                     };
 
                     let (extras, lo_arg) = info.arg.split();
@@ -299,7 +329,7 @@ impl CodeInfo {
                     ));
                     instructions.extend(
                         extras
-                            .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
+                            .map(|byte| CodeUnit::new(RealInstruction::ExtendedArg, byte))
                             .chain([CodeUnit { op, arg: lo_arg }]),
                     );
                     current_offset += info.arg.instr_size() as u32;

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
@@ -15,7 +15,11 @@ use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
 pub use crate::bytecode::{
-    instruction::{Arg, Instruction, decode_load_super_attr_arg, encode_load_super_attr_arg},
+    instruction::{
+        Arg, Instruction, InstructionMetadata, PseudoInstruction, RealInstruction,
+        decode_load_attr_arg, decode_load_super_attr_arg, encode_load_attr_arg,
+        encode_load_super_attr_arg,
+    },
     oparg::{
         BinaryOperator, BuildSliceArgCount, ComparisonOperator, ConvertValueOparg,
         IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx, OpArg,
@@ -96,20 +100,6 @@ pub fn find_exception_handler(table: &[u8], offset: u32) -> Option<ExceptionTabl
     None
 }
 
-/// Encode LOAD_ATTR oparg: bit 0 = method flag, bits 1+ = name index.
-#[inline]
-pub const fn encode_load_attr_arg(name_idx: u32, is_method: bool) -> u32 {
-    (name_idx << 1) | (is_method as u32)
-}
-
-/// Decode LOAD_ATTR oparg: returns (name_idx, is_method).
-#[inline]
-pub const fn decode_load_attr_arg(oparg: u32) -> (u32, bool) {
-    let is_method = (oparg & 1) == 1;
-    let name_idx = oparg >> 1;
-    (name_idx, is_method)
-}
-
 /// CPython 3.11+ linetable location info codes
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u8)]
@@ -313,14 +303,14 @@ bitflags! {
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct CodeUnit {
-    pub op: Instruction,
+    pub op: RealInstruction,
     pub arg: OpArgByte,
 }
 
 const _: () = assert!(mem::size_of::<CodeUnit>() == 2);
 
 impl CodeUnit {
-    pub const fn new(op: Instruction, arg: OpArgByte) -> Self {
+    pub const fn new(op: RealInstruction, arg: OpArgByte) -> Self {
         Self { op, arg }
     }
 }