ghc-9.2.1: The GHC API

GHC.Unit.Home

Contents

Description

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

Synopsis

# Documentation

data GenHomeUnit u Source #

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

Return home unit id

Return home unit instantiations

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

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.

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.

1. 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 Source #

Map over the unit identifier for instantiating units

# Predicates

Test if we are type-checking an indefinite unit

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

Test if we are compiling a definite unit

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

Test if we are compiling by instantiating a definite unit

Test if the unit is the home unit

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

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

Test if the module comes from the home unit

Test if the module comes from the home unit

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

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

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

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

# Helpers

Make a module in home unit

Make a module in home unit

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.

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.