badDepMsg mod
= hang (ptext SLIT("Interface file inconsistency:"))
- 2 (sep [ptext SLIT("home-package module") <+> quotes (ppr mod) <+> ptext SLIT("is mentioned is needed,"),
- ptext SLIT("but is not among the dependencies of interfaces directly imported by the module being compiled")])
+ 2 (sep [ptext SLIT("home-package module") <+> quotes (ppr mod) <+> ptext SLIT("is needed,"),
+ ptext SLIT("but is not listed in the dependencies of the interfaces directly imported by the module being compiled")])
-----------------------------------------------------
-- Loading type/class/value decls
; thing <- forkM doc $ do { bumpDeclStats main_name
; tcIfaceDecl ignore_prags decl }
- -- Populate the type environment with the implicitTyThings too.
- --
- -- Note [Tricky iface loop]
- -- ~~~~~~~~~~~~~~~~~~~~~~~~
- -- The delicate point here is that 'mini-env' should be
- -- buildable from 'thing' without demanding any of the things 'forkM'd
- -- by tcIfaceDecl. For example
- -- class C a where { data T a; op :: T a -> Int }
- -- We return the bindings
- -- [("C", <cls>), ("T", lookup env "T"), ("op", lookup env "op")]
- -- The call (lookup env "T") must return the tycon T without first demanding
- -- op; because getting the latter will look up T, hence loop.
- --
- -- Of course, there is no reason in principle why (lookup env "T") should demand
- -- anything do to with op, but take care:
- -- (a) implicitTyThings, and
- -- (b) getOccName of all the things returned by implicitThings,
- -- must not depend on any of the nested type-checks
- --
- -- All a bit too finely-balanced for my liking.
-
+ -- Populate the type environment with the implicitTyThings too.
+ --
+ -- Note [Tricky iface loop]
+ -- ~~~~~~~~~~~~~~~~~~~~~~~~
+ -- Summary: The delicate point here is that 'mini-env' must be
+ -- buildable from 'thing' without demanding any of the things
+ -- 'forkM'd by tcIfaceDecl.
+ --
+ -- In more detail: Consider the example
+ -- data T a = MkT { x :: T a }
+ -- The implicitTyThings of T are: [ <datacon MkT>, <selector x>]
+ -- (plus their workers, wrappers, coercions etc etc)
+ --
+ -- We want to return an environment
+ -- [ "MkT" -> <datacon MkT>, "x" -> <selector x>, ... ]
+ -- (where the "MkT" is the *Name* associated with MkT, etc.)
+ --
+ -- We do this by mapping the implict_names to the associated
+ -- TyThings. By the invariant on ifaceDeclSubBndrs and
+ -- implicitTyThings, we can use getOccName on the implicit
+ -- TyThings to make this association: each Name's OccName should
+ -- be the OccName of exactly one implictTyThing. So the key is
+ -- to define a "mini-env"
+ --
+ -- [ 'MkT' -> <datacon MkT>, 'x' -> <selector x>, ... ]
+ -- where the 'MkT' here is the *OccName* associated with MkT.
+ --
+ -- However, there is a subtlety: due to how type checking needs
+ -- to be staged, we can't poke on the forkM'd thunks inside the
+ -- implictTyThings while building this mini-env.
+ -- If we poke these thunks too early, two problems could happen:
+ -- (1) When processing mutually recursive modules across
+ -- hs-boot boundaries, poking too early will do the
+ -- type-checking before the recursive knot has been tied,
+ -- so things will be type-checked in the wrong
+ -- environment, and necessary variables won't be in
+ -- scope.
+ --
+ -- (2) Looking up one OccName in the mini_env will cause
+ -- others to be looked up, which might cause that
+ -- original one to be looked up again, and hence loop.
+ --
+ -- The code below works because of the following invariant:
+ -- getOccName on a TyThing does not force the suspended type
+ -- checks in order to extract the name. For example, we don't
+ -- poke on the "T a" type of <selector x> on the way to
+ -- extracting <selector x>'s OccName. Of course, there is no
+ -- reason in principle why getting the OccName should force the
+ -- thunks, but this means we need to be careful in
+ -- implicitTyThings and its helper functions.
+ --
+ -- All a bit too finely-balanced for my liking.
+
+ -- This mini-env and lookup function mediates between the
+ -- *Name*s n and the map from *OccName*s to the implicit TyThings
; let mini_env = mkOccEnv [(getOccName t, t) | t <- implicitTyThings thing]
lookup n = case lookupOccEnv mini_env (getOccName n) of
Just thing -> thing
Nothing ->
pprPanic "loadDecl" (ppr main_name <+> ppr n $$ ppr (decl))
- ; returnM $ (main_name, thing) : [(n, lookup n) | n <- implicit_names]
+ ; returnM $ (main_name, thing) :
+ -- uses the invariant that implicit_names and
+ -- implictTyThings are bijective
+ [(n, lookup n) | n <- implicit_names]
}
- -- We build a list from the *known* names, with (lookup n) thunks
- -- as the TyThings. That way we can extend the PTE without poking the
- -- thunks
where
doc = ptext SLIT("Declaration for") <+> ppr (ifName decl)