ghc-8.0.2: The GHC API

Safe Haskell | None
Language | Haskell2010

Module

Contents

- The ModuleName type
- The UnitId type
- Wired-in UnitIds
- The Module type
- The ModuleLocation type
- Module mappings
- ModuleName mappings
- Sets of Modules

Synopsis

- data ModuleName
- pprModuleName :: ModuleName -> SDoc
- moduleNameFS :: ModuleName -> FastString
- moduleNameString :: ModuleName -> String
- moduleNameSlashes :: ModuleName -> String
- moduleNameColons :: ModuleName -> String
- moduleStableString :: Module -> String
- mkModuleName :: String -> ModuleName
- mkModuleNameFS :: FastString -> ModuleName
- stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering
- data UnitId
- fsToUnitId :: FastString -> UnitId
- unitIdFS :: UnitId -> FastString
- stringToUnitId :: String -> UnitId
- unitIdString :: UnitId -> String
- stableUnitIdCmp :: UnitId -> UnitId -> Ordering
- primUnitId :: UnitId
- integerUnitId :: UnitId
- baseUnitId :: UnitId
- rtsUnitId :: UnitId
- thUnitId :: UnitId
- dphSeqUnitId :: UnitId
- dphParUnitId :: UnitId
- mainUnitId :: UnitId
- thisGhcUnitId :: UnitId
- holeUnitId :: UnitId
- isHoleModule :: Module -> Bool
- interactiveUnitId :: UnitId
- isInteractiveModule :: Module -> Bool
- wiredInUnitIds :: [UnitId]
- data Module = Module {
  - moduleUnitId :: !UnitId
  - moduleName :: !ModuleName
  }
- pprModule :: Module -> SDoc
- mkModule :: UnitId -> ModuleName -> Module
- stableModuleCmp :: Module -> Module -> Ordering
- class HasModule m where
- class ContainsModule t where
- data ModLocation = ModLocation {
  - ml_hs_file :: Maybe FilePath
  - ml_hi_file :: FilePath
  - ml_obj_file :: FilePath
  }
- addBootSuffix :: FilePath -> FilePath
- addBootSuffix_maybe :: Bool -> FilePath -> FilePath
- addBootSuffixLocn :: ModLocation -> ModLocation
- data ModuleEnv elt
- elemModuleEnv :: Module -> ModuleEnv a -> Bool
- extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
- extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
- extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)] -> ModuleEnv a
- plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
- delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
- delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
- plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
- lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
- lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
- mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
- mkModuleEnv :: [(Module, a)] -> ModuleEnv a
- emptyModuleEnv :: ModuleEnv a
- moduleEnvKeys :: ModuleEnv a -> [Module]
- moduleEnvElts :: ModuleEnv a -> [a]
- moduleEnvToList :: ModuleEnv a -> [(Module, a)]
- unitModuleEnv :: Module -> a -> ModuleEnv a
- isEmptyModuleEnv :: ModuleEnv a -> Bool
- foldModuleEnv :: (a -> b -> b) -> b -> ModuleEnv a -> b
- extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
- filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a
- type ModuleNameEnv elt = UniqFM elt
- type ModuleSet = Set NDModule
- emptyModuleSet :: ModuleSet
- mkModuleSet :: [Module] -> ModuleSet
- moduleSetElts :: ModuleSet -> [Module]
- extendModuleSet :: ModuleSet -> Module -> ModuleSet
- elemModuleSet :: Module -> ModuleSet -> Bool

# The ModuleName type

data ModuleName Source #

A ModuleName is essentially a simple string, e.g. `Data.List`.

Instances

Eq ModuleName # |
Methods (==) :: ModuleName -> ModuleName -> Bool # (/=) :: ModuleName -> ModuleName -> Bool #
Data ModuleName # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName -> c ModuleName Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleName Source # toConstr :: ModuleName -> Constr Source # dataTypeOf :: ModuleName -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ModuleName) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName) Source # gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ModuleName -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName Source #
Ord ModuleName # |
Methods compare :: ModuleName -> ModuleName -> Ordering # (<) :: ModuleName -> ModuleName -> Bool # (<=) :: ModuleName -> ModuleName -> Bool # (>) :: ModuleName -> ModuleName -> Bool # (>=) :: ModuleName -> ModuleName -> Bool # max :: ModuleName -> ModuleName -> ModuleName # min :: ModuleName -> ModuleName -> ModuleName #
NFData ModuleName # |
Methods rnf :: ModuleName -> () Source #
BinaryStringRep ModuleName # |
Methods fromStringRep :: ByteString -> ModuleName Source # toStringRep :: ModuleName -> ByteString Source #
Outputable ModuleName # |
Methods ppr :: ModuleName -> SDoc Source # pprPrec :: Rational -> ModuleName -> SDoc Source #
Uniquable ModuleName # |
Methods getUnique :: ModuleName -> Unique Source #
Binary ModuleName # |
Methods put_ :: BinHandle -> ModuleName -> IO () Source # put :: BinHandle -> ModuleName -> IO (Bin ModuleName) Source # get :: BinHandle -> IO ModuleName Source #

