isinstance and type checks reflect runtime behaviour better

Author: hauntsaninja

mypy/checker.py

@@ -6812,7 +6812,7 @@ def narrow_type_by_identity_equality(
                     continue
                 expr = operands[j]
 
-                current_type_range = self.get_isinstance_type(expr)
+                current_type_range = self.get_isinstance_type(expr, flatten_tuples=False)
                 if current_type_range is not None:
                     target_type = get_proper_type(
                         make_simplified_union([tr.item for tr in current_type_range])
@@ -7907,22 +7907,27 @@ def is_writable_attribute(self, node: Node) -> bool:
             return first_item.var.is_settable_property
         return False
 
-    def get_isinstance_type(self, expr: Expression) -> list[TypeRange] | None:
+    def get_isinstance_type(self, expr: Expression, flatten_tuples: bool = True) -> list[TypeRange] | None:
         """Get the type(s) resulting from an isinstance check.
 
         Returns an empty list for isinstance(x, ()).
         """
         if isinstance(expr, OpExpr) and expr.op == "|":
-            left = self.get_isinstance_type(expr.left)
+            left = self.get_isinstance_type(expr.left, flatten_tuples=False)
             if left is None and is_literal_none(expr.left):
                 left = [TypeRange(NoneType(), is_upper_bound=False)]
-            right = self.get_isinstance_type(expr.right)
+            right = self.get_isinstance_type(expr.right, flatten_tuples=False)
             if right is None and is_literal_none(expr.right):
                 right = [TypeRange(NoneType(), is_upper_bound=False)]
             if left is None or right is None:
                 return None
             return left + right
-        all_types = get_proper_types(flatten_types(self.lookup_type(expr)))
+
+        if flatten_tuples:
+            all_types = get_proper_types(flatten_types_if_tuple(self.lookup_type(expr)))
+        else:
+            all_types = [get_proper_type(self.lookup_type(expr))]
+
         types: list[TypeRange] = []
         for typ in all_types:
             if isinstance(typ, FunctionLike) and typ.is_type_obj():
@@ -8654,11 +8659,11 @@ def flatten(t: Expression) -> list[Expression]:
         return [t]
 
 
-def flatten_types(t: Type) -> list[Type]:
+def flatten_types_if_tuple(t: Type) -> list[Type]:
     """Flatten a nested sequence of tuples into one list of nodes."""
     t = get_proper_type(t)
     if isinstance(t, TupleType):
-        return [b for a in t.items for b in flatten_types(a)]
+        return [b for a in t.items for b in flatten_types_if_tuple(a)]
     elif is_named_instance(t, "builtins.tuple"):
         return [t.args[0]]
     else:

test-data/unit/check-isinstance.test

@@ -2937,3 +2937,21 @@ def foo(x: object, t: type[Any]):
     if isinstance(x, t):
         reveal_type(x)  # N: Revealed type is "Any"
 [builtins fixtures/isinstance.pyi]
+
+[case testIsInstanceUnionTuple]
+# flags: --strict-equality --warn-unreachable
+from typing import Any
+
+def f1(x: object):
+    if isinstance(x, str | (int, dict)):  # E: Argument 2 to "isinstance" has incompatible type "object"; expected "type | tuple[Any, ...]"
+        reveal_type(x)  # N: Revealed type is "builtins.object"
+    if type(x) == str | (int, dict):
+        reveal_type(x)  # N: Revealed type is "builtins.object"
+
+def f2(x: Any):
+    if isinstance(x, str | (int, dict)):  # E: Argument 2 to "isinstance" has incompatible type "object"; expected "type | tuple[Any, ...]"
+        reveal_type(x)  # N: Revealed type is "Any"
+    if type(x) == str | (int, dict):
+        reveal_type(x)  # N: Revealed type is "Any"
+
+[builtins fixtures/primitives.pyi]