, ue_namever         = ghcNameVersion dflags1

               , ue_home_unit_graph = home_unit_graph

               , ue_current_unit    = ue_currentUnit old_unit_env

               , ue_eps             = ue_eps old_unit_env

               }

         modifySession $ \h -> hscSetFlags dflags1 h{ hsc_unit_env = unit_env }

             , ue_home_unit_graph = home_unit_graph

             , ue_current_unit    = ue_currentUnit unit_env0

             , ue_eps             = ue_eps unit_env0

             }

       modifySession $ \h ->

         -- hscSetFlags takes care of updating the logger as well.

 --

 invalidateModSummaryCache :: GhcMonad m => m ()

 invalidateModSummaryCache =

  where

   inval ms = ms { ms_hs_hash = fingerprint0 }

   where

     dflags         = hsc_dflags hsc_env

     logger         = hsc_logger hsc_env

     extra_vars     = interactiveInScope (hsc_IC hsc_env)

     home_pkg_rules = hugRulesBelow hsc_env (moduleUnitId mod)

                       (GWIB { gwib_mod = moduleName mod, gwib_isBoot = NotBoot })

     ptc            = initPromotionTickContext dflags

     -- mod: get the module out of the current HscEnv so we can retrieve it from the monad.

     -- This is very convienent for the users of the monad (e.g. plugins do not have to

                     (homeUnitId home_unit)

                     (HUG.mkHomeUnitEnv unit_state (Just dbs) dflags (ue_hpt old_unit_env) (Just home_unit))

           , ue_eps       = ue_eps old_unit_env

           }

     setSession $ hscSetFlags dflags $ hsc_env { hsc_unit_env = unit_env }

 module GHC.Driver.Env

    ( Hsc(..)

    , HscEnv (..)

    , hscUpdateFlags

    , hscSetFlags

    , hsc_home_unit

 hsc_HUG :: HscEnv -> HomeUnitGraph

 hsc_HUG = ue_home_unit_graph . hsc_unit_env

 hsc_all_home_unit_ids :: HscEnv -> Set.Set UnitId

 hsc_all_home_unit_ids = HUG.allUnits . hsc_HUG

 hscUpdateHUG :: (HomeUnitGraph -> HomeUnitGraph) -> HscEnv -> HscEnv

 hscUpdateHUG f hsc_env = hsc_env { hsc_unit_env = updateHug f (hsc_unit_env hsc_env) }

 {-

 Note [Target code interpreter]

 -- | Find all rules in modules that are in the transitive closure of the given

 -- module.

 hugRulesBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO RuleBase

 -- | Get annotations from all modules "below" this one (in the dependency

 -- sense) within the home units. If the module is @Nothing@, returns /all/

 -- annotations in the home units.

 hugAnnsBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO AnnEnv

 -- | Find all COMPLETE pragmas in modules that are in the transitive closure of the

 -- given module.

 hugSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO [[a]]

 -- An explicit check to see if we are in one-shot mode to avoid poking the ModuleGraph thunk

 -- These things are currently stored in the EPS for home packages. (See #25795 for

 -- See Note [Downsweep and the ModuleGraph]

 hugSomeThingsBelowUs _ _ hsc_env _ _ | isOneShot (ghcMode (hsc_dflags hsc_env)) = return []

 hugSomeThingsBelowUs extract include_hi_boot hsc_env uid mn

 import GHC.Types.Target

 import GHC.Types.TypeEnv

 import GHC.Unit.Finder.Types

 import GHC.Unit.Env

 import GHC.Utils.Logger

 import GHC.Utils.TmpFs

         hsc_targets :: [Target],

                 -- ^ The targets (or roots) of the current session

         hsc_IC :: InteractiveContext,

                 -- ^ The context for evaluating interactive statements

         , hsc_llvm_config :: !LlvmConfigCache

                 -- ^ LLVM configuration cache.

  }

     return HscEnv { hsc_dflags         = top_dynflags

                   , hsc_logger         = setLogFlags logger (initLogFlags top_dynflags)

                   , hsc_targets        = []

                   , hsc_IC             = emptyInteractiveContext dflags

                   , hsc_NC             = nc_var

                   , hsc_FC             = fc_var

         all_errs <- liftIO $ HUG.unitEnv_foldWithKey one_unit_messages (return emptyMessages) (hsc_HUG hsc_env)

         logDiagnostics (GhcDriverMessage <$> all_errs)

         pure (emptyMessages, mod_graph)

       else do

         -- We don't have a complete module dependency graph,

         -- The graph may be disconnected and is unusable.

         pure (errs, emptyMG)

     -- for any client who might interact with GHC via load'.

     -- See Note [Timing of plugin initialization]

     initializeSessionPlugins

     guessOutputFile

     hsc_env <- getSession

   -- files. See GHC.Tc.Utils.TcGblEnv.tcg_type_env_var.

   -- See also Note [hsc_type_env_var hack]

   type_env_var <- newIORef emptyNameEnv

          -- oneshot mode does not support backpack

          -- and we want to avoid prodding the hsc_mod_graph thunk

          | isOneShot (ghcMode (hsc_dflags hsc_env)) = False

          | otherwise = False

         pruneHomeUnitEnv hme = do

           -- NB: These are empty HPTs because Iface/Load first consults the HPT

           | otherwise

           = do

             hug' <- traverse pruneHomeUnitEnv (ue_home_unit_graph old_unit_env)

             return old_unit_env

               { ue_home_unit_graph = hug'

               }

       in do

         !unit_env <- unit_env_io

         -- mg_has_holes will be checked again, but nothing else about the module graph

         pure $

           hsc_env

                 {  hsc_targets      = panic "cleanTopEnv: hsc_targets"

                 ,  hsc_IC           = panic "cleanTopEnv: hsc_IC"

                 ,  hsc_type_env_vars = case maybe_type_vars of

                                            Just vars -> vars

 withInteractiveModuleNode :: HscEnv -> TcM a -> TcM a

 withInteractiveModuleNode hsc_env thing_inside = do

   mg <- liftIO $ downsweepInteractiveImports hsc_env (hsc_IC hsc_env)

 runTcInteractive :: HscEnv -> TcRn a -> IO (Messages TcRnMessage, Maybe a)

 -- ┌▽────────────┐    │                     │

 -- │HomeUnitGraph│    │                     │

 -- └┬────────────┘    │                     │

 -- @

 --

 module GHC.Unit.Env

     ( UnitEnv (..)

     , initUnitEnv

 import GHC.Unit.Home.PackageTable

 import GHC.Unit.Home.Graph (HomeUnitGraph, HomeUnitEnv)

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Platform

 import GHC.Settings

     , ue_current_unit    :: UnitId

     , ue_home_unit_graph :: !HomeUnitGraph

         -- See Note [Multiple Home Units]

   return $ UnitEnv

     { ue_eps             = eps

     , ue_home_unit_graph = hug

     , ue_current_unit    = cur_unit

     , ue_platform        = platform

     , ue_namever         = namever

   let pruneHomeUnitEnv hme = liftIO $ do

         emptyHpt <- emptyHomePackageTable

         pure  hme{ homeUnitEnv_hpt = emptyHpt }

   modifySessionM $ \hsc_env -> do

     hug' <- traverse pruneHomeUnitEnv $ hsc_HUG hsc_env

     pure $ discardMG $ discardIC $ hscUpdateHUG (const hug') hsc_env