Change the TypeChecker toplevel interface.

Author: Guido van Rossum

mypy/build.py

@@ -1414,8 +1414,10 @@ def type_check(self) -> None:
         if self.options.semantic_analysis_only:
             return
         with self.wrap_context():
-            type_checker = TypeChecker(manager.errors, manager.modules)
-            type_checker.visit_file(self.tree, self.xpath, self.options)
+            type_checker = TypeChecker(manager.errors, manager.modules, self.options,
+                                       self.tree, self.xpath)
+            type_checker.check_first_pass()
+            type_checker.check_second_pass()
             manager.all_types.update(type_checker.type_map)
 
             if self.options.incremental:

mypy/checker.py

@@ -73,6 +73,8 @@ class TypeChecker(NodeVisitor[Type]):
     """Mypy type checker.
 
     Type check mypy source files that have been semantically analyzed.
+
+    You must create a separate instance for each source file.
     """
 
     # Are we type checking a stub?
@@ -119,53 +121,51 @@ class TypeChecker(NodeVisitor[Type]):
     # directly or indirectly.
     module_refs = None  # type: Set[str]
 
-    def __init__(self, errors: Errors, modules: Dict[str, MypyFile]) -> None:
+    def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Options,
+                 tree: MypyFile, path: str) -> None:
         """Construct a type checker.
 
         Use errors to report type check errors.
         """
         self.errors = errors
         self.modules = modules
+        self.options = options
+        self.tree = tree
+        self.path = path
         self.msg = MessageBuilder(errors, modules)
-        self.type_map = {}
-        self.binder = ConditionalTypeBinder()
         self.expr_checker = mypy.checkexpr.ExpressionChecker(self, self.msg)
+        self.binder = ConditionalTypeBinder()
+        self.globals = tree.names
         self.return_types = []
         self.type_context = []
         self.dynamic_funcs = []
         self.function_stack = []
         self.partial_types = []
         self.deferred_nodes = []
-        self.pass_num = 0
-        self.current_node_deferred = False
+        self.type_map = {}
         self.module_refs = set()
-
-    def visit_file(self, file_node: MypyFile, path: str, options: Options) -> None:
-        """Type check a mypy file with the given path."""
-        self.options = options
         self.pass_num = 0
-        self.is_stub = file_node.is_stub
-        self.errors.set_file(path)
-        self.globals = file_node.names
-        self.enter_partial_types()
-        self.is_typeshed_stub = self.errors.is_typeshed_file(path)
-        self.module_refs = set()
-        if self.options.strict_optional_whitelist is None:
-            self.suppress_none_errors = not self.options.show_none_errors
+        self.current_node_deferred = False
+        self.is_stub = tree.is_stub
+        self.is_typeshed_stub = errors.is_typeshed_file(path)
+        if options.strict_optional_whitelist is None:
+            self.suppress_none_errors = not options.show_none_errors
         else:
             self.suppress_none_errors = not any(fnmatch.fnmatch(path, pattern)
                                                 for pattern
-                                                in self.options.strict_optional_whitelist)
+                                                in options.strict_optional_whitelist)
 
-        for d in file_node.defs:
+    def check_first_pass(self) -> None:
+        """Type check the entire file, but defer functions with forward references."""
+        self.errors.set_file(self.path)
+        self.enter_partial_types()
+
+        for d in self.tree.defs:
             self.accept(d)
 
         self.leave_partial_types()
 
-        if self.deferred_nodes:
-            self.check_second_pass()
-
-        self.current_node_deferred = False
+        assert not self.current_node_deferred
 
         all_ = self.globals.get('__all__')
         if all_ is not None and all_.type is not None:
@@ -176,10 +176,9 @@ def visit_file(self, file_node: MypyFile, path: str, options: Options) -> None:
                 self.fail(messages.ALL_MUST_BE_SEQ_STR.format(str_seq_s, all_s),
                           all_.node)
 
-        del self.options
-
     def check_second_pass(self) -> None:
         """Run second pass of type checking which goes through deferred nodes."""
+        self.errors.set_file(self.path)
         self.pass_num = 1
         for node, type_name in self.deferred_nodes:
             if type_name: