Narrow unions containing Any in and_conditional_map (#21231)

Fixes #21225

I expanded it out from comprehensions to try to make it a little
clearer. The heuristics do make sense, but would be good to explore
biting the bullet and just doing the principled thing of use_meet=True

Author: hauntsaninja

mypy/checker.py

@@ -8635,28 +8635,39 @@ def and_conditional_maps(m1: TypeMap, m2: TypeMap, *, use_meet: bool = False) ->
     """
     # Both conditions can be true; combine the information. Anything
     # we learn from either conditions' truth is valid.
-    # If the same expression's type is refined by both conditions and use_meet=False, we somewhat
-    # arbitrarily give precedence to m2 unless m2's value is Any or m1's value is Never.
     result = m2.copy()
-    m2_exprs = {literal_hash(n2): n2 for n2 in m2}
-    for n1 in m1:
-        n1_hash = literal_hash(n1)
-        if n1_hash not in m2_exprs or (
-            not use_meet
-            and (
-                isinstance(get_proper_type(m1[n1]), UninhabitedType)
-                or isinstance(get_proper_type(m2[m2_exprs[n1_hash]]), AnyType)
-            )
-        ):
-            result[n1] = m1[n1]
+    m2_exprs = {literal_hash(e2): e2 for e2 in m2}
+    for e1 in m1:
+        e1_hash = literal_hash(e1)
+        if e1_hash not in m2_exprs:
+            result[e1] = m1[e1]
+            continue
+
+        if not use_meet:
+            # If use_meet=False and the same expression's type is refined by both conditions,
+            # we somewhat arbitrarily give precedence to m2, unless a) m1's value is Never, or
+            # b) m2's value is Any and m1 isn't a union that could have been narrowed to Any.
+            t1 = m1[e1]
+            pt1 = get_proper_type(t1)
+            if isinstance(pt1, UninhabitedType):
+                result[e1] = t1
+            else:
+                e2 = m2_exprs[e1_hash]
+                pt2 = get_proper_type(m2[e2])
+                if isinstance(pt2, AnyType) and not (
+                    isinstance(pt1, UnionType)
+                    and any(isinstance(get_proper_type(item), AnyType) for item in pt1.items)
+                ):
+                    result[e1] = t1
+
     if use_meet:
         # For now, meet common keys only if specifically requested.
         # This is currently used for tuple types narrowing, where having
         # a precise result is important.
-        for n1 in m1:
-            for n2 in m2:
-                if literal_hash(n1) == literal_hash(n2):
-                    result[n1] = meet_types(m1[n1], m2[n2])
+        for e1 in m1:
+            for e2 in m2:
+                if literal_hash(e1) == literal_hash(e2):
+                    result[e1] = meet_types(m1[e1], m2[e2])
     return result
 
 

test-data/unit/check-isinstance.test

@@ -2319,6 +2319,17 @@ assert isinstance(x, B)
 reveal_type(x)  # N: Revealed type is "Any"
 [builtins fixtures/isinstance.pyi]
 
+[case testIsinstanceNarrowsAfterNoneCheckWithAnyUnion]
+# flags: --warn-unreachable
+from typing import Any, Union
+
+def f(val: Union[Any, str]) -> None:
+    if val is None or isinstance(val, str):
+        reveal_type(val)  # N: Revealed type is "None | builtins.str"
+        return
+    reveal_type(val)  # N: Revealed type is "Any"
+[builtins fixtures/isinstance.pyi]
+
 [case testIsinstanceIgnoredImport]
 # flags: --warn-unreachable
 from typing import Union