{ homeUnitEnv_units = unit_state

           , homeUnitEnv_unit_dbs = Just dbs

           , homeUnitEnv_dflags = updated_dflags

           }

   let unit_env = UnitEnv.ue_updateHomeUnitEnv upd uid (hsc_unit_env hsc_env)

             , homeUnitEnv_unit_dbs = Just dbs

             , homeUnitEnv_dflags = updated_dflags

             , homeUnitEnv_hpt = old_hpt

             }

         let dflags1 = homeUnitEnv_dflags $ HUG.unitEnv_lookup (ue_currentUnit old_unit_env) home_unit_graph

         , homeUnitEnv_unit_dbs = Just dbs

         , homeUnitEnv_dflags = updated_dflags

         , homeUnitEnv_hpt = old_hpt

         }

 -- When changing the DynFlags, we want the changes to apply to future

         Nothing -> liftIO $ do

            res <- findImportedModule hsc_env mod_name pkgqual

            case res of

                          | otherwise -> modNotLoadedError dflags m loc

              err -> throwOneError sec $ noModError hsc_env noSrcSpan mod_name err

           , ue_home_unit_graph =

                 HUG.unitEnv_singleton

                     (homeUnitId home_unit)

           , ue_eps       = ue_eps old_unit_env

           , ue_module_graph = ue_module_graph old_unit_env

           }

 hsc_home_unit :: HscEnv -> HomeUnit

 hsc_home_unit = ue_unsafeHomeUnit . hsc_unit_env

 hsc_home_unit_maybe = ue_homeUnit . hsc_unit_env

 hsc_units :: HasDebugCallStack => HscEnv -> UnitState

   lookupIfaceByModule (hsc_HUG hsc_env) (eps_PIT eps) mod

 mainModIs :: HomeUnitEnv -> Module

 -- | Retrieve the target code interpreter

 --

       newHscEnv

     , newHscEnvWithHUG

     , initHscEnv

     -- * Compiling complete source files

     , Messager, batchMsg, batchMultiMsg

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Unit.Home.PackageTable

 import qualified GHC.ByteCode.Serialize as ByteCode

 {- **********************************************************************

 %*                                                                      *

 newHscEnv :: FilePath -> DynFlags -> IO HscEnv

 newHscEnv top_dir dflags = do

     nc_var  <- newNameCache

     fc_var  <- initFinderCache

     tmpfs   <- initTmpFs

     let dflags = homeUnitEnv_dflags $ HUG.unitEnv_lookup cur_unit home_unit_graph

     unit_env <- initUnitEnv cur_unit home_unit_graph (ghcNameVersion dflags) (targetPlatform dflags)

                   , hsc_llvm_config    = llvm_config

                   }

 -- | Initialize HscEnv from an optional top_dir path

 initHscEnv :: Maybe FilePath -> IO HscEnv

 initHscEnv mb_top_dir = do

           -- way we do the import depends on whether we're currently compiling

           -- the base package or not.

                  ++ (case home_unit of

                           | isHomeUnitId hu ghcInternalUnitId

                           , platformOS platform == OSMinGW32

                           -> ["-DCOMPILING_GHC_INTERNAL_PACKAGE"]

 import GHC.Unit.Env

 import GHC.Unit (UnitId)

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Types.SrcLoc

 import GHC.Types.SourceError

 import Data.Bifunctor

 import GHC.Data.Graph.Directed

 import qualified Data.List.NonEmpty as NE

 -- Strip out any ["+RTS", ..., "-RTS"] sequences in the command string list.

 removeRTS :: [String] -> [String]

   checkDuplicateUnits initial_dflags (NE.toList (NE.zip unitArgsFiles unitDflags))

   checkUnitCycles initial_dflags home_unit_graph

     augment_maybe (Just f) = Just (augment f)

     augment f | isRelative f, Just offset <- workingDirectory dflags = offset </> f

               | otherwise = f

   = vcat [text "Bad interface file:" <+> text file,

           nest 4 err]

                     -> ModuleName -> InstalledFindResult -> MissingInterfaceError

 cannotFindInterface us mhu p mn ifr =

   CantFindErr us FindingInterface $

 cantFindInstalledErr

     :: UnitState

     -> Profile

     -> ModuleName

     -> InstalledFindResult

             InstalledNotFound files mb_pkg

                 | Just pkg <- mb_pkg

                 -> not_found_in_package pkg $ fmap unsafeDecodeUtf files

                 | null files

                      , fr_mods_hidden = mod_hiddens, fr_pkgs_hidden = pkg_hiddens

                      , fr_unusables = unusables, fr_suggestions = suggest }

                 | Just pkg <- mb_pkg

                 , not (isHomeUnit home_unit pkg)  -- module isn't from it

                 -> not_found_in_package (toUnitId pkg) files

 -- | Returns @True@ if a 'ModIface' comes from an external package.

 -- In this case, we should NOT load it into the EPS; the entities

 -- should instead come from the local merged signature interface.

 is_external_sig mhome_unit iface =

     -- It's a signature iface...

     mi_semantic_module iface /= mi_module iface &&

     -- and it's not from the local package

 -- | This is an improved version of 'findAndReadIface' which can also

 -- handle the case when a user requests @p[A=<B>]:M@ but we only

                                       m mod0 hi_boot_file

   case getModuleInstantiation mod0 of

       (imod, Just indef)

         , isHomeUnitIndefinite home_unit ->

           find_iface imod >>= \case

             Succeeded (iface0, path) ->

                 return (Succeeded (renameFreeHoles ifhs insts))

             Failed err -> return (Failed err)

                -> MaybeErr MissingInterfaceError IsBootInterface

 -- Figure out whether we want Foo.hi or Foo.hi-boot

 wantHiBootFile mhome_unit eps mod from

   = case from of

        ImportByUser usr_boot

           -> Failed (BadSourceImport mod)

           | otherwise -> Succeeded usr_boot

           -> Succeeded NotBoot

        ImportBySystem

           -> Succeeded NotBoot

              -- If the module to be imported is not from this package

              -- don't look it up in eps_is_boot, because that is keyed

            -- It's not in the HPT because we are in one shot mode,

            -- so use the Finder to get a ModLocation...

            case ue_homeUnit unit_env of

               let fc = ldFinderCache opts

               let fopts = ldFinderOpts opts

 renamePkgQual unit_env mn mb_pkg = case mb_pkg of

   Nothing -> NoPkgQual

   Just pkg_fs

     , pkg_fs == fsLit "this"

     -> ThisPkg uid

                 -- It's not in the HPT because we are in one shot mode,

                 -- so use the Finder to get a ModLocation...

               case ue_homeUnit unit_env of

                     mb_stuff <- findHomeModule finder_cache finder_opts home_unit (moduleName mod)

                     case mb_stuff of

                       Found loc mod -> found loc mod

     forM normal_imports $ \(mb_pkg, L _ imp) -> do

         found <- findImportedModule hsc_env imp mb_pkg

         case found of

                 return (uniqDSetToList (moduleFreeHoles mod))

             _ -> return []

   where

   go (accL, accR) ((_stage, mb_pkg, L _ imp):imports) = do

     found <- findImportedModule hsc_env imp mb_pkg

     let acc' = case found of

               case moduleUnit mod of

                   HoleUnit -> (moduleName mod : accL, accR)

                   RealUnit _ -> (accL, accR)

               !knot_vars = tcg_type_env_var tcg_env

               -- When we are instantiating a signature, we DEFINITELY

               -- do not want to knot tie.

         ; let { if_env = IfGblEnv {

                             if_doc = text "initIfaceTcRn",

                             if_rec_types =

   where

     unit_state = HUG.homeUnitEnv_units (ue_currentHomeUnitEnv unit_env)

     ids      = ids0 ++ inst_ids

        -- which is not a real package. Don't look it up.

        -- Fixes #14525

     pkg_map = unitInfoMap unit_state

     preload = preloadUnits unit_state

 -- Query and modify home units in HomeUnitEnv

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

 ue_homeUnit = HUG.homeUnitEnv_home_unit . ue_currentHomeUnitEnv

 ue_unsafeHomeUnit :: UnitEnv -> HomeUnit

 ue_unitHomeUnit :: UnitId -> UnitEnv -> HomeUnit

 ue_unitHomeUnit uid = expectJust . ue_unitHomeUnit_maybe uid

 ue_unitHomeUnit_maybe :: UnitId -> UnitEnv -> Maybe HomeUnit

 ue_unitHomeUnit_maybe uid ue_env =

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

 -- Query and modify the currently active unit

   :: FinderCache

   -> FinderOpts

   -> UnitEnv

   -> ModuleName

   -> PkgQual

   -> IO FindResult

 findImportedModuleNoHsc fc fopts ue mhome_unit mod_name mb_pkg =

   case mb_pkg of

     NoPkgQual  -> unqual_import

                 | Just os <- lookup uid other_fopts -> home_pkg_import (uid, os)

     OtherPkg _ -> pkg_import

   where

     home_pkg_import (uid, opts)

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

       -- of that package which reexports it.

       | Just real_mod_name <- lookupUniqMap (finder_reexportedModules opts) mod_name =

       | elementOfUniqSet mod_name (finder_hiddenModules opts) =

         return (mkHomeHidden uid)

       | otherwise =

                     `orIfNotFound`

                     findExposedPackageModule fc fopts units mod_name NoPkgQual

     hpt_deps :: [UnitId]

     hpt_deps  = Set.toList (homeUnitDepends units)

     other_fopts  = map (\uid -> (uid, initFinderOpts (homeUnitEnv_dflags (ue_findHomeUnitEnv uid ue)))) hpt_deps

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

 -- 'findImportedModule', unless @-hide-all-plugin-packages@ or

 -- @-plugin-package@ are specified.

   findHomeModule fc fopts home_unit mod_name

   `orIfNotFound`

   findExposedPluginPackageModule fc fopts units mod_name

 findPluginModule :: HscEnv -> ModuleName -> IO FindResult

 findPluginModule hsc_env mod_name = do

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

 -- directly.

 findExactModuleNoHsc fc fopts other_fopts unit_state mhome_unit mod is_boot = do

   res <- case mhome_unit of

      | isHomeInstalledModule home_unit mod

         -> findInstalledHomeModule fc fopts (homeUnitId home_unit) (moduleName mod)

      | Just home_fopts <- HUG.unitEnv_lookup_maybe (moduleUnit mod) other_fopts

         -> findInstalledHomeModule fc home_fopts (moduleUnit mod) (moduleName mod)

   case (res, is_boot) of

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

     _ -> return res

 --       the instantiating module of @r:A@ in @p[A=q[]:B]@ is @r:A@.

 --       the instantiating module of @p:A@ in @p@ is @p:A@.

 --       the instantiating module of @r:A@ in @p@ is @r:A@.

    | otherwise           = mod

     --

     -- (This changes a previous invariant: changed Jan 05.)

     -- ^ Home-unit

   }

 mkHomeUnitEnv us dbs dflags hpt home_unit = HomeUnitEnv

   { homeUnitEnv_units = us

   , homeUnitEnv_unit_dbs = dbs

 pprHomeUnitEnv uid env = do

   hptDoc <- pprHPT $ homeUnitEnv_hpt env

   return $

     $$ nest 4 hptDoc

         [ sessionUnitExposedFlag ] ++

         [ homeUnitPkgFlag uid

         | homeUnitEnv <- Foldable.toList $ hsc_HUG hsc_env

         , let uid = homeUnitId homeUnit

         ] ++

         (packageFlags dflags0)

         { packageFlags =

           [ homeUnitPkgFlag uid

           | homeUnitEnv <- Foldable.toList $ hsc_HUG hsc_env

           , let uid = homeUnitId homeUnit

           ] ++

           (packageFlags dflags)

       (dbs,unit_state,home_unit,_mconstants) <-

         liftIO $ initUnits logger dflags (Just cached_unit_dbs) all_home_units

       hpt <- liftIO emptyHomePackageTable

 reportError :: GhciMonad m => GhciCommandMessage -> m ()

 reportError err = do