ghc-8.4.4: The GHC API

Safe HaskellNone




Types for the per-module compiler


compilation state

data HscEnv Source #

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--. 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_dflags :: DynFlags

    The dynamic flag settings

  • hsc_targets :: [Target]

    The targets (or roots) of the current session

  • hsc_mod_graph :: ModuleGraph

    The module graph of the current session

  • hsc_IC :: InteractiveContext

    The context for evaluating interactive statements

  • hsc_HPT :: 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.)

  • hsc_EPS :: !(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_NC :: !(IORef NameCache)

    As with hsc_EPS, this is side-effected by compiling to reflect sucking in interface files. They cache the state of external interface files, in effect.

  • hsc_FC :: !(IORef FinderCache)

    The cached result of performing finding in the file system

  • hsc_type_env_var :: Maybe (Module, IORef TypeEnv)

    Used for one-shot compilation only, to initialise the IfGblEnv. See tcg_type_env_var for TcGblEnv. See also Note [hsc_type_env_var hack]

  • hsc_iserv :: MVar (Maybe IServ)

    interactive server process. Created the first time it is needed.

hscEPS :: HscEnv -> IO ExternalPackageState Source #

Retrieve the ExternalPackageState cache.

type FinderCache = InstalledModuleEnv InstalledFindResult Source #

The FinderCache maps modules to the result of searching for that module. It records the results of searching for modules along the search path. On :load, we flush the entire contents of this cache.

data FindResult Source #

The result of searching for an imported module.

NB: FindResult manages both user source-import lookups (which can result in Module) as well as direct imports for interfaces (which always result in InstalledModule).


Found ModLocation Module

The module was found

NoPackage UnitId

The requested package was not found

FoundMultiple [(Module, ModuleOrigin)]

_Error_: both in multiple packages


Not found

data Target Source #

A compilation target.

A target may be supplied with the actual text of the module. If so, use this instead of the file contents (this is for use in an IDE where the file hasn't been saved by the user yet).




Outputable Target # 
Instance details

Defined in HscTypes

data TargetId Source #


TargetModule ModuleName

A module name: search for the file

TargetFile FilePath (Maybe Phase)

A filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename.

Eq TargetId # 
Instance details

Defined in HscTypes

Outputable TargetId # 
Instance details

Defined in HscTypes

data HscStatus Source #

Status of a compilation to hard-code


data ModuleGraph Source #

A ModuleGraph contains all the nodes from the home package (only). There will be a node for each source module, plus a node for each hi-boot module.

The graph is not necessarily stored in topologically-sorted order. Use topSortModuleGraph and flattenSCC to achieve this.

extendMG :: ModuleGraph -> ModSummary -> ModuleGraph Source #

Add a ModSummary to ModuleGraph. Assumes that the new ModSummary is not an element of the ModuleGraph.

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

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

mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary Source #

Look up a ModSummary in the ModuleGraph

needsTemplateHaskellOrQQ :: ModuleGraph -> Bool Source #

Determines whether a set of modules requires Template Haskell or Quasi Quotes

Note that if the session's DynFlags enabled Template Haskell when depanal was called, then each module in the returned module graph will have Template Haskell enabled whether it is actually needed or not.

Hsc monad

newtype Hsc a Source #


Hsc (HscEnv -> WarningMessages -> IO (a, WarningMessages)) 
Monad Hsc # 
Instance details

Defined in HscTypes


(>>=) :: Hsc a -> (a -> Hsc b) -> Hsc b Source #

(>>) :: Hsc a -> Hsc b -> Hsc b Source #

return :: a -> Hsc a Source #

fail :: String -> Hsc a Source #

Functor Hsc # 
Instance details

Defined in HscTypes


fmap :: (a -> b) -> Hsc a -> Hsc b Source #

(<$) :: a -> Hsc b -> Hsc a Source #

Applicative Hsc # 
Instance details

Defined in HscTypes


pure :: a -> Hsc a Source #

(<*>) :: Hsc (a -> b) -> Hsc a -> Hsc b Source #

liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c Source #

(*>) :: Hsc a -> Hsc b -> Hsc b Source #

(<*) :: Hsc a -> Hsc b -> Hsc a Source #

MonadIO Hsc # 
Instance details

Defined in HscTypes


liftIO :: IO a -> Hsc a Source #

HasDynFlags Hsc # 
Instance details

Defined in HscTypes

runHsc :: HscEnv -> Hsc a -> IO a Source #

Information about modules

data ModDetails Source #

The ModDetails is essentially a cache for information in the ModIface for home modules only. Information relating to packages will be loaded into global environments in ExternalPackageState.




emptyModDetails :: ModDetails Source #

Constructs an empty ModDetails

data ModGuts Source #

A ModGuts is carried through the compiler, accumulating stuff as it goes There is only one ModGuts at any time, the one for the module being compiled right now. Once it is compiled, a ModIface and ModDetails are extracted and the ModGuts is discarded.




data CgGuts Source #

A restricted form of ModGuts for code generation purposes




data ForeignStubs Source #

Foreign export stubs



We don't have any stubs

ForeignStubs SDoc SDoc

There are some stubs. Parameters:

1) Header file prototypes for "foreign exported" functions

2) C stubs to use when calling "foreign exported" functions

