Add some checks for edge cases.

Author: ZeroIntensity

Lib/functools.py

@@ -929,6 +929,32 @@ def _is_valid_dispatch_type(cls):
         return (_is_union_type(cls) and
                 all(isinstance(arg, type) for arg in get_args(cls)))
 
+    def _skip_self_type(argname, cls, hints_iter):
+        # GH-130827: Methods are sometimes annotated with
+        # typing.Self. We should skip that when it's a valid type.
+        from typing import Self
+        if cls is not Self:
+            return argname, cls
+        if not is_method:
+            # typing.Self is not valid in a normal function
+            raise TypeError(
+                f"Invalid annotation for {argname!r}. "
+                "typing.Self can only be used with singledispatchmethod()"
+            )
+        try:
+            argname, cls = next(hints_iter)
+            return argname, cls
+        except StopIteration:
+            # The method is one of some invalid edge cases:
+            # 1. method(self: Self) -> ...
+            # 2. method(self, weird: Self) -> ...
+            # 3. method(self: Self, unannotated) -> ...
+            raise TypeError(
+                f"Invalid annotation for {argname!r}. "
+                "typing.Self must be the first annotation and must "
+                "have a second parameter with an annotation"
+            ) from None
+
     def register(cls, func=None):
         """generic_func.register(cls, func) -> func
 
@@ -955,18 +981,11 @@ def register(cls, func=None):
             func = cls
 
             # only import typing if annotation parsing is necessary
-            from typing import get_type_hints, Self
+            from typing import get_type_hints
             from annotationlib import Format, ForwardRef
             hints_iter = iter(get_type_hints(func, format=Format.FORWARDREF).items())
             argname, cls = next(hints_iter)
-            if cls is Self:
-                if not is_method:
-                    raise TypeError(
-                        f"Invalid annotation for {argname!r}. ",
-                        "typing.Self can only be used with singledispatchmethod()"
-                    )
-                else:
-                    argname, cls = next(hints_iter)
+            argname, cls = _skip_self_type(argname, cls, hints_iter)
 
             if not _is_valid_dispatch_type(cls):
                 if _is_union_type(cls):

Lib/test/test_functools.py

@@ -3376,15 +3376,48 @@ def _(self: typing.Self, arg: int) -> int:
         foo = Foo()
         self.assertEqual(foo.bar(42), 42)
 
+        # But, it shouldn't work on singledispatch()
         @functools.singledispatch
         def test(self: typing.Self, arg: int | str) -> int | str:
             pass
-        # But, it shouldn't work on singledispatch()
         with self.assertRaises(TypeError):
             @test.register
             def silly(self: typing.Self, arg: int | str) -> int | str:
                 pass
 
+        # typing.Self cannot be the only annotation
+        with self.assertRaises(TypeError):
+            class Foo:
+                @functools.singledispatchmethod
+                def bar(self: typing.Self, arg: int | str):
+                    pass
+
+                @bar.register
+                def _(self: typing.Self, arg):
+                    return arg
+
+        # typing.Self can only be used in the first parameter
+        with self.assertRaises(TypeError):
+            class Foo:
+                @functools.singledispatchmethod
+                def bar(self, arg: int | str):
+                    pass
+
+                @bar.register
+                def _(self, arg: typing.Self):
+                    return arg
+
+         # 'self' cannot be the only parameter
+         with self.assertRaises(TypeError):
+             class Foo:
+                 @functools.singledispatchmethod
+                 def bar(self: typing.Self, arg: int | str):
+                     pass
+
+                 @bar.register
+                 def _(self: typing.Self):
+                     pass
+
 
 class CachedCostItem:
     _cost = 1