`downsweep` takes a `Maybe ModuleGraph` as one of its arguments.

 Downsweep iteratively *expands* each so-called 'DownsweepNode' into a list of

   dsNodeExpand :: DownsweepNode -> DownsweepM (NodeRes (ModuleGraphNode, [DownsweepNode]))

 modifySummCache :: ModSummaryCache -> (ModSummaryCacheMap -> ModSummaryCacheMap) -> IO ()

 modifyImpsCache :: ImportsCache    -> (ImportsCacheMap    -> ImportsCacheMap)    -> IO ()

 -- | A cache from a module import (in given home unit context, with a package

 -- qualifier, and the imported module name (with or without SOURCE)) to the

   return PreprocessedImports {..}

 --------------------------------------------------------------------------------

 --------------------------------------------------------------------------------

 data NodeRes v

   -- | Computed the node payload successfully

   = NSuccess v

   -- abort.

   | NSkip

 -- graph by iteratively expanding a node into a payload and a list of children

 -- nodes to visit next.

 --

 -- The result is a mapping from the key of every node transitively reachable

 -- from the root nodes (inclusively) to the payload returned by expanding that

 -- node. The result includes the previously visited nodes given in @base_map@,

 --

 -- The @expand@ function returns an 'NResult'. See the 'NResult' documentation

 -- for more information about each result type.

     visited_var <- newTVarIO (fromMaybe Map.empty base_map)

     pending     <- newTVarIO Set.empty

     worklist    <- newTQueueIO

     coord_tid   <- forkIO $

       coordinator ds_env exc_var visited_var worklist pending

         `MC.catch` \case

           (e::MC.SomeException)

             -- exit cleanly when killed

             | otherwise -> atomically (modifyTVar' exc_var (<|> Just e))

     mapM_ (atomically . writeTQueue worklist) roots

     mb_exc <- atomically $ do

       readTVar exc_var >>= \case

         Nothing -> do

           empty_worklist <- isEmptyTQueue worklist

           empty_pending  <- Set.null <$> readTVar pending

           unless (empty_worklist && empty_pending) retry

           return Nothing

     killThread coord_tid

     case mb_exc of

       Just e  -> throwIO e

       Nothing -> readTVarIO visited_var

   where

     coordinator ds_env exc_var visvar worklist pendvar = forever $ do

       mb_node_to_expand <- atomically $ do

       case mb_node_to_expand of

         Nothing        -> return ()

           withLocalTmpFSMake (ds_make_env ds_env) $ \make_env ->

             forkIO $

       withAbstractSem (compile_sem ds_make_env) $ -- acquire -j par token

              expand node -- do the main work!

         case r of

             atomically $ modifyTVar' visvar (Map.insert k NSkip)

             atomically $ modifyTVar' visvar (Map.insert k (NSuccess v))

             mapM_ (atomically . writeTQueue worklist) ns

         atomically $ modifyTVar' pendvar (Set.delete k)

 {-

 Note [Downsweep Control Flow and Caching]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 which takes care of iteratively expanding and traversing all nodes of the

 in-construction module graph necessary to build a full `ModuleGraph` at the

 end.

 sure we don't do repeated work (notably, we NEVER summarise the same module

 twice).

    same node of the module graph. Cache is keyed by the final

    `ModuleGraph`s `NodeKey`s.