Short-circuit identity in rich_compare_bool for Eq/Ne (PyObject_RichCompareBool parity)

changjoon-park · changjoon-park · commit fe4c8b3ed514 · 2026-04-29T19:43:51.000+09:00
CPython distinguishes two comparison entry points (Objects/object.c):
- PyObject_RichCompare returns the raw __eq__ / __ne__ result; no
  identity short-circuit
- PyObject_RichCompareBool returns bool; identity implies equality
  (and inequality is false on identity), short-circuiting before
  dispatch

Collection membership / equality (x in [x], [nan] == [nan], set/dict
comparisons) go through the bool variant and rely on the short-circuit.
RustPython's rich_compare_bool skipped the identity check, so a buggy
or raising __eq__ propagated even when the operand was the same object.

Add an identity short-circuit at the top of rich_compare_bool for Eq
(returns true) and Ne (returns false). Ordering ops fall through to
_cmp because Python does not guarantee reflexivity for &lt;/&lt;=/&gt;/&gt;=.
_cmp itself is untouched, so == / != operators continue to invoke
__eq__ / __ne__ exactly as before.

Unmasks test_dictviews.TestDictViews.test_compare_error.

Verified byte-identical with CPython 3.14.4 across 53 scenarios in 10
categories (collection membership / equality / ordering ops / NaN /
hash collision / dict views / list-set-dict ops). 14-module regression
sweep ~2,402 tests passes with no regressions.
diff --git a/Lib/test/test_dictviews.py b/Lib/test/test_dictviews.py
@@ -292,7 +292,6 @@ def test_copy(self):
         self.assertRaises(TypeError, copy.copy, d.values())
         self.assertRaises(TypeError, copy.copy, d.items())
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_compare_error(self):
         class Exc(Exception):
             pass
diff --git a/crates/vm/src/protocol/object.rs b/crates/vm/src/protocol/object.rs
@@ -348,6 +348,20 @@ impl PyObject {
         op_id: PyComparisonOp,
         vm: &VirtualMachine,
     ) -> PyResult<bool> {
+        // CPython parity: PyObject_RichCompareBool guarantees identity implies
+        // equality (and inequality is false on identity), short-circuiting
+        // before dispatch. Collection membership / equality (e.g. `x in [x]`,
+        // `[nan] == [nan]`) depend on this even when `__eq__` would raise
+        // or return False. Only Eq/Ne are decidable from identity; ordering
+        // ops fall through to `_cmp` because Python does not guarantee
+        // reflexivity for `<`/`<=`/`>`/`>=`.
+        if self.is(other) {
+            match op_id {
+                PyComparisonOp::Eq => return Ok(true),
+                PyComparisonOp::Ne => return Ok(false),
+                _ => {}
+            }
+        }
         match self._cmp(other, op_id, vm)? {
             Either::A(obj) => obj.try_to_bool(vm),
             Either::B(other) => Ok(other),
