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 = HUG.allUnits (ue_home_unit_graph old_unit_env)

           updated_dflags <- liftIO $ updatePlatformConstants dflags0 mconstants

           pure HomeUnitEnv

               , ue_current_unit    = ue_currentUnit old_unit_env

               , ue_module_graph    = ue_module_graph old_unit_env

               , ue_eps             = ue_eps old_unit_env

               }

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

     else modifySession (hscSetFlags dflags0)

             , ue_current_unit    = ue_currentUnit unit_env0

             , ue_eps             = ue_eps unit_env0

             , ue_module_graph    = ue_module_graph 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

    parens (text (expectJust (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 dflags = hsc_dflags hsc_env

       let sec    = initSourceErrorContext dflags

       let fopts  = initFinderOpts dflags

       case res of

         Found _ m -> return m

         err       -> throwOneError sec $ noModError hsc_env noSrcSpan mod_name err

       let dflags = hsc_dflags hsc_env

       let sec    = initSourceErrorContext dflags

       let fopts  = initFinderOpts dflags

       case res of

         Found _ m -> return [m]

         err       -> throwOneError sec $ noModError hsc_env noSrcSpan mod_name err

                                 , mg_loc     = loc

                                 , mg_rdr_env = rdr_env })

   = do { hpt_rule_base <- home_pkg_rules

        ; let builtin_passes = getCoreToDo dflags hpt_rule_base extra_vars

              uniq_tag = SimplTag

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

                                     name_ppr_ctx loc $

     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

   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

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

           , ue_eps       = ue_eps old_unit_env

           , ue_module_graph = ue_module_graph old_unit_env

           }

     setSession $ hscSetFlags dflags $ hsc_env { hsc_unit_env = unit_env }

     hi_timestamp <- liftIO $ modificationTimeIfExists (ml_hi_file_ospath location)

     hie_timestamp <- liftIO $ modificationTimeIfExists (ml_hie_file_ospath location)

     -- Also copied from 'getImports'

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

         implicit_prelude = xopt LangExt.ImplicitPrelude dflags

         generated_imports = mkPrelImports modname implicit_prelude imps

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

     extra_sig_imports <- liftIO $ findExtraSigImports hsc_env hsc_src modname

   where

  --

     -- A simple edge to a module from the same home unit

     mkEdge (IIModule n) =

       let

       let lvl = convImportLevel (ideclLevelSpec i)

           wanted_mod = unLoc (ideclName i)

           is_boot = ideclSource i

           unitId = homeUnitId $ hsc_home_unit hsc_env

 loopFromInteractive :: HscEnv

                     -> M.Map NodeKey ModuleGraphNode

                     -> IO ([ModuleNodeEdge],M.Map NodeKey ModuleGraphNode)

 loopFromInteractive _ [] cached_nodes = return ([], cached_nodes)

     Left edge -> do

         (edges, cached_nodes') <- loopFromInteractive hsc_env edges cached_nodes

         return (edge : edges, cached_nodes')

       let home_unit = ue_unitHomeUnit unitId (hsc_unit_env hsc_env)

       let k _ loc mod =

             let key = moduleToMnk mod is_boot

             in return $ FoundHome (ModuleNodeFixed key loc)

       case found of

         -- Case 1: Home modules have to already be in the cache.

         FoundHome (ModuleNodeFixed mod _) -> do

               sec = initSourceErrorContext pi_local_dflags

           mimps <- getImports popts sec imp_prelude pi_hspp_buf pi_hspp_fn src_fn

           return (first (mkMessages . fmap mkDriverPsHeaderMessage . getMessages) mimps)

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

   let pi_srcimps = pi_srcimps'

   let pi_theimps = rn_imps pi_theimps'

    , hsc_home_unit

    , hsc_home_unit_maybe

    , hsc_units

    , hsc_HPT

    , hsc_HUE

    , hsc_HUG

 hsc_units :: HasDebugCallStack => HscEnv -> UnitState

 hsc_units = ue_homeUnitState . 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

     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

         used_args = Set.fromList (map unitId loadedPackages)

   -- gather the imports and module name

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

     buf <- hGetStringBuffer input_fn

     let imp_prelude = xopt LangExt.ImplicitPrelude dflags

         popts = initParserOpts dflags

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

         sec = initSourceErrorContext dflags

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

 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

 modInfoModBreaks :: ModuleInfo -> Maybe InternalModBreaks

 modInfoModBreaks = minf_modBreaks

   (initial_home_graph, mainUnitId) <- liftIO $ createUnitEnvFromFlags unitDflags

   let home_units = HUG.allUnits initial_home_graph

   home_unit_graph <- forM initial_home_graph $ \homeUnitEnv -> do

     let cached_unit_dbs = homeUnitEnv_unit_dbs homeUnitEnv

         hue_flags = homeUnitEnv_dflags homeUnitEnv

         dflags = homeUnitEnv_dflags homeUnitEnv

     updated_dflags <- liftIO $ updatePlatformConstants dflags mconstants

     emptyHpt <- liftIO $ emptyHomePackageTable

   let activeUnit = fst $ NE.head unitEnvList

   return (HUG.hugFromList (NE.toList unitEnvList), activeUnit)

   = 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

              -- in allocations by ~5% if we don't do this.

            traverse (lookupCompleteMatch type_env hsc_env) =<<

              localAndImportedCompleteMatches tcg_comp_env eps

                            msg_var cc_st_var statics_var

                            next_wrapper_num_var ds_complete_matches

        }

        ; msg_var          <- newIORef emptyMessages

        ; statics_var      <- newIORef nilOL

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

        ; ds_complete_matches <- traverse (lookupCompleteMatch type_env hsc_env) =<<

             localAndImportedCompleteMatches local_complete_matches eps

        ; let

                               fam_inst_env ptc msg_var cc_st_var statics_var

                               next_wrapper_num ds_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 (OrdList (Id,CoreExpr))

          -> IORef (ModuleEnv Int) -> DsCompleteMatches

          -> (DsGblEnv, DsLclEnv)

          statics_var 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

         getMinimalImports,

         printMinimalImports,

         renamePkgQual, renameRawPkgQual,

         classifyGREs,

         ImportDeclUsage

     ) where

     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 unit_state

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

 -- interface, but without 'imp_mods'.

 checkConName :: RdrName -> TcRn ()

 checkConName name

   = checkErr (isRdrDataCon name || isRdrTc name) (TcRnIllegalDataCon name)

 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

         ; 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

                                                  , let local_gres = filter isLocalGRE gres

                                                  , not (null local_gres) ]) ]

               pure $ mi_module iface : dep_orphs (mi_deps iface)

              getOrphansForModule m = do

               iface <- loadModuleInterface (text "runTcInteractive") m

               pure $ mi_module iface : dep_orphs (mi_deps iface)

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

             case i of                   -- force above: see #15111

                 IIModule n -> getOrphansForModule n

        ; (home_insts, home_fam_insts) <- liftIO $ UnitEnv.hugAllInstances (hsc_unit_env hsc_env)

   = do { ptc <- initPromotionTickContext <$> getDynFlags

        ; rdr_env <- getGlobalRdrEnv

        ; hsc_env <- getTopEnv

 -- | Like logInfoTcRn, but for user consumption

 printForUserTcRn :: SDoc -> TcRn ()

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

   unit_state = ue_homeUnitState unit_env

 mkQualName :: Outputable info => GlobalRdrEnvX info -> QueryQualifyName

 mkQualName env = qual_name 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.

      | [(_, pkgconfig)] <- lookup,

        mkUnit pkgconfig == moduleUnit mod

      = 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

     }

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

       dflags    = hsc_dflags hsc_env

       fopts     = initFinderOpts dflags

   in do

 findImportedModuleWithIsBoot :: HscEnv -> ModuleName -> IsBootInterface -> PkgQual -> IO FindResult

 findImportedModuleWithIsBoot hsc_env mod is_boot pkg_qual = do

   :: 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.

       | Just real_mod_name <- lookupUniqMap (finder_reexportedModules opts) mod_name =

       | elementOfUniqSet mod_name (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_homeUnitState 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`