Safe Haskell	None
Language	Haskell2010

GHC.Unit.State

Contents

Reading the package config, and processing cmdline args
Querying the package config
Inspecting the set of packages in scope
Utils

Description

Package manipulation

Synopsis

module GHC.Unit.Info
data PackageState = PackageState {
- unitInfoMap :: UnitInfoMap
- packageNameMap :: Map PackageName IndefUnitId
- unwireMap :: Map WiredUnitId WiredUnitId
- preloadPackages :: [PreloadUnitId]
- explicitPackages :: [Unit]
- moduleNameProvidersMap :: !ModuleNameProvidersMap
- pluginModuleNameProvidersMap :: !ModuleNameProvidersMap
- requirementContext :: Map ModuleName [InstantiatedModule]
}
data PackageDatabase unit = PackageDatabase {
- packageDatabasePath :: FilePath
- packageDatabaseUnits :: [GenUnitInfo unit]
}
data UnitInfoMap
emptyPackageState :: PackageState
initPackages :: DynFlags -> IO (DynFlags, [PreloadUnitId])
readPackageDatabases :: DynFlags -> IO [PackageDatabase UnitId]
readPackageDatabase :: DynFlags -> FilePath -> IO (PackageDatabase UnitId)
getPackageConfRefs :: DynFlags -> IO [PkgDbRef]
resolvePackageDatabase :: DynFlags -> PkgDbRef -> IO (Maybe FilePath)
listUnitInfoMap :: PackageState -> [UnitInfo]
lookupUnit :: DynFlags -> Unit -> Maybe UnitInfo
lookupUnit' :: Bool -> UnitInfoMap -> Unit -> Maybe UnitInfo
lookupInstalledPackage :: PackageState -> UnitId -> Maybe UnitInfo
lookupPackageName :: PackageState -> PackageName -> Maybe IndefUnitId
improveUnit :: UnitInfoMap -> Unit -> Unit
searchPackageId :: PackageState -> PackageId -> [UnitInfo]
unsafeGetUnitInfo :: HasDebugCallStack => DynFlags -> Unit -> UnitInfo
getInstalledPackageDetails :: HasDebugCallStack => PackageState -> UnitId -> UnitInfo
displayUnitId :: PackageState -> UnitId -> Maybe String
listVisibleModuleNames :: DynFlags -> [ModuleName]
lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, UnitInfo)]
lookupModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult
lookupPluginModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult
data LookupResult
- = LookupFound Module UnitInfo
- | LookupMultiple [(Module, ModuleOrigin)]
- | LookupHidden [(Module, ModuleOrigin)] [(Module, ModuleOrigin)]
- | LookupUnusable [(Module, ModuleOrigin)]
- | LookupNotFound [ModuleSuggestion]
data ModuleSuggestion
- = SuggestVisible ModuleName Module ModuleOrigin
- | SuggestHidden ModuleName Module ModuleOrigin
data ModuleOrigin
- = ModHidden
- | ModUnusable UnusablePackageReason
- | ModOrigin {
  - fromOrigPackage :: Maybe Bool
  - fromExposedReexport :: [UnitInfo]
  - fromHiddenReexport :: [UnitInfo]
  - fromPackageFlag :: Bool
  }
data UnusablePackageReason
- = IgnoredWithFlag
- | BrokenDependencies [UnitId]
- | CyclicDependencies [UnitId]
- | IgnoredDependencies [UnitId]
- | ShadowedDependencies [UnitId]
pprReason :: SDoc -> UnusablePackageReason -> SDoc
getPackageIncludePath :: DynFlags -> [PreloadUnitId] -> IO [String]
getPackageLibraryPath :: DynFlags -> [PreloadUnitId] -> IO [String]
getPackageLinkOpts :: DynFlags -> [PreloadUnitId] -> IO ([String], [String], [String])
getPackageExtraCcOpts :: DynFlags -> [PreloadUnitId] -> IO [String]
getPackageFrameworkPath :: DynFlags -> [PreloadUnitId] -> IO [String]
getPackageFrameworks :: DynFlags -> [PreloadUnitId] -> IO [String]
getPreloadPackagesAnd :: DynFlags -> [PreloadUnitId] -> IO [UnitInfo]
collectArchives :: DynFlags -> UnitInfo -> IO [FilePath]
collectIncludeDirs :: [UnitInfo] -> [FilePath]
collectLibraryPaths :: DynFlags -> [UnitInfo] -> [FilePath]
collectLinkOpts :: DynFlags -> [UnitInfo] -> ([String], [String], [String])
packageHsLibs :: DynFlags -> UnitInfo -> [String]
getLibs :: DynFlags -> [PreloadUnitId] -> IO [(String, String)]
mkIndefUnitId :: PackageState -> FastString -> IndefUnitId
updateIndefUnitId :: PackageState -> IndefUnitId -> IndefUnitId
unwireUnit :: DynFlags -> Unit -> Unit
pprFlag :: PackageFlag -> SDoc
pprPackages :: PackageState -> SDoc
pprPackagesSimple :: PackageState -> SDoc
pprModuleMap :: ModuleNameProvidersMap -> SDoc
isIndefinite :: DynFlags -> Bool

