@@ -862,7 +862,7 @@ def _is_valid_dispatch_type(cls):
         return (_is_union_type(cls) and
                 all(isinstance(arg, type) for arg in get_args(cls)))
 
-    def register(cls, func=None):
+    def register(cls, func=None, _arg_index=0):
         """generic_func.register(cls, func) -> func
 
         Registers a new implementation for the given *cls* on a *generic_func*.
@@ -878,8 +878,13 @@ def register(cls, func=None):
                     f"Invalid first argument to `register()`. "
                     f"{cls!r} is not a class or union type."
                 )
+            import inspect
+            try:
+                args = list(inspect.signature(cls).parameters.keys())
+            except TypeError:
+                args = []
             ann = getattr(cls, '__annotations__', {})
-            if not ann:
+            if len(args) <= _arg_index or args[_arg_index] not in ann:
                 raise TypeError(
                     f"Invalid first argument to `register()`: {cls!r}. "
                     f"Use either `@register(some_class)` or plain `@register` "
@@ -954,7 +959,7 @@ def register(self, cls, method=None):
 
         Registers a new implementation for the given *cls* on a *generic_method*.
         """
-        return self.dispatcher.register(cls, func=method)
+        return self.dispatcher.register(cls, func=method, _arg_index=1)
 
     def __get__(self, obj, cls=None):
         if self._method_cache is not None:

@@ -2865,6 +2865,39 @@ def _(arg: typing.Union[int, typing.Iterable[str]]):
             'typing.Union[int, typing.Iterable[str]] not all arguments are classes.'
         ))
 
+        with self.assertRaises(TypeError) as exc:
+            @i.register
+            def _(arg) -> str:
+                # At runtime, dispatching on generics is impossible.
+                # When registering implementations with singledispatch, avoid
+                # types from `typing`. Instead, annotate with regular types
+                # or ABCs.
+                return "I annotated with a generic collection"
+        self.assertTrue(str(exc.exception).startswith(
+            "Invalid first argument to `register()`:"
+        ))
+        self.assertTrue(str(exc.exception).endswith(
+            'Use either `@register(some_class)` or plain `@register` on an annotated function.'
+        ))
+
+        @functools.singledispatch
+        def i(arg1, arg2):
+            return "base"
+        with self.assertRaises(TypeError) as exc:
+            @i.register
+            def _(arg1, arg2: int) -> str:
+                # At runtime, dispatching on generics is impossible.
+                # When registering implementations with singledispatch, avoid
+                # types from `typing`. Instead, annotate with regular types
+                # or ABCs.
+                return "I annotated with a generic collection"
+        self.assertTrue(str(exc.exception).startswith(
+            "Invalid first argument to `register()`:"
+        ))
+        self.assertTrue(str(exc.exception).endswith(
+            'Use either `@register(some_class)` or plain `@register` on an annotated function.'
+        ))
+
     def test_invalid_positional_argument(self):
         @functools.singledispatch
         def f(*args):

diff --git a/Misc/NEWS.d/next/Library/2020-05-02-23-46-25.bpo-40464.MxGkfE.rst b/Misc/NEWS.d/next/Library/2020-05-02-23-46-25.bpo-40464.MxGkfE.rst
@@ -0,0 +1 @@
+Fix return annotation being used as the arg annotation in functools.singledispatch
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Fix return annotation being used as the arg annotation in functools.singledispatch