Remove ReturnConst

RustPython · youknowone · Jan 20, 2026 · Jan 20, 2026 · Jan 20, 2026 · Jan 20, 2026
commit 1de86789c25deb5a7d90c94f58bc38f937131816
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
@@ -219,7 +219,6 @@
     'BREAK': 216,
     'CONTINUE': 217,
     'JUMP_IF_NOT_EXC_MATCH': 220,
-    'RETURN_CONST': 222,
     'SET_EXC_INFO': 223,
     'INSTRUMENTED_END_FOR': 234,
     'INSTRUMENTED_POP_ITER': 235,

diff --git a/Lib/dis.py b/Lib/dis.py
@@ -34,7 +34,6 @@
 
 ENTER_EXECUTOR = opmap['ENTER_EXECUTOR']
 LOAD_CONST = opmap['LOAD_CONST']
-RETURN_CONST = opmap['RETURN_CONST']
 LOAD_GLOBAL = opmap['LOAD_GLOBAL']
 BINARY_OP = opmap['BINARY_OP']
 JUMP_BACKWARD = opmap['JUMP_BACKWARD']

diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
@@ -210,7 +210,8 @@ def bug42562():
 
 dis_bug42562 = """\
           RESUME                   0
-          RETURN_CONST             0 (None)
+          LOAD_CONST               0 (None)
+          RETURN_VALUE
 """
 
 # Extended arg followed by NOP

diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
@@ -117,7 +117,7 @@ def f():
             return None
 
         self.assertNotInBytecode(f, 'LOAD_GLOBAL')
-        self.assertInBytecode(f, 'RETURN_CONST', None)
+        self.assertInBytecode(f, 'LOAD_CONST', None)
         self.check_lnotab(f)
 
     @unittest.expectedFailure # TODO: RUSTPYTHON

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -7688,17 +7688,11 @@ impl Compiler {
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
-        let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::ReturnConst { idx })
+        self.emit_load_const(constant);
+        emit!(self, Instruction::ReturnValue)
     }
 
     fn emit_return_value(&mut self) {
-        if let Some(inst) = self.current_block().instructions.last_mut()
-            && let AnyInstruction::Real(Instruction::LoadConst { idx }) = inst.instr
-        {
-            inst.instr = Instruction::ReturnConst { idx }.into();
-            return;
-        }
         emit!(self, Instruction::ReturnValue)
     }
 

diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
diff --git a/...s/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/...s/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
@@ -273,9 +273,6 @@ pub enum Instruction {
         target: Arg<Label>,
     } = 217,
     JumpIfNotExcMatch(Arg<Label>) = 220,
-    ReturnConst {
-        idx: Arg<u32>,
-    } = 222,
     SetExcInfo = 223,
     // CPython 3.14 RESUME (128)
     Resume {
@@ -434,7 +431,6 @@ impl TryFrom<u8> for Instruction {
                 target: Arg::marker(),
             }),
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
-            u8::from(Self::ReturnConst { idx: Arg::marker() }),
             u8::from(Self::SetExcInfo),
         ];
 
@@ -479,7 +475,6 @@ impl InstructionMetadata for Instruction {
                 | Self::Continue { .. }
                 | Self::Break { .. }
                 | Self::ReturnValue
-                | Self::ReturnConst { .. }
                 | Self::RaiseVarargs { .. }
                 | Self::Reraise { .. }
         )
@@ -559,7 +554,6 @@ impl InstructionMetadata for Instruction {
             Self::ContainsOp(_) => -1,
             Self::JumpIfNotExcMatch(_) => -2,
             Self::ReturnValue => -1,
-            Self::ReturnConst { .. } => 0,
             Self::Resume { .. } => 0,
             Self::YieldValue { .. } => 0,
             // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
@@ -935,7 +929,6 @@ impl InstructionMetadata for Instruction {
             Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
             Self::Reraise { depth } => w!(RERAISE, depth),
             Self::Resume { arg } => w!(RESUME, arg),
-            Self::ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
             Self::ReturnValue => w!(RETURN_VALUE),
             Self::Send { target } => w!(SEND, target),
             Self::SetAdd { i } => w!(SET_ADD, i),

diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
@@ -211,7 +211,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
                 Instruction::ReturnValue
-                | Instruction::ReturnConst { .. }
                 | Instruction::JumpBackward { .. }
                 | Instruction::JumpBackwardNoInterrupt { .. }
                 | Instruction::JumpForward { .. } => {
@@ -628,11 +627,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
-            Instruction::ReturnConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.return_value(val)
-            }
             Instruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)

diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
@@ -141,7 +141,7 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
             | Instruction::ExtendedArg => {
                 // Ignore these instructions for annotation extraction
             }
-            Instruction::ReturnValue | Instruction::ReturnConst { .. } => {
+            Instruction::ReturnValue => {
                 // End of function - return what we have
                 return annotations;
             }
@@ -276,11 +276,6 @@ impl StackMachine {
                     self.stack.push(StackValue::Function(func));
                 }
             }
-            Instruction::ReturnConst { idx } => {
-                let idx = idx.get(arg);
-                self.stack.push(constants[idx as usize].clone().into());
-                return ControlFlow::Break(());
-            }
             Instruction::ReturnValue => return ControlFlow::Break(()),
             Instruction::ExtendedArg => {}
             _ => unimplemented!(

diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
@@ -71,9 +71,7 @@ mod opcode {
         pub fn has_const(opcode: i32) -> bool {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
-                Ok(AnyInstruction::Real(
-                    Instruction::LoadConst { .. } | Instruction::ReturnConst { .. }
-                ))
+                Ok(AnyInstruction::Real(Instruction::LoadConst { .. }))
             )
         }
 

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -1562,10 +1562,6 @@ impl ExecutingFrame<'_> {
                 // }
                 Ok(None)
             }
-            Instruction::ReturnConst { idx } => {
-                let value = self.code.constants[idx.get(arg) as usize].clone().into();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
-            }
             Instruction::ReturnValue => {
                 let value = self.pop_value();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })