Tests and fixes for staticmethod

Author: johnslavik

Lib/functools.py

@@ -888,15 +888,15 @@ def _find_impl(cls, registry):
             match = t
     return registry.get(match)
 
-def _get_dispatch_param(func, *, _dispatchmethod=False):
+def _get_dispatch_param(func, *, _insideclass=False):
     """Finds the first positional and user-specified parameter in a callable
     or descriptor.
 
     Used by singledispatch for registration by type annotation of the parameter.
     """
     # Fast path for typical callables and descriptors.
     # idx is 0 when singledispatch() and 1 when singledispatchmethod()
-    idx = _dispatchmethod
+    idx = _insideclass
     if isinstance(func, staticmethod):
         idx = 0
         func = func.__func__
@@ -965,7 +965,7 @@ def _is_valid_dispatch_type(cls):
         return (isinstance(cls, UnionType) and
                 all(isinstance(arg, type) for arg in cls.__args__))
 
-    def register(cls, func=None, _dispatchmethod=False):
+    def register(cls, func=None, _insideclass=False):
         """generic_func.register(cls, func) -> func
 
         Registers a new implementation for the given *cls* on a *generic_func*.
@@ -990,7 +990,7 @@ def register(cls, func=None, _dispatchmethod=False):
                 )
             func = cls
 
-            argname = _get_dispatch_param(func, _dispatchmethod=_dispatchmethod)
+            argname = _get_dispatch_param(func, _insideclass=_insideclass)
             if argname is None:
                 raise TypeError(
                     f"Invalid first argument to `register()`: {func!r} "
@@ -1069,12 +1069,12 @@ def __init__(self, func):
         self.dispatcher = singledispatch(func)
         self.func = func
 
-    def register(self, cls, method=None):
+    def register(self, cls, method=None, _insideclass=True):
         """generic_method.register(cls, func) -> func
 
         Registers a new implementation for the given *cls* on a *generic_method*.
         """
-        return self.dispatcher.register(cls, func=method, _dispatchmethod=True)
+        return self.dispatcher.register(cls, func=method, _insideclass=_insideclass)
 
     def __get__(self, obj, cls=None):
         return _singledispatchmethod_get(self, obj, cls)
@@ -1149,7 +1149,7 @@ def __wrapped__(self):
 
     @property
     def register(self):
-        return self._unbound.register
+        return partial(self._unbound.register, _insideclass=False)
 
 
 ################################################################################

Lib/test/test_functools.py

@@ -2993,18 +2993,33 @@ def _(arg: int):
                 return isinstance(arg, int)
             @t.register
             @staticmethod
-            def _(arg: str):
+            def _(arg: str, /):
                 return isinstance(arg, str)
             @t.register
             @wrapper_decorator
             @staticmethod
-            def _(arg: bytes):
+            def _(arg: bytes) -> bool:
                 return isinstance(arg, bytes)
+            @wrapper_decorator
+            @staticmethod
+            def outer1(arg: complex):
+                return isinstance(arg, complex)
+            @wrapper_decorator
+            @staticmethod
+            def outer2(arg: bool):
+                return isinstance(arg, bool)
+
+        A.t.register(staticmethod(A.outer1))
         a = A()
+        a.t.register(staticmethod(a.outer2))
 
         self.assertTrue(A.t(0))
         self.assertTrue(A.t(''))
         self.assertEqual(A.t(0.0), 0.0)
+        self.assertTrue(A.t(0j))
+        self.assertTrue(a.t(42j))
+        self.assertTrue(A.t(True))
+        self.assertTrue(a.t(False))
 
     def test_classmethod_type_ann_register(self):
         def wrapper_decorator(func):