import GHC.Data.StringBuffer

 import GHC.Data.FastString

 import qualified GHC.LanguageExtensions as LangExt

 import GHC.Tc.Utils.Monad    ( finalSafeMode, fixSafeInstances, initIfaceTcRn )

 import GHC.Tc.Types

   let old_hue = ue_findHomeUnitEnv uid (hsc_unit_env hsc_env)

   let cached_unit_dbs = homeUnitEnv_unit_dbs old_hue

   updated_dflags <- liftIO $ updatePlatformConstants dflags1 mconstants

   let upd hue =

     then do

         -- additionally, set checked dflags so we don't lose fixes

         old_unit_env <- ue_setFlags dflags0 . hsc_unit_env <$> getSession

         home_unit_graph <- forM (ue_home_unit_graph old_unit_env) $ \homeUnitEnv -> do

           let cached_unit_dbs = homeUnitEnv_unit_dbs homeUnitEnv

               old_hpt = homeUnitEnv_hpt homeUnitEnv

               home_units = unitEnv_keys (ue_home_unit_graph old_unit_env)

           updated_dflags <- liftIO $ updatePlatformConstants dflags0 mconstants

           pure HomeUnitEnv

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

     else modifySession (hscSetFlags dflags0)

 getNamePprCtx :: GhcMonad m => m NamePprCtx

 getNamePprCtx = withSession $ \hsc_env -> do

 -- | Container for information about a 'Module'.

 data ModuleInfo = ModuleInfo {

   ModuleInfo ->

   m NamePprCtx

 mkNamePprCtxForModule mod minf = withSession $ \hsc_env -> do

       ptc = initPromotionTickContext (hsc_dflags hsc_env)

   return name_ppr_ctx

    parens (text (expectJust "modNotLoadedError" (ml_hs_file loc)))

 renamePkgQualM :: GhcMonad m => ModuleName -> Maybe FastString -> m PkgQual

 renameRawPkgQualM :: GhcMonad m => ModuleName -> RawPkgQual -> m PkgQual

 -- | Like 'findModule', but differs slightly when the module refers to

 -- a source file, and the file has not been loaded via 'load'.  In

       let units  = hsc_units hsc_env

       let dflags = hsc_dflags hsc_env

       let fopts  = initFinderOpts dflags

       case res of

         Found _ m -> return m

         err       -> throwOneError $ noModError hsc_env noSrcSpan mod_name err

                                 , mg_rdr_env = rdr_env })

   = do { let builtin_passes = getCoreToDo dflags hpt_rule_base extra_vars

              uniq_tag = 's'

        ; (guts2, stats) <- runCoreM hsc_env hpt_rule_base uniq_tag mod

                                     name_ppr_ctx loc $

     home_pkg_rules = hptRules hsc_env (moduleUnitId mod) (GWIB { gwib_mod = moduleName mod

                                                                , gwib_isBoot = NotBoot })

     hpt_rule_base  = mkRuleBase home_pkg_rules

     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

   dflags    <- getDynFlags

   us        <- getUniqueSupplyM

   p_fam_env <- getPackageFamInstEnv

   let platform = targetPlatform dflags

   let fam_envs = (p_fam_env, mg_fam_inst_env guts)

   let updateBinds  f = return $ guts { mg_binds = f (mg_binds guts) }

         mkNamePprCtx

           (initPromotionTickContext dflags)

           (hsc_unit_env hsc_env)

           rdr_env

     logger <- getLogger

     let dflags0 = hsc_dflags hsc_env

     let old_unit_env = hsc_unit_env hsc_env

     newdbs <- case ue_unit_dbs old_unit_env of

         Nothing  -> panic "addUnit: called too early"

         Just dbs ->

                , unitDatabaseUnits = [u]

                }

          in return (dbs ++ [newdb]) -- added at the end because ordering matters

     -- update platform constants

     dflags <- liftIO $ updatePlatformConstants dflags0 mconstants

                     (homeUnitId home_unit)

                     (mkHomeUnitEnv 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 }

     hi_timestamp <- liftIO $ modificationTimeIfExists (ml_hi_file location)

     hie_timestamp <- liftIO $ modificationTimeIfExists (ml_hie_file location)

     -- Also copied from 'getImports'

     let (src_idecls, ord_idecls) = partition ((== IsBoot) . ideclSource . unLoc) imps

         implicit_imports = mkPrelImports modname loc

                                          implicit_prelude imps

         convImport (L _ i) = (rn_pkg_qual (ideclPkgQual i), reLoc $ ideclName i)

     extra_sig_imports <- liftIO $ findExtraSigImports hsc_env hsc_src modname

    , hsc_home_unit

    , hsc_home_unit_maybe

    , hsc_units

    , hsc_HPT

    , hsc_HUE

    , hsc_HUG

 import GHC.Unit.Home.ModInfo

 import GHC.Unit.Env

 import GHC.Unit.External

 import GHC.Core         ( CoreRule )

 import GHC.Core.FamInstEnv

 hsc_units :: HasDebugCallStack => HscEnv -> UnitState

 hsc_units = ue_units . hsc_unit_env

 hsc_HPT :: HscEnv -> HomePackageTable

 hsc_HPT = ue_hpt . hsc_unit_env

     $! {-# SCC "CoreTidy" #-} tidyProgram opts guts

   -- post tidy pretty-printing and linting...

   let tidy_rules     = md_rules details

   let all_tidy_binds = cg_binds cgguts

       ptc            = initPromotionTickContext (hsc_dflags hsc_env)

   endPassHscEnvIO hsc_env name_ppr_ctx CoreTidy all_tidy_binds tidy_rules

 import GHC.Types.Unique.DFM (udfmRestrictKeysSet)

 import GHC.Types.Unique

 import GHC.Iface.Errors.Types

 import qualified GHC.Data.Word64Set as W

 import GHC.Data.Graph.Directed.Reachability

     if isEmptyMessages errs

       then do

         hsc_env <- getSession

         let one_unit_messages get_mod_errs k hue = do

               errs <- get_mod_errs

               unknown_module_err <- warnUnknownModules (hscSetActiveUnitId k hsc_env) (homeUnitEnv_dflags hue) mod_graph

               let unused_home_mod_err = warnMissingHomeModules (homeUnitEnv_dflags hue) (hsc_targets hsc_env) mod_graph

               return $ errs `unionMessages` unused_home_mod_err

 -- actually loaded packages. All the packages, specified on command line,

 -- but never loaded, are probably unused dependencies.

     let diag_opts = initDiagOpts dflags

         home_mod_sum = filter (\ms -> homeUnitId_ dflags == ms_unitid ms) (mgModSummaries mod_graph)

     -- Only need non-source imports here because SOURCE imports are always HPT

         loadedPackages = concat $

             $ concatMap ms_imps home_mod_sum

         any_import_ghc_prim = any ms_ghc_prim_import home_mod_sum

           mimps <- getImports popts imp_prelude pi_hspp_buf pi_hspp_fn src_fn

           let mopts = map unLoc $ snd $ getOptions popts pi_hspp_buf src_fn

           pure $ ((, mopts) <$>) $ first (mkMessages . fmap mkDriverPsHeaderMessage . getMessages) mimps

   let rn_imps = fmap (\(pk, lmn@(L _ mn)) -> (rn_pkg_qual mn pk, lmn))

   let pi_srcimps = rn_imps pi_srcimps'

   let pi_theimps = rn_imps pi_theimps'

   -- gather the imports and module name

   (hspp_buf,mod_name,imps,src_imps, ghc_prim_imp) <- do

     buf <- hGetStringBuffer input_fn

     let imp_prelude = xopt LangExt.ImplicitPrelude dflags

         popts = initParserOpts dflags

         rn_imps = fmap (\(rpk, lmn@(L _ mn)) -> (rn_pkg_qual mn rpk, lmn))

     eimps <- getImports popts imp_prelude buf input_fn (basename <.> suff)

     case eimps of

   = do { let dflags = hsc_dflags hsc_env

              logger = hsc_logger hsc_env

              ptc = initPromotionTickContext (hsc_dflags hsc_env)

         ; withTiming logger

                      (text "Desugar"<+>brackets (ppr mod))

                      (const ()) $

 import GHC.Unit.Env

 import GHC.Unit.External

 import GHC.Unit.Module

 import GHC.Unit.Module.ModGuts

                                 ++ eps_complete_matches eps     -- from imports

              -- re-use existing next_wrapper_num to ensure uniqueness

              next_wrapper_num_var = tcg_next_wrapper_num tcg_env

                            msg_var cc_st_var next_wrapper_num_var complete_matches

        }

        ; next_wrapper_num <- newIORef emptyModuleEnv

        ; msg_var <- newIORef emptyMessages

        ; eps <- liftIO $ hscEPS hsc_env

        ; let unit_env = hsc_unit_env hsc_env

              type_env = typeEnvFromEntities ids tycons patsyns fam_insts

              ptc = initPromotionTickContext (hsc_dflags hsc_env)

              bindsToIds (Rec    binds) = map fst binds

              ids = concatMap bindsToIds binds

                               fam_inst_env ptc msg_var cc_st_var

                               next_wrapper_num complete_matches

        ; runDs hsc_env envs thing_inside

            Just ret -> pure ret

            Nothing  -> pprPanic "initTcDsForSolver" (vcat $ pprMsgEnvelopeBagWithLocDefault (getErrorMessages msgs)) }

          -> PromotionTickContext

          -> IORef (Messages DsMessage) -> IORef CostCentreState

          -> IORef (ModuleEnv Int) -> CompleteMatches

          -> (DsGblEnv, DsLclEnv)

          next_wrapper_num complete_matches

   = let if_genv = IfGblEnv { if_doc       = text "mkDsEnvs"

   -- Failing tests here are `ghci` and `T11985` if you get this wrong.

                            , ds_fam_inst_env = fam_inst_env

                            , ds_gbl_rdr_env  = rdr_env

                            , ds_if_env  = (if_genv, if_lenv)

                            , ds_msgs    = msg_var

                            , ds_complete_matches = complete_matches

                            , ds_cc_st   = cc_st_var

 checkDependencies hsc_env summary iface

  = do

     res_normal <- classify_import (findImportedModule hsc_env) (ms_textual_imps summary ++ ms_srcimps summary)

     case sequence (res_normal ++ res_plugin ++ [Right (fake_ghc_prim_import)| ms_ghc_prim_import summary]) of

       Left recomp -> return $ NeedsRecompile recomp

       Right es -> do

         getMinimalImports,

         printMinimalImports,

         renamePkgQual, renameRawPkgQual,

         classifyGREs,

         ImportDeclUsage,

     ) where

 import GHC.Unit.Module.Imported

 import GHC.Unit.Module.Deps

 import GHC.Unit.Env

 import GHC.Data.Bag

 import GHC.Data.FastString

     hsc_env <- getTopEnv

     unit_env <- hsc_unit_env <$> getTopEnv

     -- Check for self-import, which confuses the typechecker (#9032)

     -- ghc --make rejects self-import cycles already, but batch-mode may not

 -- | Rename raw package imports

   NoRawPkgQual -> NoPkgQual

 -- | Rename raw package imports

   Nothing -> NoPkgQual

   Just pkg_fs

     | Just uid <- homeUnitId <$> ue_homeUnit unit_env

     | Just (uid, _) <- find (fromMaybe False . fmap (== pkg_fs) . snd) home_names

     -> ThisPkg uid

     -> OtherPkg uid

     | otherwise

     hpt_deps :: [UnitId]

     hpt_deps  = homeUnitDepends units

 -- | Calculate the 'ImportAvails' induced by an import of a particular

 -- interface, but without 'imp_mods'.

 import GHC.Unit

 import GHC.Unit.Env

 import GHC.Core.FamInstEnv

 import GHC.Core.InstEnv

         ]

 -- | Get the NamePprCtx function based on the flags and this InteractiveContext

   where ptc = initPromotionTickContext (ic_dflags ictxt)

 -- | extendInteractiveContext is called with new TyThings recently defined to update the

     let unit_state = ue_units unit_env

     let mhome_unit = hsc_home_unit_maybe hsc_env

     -- First find the unit the module resides in by searching exposed units and home modules

     case found_module of

         Found _ mod -> do

             -- Find the exports of the module

         ; when (notNull prel_imports) $ do

             addDiagnostic TcRnImplicitImportOfPrelude

         ; -- TODO This is a little skeevy; maybe handle a bit more directly

           let { simplifyImport (L _ idecl) =

                   , reLoc $ ideclName idecl)

               }

         ; raw_sig_imports <- liftIO

                                  (loadSrcInterface (text "runTcInteractive") m

                                                    NotBoot mb_pkg)

        ; !orphs <- fmap (force . concat) . forM (ic_imports icxt) $ \i ->

             case i of                   -- force above: see #15111

                 IIModule n -> getOrphans n NoPkgQual

        ; let imports = emptyImportAvails { imp_orphs = orphs }

   = do { ptc <- initPromotionTickContext <$> getDynFlags

        ; rdr_env <- getGlobalRdrEnv

        ; hsc_env <- getTopEnv

 -- | Like logInfoTcRn, but for user consumption

 printForUserTcRn :: SDoc -> TcRn ()

 import GHC.Unit

 import GHC.Unit.Env

 import GHC.Types.Name

 import GHC.Types.Name.Reader

 -- | Creates some functions that work out the best ways to format

 -- names for the user according to a set of heuristics.

  = QueryQualify

       (mkQualName env)

       (mkQualPackage unit_state)

       (mkPromTick ptc env)

   where

 -- | Creates a function for formatting modules based on two heuristics:

 -- (1) if the module is the current module, don't qualify, and (2) if there

 -- is only one exposed package which exports this module, don't qualify.

      | Just home_unit <- mhome_unit

      , isHomeModule home_unit mod = False

      = False

      | otherwise = True

 -- | Creates a function for formatting packages based on two heuristics:

 -- (1) don't qualify if the package in question is "main", and (2) only qualify

     , ue_namever   :: !GhcNameVersion

         -- ^ GHC name/version (used for dynamic library suffix)

     }

 ueEPS :: UnitEnv -> IO ExternalPackageState

 initUnitEnv :: UnitId -> HomeUnitGraph -> GhcNameVersion -> Platform -> IO UnitEnv

 initUnitEnv cur_unit hug namever platform = do

   eps <- initExternalUnitCache

   return $ UnitEnv

     { ue_eps             = eps

     , ue_home_unit_graph = hug

     , ue_current_unit    = cur_unit

     , ue_platform        = platform

     , ue_namever         = namever

     }

 -- | Get home-unit

 import GHC.Unit.Home

 import GHC.Unit.State

 import GHC.Unit.Finder.Types

 import qualified GHC.Data.ShortText as ST

 import Data.Time

 import qualified Data.Map as M

 import GHC.Driver.Env

 import GHC.Driver.Config.Finder

 import qualified Data.Set as Set

 import qualified Data.List.NonEmpty as NE

       dflags    = hsc_dflags hsc_env

       fopts     = initFinderOpts dflags

   in do

 findImportedModuleNoHsc

   :: FinderCache

   -> FinderOpts

   -> UnitEnv

   -> Maybe HomeUnit

   -> ModuleName

   -> PkgQual

   -> IO FindResult

   case mb_pkg of

     NoPkgQual  -> unqual_import

     ThisPkg uid | (homeUnitId <$> mhome_unit) == Just uid -> home_import

       -- If the module is reexported, then look for it as if it was from the perspective

       -- of that package which reexports it.

       | mod_name `Set.member` finder_reexportedModules opts =

       | mod_name `Set.member` finder_hiddenModules opts =

         return (mkHomeHidden uid)

       | otherwise =

     -- first before looking at the packages in order.

     any_home_import = foldr1 orIfNotFound (home_import: map home_pkg_import other_fopts)

     unqual_import = any_home_import

                     `orIfNotFound`

     units     = case mhome_unit of

                   Nothing -> ue_units ue

 -- plugin.  This consults the same set of exposed packages as

 -- 'findImportedModule', unless @-hide-all-plugin-packages@ or

 -- @-plugin-package@ are specified.

   findHomeModule fc fopts home_unit mod_name

   `orIfNotFound`

 -- | Locate a specific 'Module'.  The purpose of this function is to

 -- create a 'ModLocation' for a given 'Module', that is to find out

   let mod = mkModule home_unit mod_name

   modLocationCache fc mod do_this

   findLookupResult fc fopts

   findLookupResult fc fopts

 findLookupResult :: FinderCache -> FinderOpts -> LookupResult -> IO FindResult

 findLookupResult fc fopts r = case r of

 -- (c) The University of Glasgow, 2006

 -- | Unit manipulation

 module GHC.Unit.State (

         closeUnitDeps',

         mayThrowUnitErr,

         -- * Module hole substitution

         ShHoleSubst,

         renameHoleUnit,

 import qualified Data.Set as Set

 import GHC.LanguageExtensions

 import Control.Applicative

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

 -- The Unit state

 -- | Find the UnitId which an import qualified by a package import comes from.

 -- Compared to 'lookupPackageName', this function correctly accounts for visibility,

 -- renaming and thinning.

   -- 1. Find all modules providing the ModuleName (this accounts for visibility/thinning etc)

   -- 2. Get the UnitIds of the candidates

   let candidates_uid = concatMap to_uid $ sortOn fst $ nonDetUniqMapToList providers

   -- 3. Get the package names of the candidates

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

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

 -- 'unitState' in 'DynFlags'.