better generic handling

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,
@@ -6553,19 +6553,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
@@ -6690,6 +6677,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(target_type, Instance):
+                    target_type = erase_type(target_type)
 
                 if (
                     # See comments in ambiguous_enum_equality_keys
@@ -8577,9 +8566,6 @@ def reduce_and_conditional_type_maps(ms: list[TypeMap], *, use_meet: bool) -> Ty
     "builtins.bytes",
     "builtins.bytearray",
     "builtins.memoryview",
-    "builtins.list",
-    "builtins.dict",
-    "builtins.set",
 }
 
 

mypy/meet.py

@@ -657,18 +657,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

@@ -2876,7 +2876,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:
@@ -2893,7 +2893,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"]
 
@@ -2906,7 +2906,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]