gh-92810: Apply fixes

Signed-off-by: Martynov Maxim <[email protected]>

Author: dolfinus

Lib/_py_abc.py

@@ -51,6 +51,7 @@ def __new__(mcls, name, bases, namespace, /, **kwargs):
         cls._abc_cache = WeakSet()
         cls._abc_negative_cache = WeakSet()
         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
+        cls._prevent_recursion = 0
         return cls
 
     def register(cls, subclass):
@@ -154,19 +155,6 @@ def __subclasscheck__(cls, subclass):
             if issubclass(subclass, rcls):
                 cls._abc_cache.add(subclass)
                 return True
-
-        # Check if it's a subclass of a subclass (recursive).
-        # >>> class Ancestor: __subclasses__ = lambda: [Other]
-        # >>> class Other: pass
-        # >>> isinstance(Other, Ancestor) is True
-        # Do not iterate over cls.__subclasses__() because it returns the entire class tree,
-        # not just direct children, which leads to O(n^2) lookup.
-        original_subclasses = getattr(cls, "__dict__", {}).get("__subclasses__", _UNSET)
-        if original_subclasses is not _UNSET:
-            for scls in original_subclasses():
-                if issubclass(subclass, scls):
-                    cls._abc_cache.add(subclass)
-                    return True
         # No dice; update negative cache
         cls._abc_negative_cache.add(subclass)
         return False

Lib/test/test_abc.py

@@ -411,34 +411,6 @@ class MyInt(int):
             self.assertIsInstance(42, A)
             self.assertIsInstance(42, (A,))
 
-        def test_subclasses(self):
-            class A:
-                pass
-
-            class B:
-                pass
-
-            class C:
-                pass
-
-            class Sup(metaclass=abc_ABCMeta):
-                __subclasses__ = lambda: [A, B]
-
-            self.assertIsSubclass(A, Sup)
-            self.assertIsSubclass(A, (Sup,))
-            self.assertIsInstance(A(), Sup)
-            self.assertIsInstance(A(), (Sup,))
-
-            self.assertIsSubclass(B, Sup)
-            self.assertIsSubclass(B, (Sup,))
-            self.assertIsInstance(B(), Sup)
-            self.assertIsInstance(B(), (Sup,))
-
-            self.assertNotIsSubclass(C, Sup)
-            self.assertNotIsSubclass(C, (Sup,))
-            self.assertNotIsInstance(C(), Sup)
-            self.assertNotIsInstance(C(), (Sup,))
-
         def test_subclasses_bad_arguments(self):
             class A(metaclass=abc_ABCMeta):
                 pass
@@ -457,37 +429,6 @@ class C:
             with self.assertRaises(TypeError):
                 issubclass(C(), A)
 
-            # bpo-34441: Check that issubclass() doesn't crash on bogus
-            # classes.
-            bogus_subclasses = [
-                None,
-                lambda x: [],
-                lambda: 42,
-                lambda: [42],
-            ]
-
-            for i, func in enumerate(bogus_subclasses):
-                class S(metaclass=abc_ABCMeta):
-                    __subclasses__ = func
-
-                with self.subTest(i=i):
-                    with self.assertRaises(TypeError):
-                        issubclass(int, S)
-
-            # Also check that issubclass() propagates exceptions raised by
-            # __subclasses__.
-            class CustomError(Exception): ...
-            exc_msg = "exception from __subclasses__"
-
-            def raise_exc():
-                raise CustomError(exc_msg)
-
-            class S(metaclass=abc_ABCMeta):
-                __subclasses__ = raise_exc
-
-            with self.assertRaisesRegex(CustomError, exc_msg):
-                issubclass(int, S)
-
         def test_subclasshook(self):
             class A(metaclass=abc.ABCMeta):
                 @classmethod

Lib/test/test_isinstance.py

@@ -351,6 +351,28 @@ class B:
         with support.infinite_recursion(25):
             self.assertRaises(RecursionError, issubclass, X(), int)
 
