@@ -17,7 +17,7 @@
 from genericpath import *
 
 from typing import (
-    Tuple, BinaryIO, TextIO, Pattern, AnyStr, List, Set, Any, Union
+    Tuple, BinaryIO, TextIO, Pattern, AnyStr, List, Set, Any, Union, cast
 )
 
 __all__ = ["normcase","isabs","join","splitdrive","split","splitext",
@@ -56,7 +56,7 @@ def normcase(s: AnyStr) -> AnyStr:
     if not isinstance(s, (bytes, str)):
         raise TypeError("normcase() argument must be str or bytes, "
                         "not '{}'".format(s.__class__.__name__))
-    return s
+    return cast(AnyStr, s)
 
 
 # Return whether a path is absolute.
 
@@ -2412,12 +2412,29 @@ def find_isinstance_check(node: Node,
 
 def get_isinstance_type(node: Node, type_map: Dict[Node, Type]) -> Type:
     type = type_map[node]
-    if isinstance(type, FunctionLike):
-        if type.is_type_obj():
-            # Type variables may be present -- erase them, which is the best
-            # we can do (outside disallowing them here).
-            return erase_typevars(type.items()[0].ret_type)
-    return None
+
+    if isinstance(type, TupleType):
+        all_types = type.items
+    else:
+        all_types = [type]
+
+    types = []  # type: List[Type]
+
+    for type in all_types:
+        if isinstance(type, FunctionLike):
+            if type.is_type_obj():
+                # Type variables may be present -- erase them, which is the best
+                # we can do (outside disallowing them here).
+                type = erase_typevars(type.items()[0].ret_type)
+
+            types.append(type)
+
+    if len(types) == 0:
+        return None
+    elif len(types) == 1:
+        return types[0]
+    else:
+        return UnionType(types)
 
 
 def expand_node(defn: Node, map: Dict[int, Type]) -> Node:
 
@@ -343,6 +343,30 @@ while 1:
         z = h.pet.paws + 'a' # E: Unsupported operand types for + ("int" and "str")
 [builtins fixtures/isinstancelist.py]
 
+[case testIsinstanceTuple]
+from typing import Union
+
+class A:
+    pass
+
+class B:
+    def method2(self, arg: int):
+        return 123
+
+class C:
+    def method2(self, arg: int):
+        return 456
+
+    def method3(self, arg: str):
+        return 'abc'
+
+v = A() # type: Union[A, B, C]
+
+if isinstance(v, (B, C)):
+    v.method2(123)
+    v.method3('xyz') # E: Some element of union has no attribute "method3"
+[builtins fixtures/isinstance.py]
+
 [case testMemberAssignmentChanges-skip]
 from typing import Union
 
 
@@ -1,15 +1,18 @@
-from typing import builtinclass
+from typing import builtinclass, Tuple, TypeVar, Generic, Union
+
+T = TypeVar('T')
 
 class object:
     def __init__(self) -> None: pass
 
 class type:
     def __init__(self, x) -> None: pass
 
-class tuple: pass
+class tuple(Generic[T]): pass
+
 class function: pass
 
-def isinstance(x: object, t: type) -> bool: pass
+def isinstance(x: object, t: Union[type, Tuple[type, ...]]) -> bool: pass
 
 class int: pass
 class float: pass