Rework narrowing logic for equality and identity

mypy/test/testargs.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/testtypes.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/typeops.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)])
 

mypyc/test-data/run-classes.test

@@ -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
 

test-data/unit/check-enum.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-flags.test

@@ -2377,7 +2377,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-isinstance.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-narrowing.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]