Address review; simplify

Author: AlexWaygood

mypy/meet.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from itertools import chain
 from typing import Callable
 
 from mypy import join
@@ -343,13 +342,20 @@ def _is_overlapping_types(left: Type, right: Type) -> bool:
     left_possible = get_possible_variants(left)
     right_possible = get_possible_variants(right)
 
-    # First handle a special case: comparing a `Parameters` to a `ParamSpecType`.
-    # This should always be considered an overlapping equality check.
-    # This needs to be done before we move on to other TypeVarLike comparisons.
-    if (isinstance(left, Parameters) and isinstance(right, ParamSpecType)) or (
-        isinstance(left, ParamSpecType) and isinstance(right, Parameters)
+    # First handle special cases relating to PEP 612:
+    # - comparing a `Parameters` to a `Parameters
+    # - comparing a `Parameters` to a `ParamSpecType`
+    # - comparing a `ParamSpecType` to a `ParamSpecType`
+    #
+    # This should all always be considered overlapping equality checks.
+    # These need to be done before we move on to other TypeVarLike comparisons.
+    if isinstance(left, (Parameters, ParamSpecType)) and isinstance(
+        right, (Parameters, ParamSpecType)
     ):
         return True
+    # A `Parameters` does not overlap with anything else, however
+    if isinstance(left, Parameters) or isinstance(right, Parameters):
+        return False
 
     # Now move on to checking multi-variant types like Unions. We also perform
     # the same logic if either type happens to be a TypeVar/ParamSpec/TypeVarTuple.
@@ -460,24 +466,6 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
     elif isinstance(right, CallableType):
         right = right.fallback
 
-    if isinstance(left, Parameters):
-        if not isinstance(right, Parameters):
-            return False
-        if len(left.arg_types) == len(right.arg_types):
-            return all(
-                _is_overlapping_types(left_arg, right_arg)
-                for left_arg, right_arg in zip(left.arg_types, right.arg_types)
-            )
-        if not any(
-            isinstance(arg, TypeVarLikeType) for arg in chain(left.arg_types, right.arg_types)
-        ):
-            return False
-        # TODO: Is this sound?
-        return True
-    if isinstance(right, Parameters):
-        assert not isinstance(left, (Parameters, TypeVarLikeType))
-        return False
-
     if isinstance(left, LiteralType) and isinstance(right, LiteralType):
         if left.value == right.value:
             # If values are the same, we still need to check if fallbacks are overlapping,

test-data/unit/pythoneval.test

@@ -1935,38 +1935,35 @@ P = ParamSpec("P")
 class Foo(Generic[P]): ...
 class Bar(Generic[P]): ...
 
-def bad1(foo1: Foo[[int]], foo2: Foo[[str]]) -> bool:
-    return foo1 == foo2
+def bad(foo: Foo[[int]], bar: Bar[[int]]) -> bool:
+    return foo == bar
 
-def bad2(foo1: Foo[[int, str]], foo2: Foo[[int, bytes]]) -> bool:
+def good1(foo1: Foo[[int]], foo2: Foo[[str]]) -> bool:
     return foo1 == foo2
 
-def bad3(foo1: Foo[[int]], foo2: Foo[[int, int]]) -> bool:
+def good2(foo1: Foo[[int, str]], foo2: Foo[[int, bytes]]) -> bool:
     return foo1 == foo2
 
-def bad4(foo: Foo[[int]], bar: Bar[[int]]) -> bool:
-    return foo == bar
+def good3(foo1: Foo[[int]], foo2: Foo[[int, int]]) -> bool:
+    return foo1 == foo2
 
-def good1(foo1: Foo[[int]], foo2: Foo[[int]]) -> bool:
+def good4(foo1: Foo[[int]], foo2: Foo[[int]]) -> bool:
     return foo1 == foo2
 
-def good2(foo1: Foo[[int]], foo2: Foo[[bool]]) -> bool:
+def good5(foo1: Foo[[int]], foo2: Foo[[bool]]) -> bool:
     return foo1 == foo2
 
-def good3(foo1: Foo[[int, int]], foo2: Foo[[bool, bool]]) -> bool:
+def good6(foo1: Foo[[int, int]], foo2: Foo[[bool, bool]]) -> bool:
     return foo1 == foo2
 
-def good4(foo1: Foo[[int]], foo2: Foo[P], *args: P.args, **kwargs: P.kwargs) -> bool:
+def good7(foo1: Foo[[int]], foo2: Foo[P], *args: P.args, **kwargs: P.kwargs) -> bool:
     return foo1 == foo2
 
-def good5(foo1: Foo[P], foo2: Foo[[int, str, bytes]], *args: P.args, **kwargs: P.kwargs) -> bool:
+def good8(foo1: Foo[P], foo2: Foo[[int, str, bytes]], *args: P.args, **kwargs: P.kwargs) -> bool:
     return foo1 == foo2
 
-def good6(foo1: Foo[Concatenate[int, P]], foo2: Foo[[int, str, bytes]], *args: P.args, **kwargs: P.kwargs) -> bool:
+def good9(foo1: Foo[Concatenate[int, P]], foo2: Foo[[int, str, bytes]], *args: P.args, **kwargs: P.kwargs) -> bool:
     return foo1 == foo2
 
 [out]
-_testStrictEqualitywithParamSpec.py:11: error: Non-overlapping equality check (left operand type: "Foo[[int]]", right operand type: "Foo[[str]]")
-_testStrictEqualitywithParamSpec.py:14: error: Non-overlapping equality check (left operand type: "Foo[[int, str]]", right operand type: "Foo[[int, bytes]]")
-_testStrictEqualitywithParamSpec.py:17: error: Non-overlapping equality check (left operand type: "Foo[[int]]", right operand type: "Foo[[int, int]]")
-_testStrictEqualitywithParamSpec.py:20: error: Non-overlapping equality check (left operand type: "Foo[[int]]", right operand type: "Bar[[int]]")
+_testStrictEqualitywithParamSpec.py:11: error: Non-overlapping equality check (left operand type: "Foo[[int]]", right operand type: "Bar[[int]]")