ghcide-2.5.0.0: The core of an IDE
Safe HaskellSafe-Inferred
LanguageHaskell2010

Development.IDE.GHC.Compat.Env

Description

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

Synopsis

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.

hsc_HPT :: HscEnv -> HomePackageTable #

The home package table describes already-compiled home-package modules, excluding the module we are compiling right now. (In one-shot mode the current module is the only home-package module, so hsc_HPT is empty. All other modules count as "external-package" modules. However, even in GHCi mode, hi-boot interfaces are demand-loaded into the external-package table.)

hsc_HPT is not mutable because we only demand-load external packages; the home package is eagerly loaded, module by module, by the compilation manager.

The HPT may contain modules compiled earlier by --make but not actually below the current module in the dependency graph.

(This changes a previous invariant: changed Jan 05.)

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

    virtual CWD of the program

  • ic_plugins :: ![LoadedPlugin]

    Cache of loaded plugins. We store them here to avoid having to load them everytime we switch to the interctive context.

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

Set the DynFlags used to evaluate interactive expressions. Also initialise (load) plugins.

Note: this cannot be used for changes to packages. Use setSessionDynFlags, or setProgramDynFlags and then copy the unitState 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_tmpfs :: HscEnv -> TmpFs #

Temporary files

hsc_unit_env :: HscEnv -> UnitEnv #

Unit environment (unit state, home unit, etc.).

Initialized from the databases cached in hsc_unit_dbs and from the DynFlags.

hsc_hooks :: HscEnv -> Hooks #

Hooks

data TmpFs #

Temporary file-system

HomeUnit

mkHomeModule :: HomeUnit -> ModuleName -> Module #

Make a module in home unit

Provide backwards Compatible

data Logger #

data UnitEnv #

Home Unit

homeUnitId_ :: DynFlags -> UnitId #

Target home unit-id

DynFlags Helper

setBytecodeLinkerOptions :: DynFlags -> DynFlags Source #

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

safeImportsOn :: DynFlags -> Bool #

Test if Safe Imports are on in some form

Ways

type Ways = Set Way #

data Way #

A way

Don't change the constructor order as it us used by waysTag to create a unique tag (e.g. thr_debug_p) which is expected by other tools (e.g. Cabal).

Instances

Instances details
Show Way 
Instance details

Defined in GHC.Platform.Ways

Methods

showsPrec :: Int -> Way -> ShowS #

show :: Way -> String #

showList :: [Way] -> ShowS #

Eq Way 
Instance details

Defined in GHC.Platform.Ways

Methods

(==) :: Way -> Way -> Bool #

(/=) :: Way -> Way -> Bool #

Ord Way 
Instance details

Defined in GHC.Platform.Ways

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 #

hostFullWays :: Ways #

Host "full" ways (i.e. ways that have an impact on the compilation, not RTS only ways).

These ways must be used when compiling codes targeting the internal interpreter.

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

Turn these flags on when enabling this way

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

Turn these flags off when enabling this way

Backend, backwards compatible

data Backend #

Code generation backends.

GHC supports several code generation backends serving different purposes (producing machine code, producing ByteCode for the interpreter) and supporting different platforms.

Instances

Instances details
Read Backend 
Instance details

Defined in GHC.Driver.Backend

Show Backend 
Instance details

Defined in GHC.Driver.Backend

Eq Backend 
Instance details

Defined in GHC.Driver.Backend

Methods

(==) :: Backend -> Backend -> Bool #

(/=) :: Backend -> Backend -> Bool #

Ord Backend 
Instance details

Defined in GHC.Driver.Backend