type ImportedMods = ModuleEnv [ImportedBy] Source #

Records the modules directly imported by a module for extracting e.g. usage information, and also to give better error message

data ImportedBy Source #

If a module was "imported" by the user, we associate it with more detailed usage information ImportedModsVal; a module imported by the system only gets used for usage information.

data ImportedModsVal Source #




data SptEntry Source #

An entry to be inserted into a module's static pointer table. See Note [Grand plan for static forms] in StaticPtrTable.


SptEntry Id Fingerprint 
Outputable SptEntry # 
Instance details

Defined in HscTypes

data ForeignSrcLang Source #


Eq ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

Show ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

Generic ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: * -> * Source #

type Rep ForeignSrcLang 
Instance details

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang = D1 (MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-8.4.4" False) ((C1 (MetaCons "LangC" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "LangCxx" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "LangObjc" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "LangObjcxx" PrefixI False) (U1 :: * -> *)))

data ModSummary Source #

A single node in a ModuleGraph. The nodes of the module graph are one of:

  • A regular Haskell source module
  • A hi-boot source module




Outputable ModSummary # 
Instance details

Defined in HscTypes

isBootSummary :: ModSummary -> Bool Source #

Did this ModSummary originate from a hs-boot file?

data SourceModified Source #

Indicates whether a given module's source has been modified since it was last compiled.



the source has been modified


the source has not been modified. Compilation may or may not be necessary, depending on whether any dependencies have changed since we last compiled.


the source has not been modified, and furthermore all of its (transitive) dependencies are up to date; it definitely does not need to be recompiled. This is important for two reasons: (a) we can omit the version check in checkOldIface, and (b) if the module used TH splices we don't need to force recompilation.

Information about the module being compiled

State relating to modules in this package

type HomePackageTable = DModuleNameEnv HomeModInfo Source #

Helps us find information about modules in the home package

data HomeModInfo Source #

Information about modules in the package being compiled




emptyHomePackageTable :: HomePackageTable Source #

Constructs an empty HomePackageTable

hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst]) Source #

Find all the instance declarations (of classes and families) from the Home Package Table filtered by the provided predicate function. Used in tcRnImports, to select the instances that are in the transitive closure of imports from the currently compiled module.

hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule] Source #

Get rules from modules "below" this one (in the dependency sense)

hptVectInfo :: HscEnv -> VectInfo Source #

Get the combined VectInfo of all modules in the home package table. In contrast to instances and rules, we don't care whether the modules are "below" us in the dependency sense. The VectInfo of those modules not "below" us does not affect the compilation of the current module.

State relating to known packages

data ExternalPackageState Source #

Information about other packages that we have slurped in by reading their interface files