Documentation

module GHC.Unit.Info

Reading the package config, and processing cmdline args

data PackageState Source #

Constructors

PackageState

Fields

unitInfoMap :: UnitInfoMap
A mapping of Unit to UnitInfo. This list is adjusted so that only valid packages are here. UnitInfo reflects what was stored *on disk*, except for the trusted flag, which is adjusted at runtime. (In particular, some packages in this map may have the exposed flag be False.)
packageNameMap :: Map PackageName IndefUnitId
A mapping of PackageName to IndefUnitId. This is used when users refer to packages in Backpack includes.
unwireMap :: Map WiredUnitId WiredUnitId
A mapping from wired in names to the original names from the package database.
preloadPackages :: [PreloadUnitId]
The packages we're going to link in eagerly. This list should be in reverse dependency order; that is, a package is always mentioned before the packages it depends on.
explicitPackages :: [Unit]
Packages which we explicitly depend on (from a command line flag). We'll use this to generate version macros.
moduleNameProvidersMap :: !ModuleNameProvidersMap
This is a full map from ModuleName to all modules which may possibly be providing it. These providers may be hidden (but we'll still want to report them in error messages), or it may be an ambiguous import.
pluginModuleNameProvidersMap :: !ModuleNameProvidersMap
A map, like moduleNameProvidersMap, but controlling plugin visibility.
requirementContext :: Map ModuleName [InstantiatedModule]
A map saying, for each requirement, what interfaces must be merged together when we use them. For example, if our dependencies are p[A=A] and q[A=A,B=r[C=A]:B], then the interfaces to merge for A are p[A=A]:A, q[A=A,B=r[C=A]:B]:A and r[C=A]:C.
There's an entry in this map for each hole in our home library.

data PackageDatabase unit Source #

Package database

Constructors

PackageDatabase
Fields packageDatabasePath :: FilePath packageDatabaseUnits :: [GenUnitInfo unit]

data UnitInfoMap Source #

Map from UnitId to UnitInfo, plus the transitive closure of preload units.

emptyPackageState :: PackageState Source #

initPackages :: DynFlags -> IO (DynFlags, [PreloadUnitId]) Source #

Read the package database files, and sets up various internal tables of package information, according to the package-related flags on the command-line (-package, -hide-package etc.)

Returns a list of packages to link in if we're doing dynamic linking. This list contains the packages that the user explicitly mentioned with -package flags.

initPackages can be called again subsequently after updating the packageFlags field of the DynFlags, and it will update the pkgState in DynFlags and return a list of packages to link in.

readPackageDatabases :: DynFlags -> IO [PackageDatabase UnitId] Source #

readPackageDatabase :: DynFlags -> FilePath -> IO (PackageDatabase UnitId) Source #

getPackageConfRefs :: DynFlags -> IO [PkgDbRef] Source #

resolvePackageDatabase :: DynFlags -> PkgDbRef -> IO (Maybe FilePath) Source #

Return the path of a package database from a PkgDbRef. Return Nothing when the user database filepath is expected but the latter doesn't exist.

NB: This logic is reimplemented in Cabal, so if you change it, make sure you update Cabal. (Or, better yet, dump it in the compiler info so Cabal can use the info.)

listUnitInfoMap :: PackageState -> [UnitInfo] Source #

Get a list of entries from the package database. NB: be careful with this function, although all packages in this map are "visible", this does not imply that the exposed-modules of the package are available (they may have been thinned or renamed).

Querying the package config

lookupUnit :: DynFlags -> Unit -> Maybe UnitInfo Source #

Find the unit we know about with the given unit id, if any

lookupUnit' :: Bool -> UnitInfoMap -> Unit -> Maybe UnitInfo Source #

A more specialized interface, which takes a boolean specifying whether or not to look for on-the-fly renamed interfaces, and just a UnitInfoMap rather than a DynFlags (so it can be used while we're initializing DynFlags

lookupInstalledPackage :: PackageState -> UnitId -> Maybe UnitInfo Source #

lookupPackageName :: PackageState -> PackageName -> Maybe IndefUnitId Source #

Find the package we know about with the given package name (e.g. foo), if any (NB: there might be a locally defined unit name which overrides this)

improveUnit :: UnitInfoMap -> Unit -> Unit Source #

Given a fully instantiated GenInstantiatedUnit, improve it into a RealUnit if we can find it in the package database.

searchPackageId :: PackageState -> PackageId -> [UnitInfo] Source #

Search for packages with a given package ID (e.g. "foo-0.1")

unsafeGetUnitInfo :: HasDebugCallStack => DynFlags -> Unit -> UnitInfo Source #

Looks up the package with the given id in the package state, panicing if it is not found

getInstalledPackageDetails :: HasDebugCallStack => PackageState -> UnitId -> UnitInfo Source #

displayUnitId :: PackageState -> UnitId -> Maybe String Source #

listVisibleModuleNames :: DynFlags -> [ModuleName] Source #

lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, UnitInfo)] Source #

