Support loading from cache in fine-grained incremental mdoe

Author: msullivan

mypy/build.py

@@ -2374,6 +2374,13 @@ def process_graph(graph: Graph, manager: BuildManager) -> None:
                 manager.log("Processing SCC of size %d (%s) as %s" % (size, scc_str, fresh_msg))
             process_stale_scc(graph, scc, manager)
 
+    # If we are running in fine-grained incremental mode with caching,
+    # we need to always process fresh SCCs.
+    if manager.options.fine_grained_incremental and manager.options.cache_fine_grained:
+        for prev_scc in fresh_scc_queue:
+            process_fresh_scc(graph, prev_scc, manager)
+        fresh_scc_queue = []
+
     sccs_left = len(fresh_scc_queue)
     nodes_left = sum(len(scc) for scc in fresh_scc_queue)
     manager.add_stats(sccs_left=sccs_left, nodes_left=nodes_left)

mypy/dmypy_server.py

@@ -103,7 +103,8 @@ def __init__(self, flags: List[str]) -> None:
         if self.fine_grained:
             options.incremental = True
             options.show_traceback = True
-            options.cache_dir = os.devnull
+            if not options.cache_fine_grained:
+                options.cache_dir = os.devnull
 
     def serve(self) -> None:
         """Serve requests, synchronously (no thread or fork)."""

mypy/server/update.py

@@ -279,10 +279,11 @@ def update_single(self, module: str, path: str) -> Tuple[List[str],
             print('triggered:', sorted(filtered))
         self.triggered.extend(triggered | self.previous_targets_with_errors)
         collect_dependencies({module: tree}, self.deps, graph)
-        propagate_changes_using_dependencies(manager, graph, self.deps, triggered,
-                                             {module},
-                                             self.previous_targets_with_errors,
-                                             graph)
+        remaining += propagate_changes_using_dependencies(
+            manager, graph, self.deps, triggered,
+            {module},
+            self.previous_targets_with_errors,
+            graph)
 
         # Preserve state needed for the next update.
         self.previous_targets_with_errors = manager.errors.targets()
@@ -704,9 +705,10 @@ def propagate_changes_using_dependencies(
         triggered: Set[str],
         up_to_date_modules: Set[str],
         targets_with_errors: Set[str],
-        modules: Iterable[str]) -> None:
+        modules: Iterable[str]) -> List[Tuple[str, str]]:
     # TODO: Multiple type checking passes
     num_iter = 0
+    remaining_modules = []
 
     # Propagate changes until nothing visible has changed during the last
     # iteration.
@@ -730,7 +732,13 @@ def propagate_changes_using_dependencies(
         # TODO: Preserve order (set is not optimal)
         for id, nodes in sorted(todo.items(), key=lambda x: x[0]):
             assert id not in up_to_date_modules
-            triggered |= reprocess_nodes(manager, graph, id, nodes, deps)
+            # TODO: Is there a better way to detect that the file isn't loaded?
+            if not manager.modules[id].defs:
+                # We haven't actually loaded this file! Add it to the
+                # queue of files that need to be processed fully.
+                remaining_modules.append((id, manager.modules[id].path))
+            else:
+                triggered |= reprocess_nodes(manager, graph, id, nodes, deps)
         # Changes elsewhere may require us to reprocess modules that were
         # previously considered up to date. For example, there may be a
         # dependency loop that loops back to an originally processed module.
@@ -739,6 +747,8 @@ def propagate_changes_using_dependencies(
         if DEBUG:
             print('triggered:', list(triggered))
 
+    return remaining_modules
+
 
 def find_targets_recursive(
         triggers: Set[str],
@@ -994,4 +1004,6 @@ def lookup_target(modules: Dict[str, MypyFile], target: str) -> List[DeferredNod
 
 
 def extract_type_maps(graph: Graph) -> Dict[str, Dict[Expression, Type]]:
-    return {id: state.type_map() for id, state in graph.items()}
+    # This is used to export information used only by the testmerge harness.
+    return {id: state.type_map() for id, state in graph.items()
+            if state.tree}