Fix narrowing for AbstractSet and Mapping (#21352)

This builds on the tech I added a few days ago in #21281. So we can also
get rid of frozenset special case from #21151. I believe we account for
all the dangerous_comparison logic now

Author: hauntsaninja

mypy/checker.py

@@ -8924,24 +8924,9 @@ def reduce_and_conditional_type_maps(ms: list[TypeMap], *, use_meet: bool) -> Ty
     return result
 
 
-BUILTINS_CUSTOM_EQ_CHECKS: Final = {
-    "builtins.frozenset",
-    "_collections_abc.dict_keys",
-    "_collections_abc.dict_items",
-}
-
-
 def has_custom_eq_checks(t: Type) -> bool:
-    return (
-        custom_special_method(t, "__eq__", check_all=False)
-        or custom_special_method(t, "__ne__", check_all=False)
-        # custom_special_method has special casing for builtins.* and typing.* that make the
-        # above always return False. Some builtin collections still have equality behavior that
-        # crosses nominal type boundaries and isn't captured by VALUE_EQUALITY_TYPE_DOMAINS.
-        or (
-            isinstance(pt := get_proper_type(t), Instance)
-            and pt.type.fullname in BUILTINS_CUSTOM_EQ_CHECKS
-        )
+    return custom_special_method(t, "__eq__", check_all=False) or custom_special_method(
+        t, "__ne__", check_all=False
     )
 
 
@@ -9731,6 +9716,8 @@ def visit_starred_pattern(self, p: StarredPattern) -> None:
     "builtins.bytes": "builtins.bytes",
     "builtins.bytearray": "builtins.bytes",
     "builtins.memoryview": "builtins.bytes",
+    "typing.Mapping": "typing.Mapping",
+    "typing.AbstractSet": "typing.AbstractSet",
 }
 
 VALUE_EQUALITY_DOMAINS: Final = {**OPEN_VALUE_EQUALITY_DOMAINS, **CLOSED_VALUE_EQUALITY_DOMAINS}

test-data/unit/pythoneval.test

@@ -2212,3 +2212,59 @@ d3: A = d1 | d2
 reveal_type(d1 | d2)
 [out]
 _testDictOrUnionEdgeCases.py:10: note: Revealed type is "dict[str, dict[str, ... | int] | int]"
+
+[case testNarrowingMappingAndAbstractSet]
+# flags: --strict-equality --warn-unreachable
+from typing import Mapping, AbstractSet
+
+def f1(x: Mapping[str, int], y: dict[str, int]) -> None:
+    if isinstance(x, dict):
+        reveal_type(x)
+
+    if x == y:
+        reveal_type(x)
+        reveal_type(y)
+
+    if x == {}:
+        reveal_type(x)
+
+def f2(x: AbstractSet[int], y: set[int]) -> None:
+    if isinstance(x, set):
+        reveal_type(x)
+
+    if x == y:
+        reveal_type(x)
+        reveal_type(y)
+
+    if x == set():
+        reveal_type(x)
+
+def f3(x: frozenset[int], y: set[int]):
+    if x == y:
+        reveal_type(x)
+        reveal_type(y)
+
+def f4(x: dict[str, int], y: set[str]):
+    if x.keys() == y:
+        reveal_type(x)
+        reveal_type(y)
+
+    z = x.keys()
+    if z == y:
+        reveal_type(z)
+        reveal_type(y)
+[out]
+_testNarrowingMappingAndAbstractSet.py:6: note: Revealed type is "dict[Any, Any]"
+_testNarrowingMappingAndAbstractSet.py:9: note: Revealed type is "typing.Mapping[str, int]"
+_testNarrowingMappingAndAbstractSet.py:10: note: Revealed type is "dict[str, int]"
+_testNarrowingMappingAndAbstractSet.py:13: note: Revealed type is "typing.Mapping[str, int]"
+_testNarrowingMappingAndAbstractSet.py:17: note: Revealed type is "set[Any]"
+_testNarrowingMappingAndAbstractSet.py:20: note: Revealed type is "typing.AbstractSet[int]"
+_testNarrowingMappingAndAbstractSet.py:21: note: Revealed type is "set[int]"
+_testNarrowingMappingAndAbstractSet.py:24: note: Revealed type is "typing.AbstractSet[int]"
+_testNarrowingMappingAndAbstractSet.py:28: note: Revealed type is "frozenset[int]"
+_testNarrowingMappingAndAbstractSet.py:29: note: Revealed type is "set[int]"
+_testNarrowingMappingAndAbstractSet.py:33: note: Revealed type is "dict[str, int]"
+_testNarrowingMappingAndAbstractSet.py:34: note: Revealed type is "set[str]"
+_testNarrowingMappingAndAbstractSet.py:38: note: Revealed type is "_collections_abc.dict_keys[str, int]"
+_testNarrowingMappingAndAbstractSet.py:39: note: Revealed type is "set[str]"