A bunch of cleanup

Author: msullivan

mypy/build.py

@@ -80,6 +80,7 @@ class BuildResult:
       manager: The build manager.
       files:   Dictionary from module name to related AST node.
       types:   Dictionary from parse tree node to its inferred type.
+      used_cache: Whether the build took advantage of a cache
       errors:  List of error messages.
     """
 
@@ -88,6 +89,7 @@ def __init__(self, manager: 'BuildManager', graph: Graph) -> None:
         self.graph = graph
         self.files = manager.modules
         self.types = manager.all_types  # Non-empty for tests only or if dumping deps
+        self.used_cache = manager.cache_enabled
         self.errors = []  # type: List[str]  # Filled in by build if desired
 
 
@@ -569,6 +571,7 @@ class BuildManager:
       flush_errors:    A function for processing errors after each SCC
       saved_cache:     Dict with saved cache state for coarse-grained dmypy
                        (read-write!)
+      cache_enabled:   Whether cache usage is enabled
       stats:           Dict with various instrumentation numbers
     """
 
@@ -606,9 +609,13 @@ def __init__(self, data_dir: str,
         self.rechecked_modules = set()  # type: Set[str]
         self.plugin = plugin
         self.flush_errors = flush_errors
+        self.cache_enabled = options.incremental and options.cache_dir != os.devnull
         self.saved_cache = saved_cache if saved_cache is not None else {}  # type: SavedCache
         self.stats = {}  # type: Dict[str, Any]  # Values are ints or floats
 
+    def use_fine_grained_cache(self) -> bool:
+        return self.cache_enabled and self.options.use_fine_grained_cache
+
     def maybe_swap_for_shadow_path(self, path: str) -> str:
         if (self.options.shadow_file and
                 os.path.samefile(self.options.shadow_file[0], path)):
@@ -1156,7 +1163,7 @@ def validate_meta(meta: Optional[CacheMeta], id: str, path: Optional[str],
     # changed since the cache was generated. We *don't* want to do a
     # coarse-grained incremental rebuild, so we accept the cache
     # metadata even if it doesn't match the source file.
-    if manager.options.use_fine_grained_cache:
+    if manager.use_fine_grained_cache():
         manager.log('Using potentially stale metadata for {}'.format(id))
         return meta
 
@@ -1654,7 +1661,7 @@ def __init__(self,
         self.path = path
         self.xpath = path or '<string>'
         self.source = source
-        if path and source is None and self.options.incremental:
+        if path and source is None and self.manager.cache_enabled:
             self.meta = find_cache_meta(self.id, path, manager)
             # TODO: Get mtime if not cached.
             if self.meta is not None:
@@ -1677,7 +1684,7 @@ def __init__(self,
             # When doing a fine-grained cache load, pretend we only
             # know about modules that have cache information and defer
             # handling new modules until the fine-grained update.
-            if manager.options.use_fine_grained_cache:
+            if manager.use_fine_grained_cache():
                 manager.log("Deferring module to fine-grained update %s (%s)" % (path, id))
                 raise ModuleNotFound
 
@@ -1798,7 +1805,7 @@ def fix_cross_refs(self) -> None:
         # cache load because we need to gracefully handle missing modules.
         fixup_module_pass_one(self.tree, self.manager.modules,
                               self.manager.options.quick_and_dirty or
-                              self.manager.options.use_fine_grained_cache)
+                              self.manager.use_fine_grained_cache())
 
     def calculate_mros(self) -> None:
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
@@ -2059,7 +2066,7 @@ def valid_references(self) -> Set[str]:
 
     def write_cache(self) -> None:
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
-        if not self.path or self.options.cache_dir == os.devnull:
+        if not self.path or not self.manager.cache_enabled:
             return
         if self.manager.options.quick_and_dirty:
             is_errors = self.manager.errors.is_errors_for_file(self.path)
@@ -2109,10 +2116,9 @@ def dispatch(sources: List[BuildSource], manager: BuildManager) -> Graph:
     # In this case, we just turn the cache off entirely, so we don't need
     # to worry about some files being loaded and some from cache and so
     # that fine-grained mode never *writes* to the cache.
-    if manager.options.use_fine_grained_cache and len(graph) < 0.50 * len(sources):
+    if manager.use_fine_grained_cache() and len(graph) < 0.50 * len(sources):
         manager.log("Redoing load_graph without cache because too much was missing")
-        manager.options.use_fine_grained_cache = False
-        manager.options.cache_dir = os.devnull
+        manager.cache_enabled = False
         graph = load_graph(sources, manager)
 
     t1 = time.time()
@@ -2133,7 +2139,10 @@ def dispatch(sources: List[BuildSource], manager: BuildManager) -> Graph:
     if manager.options.dump_graph:
         dump_graph(graph)
         return graph
-    if manager.options.use_fine_grained_cache:
+    # If we are loading a fine-grained incremental mode cache, we
+    # don't want to do a real incremental reprocess of the graph---we
+    # just want to load in all of the cache information.
+    if manager.use_fine_grained_cache():
         process_fine_grained_cache_graph(graph, manager)
     else:
         process_graph(graph, manager)

mypy/dmypy_server.py

@@ -280,9 +280,6 @@ def initialize_fine_grained(self, sources: List[mypy.build.BuildSource]) -> Dict
             result = mypy.build.build(sources=sources,
                                       options=self.options,
                                       alt_lib_path=self.alt_lib_path)
-            # build will clear use_fine_grained_cache if it needs to give up
-            # on doing a cache load.
-            cache_load_succeeded = self.options.use_fine_grained_cache
         except mypy.errors.CompileError as e:
             output = ''.join(s + '\n' for s in e.messages)
             if e.use_stdout:
@@ -300,7 +297,7 @@ def initialize_fine_grained(self, sources: List[mypy.build.BuildSource]) -> Dict
         # If we are using the fine-grained cache, build hasn't actually done
         # the typechecking on the updated files yet.
         # Run a fine-grained update starting from the cached data
-        if cache_load_succeeded:
+        if result.used_cache:
             # Pull times and hashes out of the saved_cache and stick them into
             # the fswatcher, so we pick up the changes.
             for state in self.fine_grained_manager.graph.values():

mypy/server/update.py

@@ -171,10 +171,8 @@ def __init__(self,
         # Module that we haven't processed yet but that are known to be stale.
         self.stale = []  # type: List[Tuple[str, str]]
         # Disable the cache so that load_graph doesn't try going back to disk
-        # for the cache. This is kind of a hack and it might be better to have
-        # this directly reflected in load_graph's interface.
-        self.options.cache_dir = os.devnull
-        self.options.use_fine_grained_cache = False
+        # for the cache.
+        self.manager.cache_enabled = False
         manager.saved_cache = {}
         # Active triggers during the last update
         self.triggered = []  # type: List[str]