data EpsStats Source #

Accumulated statistics about what we are putting into the ExternalPackageState. "In" means stuff that is just read from interface files, "Out" means actually sucked in and type-checked

addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats Source #

Add stats for one newly-read interface

type PackageIfaceTable = ModuleEnv ModIface Source #

Helps us find information about modules in the imported packages

emptyPackageIfaceTable :: PackageIfaceTable Source #

Constructs an empty PackageIfaceTable

lookupIfaceByModule :: DynFlags -> HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface Source #

Find the ModIface for a Module, searching in both the loaded home and external package module information

emptyModIface :: Module -> ModIface Source #

Constructs an empty ModIface


data MetaRequest Source #

The supported metaprogramming result types

data MetaResult Source #

data constructors not exported to ensure correct result type


prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv Source #

Deal with gathering annotations in from all possible places and combining them into a single AnnEnv

Interactive context

data InteractiveContext Source #

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




  • 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

emptyInteractiveContext :: DynFlags -> InteractiveContext Source #

Constructs an empty InteractiveContext.

icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified Source #

Get the PrintUnqualified function based on the flags and this InteractiveContext

icInScopeTTs :: InteractiveContext -> [TyThing] Source #

This function returns the list of visible TyThings (useful for e.g. showBindings)

icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv Source #

Add TyThings to the GlobalRdrEnv, earlier ones in the list shadowing later ones, and shadowing existing entries in the GlobalRdrEnv.

extendInteractiveContext :: InteractiveContext -> [TyThing] -> [ClsInst] -> [FamInst] -> Maybe [Type] -> FixityEnv -> InteractiveContext Source #

extendInteractiveContext is called with new TyThings recently defined to update the InteractiveContext to include them. Ids are easily removed when shadowed, but Classes and TyCons are not. Some work could be done to determine whether they are entirely shadowed, but as you could still have references to them (e.g. instances for classes or values of the type for TyCons), it's not clear whether removing them is even the appropriate behavior.

data InteractiveImport Source #


IIDecl (ImportDecl GhcPs)

Bring the exports of a particular module (filtered by an import decl) into scope

IIModule ModuleName

Bring into scope the entire top-level envt of of this module, including the things imported into it.

mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified Source #

Creates some functions that work out the best ways to format names for the user according to a set of heuristics.

mkQualPackage :: DynFlags -> QueryQualifyPackage Source #

Creates a function for formatting packages based on two heuristics: (1) don't qualify if the package in question is "main", and (2) only qualify with a unit id if the package ID would be ambiguous.

mkQualModule :: DynFlags -> QueryQualifyModule Source #

Creates a function for formatting modules based on two heuristics: (1) if the module is the current module, don't qualify, and (2) if there is only one exposed package which exports this module, don't qualify.

pkgQual :: DynFlags -> PrintUnqualified Source #

A function which only qualifies package names if necessary; but qualifies all other identifiers.


data ModIface Source #

A ModIface plus a ModDetails summarises everything we know about a compiled module. The ModIface is the stuff *before* linking, and can be written out to an interface file. The 'ModDetails is after linking and can be completely recovered from just the ModIface.

When we read an interface file, we also construct a ModIface from it, except that we explicitly make the mi_decls and a few other fields empty; as when reading we consolidate the declarations etc. into a number of indexed maps and environments in the ExternalPackageState.




Binary ModIface # 
Instance details

Defined in HscTypes

mkIfaceWarnCache :: Warnings -> OccName -> Maybe WarningTxt Source #

Constructs the cache for the mi_warn_fn field of a ModIface

mkIfaceHashCache :: [(Fingerprint, IfaceDecl)] -> OccName -> Maybe (OccName, Fingerprint) Source #

Constructs cache for the mi_hash_fn field of a ModIface

mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Maybe Fixity Source #

Creates cached lookup for the mi_fix_fn field of ModIface

mi_boot :: ModIface -> Bool Source #

Old-style accessor for whether or not the ModIface came from an hs-boot file.

