Merge branch 'main' into gh-636-backport-137281-param-order

Author: brianschubert

CHANGELOG.md

@@ -5,6 +5,9 @@
   with type variables. Now, parametrized `Generic` or `Protocol` base classes always
   dictate the number and the order of the type parameters. Patch by Brian Schubert,
   backporting a CPython PR by Nikita Sobolev.
+- Fix `__init_subclass__()` behavior in the presence of multiple inheritance involving
+  an `@deprecated`-decorated base class. Backport of CPython PR
+  [#138210](https://github.com/python/cpython/pull/138210) by Brian Schubert.
 - Raise `TypeError` when attempting to subclass `typing_extensions.ParamSpec` on
   Python 3.9. The `typing` implementation has always raised an error, and the
   `typing_extensions` implementation has raised an error on Python 3.10+ since

doc/conf.py

@@ -56,6 +56,10 @@
 # Don't include object entries (e.g. functions, classes) in the table of contents.
 toc_object_entries = False
 
+# Warn about all references where the target cannot be found.
+nitpicky = True
+
+
 class MyTranslator(HTML5Translator):
     """Adds a link target to name without `typing_extensions.` prefix."""
     def visit_desc_signature(self, node: Element) -> None:

doc/index.rst

@@ -303,7 +303,7 @@ Special typing primitives
       ``default=None`` is passed, and to :data:`NoDefault` if no value is passed.
 
       Previously, passing ``None`` would result in :attr:`!__default__` being set
-      to :py:class:`types.NoneType`, and passing no value for the parameter would
+      to :py:data:`types.NoneType`, and passing no value for the parameter would
       result in :attr:`!__default__` being set to ``None``.
 
    .. versionchanged:: 4.12.0
@@ -312,10 +312,9 @@ Special typing primitives
       with :py:class:`typing.ParamSpec` on Python 3.13+.
 
 .. class:: ParamSpecArgs
+           ParamSpecKwargs
 
-.. class:: ParamSpecKwargs
-
-   See :py:class:`typing.ParamSpecArgs` and :py:class:`typing.ParamSpecKwargs`.
+   See :py:data:`typing.ParamSpecArgs` and :py:data:`typing.ParamSpecKwargs`.
    In ``typing`` since 3.10.
 
 .. class:: Protocol
@@ -471,7 +470,7 @@ Special typing primitives
 
       ``TypedDict`` is now a function rather than a class.
       This brings ``typing_extensions.TypedDict`` closer to the implementation
-      of :py:mod:`typing.TypedDict` on Python 3.9 and higher.
+      of :py:class:`typing.TypedDict` on Python 3.9 and higher.
 
    .. versionchanged:: 4.7.0
 
@@ -526,7 +525,7 @@ Special typing primitives
       ``default=None`` is passed, and to :data:`NoDefault` if no value is passed.
 
       Previously, passing ``None`` would result in :attr:`!__default__` being set
-      to :py:class:`types.NoneType`, and passing no value for the parameter would
+      to :py:data:`types.NoneType`, and passing no value for the parameter would
       result in :attr:`!__default__` being set to ``None``.
 
    .. versionchanged:: 4.12.0
@@ -557,7 +556,7 @@ Special typing primitives
       ``default=None`` is passed, and to :data:`NoDefault` if no value is passed.
 
       Previously, passing ``None`` would result in :attr:`!__default__` being set
-      to :py:class:`types.NoneType`, and passing no value for the parameter would
+      to :py:data:`types.NoneType`, and passing no value for the parameter would
       result in :attr:`!__default__` being set to ``None``.
 
    .. versionchanged:: 4.12.0
@@ -799,7 +798,7 @@ Functions
    * Raises :exc:`TypeError` when it encounters certain objects that are
      not valid type hints.
    * Replaces type hints that evaluate to :const:`!None` with
-     :class:`types.NoneType`.
+     :data:`types.NoneType`.
    * Supports the :attr:`Format.FORWARDREF` and
      :attr:`Format.STRING` formats.
 
@@ -1369,7 +1368,7 @@ versions of Python, but all are listed here for completeness.
 
 .. data:: Union
 
-   See :py:data:`typing.Union`.
+   See :py:class:`typing.Union`.
 
    .. versionadded:: 4.7.0
 

src/test_typing_extensions.py

@@ -813,6 +813,25 @@ class D(C, x=3):
 
         self.assertEqual(D.inited, 3)
 
+    def test_existing_init_subclass_in_sibling_base(self):
+        @deprecated("A will go away soon")
+        class A:
+            pass
+        class B:
+            def __init_subclass__(cls, x):
+                super().__init_subclass__()
+                cls.inited = x
+
+        with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):
+            class C(A, B, x=42):
+                pass
+        self.assertEqual(C.inited, 42)
+
+        with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):
+            class D(B, A, x=42):
+                pass
+        self.assertEqual(D.inited, 42)
+
     def test_init_subclass_has_correct_cls(self):
         init_subclass_saw = None
 

src/typing_extensions.py

@@ -2903,9 +2903,9 @@ def method(self) -> None:
         return arg
 
 
-# Python 3.13.3+ contains a fix for the wrapped __new__
-# Breakpoint: https://github.com/python/cpython/pull/132160
-if sys.version_info >= (3, 13, 3):
+# Python 3.13.8+ and 3.14.1+ contain a fix for the wrapped __init_subclass__
+# Breakpoint: https://github.com/python/cpython/pull/138210
+if ((3, 13, 8) <= sys.version_info < (3, 14)) or sys.version_info >= (3, 14, 1):
     deprecated = warnings.deprecated
 else:
     _T = typing.TypeVar("_T")
@@ -2998,27 +2998,27 @@ def __new__(cls, /, *args, **kwargs):
 
                 arg.__new__ = staticmethod(__new__)
 
-                original_init_subclass = arg.__init_subclass__
-                # We need slightly different behavior if __init_subclass__
-                # is a bound method (likely if it was implemented in Python)
-                if isinstance(original_init_subclass, MethodType):
-                    original_init_subclass = original_init_subclass.__func__
+                if "__init_subclass__" in arg.__dict__:
+                    # __init_subclass__ is directly present on the decorated class.
+                    # Synthesize a wrapper that calls this method directly.
+                    original_init_subclass = arg.__init_subclass__
+                    # We need slightly different behavior if __init_subclass__
+                    # is a bound method (likely if it was implemented in Python).
+                    # Otherwise, it likely means it's a builtin such as
+                    # object's implementation of __init_subclass__.
+                    if isinstance(original_init_subclass, MethodType):
+                        original_init_subclass = original_init_subclass.__func__
 
                     @functools.wraps(original_init_subclass)
                     def __init_subclass__(*args, **kwargs):
                         warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
                         return original_init_subclass(*args, **kwargs)
-
-                    arg.__init_subclass__ = classmethod(__init_subclass__)
-                # Or otherwise, which likely means it's a builtin such as
-                # object's implementation of __init_subclass__.
                 else:
-                    @functools.wraps(original_init_subclass)
-                    def __init_subclass__(*args, **kwargs):
+                    def __init_subclass__(cls, *args, **kwargs):
                         warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
-                        return original_init_subclass(*args, **kwargs)
+                        return super(arg, cls).__init_subclass__(*args, **kwargs)
 
-                    arg.__init_subclass__ = __init_subclass__
+                arg.__init_subclass__ = classmethod(__init_subclass__)
 
                 arg.__deprecated__ = __new__.__deprecated__ = msg
                 __init_subclass__.__deprecated__ = msg