Safe Haskell | None |
---|---|
Language | Haskell2010 |
Package manipulation
- module PackageConfig
- data PackageState
- emptyPackageState :: PackageState
- initPackages :: DynFlags -> IO (DynFlags, [UnitId])
- readPackageConfigs :: DynFlags -> IO [(FilePath, [PackageConfig])]
- getPackageConfRefs :: DynFlags -> IO [PkgConfRef]
- resolvePackageConfig :: DynFlags -> PkgConfRef -> IO (Maybe FilePath)
- readPackageConfig :: DynFlags -> FilePath -> IO (FilePath, [PackageConfig])
- listPackageConfigMap :: DynFlags -> [PackageConfig]
- lookupPackage :: DynFlags -> UnitId -> Maybe PackageConfig
- searchPackageId :: DynFlags -> SourcePackageId -> [PackageConfig]
- getPackageDetails :: DynFlags -> UnitId -> PackageConfig
- listVisibleModuleNames :: DynFlags -> [ModuleName]
- lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, PackageConfig)]
- lookupModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult
- lookupPluginModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult
- data LookupResult
- data ModuleSuggestion
- data ModuleOrigin
- getPackageIncludePath :: DynFlags -> [UnitId] -> IO [String]
- getPackageLibraryPath :: DynFlags -> [UnitId] -> IO [String]
- getPackageLinkOpts :: DynFlags -> [UnitId] -> IO ([String], [String], [String])
- getPackageExtraCcOpts :: DynFlags -> [UnitId] -> IO [String]
- getPackageFrameworkPath :: DynFlags -> [UnitId] -> IO [String]
- getPackageFrameworks :: DynFlags -> [UnitId] -> IO [String]
- getPreloadPackagesAnd :: DynFlags -> [UnitId] -> IO [PackageConfig]
- collectIncludeDirs :: [PackageConfig] -> [FilePath]
- collectLibraryPaths :: [PackageConfig] -> [FilePath]
- collectLinkOpts :: DynFlags -> [PackageConfig] -> ([String], [String], [String])
- packageHsLibs :: DynFlags -> PackageConfig -> [String]
- unitIdPackageIdString :: DynFlags -> UnitId -> Maybe String
- pprFlag :: PackageFlag -> SDoc
- pprPackages :: DynFlags -> SDoc
- pprPackagesSimple :: DynFlags -> SDoc
- pprModuleMap :: DynFlags -> SDoc
- isDllName :: DynFlags -> UnitId -> Module -> Name -> Bool
Documentation
module PackageConfig
Reading the package config, and processing cmdline args
data PackageState Source #
initPackages :: DynFlags -> IO (DynFlags, [UnitId]) Source #
Call this after parseDynFlags
. It reads 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.
readPackageConfigs :: DynFlags -> IO [(FilePath, [PackageConfig])] Source #
getPackageConfRefs :: DynFlags -> IO [PkgConfRef] Source #
resolvePackageConfig :: DynFlags -> PkgConfRef -> IO (Maybe FilePath) Source #
readPackageConfig :: DynFlags -> FilePath -> IO (FilePath, [PackageConfig]) Source #
listPackageConfigMap :: DynFlags -> [PackageConfig] 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
lookupPackage :: DynFlags -> UnitId -> Maybe PackageConfig Source #
Find the package we know about with the given key (e.g. foo_HASH
), if any
searchPackageId :: DynFlags -> SourcePackageId -> [PackageConfig] Source #
Search for packages with a given package ID (e.g. "foo-0.1")
getPackageDetails :: DynFlags -> UnitId -> PackageConfig Source #
Looks up the package with the given id in the package state, panicing if it is not found
listVisibleModuleNames :: DynFlags -> [ModuleName] Source #
lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, PackageConfig)] Source #
Takes a ModuleName
, and if the module is in any package returns
list of modules which take that name.
lookupPluginModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult Source #
data LookupResult Source #
The result of performing a lookup
LookupFound Module PackageConfig | 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 |
LookupNotFound [ModuleSuggestion] | Nothing found, here are some suggested different names |
data ModuleSuggestion Source #
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
causepkg
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
causespkg
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. LetdepExposedPackages
be the transitive closure fromexposedPackages
of their dependencies. - When searching for a module from an 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!
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.) |
ModOrigin | Module is public, and could have come from some places. |
|
Inspecting the set of packages in scope
getPackageIncludePath :: DynFlags -> [UnitId] -> IO [String] Source #
Find all the include directories in these and the preload packages
getPackageLibraryPath :: DynFlags -> [UnitId] -> IO [String] Source #
Find all the library paths in these and the preload packages
getPackageLinkOpts :: DynFlags -> [UnitId] -> IO ([String], [String], [String]) Source #
Find all the link options in these and the preload packages, returning (package hs lib options, extra library options, other flags)
getPackageExtraCcOpts :: DynFlags -> [UnitId] -> IO [String] Source #
Find all the C-compiler options in these and the preload packages
getPackageFrameworkPath :: DynFlags -> [UnitId] -> IO [String] Source #
Find all the package framework paths in these and the preload packages
getPackageFrameworks :: DynFlags -> [UnitId] -> IO [String] Source #
Find all the package frameworks in these and the preload packages
getPreloadPackagesAnd :: DynFlags -> [UnitId] -> IO [PackageConfig] Source #
Find all the PackageConfig
in both the preload packages from DynFlags
and corresponding to the list of
PackageConfig
s
collectIncludeDirs :: [PackageConfig] -> [FilePath] Source #
collectLibraryPaths :: [PackageConfig] -> [FilePath] Source #
collectLinkOpts :: DynFlags -> [PackageConfig] -> ([String], [String], [String]) Source #
packageHsLibs :: DynFlags -> PackageConfig -> [String] Source #
Utils
pprFlag :: PackageFlag -> SDoc Source #
pprPackages :: DynFlags -> SDoc Source #
Show (very verbose) package info
pprPackagesSimple :: DynFlags -> SDoc Source #
Show simplified package info.
The idea is to only print package id, and any information that might be different from the package databases (exposure, trust)
pprModuleMap :: DynFlags -> SDoc Source #
Show the mapping of modules to where they come from.