.

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
@@ -6540,19 +6540,6 @@ def comparison_type_narrowing_helper(self, node: ComparisonExpr) -> tuple[TypeMa
                             narrowable_indices={0},
                         )
 
-                        # We only try and narrow away 'None' for now
-                        if (
-                            not is_unreachable_map(if_map)
-                            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
@@ -6676,6 +6663,8 @@ def narrow_type_by_identity_equality(
                 target_type = operand_types[j]
                 if should_coerce_literals:
                     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
@@ -8602,13 +8591,7 @@ def reduce_and_conditional_type_maps(ms: list[TypeMap], *, use_meet: bool) -> Ty
     return result
 
 
-BUILTINS_CUSTOM_EQ_CHECKS: Final = {
-    "builtins.bytearray",
-    "builtins.memoryview",
-    "builtins.list",
-    "builtins.dict",
-    "builtins.set",
-}
+BUILTINS_CUSTOM_EQ_CHECKS: Final = {"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-narrowing.test

@@ -1049,6 +1049,25 @@ def f(x: Custom, y: CustomSub):
         reveal_type(y)  # N: Revealed type is "__main__.CustomSub"
 [builtins fixtures/tuple.pyi]
 
+[case testNarrowingCustomEqualityGeneric]
+# flags: --strict-equality --warn-unreachable
+from __future__ import annotations
+
+class Custom:
+    def __eq__(self, other: object) -> bool:
+        raise
+
+class Default: ...
+
+def f(x: list[Custom] | Default, y: list[int]):
+    if x == y:  # E: Non-overlapping equality check (left operand type: "list[Custom] | Default", right operand type: "list[int]")
+        reveal_type(x)  # N: Revealed type is "builtins.list[__main__.Custom]"
+        reveal_type(y)  # N: Revealed type is "builtins.list[builtins.int]"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.list[__main__.Custom] | __main__.Default"
+        reveal_type(y)  # N: Revealed type is "builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
+
 [case testNarrowingUnreachableCases]
 # flags: --strict-equality --warn-unreachable
 from typing import Literal, Union

test-data/unit/check-tuples.test

@@ -1540,7 +1540,9 @@ class B: pass
 
 def f1(possibles: Tuple[int, Tuple[A]], x: Optional[Tuple[B]]):
     if x in possibles:
-        reveal_type(x)  # N: Revealed type is "tuple[__main__.B]"
+        # TODO: this branch is actually unreachable
+        # This is an easy fix: https://github.com/python/mypy/pull/20660
+        reveal_type(x)  # N: Revealed type is "tuple[__main__.B] | None"
     else:
         reveal_type(x) # N: Revealed type is "tuple[__main__.B] | None"