[get rid of 'hoModules' field in data Ho
John Meacham <john@repetae.net>**20070823034312] hunk ./Ho/Binary.hs 43
-    put (Ho aa ab ac ad ae af ag ah ai aj ak al am an) = do
-	    put aa
+    put (Ho ab ac ad ae af ag ah ai aj ak al am an) = do
hunk ./Ho/Binary.hs 58
-    aa <- get
hunk ./Ho/Binary.hs 71
-    return (Ho aa ab ac ad ae af ag ah ai aj ak al am an)
+    return (Ho ab ac ad ae af ag ah ai aj ak al am an)
hunk ./Ho/Build.hs 19
-import List
+import Data.List hiding(union)
hunk ./Ho/Build.hs 233
-                    (readHo,rs) <- f (hsModuleRequires hs ++ xs) (Set.insert m ds)
-                    return (readHo,((hs,(m,fd),s):rs))
+                    (mp,readHo,rs) <- f (hsModuleRequires hs ++ xs) (Set.insert m ds)
+                    return (mp,readHo,((hs,(m,fd),s):rs))
hunk ./Ho/Build.hs 237
-                    (readHo,rs) <- f (fsts (hohModDepends hoh) ++ xs) (Set.union ss ds)
-                    return (ho `mappend` readHo,rs)
+                    (mp,readHo,rs) <- f (fsts (hohModDepends hoh) ++ xs) (Set.union ss ds)
+                    return (mp `union` mprovides hoh, ho `mappend` readHo,rs)
hunk ./Ho/Build.hs 241
-        f [] _ = return (mempty,mempty)
-    (readHo,ms) <- f (concat ms) Set.empty
+        f [] _ = return (mempty,mempty,mempty)
+        mprovides hoh = Map.fromList [ (x,hohHash hoh) | (x,_) <- hohDepends hoh]
+    (mp,readHo,ms) <- f (concat ms) Set.empty
hunk ./Ho/Build.hs 251
+
hunk ./Ho/Build.hs 257
-                mdeps = [ (m,dep) | m <- mods', Left dep <- Map.lookup m (hoModules . choHo $ cho')]
-                ldeps = Map.fromList [ x | m <- mods', Right x <- Map.lookup m (hoModules . choHo $ cho)]
-            let hoh = HoHeader { hohDepends    = [ x | (_,x,_) <- sc],
+                mdeps = [ (m,dep) | m <- mods', dep <- Map.lookup m (choModules cho')]
+                ldeps = mempty -- [] -- Map.fromList [ x | m <- mods', Right x <- Map.lookup m (hoModules . choHo $ cho)]
+            let hoh = fillInHohHash HoHeader { hohDepends    = [ x | (_,x,_) <- sc],
hunk ./Ho/Build.hs 265
-            newHo <- recordHoFile newHo [ x | (_,_,x) <- sc ] (fillInHohHash hoh)
-            f (cho' `mappend` collectedHo { choHo = mempty { hoModules = hoModules newHo }}) (readHo `mappend` newHo)  scs
-    ho <- ifunc cho readHo
-    f ho readHo scc
-
-
+            recordHoFile newHo [ x | (_,_,x) <- sc ] hoh
+            f (cho' `mappend` mempty { choModules = mprovides hoh }) (readHo `mappend` newHo)  scs
hunk ./Ho/Build.hs 268
+    cho <- ifunc cho { choModules = choModules cho `union` mp } readHo
+    f cho readHo scc
hunk ./Ho/Build.hs 272
-{-
hunk ./Ho/Build.hs 273
-findModule :: CollectedHo                                           -- ^ Accumulated Ho
-              -> [Either Module String]                             -- ^ Either a module or filename to find
-              -> (CollectedHo -> Ho -> IO CollectedHo)              -- ^ Process initial ho loaded from file
-              -> (CollectedHo -> [HsModule] -> IO (CollectedHo,Ho)) -- ^ Process set of mutually recursive modules to produce final Ho
-              -> IO (CollectedHo,Ho)                                -- ^ (Final accumulated ho,just the ho read to satisfy this command)
-findModule cho need ifunc func  = do
-    let f (Left (Module m)) = Left (Module m)
-        f (Right n) = Right (n,[(n,reverse $ 'o':'h':dropWhile (/= '.') (reverse n))])
-    (readHo,ms) <- nextModule (fmap Just . hoModules . choHo $ cho) [] mempty (map f (snub need))
-    processIOErrors
-    let mgraph =  (G.newGraph ms (fromModule . hsModuleName . fst3) (hsModuleRequires . fst3) )
-        scc = G.sccGroups mgraph
-        mgraph' =  (G.newGraph scc (fromModule . hsModuleName . fst3 . head) (concatMap ff . concatMap (hsModuleRequires . fst3)) )
-        ff n = [ fromModule . hsModuleName $ ms | gs@((ms,_,_):_) <- scc, n `elem` map (fromModule . hsModuleName . fst3) gs]
-    when (dump FD.SccModules) $ do
-        CharIO.putErrLn $ "scc modules:\n" ++ unlines ( map  (\xs -> show [ hsModuleName x | (x,y,z) <- xs ]) scc)
-        putErrLn $ drawForest (map (fmap (show . map (hsModuleName . fst3))) (G.dff mgraph'))
-    let f ho readHo [] = return (ho,readHo)
-        f ho readHo (sc:scs) = do
-            (cho',newHo) <- func ho [ hs | (hs,_,_) <- sc ]
-            let mods = [ hsModuleName hs | (hs,_,_) <- sc ]
-                mods' = snub [ Module m  | (hs,_,_) <- sc, m <- hsModuleRequires hs, Module m `notElem` mods]
-                mdeps = [ (m,dep) | m <- mods', Left dep <- Map.lookup m (hoModules . choHo $ cho')]
-                ldeps = Map.fromList [ x | m <- mods', Right x <- Map.lookup m (hoModules . choHo $ cho)]
-            let hoh = HoHeader { hohDepends    = [ x | (_,x,_) <- sc],
-                                 hohModDepends = mdeps,
-                                 hohMetaInfo   = []
-                               }
-            newHo <- return (newHo `mappend` mempty { hoLibraries = ldeps })
-            newHo <- recordHoFile newHo [ x | (_,_,x) <- sc ] hoh
-            f (cho' `mappend` collectedHo { choHo = mempty { hoModules = hoModules newHo }}) (readHo `mappend` newHo)  scs
-    ho <- ifunc cho readHo
-    f ho readHo scc
--}
hunk ./Ho/Build.hs 287
-        return $ Just (hh,ho { hoModules = fmap (const (Left (hohHash hh))) (hoExports ho) })
+        --return $ Just (hh,ho { hoModules = fmap (const (Left (hohHash hh))) (hoExports ho) })
+        return $ Just (hh,ho)
hunk ./Ho/Build.hs 365
-    -> IO Ho         -- ^ Ho updated with this recordfile dependencies
+    -> IO ()         -- ^ Ho updated with this recordfile dependencies
hunk ./Ho/Build.hs 371
-        return (ho { hoModules = fmap (const $ Left (hohHash header)) (hoExports ho) })
hunk ./Ho/Build.hs 397
-            let theho =  mapHoBodies eraseE ho { hoUsedIds = mempty, hoModules = mempty }
+            let theho =  mapHoBodies eraseE ho { hoUsedIds = mempty }
hunk ./Ho/Build.hs 403
-    return (ho { hoModules = fmap (const $ Left (hohHash header)) (hoExports ho) })
hunk ./Ho/Library.hs 143
-                    libraryHo   = ho { hoModules = Map.map (const $ Right (lname,pkgCS)) $ hoModules ho }
+                    libraryHo   = ho -- { hoModules = Map.map (const $ Right (lname,pkgCS)) $ hoModules ho }
hunk ./Ho/Type.hs 32
+    choModules :: Map.Map Module SHA1.Hash,
hunk ./Ho/Type.hs 41
+        choModules = choModules a `mappend` choModules b,
hunk ./Ho/Type.hs 50
-collectedHo = CollectedHo { choExternalNames = mempty, choHo = mempty, choVarMap = mempty }
+collectedHo = CollectedHo { choModules = mempty, choExternalNames = mempty, choHo = mempty, choVarMap = mempty }
hunk ./Ho/Type.hs 54
-    -- filled in by front end
-    hoModules :: Map.Map Module (Either SHA1.Hash (LibraryName,CheckSum)),     -- ^ Map of module to ho file, This never actually ends up in the binary file on disk, but is filled in when the file is read, libraries have no non-library dependencies.
hunk ./Ho/Type.hs 72
-    mempty = Ho mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty
+    mempty = Ho mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty mempty
hunk ./Ho/Type.hs 74
-        hoModules = hoModules a `mappend` hoModules b,