jit-trace, _weakref: gate the class-attribute fold on a fold census, and reject repr with a foreign self

AGENTS.md

@@ -10,6 +10,13 @@ the user explicitly expands the scope. A skipped CPython test does not override
 this boundary; fix PyPy's real public-module owner or fallback instead. See
 “Module presence follows PyPy” below for the full rule and examples.
 
+**Hard stop:** if neither the real `pypy3` import nor an upstream PyPy owner can
+be verified, do not add the module or keep it in the implementation backlog.
+
+**Known exclusions:** `_testlimitedcapi` is a CPython-only test helper, and
+PyPy has no `_datetime` extension module. Do not implement either one; preserve
+and repair PyPy's pure-Python `datetime` path when the public module is broken.
+
 ## The JIT is generated from the interpreter source
 
 pyre is structured like PyPy: `pyre-interpreter` is the RPython-interpreter

pyre/extra_tests/snippets/builtin_complex.py

@@ -226,6 +226,7 @@ def __eq__(self, other):
 # __complex__
 z = 3 + 4j
 assert z.__complex__() == z
+assert z.__complex__() is z
 assert type(z.__complex__()) == complex
 
 

pyre/extra_tests/snippets/builtin_exceptions.py

@@ -78,6 +78,50 @@ def __init__(self, value):
     assert e.value == "test"
 
 
+class KeywordException(Exception):
+    def __init__(self, *, value):
+        self.value = value
+
+
+exc = KeywordException(value="test")
+assert exc.value == "test"
+assert exc.args == ()
+
+# PyPy `check_and_find_best_base`: fieldless exception aliases reuse their
+# parent's Layout, while concrete W_* siblings conflict.
+class CompatibleException(ValueError, OSError):
+    pass
+
+
+assert issubclass(CompatibleException, ValueError)
+assert issubclass(CompatibleException, OSError)
+
+try:
+    class ConflictingUnicodeErrors(UnicodeTranslateError, UnicodeEncodeError):
+        pass
+except TypeError as exc:
+    assert "layout conflict" in str(exc) or "lay-out conflict" in str(exc)
+else:
+    assert False, "conflicting Unicode error layouts accepted"
+
+# `interp_group.W_BaseExceptionGroup` owns a concrete child Layout while
+# `W_ExceptionGroup` reuses it. Fieldless exception aliases remain compatible
+# and the group becomes the best base; concrete sibling layouts conflict.
+class CompatibleGroup(ArithmeticError, ExceptionGroup):
+    pass
+
+
+assert CompatibleGroup.__base__ is ExceptionGroup
+
+try:
+    class ConflictingGroup(OSError, BaseExceptionGroup):
+        pass
+except TypeError as exc:
+    assert "layout conflict" in str(exc) or "lay-out conflict" in str(exc)
+else:
+    assert False, "BaseExceptionGroup sibling layout conflict accepted"
+
+
 exc = SyntaxError("msg", 1, 2, 3, 4, 5)
 assert exc.msg == "msg"
 assert exc.filename is None

pyre/extra_tests/snippets/builtin_property.py

@@ -1,3 +1,5 @@
+import pickle
+
 from testutils import assert_raises
 
 
@@ -119,3 +121,10 @@ class SlottedProperty(property):
 with assert_raises(TypeError) as caught:
     property().__set_name__(owner=object, name="value")
 assert str(caught.exception) == "property.__set_name__() takes no keyword arguments"
+
+# A property stores four native descriptor fields which an empty __newobj__
+# cannot reconstruct.  CPython 3.14 rejects the inherited object reducer.
+with assert_raises(TypeError):
+    property().__reduce_ex__(pickle.HIGHEST_PROTOCOL)
+with assert_raises(TypeError):
+    pickle.dumps(property())

pyre/extra_tests/snippets/builtin_set.py

@@ -90,6 +90,15 @@ class S(set):
 assert repr(S()) == "S()"
 assert repr(S([1, 2, 3])) == "S({1, 2, 3})"
 
+
+class SetCustomRepr(set):
+    def __repr__(self):
+        return "<custom " + set.__repr__(self) + ">"
+
+
+assert repr(SetCustomRepr()) == "<custom SetCustomRepr()>"
+assert repr(SetCustomRepr([1, 2, 3])) == "<custom SetCustomRepr({1, 2, 3})>"
+
 recursive = S()
 recursive.add(Hashable(recursive))
 assert repr(recursive) == "S({S(...)})"
