hue

           { homeUnitEnv_units = unit_state

           , homeUnitEnv_dflags = updated_dflags

           }

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

             { homeUnitEnv_units = unit_state

             , homeUnitEnv_dflags = updated_dflags

             , homeUnitEnv_hpt = old_hpt

             }

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

         { homeUnitEnv_units = unit_state

         , homeUnitEnv_dflags = updated_dflags

         , homeUnitEnv_hpt = old_hpt

         }

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

 findQualifiedModule pkgqual mod_name = withSession $ \hsc_env -> do

   let logger = hsc_logger hsc_env

   liftIO $ trace_if logger (text "findQualifiedModule" <+> ppr mod_name <+> ppr pkgqual)

   let dflags = hsc_dflags hsc_env

   let sec = initSourceErrorContext dflags

   case pkgqual of

         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

           , ue_uic = ue_uic old_unit_env

    , hscUpdateFlags

    , hscSetFlags

    , hsc_home_unit

    , hsc_units

    , hsc_HPT

    , hsc_HUE

 runInteractiveHsc hsc_env = runHsc (mkInteractiveHscEnv hsc_env)

 hsc_home_unit :: HscEnv -> HomeUnit

 hsc_units :: HasDebugCallStack => HscEnv -> UnitState

 hsc_units = ue_homeUnitState . hsc_unit_env

   lookupIfaceByModule (hsc_HUG hsc_env) (eps_PIT eps) mod

 mainModIs :: HomeUnitEnv -> Module

 -- | Retrieve the target code interpreter

 --

   where

     home_unit_graph hpt = HUG.unitEnv_singleton

                         (homeUnitId_ dflags)

 newHscEnvWithHUG :: FilePath -> DynFlags -> UnitId -> HomeUnitGraph -> IO HscEnv

 newHscEnvWithHUG top_dir top_dynflags cur_unit home_unit_graph = do

   where

    initialise_knot_var hsc_env = liftIO $

     in mkModuleEnv . (:[]) . (mod_name,) <$> newIORef emptyTypeEnv

 rehydrateAfter :: HscEnv

   let dflags    = hsc_dflags hsc_env

   let logger    = hsc_logger hsc_env

   let unit_env  = hsc_unit_env hsc_env

   let tmpfs     = hsc_tmpfs hsc_env

   let tmpdir    = tmpDir dflags

   let platform  = ue_platform unit_env

           -- These symbols are imported into the stub.c file via RtsAPI.h, and the

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

           -- the base package or not.

                  -- GCC 4.6+ doesn't like -Wimplicit when compiling C++.

                  ++ (if (cc_phase /= Ccxx && cc_phase /= Cobjcxx)

 import GHC.Unit.Env

 import GHC.Unit (UnitId)

 import GHC.Unit.Home.PackageTable

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Unit.State  ( emptyUnitState )

       { homeUnitEnv_units = unit_state

       , homeUnitEnv_dflags = updated_dflags

       , homeUnitEnv_hpt = emptyHpt

       }

   checkUnitCycles initial_dflags home_unit_graph

   unitEnvList <- forM unitDflags $ \dflags -> do

     emptyHpt <- emptyHomePackageTable

     let newInternalUnitEnv =

     return (homeUnitId_ dflags, newInternalUnitEnv)

   let activeUnit = fst $ NE.head unitEnvList

   return (HUG.hugFromList (NE.toList unitEnvList), activeUnit)

   = do

     file_hashes <- liftIO $ mapM getFileHash dependent_files

     dirs_hashes <- liftIO $ mapM getDirHash dependent_dirs

     -- Dependencies on object files due to TH and plugins

     object_usages <- liftIO $ mkObjectUsage plugins fc needed_links needed_pkgs

     let all_home_ids = HUG.allUnits (ue_home_unit_graph unit_env)

   = 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

     -> CantFindInstalled

   = CantFindInstalled mod_name more_info

   where

     build_tag  = waysBuildTag (profileWays profile)

             InstalledNotFound files mb_pkg

                 | Just pkg <- mb_pkg

                 -> not_found_in_package pkg $ fmap unsafeDecodeUtf files

                 | null files

 cantFindErr unit_env profile mod_name find_result

   = CantFindInstalled mod_name more_info

   where

     more_info

       = case find_result of

             NoPackage pkg

                      , fr_mods_hidden = mod_hiddens, fr_pkgs_hidden = pkg_hiddens

                      , fr_unusables = unusables, fr_suggestions = suggest }

                 | Just pkg <- mb_pkg

                 -> not_found_in_package (toUnitId pkg) files

                 | not (null suggest)

                 -- Check whether we have the interface already

         ; hsc_env <- getTopEnv

         ; liftIO (lookupIfaceByModule hug (eps_PIT eps) mod) >>= \case {

             Just iface

                 -> return (Succeeded iface) ;   -- Already loaded

             _ -> do {

         -- READ THE MODULE IN

                            Failed err             -> return (Failed err)

                            Succeeded hi_boot_file -> do

                              hsc_env <- getTopEnv

         ; warnPprTrace bad_boot "loadInterface" (ppr mod) $

           updateEps_  $ \ eps ->

                 then eps

            else if bad_boot

                 -- See Note [Loading your own hi-boot file]

 -- | 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.

     -- 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

   -> IO (MaybeErr MissingInterfaceError (ModIface, ModLocation))

 computeInterface hsc_env doc_str hi_boot_file mod0 = do

   massert (not (isHoleModule mod0))

   let find_iface m = findAndReadIface hsc_env doc_str

                                       m mod0 hi_boot_file

   case getModuleInstantiation mod0 of

       (imod, Just indef)

           find_iface imod >>= \case

             Succeeded (iface0, path) ->

               rnModIface hsc_env (instUnitInsts (moduleUnit indef)) Nothing iface0 >>= \case

                 return (Succeeded (renameFreeHoles ifhs insts))

             Failed err -> return (Failed err)

                -> MaybeErr MissingInterfaceError IsBootInterface

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

   = 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

   let profile = targetProfile dflags

       unit_state = hsc_units hsc_env

       name_cache = hsc_NC hsc_env

       dflags     = hsc_dflags hsc_env

       logger     = hsc_logger hsc_env

       hooks      = hsc_hooks hsc_env

           trace_if logger (text "...not found")

           return $ Failed $ cannotFindInterface

                               unit_state

                               profile

                               (moduleName mod)

                               err

       = HUG.lookupHugByModule mod (ue_home_unit_graph unit_env) >>= \case

           Just mod_info -> adjust_linkable (expectJust (homeModLinkable mod_info))

           Nothing -> do

         where

             fallback_no_bytecode home_unit mod = do

               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

   let load_info mod = do

         -- Adapted from the tangled code in GHC.Linker.Loader.getLinkDeps.

         linkable <- HUG.lookupHugByModule mod (ue_home_unit_graph unit_env) >>= \case

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

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

                 where

                     found loc mod = do {

                       mb_lnk <- findObjectLinkableMaybe mod loc ;

                       case mb_lnk of {

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

         found <- findImportedModule hsc_env imp mb_pkg

         case found of

                 return (uniqDSetToList (moduleFreeHoles mod))

             _ -> return []

   where

 -- | Like @implicitRequirements'@, but returns either the module name, if it is

 -- a free hole, or the instantiated unit the imported module is from, so that

   -> IO ([ModuleName], [InstantiatedUnit])

 implicitRequirementsShallow hsc_env normal_imports = go ([], []) normal_imports

  where

   go acc [] = pure acc

   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)

 lookupGlobal_maybe hsc_env name

   = do  {    -- Try local envt

           let mod = icInteractiveModule (hsc_IC hsc_env)

         ; if nameIsLocalOrFrom tcg_semantic_mod name

           then return $ Failed $ Left name

      ; let

         -- bangs to avoid leaking the env (#19356)

         !dflags = hsc_dflags hsc_env

         !logger = hsc_logger hsc_env

         maybe_rn_syntax :: forall a. a -> Maybe a ;

           , tcg_th_docs            = th_docs_var

           , tcg_mod                = mod

           , tcg_src                = hsc_src

           , tcg_rdr_env            = emptyGlobalRdrEnv

           , tcg_fix_env            = emptyNameEnv

   = do  { tcg_env <- getGblEnv

         ; hsc_env <- getTopEnv

           -- bangs to avoid leaking the envs (#19356)

               !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 =

     , ue_unitHomeUnit_maybe

     , ue_updateHomeUnitEnv

     , ue_all_home_unit_ids

     -- * HUG Re-export

     , HomeUnitGraph

   where

     unit_state = HUG.homeUnitEnv_units (ue_currentHomeUnitEnv unit_env)

     ids      = ids0 ++ inst_ids

     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_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

 {-# LANGUAGE RecordWildCards  #-}

 -- | Module finder

 module GHC.Unit.Finder (

 findImportedModule :: HscEnv -> ModuleName -> PkgQual -> IO FindResult

 findImportedModule hsc_env mod pkg_qual =

   let fc           = hsc_FC hsc_env

       dflags       = hsc_dflags hsc_env

       fopts        = initFinderOpts dflags

   in do

   -> FinderOpts

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> ModuleName

   -> PkgQual

   -> IO FindResult

   case mb_pkg of

     NoPkgQual  -> unqual_import

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

     OtherPkg _ -> pkg_import

   where

     all_opts :: [(UnitId, FinderOpts)]

     home_import :: IO FindResult

     home_pkg_import :: (UnitId, FinderOpts) -> IO FindResult

     home_pkg_import = findHomeUnitDepModule fc ue home_module_name_providers_map mod_name

     unqual_import :: IO FindResult

     unqual_import = findHomeOrRegularPackageModule fc fopts ue

     unit_state :: UnitState

     other_fopts :: [(UnitId, FinderOpts)]

     other_fopts = homeUnitDepsFinderOpts ue home_module_name_providers_map

   -> FinderOpts

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> ModuleName

   -> IO FindResult

     findHomeModuleAmongDeps fc fopts ue home_module_name_providers_map

     `orIfNotFound`

     findExposedPluginPackageModule fc fopts unit_state mod_name

   where

     unit_state = HUG.homeUnitEnv_units $

                  ue_findHomeUnitEnv (homeUnitId home_unit) ue

 findPluginModule :: HscEnv -> ModuleName -> IO FindResult

 findPluginModule hsc_env mod_name = do

   let fc           = hsc_FC hsc_env

       home_module_name_providers_map =

         mgHomeModuleNameProvidersMap (hsc_mod_graph hsc_env)

   findPluginModuleNoHsc fc (initFinderOpts (hsc_dflags hsc_env))

     | Just real_mod_name

           <- lookupUniqMap (finder_reexportedModules opts) mod_name

         = findHomeOrRegularPackageModule fc opts ue home_module_name_providers_map

               real_mod_name

     | elementOfUniqSet mod_name (finder_hiddenModules opts)

         = return (mkHomeHidden uid)

   -> FinderOpts

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> ModuleName

   -> IO FindResult

     foldr1 orIfNotFound (home_import :| map home_pkg_import other_fopts)

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

     -- (map home_pkg_import other_fopts)`, as that would not be the same.

     -- `home_import` is first because we need to first look within the current

     -- unit before looking at the other units in order.

   where

     home_pkg_import = findHomeUnitDepModule fc ue home_module_name_providers_map mod_name

     other_fopts = homeUnitDepsFinderOpts ue home_module_name_providers_map

                                          unit_state mod_name

   -> FinderOpts

   -> UnitEnv

   -> HomeModuleNameProvidersMap

   -> ModuleName

   -> IO FindResult

     findHomeModuleAmongDeps fc fopts ue home_module_name_providers_map

     `orIfNotFound`

     findExposedPackageModule fc fopts unit_state mod_name NoPkgQual

   where

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

 -- directly.

      | 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

   let dflags = hsc_dflags hsc_env

   let fc = hsc_FC hsc_env

   let unit_state = hsc_units 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

 --       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 dflags hpt home_unit = HomeUnitEnv

   { homeUnitEnv_units = us

   , homeUnitEnv_dflags = dflags

 pprHomeUnitEnv uid env = do

   hptDoc <- pprHPT $ homeUnitEnv_hpt env

   return $