Rework narrowing logic for equality and identity (#20492)

Mypy does not narrow as much as it could, which results in false
positives.

We would also like to narrow based on containment. The PR for that was
previously reverted due to inconsistencies between narrowing via
equality and via containment. This fixes the inconsistency on the
equality side and paves the road for adding narrowing via containment.
That is, we lay groundwork for fixing
#17864 and fixing
#17841

Fixes #18524
Fixes #20041
Fixes #17162
Fixes #16830
Fixes #13704
Fixes #7642
Fixes #3964

Author: hauntsaninja

mypy/checker.py

@@ -9,6 +9,7 @@
 
 import argparse
 import sys
+from typing import Any, cast
 
 from mypy.main import infer_python_executable, process_options
 from mypy.options import Options
@@ -63,7 +64,7 @@ def test_executable_inference(self) -> None:
 
         # first test inferring executable from version
         options = Options()
-        options.python_executable = None
+        options.python_executable = cast(Any, None)
         options.python_version = sys.version_info[:2]
         infer_python_executable(options, special_opts)
         assert options.python_version == sys.version_info[:2]

mypy/test/testargs.py

@@ -194,12 +194,12 @@ def test_generic_function_type(self) -> None:
 
     def test_type_alias_expand_once(self) -> None:
         A, target = self.fx.def_alias_1(self.fx.a)
-        assert get_proper_type(A) == target
         assert get_proper_type(target) == target
+        assert get_proper_type(A) == target
 
         A, target = self.fx.def_alias_2(self.fx.a)
-        assert get_proper_type(A) == target
         assert get_proper_type(target) == target
+        assert get_proper_type(A) == target
 
     def test_recursive_nested_in_non_recursive(self) -> None:
         A, _ = self.fx.def_alias_1(self.fx.a)

mypy/test/testtypes.py

@@ -1005,7 +1005,7 @@ def is_singleton_type(typ: Type) -> bool:
     return typ.is_singleton_type()
 
 
-def try_expanding_sum_type_to_union(typ: Type, target_fullname: str) -> Type:
+def try_expanding_sum_type_to_union(typ: Type, target_fullname: str | None) -> Type:
     """Attempts to recursively expand any enum Instances with the given target_fullname
     into a Union of all of its component LiteralTypes.
 
@@ -1034,7 +1034,9 @@ class Status(Enum):
         ]
         return UnionType.make_union(items)
 
-    if isinstance(typ, Instance) and typ.type.fullname == target_fullname:
+    if isinstance(typ, Instance) and (
+        target_fullname is None or typ.type.fullname == target_fullname
+    ):
         if typ.type.fullname == "builtins.bool":
             return UnionType([LiteralType(True, typ), LiteralType(False, typ)])
 

mypy/typeops.py

@@ -4920,6 +4920,7 @@ def test_setattr() -> None:
     assert i.one == 1
     assert i.two == None
     assert i.const == 42
+    i = i
 
     i.__setattr__("two", "2")
     assert i.two == "2"
@@ -4957,6 +4958,7 @@ def test_setattr_inherited() -> None:
     assert i.one == 1
     assert i.two == None
     assert i.const == 42
+    i = i
 
     i.__setattr__("two", "2")
     assert i.two == "2"
@@ -4996,6 +4998,7 @@ def test_setattr_overridden() -> None:
     assert i.one == 1
     assert i.two == None
     assert i.const == 42
+    i = i
 
     i.__setattr__("two", "2")
     assert i.two == "2"
@@ -5064,6 +5067,7 @@ def test_setattr_nonnative() -> None:
     assert i.one == 1
     assert i.two == None
     assert i.const == 42
+    i = i
 
     i.__setattr__("two", "2")
     assert i.two == "2"
@@ -5134,6 +5138,8 @@ def test_no_setattr_nonnative() -> None:
     object.__setattr__(i, "three", 102)
     assert i.three == 102
 
+    i = i
+
     del i.three
     assert i.three == None
 

mypyc/test-data/run-classes.test

@@ -1032,7 +1032,7 @@ else:
     reveal_type(z)  # No output: this branch is unreachable
 [builtins fixtures/bool.pyi]
 
-[case testEnumReachabilityNoNarrowingForUnionMessiness]
+[case testEnumReachabilityNarrowingForUnionMessiness]
 from enum import Enum
 from typing import Literal
 
@@ -1045,17 +1045,16 @@ x: Foo
 y: Literal[Foo.A, Foo.B]
 z: Literal[Foo.B, Foo.C]
 
-# For the sake of simplicity, no narrowing is done when the narrower type is a Union.
 if x is y:
-    reveal_type(x)  # N: Revealed type is "__main__.Foo"
+    reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
 else:
     reveal_type(x)  # N: Revealed type is "__main__.Foo"
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
 
 if y is z:
-    reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
-    reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"
+    reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.B]"
+    reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.B]"
 else:
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
     reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"

test-data/unit/check-enum.test

@@ -2372,7 +2372,7 @@ x: int = ""  # E: Incompatible types in assignment (expression has type "str", v
 x: int = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 [case testDisableBytearrayPromotion]
-# flags: --disable-bytearray-promotion --strict-equality
+# flags: --disable-bytearray-promotion --strict-equality --warn-unreachable
 def f(x: bytes) -> None: ...
 f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
 f(memoryview(b"asdf"))

test-data/unit/check-flags.test

@@ -2729,7 +2729,7 @@ from typing import Union
 
 y: str
 if type(y) is int:  # E: Subclass of "str" and "int" cannot exist: would have incompatible method signatures
-    y # E: Statement is unreachable
+    y  # E: Statement is unreachable
 else:
     reveal_type(y) # N: Revealed type is "builtins.str"
 [builtins fixtures/isinstance.pyi]
@@ -2760,6 +2760,7 @@ else:
     reveal_type(x)  # N: Revealed type is "builtins.int | builtins.str"
 
 [case testTypeEqualsMultipleTypesShouldntNarrow]
+# flags: --warn-unreachable
 # make sure we don't do any narrowing if there are multiple types being compared
 
 from typing import Union

test-data/unit/check-isinstance.test

@@ -1364,13 +1364,13 @@ class A: ...
 val: Optional[A]
 
 if val == None:
-    reveal_type(val)  # N: Revealed type is "__main__.A | None"
+    reveal_type(val)  # N: Revealed type is "None"
 else:
     reveal_type(val)  # N: Revealed type is "__main__.A"
 if val != None:
     reveal_type(val)  # N: Revealed type is "__main__.A"
 else:
-    reveal_type(val)  # N: Revealed type is "__main__.A | None"
+    reveal_type(val)  # N: Revealed type is "None"
 
 if val in (None,):
     reveal_type(val)  # N: Revealed type is "__main__.A | None"
@@ -1380,6 +1380,19 @@ if val not in (None,):
     reveal_type(val)  # N: Revealed type is "__main__.A | None"
 else:
     reveal_type(val)  # N: Revealed type is "__main__.A | None"
+
+class Hmm:
+    def __eq__(self, other) -> bool: ...
+
+hmm: Optional[Hmm]
+if hmm == None:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm | None"
+else:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm"
+if hmm != None:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm"
+else:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm | None"
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingWithTupleOfTypes]
@@ -2277,13 +2290,13 @@ def f4(x: SE) -> None:
 # https://github.com/python/mypy/issues/17864
 def f(x: str | int) -> None:
     if x == "x":
-        reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int"
+        reveal_type(x)  # N: Revealed type is "builtins.str"
         y = x
 
     if x in ["x"]:
         # TODO: we should fix this reveal https://github.com/python/mypy/issues/3229
         reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int"
-        y = x
+        y = x  # E: Incompatible types in assignment (expression has type "str | int", variable has type "str")
         z = x
     z = y
 [builtins fixtures/primitives.pyi]
@@ -2699,3 +2712,97 @@ reveal_type(t.foo)  # N: Revealed type is "__main__.D"
 t.foo = C1()
 reveal_type(t.foo)  # N: Revealed type is "__main__.C"
 [builtins fixtures/property.pyi]
+
+[case testNarrowingNotImplemented]
+from __future__ import annotations
+from typing_extensions import Self
+
+class X:
+    def __divmod__(self, other: Self | int) -> tuple[Self, Self]: ...
+
+    def __floordiv__(self, other: Self | int) -> Self:
+        qr = self.__divmod__(other)
+        if qr is NotImplemented:
+            return NotImplemented
+        return qr[0]
+[builtins fixtures/notimplemented.pyi]
+
+
+[case testNarrowingBooleans]
+# flags: --warn-return-any
+from typing import Any
+
+def foo(x: dict[str, Any]) -> bool:
+    if x.get("event") is False:
+        return False
+    if x.get("event") is True:
+        return True
+    raise
+[builtins fixtures/dict.pyi]
+
+
+[case testNarrowingTypeObjects]
+from __future__ import annotations
+from typing import Callable, Any, TypeVar, Generic, Protocol
+_T_co = TypeVar('_T_co', covariant=True)
+
+class Boxxy(Protocol[_T_co]):
+    def get_box(self) -> _T_co: ...
+
+class TupleLike(Generic[_T_co]):
+    def __init__(self, iterable: Boxxy[_T_co], /) -> None:
+        raise
+
+class Box1(Generic[_T_co]):
+    def __init__(self, content: _T_co, /) -> None: ...
+    def get_box(self) -> _T_co: raise
+
+class Box2(Generic[_T_co]):
+    def __init__(self, content: _T_co, /) -> None: ...
+    def get_box(self) -> _T_co: raise
+
+def get_type(setting_name: str) -> Callable[[Box1], Any] | type[Any]:
+    raise
+
+def main(key: str):
+    existing_value_type = get_type(key)
+    if existing_value_type is TupleLike:
+        reveal_type(TupleLike)  # N: Revealed type is "def [_T_co] (__main__.Boxxy[_T_co`1]) -> __main__.TupleLike[_T_co`1]"
+        TupleLike(Box2("str"))
+[builtins fixtures/tuple.pyi]
+
+[case testNarrowingCollections]
+# flags: --warn-unreachable
+from typing import cast
+
+class X:
+    def __init__(self) -> None:
+        self.x: dict[str, str] = {}
+        self.y: list[str] = []
+
+    def xxx(self) -> None:
+        if self.x == {}:
+            reveal_type(self.x)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
+            self.x["asdf"]
+
+        if self.x == dict():
+            reveal_type(self.x)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
+            self.x["asdf"]
+
+        if self.x == cast(dict[int, int], {}):
+            reveal_type(self.x)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
+            self.x["asdf"]
+
+    def yyy(self) -> None:
+        if self.y == []:
+            reveal_type(self.y)  # N: Revealed type is "builtins.list[builtins.str]"
+            self.y[0].does_not_exist  # E: "str" has no attribute "does_not_exist"
+
+        if self.y == list():
+            reveal_type(self.y)  # N: Revealed type is "builtins.list[builtins.str]"
+            self.y[0].does_not_exist  # E: "str" has no attribute "does_not_exist"
+
+        if self.y == cast(list[int], []):
+            reveal_type(self.y)  # N: Revealed type is "builtins.list[builtins.str]"
+            self.y[0].does_not_exist  # E: "str" has no attribute "does_not_exist"
+[builtins fixtures/dict.pyi]