stubtest: relax async checking for abstract methods

mypy/stubtest.py

@@ -734,14 +734,31 @@ def verify_funcitem(
     # That results in false positives.
     # See https://github.com/python/typeshed/issues/7344
     if runtime_is_coroutine and not stub.is_coroutine:
-        yield Error(
-            object_path,
-            'is an "async def" function at runtime, but not in the stub',
-            stub,
-            runtime,
-            stub_desc=stub_desc,
-            runtime_desc=runtime_sig_desc
-        )
+        if (
+            getattr(runtime, "__isabstractmethod__", False)
+            or (isinstance(stub, nodes.FuncDef) and stub.is_abstract)
+        ):
+            # Be more permissive if the method is an abstractmethod:
+            # Only error if the return type of the stub isn't awaitable
+            if isinstance(stub.type, mypy.types.CallableType):
+                ret_type = mypy.types.get_proper_type(stub.type.ret_type)
+                should_error = (
+                    isinstance(ret_type, mypy.types.Instance)
+                    and "__await__" not in ret_type.type.names
+                )
+            else:
+                should_error = False
+        else:
+            should_error = True
+        if should_error:
+            yield Error(
+                object_path,
+                'is an "async def" function at runtime, but not in the stub',
+                stub,
+                runtime,
+                stub_desc=stub_desc,
+                runtime_desc=runtime_sig_desc
+            )
 
     if not signature:
         return

mypy/test/teststubtest.py

@@ -54,8 +54,11 @@ def __init__(self, name, covariant: bool = ..., contravariant: bool = ...) -> No
 _S = TypeVar("_S", contravariant=True)
 _R = TypeVar("_R", covariant=True)
 
-class Coroutine(Generic[_T_co, _S, _R]): ...
 class Iterable(Generic[_T_co]): ...
+class Generator(Iterable[_T_co], Generic[_T_co, _S, _R]): ...
+class Awaitable(Generic[_T_co]):
+    def __await__(self) -> Generator[Any, None, _T_co]: ...
+class Coroutine(Generic[_T_co, _S, _R]): ...
 class Mapping(Generic[_K, _V]): ...
 class Sequence(Iterable[_T_co]): ...
 class Tuple(Sequence[_T_co]): ...
@@ -229,6 +232,54 @@ def test_coroutines(self) -> Iterator[Case]:
             runtime="async def bingo(): return 5",
             error=None,
         )
+        # Be more permissive if it's an abstractmethod in the stub...
+        yield Case(
+            stub="""
+            from abc import abstractmethod
+            from typing import Awaitable
+            class Bar:
+                @abstractmethod
+                def abstract(self) -> Awaitable[int]: ...
+            """,
+            runtime="""
+            class Bar:
+                async def abstract(self): return 5
+            """,
+            error=None,
+        )
+        # ...and/or an abstractmethod at runtime...
+        yield Case(
+            stub="""
+            from typing import Generator, Any
+            class _CustomAwaitable:
+                def __await__(self) -> Generator[Any, Any, Any]: ...
+            class Foo:
+                def abstract(self) -> _CustomAwaitable: ...
+            """,
+            runtime="""
+            from abc import abstractmethod
+            class Foo:
+                @abstractmethod
+                async def abstract(self): return 5
+            """,
+            error=None,
+        )
+        # ...but still error if the stub's return type isn't awaitable
+        yield Case(
+            stub="""
+            from abc import abstractmethod
+            class Baz:
+                @abstractmethod
+                def abstract(self) -> int: ...
+            """,
+            runtime="""
+            from abc import abstractmethod
+            class Baz:
+                @abstractmethod
+                async def abstract(self): return 5
+            """,
+            error="Baz.abstract",
+        )
 
     @collect_cases
     def test_arg_name(self) -> Iterator[Case]: