import GHC.Data.FastString

 import GHC.Data.Maybe      ( expectJust )

 import qualified GHC.Data.Maybe as M

 import GHC.Data.StringBuffer

 import GHC.Data.Graph.Directed.Reachability

 import qualified GHC.LanguageExtensions as LangExt

     -- file was used in.

     -- Reuse these if we can because the most expensive part of downsweep is

     -- reading the headers.

     old_summary_map =

     -- Dependencies arising on a unit (backpack and module linking deps)

     unitModuleNodes :: [ModuleGraphNode] -> UnitId -> HomeUnitEnv -> [Either (Messages DriverMessage) ModuleGraphNode]

 -- This function will start at the given roots, and traverse downwards to find

 -- all the dependencies, all the way to the leaf units.

 downsweepFromRootNodes :: HscEnv

                   -> [ModuleName]

                   -> Bool

                   -> DownsweepMode -- ^ Whether to create fixed or compile nodes for dependencies

 data DownsweepEnv = DownsweepEnv {

       downsweep_hsc_env :: HscEnv

     , _downsweep_mode :: DownsweepMode

     , _downsweep_excl_mods :: [ModuleName]

 }

 getRootSummary ::

   [ModuleName] ->

   HscEnv ->

   Target ->

   IO (Either DriverMessages ModSummary)

 summariseFile

         :: HscEnv

         -> HomeUnit

         -> FilePath                     -- source file name

         -> Maybe Phase                  -- start phase

         -> Maybe (StringBuffer,UTCTime)

 summariseFile hsc_env' home_unit old_summaries src_fn mb_phase maybe_buf

         -- we can use a cached summary if one is available and the

         -- source file hasn't changed,

    = do

         let location = ms_location $ old_summary

   where

     -- change the main active unit so all operations happen relative to the given unit

     hsc_env = hscSetActiveHomeUnit home_unit hsc_env'

     -- src_fn does not necessarily exist on the filesystem, so we need to

     -- check what kind of target we are dealing with

     get_src_hash = case maybe_buf of

 -- --make mode.

 summariseModule :: HscEnv

                 -> HomeUnit

                 -> IsBootInterface

                 -> Located ModuleName

                 -> PkgQual

 -- for it and potentially compile it.

 summariseModuleWithSource

           :: HomeUnit

           -- ^ Map of old summaries

           -> IsBootInterface    -- True <=> a {-# SOURCE #-} import

           -> Maybe (StringBuffer, UTCTime)

   where

     dflags    = hsc_dflags hsc_env

     new_summary_cache_check loc mod src_fn h

          -- check the hash on the source file, and

          -- return the cached summary if it hasn't changed.  If the

            Nothing    ->

                checkSummaryHash hsc_env (new_summary loc mod src_fn) old_summary loc h

       | otherwise = new_summary loc mod src_fn h

     new_summary :: ModLocation

                   -> Module