pprModuleName :: ModuleName -> SDoc Source #

moduleNameFS :: ModuleName -> FastString Source #

moduleNameString :: ModuleName -> String Source #

moduleNameSlashes :: ModuleName -> String Source #

Returns the string version of the module name, with dots replaced by slashes.

moduleNameColons :: ModuleName -> String Source #

Returns the string version of the module name, with dots replaced by underscores.

moduleStableString :: Module -> String Source #

Get a string representation of a `Module` that's unique and stable across recompilations. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"

mkModuleName :: String -> ModuleName Source #

mkModuleNameFS :: FastString -> ModuleName Source #

stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering Source #

Compares module names lexically, rather than by their `Unique`s

# The UnitId type

data UnitId Source #

A string which uniquely identifies a package. For wired-in packages, it is just the package name, but for user compiled packages, it is a hash. ToDo: when the key is a hash, we can do more clever things than store the hex representation and hash-cons those strings.

Instances

Eq UnitId # |
Methods (==) :: UnitId -> UnitId -> Bool # (/=) :: UnitId -> UnitId -> Bool #
Data UnitId # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId Source # toConstr :: UnitId -> Constr Source # dataTypeOf :: UnitId -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c UnitId) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) Source # gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r Source # gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source #
Ord UnitId # |
Methods compare :: UnitId -> UnitId -> Ordering # (<) :: UnitId -> UnitId -> Bool # (<=) :: UnitId -> UnitId -> Bool # (>) :: UnitId -> UnitId -> Bool # (>=) :: UnitId -> UnitId -> Bool # max :: UnitId -> UnitId -> UnitId # min :: UnitId -> UnitId -> UnitId #
NFData UnitId # |
Methods rnf :: UnitId -> () Source #
BinaryStringRep UnitId # |
Methods fromStringRep :: ByteString -> UnitId Source # toStringRep :: UnitId -> ByteString Source #
Outputable UnitId # |
Methods ppr :: UnitId -> SDoc Source # pprPrec :: Rational -> UnitId -> SDoc Source #
Uniquable UnitId # |
Methods getUnique :: UnitId -> Unique Source #
Binary UnitId # |
Methods put_ :: BinHandle -> UnitId -> IO () Source # put :: BinHandle -> UnitId -> IO (Bin UnitId) Source # get :: BinHandle -> IO UnitId Source #

fsToUnitId :: FastString -> UnitId Source #

unitIdFS :: UnitId -> FastString Source #

stringToUnitId :: String -> UnitId Source #

unitIdString :: UnitId -> String Source #

stableUnitIdCmp :: UnitId -> UnitId -> Ordering Source #

Compares package ids lexically, rather than by their `Unique`s

# Wired-in UnitIds

Certain packages are known to the compiler, in that we know about certain entities that reside in these packages, and the compiler needs to declare static Modules and Names that refer to these packages. Hence the wired-in packages can't include version numbers, since we don't want to bake the version numbers of these packages into GHC.

So here's the plan. Wired-in packages are still versioned as normal in the packages database, and you can still have multiple versions of them installed. However, for each invocation of GHC, only a single instance of each wired-in package will be recognised (the desired one is selected via `-package`/`-hide-package`), and GHC will use the unversioned `UnitId` below when referring to it, including in .hi files and object file symbols. Unselected versions of wired-in packages will be ignored, as will any other package that depends directly or indirectly on it (much as if you had used `-ignore-package`).

primUnitId :: UnitId Source #

integerUnitId :: UnitId Source #

baseUnitId :: UnitId Source #

rtsUnitId :: UnitId Source #

thUnitId :: UnitId Source #

dphSeqUnitId :: UnitId Source #

dphParUnitId :: UnitId Source #

mainUnitId :: UnitId Source #

This is the package Id for the current program. It is the default package Id if you don't specify a package name. We don't add this prefix to symbol names, since there can be only one main package per program.

thisGhcUnitId :: UnitId Source #

holeUnitId :: UnitId Source #

This is a fake package id used to provide identities to any un-implemented signatures. The set of hole identities is global over an entire compilation.

isHoleModule :: Module -> Bool Source #

interactiveUnitId :: UnitId Source #

isInteractiveModule :: Module -> Bool Source #

wiredInUnitIds :: [UnitId] Source #

# The Module type

data Module Source #

A Module is a pair of a `UnitId` and a `ModuleName`.

Constructors