@@ -447,6 +456,17 @@ class FS(frozenset):
 assert repr(FS([1, 2, 3])) == "FS({1, 2, 3})"
 
 
+class FrozenSetCustomRepr(frozenset):
+    def __repr__(self):
+        return "<custom " + frozenset.__repr__(self) + ">"
+
+
+assert repr(FrozenSetCustomRepr()) == "<custom FrozenSetCustomRepr()>"
+assert repr(FrozenSetCustomRepr([1, 2, 3])) == (
+    "<custom FrozenSetCustomRepr({1, 2, 3})>"
+)
+
+
 class MutatingSetKey:
     enabled = False
     target = None

pyre/extra_tests/snippets/builtin_typedef_census.py

@@ -6,6 +6,8 @@
 import sys
 import types
 import weakref
+from array import array
+from collections import deque
 
 from testutils import assert_raises
 
@@ -72,6 +74,35 @@ def _absent(tp, name):
 assert isinstance(memoryview.__doc__, str)
 assert "memoryview" in memoryview.__doc__
 
+for view_type in (type({}.keys()), type({}.values()), type({}.items())):
+    assert "__doc__" in view_type.__dict__
+    assert view_type.__dict__["__doc__"] is None
+
+# `typeobject.py ensure_common_attributes` gives every TypeDef an own doc
+# entry; `ensure_hash` suppresses an inherited object hash when equality is
+# defined locally.
+assert "__doc__" in array.__dict__
+assert array.__doc__.startswith("array(typecode [, initializer]) -> array\n")
+assert "itemsize -- the length in bytes of one array item" in array.__doc__
+assert array.__dict__["__hash__"] is None
+assert_raises(TypeError, hash, array("i"))
+
+assert deque.__dict__["__doc__"] == (
+    "A list-like sequence optimized for data accesses near its endpoints."
+)
+for weak_type in (
+    weakref.ReferenceType,
+    weakref.ProxyType,
+    weakref.CallableProxyType,
+):
+    assert "__doc__" in weak_type.__dict__
+    assert weak_type.__dict__["__doc__"] is None
+
+wrapper_descriptor = type(object.__str__)
+assert wrapper_descriptor.__name__ == "wrapper_descriptor"
+assert "__repr__" in wrapper_descriptor.__dict__
+assert wrapper_descriptor.__dict__["__repr__"](object.__str__) == repr(object.__str__)
+
 # --- SPEC-omit: PyPy TypeDef key, CPython 3.14 type dict has no such key ---
 
 _absent(bool, "__str__")

pyre/extra_tests/snippets/closure_over_parameter_not_double_wrapped.py

@@ -9,3 +9,30 @@ def add(x):
 result = make_adder(10)(5)
 
 assert result == 15
+
+# A cell passed as the captured argument is still an ordinary Python value.
+# The new closure must therefore contain a distinct outer cell whose contents
+# are the argument cell, rather than mistaking that argument for its own
+# closure container.  PyPy `PyFrame.init_cells` gets this from its separate
+# argument/cell slots; pyre's unified locals-plus slot must preserve it too.
+def external_cell():
+    value = 42
+
+    def inner():
+        return value
+
+    return inner.__closure__[0]
+
+
+cell_ext = external_cell()
+def capture(arg):
+    def read():
+        return arg
+
+    return read
+
+
+read = capture(cell_ext)
+cell_closure = read.__closure__[0]
+assert read() is cell_ext
+assert cell_closure is not cell_ext

pyre/extra_tests/snippets/pickle_native_getstate.py

