Background

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.

Repro

class BadEq:
    def __hash__(self): return 7
    def __eq__(self, other): raise RuntimeError("eq called")

x = BadEq()
d = {x: x}
v1 = next(iter(d.values()))

v1 in d.values()
# CPython 3.14: True
# RustPython:   RuntimeError("eq called")    (before this PR)

NaN exhibits the canonical asymmetry that proves the contract:

n = float('nan')
n == n          # False  (RichCompare path, no shortcut)
[n] == [n]      # True   (RichCompareBool path, identity shortcut)
n in [n]        # True

Fix

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 < / <= / > / >= (e.g. user-defined __lt__ may legitimately return False for x < x). _cmp itself is untouched, so == / != operators continue to invoke __eq__ / __ne__ exactly as before.

Tests unmasked

• test_dictviews.TestDictViews.test_compare_error

Verification

53 scenarios across 10 categories — byte-identical with CPython 3.14.4 (diff empty):

• 6 ordering ops with raising dunders (<, <=, >, >=) — all raise (no shortcut)
• 7 collection membership types (list, tuple, set, frozenset, dict, dict.keys, deque)
• 2 dict view types (values, items)
• 7 container equality (== and != for list / tuple / set / frozenset / dict)
• 6 NaN edge cases (n == n False, [n] == [n] True, n in [n] True)
• 5 FalseEq class cases (where __eq__ returns False)
• 3 list operations (count, index, remove)
• 3 set operations (add, union, len)
• 3 dict operations (get, setdefault)
• 4 hash collision + identity separation cases

No regressions across 14 modules (~2,402 tests): test_dictviews, test_dict, test_set, test_list, test_tuple, test_collections, test_typing, test_descr, test_iter, test_compare, test_class, test_userdict, test_userlist, test_ordered_dict.

Out-of-scope finding (recorded for follow-up)

range.__contains__ and array.__contains__ return False on type mismatch (e.g. RaisingEq() in range(10) returns False without calling __eq__). CPython's specialized range_contains and array_contains fall back to the default sequence contains for non-fast-path types, which would invoke __eq__. This divergence is independent of the rich_compare_bool change in this PR — those specialized contains slots bypass bool_eq entirely.

Summary by CodeRabbit

• Bug Fixes
  • Equality/inequality now short-circuit when both operands are the same object, improving correctness and performance.
  • Mapping and weak proxy comparisons now evaluate rich-comparison results and coerce them to booleans, ensuring consistent semantics and proper error propagation.
  • Weak references retain identity fallback when a referent cannot be resolved.