X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fiface%2FLoadIface.lhs;h=34026a6bf6e02267065fbc7a9cabc946533764eb;hp=e4ac07506a1fb3ddd079e2038480e03370ee3e9e;hb=6a05ec5ef5373f61b7f9f5bdc344483417fa801b;hpb=6202305819577fce2b11ab509ed94422775df30e

diff --git a/compiler/iface/LoadIface.lhs b/compiler/iface/LoadIface.lhs
index e4ac075..34026a6 100644
--- a/compiler/iface/LoadIface.lhs
+++ b/compiler/iface/LoadIface.lhs
@@ -357,38 +357,72 @@ loadDecl ignore_prags mod (_version, decl)
 	; 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)