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

                         $ renameHoleUnit unit_state (listToUFM insts) uid0

               in ExposePackage

                 (showSDoc dflags

               | 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

 data GlobalUnitKey =

   GlobalUnitKey

 data UnitIndex = UnitIndex

   -- ^ TODO @fendor: document global property

   -- ^ TODO @fendor: document global property

   }

 initUnitIndex :: UnitIndex

 addUnitInfoMap :: UnitInfoMap -> UnitIndex -> UnitIndex

 addUnitInfoMap unit_info_map unit_index =

   unit_index

     }

 -- lookupUnitInfoMap :: UnitIndex -> UnitId -> Maybe UnitInfo

 -- lookupUnitInfoMap unit_index unit_id =

          ds -> ds

     }

 evaluateUnitInfo :: UnitInfo -> IO UnitInfo

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

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

   return wiredInMap

 updateWiredInUnits wiredInMap knownInfos pkgs =

   map (updateWiredInUnitsInUnitInfo wiredInMap knownInfos) pkgs

 updateWiredInUnitsInUnitInfo wiredInMap knownInfos pkg =

   let

     upd_pkg pkg

                   (unitExposedModules pkg)

         }

   in

       Just ui ->

         Right ui

       Nothing ->

         let

           updated_pkg = upd_deps $ upd_pkg pkg

         in

 -- Helper functions for rewiring Module and Unit.  These

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

                             -- Note: we NEVER expose indefinite packages by

                             -- default, because it's almost assuredly not

                             -- what you want (no mix-in linking has occurred).

                                then addToUniqMap vm (mkUnit p)

                                                UnitVisibility {

                                                  uv_expose_all = True,

                                                  uv_renamings = [],

                                                  uv_requirements = emptyUniqMap,

                                                  uv_explicit = Nothing

                                                }

     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: " ++)