@@ -0,0 +1,74 @@
+# pyre-check: gate=1
+# `object_getstate` calls an overriding `__getstate__` and only falls back to
+# `object_getstate_default(required)` when the type still uses
+# `object.__getstate__`.  The `required` refusal therefore stops at the
+# boundary that hook draws: a native layout publishing one is rebuilt from the
+# state it returns, and one that publishes none cannot be rebuilt through an
+# empty `__newobj__` call.
+#
+# `__reduce_ex__` is called directly rather than through `pickle`: this
+# directory carries its own `_pickle.py`, which shadows the stdlib extension
+# module and stops `import pickle` from working here.  That keeps this file
+# green under CPython too, unlike its `pickle_*` neighbours, which is what
+# lets it be gated.
+import io
+import itertools
+import types
+
+
+def refuses(obj):
+    try:
+        obj.__reduce_ex__(2)
+    except TypeError as e:
+        assert "cannot pickle" in str(e), (obj, str(e))
+        return True
+    return False
+
+
+# --- publishes `__getstate__`: reduces through the hook ---------------------
+b = io.BytesIO(b"abcdef")
+b.seek(2)
+b.tag = "kept"
+assert io.BytesIO.__getstate__ is not object.__getstate__
+newobj, args, state, listitems, dictitems = b.__reduce_ex__(2)
+assert args == (io.BytesIO,), args
+assert state == (b"abcdef", 2, {"tag": "kept"}), state
+assert listitems is None and dictitems is None, (listitems, dictitems)
+
+s = io.StringIO("hello")
+s.read(2)
+assert io.StringIO.__getstate__ is not object.__getstate__
+state = s.__reduce_ex__(2)[2]
+# `(value, readnl, pos, dict)`; the trailing dict is empty here and pyre and
+# CPython spell an empty one differently, so only value and pos are pinned.
+assert state[0] == "hello", state
+assert state[2] == 2, state
+
+# --- publishes a refusing `__getstate__`: the hook owns the refusal ---------
+w = io.BufferedWriter(io.BytesIO())
+assert io.BufferedWriter.__getstate__ is not object.__getstate__
+assert refuses(w)
+
+# --- publishes none: `object_getstate_default(required)` refuses ------------
+for obj in (
+    types.ModuleType("m"),
+    property(),
+    staticmethod(len),
+    classmethod(len),
+    itertools.count(),
+):
+    assert type(obj).__getstate__ is object.__getstate__, obj
+    assert refuses(obj), obj
+
+
+# The refusal reaches neither an ordinary instance nor a list or a dict.
+class C:
+    def __init__(self):
+        self.x = 1
+
+
+assert C().__reduce_ex__(2)[2] == {"x": 1}
+assert list(([1, 2]).__reduce_ex__(2)[3]) == [1, 2]
+assert list(({"a": 1}).__reduce_ex__(2)[4]) == [("a", 1)]
+
+print("pickle_native_getstate OK")

pyre/extra_tests/snippets/stdlib_collections.py

@@ -1,4 +1,5 @@
 from collections import defaultdict, deque
+from testutils import assert_raises
 
 
 # Python 3.14's defaultdict.__missing__ preserves a value installed by a
@@ -73,6 +74,67 @@ def __setattr__(self, name, value):
 
 assert deque([1, 2, 3], 4) * 2 == deque([3, 1, 2, 3])
 
+
+class DequeRepeatIndex:
+    def __index__(self):
+        # The receiver and count must stay rooted across arbitrary Python code.
+        import gc
+
+        gc.collect()
+        return 2
+
+
+class DequeRepeatReflected:
+    def __rmul__(self, other):
+        return ("reflected", other)
+
+
+class DequeRepeatOverride(deque):
+    def __mul__(self, other):
+        return ("override", other)
+
+    def __rmul__(self, other):
+        return ("reflected override", other)
+
+
+class SlottedDeque(deque):
+    __slots__ = ("slot_value", "__dict__")
+
+
+repeat_source = deque([1, 2])
+assert repeat_source * DequeRepeatIndex() == deque([1, 2, 1, 2])
+assert DequeRepeatIndex() * repeat_source == deque([1, 2, 1, 2])
+assert repeat_source * DequeRepeatReflected() == ("reflected", repeat_source)
+repeat_override = DequeRepeatOverride([1])
+assert repeat_override * 3 == ("override", 3)
+assert 3 * repeat_override == ("reflected override", 3)
+assert_raises(TypeError, deque.__mul__, repeat_source, object())
+assert_raises(OverflowError, lambda: repeat_source * (10**100))
+
+slotted_deque = SlottedDeque([1])
+slotted_deque.slot_value = 2
+slotted_deque.dict_value = 3
+assert slotted_deque.__dict__ == {"dict_value": 3}
+assert slotted_deque.__getstate__() == (
+    {"dict_value": 3},
+    {"slot_value": 2},
+)
+del slotted_deque.slot_value
+assert_raises(AttributeError, getattr, slotted_deque, "slot_value")
+
+repeat_big = deque([0])
+repeat_big *= 2**8
+assert_raises(MemoryError, lambda: repeat_big * (2**56))
+assert_raises(MemoryError, lambda: (2**56) * repeat_big)
+
+
+def repeat_big_in_place():
+    value = repeat_big.copy()
+    value *= 2**56
+
+
+assert_raises(MemoryError, repeat_big_in_place)
+
 # Optional constructor args, including the `maxlen` keyword form.
 assert deque(maxlen=5).maxlen == 5
 assert deque().maxlen is None