Merge remote-tracking branch 'upstream/main' into opcode-name

ShaharNaveh · ShaharNaveh · commit f87a6303a309 · 2026-03-15T11:23:21.000+01:00
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
@@ -1971,7 +1971,6 @@ def test_setattr(self):
 
     # test_str(): see test_str.py and test_bytes.py for str() tests.
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: floats 0.0 and -0.0 are not identical: zeros have different signs
     def test_sum(self):
         self.assertEqual(sum([]), 0)
         self.assertEqual(sum(list(range(2,8))), 27)
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
@@ -7,7 +7,7 @@ use crate::{
             self, BinaryOperator, BuildSliceArgCount, CommonConstant, ComparisonOperator,
             ConvertValueOparg, IntrinsicFunction1, IntrinsicFunction2, Invert, Label, LoadAttr,
             LoadSuperAttr, MakeFunctionFlag, NameIdx, OpArg, OpArgByte, OpArgType, RaiseKind,
-            SpecialMethod, StoreFastLoadFast, UnpackExArgs,
+            SpecialMethod, UnpackExArgs,
         },
     },
     marshal::MarshalError,
@@ -201,13 +201,13 @@ pub enum Instruction {
         var_num: Arg<oparg::VarNum>,
     } = 86,
     LoadFastBorrowLoadFastBorrow {
-        var_nums: Arg<u32>,
+        var_nums: Arg<oparg::VarNums>,
     } = 87,
     LoadFastCheck {
         var_num: Arg<oparg::VarNum>,
     } = 88,
     LoadFastLoadFast {
-        var_nums: Arg<u32>,
+        var_nums: Arg<oparg::VarNums>,
     } = 89,
     LoadFromDictOrDeref {
         i: Arg<NameIdx>,
@@ -279,10 +279,10 @@ pub enum Instruction {
         var_num: Arg<oparg::VarNum>,
     } = 112,
     StoreFastLoadFast {
-        var_nums: Arg<StoreFastLoadFast>,
+        var_nums: Arg<oparg::VarNums>,
     } = 113,
     StoreFastStoreFast {
-        var_nums: Arg<u32>,
+        var_nums: Arg<oparg::VarNums>,
     } = 114,
     StoreGlobal {
         namei: Arg<NameIdx>,
@@ -1342,20 +1342,22 @@ impl InstructionMetadata for Instruction {
             // Oparg needs to be passed into a function.
             ($map:ident = $arg_marker:expr) => {{
                 let arg = $arg_marker.get(arg);
-                write!(f, "{:pad$}({}, {})", self.name(), arg, $map(arg))
+                write!(f, "{:pad$}({}, {})", opname, arg, $map(arg))
             }};
 
             // Oparg to be shown via `fmt::Display`
             ($arg_marker:expr) => {
-                write!(f, "{:pad$}({})", self.name(), $arg_marker.get(arg))
+                write!(f, "{:pad$}({})", opname, $arg_marker.get(arg))
             };
 
             // Oparg to be shown via `fmt::Debug`
             ( ?$arg_marker:expr) => {
-                write!(f, "{:pad$}({:?})", self.name(), $arg_marker.get(arg))
+                write!(f, "{:pad$}({:?})", opname, $arg_marker.get(arg))
             };
         }
 
+        let opname = self.name();
+
         let varname = |var_num: oparg::VarNum| ctx.get_varname(var_num);
         let name = |i: u32| ctx.get_name(i as usize);
         let cell_name = |i: u32| ctx.get_cell_name(i as usize);
@@ -1382,7 +1384,7 @@ impl InstructionMetadata for Instruction {
 
         match self {
             Self::BinarySlice => w!(),
-            Self::BinaryOp { op } => write!(f, "{:pad$}({})", self.name(), op.get(arg)),
+            Self::BinaryOp { op } => write!(f, "{:pad$}({})", opname, op.get(arg)),
             Self::BinaryOpInplaceAddUnicode => w!(),
             Self::BuildList { count } => w!(count),
             Self::BuildMap { count } => w!(count),
@@ -1401,7 +1403,7 @@ impl InstructionMetadata for Instruction {
             Self::CleanupThrow => w!(),
             Self::CompareOp { opname } => w!(?opname),
             Self::ContainsOp { invert } => w!(?invert),
-            Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", self.name(), oparg.get(arg)),
+            Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", opname, oparg.get(arg)),
             Self::Copy { i } => w!(i),
             Self::CopyFreeVars { n } => w!(n),
             Self::DeleteAttr { namei } => w!(name = namei),
@@ -1438,7 +1440,6 @@ impl InstructionMetadata for Instruction {
                 let oparg = namei.get(arg);
                 let oparg_u32 = u32::from(oparg);
                 let attr_name = name(oparg.name_idx());
-                let opname = self.name();
                 if oparg.is_method() {
                     write!(
                         f,
@@ -1452,7 +1453,7 @@ impl InstructionMetadata for Instruction {
             Self::LoadBuildClass => w!(),
             Self::LoadCommonConstant { idx } => w!(?idx),
             Self::LoadFromDictOrDeref { i } => w!(cell_name = i),
-            Self::LoadConst { consti } => fmt_const(self.name(), arg, f, consti),
+            Self::LoadConst { consti } => fmt_const(opname, arg, f, consti),
             Self::LoadSmallInt { i } => w!(i),
             Self::LoadDeref { i } => w!(cell_name = i),
             Self::LoadFast { var_num } => w!(varname = var_num),
@@ -1461,25 +1462,22 @@ impl InstructionMetadata for Instruction {
             Self::LoadFastCheck { var_num } => w!(varname = var_num),
             Self::LoadFastLoadFast { var_nums } => {
                 let oparg = var_nums.get(arg);
-                let idx1 = oparg >> 4;
-                let idx2 = oparg & 15;
-                let name1 = varname(idx1.into());
-                let name2 = varname(idx2.into());
-                write!(f, "{:pad$}({}, {})", self.name(), name1, name2)
+                let (idx1, idx2) = oparg.indexes();
+                let name1 = varname(idx1);
+                let name2 = varname(idx2);
+                write!(f, "{:pad$}({}, {})", opnmae, name1, name2)
             }
             Self::LoadFastBorrowLoadFastBorrow { var_nums } => {
                 let oparg = var_nums.get(arg);
-                let idx1 = oparg >> 4;
-                let idx2 = oparg & 15;
-                let name1 = varname(idx1.into());
-                let name2 = varname(idx2.into());
-                write!(f, "{:pad$}({}, {})", self.name(), name1, name2)
+                let (idx1, idx2) = oparg.indexes();
+                let name1 = varname(idx1);
+                let name2 = varname(idx2);
+                write!(f, "{:pad$}({}, {})", opname, name1, name2)
             }
             Self::LoadFromDictOrGlobals { i } => w!(name = i),
             Self::LoadGlobal { namei } => {
                 let oparg = namei.get(arg);
                 let name_idx = oparg >> 1;
-                let opname = self.name();
                 if (oparg & 1) != 0 {
                     write!(f, "{:pad$}({}, NULL + {})", opname, oparg, name(name_idx))
                 } else {
@@ -1489,7 +1487,6 @@ impl InstructionMetadata for Instruction {
             Self::LoadGlobalBuiltin => {
                 let oparg = u32::from(arg);
                 let name_idx = oparg >> 1;
-                let opname = self.name();
                 if (oparg & 1) != 0 {
                     write!(f, "{:pad$}({}, NULL + {})", opname, oparg, name(name_idx))
                 } else {
@@ -1499,7 +1496,6 @@ impl InstructionMetadata for Instruction {
             Self::LoadGlobalModule => {
                 let oparg = u32::from(arg);
                 let name_idx = oparg >> 1;
-                let opname = self.name();
                 if (oparg & 1) != 0 {
                     write!(f, "{:pad$}({}, NULL + {})", opname, oparg, name(name_idx))
                 } else {
@@ -1514,7 +1510,7 @@ impl InstructionMetadata for Instruction {
                 write!(
                     f,
                     "{:pad$}({}, {}, method={}, class={})",
-                    self.name(),
+                    opname,
                     u32::from(oparg),
                     name(oparg.name_idx()),
                     oparg.is_load_method(),
@@ -1555,21 +1551,13 @@ impl InstructionMetadata for Instruction {
             Self::StoreFast { var_num } => w!(varname = var_num),
             Self::StoreFastLoadFast { var_nums } => {
                 let oparg = var_nums.get(arg);
-                let store_idx = oparg.store_idx();
-                let load_idx = oparg.load_idx();
-                write!(f, "{:pad$}({}, {})", self.name(), store_idx, load_idx)
+                let (store_idx, load_idx) = oparg.indexes();
+                write!(f, " {:pad$}({}, {})", opnmae, store_idx, load_idx)
             }
             Self::StoreFastStoreFast { var_nums } => {
                 let oparg = var_nums.get(arg);
-                let idx1 = oparg >> 4;
-                let idx2 = oparg & 15;
-                write!(
-                    f,
-                    "{:pad$}({}, {})",
-                    self.name(),
-                    varname(idx1.into()),
-                    varname(idx2.into())
-                )
+                let (idx1, idx2) = oparg.indexes();
+                write!(f, "{:pad$}({}, {})", opname, varname(idx1), varname(idx2))
             }
             Self::StoreGlobal { namei } => w!(name = namei),
             Self::StoreName { namei } => w!(name = namei),
diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
@@ -733,36 +733,41 @@ newtype_oparg!(
 newtype_oparg!(
     #[derive(Clone, Copy)]
     #[repr(transparent)]
-    pub struct LoadAttr(u32)
+    pub struct VarNums(u32)
 );
 
 newtype_oparg!(
     #[derive(Clone, Copy)]
     #[repr(transparent)]
-    pub struct LoadSuperAttr(u32)
+    pub struct LoadAttr(u32)
 );
 
 newtype_oparg!(
-    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+    #[derive(Clone, Copy)]
     #[repr(transparent)]
-    pub struct Label(u32)
+    pub struct LoadSuperAttr(u32)
 );
 
 newtype_oparg!(
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
     #[repr(transparent)]
-    pub struct StoreFastLoadFast(u32)
+    pub struct Label(u32)
 );
 
-impl StoreFastLoadFast {
+impl VarNums {
+    #[must_use]
+    pub const fn idx_1(self) -> VarNum {
+        VarNum::new(self.0 >> 4)
+    }
+
     #[must_use]
-    pub const fn store_idx(self) -> NameIdx {
-        self.0 >> 4
+    pub const fn idx_2(self) -> VarNum {
+        VarNum::new(self.0 & 15)
     }
 
     #[must_use]
-    pub const fn load_idx(self) -> NameIdx {
-        self.0 & 15
+    pub const fn indexes(self) -> (VarNum, VarNum) {
+        (self.idx_1(), self.idx_2())
     }
 }
 
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
@@ -660,10 +660,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             Instruction::LoadFastLoadFast { var_nums }
             | Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
                 let oparg = var_nums.get(arg);
-                let idx1 = oparg >> 4;
-                let idx2 = oparg & 0xF;
+                let (idx1, idx2) = oparg.indexes();
                 for idx in [idx1, idx2] {
-                    let local = self.variables[idx as usize]
+                    let local = self.variables[idx]
                         .as_ref()
                         .ok_or(JitCompileError::BadBytecode)?;
                     self.stack.push(JitValue::from_type_and_value(
diff --git a/crates/vm/src/builtins/complex.rs b/crates/vm/src/builtins/complex.rs
@@ -287,6 +287,44 @@ impl PyComplex {
             Ok(vm.ctx.not_implemented())
         }
     }
+
+    fn complex_real_binop<CCF, RCF, CRF, R>(
+        a: &PyObject,
+        b: &PyObject,
+        cc_op: CCF,
+        cr_op: CRF,
+        rc_op: RCF,
+        vm: &VirtualMachine,
+    ) -> PyResult
+    where
+        CCF: FnOnce(Complex64, Complex64) -> R,
+        CRF: FnOnce(Complex64, f64) -> R,
+        RCF: FnOnce(f64, Complex64) -> R,
+        R: ToPyResult,
+    {
+        let value = match (a.downcast_ref::<PyComplex>(), b.downcast_ref::<PyComplex>()) {
+            // complex + complex
+            (Some(a_complex), Some(b_complex)) => cc_op(a_complex.value, b_complex.value),
+            (Some(a_complex), None) => {
+                let Some(b_real) = float::to_op_float(b, vm)? else {
+                    return Ok(vm.ctx.not_implemented());
+                };
+
+                // complex + real
+                cr_op(a_complex.value, b_real)
+            }
+            (None, Some(b_complex)) => {
+                let Some(a_real) = float::to_op_float(a, vm)? else {
+                    return Ok(vm.ctx.not_implemented());
+                };
+
+                // real + complex
+                rc_op(a_real, b_complex.value)
+            }
+            (None, None) => return Ok(vm.ctx.not_implemented()),
+        };
+        value.to_pyresult(vm)
+    }
 }
 
 #[pyclass(
@@ -396,8 +434,26 @@ impl Hashable for PyComplex {
 impl AsNumber for PyComplex {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            add: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a + b, vm)),
-            subtract: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a - b, vm)),
+            add: Some(|a, b, vm| {
+                PyComplex::complex_real_binop(
+                    a,
+                    b,
+                    |a, b| a + b,
+                    |a_complex, b_real| Complex64::new(a_complex.re + b_real, a_complex.im),
+                    |a_real, b_complex| Complex64::new(a_real + b_complex.re, b_complex.im),
+                    vm,
+                )
+            }),
+            subtract: Some(|a, b, vm| {
+                PyComplex::complex_real_binop(
+                    a,
+                    b,
+                    |a, b| a - b,
+                    |a_complex, b_real| Complex64::new(a_complex.re - b_real, a_complex.im),
+                    |a_real, b_complex| Complex64::new(a_real - b_complex.re, -b_complex.im),
+                    vm,
+                )
+            }),
             multiply: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a * b, vm)),
             power: Some(|a, b, c, vm| {
                 if vm.is_none(c) {
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -2725,12 +2725,11 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastLoadFast { var_nums: packed } => {
+            Instruction::LoadFastLoadFast { var_nums } => {
                 // Load two local variables at once
                 // oparg encoding: (idx1 << 4) | idx2
-                let oparg = packed.get(arg);
-                let idx1 = (oparg >> 4) as usize;
-                let idx2 = (oparg & 15) as usize;
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
                 let fastlocals = self.localsplus.fastlocals();
                 let x1 = fastlocals[idx1].clone().ok_or_else(|| {
                     vm.new_exception_msg(
@@ -2774,10 +2773,9 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastBorrowLoadFastBorrow { var_nums: packed } => {
-                let oparg = packed.get(arg);
-                let idx1 = (oparg >> 4) as usize;
-                let idx2 = (oparg & 15) as usize;
+            Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
                 let fastlocals = self.localsplus.fastlocals();
                 let x1 = fastlocals[idx1].clone().ok_or_else(|| {
                     vm.new_exception_msg(
@@ -3309,17 +3307,17 @@ impl ExecutingFrame<'_> {
                 let value = self.pop_value();
                 let locals = self.localsplus.fastlocals_mut();
                 let oparg = var_nums.get(arg);
-                locals[oparg.store_idx() as usize] = Some(value);
-                let load_value = locals[oparg.load_idx() as usize]
+                let (store_idx, load_idx) = oparg.indexes();
+                locals[store_idx] = Some(value);
+                let load_value = locals[load_idx]
                     .clone()
                     .expect("StoreFastLoadFast: load slot should have value after store");
                 self.push_value(load_value);
                 Ok(None)
             }
-            Instruction::StoreFastStoreFast { var_nums: packed } => {
-                let oparg = packed.get(arg);
-                let idx1 = (oparg >> 4) as usize;
-                let idx2 = (oparg & 15) as usize;
+            Instruction::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
                 let value1 = self.pop_value();
                 let value2 = self.pop_value();
                 let fastlocals = self.localsplus.fastlocals_mut();