Module |
Fields moduleUnitId :: !UnitId moduleName :: !ModuleName

Instances

Eq Module # |
Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Data Module # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module Source # toConstr :: Module -> Constr Source # dataTypeOf :: Module -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Module) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) Source # gmapT :: (forall b. Data b => b -> b) -> Module -> Module Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source #
Ord Module # |
Methods compare :: Module -> Module -> Ordering # (<) :: Module -> Module -> Bool # (<=) :: Module -> Module -> Bool # (>) :: Module -> Module -> Bool # (>=) :: Module -> Module -> Bool # max :: Module -> Module -> Module # min :: Module -> Module -> Module #
NFData Module # |
Methods rnf :: Module -> () Source #
Outputable Module # |
Methods ppr :: Module -> SDoc Source # pprPrec :: Rational -> Module -> SDoc Source #
Uniquable Module # |
Methods getUnique :: Module -> Unique Source #
Binary Module # |
Methods put_ :: BinHandle -> Module -> IO () Source # put :: BinHandle -> Module -> IO (Bin Module) Source # get :: BinHandle -> IO Module Source #

pprModule :: Module -> SDoc Source #

mkModule :: UnitId -> ModuleName -> Module Source #

stableModuleCmp :: Module -> Module -> Ordering Source #

This gives a stable ordering, as opposed to the Ord instance which gives an ordering based on the `Unique`s of the components, which may not be stable from run to run of the compiler.

class HasModule m where Source #

Minimal complete definition

getModule

Methods

getModule :: m Module Source #

Instances

HasModule CoreM # |
Methods getModule :: CoreM Module Source #
ContainsModule env => HasModule (IOEnv env) # |
Methods getModule :: IOEnv env Module Source #

class ContainsModule t where Source #

Minimal complete definition

extractModule

Methods

extractModule :: t -> Module Source #

Instances

ContainsModule TcGblEnv # |
Methods extractModule :: TcGblEnv -> Module Source #
ContainsModule DsGblEnv # |
Methods extractModule :: DsGblEnv -> Module Source #
ContainsModule gbl => ContainsModule (Env gbl lcl) # |
Methods extractModule :: Env gbl lcl -> Module Source #

# The ModuleLocation type

data ModLocation Source #

Where a module lives on the file system: the actual locations of the .hs, .hi and .o files, if we have them

Constructors

ModLocation |
Fields ml_hs_file :: Maybe FilePath ml_hi_file :: FilePath ml_obj_file :: FilePath

Instances

Show ModLocation # |
Methods showsPrec :: Int -> ModLocation -> ShowS Source # show :: ModLocation -> String Source # showList :: [ModLocation] -> ShowS Source #
Outputable ModLocation # |
Methods ppr :: ModLocation -> SDoc Source # pprPrec :: Rational -> ModLocation -> SDoc Source #

addBootSuffix :: FilePath -> FilePath Source #

Add the `-boot` suffix to .hs, .hi and .o files

addBootSuffix_maybe :: Bool -> FilePath -> FilePath Source #

Add the `-boot` suffix if the `Bool` argument is `True`

addBootSuffixLocn :: ModLocation -> ModLocation Source #

Add the `-boot` suffix to all file paths associated with the module

# Module mappings

data ModuleEnv elt Source #

A map keyed off of `Module`s

elemModuleEnv :: Module -> ModuleEnv a -> Bool Source #

extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a Source #

extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a Source #

extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)] -> ModuleEnv a Source #

plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a Source #

delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a Source #

delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a Source #

plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a Source #

lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a Source #

lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a Source #

mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b Source #

mkModuleEnv :: [(Module, a)] -> ModuleEnv a Source #

emptyModuleEnv :: ModuleEnv a Source #

moduleEnvKeys :: ModuleEnv a -> [Module] Source #

moduleEnvElts :: ModuleEnv a -> [a] Source #

moduleEnvToList :: ModuleEnv a -> [(Module, a)] Source #

unitModuleEnv :: Module -> a -> ModuleEnv a Source #

isEmptyModuleEnv :: ModuleEnv a -> Bool Source #

foldModuleEnv :: (a -> b -> b) -> b -> ModuleEnv a -> b Source #

extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a -> ModuleEnv a Source #

filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a Source #

# ModuleName mappings

type ModuleNameEnv elt = UniqFM elt Source #

A map keyed off of `ModuleName`s (actually, their `Unique`s)

# Sets of Modules

type ModuleSet = Set NDModule Source #

A set of `Module`s

emptyModuleSet :: ModuleSet Source #

mkModuleSet :: [Module] -> ModuleSet Source #

moduleSetElts :: ModuleSet -> [Module] Source #

extendModuleSet :: ModuleSet -> Module -> ModuleSet Source #

elemModuleSet :: Module -> ModuleSet -> Bool Source #