getBindings, getInsts, getNamePprCtx,

         findModule, lookupModule,

         findQualifiedModule, lookupQualifiedModule,

         renamePkgQualM, renameRawPkgQualM,

         isModuleTrusted, moduleTrustReqs,

         getNamesInScope,

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

     _not_a_home_module -> return Nothing

 -- TODO: this is incorrect, what if we have mulitple 'ModuleName's in our HPTs?

 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

   -- TODO: definitely wrong.

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

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

             case i of                   -- force above: see #15111

                 IIDecl i   -> getOrphans (unLoc (ideclName i))

                                          (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

     Just hue -> lookupHpt (homeUnitEnv_hpt hue) mod

 -- TODO: this should not be merged, where else could we try to search for modules?

   where

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

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

    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

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

       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"