, 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 (md_complete_matches . hm_details) False hsc uid mn

 -- | Find instances visible from the given set of imports

 hugInstancesBelow hsc_env uid mnwib = do

  let mn = gwib_mod mnwib

  (insts, famInsts) <-

                                   -- Don't include instances for the current module

                                   in if moduleName (mi_module (hm_iface mod_info)) == mn

                                        then []

                           True -- Include -hi-boot

                           hsc_env

                           uid

 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

 -- We don't need to check the current module, this is done in

 -- tcExtendLocalFamInstEnv.

 -- See Note [The type family instance consistency story].

   = do { (eps, hug) <- getEpsAndHug

        ; traceTc "checkFamInstConsistency" (ppr directlyImpMods)

        ; let { -- Fetch the iface of a given module.  Must succeed as

              -- See Note [Order of type family consistency checks]

              }

        ; debug_consistent_set <- mapM (\x -> (\y -> (x, length y)) <$> modConsistent x) directlyImpMods

        ; traceTc "init_consistent_set" (ppr debug_consistent_set)

        ; let init_consistent_set = map fst (reverse (sortOn snd debug_consistent_set))

 import GHC.Core.TyCo.Tidy( tidyTopType )

 import GHC.Core.FamInstEnv

    ( FamInst, pprFamInst, famInstsRepTyCons, orphNamesOfFamInst

 import GHC.Parser.Header       ( mkPrelImports )

   = do  { (rn_imports, imp_user_spec, rdr_env, imports) <- rnImports import_decls

         -- Get the default declarations for the classes imported by this module

         -- and group them by class.

         ; this_mod <- getModule

         ; gbl_env <- getGblEnv

         ; let unitId = homeUnitId $ hsc_home_unit hsc_env

                 -- filtering also ensures that we don't see instances from

                 -- modules batch (@--make@) compiled before this one, but

                 -- which are not below this one.

                     hugInstancesBelow hsc_env unitId mnwib

                 -- We use 'unsafeInterleaveIO' to avoid redundant memory allocations

                 -- See Note [Lazily loading COMPLETE pragmas] from GHC.HsToCore.Monad

               tcg_rn_imports   = rn_imports,

               tcg_default      = foldMap subsume tc_defaults,

               tcg_inst_env     = tcg_inst_env gbl `unionInstEnv` home_insts,

             }) $ do {

         ; traceRn "rn1" (ppr (imp_direct_dep_mods imports))

                              $ imports }

         ; logger <- getLogger

         ; withTiming logger (text "ConsistencyCheck"<+>brackets (ppr this_mod)) (const ())

         ; traceRn "rn1: } checking family instance consistency" empty

         ; gbl_env <- getGblEnv

 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

   -- * Very important queries

   , allInstances

   , allAnns

   , allCompleteSigs

   go hue = liftA2 (\(a,b) (a',b') -> (a `unionInstEnv` a', b ++ b'))

                   (hptAllInstances (homeUnitEnv_hpt hue))

 allAnns :: HomeUnitGraph -> IO AnnEnv

 allAnns hug = foldr go (pure emptyAnnEnv) hug where

   go hue = liftA2 plusAnnEnv (hptAllAnnotations (homeUnitEnv_hpt hue))

     -- * Queries about home modules

   , hptCompleteSigs

   , hptAllInstances

   , hptAllAnnotations

     -- ** More Traversal-based queries

   let (insts, famInsts) = unzip hits

   return (foldl' unionInstEnv emptyInstEnv insts, concat famInsts)

 -- | All annotations from the HPT

 hptAllAnnotations :: HomePackageTable -> IO AnnEnv

 hptAllAnnotations = fmap mkAnnEnv . concatHpt (md_anns . hm_details)

   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

     process

       ^>= 1.6,

     containers

     base

        >= 4.14 && < 5,

     text