RustPython · youknowone · Jan 14, 2026 · Jan 11, 2026 · Jan 11, 2026 · Jan 11, 2026
diff --git a/.cspell.dict/rust-more.txt b/.cspell.dict/rust-more.txt
@@ -1,4 +1,5 @@
 ahash
+argty
 arrayvec
 bidi
 biguint

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},
 };
@@ -197,44 +199,44 @@ impl CodeInfo {
             for info in &mut block.instructions {
                 match info.instr {
                     // LOAD_ATTR_METHOD pseudo → LOAD_ATTR (with method flag=1)
-                    Instruction::LoadAttrMethod { idx } => {
+                    Instruction::Pseudo(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() };
+                        info.instr = RealInstruction::LoadAttr { idx: Arg::marker() }.into();
                     }
                     // LOAD_ATTR → encode with method flag=0
-                    Instruction::LoadAttr { idx } => {
+                    Instruction::Real(RealInstruction::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;
+                    Instruction::Pseudo(PseudoInstruction::PopBlock) => {
+                        info.instr = RealInstruction::Nop.into();
                     }
                     // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
-                    Instruction::LoadSuperMethod { idx } => {
+                    Instruction::Pseudo(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 } => {
+                    Instruction::Pseudo(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 } => {
+                    Instruction::Pseudo(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 } => {
+                    Instruction::Real(RealInstruction::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() };
+                        info.instr = RealInstruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     _ => {}
                 }
@@ -277,19 +279,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 +303,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
@@ -14,7 +14,9 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
-pub use crate::bytecode::instruction::Instruction;
+pub use crate::bytecode::instruction::{
+    Instruction, InstructionMetadata, PseudoInstruction, RealInstruction,
+};
 
 mod instruction;
 
@@ -117,7 +119,7 @@ pub const fn decode_load_super_attr_arg(oparg: u32) -> (u32, bool, bool) {
     (name_idx, load_method, has_class)
 }
 
-/// Oparg values for [`Instruction::ConvertValue`].
+/// Oparg values for [`RealInstruction::ConvertValue`].
 ///
 /// ## See also
 ///
@@ -161,7 +163,7 @@ impl fmt::Display for ConvertValueOparg {
             Self::Str => "1 (str)",
             Self::Repr => "2 (repr)",
             Self::Ascii => "3 (ascii)",
-            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
+            // We should never reach this. `FVC_NONE` are being handled by `RealInstruction::FormatSimple`
             Self::None => "",
         };
 
@@ -467,9 +469,9 @@ pub struct OpArgState {
 
 impl OpArgState {
     #[inline(always)]
-    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
+    pub fn get(&mut self, ins: CodeUnit) -> (RealInstruction, OpArg) {
         let arg = self.extend(ins.arg);
-        if ins.op != Instruction::ExtendedArg {
+        if ins.op != RealInstruction::ExtendedArg {
             self.reset();
         }
         (ins.op, arg)
@@ -605,7 +607,7 @@ impl<T: OpArgType> fmt::Debug for Arg<T> {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 #[repr(transparent)]
 // XXX: if you add a new instruction that stores a Label, make sure to add it in
-// Instruction::label_arg
+// RealInstruction::label_arg
 pub struct Label(pub u32);
 
 impl OpArgType for Label {
@@ -692,14 +694,14 @@ pub type NameIdx = u32;
 #[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 }
     }
 }
@@ -956,9 +958,9 @@ op_arg_enum!(
     /// # Examples
     ///
     /// ```rust
-    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
+    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, RealInstruction};
     /// let (op, _) = Arg::new(BinaryOperator::Add);
-    /// let instruction = Instruction::BinaryOp { op };
+    /// let instruction = RealInstruction::BinaryOp { op };
     /// ```
     ///
     /// See also:
-Original file line number
+Diff line change
@@ -1,4 +1,5 @@
     ahash
+    argty
     arrayvec
     bidi
     biguint
@@ Expand Down @@