mi_fix :: ModIface -> OccName -> Fixity Source #

Lookups up a (possibly cached) fixity from a ModIface. If one cannot be found, defaultFixity is returned instead.

mi_semantic_module :: ModIface -> Module Source #

The semantic module for this interface; e.g., if it's a interface for a signature, if mi_module is p[A=A]:A, mi_semantic_module will be A.

mi_free_holes :: ModIface -> UniqDSet ModuleName Source #

The "precise" free holes, e.g., the signatures that this ModIface depends on.

renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName Source #

Given a set of free holes, and a unit identifier, rename the free holes according to the instantiation of the unit identifier. For example, if we have A and B free, and our unit identity is p[A=C,B=impl:B], the renamed free holes are just C.


type FixityEnv = NameEnv FixItem Source #

Fixity environment mapping names to their fixities

data FixItem Source #

Fixity information for an Name. We keep the OccName in the range so that we can generate an interface from it


FixItem OccName Fixity 
Outputable FixItem # 
Instance details

Defined in HscTypes

TyThings and type environments

data TyThing Source #

A global typecheckable-thing, essentially anything that has a name. Not to be confused with a TcTyThing, which is also a typecheckable thing but in the *local* context. See TcEnv for how to retrieve a TyThing given a Name.

Outputable TyThing # 
Instance details

Defined in TyCoRep

NamedThing TyThing # 
Instance details

Defined in TyCoRep

tyThingAvailInfo :: TyThing -> [AvailInfo] Source #

The Names that a TyThing should bring into scope. Used to build the GlobalRdrEnv for the InteractiveContext.

tyThingTyCon :: TyThing -> TyCon Source #

Get the TyCon from a TyThing if it is a type constructor thing. Panics otherwise

tyThingDataCon :: TyThing -> DataCon Source #

Get the DataCon from a TyThing if it is a data constructor thing. Panics otherwise

tyThingConLike :: TyThing -> ConLike Source #

Get the ConLike from a TyThing if it is a data constructor thing. Panics otherwise

tyThingId :: TyThing -> Id Source #

Get the Id from a TyThing if it is a id *or* data constructor thing. Panics otherwise

tyThingCoAxiom :: TyThing -> CoAxiom Branched Source #

Get the CoAxiom from a TyThing if it is a coercion axiom thing. Panics otherwise

tyThingParent_maybe :: TyThing -> Maybe TyThing Source #

tyThingParent_maybe x returns (Just p) when pprTyThingInContext should print a declaration for p (albeit with some "..." in it) when asked to show x It returns the *immediate* parent. So a datacon returns its tycon but the tycon could be the associated type of a class, so it in turn might have a parent.

implicitTyThings :: TyThing -> [TyThing] Source #

Determine the TyThings brought into scope by another TyThing other than itself. For example, Id's don't have any implicit TyThings as they just bring themselves into scope, but classes bring their dictionary datatype, type constructor and some selector functions into scope, just for a start!

isImplicitTyThing :: TyThing -> Bool Source #

Returns True if there should be no interface-file declaration for this thing on its own: either it is built-in, or it is part of some other declaration, or it is generated implicitly by some other declaration.

type TypeEnv = NameEnv TyThing Source #

A map from Names to TyThings, constructed by typechecking local declarations or interface files

lookupType :: DynFlags -> HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing Source #

Find the TyThing for the given Name by using all the resources at our disposal: the compiled modules in the HomePackageTable and the compiled modules in other packages that live in PackageTypeEnv. Note that this does NOT look up the TyThing in the module being compiled: you have to do that yourself, if desired

lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing) Source #

As lookupType, but with a marginally easier-to-use interface if you have a HscEnv


class Monad m => MonadThings m where Source #

Class that abstracts out the common ability of the monads in GHC to lookup a TyThing in the monadic environment by Name. Provides a number of related convenience functions for accessing particular kinds of TyThing

Minimal complete definition


Information on imports and exports

