Add @typing.override

CHANGELOG.md

@@ -1,7 +1,10 @@
 # Release 4.4.0 ()
+
 - Add `typing_extensions.Any` a backport of python 3.11's Any class which is
   subclassable at runtime. (backport from python/cpython#31841, by Shantanu 
   and Jelle Zijlstra). Patch by James Hilton-Balfe (@Gobot1234).
+- Runtime support for PEP 698, adding `typing_extensions.override`. Patch by
+  Jelle Zijlstra.
 
 # Release 4.3.0 (July 1, 2022)
 

src/test_typing_extensions.py

@@ -29,6 +29,7 @@
 from typing_extensions import assert_type, get_type_hints, get_origin, get_args
 from typing_extensions import clear_overloads, get_overloads, overload
 from typing_extensions import NamedTuple
+from typing_extensions import override
 from _typed_dict_test_helper import FooGeneric
 
 # Flags used to mark tests that only apply after a specific
@@ -160,6 +161,20 @@ def test_exception(self):
             assert_never(None)
 
 
+class OverrideTests(BaseTestCase):
+    def test_override(self):
+        class Base:
+            def foo(self): ...
+
+        class Derived(Base):
+            @override
+            def foo(self):
+                return 42
+
+        self.assertIsSubclass(Derived, Base)
+        self.assertEqual(Derived().foo(), 42)
+
+
 class AnyTests(BaseTestCase):
     def test_can_subclass(self):
         class Mock(Any): pass

src/typing_extensions.py

@@ -61,6 +61,7 @@
     'Literal',
     'NewType',
     'overload',
+    'override',
     'Protocol',
     'reveal_type',
     'runtime',
@@ -2000,6 +2001,34 @@ def decorator(cls_or_fn):
         return decorator
 
 
+if hasattr(typing, "override"):
+    override = typing.override
+else:
+    _T = typing.TypeVar("_T", bound=typing.Callable[..., typing.Any])
+
+    def override(__arg: _T) -> _T:
+        """Indicate that a method overrides a method in a base class.
+
+        Usage:
+
+            class Base:
+                def method(self) -> None: ...
+                    pass
+
+            class Child(Base):
+                @override
+                def method(self) -> None:
+                    super().method()
+
+        When this decorator is applied to a method, the type checker will
+        validate that it overrides a method with the same name on a base class.
+        This helps prevent bugs that may occur when the base class is changed
+        without an equivalent change to a child class.
+
+        """
+        return __arg
+
+
 # We have to do some monkey patching to deal with the dual nature of
 # Unpack/TypeVarTuple:
 # - We want Unpack to be a kind of TypeVar so it gets accepted in