Safe Haskell	None
Language	Haskell2010

Development.IDE.GHC.Compat.Env

Contents

HomeUnit
Provide backwards Compatible
Home Unit
DynFlags Helper
Ways
Backend, backwards compatible

Description

Compat module for the main Driver types, such as HscEnv, UnitEnv and some DynFlags compat functions.

Synopsis

data HscEnv
data InteractiveContext = InteractiveContext {
- ic_dflags :: DynFlags
- ic_mod_index :: Int
- ic_imports :: [InteractiveImport]
- ic_tythings :: [TyThing]
- ic_rn_gbl_env :: GlobalRdrEnv
- ic_instances :: ([ClsInst], [FamInst])
- ic_fix_env :: FixityEnv
- ic_default :: Maybe [Type]
- ic_resume :: [Resume]
- ic_monad :: Name
- ic_int_print :: Name
- ic_cwd :: Maybe FilePath
}
setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext
setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()
hsc_dflags :: HscEnv -> DynFlags
hsc_EPS :: HscEnv -> IORef ExternalPackageState
hsc_logger :: HscEnv -> Logger
hsc_tmpfs :: HscEnv -> TmpFs
hsc_unit_env :: HscEnv -> UnitEnv
hsc_hooks :: HscEnv -> Hooks
hscSetHooks :: Hooks -> HscEnv -> HscEnv
type TmpFs = ()
hscHomeUnit :: HscEnv -> HomeUnit
type HomeUnit = UnitId
setHomeUnitId_ :: UnitId -> DynFlags -> DynFlags
mkHomeModule :: HomeUnit -> ModuleName -> Module
newtype Logger = Logger {
- log_action :: LogAction
}
type UnitEnv = ()
hscSetUnitEnv :: UnitEnv -> HscEnv -> HscEnv
hscSetFlags :: DynFlags -> HscEnv -> HscEnv
initTempFs :: HscEnv -> IO HscEnv
homeUnitId_ :: DynFlags -> UnitId
setBytecodeLinkerOptions :: DynFlags -> DynFlags
setInterpreterLinkerOptions :: DynFlags -> DynFlags
safeImportsOn :: DynFlags -> Bool
type Ways = [Way]
data Way
hostFullWays :: Ways
setWays :: Ways -> DynFlags -> DynFlags
wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]
type Backend = HscTarget
setBackend :: Backend -> DynFlags -> DynFlags
platformDefaultBackend :: DynFlags -> Backend

Documentation

data HscEnv #

HscEnv is like Session, except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. It's also used to store the dynamic linker state to allow for multiple linkers in the same address space. Things like the module graph don't change during a single compilation.

Historical note: "hsc" used to be the name of the compiler binary, when there was a separate driver and compiler. To compile a single module, the driver would invoke hsc on the source code... so nowadays we think of hsc as the layer of the compiler that deals with compiling a single module.

data InteractiveContext #

Interactive context, recording information about the state of the context in which statements are executed in a GHCi session.

Constructors

InteractiveContext

Fields

ic_dflags :: DynFlags
The DynFlags used to evaluate interative expressions and statements.
ic_mod_index :: Int
Each GHCi stmt or declaration brings some new things into scope. We give them names like interactive:Ghci9.T, where the ic_index is the '9'. The ic_mod_index is incremented whenever we add something to ic_tythings See Note [The interactive package]
ic_imports :: [InteractiveImport]
The GHCi top-level scope (ic_rn_gbl_env) is extended with these imports
This field is only stored here so that the client can retrieve it with GHC.getContext. GHC itself doesn't use it, but does reset it to empty sometimes (such as before a GHC.load). The context is set with GHC.setContext.
ic_tythings :: [TyThing]
TyThings defined by the user, in reverse order of definition (ie most recent at the front) See Note [ic_tythings]
ic_rn_gbl_env :: GlobalRdrEnv
The cached GlobalRdrEnv, built by setContext and updated regularly It contains everything in scope at the command line, including everything in ic_tythings
ic_instances :: ([ClsInst], [FamInst])
All instances and family instances created during this session. These are grabbed en masse after each update to be sure that proper overlapping is retained. That is, rather than re-check the overlapping each time we update the context, we just take the results from the instance code that already does that.
ic_fix_env :: FixityEnv
Fixities declared in let statements
ic_default :: Maybe [Type]
The current default types, set by a 'default' declaration
ic_resume :: [Resume]
The stack of breakpoint contexts
ic_monad :: Name
The monad that GHCi is executing in
ic_int_print :: Name
The function that is used for printing results of expressions in ghci and -e mode.
ic_cwd :: Maybe FilePath

setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext #

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

Set the DynFlags used to evaluate interactive expressions. Note: this cannot be used for changes to packages. Use setSessionDynFlags, or setProgramDynFlags and then copy the pkgState into the interactive DynFlags.

hsc_dflags :: HscEnv -> DynFlags #

The dynamic flag settings

hsc_EPS :: HscEnv -> IORef ExternalPackageState #

Information about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.

hsc_logger :: HscEnv -> Logger Source #

hsc_tmpfs :: HscEnv -> TmpFs Source #

hsc_unit_env :: HscEnv -> UnitEnv Source #

hsc_hooks :: HscEnv -> Hooks Source #

hscSetHooks :: Hooks -> HscEnv -> HscEnv Source #

type TmpFs = () Source #

HomeUnit

hscHomeUnit :: HscEnv -> HomeUnit Source #

type HomeUnit = UnitId Source #

setHomeUnitId_ :: UnitId -> DynFlags -> DynFlags Source #

mkHomeModule :: HomeUnit -> ModuleName -> Module Source #

Provide backwards Compatible

newtype Logger Source #

Constructors

Logger
Fields log_action :: LogAction

type UnitEnv = () Source #

hscSetUnitEnv :: UnitEnv -> HscEnv -> HscEnv Source #

hscSetFlags :: DynFlags -> HscEnv -> HscEnv Source #

initTempFs :: HscEnv -> IO HscEnv Source #

Home Unit

homeUnitId_ :: DynFlags -> UnitId Source #

DynFlags Helper

setBytecodeLinkerOptions :: DynFlags -> DynFlags Source #

We don't want to generate object code so we compile to bytecode (HscInterpreted) which implies LinkInMemory HscInterpreted

setInterpreterLinkerOptions :: DynFlags -> DynFlags Source #

safeImportsOn :: DynFlags -> Bool Source #

Ways

type Ways = [Way] Source #

data Way #

Instances

Instances details

Eq Way
Instance details Defined in DynFlags Methods (==) :: Way -> Way -> Bool # (/=) :: Way -> Way -> Bool #
Ord Way
Instance details Defined in DynFlags Methods compare :: Way -> Way -> Ordering # (<) :: Way -> Way -> Bool # (<=) :: Way -> Way -> Bool # (>) :: Way -> Way -> Bool # (>=) :: Way -> Way -> Bool # max :: Way -> Way -> Way # min :: Way -> Way -> Way #
Show Way
Instance details Defined in DynFlags Methods showsPrec :: Int -> Way -> ShowS # show :: Way -> String # showList :: [Way] -> ShowS #

hostFullWays :: Ways Source #

setWays :: Ways -> DynFlags -> DynFlags Source #

wayGeneralFlags :: Platform -> Way -> [GeneralFlag] #

wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag] #

Backend, backwards compatible

type Backend = HscTarget Source #

setBackend :: Backend -> DynFlags -> DynFlags Source #

platformDefaultBackend :: DynFlags -> Backend Source #