Some cleanups

Author: msullivan

mypy/build.py

@@ -2506,7 +2506,7 @@ def process_graph(graph: Graph, manager: BuildManager) -> None:
                 # TODO: see if it's possible to determine if we need to process only a
                 # _subset_ of the past SCCs instead of having to process them all.
                 for prev_scc in fresh_scc_queue:
-                    process_fresh_scc(graph, prev_scc, manager)
+                    process_fresh_modules(graph, prev_scc, manager)
                 fresh_scc_queue = []
             size = len(scc)
             if size == 1:
@@ -2587,16 +2587,17 @@ def order_ascc(graph: Graph, ascc: AbstractSet[str], pri_max: int = PRI_ALL) ->
     return [s for ss in sccs for s in order_ascc(graph, ss, pri_max)]
 
 
-def process_fresh_scc(graph: Graph, scc: List[str], manager: BuildManager) -> None:
-    """Process the modules in one SCC from their cached data.
+def process_fresh_modules(graph: Graph, modules: List[str], manager: BuildManager) -> None:
+    """Process the modules in one group of modules from their cached data.
 
+    This can be used to process an SCC of modules
     This involves loading the tree from JSON and then doing various cleanups.
     """
-    for id in scc:
+    for id in modules:
         graph[id].load_tree()
-    for id in scc:
+    for id in modules:
         graph[id].fix_cross_refs()
-    for id in scc:
+    for id in modules:
         graph[id].patch_dependency_parents()
 
 

mypy/server/update.py

@@ -122,7 +122,7 @@
 
 from mypy.build import (
     BuildManager, State, BuildSource, BuildResult, Graph, load_graph, module_not_found,
-    process_fresh_scc,
+    process_fresh_modules,
     PRI_INDIRECT, DEBUG_FINE_GRAINED,
 )
 from mypy.checker import DeferredNode
@@ -376,7 +376,7 @@ def find_unloaded_deps(manager: BuildManager, graph: Dict[str, State],
     module, we don't need to explore its dependencies.  (This
     invariant is slightly violated when dependencies are added, which
     can be handled by calling find_unloaded_deps directly on the new
-    dependencies)
+    dependencies.)
     """
     worklist = list(initial)
     seen = set()  # type: Set[str]
@@ -398,12 +398,12 @@ def find_unloaded_deps(manager: BuildManager, graph: Dict[str, State],
 
 def ensure_trees_loaded(manager: BuildManager, graph: Dict[str, State],
                         initial: Sequence[str]) -> None:
-    """Ensure that the modules in initial and their deps have loaded trees"""
+    """Ensure that the modules in initial and their deps have loaded trees."""
     to_process = find_unloaded_deps(manager, graph, initial)
     if to_process:
-        manager.log("Calling process_fresh_scc on an 'scc' of size {} ({})".format(
+        manager.log_fine_grained("Calling process_fresh_modules on set of size {} ({})".format(
             len(to_process), to_process))
-        process_fresh_scc(graph, to_process, manager)
+        process_fresh_modules(graph, to_process, manager)
 
 
 def get_all_dependencies(manager: BuildManager, graph: Dict[str, State]) -> Dict[str, Set[str]]:
@@ -770,9 +770,9 @@ def find_targets_recursive(
                                                Set[str]]:
     """Find names of all targets that need to reprocessed, given some triggers.
 
-    Returns: a tuple containing a:
+    Returns: A tuple containing a:
      * Dictionary from module id to a set of stale targets.
-     * A set of module ids for unparsed modules with stale targets
+     * A set of module ids for unparsed modules with stale targets.
     """
     result = {}  # type: Dict[str, Set[DeferredNode]]
     worklist = triggers