type WhetherHasOrphans = Bool Source #

Records whether a module has orphans. An "orphan" is one of:

  • An instance declaration in a module other than the definition module for one of the type constructors or classes in the instance head
  • A transformation rule in a module other than the one defining the function in the head of the rule
  • A vectorisation pragma

type IsBootInterface = Bool Source #

Did this module originate from a *-boot file?

data Usage Source #

Records modules for which changes may force recompilation of this module See wiki:

This differs from Dependencies. A module X may be in the dep_mods of this module (via an import chain) but if we don't use anything from X it won't appear in our Usage



Module from another package



Module from the current package | A file upon which the module depends, e.g. a CPP #include, or using TH's addDependentFile





A requirement which was merged into this one.


Eq Usage # 
Instance details

Defined in HscTypes


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

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

Binary Usage # 
Instance details

Defined in HscTypes

data Dependencies Source #

Dependency information about ALL modules and packages below this one in the import hierarchy.

Invariant: the dependencies of a module M never includes M.

Invariant: none of the lists contain duplicates.




  • dep_mods :: [(ModuleName, IsBootInterface)]

    All home-package modules transitively below this one I.e. modules that this one imports, or that are in the dep_mods of those directly-imported modules

  • dep_pkgs :: [(InstalledUnitId, Bool)]

    All packages transitively below this module I.e. packages to which this module's direct imports belong, or that are in the dep_pkgs of those modules The bool indicates if the package is required to be trusted when the module is imported as a safe import (Safe Haskell). See Note [RnNames . Tracking Trust Transitively]

  • dep_orphs :: [Module]

    Transitive closure of orphan modules (whether home or external pkg).

    (Possible optimization: don't include family instance orphans as they are anyway included in dep_finsts. But then be careful about code which relies on dep_orphs having the complete list!) This does NOT include us, unlike imp_orphs.

  • dep_finsts :: [Module]

    Transitive closure of depended upon modules which contain family instances (whether home or external). This is used by checkFamInstConsistency. This does NOT include us, unlike imp_finsts. See Note [The type family instance consistency story].

Eq Dependencies # 
Instance details

Defined in HscTypes

Binary Dependencies # 
Instance details

Defined in HscTypes

type IfaceExport = AvailInfo Source #

The original names declared of a certain module that are exported


data Warnings Source #

Warning information for a module



Nothing deprecated

WarnAll WarningTxt

Whole module deprecated

WarnSome [(OccName, WarningTxt)]

Some specific things deprecated

Eq Warnings # 
Instance details

Defined in HscTypes

Outputable Warnings # 
Instance details

Defined in LoadIface

Binary Warnings # 
Instance details

Defined in HscTypes

data WarningTxt Source #

Warning Text

reason/explanation from a WARNING or DEPRECATED pragma

Eq WarningTxt # 
Instance details

Defined in BasicTypes

Data WarningTxt # 
Instance details

Defined in BasicTypes


gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarningTxt -> c WarningTxt Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WarningTxt Source #

toConstr :: WarningTxt -> Constr Source #

dataTypeOf :: WarningTxt -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WarningTxt) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WarningTxt) Source #

gmapT :: (forall b. Data b => b -> b) -> WarningTxt -> WarningTxt Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarningTxt -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarningTxt -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> WarningTxt -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarningTxt -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarningTxt -> m WarningTxt Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningTxt -> m WarningTxt Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningTxt -> m WarningTxt Source #

Outputable WarningTxt # 
Instance details

Defined in BasicTypes

Binary WarningTxt # 
Instance details

Defined in Binary

Linker stuff

data Linkable Source #

Information we can use to dynamically link modules into the compiler




  • linkableTime :: UTCTime

    Time at which this linkable was built (i.e. when the bytecodes were produced, or the mod date on the files)

  • linkableModule :: Module

    The linkable module itself

  • linkableUnlinked :: [Unlinked]

    Those files and chunks of code we have yet to link.

    INVARIANT: A valid linkable always has at least one Unlinked item. If this list is empty, the Linkable represents a fake linkable, which is generated in HscNothing mode to avoid recompiling modules.

    ToDo: Do items get removed from this list when they get linked?

