X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2FbasicTypes%2FMkId.lhs;h=b1c90b3c3615941b4d1ccf4040366cd8562d6838;hp=b28b985e7fc54c07d25c88872af51f3e7bec8f86;hb=703ca1542c8e0983cc9d8eebce6e9f3dd3fd71e2;hpb=e598b8f91d1886cd6cab2e07efa6749fe4035614

diff --git a/compiler/basicTypes/MkId.lhs b/compiler/basicTypes/MkId.lhs
index b28b985..b1c90b3 100644
--- a/compiler/basicTypes/MkId.lhs
+++ b/compiler/basicTypes/MkId.lhs
@@ -33,7 +33,7 @@ module MkId (
         -- And some particular Ids; see below for why they are wired in
         wiredInIds, ghcPrimIds,
         unsafeCoerceId, realWorldPrimId, voidArgId, nullAddrId, seqId,
-        lazyId, lazyIdUnfolding, lazyIdKey,
+        lazyId, lazyIdKey,
 
         mkRuntimeErrorApp, mkImpossibleExpr,
         rEC_CON_ERROR_ID, iRREFUT_PAT_ERROR_ID, rUNTIME_ERROR_ID,
@@ -50,7 +50,6 @@ import TysPrim
 import TysWiredIn
 import PrelRules
 import Type
-import TypeRep
 import Coercion
 import TcType
 import CoreUtils	( exprType, mkCoerce )
@@ -60,7 +59,6 @@ import TyCon
 import Class
 import VarSet
 import Name
-import OccName
 import PrimOp
 import ForeignCall
 import DataCon
@@ -70,7 +68,6 @@ import IdInfo
 import NewDemand
 import CoreSyn
 import Unique
-import Maybes
 import PrelNames
 import BasicTypes       hiding ( SuccessFlag(..) )
 import Util
@@ -904,11 +901,7 @@ nullAddrId = pcMiscPrelId nullAddrName addrPrimTy info
            mkCompulsoryUnfolding (Lit nullAddrLit)
 
 ------------------------------------------------
-seqId :: Id
--- 'seq' is very special.  See notes with
---	See DsUtils.lhs Note [Desugaring seq (1)] and
---			Note [Desugaring seq (2)] and
--- Fixity is set in LoadIface.ghcPrimIface
+seqId :: Id	-- See Note [seqId magic]
 seqId = pcMiscPrelId seqName ty info
   where
     info = noCafIdInfo `setUnfoldingInfo` mkCompulsoryUnfolding rhs
@@ -920,29 +913,72 @@ seqId = pcMiscPrelId seqName ty info
     rhs = mkLams [alphaTyVar,openBetaTyVar,x,y] (Case (Var x) x openBetaTy [(DEFAULT, [], Var y)])
 
 ------------------------------------------------
-lazyId :: Id
--- lazy :: forall a?. a? -> a?   (i.e. works for unboxed types too)
--- Used to lazify pseq:         pseq a b = a `seq` lazy b
--- 
--- Also, no strictness: by being a built-in Id, all the info about lazyId comes from here,
--- not from GHC.Base.hi.   This is important, because the strictness
--- analyser will spot it as strict!
---
--- Also no unfolding in lazyId: it gets "inlined" by a HACK in the worker/wrapperpass
---      (see WorkWrap.wwExpr)   
--- We could use inline phases to do this, but that would be vulnerable to changes in 
--- phase numbering....we must inline precisely after strictness analysis.
+lazyId :: Id	-- See Note [lazyId magic]
 lazyId = pcMiscPrelId lazyIdName ty info
   where
     info = noCafIdInfo
     ty  = mkForAllTys [alphaTyVar] (mkFunTy alphaTy alphaTy)
-
-lazyIdUnfolding :: CoreExpr     -- Used to expand 'lazyId' after strictness anal
-lazyIdUnfolding = mkLams [openAlphaTyVar,x] (Var x)
-                where
-                  [x] = mkTemplateLocals [openAlphaTy]
 \end{code}
 
+Note [seqId magic]
+~~~~~~~~~~~~~~~~~~
+'seq' is special in several ways.  
+
+a) Its second arg can have an unboxed type
+      x `seq` (v +# w)
+
+b) Its fixity is set in LoadIface.ghcPrimIface
+
+c) It has quite a bit of desugaring magic. 
+   See DsUtils.lhs Note [Desugaring seq (1)] and (2) and (3)
+
+d) There is some special rule handing: Note [RULES for seq]
+
+Note [Rules for seq]
+~~~~~~~~~~~~~~~~~~~~
+Roman found situations where he had
+      case (f n) of _ -> e
+where he knew that f (which was strict in n) would terminate if n did.
+Notice that the result of (f n) is discarded. So it makes sense to
+transform to
+      case n of _ -> e
+
+Rather than attempt some general analysis to support this, I've added
+enough support that you can do this using a rewrite rule:
+
+  RULE "f/seq" forall n.  seq (f n) e = seq n e
+
+You write that rule.  When GHC sees a case expression that discards
+its result, it mentally transforms it to a call to 'seq' and looks for
+a RULE.  (This is done in Simplify.rebuildCase.)  As usual, the
+correctness of the rule is up to you.
+
+To make this work, we need to be careful that the magical desugaring
+done in Note [seqId magic] item (c) is *not* done on the LHS of a rule.
+Or rather, we arrange to un-do it, in DsBinds.decomposeRuleLhs.
+
+
+Note [lazyId magic]
+~~~~~~~~~~~~~~~~~~~
+    lazy :: forall a?. a? -> a?   (i.e. works for unboxed types too)
+
+Used to lazify pseq:   pseq a b = a `seq` lazy b
+
+Also, no strictness: by being a built-in Id, all the info about lazyId comes from here,
+not from GHC.Base.hi.   This is important, because the strictness
+analyser will spot it as strict!
+
+Also no unfolding in lazyId: it gets "inlined" by a HACK in CorePrep.
+It's very important to do this inlining *after* unfoldings are exposed 
+in the interface file.  Otherwise, the unfolding for (say) pseq in the
+interface file will not mention 'lazy', so if we inline 'pseq' we'll totally
+miss the very thing that 'lazy' was there for in the first place.
+See Trac #3259 for a real world example.
+
+lazyId is defined in GHC.Base, so we don't *have* to inline it.  If it
+appears un-applied, we'll end up just calling it.
+
+-------------------------------------------------------------
 @realWorld#@ used to be a magic literal, \tr{void#}.  If things get
 nasty as-is, change it back to a literal (@Literal@).