Require all overloads be either sync or async

mypy/checker.py

@@ -622,6 +622,7 @@ def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
 
     def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         num_abstract = 0
+        num_async = 0
         if not defn.items:
             # In this case we have already complained about none of these being
             # valid overloads.
@@ -643,8 +644,11 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
                 self.visit_decorator_inner(fdef, allow_empty=True)
             if fdef.func.abstract_status in (IS_ABSTRACT, IMPLICITLY_ABSTRACT):
                 num_abstract += 1
+            if fdef.func.is_coroutine:
+                num_async += 1
         if num_abstract not in (0, len(defn.items)):
             self.fail(message_registry.INCONSISTENT_ABSTRACT_OVERLOAD, defn)
+        self.check_sync_or_async_overloads(defn, num_async)
         if defn.impl:
             defn.impl.accept(self)
         if not defn.is_property:
@@ -698,6 +702,22 @@ def extract_callable_type(self, inner_type: Type | None, ctx: Context) -> Callab
                 self.msg.not_callable(inner_type, ctx)
         return outer_type
 
+    def check_sync_or_async_overloads(self, defn: OverloadedFuncDef, num_async: int) -> None:
+        if isinstance(defn.impl, Decorator):
+            impl_type: bool | None = defn.impl.func.is_coroutine
+        elif isinstance(defn.impl, FuncDef):
+            impl_type = defn.impl.is_coroutine
+        else:
+            impl_type = None
+
+        len_items = len(defn.items)
+        if (
+            num_async not in (0, len_items)
+            or (num_async == 0 and impl_type is True)
+            or (num_async == len_items and impl_type is False)
+        ):
+            self.fail(message_registry.INCONSISTENT_ASYNC_OVERLOAD.format(), defn)
+
     def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
         # At this point we should have set the impl already, and all remaining
         # items are decorators

mypy/message_registry.py

@@ -97,6 +97,9 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 INCONSISTENT_ABSTRACT_OVERLOAD: Final = ErrorMessage(
     "Overloaded method has both abstract and non-abstract variants"
 )
+INCONSISTENT_ASYNC_OVERLOAD: Final = ErrorMessage(
+    "All overloaded items but be either sync or async"
+)
 MULTIPLE_OVERLOADS_REQUIRED: Final = ErrorMessage("Single overload definition, multiple required")
 READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE: Final = ErrorMessage(
     "Read-only property cannot override read-write property"

test-data/unit/check-overloading.test

@@ -6674,3 +6674,43 @@ c2 = MyCallable("test")
 reveal_type(c2)  # N: Revealed type is "__main__.MyCallable[builtins.str]"
 reveal_type(c2()) # should be int  # N: Revealed type is "builtins.int"
 [builtins fixtures/tuple.pyi]
+
+[case testAllOverloadsAreEitherSyncOrAsync]
+from typing import overload, Union
+
+# Correct async:
+
+@overload
+async def iter_data1(s: str) -> str: ...
+@overload
+async def iter_data1(s: int) -> int: ...
+async def iter_data1(s): ...
+
+# Correct sync:
+@overload
+def iter_data2(s: str) -> str: ...
+@overload
+def iter_data2(s: int) -> int: ...
+def iter_data2(s): ...
+
+# Mixed items:
+@overload  # E: All overloaded items but be either sync or async
+async def iter_data3(s: str) -> str: ...
+@overload
+def iter_data3(s: int) -> int: ...
+def iter_data3(s): ...
+
+# Wrong sync impl:
+@overload  # E: All overloaded items but be either sync or async
+async def iter_data4(s: str) -> str: ...
+@overload
+async def iter_data4(s: int) -> int: ...
+def iter_data4(s): ...
+
+# Wrong async impl:
+@overload  # E: All overloaded items but be either sync or async
+def iter_data5(s: str) -> str: ...
+@overload
+def iter_data5(s: int) -> int: ...
+async def iter_data5(s): ...
+[builtins fixtures/tuple.pyi]