python · JelleZijlstra · Apr 16, 2022 · Mar 6, 2022 · Mar 7, 2022 · Mar 7, 2022
@@ -2407,6 +2407,32 @@ Functions and decorators

   See :pep:`484` for details and comparison with other typing semantics.

+   .. versionchanged:: 3.11
+      Overloaded functions can now be introspected at runtime using :func:`get_overloads`.
+
+
+.. function:: get_overloads(func)
+
+   Return a sequence of :func:`@overload <overload>`-decorated definitions for *func*. *func* is
+   the function object for the implementation of the overloaded function.
+   For example, given the definition of ``process`` in the documentation for
+   :func:`@overload <overload>`, ``get_overloads(process)`` will return a sequence of three
+   function objects for the three defined overloads.
+
+   This function can be used for introspecting an overloaded function at runtime.
+
+   .. versionadded:: 3.11
+
+
+.. function:: clear_overloads(func=None)
+
+   Clear all registered overloads for the given *func*. If *func* is None, clear
+   all overloads stored in the internal registry. This can be used to reclaim the
+   memory used by the registry.
+
+   .. versionadded:: 3.11
+
+
 .. decorator:: final

   A decorator to indicate to type checkers that the decorated method

@@ -1,15 +1,18 @@
 import contextlib
 import collections
+from collections import defaultdict
 from functools import lru_cache
 import inspect
 import pickle
 import re
 import sys
 import warnings
 from unittest import TestCase, main, skipUnless, skip
+from unittest.mock import patch
 from copy import copy, deepcopy

 from typing import Any, NoReturn, Never, assert_never
+from typing import overload, get_overloads, clear_overloads
 from typing import TypeVar, TypeVarTuple, Unpack, AnyStr
 from typing import T, KT, VT  # Not in __all__.
 from typing import Union, Optional, Literal
@@ -3850,11 +3853,22 @@ def test_or(self):
        self.assertEqual("x" | X, Union["x", X])


+@lru_cache()
+def cached_func(x, y):
+    return 3 * x + y
+
+
+class MethodHolder:
+    @classmethod
+    def clsmethod(cls): ...
+    @staticmethod
+    def stmethod(): ...
+    def method(self): ...
+
+
 class OverloadTests(BaseTestCase):

    def test_overload_fails(self):
-        from typing import overload
-
        with self.assertRaises(RuntimeError):

            @overload
@@ -3864,8 +3878,6 @@ def blah():
            blah()

    def test_overload_succeeds(self):
-        from typing import overload
-
        @overload
        def blah():
            pass
@@ -3875,6 +3887,52 @@ def blah():

        blah()

+    def set_up_overloads(self):
+        def blah():
+            pass
+
+        overload1 = blah
+        overload(blah)
+
+        def blah():
+            pass
+
+        overload2 = blah
+        overload(blah)
+
+        def blah():
+            pass
+
+        return blah, [overload1, overload2]
+
+    # Make sure we don't clear the global overload registry
+    @patch("typing._overload_registry",
+        defaultdict(lambda: defaultdict(dict)))
+    def test_overload_registry(self):
+        self.assertEqual(len(typing._overload_registry), 0)
+
+        impl, overloads = self.set_up_overloads()
+        self.assertNotEqual(typing._overload_registry, {})
+        self.assertEqual(list(get_overloads(impl)), overloads)
+
+        clear_overloads(impl)
+        self.assertEqual(typing._overload_registry, {})
+        self.assertEqual(get_overloads(impl), [])
+
+        impl, overloads = self.set_up_overloads()
+        self.assertNotEqual(typing._overload_registry, {})
+        self.assertEqual(list(get_overloads(impl)), overloads)
+
+        clear_overloads()
+        self.assertEqual(typing._overload_registry, {})
+        self.assertEqual(get_overloads(impl), [])
+
+    def test_overload_registry_repeated(self):
+        for _ in range(2):
+            impl, overloads = self.set_up_overloads()
+
+            self.assertEqual(list(get_overloads(impl)), overloads)
+

 # Definitions needed for features introduced in Python 3.6


@@ -21,6 +21,7 @@

 from abc import abstractmethod, ABCMeta
 import collections
+from collections import defaultdict
 import collections.abc
 import contextlib
 import functools
@@ -121,9 +122,11 @@ def _idfunc(_, x):
    'assert_type',
    'assert_never',
    'cast',
+    'clear_overloads',
    'final',
    'get_args',
    'get_origin',
+    'get_overloads',
    'get_type_hints',
    'is_typeddict',
    'LiteralString',
@@ -2429,6 +2432,10 @@ def _overload_dummy(*args, **kwds):
        "by an implementation that is not @overload-ed.")


+# {module: {qualname: {firstlineno: func}}}
+_overload_registry = defaultdict(lambda: defaultdict(dict))
+
+
 def overload(func):
    """Decorator for overloaded functions/methods.

@@ -2454,10 +2461,46 @@ def utf8(value: bytes) -> bytes: ...
      def utf8(value: str) -> bytes: ...
      def utf8(value):
          # implementation goes here
+
+    The overloads for a function can be retrieved at runtime using the
+    get_overloads() function.
    """
+    # classmethod and staticmethod
+    f = getattr(func, "__func__", func)
+    try:
+        _overload_registry[f.__module__][f.__qualname__][f.__code__.co_firstlineno] = func
+    except AttributeError:
+        # Not a normal function; ignore.
+        pass
    return _overload_dummy


+def get_overloads(func):
+    """Return all defined overloads for *func* as a sequence."""
+    # classmethod and staticmethod
+    f = getattr(func, "__func__", func)
+    if f.__module__ not in _overload_registry:
+        return []
+    mod_dict = _overload_registry[f.__module__]
+    if f.__qualname__ not in mod_dict:
+        return []
+    return list(mod_dict[f.__qualname__].values())
+
+
+def clear_overloads(func=None):
+    """Clear all overloads for the given function (or all functions)."""
+    if func is None:
+        _overload_registry.clear()
+    else:
+        f = getattr(func, "__func__", func)
+        if f.__module__ not in _overload_registry:
+            return
+        mod_dict = _overload_registry[f.__module__]
+        mod_dict.pop(f.__qualname__, None)
+        if not mod_dict:
+            del _overload_registry[f.__module__]
+
+
 def final(f):
    """A decorator to indicate final methods and final classes.


diff --git a/Misc/NEWS.d/next/Library/2022-03-06-18-15-32.bpo-45100.B_lHu0.rst b/Misc/NEWS.d/next/Library/2022-03-06-18-15-32.bpo-45100.B_lHu0.rst
@@ -0,0 +1,2 @@
+Add :func:`typing.get_overloads` and :func:`typing.clear_overloads`.
+Patch by Jelle Zijlstra.
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		Add :func:`typing.get_overloads` and :func:`typing.clear_overloads`.
		Patch by Jelle Zijlstra.