Better handling of generics when narrowing

Author: hauntsaninja

mypy/checker.py

@@ -45,7 +45,7 @@
 from mypy.expandtype import expand_type
 from mypy.literals import Key, extract_var_from_literal_hash, literal, literal_hash
 from mypy.maptype import map_instance_to_supertype
-from mypy.meet import is_overlapping_erased_types, is_overlapping_types, meet_types
+from mypy.meet import is_overlapping_types, meet_types
 from mypy.message_registry import ErrorMessage
 from mypy.messages import (
     SUGGESTED_TEST_FIXTURES,
@@ -235,7 +235,7 @@
     is_literal_type,
     is_named_instance,
 )
-from mypy.types_utils import is_overlapping_none, remove_optional, store_argument_type, strip_type
+from mypy.types_utils import store_argument_type, strip_type
 from mypy.typetraverser import TypeTraverserVisitor
 from mypy.typevars import fill_typevars, fill_typevars_with_any, has_no_typevars
 from mypy.util import is_dunder, is_sunder
@@ -6561,19 +6561,6 @@ def comparison_type_narrowing_helper(self, node: ComparisonExpr) -> tuple[TypeMa
                             narrowable_indices={0},
                         )
 
-                        # We only try and narrow away 'None' for now
-                        if (
-                            if_map is not None
-                            and is_overlapping_none(item_type)
-                            and not is_overlapping_none(collection_item_type)
-                            and not (
-                                isinstance(collection_item_type, Instance)
-                                and collection_item_type.type.fullname == "builtins.object"
-                            )
-                            and is_overlapping_erased_types(item_type, collection_item_type)
-                        ):
-                            if_map[operands[left_index]] = remove_optional(item_type)
-
                 if right_index in narrowable_operand_index_to_hash:
                     if_type, else_type = self.conditional_types_for_iterable(
                         item_type, iterable_type
@@ -6709,6 +6696,8 @@ def narrow_type_by_identity_equality(
                     # `x` to `Literal[Foo.A]` iff `Foo` has exactly one member.
                     # See testMatchEnumSingleChoice
                     target_type = coerce_to_literal(target_type)
+                if isinstance(get_proper_type(target_type), Instance):
+                    target_type = erase_type(target_type)
 
                 if (
                     # See comments in ambiguous_enum_equality_keys
@@ -8589,14 +8578,7 @@ def reduce_conditional_maps(
         return final_if_map, final_else_map
 
 
-BUILTINS_CUSTOM_EQ_CHECKS: Final = {
-    "builtins.bytes",
-    "builtins.bytearray",
-    "builtins.memoryview",
-    "builtins.list",
-    "builtins.dict",
-    "builtins.set",
-}
+BUILTINS_CUSTOM_EQ_CHECKS: Final = {"builtins.bytes", "builtins.bytearray", "builtins.memoryview"}
 
 
 def has_custom_eq_checks(t: Type) -> bool:

mypy/meet.py

@@ -3,7 +3,6 @@
 from collections.abc import Callable
 
 from mypy import join
-from mypy.erasetype import erase_type
 from mypy.maptype import map_instance_to_supertype
 from mypy.state import state
 from mypy.subtypes import (
@@ -657,18 +656,6 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
     return False
 
 
-def is_overlapping_erased_types(
-    left: Type, right: Type, *, ignore_promotions: bool = False
-) -> bool:
-    """The same as 'is_overlapping_erased_types', except the types are erased first."""
-    return is_overlapping_types(
-        erase_type(left),
-        erase_type(right),
-        ignore_promotions=ignore_promotions,
-        prohibit_none_typevar_overlap=True,
-    )
-
-
 def are_typed_dicts_overlapping(
     left: TypedDictType, right: TypedDictType, is_overlapping: Callable[[Type, Type], bool]
 ) -> bool:

test-data/unit/check-isinstance.test

@@ -2018,7 +2018,7 @@ nested_any: List[List[Any]]
 if lst in nested_any:
     reveal_type(lst) # N: Revealed type is "builtins.list[builtins.int]"
 if x in nested_any:
-    reveal_type(x) # N: Revealed type is "builtins.int | None"
+    reveal_type(x) # E: Statement is unreachable
 [builtins fixtures/list.pyi]
 
 [case testNarrowTypeAfterInTuple]

test-data/unit/check-narrowing.test

@@ -2902,7 +2902,7 @@ def main(key: str):
 [builtins fixtures/tuple.pyi]
 
 [case testNarrowingCollections]
-# flags: --warn-unreachable
+# flags: --warn-unreachable --strict-equality
 from typing import cast
 
 class X:
@@ -2919,7 +2919,7 @@ class X:
             reveal_type(self.x)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
             self.x["asdf"]
 
-        if self.x == cast(dict[int, int], {}):
+        if self.x == cast(dict[int, int], {}):  # E: Non-overlapping equality check (left operand type: "dict[str, str]", right operand type: "dict[int, int]")
             reveal_type(self.x)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
             self.x["asdf"]
 
@@ -2932,7 +2932,7 @@ class X:
             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], []):
+        if self.y == cast(list[int], []):  # E: Non-overlapping equality check (left operand type: "list[str]", right operand type: "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]