logger <- getLogger

   hsc_env <- getSession

   updated_dflags <- liftIO $ updatePlatformConstants dflags1 mconstants

   let upd hue =

               old_hpt = homeUnitEnv_hpt homeUnitEnv

               home_units = HUG.allUnits (ue_home_unit_graph old_unit_env)

           updated_dflags <- liftIO $ updatePlatformConstants dflags0 mconstants

           pure HomeUnitEnv

               , ue_module_graph    = ue_module_graph old_unit_env

               , ue_eps             = ue_eps old_unit_env

               , ue_eud             = ue_eud old_unit_env

               }

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

     else modifySession (hscSetFlags dflags0)

             , ue_eps             = ue_eps unit_env0

             , ue_module_graph    = ue_module_graph unit_env0

             , ue_eud             = ue_eud unit_env0

             }

       modifySession $ \h ->

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

           old_hpt = homeUnitEnv_hpt homeUnitEnv

           home_units = HUG.allUnits (ue_home_unit_graph unit_env)

       updated_dflags <- liftIO $ updatePlatformConstants dflags mconstants

       pure HomeUnitEnv

                -> BkpM a

 withBkpSession cid insts deps session_type do_this = do

     dflags <- getDynFlags

     let cid_fs = unitFS cid

         is_primary = False

         uid_str = unpackFS (mkInstantiatedUnitHash cid insts)

                  | otherwise = sub_comp (key_base p)

         mk_temp_env hsc_env =

             { backend = case session_type of

                             TcSession -> noBackend

                             _         -> backend dflags

             , importPaths = []

             -- Synthesize the flags

             , packageFlags = packageFlags dflags ++ map (\(uid0, rn) ->

                         $ improveUnit unit_state

                         $ renameHoleUnit unit_state (listToUFM insts) uid0

               in ExposePackage

               | otherwise

               = [Nothing]

         linkables <- liftIO $ catMaybes <$> concatHpt takeLinkables (hsc_HPT hsc_env)

         let

             obj_files = concatMap linkableFiles linkables

             compat_fs = unitIdFS cid

             compat_pn = PackageName compat_fs

                         -- really used for anything, so we leave it

                         -- blank for now.

                         TcSession -> []

                                 $ deps ++ [ moduleUnit mod

                                           | (_, mod) <- insts

                                           , not (isHoleModule mod) ],

           { packageDBFlags = packageDBFlags dflags0 ++ [PackageDB (PkgDbPath (unitDatabasePath newdb))]

           }

     -- update platform constants

           , ue_eps       = ue_eps old_unit_env

           , ue_module_graph = ue_module_graph old_unit_env

           , ue_eud       = ue_eud old_unit_env

           }

     setSession $ hscSetFlags dflags $ hsc_env { hsc_unit_env = unit_env }

    , hsc_HUE

    , hsc_HUG

    , hsc_all_home_unit_ids

    , hscUpdateLoggerFlags

    , hscUpdateHUG

    , hscInsertHPT

 hscEUDC :: HscEnv -> ExternalUnitDatabaseCache UnitId

 hscEUDC hsc_env = ue_eud (hsc_unit_env hsc_env)

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

 -- * Queries on Transitive Closure

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

   home_unit_graph <- forM initial_home_graph $ \homeUnitEnv -> do

     let hue_flags = homeUnitEnv_dflags homeUnitEnv

         dflags = homeUnitEnv_dflags homeUnitEnv

     updated_dflags <- liftIO $ updatePlatformConstants dflags mconstants

     emptyHpt <- liftIO $ emptyHomePackageTable

 import GHC.Types.CompleteMatch

 import GHC.Core.InstEnv

 import GHC.Core.FamInstEnv

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

 -- The hard queries

     , ue_eud :: {-# UNPACK #-} !(ExternalUnitDatabaseCache UnitId)

         -- TODO: @fendor Docs

     }

 ueEPS :: UnitEnv -> IO ExternalPackageState

 initUnitEnv cur_unit hug namever platform = do

   eps <- initExternalUnitCache

   eud <- initExternalUnitDatabaseCache

   return $ UnitEnv

     { ue_eps             = eps

     , ue_home_unit_graph = hug

     , ue_platform        = platform

     , ue_namever         = namever

     , ue_eud             = eud

     }

 updateHug :: (HomeUnitGraph -> HomeUnitGraph) -> UnitEnv -> UnitEnv

 module GHC.Unit.State (

         module GHC.Unit.Info,

         -- * Reading the package config, and processing cmdline args

         UnitState(..),

         PreloadUnitClosure,

         lookupUnitId',

         unsafeLookupUnitId,

         isUnitTrusted,

         isUnitInfoTrusted,

         lookupPackageName,

 import qualified Data.Set as Set

 import Control.Applicative

 import GHC.Unit.External.Database

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

 -- The Unit state

 type ModuleNameProvidersMap =

     UniqMap ModuleName (UniqMap Module ModuleOrigin)

 data UnitState = UnitState {

   -- | A mapping of 'Unit' to 'UnitInfo'.  This list is adjusted

   -- so that only valid units are here.  'UnitInfo' reflects

   -- And also to resolve package qualifiers with the PackageImports extension.

   packageNameMap            :: UniqFM PackageName UnitId,

   -- | The units we're going to link in eagerly.  This list

   -- should be in reverse dependency order; that is, a unit

     distrustedUnits = Set.empty,

     preloadClosure = emptyUniqSet,

     packageNameMap = emptyUFM,

     preloadUnits   = [],

     explicitUnits  = [],

     homeUnitDepends = Set.empty,

 -- 'initUnits' can be called again subsequently after updating the

 -- 'packageFlags' field of the 'DynFlags', and it will update the

 -- 'unitState' in 'DynFlags'.

   let forceUnitInfoMap state = unitInfoMap state `seq` ()

   unit_state <- withTiming logger (text "initializing unit database")

                    forceUnitInfoMap

   putDumpFileMaybe logger Opt_D_dump_mod_map "Module Map"

     FormatText (updSDocContext (\ctx -> ctx {sdocLineLength = 200})

                 $ pprModuleMap (moduleNameProvidersMap unit_state))

                              (homeUnitId_ dflags)

                              (homeUnitInstanceOf_ dflags)

                              (homeUnitInstantiations_ dflags)

   return (unit_state,home_unit,mconstants)

 mkHomeUnit

     -> UnitId                 -- ^ Home unit id

     -> Maybe UnitId           -- ^ Home unit instance of

     -> [(ModuleName, Module)] -- ^ Home unit instantiations

     -> HomeUnit

     let

         -- Some wired units can be used to instantiate the home unit. We need to

         -- replace their unit keys with their wired unit ids.

         hu_instantiations = map (fmap (upd_wired_in_mod wmap)) hu_instantiations_

     in case (hu_instanceof, hu_instantiations) of

       (Nothing,[]) -> DefiniteHomeUnit hu_id Nothing

       pkg_configs1 = map (mungeUnitInfo top_dir pkgroot . mapUnitInfo (\(UnitKey x) -> UnitId x) . mkUnitKeyInfo)

                          proto_pkg_configs

   --

   where

     readDirStyleUnitInfo :: OsPath -> IO [DbUnitInfo]

     readDirStyleUnitInfo conf_dir = do

          ds -> ds

     }

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

 -- Modify our copy of the unit database based on trust flags,

 -- -trust and -distrust.

 -- See Note [Wired-in units] in GHC.Unit.Types

 type WiringMap = UniqMap UnitId UnitId

 findWiredInUnits

    :: Logger

    -> [UnitInfo]           -- database

    -> VisibilityMap             -- info on what units are visible

                                 -- for wired in selection

 findWiredInUnits logger prec_map pkgs vis_map = do

   -- Now we must find our wired-in units, and rename them to

   -- their canonical names (eg. base-1.0 ==> base), as described

           , not (unitIsIndefinite realUnitInfo)

           ]

 -- Helper functions for rewiring Module and Unit.  These

 -- rewrite Units of modules in wired-in packages to the form known to the

 mkUnitState

     :: Logger

     -> UnitConfig

     -> IO UnitState

 {-

    Plan.

   -- Compute trust flags (these flags apply regardless of whether

   -- or not packages are visible or not)

             $ foldM (applyTrustFlag prec_map unusable (nonDetEltsUniqMap pkg_map2))

                  (trustedUnits, distrustedUnits) (reverse (unitConfigFlagsTrusted cfg))

   let pkgs1 = nonDetEltsUniqMap pkg_map2

   -- it modifies the unit ids of wired in packages, but when we process

   -- package arguments we need to key against the old versions.

   --

   let pkg_db = mkUnitInfoMap pkgs2

   -- Update the visibility map, so we treat wired packages as visible.

          , moduleNameProvidersMap       = mod_map

          , pluginModuleNameProvidersMap = mkModuleNameProvidersMap logger cfg pkg_db emptyUniqSet plugin_vis_map

          , packageNameMap               = pkgname_map

          , requirementContext           = req_ctx

          , allowVirtualUnits            = unitConfigAllowVirtual cfg

          }

 -- | Given a wired-in 'Unit', "unwire" it into the 'Unit'

 -- that it was recorded as in the package database.

 unwireUnit state uid@(RealUnit (Definite def_uid)) =

 unwireUnit _ uid = uid

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

     setupHomeUnitFor :: GHC.GhcMonad m => Logger -> DynFlags -> S.Set UnitId -> m HomeUnitEnv

     setupHomeUnitFor logger dflags all_home_units = do

       env <- GHC.getSession

       (unit_state,home_unit,_mconstants) <-

       hpt <- liftIO emptyHomePackageTable

       pure (HUG.mkHomeUnitEnv unit_state dflags hpt (Just home_unit))

       , unitHaddockHTMLs        = munge_paths (munge_urls (unitHaddockHTMLs pkg))

       }

    where

       (munge_path,munge_url) = mkMungePathUrl top_dir pkgroot

 -- | Decode an 'OsPath' to 'FilePath', throwing an 'error' if decoding failed.

 -- Prefer 'decodeUtf' and gracious error handling.

 unsafeDecodeUtf :: HasCallStack => OsPath -> FilePath

 unsafeDecodeUtf = OsPath.Internal.so

     logger' <- getLogger

     let logger = setLogFlags logger' (initLogFlags dflags)

     let parserOpts = Parser.initParserOpts dflags

     -- If any --show-interface was used, show the given interfaces

     forM_ (optShowInterfaceFile flags) $ \path -> liftIO $ do

           }

       -- Render the interfaces.

     -- If we were not given any input files, error if documentation was

     -- requested

       packages <- liftIO $ readInterfaceFiles name_cache (readIfaceArgs flags) noChecks

       -- Render even though there are no input files (usually contents/index).

 -- | Run the GHC action using a temporary output directory

 withTempOutputDir :: Ghc a -> Ghc a

   :: DynFlags

   -> ParserOpts

   -> Logger

   -> UnitState

   -> [Flag]

   -> SinceQual

   -> [(DocPaths, Visibility, FilePath, InterfaceFile)]

   -> [Interface]

   -> IO ()

   updateHTMLXRefs (map (\(docPath, _ifaceFilePath, _showModules, ifaceFile) ->

                           ( case baseUrl flags of

                               Nothing  -> docPathsHtml docPath

       (DocPaths {docPathsSources=Just path}, _, _, ifile) <- pkgs

       iface <- ifInstalledIfaces ifile

       return (instMod iface, path)

   where

     -- get package name from unit-id

     packageName :: Unit -> String

   :: DynFlags

   -> ParserOpts

   -> Logger

   -> UnitState

   -> [Flag]

   -> SinceQual

   -> [(FilePath, PackageInterfaces)]

   -> Map Module FilePath

   -> IO ()

   let

     packageInfo = PackageInfo { piPackageName    = fromMaybe (PackageName mempty)

                                                  $ optPackageName flags

     -- records the *wired in* identity base.  So untranslate it

     -- so that we can service the request.

     unwire :: Module -> Module

   reexportedIfaces <- concat `fmap` (for (reexportFlags flags) $ \mod_str -> do

     let warn' = hPutStrLn stderr . ("Warning: " ++)