LookupFound Module (UnitInfo, ModuleOrigin)	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

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

UnitInfoMap

type UnitInfoMap = Map UnitId UnitInfo #

getUnitInfoMap :: HscEnv -> UnitInfoMap Source #

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

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

A more specialized interface, which doesn't require a UnitState (so it can be used while we're initializing DynFlags)

Parameters: * a boolean specifying whether or not to look for on-the-fly renamed interfaces * a UnitInfoMap * a PreloadUnitClosure

UnitInfo

type UnitInfo = GenUnitInfo UnitId #

Information about an installed unit (units are identified by their internal UnitId)

unitExposedModules :: GenericUnitInfo compid srcpkgid srcpkgname uid modulename mod -> [(modulename, Maybe mod)] #

Modules exposed by the unit.

A module can be re-exported from another package. In this case, we indicate the module origin in the second parameter.

unitDepends :: GenericUnitInfo compid srcpkgid srcpkgname uid modulename mod -> [uid] #

Identifiers of the units this one depends on

unitHaddockInterfaces :: UnitInfo -> [FilePath] Source #

mkUnit :: UnitInfo -> Unit #

Make a Unit from a UnitInfo

If the unit is definite, make a RealUnit from unitId field.

If the unit is indefinite, make a VirtUnit from unitInstanceOf and unitInstantiations fields. Note that in this case we don't keep track of unitId. It can be retrieved later with "improvement", i.e. matching on `unitInstanceOf/unitInstantiations` fields (see Note [About units] in GHC.Unit).

unitPackageNameString :: GenUnitInfo u -> String #

unitPackageVersion :: GenericUnitInfo compid srcpkgid srcpkgname uid modulename mod -> Version #

Source package version

UnitId helpers

data UnitId #

A UnitId identifies a built library in a database and is used to generate unique symbols, etc. It's usually of the form:

pkgname-1.2:libname+hash

These UnitId are provided to us via the -this-unit-id flag.

The library in question may be definite or indefinite; if it is indefinite, none of the holes have been filled (we never install partially instantiated libraries as we can cheaply instantiate them on-the-fly, cf VirtUnit). Put another way, an installed unit id is either fully instantiated, or not instantiated at all.

Instances

Instances details

Data Unit
Instance details Defined in GHC.Unit.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unit -> c Unit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Unit # toConstr :: Unit -> Constr # dataTypeOf :: Unit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Unit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unit) # gmapT :: (forall b. Data b => b -> b) -> Unit -> Unit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r # gmapQ :: (forall d. Data d => d -> u) -> Unit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Unit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unit -> m Unit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit -> m Unit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit -> m Unit #
Show Module Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show Unit
Instance details Defined in GHC.Unit.Types Methods showsPrec :: Int -> Unit -> ShowS # show :: Unit -> String # showList :: [Unit] -> ShowS #
Show UnitId Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> UnitId -> ShowS # show :: UnitId -> String # showList :: [UnitId] -> ShowS #
NFData Unit
Instance details Defined in GHC.Unit.Types Methods rnf :: Unit -> () #
Uniquable Module
Instance details Defined in GHC.Unit.Types Methods getUnique :: Module -> Unique #
Uniquable UnitId
Instance details Defined in GHC.Unit.Types Methods getUnique :: UnitId -> Unique #
IsUnitId UnitId
Instance details Defined in GHC.Unit.Types Methods unitFS :: UnitId -> FastString #
Binary InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> InstantiatedUnit -> IO () # put :: BinHandle -> InstantiatedUnit -> IO (Bin InstantiatedUnit) # get :: BinHandle -> IO InstantiatedUnit #
Binary Unit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> Unit -> IO () # put :: BinHandle -> Unit -> IO (Bin Unit) # get :: BinHandle -> IO Unit #
Binary UnitId
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> UnitId -> IO () # put :: BinHandle -> UnitId -> IO (Bin UnitId) # get :: BinHandle -> IO UnitId #
Outputable InstalledModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstalledModule -> SDoc #
Outputable InstantiatedModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc #
Outputable InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedUnit -> SDoc #
Outputable Module
Instance details Defined in GHC.Unit.Types Methods ppr :: Module -> SDoc #
Outputable Unit
Instance details Defined in GHC.Unit.Types Methods ppr :: Unit -> SDoc #
Outputable UnitId
Instance details Defined in GHC.Unit.Types Methods ppr :: UnitId -> SDoc #
Eq UnitId
Instance details Defined in GHC.Unit.Types Methods (==) :: UnitId -> UnitId -> Bool # (/=) :: UnitId -> UnitId -> Bool #
Ord Unit
Instance details Defined in GHC.Unit.Types Methods compare :: Unit -> Unit -> Ordering # (<) :: Unit -> Unit -> Bool # (<=) :: Unit -> Unit -> Bool # (>) :: Unit -> Unit -> Bool # (>=) :: Unit -> Unit -> Bool # max :: Unit -> Unit -> Unit # min :: Unit -> Unit -> Unit #
Ord UnitId
Instance details Defined in GHC.Unit.Types 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 #

