GHC.Unit.Home

The home unit is the unit (i.e. compiled package) that contains the module we are compiling/typechecking.

Documentation

data GenHomeUnit u

Information about the home unit (i.e., the until that will contain the modules we are compiling)

The unit identifier of the instantiating units is left open to allow switching from UnitKey (what is provided by the user) to UnitId (internal unit identifier) with homeUnitMap.

TODO: this isn't implemented yet. UnitKeys are still converted too early into UnitIds in GHC.Unit.State.readUnitDataBase

Constructors

DefiniteHomeUnit UnitId (Maybe (u, GenInstantiations u))

Definite home unit (i.e. that we can compile).

Nothing: not an instantiated unit Just (i,insts): made definite by instantiating "i" with "insts"

IndefiniteHomeUnit UnitId (GenInstantiations u)

Indefinite home unit (i.e. that we can only typecheck)

All the holes are instantiated with fake modules from the Hole unit. See Note [Representation of module/name variables] in GHC.Unit

type HomeUnit = GenHomeUnit UnitId

homeUnitId :: GenHomeUnit u -> UnitId

Return home unit id

homeUnitInstantiations :: GenHomeUnit u -> GenInstantiations u

Return home unit instantiations

homeUnitInstanceOf :: HomeUnit -> UnitId

Return the unit id of the unit that is instantiated by the home unit.

E.g. if home unit = q[A=p:B,...] we return q.

If the home unit is not an instance of another unit, we return its own unit id (it is an instance of itself if you will).

homeUnitInstanceOfMaybe :: GenHomeUnit u -> Maybe u

Return the unit id of the unit that is instantiated by the home unit.

E.g. if home unit = q[A=p:B,...] we return (Just q).

If the home unit is not an instance of another unit, we return Nothing.

homeUnitAsUnit :: HomeUnit -> Unit

Return the home unit as a normal unit.

We infer from the home unit itself the kind of unit we create: 1. If the home unit is definite, we must be compiling so we return a real unit. The definite home unit may be the result of a unit instantiation, say `p = q[A=r:X]`. In this case we could have returned a virtual unit `q[A=r:X]` but it's not what the clients of this function expect, especially because p is lost when we do this. The unit id of a virtual unit is made up internally so `unitId(q[A=r:X])` is not equal to p.

2. If the home unit is indefinite we can only create a virtual unit from it. It's ok because we must be only typechecking the home unit so we won't produce any code object that rely on the unit id of this virtual unit.

homeUnitMap :: IsUnitId v => (u -> v) -> GenHomeUnit u -> GenHomeUnit v

Map over the unit identifier for instantiating units

Predicates

isHomeUnitIndefinite :: GenHomeUnit u -> Bool

Test if we are type-checking an indefinite unit

(if it is not, we should never use on-the-fly renaming)

isHomeUnitDefinite :: GenHomeUnit u -> Bool

Test if we are compiling a definite unit

(if it is, we should never use on-the-fly renaming)

isHomeUnitInstantiating :: GenHomeUnit u -> Bool

Test if we are compiling by instantiating a definite unit

isHomeUnit :: HomeUnit -> Unit -> Bool

Test if the unit is the home unit

isHomeUnitId :: GenHomeUnit u -> UnitId -> Bool

Test if the unit-id is the home unit-id

isHomeUnitInstanceOf :: HomeUnit -> UnitId -> Bool

Test if the home unit is an instance of the given unit-id

isHomeModule :: HomeUnit -> Module -> Bool

Test if the module comes from the home unit

isHomeInstalledModule :: GenHomeUnit u -> InstalledModule -> Bool

Test if the module comes from the home unit

notHomeUnitId :: Maybe (GenHomeUnit u) -> UnitId -> Bool

Test if the unit-id is not the home unit-id

notHomeModule :: HomeUnit -> Module -> Bool

Test if a module doesn't come from the given home unit

notHomeModuleMaybe :: Maybe HomeUnit -> Module -> Bool

Test if a module doesn't come from the given home unit

notHomeInstalledModule :: GenHomeUnit u -> InstalledModule -> Bool

Test if a module doesn't come from the given home unit

notHomeInstalledModuleMaybe :: Maybe (GenHomeUnit u) -> InstalledModule -> Bool

Test if a module doesn't come from the given home unit

Helpers

mkHomeModule :: HomeUnit -> ModuleName -> Module

Make a module in home unit

mkHomeInstalledModule :: GenHomeUnit u -> ModuleName -> InstalledModule

Make a module in home unit

homeModuleInstantiation :: Maybe HomeUnit -> Module -> Module

Return the module that is used to instantiate the given home module.

If the given module isn't a module hole, return the actual home module.

E.g., the instantiating module of p:A in p[A=q[]:B] is q[]:B. the instantiating module of r:A in p[A=q[]:B] is r:A. the instantiating module of p:A in p is p:A. the instantiating module of r:A in p is r:A.

homeModuleNameInstantiation :: HomeUnit -> ModuleName -> Module

Return the module that is used to instantiate the given home module name. If the ModuleName doesn't refer to a signature, return the actual home module.

E.g., the instantiating module of A in p[A=q[]:B] is q[]:B. the instantiating module of A in p is p:A.