Development.IDE.GHC.Compat.Units

Compat module for UnitState and UnitInfo.

UnitState

data UnitState

oldInitUnits :: DynFlags -> IO DynFlags

oldInitUnits only needs to modify DynFlags for GHC <9.2 For GHC >= 9.2, we need to set the hsc_unit_env also, that is done later by initUnits

unitState :: HscEnv -> UnitState

getUnitName :: HscEnv -> UnitId -> Maybe PackageName

explicitUnits :: UnitState -> [Unit]

preloadClosureUs :: HscEnv -> PreloadUnitClosure

listVisibleModuleNames :: HscEnv -> [ModuleName]

data LookupResult

The result of performing a lookup

Constructors

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

UnitInfoMap

type UnitInfoMap = Map UnitId UnitInfo

getUnitInfoMap :: HscEnv -> UnitInfoMap

lookupUnit :: HscEnv -> Unit -> Maybe UnitInfo

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]

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

Data Unit

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

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> Module -> ShowS

show :: Module -> String

showList :: [Module] -> ShowS

Show Unit

Defined in GHC.Unit.Types

Methods

showsPrec :: Int -> Unit -> ShowS

show :: Unit -> String

showList :: [Unit] -> ShowS

Show UnitId

Defined in Development.IDE.GHC.Orphans

Methods

showsPrec :: Int -> UnitId -> ShowS

show :: UnitId -> String

showList :: [UnitId] -> ShowS

NFData Unit

Defined in GHC.Unit.Types

Methods

rnf :: Unit -> ()

Uniquable Module

Defined in GHC.Unit.Types

Methods

getUnique :: Module -> Unique

Uniquable UnitId

Defined in GHC.Unit.Types

Methods

getUnique :: UnitId -> Unique

IsUnitId UnitId

Defined in GHC.Unit.Types

Methods

unitFS :: UnitId -> FastString

Binary InstantiatedUnit

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> InstantiatedUnit -> IO ()

put :: BinHandle -> InstantiatedUnit -> IO (Bin InstantiatedUnit)

get :: BinHandle -> IO InstantiatedUnit

Binary Unit

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> Unit -> IO ()

put :: BinHandle -> Unit -> IO (Bin Unit)

get :: BinHandle -> IO Unit

Binary UnitId

Defined in GHC.Unit.Types

Methods

put_ :: BinHandle -> UnitId -> IO ()

put :: BinHandle -> UnitId -> IO (Bin UnitId)

get :: BinHandle -> IO UnitId

Outputable InstalledModule

Defined in GHC.Unit.Types

Methods

ppr :: InstalledModule -> SDoc

Outputable InstantiatedModule

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedModule -> SDoc

Outputable InstantiatedUnit

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedUnit -> SDoc

Outputable Module

Defined in GHC.Unit.Types

Methods

ppr :: Module -> SDoc

Outputable Unit

Defined in GHC.Unit.Types

Methods

ppr :: Unit -> SDoc

Outputable UnitId

Defined in GHC.Unit.Types

Methods

ppr :: UnitId -> SDoc

Eq UnitId

Defined in GHC.Unit.Types

Methods

(==) :: UnitId -> UnitId -> Bool

(/=) :: UnitId -> UnitId -> Bool

Ord Unit

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

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

defUnitId :: unit -> Definite unit

installedModule :: unit -> ModuleName -> GenModule unit

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

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])

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

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