diff --git a/mypy/build.py b/mypy/build.py
index bfe8886a5116..41d1f5528e2d 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -437,7 +437,7 @@ def lookup_state(self, module: str) -> 'State':
         for state in self.states:
             if state.id == module:
                 return state
-        raise RuntimeError('%s not found' % str)
+        raise RuntimeError('%s not found' % module)
 
     def all_imported_modules_in_file(self,
                                      file: MypyFile) -> List[Tuple[str, int]]:
diff --git a/mypy/constraints.py b/mypy/constraints.py
index e8794338c20d..ba9136a33b22 100644
--- a/mypy/constraints.py
+++ b/mypy/constraints.py
@@ -273,6 +273,12 @@ def infer_against_any(self, types: List[Type]) -> List[Constraint]:
             res.extend(infer_constraints(t, AnyType(), self.direction))
         return res
 
+    def visit_overloaded(self, type: Overloaded) -> List[Constraint]:
+        res = []  # type: List[Constraint]
+        for t in type.items():
+            res.extend(infer_constraints(t, self.actual, self.direction))
+        return res
+
 
 def negate_constraints(constraints: List[Constraint]) -> List[Constraint]:
     res = []  # type: List[Constraint]
diff --git a/mypy/sametypes.py b/mypy/sametypes.py
index acb4e7c987c2..7ea1a437a5c3 100644
--- a/mypy/sametypes.py
+++ b/mypy/sametypes.py
@@ -2,7 +2,7 @@
 
 from mypy.types import (
     Type, UnboundType, ErrorType, AnyType, NoneTyp, Void, TupleType, UnionType, CallableType,
-    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList
+    TypeVarType, Instance, TypeVisitor, ErasedType, TypeList, Overloaded
 )
 
 
@@ -91,3 +91,10 @@ def visit_union_type(self, left: UnionType) -> bool:
             return is_same_types(left.items, cast(UnionType, self.right).items)
         else:
             return False
+
+    def visit_overloaded(self, left: Overloaded) -> bool:
+        if isinstance(self.right, Overloaded):
+            return is_same_types(cast(List[Type], left.items()),
+                                 cast(List[Type], cast(Overloaded, self.right).items()))
+        else:
+            return False
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
index f51b301fc131..a9d965ef1588 100644
--- a/mypy/typeanal.py
+++ b/mypy/typeanal.py
@@ -333,3 +333,6 @@ def visit_type_list(self, t: TypeList) -> None:
 
     def visit_type_var(self, t: TypeVarType) -> None:
         pass
+
+    def visit_star_type(self, t: StarType) -> None:
+        pass
diff --git a/mypy/types.py b/mypy/types.py
index be03b4b2ad86..7a5614670a7e 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -492,50 +492,65 @@ class TypeVisitor(Generic[T]):
     The parameter T is the return type of the visit methods.
     """
 
+    def _notimplemented_helper(self) -> NotImplementedError:
+        return NotImplementedError("Method visit_type_list not implemented in "
+                                   + "'{}'\n".format(type(self).__name__)
+                                   + "This is a known bug, track development in "
+                                   + "'https://github.com/JukkaL/mypy/issues/730'")
+
+    @abstractmethod
     def visit_unbound_type(self, t: UnboundType) -> T:
         pass
 
     def visit_type_list(self, t: TypeList) -> T:
-        pass
+        raise self._notimplemented_helper()
 
     def visit_error_type(self, t: ErrorType) -> T:
-        pass
+        raise self._notimplemented_helper()
 
+    @abstractmethod
     def visit_any(self, t: AnyType) -> T:
         pass
 
+    @abstractmethod
     def visit_void(self, t: Void) -> T:
         pass
 
+    @abstractmethod
     def visit_none_type(self, t: NoneTyp) -> T:
         pass
 
     def visit_erased_type(self, t: ErasedType) -> T:
-        pass
+        raise self._notimplemented_helper()
 
+    @abstractmethod
     def visit_type_var(self, t: TypeVarType) -> T:
         pass
 
+    @abstractmethod
     def visit_instance(self, t: Instance) -> T:
         pass
 
+    @abstractmethod
     def visit_callable_type(self, t: CallableType) -> T:
         pass
 
     def visit_overloaded(self, t: Overloaded) -> T:
-        pass
+        raise self._notimplemented_helper()
 
+    @abstractmethod
     def visit_tuple_type(self, t: TupleType) -> T:
         pass
 
     def visit_star_type(self, t: StarType) -> T:
-        pass
+        raise self._notimplemented_helper()
 
+    @abstractmethod
     def visit_union_type(self, t: UnionType) -> T:
         pass
 
     def visit_ellipsis_type(self, t: EllipsisType) -> T:
-        assert False               # XXX catch visitors that don't have this implemented yet
+        raise self._notimplemented_helper()
 
 
 class TypeTranslator(TypeVisitor[Type]):
@@ -609,6 +624,10 @@ def translate_variables(self,
                             variables: List[TypeVarDef]) -> List[TypeVarDef]:
         return variables
 
+    def visit_overloaded(self, type: Overloaded) -> Type:
+        items = [t.accept(self) for t in type.items()]  # type: ignore
+        return Overloaded(items=cast(List[CallableType], items))
+
 
 class TypeStrVisitor(TypeVisitor[str]):
     """Visitor for pretty-printing types into strings.
@@ -805,6 +824,9 @@ def visit_star_type(self, t: StarType) -> bool:
     def visit_union_type(self, t: UnionType) -> bool:
         return self.query_types(t.items)
 
+    def visit_overloaded(self, t: Overloaded) -> bool:
+        return self.query_types(cast(List[Type], t.items()))
+
     def query_types(self, types: List[Type]) -> bool:
         """Perform a query for a list of types.