import qualified Data.Map as Map

 import qualified Data.Set as Set

 import Control.Concurrent ( newQSem, waitQSem, signalQSem, ThreadId, killThread, forkIOWithUnmask )

 import qualified GHC.Conc as CC

 import Control.Concurrent.MVar

     liftIO $ flushFinderCaches (hsc_FC hsc_env) (hsc_unit_env hsc_env)

     (errs, graph_nodes) <- liftIO $ downsweep

       excluded_mods allow_dup_roots

     let

       mod_graph = mkModuleGraph graph_nodes

 -- an import of this module mean.

 type DownsweepCache = M.Map (UnitId, PkgQual, ModuleNameWithIsBoot) [Either DriverMessages ModSummary]

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

 --

 -- | Downsweep (dependency analysis)

 downsweep :: HscEnv

           -> [ModSummary]

           -- ^ Old summaries

           -> [ModuleName]       -- Ignore dependencies on these; treat

                                 -- them as if they were package modules

           -> Bool               -- True <=> allow multiple targets to have

                 -- The non-error elements of the returned list all have distinct

                 -- (Modules, IsBoot) identifiers, unless the Bool is true in

                 -- which case there can be repeats

   n_jobs <- mkWorkerLimit (hsc_dflags hsc_env)

   new <- rootSummariesParallel n_jobs hsc_env summary

   where

     summary = getRootSummary excl_mods old_summary_map

     -- file was used in.

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

     -- reading the headers.

     old_summary_map =

 downsweep_imports :: HscEnv

                   -> [ModuleName]

                   -> Bool

                   -> ([(UnitId, DriverMessages)], [ModSummary])

                   -> IO ([DriverMessages], [ModuleGraphNode])

    = do

        let root_map = mkRootMap rootSummariesOk

        checkDuplicates root_map

        let closure_errs = checkHomeUnitsClosed (hsc_unit_env hsc_env)

        let unit_env = hsc_unit_env hsc_env

        let tmpfs    = hsc_tmpfs    hsc_env

 getRootSummary ::

   [ModuleName] ->

   HscEnv ->

   Target ->

   IO (Either (UnitId, 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

 summariseModule

           :: HscEnv

           -> HomeUnit

           -- ^ Map of old summaries

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

           -> Located ModuleName -- Imported module to be summarised

               Right ms -> FoundHome ms

     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

       let hsc' = hscSetActiveUnitId uid hsc_env

       -- Load potential dependencies first

       (done', pls') <- foldM (\(done', pls') uid -> load done' uid pls') (done, pls)

       pls'' <- loadCmdLineLibs'' interp hsc' pls'

       return $ (Set.insert uid done', pls'')

        -- not really correct as pkg_fs is unlikely to be a valid unit-id but

        -- we will report the failure later...

   where

     units = ue_units unit_env

     hpt_deps  = homeUnitDepends units

     loop acc (uid:uids)

       | uid `Set.member` acc = loop acc uids

       | otherwise =

         in loop (Set.insert uid acc) (hue ++ uids)

 import Data.Time

 import qualified Data.Map as M

 import GHC.Driver.Env

 import GHC.Driver.Config.Finder

 import qualified Data.Set as Set

 import qualified Data.List.NonEmpty as NE

       dflags    = hsc_dflags hsc_env

       fopts     = initFinderOpts dflags

   in do

 findImportedModuleNoHsc

   :: FinderCache

   -> FinderOpts

   -> UnitEnv

   -> Maybe HomeUnit

   -> ModuleName

   -> PkgQual

   -> IO FindResult

   case mb_pkg of

     NoPkgQual  -> unqual_import

     ThisPkg uid | (homeUnitId <$> mhome_unit) == Just uid -> home_import

                 | otherwise -> pprPanic "findImportModule" (ppr mod_name $$ ppr mb_pkg $$ ppr (homeUnitId <$> mhome_unit) $$ ppr uid $$ ppr (map fst all_opts))

     OtherPkg _ -> pkg_import

   where

     all_opts = case mhome_unit of

     home_import = case mhome_unit of

                    Just home_unit -> findHomeModule fc fopts home_unit mod_name

       -- If the module is reexported, then look for it as if it was from the perspective

       -- of that package which reexports it.

       | mod_name `Set.member` finder_reexportedModules opts =

       | mod_name `Set.member` finder_hiddenModules opts =

         return (mkHomeHidden uid)

       | otherwise =

     -- Do not be smart and change this to `foldr orIfNotFound home_import hs` as

     -- that is not the same!! home_import is first because we need to look within ourselves

     -- first before looking at the packages in order.

     pkg_import    = findExposedPackageModule fc fopts units  mod_name mb_pkg

     units     = case mhome_unit of

                   Nothing -> ue_units ue

                   Just home_unit -> homeUnitEnv_units $ ue_findHomeUnitEnv (homeUnitId home_unit) ue

     hpt_deps  = homeUnitDepends units

 -- | Locate a plugin module requested by the user, for a compiler

 -- plugin.  This consults the same set of exposed packages as

    , mgModSummaries

    , mgModSummaries'

    , mgLookupModule

    , showModMsg

    , moduleGraphNodeModule

    , moduleGraphNodeModSum

 -- check that the module and its hs-boot agree.

 --

 -- The graph is not necessarily stored in topologically-sorted order.  Use

 -- 'GHC.topSortModuleGraph' and 'GHC.Data.Graph.Directed.flattenSCC' to achieve this.

 data ModuleGraph = ModuleGraph

   { mg_mss :: [ModuleGraphNode]

   , mg_graph :: (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode)

     -- A cached transitive dependency calculation so that a lot of work is not

     -- repeated whenever the transitive dependencies need to be calculated (for example, hptInstances)

   }

 -- | Map a function 'f' over all the 'ModSummaries'.

 -- To preserve invariants 'f' can't change the isBoot status.

 mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph

 mapMG f mg@ModuleGraph{..} = mg

   }

 unionMG :: ModuleGraph -> ModuleGraph -> ModuleGraph

 unionMG a b =

   in ModuleGraph {

         mg_mss = new_mss

       , mg_graph = mkTransDeps new_mss

       }

 mkTransDeps :: [ModuleGraphNode] -> (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode)

 mkTransDeps = first graphReachability {- module graph is acyclic -} . moduleGraphNodes False

 mgModSummaries :: ModuleGraph -> [ModSummary]

 mgModSummaries mg = [ m | ModuleNode _ m <- mgModSummaries' mg ]

       = Just ms

     go _ = Nothing

 emptyMG :: ModuleGraph

 isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool

 isTemplateHaskellOrQQNonBoot ms =

 -- not an element of the ModuleGraph.

 extendMG :: ModuleGraph -> [NodeKey] -> ModSummary -> ModuleGraph

 extendMG ModuleGraph{..} deps ms = ModuleGraph

   }

 extendMGInst :: ModuleGraph -> UnitId -> InstantiatedUnit -> ModuleGraph

 extendMGInst mg uid depUnitId = mg

   -- -Wunused-packages warning.

   explicitUnits :: [(Unit, Maybe PackageArg)],

   -- | This is a full map from 'ModuleName' to all modules which may possibly

   -- be providing it.  These providers may be hidden (but we'll still want

     unwireMap      = emptyUniqMap,

     preloadUnits   = [],

     explicitUnits  = [],

     moduleNameProvidersMap       = emptyUniqMap,

     pluginModuleNameProvidersMap = emptyUniqMap,

     requirementContext           = emptyUniqMap,

   let !state = UnitState

          { preloadUnits                 = dep_preload

          , explicitUnits                = explicit_pkgs

          , unitInfoMap                  = pkg_db

          , preloadClosure               = emptyUniqSet

          , moduleNameProvidersMap       = mod_map

 //

 // The CPP is thus about the RTS version GHC is linked against, and not the

 // version of the GHC being built.

 HsWord64 ghc_unique_counter64 = 0;

 #endif

 #if !MIN_VERSION_GLASGOW_HASKELL(9,3,0,0)

 checkUnitCycles dflags graph = processSCCs sccs

   where

     mkNode :: (UnitId, HomeUnitEnv) -> Node UnitId UnitId

     nodes = map mkNode (unitEnv_elts graph)

     sccs = stronglyConnCompFromEdgedVerticesOrd nodes

     liftIO $ do

     flushFinderCaches (hsc_FC hsc_env) (hsc_unit_env hsc_env)

     createDirectoryIfMissing False "mydir"

     renameFile "B.hs" "mydir/B.hs"

     -- If 'checkSummaryTimestamp' were to call 'addHomeModuleToFinder' with

     -- (ms_location old_summary) like summariseFile used to instead of

     setTargets [tgt]

     hsc_env <- getSession

     it label $ cnd (mapMaybe moduleGraphNodeModSum nodes)