+    def test_override_subclasses(self):
+        class A: pass
+        class B: pass
+
+        class Parent1:
+            @classmethod
+            def __subclasses__(self):
+                return [A, B]
+
+        class Parent2:
+            __subclasses__ = lambda: [A, B]
+
+        self.assertNotIsInstance(A(), Parent1)
+        self.assertNotIsInstance(B(), Parent1)
+        self.assertNotIsSubclass(A, Parent1)
+        self.assertNotIsSubclass(B, Parent1)
+
+        self.assertNotIsInstance(A(), Parent2)
+        self.assertNotIsInstance(B(), Parent2)
+        self.assertNotIsSubclass(A, Parent2)
+        self.assertNotIsSubclass(B, Parent2)
+
 
 def blowstack(fxn, arg, compare_to):
     # Make sure that calling isinstance with a deeply nested tuple for its

Modules/_abc.c

@@ -603,21 +603,19 @@ _abc__abc_register_impl(PyObject *module, PyObject *self, PyObject *subclass)
         return NULL;
     }
 
-    if (!PyTuple_Check(mro)) {
-        PyErr_SetString(PyExc_TypeError, "__mro__ is not tuple");
+    if (!PyTuple_CheckExact(mro)) {
+        PyErr_SetString(PyExc_TypeError, "__mro__ must be an exact tuple");
         goto error;
     }
 
     for (Py_ssize_t pos = 0; pos < PyTuple_GET_SIZE(mro); pos++) {
         PyObject *base_class = PyTuple_GET_ITEM(mro, pos);  // borrowed
         PyObject *base_class_data;
 
-        if (PyObject_GetOptionalAttr(base_class, &_Py_ID(_abc_impl),
-                                 &base_class_data) < 0) {
-            goto error;
-        }
-
-        if (PyErr_Occurred()) {
+        if (PyObject_GetOptionalAttr(base_class,
+                                     &_Py_ID(_abc_impl),
+                                     &base_class_data) < 0)
+        {
             goto error;
         }
 
@@ -627,8 +625,11 @@ _abc__abc_register_impl(PyObject *module, PyObject *self, PyObject *subclass)
         }
 
         _abc_data *base_class_state = _abc_data_CAST(base_class_data);
-        if (_add_to_weak_set(base_class_state, &base_class_state->_abc_registry, subclass) < 0) {
-            Py_DECREF(base_class_data);
+        int res = _add_to_weak_set(base_class_state,
+                                   &base_class_state->_abc_registry,
+                                   subclass);
+        Py_DECREF(base_class_data);
+        if (res < 0) {
             goto error;
         }
     }
@@ -763,7 +764,6 @@ _abc__abc_subclasscheck_impl(PyObject *module, PyObject *self,
 
     PyObject *ok, *subclasses = NULL, *result = NULL;
     _abcmodule_state *state = NULL;
-    Py_ssize_t pos;
     int incache;
     _abc_data *impl = _get_impl(module, self);
     if (impl == NULL) {
@@ -850,45 +850,6 @@ _abc__abc_subclasscheck_impl(PyObject *module, PyObject *self,
         goto end;
     }
 
-    /* 6. Check if it's a subclass of a subclass (recursive).
-        >>> class Ancestor: __subclasses__ = lambda: [Other]
-        >>> class Other: pass
-        >>> isinstance(Other, Ancestor) is True
-
-      Do not iterate over cls.__subclasses__() because it returns the entire class tree,
-      not just direct children, which leads to O(n^2) lookup.
-    */
-    PyObject *dict = _PyType_GetDict(cls); // borrowed
-    PyObject *subclasses_own_method = PyDict_GetItemString(dict, "__subclasses__"); // borrowed
-    if (subclasses_own_method) {
-      subclasses = PyObject_CallNoArgs(subclasses_own_method);
-      if (subclasses == NULL) {
-          goto end;
-      }
-      if (!PyList_Check(subclasses)) {
-          PyErr_SetString(PyExc_TypeError, "__subclasses__() must return a list");
-          goto end;
-      }
-      for (pos = 0; pos < PyList_GET_SIZE(subclasses); pos++) {
-          PyObject *scls = PyList_GetItemRef(subclasses, pos);
-          if (scls == NULL) {
-              goto end;
-          }
-          int r = PyObject_IsSubclass(subclass, scls);
-          Py_DECREF(scls);
-          if (r > 0) {
-              if (_add_to_weak_set(impl, &impl->_abc_cache, subclass) < 0) {
-                  goto end;
-              }
-              result = Py_True;
-              goto end;
-          }
-          if (r < 0) {
-              goto end;
-          }
-      }
-    }
-
     /* No dice; update negative cache. */
     if (_add_to_weak_set(impl, &impl->_abc_negative_cache, subclass) < 0) {
         goto end;