Outputable Linkable # 
Instance details

Defined in HscTypes

data Unlinked Source #

Objects which have yet to be linked by the compiler


DotO FilePath

An object file (.o)

DotA FilePath

Static archive file (.a)

DotDLL FilePath

Dynamically linked library file (.so, .dll, .dylib)

BCOs CompiledByteCode [SptEntry]

A byte-code object, lives only in memory. Also carries some static pointer table entries which should be loaded along with the BCOs. See Note [Grant plan for static forms] in StaticPtrTable.

Outputable Unlinked # 
Instance details

Defined in HscTypes

isObject :: Unlinked -> Bool Source #

Is this an actual file on disk we can link in somehow?

nameOfObject :: Unlinked -> FilePath Source #

Retrieve the filename of the linkable if possible. Panic if it is a byte-code object

isInterpretable :: Unlinked -> Bool Source #

Is this a bytecode linkable with no file on disk?

byteCodeOfObject :: Unlinked -> CompiledByteCode Source #

Retrieve the compiled byte-code if possible. Panic if it is a file-based linkable

Program coverage

data HpcInfo Source #

Information about a modules use of Haskell Program Coverage




isHpcUsed :: HpcInfo -> AnyHpcUsage Source #

Find out if HPC is used by this module or any of the modules it depends upon

type AnyHpcUsage = Bool Source #

This is used to signal if one of my imports used HPC instrumentation even if there is no module-local HPC usage


data ModBreaks Source #

All the information about the breakpoints for a module




emptyModBreaks :: ModBreaks Source #

Construct an empty ModBreaks

Vectorisation information

data VectInfo Source #

Vectorisation information for ModGuts, ModDetails and ExternalPackageState; see also documentation at GlobalEnv.

NB: The following tables may also include Vars, TyCons and DataCons from imported modules, which have been subsequently vectorised in the current module.




Outputable VectInfo # 
Instance details

Defined in HscTypes

data IfaceVectInfo Source #

Vectorisation information for ModIface; i.e, the vectorisation information propagated across module boundaries.

NB: The field ifaceVectInfoVar explicitly contains the workers of data constructors as well as class selectors — i.e., their mappings are not implicitly generated from the data types. Moreover, whether the worker of a data constructor is in ifaceVectInfoVar determines whether that data constructor was vectorised (or is part of an abstractly vectorised type constructor).




Safe Haskell information

data IfaceTrustInfo Source #

Safe Haskell information for ModIface Simply a wrapper around SafeHaskellMode to sepperate iface and flags

type IsSafeImport = Bool Source #

Is an import a safe import?

result of the parser

data HsParsedModule Source #




Compilation errors and warnings

data SourceError Source #

A source error is an error that is caused by one or more errors in the source code. A SourceError is thrown by many functions in the compilation pipeline. Inside GHC these errors are merely printed via log_action, but API clients may treat them differently, for example, insert them into a list box. If you want the default behaviour, use the idiom:

handleSourceError printExceptionAndWarnings $ do
  ... api calls that may fail ...

The SourceErrors error messages can be accessed via srcErrorMessages. This list may be empty if the compiler failed due to -Werror (Opt_WarnIsError).

See printExceptionAndWarnings for more information on what to take care of when writing a custom error handler.

data GhcApiError Source #

An error thrown if the GHC API is used in an incorrect fashion.

handleSourceError Source #


:: ExceptionMonad m 
=> (SourceError -> m a)

exception handler

-> m a

action to perform

-> m a 

Perform the given action and call the exception handler if the action throws a SourceError. See SourceError for more information.

printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO () Source #

Given a bag of warnings, turn them into an exception if -Werror is enabled, or print them out otherwise.

COMPLETE signature

data CompleteMatch Source #

A list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures.




Outputable CompleteMatch # 
Instance details

Defined in HscTypes