getProgramDynFlags, setProgramDynFlags,

         updateProgramDynFlags,

         getInteractiveDynFlags, setInteractiveDynFlags,

         interpretPackageEnv,

         -- * Logging

         getBindings, getInsts, getNamePprCtx,

         findModule, lookupModule,

         findQualifiedModule, lookupQualifiedModule,

         renamePkgQualM, renameRawPkgQualM,

         isModuleTrusted, moduleTrustReqs,

         getNamesInScope,

 setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()

 setInteractiveDynFlags dflags = do

   logger <- getLogger

 -- | Get the 'DynFlags' used to evaluate interactive expressions.

 getInteractiveDynFlags :: GhcMonad m => m DynFlags

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

 -- | Checks the set of new DynFlags for possibly erroneous option

 -- combinations when invoking 'setSessionDynFlags' and friends, and if

 -- found, returns a fixed copy (if possible).

 -- TODO: this function should likely be deleted.

 isLoaded :: GhcMonad m => ModuleName -> m Bool

 isLoaded m = withSession $ \hsc_env -> liftIO $ do

 isLoadedModule :: GhcMonad m => UnitId -> ModuleName -> m Bool

 isLoadedModule uid m = withSession $ \hsc_env -> liftIO $ do

     Just mod_info      -> return (Just (mi_module (hm_iface mod_info)))

     _not_a_home_module -> return Nothing

 lookupLoadedHomeModuleByModuleName mod_name = withSession $ \hsc_env -> liftIO $ do

   trace_if (hsc_logger hsc_env) (text "lookupLoadedHomeModuleByModuleName" <+> ppr mod_name)

   home <- lookupLoadedHomeModuleByModuleName mod_name

   case home of

     Just m  -> return m

     Nothing -> liftIO $ do

       let fopts  = initFinderOpts dflags

       res <- findExposedPackageModule fc fopts units mod_name NoPkgQual

       case res of

         err       -> throwOneError $ noModError hsc_env noSrcSpan mod_name err

 -- | Check that a module is safe to import (according to Safe Haskell).

 --

   pick_interactive :: InteractiveImport -> Bool

   pick_interactive (IIDecl d)   | mod_name == Just (unLoc (ideclName d)) = True

                                 | mod_name == fmap unLoc (ideclAs d) = True

   pick_interactive _ = False

   -- We want to keep only one for each original module; preferably one with an

       -- ^ Bring the exports of a particular module

       -- (filtered by an import decl) into scope

       -- ^ Bring into scope the entire top-level envt of

       -- of this module, including the things imported

       -- into it.

     idecls :: [LImportDecl GhcPs]

     idecls = [noLocA d | IIDecl d <- imports]

     imods = [m | IIModule m <- imports]

       mkTopLevEnv hsc_env mod >>= \case

         Right env -> pure $ Right env

 mkTopLevEnv :: HscEnv -> Module -> IO (Either String GlobalRdrEnv)

 import GHC.Types.Annotations

 import GHC.Types.SrcLoc

 import GHC.Types.SourceFile

 import qualified GHC.LanguageExtensions as LangExt

 import GHC.Unit.Env as UnitEnv

                                                  , let local_gres = filter isLocalGRE gres

                                                  , not (null local_gres) ]) ]

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

             case i of                   -- force above: see #15111

                                          (renameRawPkgQual (hsc_unit_env hsc_env) (unLoc $ ideclName i) (ideclPkgQual i))

   , lookupHug

   , lookupHugByModule

   , lookupHugUnit

   , memberHugHomeModule

   , memberHugHomeInstalledModule

 import GHC.Types.Annotations

 import GHC.Types.CompleteMatch

 import GHC.Core.InstEnv

 -- | Get all 'CompleteMatches' (arising from COMPLETE pragmas) present across

     Nothing -> pure Nothing

     Just hue -> lookupHpt (homeUnitEnv_hpt hue) mod

   where

 -- | Lookup the 'HomeModInfo' of a 'Module' in the 'HomeUnitGraph' (via the 'HomePackageTable' of the corresponding unit)

 lookupHugByModule :: Module -> HomeUnitGraph -> IO (Maybe HomeModInfo)

 lookupHugUnit :: UnitId -> HomeUnitGraph -> Maybe HomeUnitEnv

 lookupHugUnit = unitEnv_lookup_maybe

 memberHugHomeModule :: Module -> HomeUnitGraph -> Bool

 memberHugHomeModule mod =

   memberHugHomeInstalledModule (fmap toUnitId mod)

 memberHugHomeInstalledModule :: InstalledModule -> HomeUnitGraph -> Bool

 memberHugHomeInstalledModule mod hug =

   case unitEnv_lookup_maybe (moduleUnit mod) hug of

    hsc_env <- GHC.getSession

    let !in_multi = length (hsc_all_home_unit_ids hsc_env) > 3

         -- We force this to make sure we don't retain the hsc_env when reloading

         -- TODO: if everything goes well, this check should be deleted once

         -- this PR has lifted the multiple home unit restrictions

    empty_cache <- liftIO newIfaceCache

                       | otherwise           = unLoc (ideclName d)

         modules_names =

              [moduleNameString (myIdeclName d) | IIDecl d <- rev_imports]

         line = 1 + line_number st

     setDumpFilePrefix :: GHC.GhcMonad m => InteractiveContext -> m () -- #17500

     setDumpFilePrefix ic = do

         dflags <- GHC.getInteractiveDynFlags

         GHC.setInteractiveDynFlags dflags { dumpPrefix = modStr ++ "." }

       where

 addModule files = do

   revertCAFs -- always revert CAFs on load/add.

   files' <- mapM expandPath files

   targets' <- filterM checkTarget targets

   -- remove old targets with the same id; e.g. for :add *M

   mapM_ GHC.removeTarget [ tid | Target { targetId = tid } <- targets' ]

 unAddModule :: GhciMonad m => [FilePath] -> m ()

 unAddModule files = do

   files' <- mapM expandPath files

   let removals = [ tid | Target { targetId = tid } <- targets ]

   mapM_ GHC.removeTarget removals

   _ <- doLoadAndCollectInfo (Unadd $ length removals) LoadAllTargets

               -- We import the module with a * iff

               --   - it is interpreted, and

               --   - -XSafe is off (it doesn't allow *-imports)

                     | otherwise = [mkIIDecl   (GHC.moduleName m)]

         setContextKeepingPackageModules keep_ctxt new_ctx

   imports <- GHC.getContext

   case imports of

     [] -> throwGhcException $ CmdLineError (':' : cmd ++ ": no current module")

     IIDecl d : _ -> do

       pkgqual <- GHC.renameRawPkgQualM (unLoc $ ideclName d) (ideclPkgQual d)

       GHC.findQualifiedModule pkgqual (unLoc (ideclName d))

 addModulesToContext_ :: GhciMonad m => [ModuleName] -> [ModuleName] -> m ()

 addModulesToContext_ starred unstarred = do

 remModulesFromContext :: GhciMonad m => [ModuleName] -> [ModuleName] -> m ()

 remModulesFromContext  starred unstarred = do

   dflags <- getDynFlags

   let safe = safeLanguageOn dflags

   case ii of

        | safe -> throwGhcException $ CmdLineError "can't use * imports with Safe Haskell"

     IIDecl d -> do

        let modname = unLoc (ideclName d)

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

 -- Utils on InteractiveImport

 mkIIModule = IIModule

 mkIIDecl :: ModuleName -> InteractiveImport

 mkIIDecl = IIDecl . simpleImportDecl

 iiModules is = [m | IIModule m <- is]

 isIIModule :: InteractiveImport -> Bool

 isIIModule _ = False

 iiModuleName :: InteractiveImport -> ModuleName

 iiModuleName (IIDecl d)   = unLoc (ideclName d)

 preludeModuleName :: ModuleName

             let oldFlags = HUG.homeUnitEnv_dflags homeUnitEnv

             -- TODO: perhaps write custom version of parseDynamicFlagsCmdLine which gives us more control over the errors and warnings

             (newFlags, _, _) <- DynFlags.parseDynamicFlagsCmdLine logger oldFlags lopts

             pure (uid, oldFlags, newFlags')

           must_reload <- GHC.updateProgramDynFlags True updates

           -- update and check interactive dynflags

           -- TODO: document the relation ship between the interactive unit and in the interactive context

           icdflags <- hsc_dflags <$> GHC.getSession

           -- if the package flags changed, reset the context and link

           -- the new packages.

           hsc_env <- GHC.getSession

           let dflags2 = hsc_dflags hsc_env

           when must_reload $ do

             when (verbosity dflags2 > 0) $

               liftIO . putStrLn $

             -- Clear caches and eventually defined breakpoints. (#1620)

             clearCaches

       idflags <- hsc_dflags <$> GHC.getSession

       installInteractivePrint (interactivePrint idflags) False

       return ()

 unknownFlagsErr :: GhciMonad m => [String] -> m ()

 unknownFlagsErr fs = mapM_ (\f -> reportError (GhciUnknownFlag f (suggestions f))) fs

       trans_ctx = transient_ctx st

       show_one (IIModule star_m)

       show_one (IIDecl imp) = showPpr dflags imp

   prel_iidecls <- getImplicitPreludeImports (rem_ctx ++ trans_ctx)

         filterM GHC.moduleIsInterpreted hmods

     -- Return all possible bids for a given Module

     bidsByModule nonquals mod = do

       (_, decls) <- getModBreak mod

       let bids = nub $ declPath <$> elems decls

               True  -> bids

               False -> (combineModIdent (showModule mod)) <$> bids

    | all isDigit arg1 = do

         imports <- GHC.getContext

         case iiModules imports of

               breakByModuleLine md (read arg1) rest

            [] -> do

               liftIO $ putStrLn "No modules are loaded with debugging support."

     case iiModules imports of

         [] -> liftIO $ putStrLn "No module to list"

         (mn : _) -> do

 list2 [arg1,arg2] | looksLikeModuleName arg1, all isDigit arg2 = do

         md <- wantInterpretedModule arg1

         listModuleLine md (read arg2)

 lookupModuleName mName = lookupQualifiedModuleName NoPkgQual mName

 lookupQualifiedModuleName :: GHC.GhcMonad m => PkgQual -> ModuleName -> m Module

 isMainUnitModule :: Module -> Bool

 isMainUnitModule m = GHC.moduleUnit m == mainUnit

 wantInterpretedModuleName :: GHC.GhcMonad m => ModuleName -> m Module

 wantInterpretedModuleName modname = do

 wantNameFromInterpretedModule :: GHC.GhcMonad m

                               => (Name -> SDoc -> m ())

                  GHC.liftIO $ putStrLn ("Load " ++ showSuccessFlag res)

                  --

                  m <- GHC.findModule (GHC.mkModuleName mn) Nothing

     where showSuccessFlag GHC.Succeeded = "succeeded"

           showSuccessFlag GHC.Failed    = "failed"

 A.hs:5:1: warning: [GHC-62161] [-Wincomplete-patterns (in -Wextra)]

     Pattern match(es) are non-exhaustive

     In an equation for ‘incompletePattern’:

     Variable not in scope: variableNotInScope :: ()

 Failed, two modules loaded.

 C.hs:6:7: error: [GHC-88464]

     Variable not in scope: variableNotInScope :: ()

 Ok, one module loaded.

 Ok, one module reloaded.

 Ok, unloaded all modules.

 Ok, no modules to be reloaded.

 Ok, one module loaded.

 Ok, one module added.

 Ok, two modules reloaded.

 Ok, two modules loaded.

 Ok, one module unadded.

 Ok, two modules loaded.

 Ok, three modules reloaded.

 True

 Ok, one module loaded.

 this

 Ok, one module reloaded.

 that

 Ok, one module loaded.

 Ok, one module loaded.

 ghci> Leaving GHCi.

 Ok, two modules loaded.

 Failed, one module reloaded.

 Ok, two modules reloaded.

 Ok, three modules loaded.

 Ok, three modules reloaded.

 Ok, one module loaded.

 Ok, one module reloaded.

 Ok, one module loaded.

 Ok, one module reloaded.

 Ok, three modules loaded.

 Ok, three modules reloaded.

 Ok, three modules loaded.

 Ok, two modules loaded.

 Ok, two modules loaded.

 Breakpoint 0 activated at T8042A.hs:1:44-56

 Ok, two modules loaded.

 "I should be printed twice"

 Leaving GHCi.