python
diff --git a/‎mypy/checker.py
Lines changed: 33 additions & 3 deletions b/‎mypy/checker.py
Lines changed: 33 additions & 3 deletions
diff --git a/‎test-data/unit/check-isinstance.test
Lines changed: 38 additions & 0 deletions b/‎test-data/unit/check-isinstance.test
Lines changed: 38 additions & 0 deletions
@@ -2437,6 +2437,21 @@ def and_conditional_maps(m1: Optional[TypeMap], m2: Optional[TypeMap]) -> Option
     return result
 
 
+def or_conditional_maps(m1: Optional[TypeMap], m2: Optional[TypeMap]) -> Optional[TypeMap]:
+    if m1 is None:
+        return m2
+    if m2 is None:
+        return m1
+    # Both branches are possible. Combine information about variables
+    # whose type is refined in both branches.
+    result = {}
+    for n1 in m1:
+        for n2 in m2:
+            if n1.literal_hash == n2.literal_hash:
+                result[n1] = UnionType.make_simplified_union([m1[n1], m2[n2]])
+    return result
+
+
 def find_isinstance_check(node: Node,
                           type_map: Dict[Node, Type],
                           weak: bool=False
@@ -2484,7 +2499,22 @@ def find_isinstance_check(node: Node,
         _, if_vars = conditional_type_map(node, vartype, NoneTyp(), weak=weak)
         return if_vars, {}
     elif isinstance(node, OpExpr) and node.op == 'and':
-        left_if_vars, right_else_vars = find_isinstance_check(
+        left_if_vars, left_else_vars = find_isinstance_check(
+            node.left,
+            type_map,
+            weak,
+        )
+
+        right_if_vars, right_else_vars = find_isinstance_check(
+            node.right,
+            type_map,
+            weak,
+        )
+
+        return (and_conditional_maps(left_if_vars, right_if_vars),
+                or_conditional_maps(left_else_vars, right_else_vars))
+    elif isinstance(node, OpExpr) and node.op == 'or':
+        left_if_vars, left_else_vars = find_isinstance_check(
             node.left,
             type_map,
             weak,
@@ -2496,8 +2526,8 @@ def find_isinstance_check(node: Node,
             weak,
         )
 
-        # Make no claim about the types in else
-        return and_conditional_maps(left_if_vars, right_if_vars), {}
+        return (or_conditional_maps(left_if_vars, right_if_vars),
+                and_conditional_maps(left_else_vars, right_else_vars))
     elif isinstance(node, UnaryExpr) and node.op == 'not':
         left, right = find_isinstance_check(node.expr, type_map, weak)
         return right, left
 
@@ -800,6 +800,24 @@ def foo(): pass
 [out]
 main: note: In function "f":
 
+[case testIsinstanceOr]
+from typing import Optional
+def f(a: bool, x: object) -> Optional[int]:
+    if a or not isinstance(x, int):
+        return None
+    return x
+def g(a: bool, x: object) -> Optional[int]:
+    if not isinstance(x, int) or a:
+        return None
+    return x
+def h(a: bool, x: object) -> Optional[int]:
+    if a or isinstance(x, int):
+        return None
+    return x # E: Incompatible return value type (got "object", expected "int")
+[builtins fixtures/isinstance.py]
+[out]
+main: note: In function "h":
+
 [case testIsinstanceWithOverlappingUnionType]
 from typing import Union
 def f(x: Union[float, int]) -> None:
@@ -854,3 +872,23 @@ def f(x: Union[List[int], str]) -> None:
 [out]
 main: note: In function "f":
 main:4: error: "int" not callable
+
+[case testIsinstanceOrIsinstance]
+class A: pass
+class B(A):
+    flag = 1
+class C(A):
+    flag = 2
+def f(x: A) -> int:
+    if isinstance(x, B) or isinstance(x, C):
+        return x.flag
+    else:
+        return 0
+def g(x: A) -> int:
+    if isinstance(x, A) or isinstance(x, C):
+        return x.flag # E: "A" has no attribute "flag"
+    else:
+        return 0
+[builtins fixtures/isinstance.py]
+[out]
+main: note: In function "g":