[lots of code cleanups
John Meacham <john@repetae.net>**20060814040549] hunk ./E/E.hs 69
-    | ELetRec [(TVr, E)] E
+    | ELetRec { eDefs :: [(TVr, E)], eBody :: E }
hunk ./E/LambdaLift.hs 28
-{-
--- | pull lets from just in definitions to top level, as they can obscure lambdas.
-flattenSC :: SC -> SC
-flattenSC (SC v cs) = SC v (concatMap f cs) where
-    f (t,[],ELetRec ds e) = fd (t,e):map fd ds
-    f (t,as,e) = [(t,as,e)]
-    fd (t,e) =  let (c,b) = fromLam e in (t,b,c)
-
-lambdaLiftE stats dt e = fmap scToE (lambdaLift stats dt (eToSC dt e))
--}
-
-data S = S { funcName :: Name, topVars :: IdSet, isStrict :: Bool, declEnv :: [(TVr,E)] }
+data S = S {
+    funcName :: Name,
+    topVars :: IdSet,
+    isStrict :: Bool,
+    declEnv :: [(TVr,E)]
+    }
hunk ./E/LambdaLift.hs 44
-lambdaLift :: Stats -> Program -> IO Program
-lambdaLift stats prog@Program { progDataTable = dataTable, progCombinators = cs } = do
+lambdaLift ::  Program -> IO Program
+lambdaLift prog@Program { progDataTable = dataTable, progCombinators = cs } = do
hunk ./E/LambdaLift.hs 48
+    statRef <- newIORef mempty
hunk ./E/LambdaLift.hs 51
-            tickStat stats stat
+            modifyIORef statRef (mappend stat)
hunk ./E/LambdaLift.hs 180
-    return $ prog { progCombinators =  ncs }
+    nstat <- readIORef statRef
+    return $ prog { progCombinators =  ncs, progStats = progStats prog `mappend` nstat }
hunk ./E/LambdaLift.hs 185
+shouldLift ELetRec {eBody = e } = shouldLift e
hunk ./E/LambdaLift.hs 202
-
---        h ((t,e):ds) rest ds' | shouldLift e = do
---            let fvs =  freeVars e
---            gs <- asks topVars
---            let fvs' = filter (not . (`Set.member` gs) . tvrIdent) fvs
---                fvs'' = reverse $ topSort $ newGraph fvs' tvrIdent freeVars
---            case fvs'' of
---                [] -> doLift t e (h ds rest ds')
---                fs -> doBigLift e fs (\e'' -> h ds rest ((t,e''):ds'))
-
-
---        f e = do
---            st <- asks isStrict
---            if (isELam e || (shouldLift e && not st)) then do
---                let (fvs :: [TVr]) = freeVars e
---                (gs :: Set.Set Int) <- asks topVars
---                let fvs' = filter (not . (`Set.member` gs) . tvrIdent) fvs
---                    fvs'' = reverse $ topSort $ newGraph fvs' tvrIdent freeVars
---                doBigLift e fvs'' return
---             else emapE' f e
-
hunk ./E/LetFloat.hs 20
-import E.Subst
-import E.Program
hunk ./E/LetFloat.hs 21
-import Info.Info as Info hiding(member,delete)
+import E.Program
hunk ./E/LetFloat.hs 23
+import E.Subst
hunk ./E/LetFloat.hs 28
+import Info.Info as Info hiding(member,delete)
+import Info.Types
+import Name.Id
hunk ./E/LetFloat.hs 34
-import qualified CharIO as C
-import qualified Util.Graph as G
hunk ./E/LetFloat.hs 37
-import Util.UniqueMonad
hunk ./E/LetFloat.hs 38
-import Name.Id
-import Info.Types
-import qualified CharIO
+import Util.UniqueMonad
+import qualified Util.Graph as G
hunk ./E/LetFloat.hs 66
-    g (ELetRec ds e) = do
+    g ELetRec { eDefs = ds, eBody = e } = do
hunk ./E/LetFloat.hs 96
-    h (ELetRec ds e) = do
+    h ELetRec { eDefs = ds, eBody = e } = do
hunk ./E/LetFloat.hs 116
-            ELetRec ds' (ELetRec ds'' x') -> do
+            ELetRec { eDefs = ds', eBody = ELetRec { eDefs = ds'', eBody = x' } } -> do
hunk ./E/LetFloat.hs 122
-            ELetRec ds' x' | not (List.null xs) -> do
+            ELetRec { eDefs = ds', eBody = x' } | not (List.null xs) -> do
hunk ./E/LetFloat.hs 125
-            ELetRec ds x' -> do
+            ELetRec { eDefs = ds, eBody = x' } -> do
hunk ./E/LetFloat.hs 128
-    at (ELetRec ds e) = do
+    at ELetRec { eDefs = ds, eBody = e } = do
hunk ./E/LetFloat.hs 191
-    f (ELetRec ds e) xs = g (G.scc $  G.newGraph [ (d,bindingFreeVars x y) | d@(x,y) <- ds ] (tvrIdent . fst . fst) (idSetToList . snd) ) xs where
+    f ELetRec { eDefs = ds, eBody = e } xs = g (G.scc $  G.newGraph [ (d,bindingFreeVars x y) | d@(x,y) <- ds ] (tvrIdent . fst . fst) (idSetToList . snd) ) xs where
hunk ./E/LetFloat.hs 293
-        g n (ELetRec ds e) imap = dds (map G.fromScc $ decomposeDs ds) [] e imap where
+        g n ELetRec { eDefs = ds, eBody = e } imap = dds (map G.fromScc $ decomposeDs ds) [] e imap where
hunk ./E/LetFloat.hs 312
-    let dofloat (ELetRec ds e) = do
+    let dofloat ELetRec { eDefs = ds, eBody = e } = do
hunk ./E/LetFloat.hs 341
-                    ELetRec ds e -> (e,ds++snds fs)
+                    ELetRec { eDefs = ds, eBody = e } -> (e,ds++snds fs)
hunk ./E/LetFloat.hs 378
-    f (ELetRec ds e) = do
+    f ELetRec { eDefs = ds, eBody = e } = do
hunk ./E/Values.hs 7
-import qualified Data.Map as Map
-import qualified Data.Set as Set
hunk ./E/Values.hs 9
-import Support.CanType
-import Support.Tuple
hunk ./E/Values.hs 14
-import qualified Info.Info as Info
-import Support.FreeVars
hunk ./E/Values.hs 15
+import Name.Id
hunk ./E/Values.hs 19
-import Name.Id
+import Support.CanType
+import Support.FreeVars
+import Support.Tuple
hunk ./E/Values.hs 23
+import qualified Info.Info as Info
hunk ./Main.hs 627
-        finalStats <- Stats.new
-        prog <- transformProgram transformParms { transformCategory = "LambdaLift", transformDumpProgress = dump FD.Progress, transformOperation = lambdaLift finalStats } prog
-        wdump FD.Progress $ Stats.print "PostLifting" finalStats
+        prog <- transformProgram transformParms { transformCategory = "LambdaLift", transformDumpProgress = dump FD.Progress, transformOperation = lambdaLift } prog
hunk ./Main.hs 663
+
+    -- We should float inward right before lambda lifting so that when a case statement is lifted out, it takes any local definitions with it.
+--    prog <- transformProgram transformParms {
+--        transformCategory = "FloatInward",
+--        transformDumpProgress = dump FD.Progress,
+--        transformOperation = programFloatInward
+--        } prog
hunk ./Main.hs 672
-    finalStats <- Stats.new
-    prog <- transformProgram transformParms { transformCategory = "LambdaLift", transformDumpProgress = dump FD.Progress, transformOperation = lambdaLift finalStats } prog
+    prog <- transformProgram transformParms { transformCategory = "LambdaLift", transformDumpProgress = dump FD.Progress, transformOperation = lambdaLift } prog
hunk ./Main.hs 674
+    finalStats <- Stats.new
hunk ./Main.hs 1082
+