type Unit = GenUnit UnitId #

unitString :: IsUnitId u => u -> String #

stringToUnit :: String -> Unit #

definiteUnitId :: Definite uid -> GenUnit uid Source #

defUnitId :: unit -> Definite unit Source #

installedModule :: unit -> ModuleName -> GenModule unit Source #

Module

toUnitId :: Unit -> UnitId #

Return the UnitId of the Unit. For on-the-fly instantiated units, return the UnitId of the indefinite unit this unit is an instance of.

moduleUnitId :: Module -> UnitId Source #

moduleUnit :: GenModule unit -> unit #

Unit the module belongs to

ExternalPackageState

data ExternalPackageState #

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

Constructors

EPS

Fields

eps_is_boot :: !(ModuleNameEnv ModuleNameWithIsBoot)
In OneShot mode (only), home-package modules accumulate in the external package state, and are sucked in lazily. For these home-pkg modules (only) we need to record which are boot modules. We set this field after loading all the explicitly-imported interfaces, but before doing anything else
The ModuleName part is not necessary, but it's useful for debug prints, and it's convenient because this field comes direct from imp_dep_mods
eps_PIT :: !PackageIfaceTable
The ModIface_s for modules in external packages whose interfaces we have opened. The declarations in these interface files are held in the eps_decls, eps_inst_env, eps_fam_inst_env and eps_rules fields of this record, not in the mi_decls fields of the interface we have sucked in.
What is in the PIT is:
- The Module
- Fingerprint info
- Its exports
- Fixities
- Deprecations and warnings
eps_free_holes :: InstalledModuleEnv (UniqDSet ModuleName)
Cache for mi_free_holes. Ordinarily, we can rely on the eps_PIT for this information, EXCEPT that when we do dependency analysis, we need to look at the Dependencies of our imports to determine what their precise free holes are (moduleFreeHolesPrecise). We don't want to repeatedly reread in the interface for every import, so cache it here. When the PIT gets filled in we can drop these entries.
eps_PTE :: !PackageTypeEnv
Result of typechecking all the external package interface files we have sucked in. The domain of the mapping is external-package modules
eps_inst_env :: !PackageInstEnv
The total InstEnv accumulated from all the external-package modules
eps_fam_inst_env :: !PackageFamInstEnv
The total FamInstEnv accumulated from all the external-package modules
eps_rule_base :: !PackageRuleBase
The total RuleEnv accumulated from all the external-package modules
eps_ann_env :: !PackageAnnEnv
The total AnnEnv accumulated from all the external-package modules
eps_complete_matches :: !PackageCompleteMatches
The total CompleteMatches accumulated from all the external-package modules
eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv)
The family instances accumulated from external packages, keyed off the module that declared them
eps_stats :: !EpsStats
Stastics about what was loaded from external packages

Utils

filterInplaceUnits :: [UnitId] -> [PackageFlag] -> ([UnitId], [PackageFlag]) Source #

type FinderCache = InstalledModuleEnv InstalledFindResult #

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.

showSDocForUser' :: HscEnv -> PrintUnqualified -> SDoc -> String Source #

findImportedModule :: HscEnv -> ModuleName -> IO (Maybe Module) Source #