You can use this to call functions returning an action in the Ghc monad inside an IO action. This is needed for some (too restrictive) callback arguments of some library functions:

libFunc :: String -> (Int -> IO a) -> IO a
ghcFunc :: Int -> Ghc a

ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a
ghcFuncUsingLibFunc str =
  reifyGhc $ \s ->
    libFunc $ \i -> do
      reflectGhc (ghcFunc i) s

data Session #

The Session is a handle to the complete state of a compilation session. A compilation session consists of a set of modules constituting the current program or library, the context for interactive evaluation, and various caches.

Constructors

Session !(IORef HscEnv)

Hsc Monad

getHscEnv :: Hsc HscEnv #

Driver compat

batchMsg :: Messager #

HscEnv Compat

set_hsc_dflags :: DynFlags -> HscEnv -> HscEnv Source #

overPkgDbRef :: (FilePath -> FilePath) -> PackageDBFlag -> PackageDBFlag Source #

guessTarget :: GhcMonad m => String -> a -> Maybe Phase -> m Target Source #

setNoCode :: DynFlags -> DynFlags Source #

getModSummaries :: ModuleGraph -> [ModSummary] Source #

mapOverIncludePaths :: (FilePath -> FilePath) -> DynFlags -> DynFlags Source #

getLogger :: HscEnv -> Logger Source #

AST compat

pattern RealSrcSpan :: RealSrcSpan -> SrcSpan Source #

type LExpression = LHsExpr GhcTc Source #

type LBinding = LHsBind GhcTc Source #

type LPattern = LPat GhcTc Source #

inTypes :: MatchGroup GhcTc LExpression -> [Type] Source #

outType :: MatchGroup GhcTc LExpression -> Type Source #

Exceptions

catch :: (MonadCatch m, Exception e) => m a -> (e -> m a) -> m a Source #

bracket :: MonadMask m => m a -> (a -> m c) -> (a -> m b) -> m b Source #

handle :: (MonadCatch m, Exception e) => (e -> m a) -> m a -> m a Source #

Doc Gap functions

pageMode :: Mode Source #

oneLineMode :: Mode Source #

DynFlags compat

initializePluginsForModSummary :: HscEnv -> ModSummary -> IO (Int, [ModuleName], ModSummary) Source #

setFrontEndHooks :: Maybe (ModSummary -> Hsc FrontendResult) -> HscEnv -> HscEnv Source #

updOptLevel :: Int -> DynFlags -> DynFlags #

Sets the DynFlags to be appropriate to the optimisation level

setWayDynamicIfHostIsDynamic :: DynFlags -> DynFlags Source #

gopt_set :: DynFlags -> GeneralFlag -> DynFlags Source #

parseDynamicFlags :: MonadIO m => Logger -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn]) Source #

Platform constants

hostIsDynamic :: Bool Source #

misc

getModuleName :: (a, b) -> a Source #

getTyThing :: (a, b, c, d, e) -> a Source #

fixInfo :: (a, b, c, d, e) -> (a, b, c, d) Source #

data FrontendResult #

FrontendResult describes the result of running the frontend of a Haskell module. Currently one always gets a FrontendTypecheck, since running the frontend involves typechecking a program. hs-sig merges are not handled here.

This data type really should be in GHC.Driver.Env, but it needs to have a TcGblEnv which is only defined here.

Constructors

FrontendTypecheck TcGblEnv

data Hsc a #

The Hsc monad: Passing an environment and warning state

Instances

Instances details

MonadIO Hsc
Instance details Defined in GHC.Driver.Env.Types Methods liftIO :: IO a -> Hsc a #
Applicative Hsc
Instance details Defined in GHC.Driver.Env.Types Methods pure :: a -> Hsc a # (<>) :: Hsc (a -> b) -> Hsc a -> Hsc b # liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c # (>) :: Hsc a -> Hsc b -> Hsc b # (<*) :: Hsc a -> Hsc b -> Hsc a #
Functor Hsc
Instance details Defined in GHC.Driver.Env.Types Methods fmap :: (a -> b) -> Hsc a -> Hsc b # (<$) :: a -> Hsc b -> Hsc a #
Monad Hsc
Instance details Defined in GHC.Driver.Env.Types Methods (>>=) :: Hsc a -> (a -> Hsc b) -> Hsc b # (>>) :: Hsc a -> Hsc b -> Hsc b # return :: a -> Hsc a #
HasDynFlags Hsc
Instance details Defined in GHC.Driver.Env.Types Methods getDynFlags :: Hsc DynFlags #
HasLogger Hsc
Instance details Defined in GHC.Driver.Env.Types Methods getLogger :: Hsc Logger #

mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph #

Map a function f over all the ModSummaries. To preserve invariants f can't change the isBoot status.

mgModSummaries :: ModuleGraph -> [ModSummary] #

unsetLogAction :: GhcMonad m => m () Source #

load' :: GhcMonad m => a -> LoadHowMuch -> Maybe Messager -> ModuleGraph -> m SuccessFlag Source #

homeUnitId_ :: DynFlags -> UnitId #

Target home unit-id

getDynFlags :: HasDynFlags m => m DynFlags #