case home of

         Just m  -> return m

         Nothing -> liftIO $ do

            case res of

              Found loc m | notHomeModuleMaybe mhome_unit m -> return m

                          | otherwise -> modNotLoadedError dflags m loc

              err -> throwOneError sec $ noModError hsc_env noSrcSpan mod_name err

     _ -> liftIO $ do

       case res of

         Found _ m -> return m

         err       -> throwOneError sec $ noModError hsc_env noSrcSpan mod_name err

       let dflags = hsc_dflags hsc_env

       let sec    = initSourceErrorContext dflags

       let fopts  = initFinderOpts dflags

       case res of

         Found _ m -> return m

         err       -> throwOneError sec $ noModError hsc_env noSrcSpan mod_name err

       let dflags = hsc_dflags hsc_env

       let sec    = initSourceErrorContext dflags

       let fopts  = initFinderOpts dflags

       case res of

         Found _ m -> return [m]

         err       -> throwOneError sec $ noModError hsc_env noSrcSpan mod_name err

 {-# LANGUAGE BlockArguments #-}

 module GHC.Driver.Concurrency

     WorkerLimit(..)

     -- * Concurrent worker scheduling

   , runCoordinatingWorkers

   , WorkerCoordination(runBlockingAction)

   , Demand

   , Rule

   , RuleAnswer(..)

       home_uid = homeUnitId (hsc_home_unit hsc_env)

       env = DownsweepEnv

         { ds_hsc_env   = hsc_env

         , ds_prior     = Map.empty

         , ds_excl_mods = []

         }

     -- to this function should already know that we can find the modules we need

     -- to load.

     for_ installed_mods $ \ i ->

         InstalledFound {} -> return ()

         _ -> throwGhcException $ ProgramError $ showSDoc (hsc_dflags hsc_env) $

                text "downsweepInstalledModules: Could not find installed module" <+> ppr i

 data DownsweepMode

   -- | @--make@: home modules are summarised from source and compiled.

   = DownsweepUseCompile

   | DownsweepUseFixed

 -- | A 'ModSummary's provenance during downsweep: an old previously constructed

 -- ModSummary, that might be potentially outdated, or a freshly constructed one

 downsweepRule env demand query =

   case query of

     Summarise uid path -> pure $ AnswerDefer \ worker_env -> do

       result <- summariseHomeSourceFile (worker_local_env worker_env) uid path

                   | IsBoot <- [isBootSummary ms] ]

 -- | Resolve a module lookup made from the given home unit.

 resolveDownsweepImport env home_uid lkp

   | ui_mod_name lkp `elem` ds_excl_mods env

   | otherwise

   where

     home_unit = ue_unitHomeUnit home_uid (hsc_unit_env (ds_hsc_env env))

     -- All operations happen relative to the home unit the import was made from.

     hsc_env = hscSetActiveHomeUnit home_unit (ds_hsc_env env)

     home_module location mod = case ds_mode env of

       DownsweepUseCompile ->

           Just path -> ResolvedHome key path

           Nothing   -> ResolvedNotFound

       where

         key = moduleToMnk mod (ui_boot lkp)

 -- it records.

 readFixedModule :: DownsweepEnv -> ModNodeKeyWithUid -> IO (Maybe FixedModule)

 readFixedModule (DownsweepEnv { ds_hsc_env = hsc_env }) key =

     InstalledFound loc -> do

       -- MP: TODO, we should just read the dependency info from the interface rather than either

       -- a. Loading the whole thing into the EPS (this might never nececssary and causes lots of things to be permanently loaded into memory)

     Nothing -> Nothing

     Just (Identity resolution) -> case resolution of

       ResolvedNotFound          -> Nothing

       ResolvedExternal uid      -> Just (NodeKey_ExternalUnit uid)

       ResolvedInstantiation iud -> Just (NodeKey_Unit iud)

       ResolvedHome key path     ->

         case lookupDMap (Summarise (mnkUnitId key) path) answers of

           Just (Identity (SummariseFound ms)) | msKey ms == key

                        { ui_pkg_qual = ThisPkg (homeUnitId home_unit) }

           -- A module target has to name a home module we can compile.

           not_found = return $ Left (moduleNotFoundErr uid modl)

       case resolution of

         ResolvedHome key path ->

           summarise (Just (uid, root_imp, resolution)) (mnkUnitId key) path

     hidden_warns = hidden_mods `minusUniqSet` unit_mods

     check_reexport mn = do

       fr <- lookupModule (reexportFrom mn)

 findDependency hsc_env (L srcloc imp) include_pkg_deps = do

   -- Find the module; this will be fast because

   -- we've done it once during downsweep.

   case r of

     Found loc _

         -- Home package: just depend on the .hi or hi-boot file

 loadKnownKeyOccMaps :: IfM lcl (MaybeErr IfaceMessage KnownKeyNameMaps)

 loadKnownKeyOccMaps

   = do { hsc_env <- getTopEnv

            findImportedModule hsc_env LookupSystem eSSENTIALS_NAME NoPkgQual

        ; case fr of

            Found _ mod -> Succeeded <$> known_key_maps mod

   -- interface; it will call the Finder again, but the ModLocation will be

   -- cached from the first search.

   = do hsc_env <- getTopEnv

        case res of

            Found _ mod -> initIfaceTcRn $ loadInterface doc mod (ImportByUser want_boot)

            -- TODO: Make sure this error message is good

                      nest 4 (text "reason:" <+> doc_str)])

   -- Look for the file

   case mb_found of

       InstalledFound loc -> do

           -- See Note [Home module load error]

    classify_imports imports =

     liftIO $ traverse (\ (L _ e) ->

            let reason = ModuleChanged (ui_mod_name e)

            imports

    logger        = hsc_logger hsc_env

               let fc = ldFinderCache opts

               let fopts = ldFinderOpts opts

               case mb_stuff of

                 Found loc _ -> do

                   from_bc <- ldLoadByteCode opts mod loc

             fallback_no_bytecode home_unit mod = do

               let fc = ldFinderCache opts

               let fopts = ldFinderOpts opts

               case mb_stuff of

                 Found loc _ -> do

                   mb_lnk <- findObjectLinkableMaybe mod loc

 import GHC.Types.Name.Reader

 import GHC.Types.Unique.DFM

 import GHC.Driver.Config.Diagnostic ( initIfaceMessageOpts )

 import GHC.Unit.Module   ( Module, ModuleName, thisGhcUnit, GenModule(moduleUnit), IsBootInterface(NotBoot) )

 import GHC.Unit.Module.ModIface

 lookupRdrNameInModuleForPlugins hsc_env mod_name rdr_name = do

     let dflags     = hsc_dflags hsc_env

     -- First find the unit the module resides in by searching exposed units and home modules

     case found_module of

         Found _ mod -> do

             -- Find the exports of the module

                         )

 import GHC.Unit.Finder.Types

 import GHC.Driver.Config.Finder (initFinderOpts)

 import qualified GHC.Unit.Home.Graph as HUG

               case ue_homeUnit unit_env of

                 Nothing -> pprPanic "getDeps: No home-unit: " (pprModule mod)

                 Just home_unit -> do

                     case mb_stuff of

                       Found loc mod -> found loc mod

                       _ -> pprPanic "getDeps: Couldn't find home-module: " (pprModule mod)

         let home_unit = hsc_home_unit hsc_env

         let dflags    = hsc_dflags hsc_env

         let fopts     = initFinderOpts dflags

         let err = TcRnTHError $ AddInvalidCorePlugin plugin

         case r of

           Found {} -> addErr err

 findImportedModule :: ModuleName -> PkgQual -> TcPluginM Finder.FindResult

 findImportedModule mod_name mb_pkg = do

     hsc_env <- getTopEnv

 lookupOrig :: Module -> OccName -> TcPluginM Name

 lookupOrig mod = unsafeTcPluginTcM . IfaceEnv.lookupOrig mod

 implicitRequirements hsc_env normal_imports

   = fmap concat $

     forM normal_imports $ \e -> do

         case found of

             Found _ mod | notHomeModuleMaybe mhome_unit mod ->

                 return (uniqDSetToList (moduleFreeHoles mod))

   go acc [] = pure acc

   go accR (e:imports) = do

     let acc' = case found of

           Found _ mod | notHomeModuleMaybe mhome_unit mod ->

               case moduleUnit mod of

 -}

 -- | Module finder

 module GHC.Unit.Finder (

     FindResult(..),

     InstalledFindResult(..),

     FinderOpts(..),

     FinderCache(..),

     initFinderCache,

     findImportedModule,

     resolveImport,

     findPluginModule,

     findExactModule,

     findHomeModule,

 import qualified System.OsPath as OsPath

 import qualified Data.List.NonEmpty as NE

 type FileExt = OsString -- Filename extension

 type BaseName = OsPath  -- Basename of file

   let hash    = fingerprintFingerprints s_hashes

   return hash

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

 --External entry points

 --

 -- Handles user-written module imports, @SOURCE@ imports, plugin module imports,

 -- system imports, etc.

 resolveImport hsc_env (UnresolvedImport { ui_scope, ui_pkg_qual, ui_boot, ui_mod_name }) = do

   res <- findImportedModule hsc_env ui_scope ui_mod_name ui_pkg_qual

   case (res, ui_boot) of

      -- ^ The module name to look up

   -> PkgQual

      -- ^ Optional PackageImports package name

 findImportedModule hsc_env scope mod pkg_qual =

   let fc           = hsc_FC hsc_env

       mb_home_unit = hsc_home_unit_maybe hsc_env

   -> ModuleLookupScope

   -> ModuleName

   -> PkgQual

 findImportedModuleNoHsc fc fopts ue home_module_name_providers_map mb_home_unit scope mod_name mb_pkg

   | LookupPlugin <- scope

   = findPluginModuleNoHsc fc fopts ue home_module_name_providers_map mb_home_unit mod_name

         Nothing           -> other_fopts

         Just home_unit_id -> (home_unit_id, fopts) : other_fopts

     home_import = case mb_home_unit of

         Just home_unit -> findHomeModule fc fopts home_unit mod_name

         Nothing        -> pure $

                           NoPackage (panic "findImportedModule: no home-unit")

     home_pkg_import = findHomeUnitDepModule fc ue home_module_name_providers_map scope mod_name

     pkg_import = findExposedPackageModule fc fopts unit_state scope mod_name mb_pkg

     unqual_import = findHomeOrRegularPackageModule fc fopts ue

                         home_module_name_providers_map mb_home_unit scope mod_name

   -> HomeModuleNameProvidersMap

   -> Maybe HomeUnit

   -> ModuleName

 findPluginModuleNoHsc fc fopts ue home_module_name_providers_map mb_home_unit@(Just home_unit) mod_name =

     findHomeModuleAmongDeps fc fopts ue home_module_name_providers_map

                             mb_home_unit LookupUser mod_name

 findPluginModuleNoHsc fc fopts ue _ Nothing mod_name =

   findExposedPluginPackageModule fc fopts (ue_homeUnitState ue) mod_name

 findPluginModule hsc_env mod_name = do

   let fc           = hsc_FC hsc_env

       mb_home_unit = hsc_home_unit_maybe hsc_env

   -> ModuleLookupScope

   -> ModuleName

   -> (UnitId, FinderOpts)

 findHomeUnitDepModule fc ue home_module_name_providers_map scope mod_name (uid, opts)

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

     -- perspective of the package which reexports it.

   -> Maybe HomeUnit

   -> ModuleLookupScope

   -> ModuleName

 findHomeModuleAmongDeps fc fopts ue home_module_name_providers_map mb_home_unit scope mod_name =

     foldr1 orIfNotFound (home_import :| map home_pkg_import other_fopts)

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

   -> Maybe HomeUnit

   -> ModuleLookupScope

   -> ModuleName

 findHomeOrRegularPackageModule fc fopts ue home_module_name_providers_map mb_home_unit scope mod_name =

     findHomeModuleAmongDeps fc fopts ue home_module_name_providers_map

                             mb_home_unit scope mod_name

 -- | A version of findExactModule which takes the exact parts of the HscEnv it needs

 -- directly.

 findExactModuleNoHsc fc fopts other_fopts unit_state mb_home_unit mod is_boot = do

   res <- case mb_home_unit of

     Just home_unit

     (InstalledFound loc, IsBoot) -> return (InstalledFound (addBootSuffixLocn loc))

     _ -> return res

 -- | Locate a specific 'Module'.  The purpose of this function is to

 -- create a 'ModLocation' for a given 'Module', that is to find out

 -- where the files associated with this module live.  It is used when

 -- reading the interface for a module mentioned by another interface,

 -- for example (a "system import").

 findExactModule hsc_env mod is_boot = do

   let dflags = hsc_dflags hsc_env

   let fc = hsc_FC hsc_env

   let other_fopts = initFinderOpts . homeUnitEnv_dflags <$> (hsc_HUG hsc_env)

   findExactModuleNoHsc fc (initFinderOpts dflags) other_fopts unit_state home_unit mod is_boot

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

 -- Helpers

              _other -> return res2

     _other -> return res

 findExposedPackageModule fc fopts units scope mod_name mb_pkg =

   findLookupResult fc fopts

     $ lookupModuleWithSuggestions units scope mod_name mb_pkg

 findExposedPluginPackageModule fc fopts units mod_name =

   findLookupResult fc fopts

     $ lookupPluginModuleWithSuggestions units LookupUser mod_name NoPkgQual

 findLookupResult fc fopts r = case r of

      LookupFound m pkg_conf -> do

        let im = fst (getModuleInstantiation m)

                        , fr_unusables = []

                        , fr_suggestions = suggest' })

 addModuleToFinder :: FinderCache -> Module -> ModLocation -> HscSource -> IO ()

 addModuleToFinder fc mod loc src_flavour = do

   let imod = toUnitId <$> mod

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

 --      The internal workers

 findHomeModule fc fopts  home_unit mod_name = do

   let uid       = homeUnitAsUnit home_unit

   r <- findInstalledHomeModule fc fopts (homeUnitId home_unit) mod_name

            , fr_unusables = []

            , fr_suggestions = []}

 findHomePackageModule fc fopts  home_unit mod_name = do

   let uid       = RealUnit (Definite home_unit)

   r <- findInstalledHomeModule fc fopts home_unit mod_name

 --

 --  4. Some special-case code in GHCi (ToDo: Figure out why that needs to

 --  call this.)

    let

      maybe_working_dir = finder_workingDirectory fopts

      home_path = case maybe_working_dir of

   | otherwise            = (work_dir </> fp) : augmentImports work_dir fps

 -- | Search for a module in external packages only.

 findPackageModule fc unit_state fopts mod = do

   let pkg_id = moduleUnit mod

   case lookupUnitId unit_state pkg_id of

 -- the 'UnitInfo' must be consistent with the unit id in the 'Module'.

 -- The redundancy is to avoid an extra lookup in the package state

 -- for the appropriate config.

 findPackageModule_ fc fopts mod pkg_conf = do

   massertPpr (moduleUnit mod == unitId pkg_conf)

              (ppr (moduleUnit mod) <+> ppr (unitId pkg_conf))

     let

        tag = waysBuildTag (finder_ways fopts)

     checkTargetModule :: GhciMonad m => ModuleName -> m Bool

     checkTargetModule m = do

       hsc_env <- GHC.getSession

         Finder.findImportedModule hsc_env Finder.LookupUser m NoPkgQual

       case result of

         Found _ _ -> return True

 import GHC.Unit.Module ( ModuleName, mkModuleName )

 import GHC.Unit.Module.ModIface

 import GHC.Unit.State  ( pprUnits, pprUnitsSimple )

 import GHC.Unit.Types  ( IsBootInterface(..) )

 import GHC.Types.Basic     ( failed )

   let find_it str = do