disallow exactly same overloads with different return value

Author: alexdrydew

mypy/checker.py

@@ -8059,8 +8059,6 @@ def get_type_var_group_variants(
 
 def expand_callable_self(c: CallableType) -> CallableType:
     for tv in c.variables:
-        # We need to expand self-type before other variables, because this is the only
-        # type variable that can have other type variables in the upper bound.
         if tv.id.is_self():
             return expand_type(c, {tv.id: tv.upper_bound}).copy_modified(
                 variables=[v for v in c.variables if not v.id.is_self()]
@@ -8142,14 +8140,32 @@ def is_unsafe_overlapping_overload_signatures(
         # Using the same `allow_partial_overlap` flag as before, can cause false
         # negatives in case where star argument is used in a catch-all fallback overload.
         # But again, practicality beats purity here.
-        if not partial_only or not is_callable_compatible(
-            other_variant,
-            sig_variant,
-            is_compat=is_subset_no_promote,
-            check_args_covariantly=True,
-            is_proper_subtype=False,
-            ignore_return=True,
-            allow_partial_overlap=True,
+
+        # Also earlier overload may not be more general overall but is more general when
+        # narrowed to common calls is handled here, so there is no unsafe overlap because
+        # it will still be caught by the earlier overload.
+        # Exeption here is when signature variants are exactly the same, in which case we
+        # should still consider them overlapping.
+        if (
+            not partial_only
+            or not is_callable_compatible(
+                other_variant,
+                sig_variant,
+                is_compat=is_subset_no_promote,
+                check_args_covariantly=True,
+                is_proper_subtype=False,
+                ignore_return=True,
+                allow_partial_overlap=True,
+            )
+            or is_callable_compatible(
+                sig_variant,
+                other_variant,
+                is_compat=lambda l, r: l == r,
+                check_args_covariantly=False,
+                is_proper_subtype=False,
+                ignore_return=True,
+                allow_partial_overlap=False,
+            )
         ):
             return True
     return False

test-data/unit/check-overloading.test

@@ -1327,9 +1327,8 @@ def h(x: Sequence[str]) -> int: pass
 @overload
 def h(x: Sequence[T]) -> None: pass  # E: Overloaded function signature 2 will never be matched: signature 1's parameter type(s) are the same or broader
 
-# Safety of this highly depends on the implementation, so we lean towards being silent.
 @overload
-def i(x: List[str]) -> int: pass
+def i(x: List[str]) -> int: pass  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
 @overload
 def i(x: List[T]) -> None: pass
 [builtins fixtures/list.pyi]
@@ -6768,3 +6767,18 @@ class D(Generic[T]):
 a: D[str]  # E: Type argument "str" of "D" must be a subtype of "C"
 reveal_type(a.f(1))  # N: Revealed type is "builtins.int"
 reveal_type(a.f("x"))  # N: Revealed type is "builtins.str"
+
+
+[case testOverloadOnExactSameTypeVariantWithIncompetibleReturnTypes]
+from typing import TypeVar, overload
+
+class A: pass
+class B: pass
+
+T = TypeVar('T', A, B)
+
+@overload
+def f(x: B) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+@overload
+def f(x: T) -> str: ...
+def f(x): ...