gh-111500: Fix super() without args calls for dataclasses with slots

python · sobolevn · Oct 31, 2023 · Mar 12, 2024 · Mar 12, 2024 · Mar 12, 2024
commit d3101658ba9f7b26f859cfea4ab62ea88a9e673c
@@ -1232,6 +1232,7 @@ def _add_slots(cls, is_frozen, weakref_slot):

    # And finally create the class.
    qualname = getattr(cls, '__qualname__', None)
+    old_cls = cls
    cls = type(cls)(cls.__name__, cls.__bases__, cls_dict)
    if qualname is not None:
        cls.__qualname__ = qualname
@@ -1243,6 +1244,34 @@ def _add_slots(cls, is_frozen, weakref_slot):
        if '__setstate__' not in cls_dict:
            cls.__setstate__ = _dataclass_setstate

+    # The following is a fix for
+    # https://github.com/python/cpython/issues/111500
+    # The code is copied-and-modified from https://github.com/python-attrs/attrs
+    # All credits for it goes to the `attrs` team and contributors.
+    #
+    # If a method mentions `__class__` or uses the no-arg super(), the
+    # compiler will bake a reference to the class in the method itself
+    # as `method.__closure__`.  Since we replace the class with a
+    # clone, we rewrite these references so it keeps working.
+    for item in cls.__dict__.values():
+        if isinstance(item, (classmethod, staticmethod)):
+            closure_cells = getattr(item.__func__, "__closure__", None)
+        elif isinstance(item, property):
+            closure_cells = getattr(item.fget, "__closure__", None)
+        else:
+            closure_cells = getattr(item, "__closure__", None)
+
+        if not closure_cells:
+            continue
+        for cell in closure_cells:
+            try:
+                match = cell.cell_contents is old_cls
+            except ValueError:  # Cell is empty
+                pass
+            else:
+                if match:
+                    cell.cell_contents = cls
+
    return cls



@@ -3494,6 +3494,67 @@ class A(Base):
        a_ref = weakref.ref(a)
        self.assertIs(a.__weakref__, a_ref)

+    def test_super_without_params_and_slots(self):
+        # https://github.com/python/cpython/issues/111500
+        for slots in (True, False):
+            with self.subTest(slots=slots):
+                @dataclass(slots=slots)
+                class Base:
+                    x: int = 0
+                    def __post_init__(self):
+                        self.x = 1
+                    def method(self):
+                        return 2
+                    @property
+                    def prop(self):
+                        return 3
+                    @classmethod
+                    def clsmethod(cls):
+                        return 4
+                    @staticmethod
+                    def stmethod():
+                        return 5
+
+                @dataclass(slots=slots)
+                class Child(Base):
+                    y: int = 0
+                    z: int = 0
+                    def __post_init__(self):
+                        self.y = 2
+                        super().__post_init__()
+                        self.z = 3
+                    def method(self):
+                        return super().method()
+                    @property
+                    def prop(self):
+                        return super().prop
+                    @classmethod
+                    def clsmethod(cls):
+                        return super().clsmethod()
+                    @staticmethod
+                    def stmethod1():
+                        return super(Child, Child).stmethod()
+                    @staticmethod
+                    def stmethod2():
+                        return super().stmethod()
+
+                inst = Child()
+                self.assertEqual(inst.x, 1)
+                self.assertEqual(inst.y, 2)
+                self.assertEqual(inst.z, 3)
+                self.assertEqual(inst.method(), 2)
+                self.assertEqual(inst.prop, 3)
+                self.assertEqual(inst.clsmethod(), 4)
+                self.assertEqual(Child.clsmethod(), 4)
+                self.assertEqual(inst.stmethod1(), 5)
+                self.assertEqual(Child.stmethod1(), 5)
+                # These failures match regular classes:
+                msg = r"super\(\): no arguments"
+                with self.assertRaisesRegex(RuntimeError, msg):
+                    inst.stmethod2()
+                with self.assertRaisesRegex(RuntimeError, msg):
+                    Child.stmethod2()
+

 class TestDescriptors(unittest.TestCase):
    def test_set_name(self):

diff --git a/Misc/NEWS.d/next/Library/2023-10-31-14-19-50.gh-issue-111500.y914Ti.rst b/Misc/NEWS.d/next/Library/2023-10-31-14-19-50.gh-issue-111500.y914Ti.rst
@@ -0,0 +1,2 @@
+Fix ``super()`` call without arguments for :mod:`dataclasses` with
+``slots=True``.
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		Fix ``super()`` call without arguments for :mod:`dataclasses` with
		``slots=True``.