Takes a ModuleName, and if the module is in any package returns list of modules which take that name.

lookupModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult Source #

lookupPluginModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult Source #

data LookupResult Source #

The result of performing a lookup

Constructors

LookupFound Module UnitInfo	Found the module uniquely, nothing else to do
LookupMultiple [(Module, ModuleOrigin)]	Multiple modules with the same name in scope
LookupHidden [(Module, ModuleOrigin)] [(Module, ModuleOrigin)]	No modules found, but there were some hidden ones with an exact name match. First is due to package hidden, second is due to module being hidden
LookupUnusable [(Module, ModuleOrigin)]	No modules found, but there were some unusable ones with an exact name match
LookupNotFound [ModuleSuggestion]	Nothing found, here are some suggested different names

data ModuleSuggestion Source #

Constructors

SuggestVisible ModuleName Module ModuleOrigin
SuggestHidden ModuleName Module ModuleOrigin

data ModuleOrigin Source #

Package state is all stored in DynFlags, including the details of all packages, which packages are exposed, and which modules they provide.

The package state is computed by initPackages, and kept in DynFlags. It is influenced by various package flags:

-package pkg and -package-id pkg cause pkg to become exposed. If -hide-all-packages was not specified, these commands also cause all other packages with the same name to become hidden.
-hide-package pkg causes pkg to become hidden.
(there are a few more flags, check below for their semantics)

The package state has the following properties.

Let exposedPackages be the set of packages thus exposed. Let depExposedPackages be the transitive closure from exposedPackages of their dependencies.
When searching for a module from a preload import declaration, only the exposed modules in exposedPackages are valid.
When searching for a module from an implicit import, all modules from depExposedPackages are valid.
When linking in a compilation manager mode, we link in packages the program depends on (the compiler knows this list by the time it gets to the link step). Also, we link in all packages which were mentioned with preload -package flags on the command-line, or are a transitive dependency of same, or are "base"/"rts". The reason for this is that we might need packages which don't contain any Haskell modules, and therefore won't be discovered by the normal mechanism of dependency tracking.

Given a module name, there may be multiple ways it came into scope, possibly simultaneously. This data type tracks all the possible ways it could have come into scope. Warning: don't use the record functions, they're partial!

Constructors

ModHidden	Module is hidden, and thus never will be available for import. (But maybe the user didn't realize), so we'll still keep track of these modules.)
ModUnusable UnusablePackageReason	Module is unavailable because the package is unusable.
ModOrigin	Module is public, and could have come from some places.
Fields fromOrigPackage :: Maybe Bool `Just False` means that this module is in someone's `exported-modules` list, but that package is hidden; `Just True` means that it is available; `Nothing` means neither applies. fromExposedReexport :: [UnitInfo] Is the module available from a reexport of an exposed package? There could be multiple. fromHiddenReexport :: [UnitInfo] Is the module available from a reexport of a hidden package? fromPackageFlag :: Bool Did the module export come from a package flag? (ToDo: track more information.

Instances

Instances details

Semigroup ModuleOrigin Source #
Instance details Defined in GHC.Unit.State Methods (<>) :: ModuleOrigin -> ModuleOrigin -> ModuleOrigin Source # sconcat :: NonEmpty ModuleOrigin -> ModuleOrigin Source # stimes :: Integral b => b -> ModuleOrigin -> ModuleOrigin Source #
Monoid ModuleOrigin Source #
Instance details Defined in GHC.Unit.State Methods mempty :: ModuleOrigin Source # mappend :: ModuleOrigin -> ModuleOrigin -> ModuleOrigin Source # mconcat :: [ModuleOrigin] -> ModuleOrigin Source #
Outputable ModuleOrigin Source #
Instance details Defined in GHC.Unit.State Methods ppr :: ModuleOrigin -> SDoc Source # pprPrec :: Rational -> ModuleOrigin -> SDoc Source #

data UnusablePackageReason Source #

The reason why a package is unusable.

Constructors

IgnoredWithFlag	We ignored it explicitly using `-ignore-package`.
BrokenDependencies [UnitId]	This package transitively depends on a package that was never present in any of the provided databases.
CyclicDependencies [UnitId]	This package transitively depends on a package involved in a cycle. Note that the list of `UnitId` reports the direct dependencies of this package that (transitively) depended on the cycle, and not the actual cycle itself (which we report separately at high verbosity.)
IgnoredDependencies [UnitId]	This package transitively depends on a package which was ignored.
ShadowedDependencies [UnitId]	This package transitively depends on a package which was shadowed by an ABI-incompatible package.

Instances

Instances details

Outputable UnusablePackageReason Source #
Instance details Defined in GHC.Unit.State Methods ppr :: UnusablePackageReason -> SDoc Source # pprPrec :: Rational -> UnusablePackageReason -> SDoc Source #