@@ -14,9 +14,25 @@ def is_same_type(left: Type, right: Type) -> bool:
         # generated spurious error messages.
         return True
     else:
+        # Simplify types to canonical forms.
+        #
+        # There are multiple possible union types that represent the same type,
+        # such as Union[int, bool, str] and Union[int, str]. Also, some union
+        # types can be simplified to non-union types such as Union[int, bool]
+        # -> int. It would be nice if we always had simplified union types but
+        # this is currently not the case, though it often is.
+        left = simplify_union(left)
+        right = simplify_union(right)
+
         return left.accept(SameTypeVisitor(right))
 
 
+def simplify_union(t: Type) -> Type:
+    if isinstance(t, UnionType):
+        return UnionType.make_simplified_union(t.items)
+    return t
+
+
 def is_same_types(a1: Sequence[Type], a2: Sequence[Type]) -> bool:
     if len(a1) != len(a2):
         return False
 
@@ -773,3 +773,23 @@ def foo(): pass
 [builtins fixtures/isinstancelist.py]
 [out]
 main: note: In function "f":
+
+[case testIsinstanceWithOverlappingUnionType]
+from typing import Union
+def f(x: Union[float, int]) -> None:
+    if isinstance(x, float):
+        pass
+    if not isinstance(x, int):
+        f(x)
+[builtins fixtures/isinstance.py]
+
+[case testIsinstanceWithOverlappingUnionType2]
+from typing import Union
+class A: pass
+class B(A): pass
+def f(x: Union[A, B]) -> None:
+    if isinstance(x, A):
+        pass
+    if not isinstance(x, B):
+        f(x)
+[builtins fixtures/isinstance.py]
@@ -1,10 +1,8 @@
 from typing import builtinclass
 
-@builtinclass
 class object:
     def __init__(self) -> None: pass
 
-@builtinclass
 class type:
     def __init__(self, x) -> None: pass
 
@@ -13,9 +11,7 @@ class function: pass
 
 def isinstance(x: object, t: type) -> bool: pass
 
-@builtinclass
 class int: pass
-@builtinclass
+class float: pass
 class bool(int): pass
-@builtinclass
 class str: pass