[move all type checking info to its own type
John Meacham <john@repetae.net>**20090711044355
 Ignore-this: e96bee644197fbe86037847abb47b662
] hunk ./src/FrontEnd/FrontEnd.hs 8
+import Data.Monoid
hunk ./src/FrontEnd/FrontEnd.hs 45
-    ms <- determineExports [ (x,y,z) | (x,(y,z)) <- Map.toList $ hoDefs $ hoExp $ choHo ho] (Map.toList $ hoExports $ hoExp $ choHo ho) ms
-    (ho',tiData) <- Tc.tiModules' ho ms
-    func ho ho' tiData
+    ms <- determineExports [ (x,y,z) | (x,(y,z)) <- Map.toList $ hoDefs $ hoTcInfo $ choHo ho] (Map.toList $ hoExports $ hoTcInfo $ choHo ho) ms
+    --(ho',tiData) <- Tc.tiModules' ho ms
+    (htc,tiData) <- Tc.tiModules (hoTcInfo (choHo ho)) ms
+    func ho mempty { hoTcInfo = htc } tiData
+    --func ho ho' tiData
hunk ./src/FrontEnd/Rename.hs 1
-module FrontEnd.Rename(unRename, collectDefsHsModule, renameModule, FieldMap, renameStatement ) where
+module FrontEnd.Rename(unRename, collectDefsHsModule, renameModule, FieldMap(..), renameStatement ) where
hunk ./src/FrontEnd/Rename.hs 31
-type FieldMap =  (Map.Map Name Int,Map.Map Name [(Name,Int)])
+data FieldMap = FieldMap (Map.Map Name Int) (Map.Map Name [(Name,Int)])
+
+instance Monoid FieldMap where
+    mempty = FieldMap mempty mempty
+    mappend (FieldMap a b) (FieldMap c d) = FieldMap (a `mappend` c) (b `mappend` d)
hunk ./src/FrontEnd/Rename.hs 463
-buildRecPat (amp,fls) n us = case Map.lookup (toName DataConstructor n) amp of
+buildRecPat (FieldMap amp fls) n us = case Map.lookup (toName DataConstructor n) amp of
hunk ./src/FrontEnd/Rename.hs 574
-buildRecConstr (amp,fls) n us = do
+buildRecConstr (FieldMap amp fls) n us = do
hunk ./src/FrontEnd/Rename.hs 591
-buildRecUpdate (amp,fls) n us = do
+buildRecUpdate (FieldMap amp fls) n us = do
hunk ./src/FrontEnd/Tc/Module.hs 1
-module FrontEnd.Tc.Module (tiModules',TiData(..)) where
+module FrontEnd.Tc.Module (tiModules,TiData(..)) where
hunk ./src/FrontEnd/Tc/Module.hs 14
-import DataConstructors
hunk ./src/FrontEnd/Tc/Module.hs 30
-import Ho.Collected
hunk ./src/FrontEnd/Tc/Module.hs 67
+buildFieldMap :: [ModInfo] -> FieldMap
+buildFieldMap ms = FieldMap ans' ans where
+        allDefs = [ (x,z) | (x,_,z) <- concat $ map modInfoDefs ms, nameType x == DataConstructor ]
+        ans = Map.fromList $ sortGroupUnderFG fst snd $ concat [ [ (y,(x,i)) |  y <- ys | i <- [0..] ]  | (x,ys) <-  allDefs ]
+        ans' = Map.fromList $ concatMap modInfoConsArity ms
+
hunk ./src/FrontEnd/Tc/Module.hs 74
+{-
hunk ./src/FrontEnd/Tc/Module.hs 81
+-}
hunk ./src/FrontEnd/Tc/Module.hs 110
-tiModules' ::  CollectedHo -> [ModInfo] -> IO (Ho,TiData)
-tiModules' cho ms = do
-    let me = choHo cho
-        hoB = hoBuild me
+tiModules ::  HoTcInfo -> [ModInfo] -> IO (HoTcInfo,TiData)
+tiModules htc ms = do
hunk ./src/FrontEnd/Tc/Module.hs 114
-    let importClassHierarchy = hoClassHierarchy hoB
-        importKindEnv = hoKinds hoB
+    let importClassHierarchy = hoClassHierarchy htc
+        importKindEnv = hoKinds htc
hunk ./src/FrontEnd/Tc/Module.hs 118
-    let fieldMap = buildFieldMap me ms
hunk ./src/FrontEnd/Tc/Module.hs 119
-    ms <- mapM (processModule fieldMap) ms
+    ms <- mapM (processModule (hoFieldMap htc)) ms
hunk ./src/FrontEnd/Tc/Module.hs 121
-    let fixityMap = thisFixityMap  `mappend` hoFixities hoB
+    let fixityMap = thisFixityMap  `mappend` hoFixities htc
hunk ./src/FrontEnd/Tc/Module.hs 123
-    let ts = thisTypeSynonyms `mappend` hoTypeSynonyms hoB
+    let ts = thisTypeSynonyms `mappend` hoTypeSynonyms htc
hunk ./src/FrontEnd/Tc/Module.hs 220
-        putStrLn $ PPrint.render $ pprintEnvMap (sigEnv `mappend` localDConsEnv `mappend` hoAssumps hoB)
+        putStrLn $ PPrint.render $ pprintEnvMap (sigEnv `mappend` localDConsEnv `mappend` hoAssumps htc)
hunk ./src/FrontEnd/Tc/Module.hs 227
-        tcInfoEnv = hoAssumps hoB `mappend` localDConsEnv, -- (importVarEnv `mappend` globalDConsEnv),
+        tcInfoEnv = hoAssumps htc `mappend` localDConsEnv, -- (importVarEnv `mappend` globalDConsEnv),
hunk ./src/FrontEnd/Tc/Module.hs 262
-    let hoBld = mempty {
+    let hoEx = HoTcInfo {
+            hoExports = Map.fromList [ (modInfoName m,modInfoExport m) | m <- ms ],
+            hoDefs =  Map.fromList [ (x,(y,filter (`member` allExports) z)) | (x,y,z) <- concat $ map modInfoDefs ms, x `member` allExports],
hunk ./src/FrontEnd/Tc/Module.hs 268
-            hoKinds = externalKindEnv,
hunk ./src/FrontEnd/Tc/Module.hs 269
+            hoKinds = externalKindEnv,
hunk ./src/FrontEnd/Tc/Module.hs 271
+            hoFieldMap = buildFieldMap ms,
hunk ./src/FrontEnd/Tc/Module.hs 274
-        hoEx = mempty {
-            hoExports = Map.fromList [ (modInfoName m,modInfoExport m) | m <- ms ],
-            hoDefs =  Map.fromList [ (x,(y,filter (`member` allExports) z)) | (x,y,z) <- concat $ map modInfoDefs ms, x `member` allExports]
-        }
hunk ./src/FrontEnd/Tc/Module.hs 283
-    return (mempty { hoBuild = hoBld, hoExp = hoEx },tiData)
+    return (hoEx,tiData)
hunk ./src/Ho/Binary.hs 11
+import FrontEnd.Rename(FieldMap(..))
hunk ./src/Ho/Binary.hs 15
-instance Binary HoBuild where
-    put (HoBuild ae af ag ah ai ak al am) = do
-	    putMap ae
-	    put af
-	    put ag
-	    put ah
-	    put ai
-	    put ak
-	    put al
-	    put am
-    get = do
-    ae <- getMap
-    af <- get
-    ag <- get
-    ah <- get
-    ai <- get
-    ak <- get
-    al <- get
-    am <- get
-    return (HoBuild ae af ag ah ai ak al am)
hunk ./src/Ho/Binary.hs 17
-instance Binary HoExp where
-    put (HoExp ac ad) = do
-	    put ac
+
+instance Binary FieldMap where
+    put (FieldMap ac ad) = do
+	    putMap ac
hunk ./src/Ho/Binary.hs 23
-    ac <- get
+    ac <- getMap
hunk ./src/Ho/Binary.hs 25
-    return (HoExp ac ad)
+    return (FieldMap ac ad)
hunk ./src/Ho/Binary.hs 72
+
+
+instance Data.Binary.Binary HoTcInfo where
+    put (HoTcInfo aa ab ac ad ae af ag ah) = do
+	    Data.Binary.put aa
+	    putMap ab
+	    putMap ac
+	    Data.Binary.put ad
+	    Data.Binary.put ae
+	    Data.Binary.put af
+	    Data.Binary.put ag
+	    Data.Binary.put ah
+    get = do
+    aa <- get
+    ab <- getMap
+    ac <- getMap
+    ad <- get
+    ae <- get
+    af <- get
+    ag <- get
+    ah <- get
+    return (HoTcInfo aa ab ac ad ae af ag ah)
+
+
+instance Data.Binary.Binary HoBuild where
+    put (HoBuild aa ab ac) = do
+	    Data.Binary.put aa
+	    Data.Binary.put ab
+	    Data.Binary.put ac
+    get = do
+    aa <- get
+    ab <- get
+    ac <- get
+    return (HoBuild aa ab ac)
+
hunk ./src/Ho/Build.hs 106
-current_version = 1
+current_version = 2
hunk ./src/Ho/Build.hs 239
+data CompNode = CompNode !HoHash [CompNode] !(IORef CompUnit)
+
+type CompUnitGraph = [(HoHash,([HoHash],CompUnit))]
+
+data CompUnit
+    = CompHo   (Maybe String)  HoHeader HoIDeps Ho
+    | CompSources [SourceCode]
+    | CompPhony
+    | CompCollected CollectedHo CompUnit
+    | CompTCed Bool CompUnit
+
hunk ./src/Ho/Build.hs 256
-
hunk ./src/Ho/Build.hs 259
-data CompUnit
-    = CompHo   (Maybe String)  HoHeader HoIDeps Ho
-    | CompSources [SourceCode]
-    | CompPhony
-    | CompCollected CollectedHo CompUnit
-
hunk ./src/Ho/Build.hs 278
-type CompUnitGraph = [(HoHash,([HoHash],CompUnit))]
hunk ./src/Ho/Build.hs 397
-data CompNode = CompNode HoHash [CompNode] (IORef CompUnit)
hunk ./src/Ho/Build.hs 398
+-- turn the list of CompUnits into a true mutable graph.
hunk ./src/Ho/Build.hs 409
+-- take the list of CompNodes and what modules we want and create a root node
+-- that will reach all dependencies when compiled.
+
hunk ./src/Ho/Build.hs 418
+
+-- typechecking, this goes through and typechecks everything. It returns 'True' if there were errors.
+{-
+typeCheckGraph :: CompNode -> IO Bool
+typeCheckGraph cn = do
+    cur <- newMVar (1::Int)
+    let countNodes (CompNode hh deps ref) = readIORef ref >>= \cn -> case cn of
+            CompCollected _ _ -> return Set.empty
+            CompPhony         -> mconcat `fmap` mapM countNodes deps
+            CompHo _ hoh idep _  -> do ds <- mconcat `fmap` mapM countNodes deps
+                                       return $ ds `Set.union` Set.fromList (map (show.fst) (hoDepends idep))
+            CompSources sc    -> do ds <- mconcat `fmap` mapM countNodes deps
+                                    return $ ds `Set.union` Set.fromList (map sourceIdent sc)
+        tickProgress = modifyMVar cur $ \val -> return (val+1,val)
+    maxModules <- Set.size `fmap` countNodes cn
+    let showProgress ms = forM_ ms $ \modName ->
+          do curModule <- tickProgress cur
+             printf fmtStr curModule maxModules (show $ hsModuleName modName)
+        fmtStr = printf "[%%%dd of %*d] %%s]" fmtLen fmtLen maxModules where
+            fmtLen = ceiling (logBase 10 (fromIntegral maxModules+1) :: Double) :: Int
+    let f (CompNode hh deps ref) = readIORef ref >>= \cn -> case cn of
+            CompCollected ch _ -> return False
+            CompTCed errors _ -> return errors
+            CompPhony -> do
+                xs <- or `fmap` mapM f deps
+                writeIORef ref (CompTCed xs CompPhony)
+                return xs
+            CompHo {} -> return False
+            CompSources sc -> do
+                let hdep = [ h | CompNode h _ _ <- deps]
+                cho <- mconcat `fmap` mapM f deps
+                modules <- forM sc $ \x -> case x of
+                    SourceParsed { sourceHash = h,sourceModule = mod } -> return (h,mod)
+                    SourceRaw { sourceHash = h,sourceLBS = lbs, sourceFP = fp } -> do
+                        mod <- parseHsSource fp lbs
+                        return (h,mod)
+                showProgress (snds modules)
+--                (cho',newHo) <- func cho (snds modules)
+--
+--                let hoh = HoHeader {
+--                             hohVersion = current_version,
+--                             hohName = Left mgName,
+--                             hohHash       = hh,
+--                             hohArchDeps = [],
+--                             hohLibDeps   = []
+--                             }
+--                    idep = HoIDeps {
+--                            hoIDeps = Map.fromList [ (h,(hsModuleName mod,hsModuleRequires mod)) | (h,mod) <- modules],
+--                            hoDepends    = [ (hsModuleName mod,h) | (h,mod) <- modules],
+--                            hoModDepends = hdep
+--                            }
+--                    (mgName:_) = sort $ map (hsModuleName . snd) modules
+--
+--                recordHoFile newHo idep (map sourceHoName sc) hoh
+--                writeIORef ref (CompCollected cho' (CompHo Nothing hoh idep newHo))
+--                return cho'
+    f cn
+
+-}
hunk ./src/Ho/Build.hs 563
-    return (hoh,fc cff_idep,mempty { hoExp = fc cff_defs, hoBuild = fc cff_core})
+    return (hoh,fc cff_idep,mempty { hoTcInfo = fc cff_defs, hoBuild = fc cff_core})
hunk ./src/Ho/Build.hs 606
-                    (cff_defs, compress $ encode $ hoExp theho),
+                    (cff_defs, compress $ encode $ hoTcInfo theho),
hunk ./src/Ho/Build.hs 759
-        hoE = hoExp ho
+        hoE = hoTcInfo ho
hunk ./src/Ho/Build.hs 768
-    putStrLn $ "hoAssumps:" <+> tshow (size $ hoAssumps hoB)
-    putStrLn $ "hoFixities:" <+> tshow (size $  hoFixities hoB)
-    putStrLn $ "hoKinds:" <+> tshow (size $  hoKinds hoB)
-    putStrLn $ "hoClassHierarchy:" <+> tshow (size $  hoClassHierarchy hoB)
-    putStrLn $ "hoTypeSynonyms:" <+> tshow (size $  hoTypeSynonyms hoB)
+    putStrLn $ "hoAssumps:" <+> tshow (size $ hoAssumps hoE)
+    putStrLn $ "hoFixities:" <+> tshow (size $  hoFixities hoE)
+    putStrLn $ "hoKinds:" <+> tshow (size $  hoKinds hoE)
+    putStrLn $ "hoClassHierarchy:" <+> tshow (size $  hoClassHierarchy hoE)
+    putStrLn $ "hoTypeSynonyms:" <+> tshow (size $  hoTypeSynonyms hoE)
hunk ./src/Ho/Build.hs 784
-        CharIO.putStrLn $  (pprint $ hoKinds hoB :: String)
+        CharIO.putStrLn $  (pprint $ hoKinds hoE :: String)
hunk ./src/Ho/Build.hs 787
-        printClassSummary (hoClassHierarchy hoB)
+        printClassSummary (hoClassHierarchy hoE)
hunk ./src/Ho/Build.hs 790
-             printClassHierarchy (hoClassHierarchy hoB)}
+             printClassHierarchy (hoClassHierarchy hoE)}
hunk ./src/Ho/Build.hs 801
-        putStrLn $ PPrint.render $ pprint (hoAssumps hoB)
+        putStrLn $ PPrint.render $ pprint (hoAssumps hoE)
hunk ./src/Ho/Collected.hs 28
-choClassHierarchy = hoClassHierarchy . hoBuild . choHo
-choTypeSynonyms = hoTypeSynonyms . hoBuild . choHo
-choFixities = hoFixities . hoBuild . choHo
-choAssumps = hoAssumps . hoBuild . choHo
+choClassHierarchy = hoClassHierarchy . hoTcInfo . choHo
+choTypeSynonyms = hoTypeSynonyms . hoTcInfo . choHo
+choFixities = hoFixities . hoTcInfo . choHo
+choAssumps = hoAssumps . hoTcInfo . choHo
hunk ./src/Ho/Type.hs 24
+import FrontEnd.Rename(FieldMap())
hunk ./src/Ho/Type.hs 90
+--    hoModuleDeps :: Map.Map ModuleGroup [ModuleGroup],
hunk ./src/Ho/Type.hs 94
--- data only needed for name resolution
-data HoExp = HoExp {
+data CollectedTc = CollectedTc {
+    ctcClassHierarchy :: ClassHierarchy,
+    ctcInfo :: HoTcInfo
+    }
+    {-! derive: update, Monoid !-}
+
+-- data only needed for type checking.
+data HoTcInfo = HoTcInfo {
hunk ./src/Ho/Type.hs 103
-    hoDefs :: Map.Map Name (SrcLoc,[Name])
+    hoDefs :: Map.Map Name (SrcLoc,[Name]),
+    hoAssumps :: Map.Map Name Type,        -- used for typechecking
+    hoFixities :: FixityMap,
+    hoKinds :: KindEnv,                    -- used for typechecking
+    hoTypeSynonyms :: TypeSynonyms,
+    hoClassHierarchy :: ClassHierarchy,
+    hoFieldMap :: FieldMap
hunk ./src/Ho/Type.hs 111
+    {-! derive: update, Monoid !-}
hunk ./src/Ho/Type.hs 113
--- classes are used by both the core transformations and front end typechecking
--- so they are in their own section
+-- classes and the datatable are used by both the core transformations and
+-- front end typechecking so they are in their own section
hunk ./src/Ho/Type.hs 116
+-- this needs datatable
hunk ./src/Ho/Type.hs 119
-    } deriving(Binary)
+    } deriving(Binary,Monoid)
hunk ./src/Ho/Type.hs 122
-    hoAssumps :: Map.Map Name Type,        -- used for typechecking
-    hoFixities :: FixityMap,
-    hoKinds :: KindEnv,                      -- used for typechecking
-    hoClassHierarchy :: ClassHierarchy,
-    hoTypeSynonyms :: TypeSynonyms,
hunk ./src/Ho/Type.hs 127
-    {-! derive: update !-}
+    {-! derive: update, Monoid !-}
hunk ./src/Ho/Type.hs 130
-    hoExp :: HoExp,
+    hoTcInfo :: HoTcInfo,
hunk ./src/Ho/Type.hs 133
-    {-! derive: update !-}
+    {-! derive: update, Monoid !-}
hunk ./src/Ho/Type.hs 135
+{-
hunk ./src/Ho/Type.hs 139
-        hoExp = hoExp a `mappend` hoExp b,
+        hoTcInfo = hoTcInfo a `mappend` hoTcInfo b,
hunk ./src/Ho/Type.hs 143
-instance Monoid HoExp where
-    mempty = HoExp mempty mempty
-    mappend a b = HoExp {
+instance Monoid HoTcInfo where
+    mempty = HoTcInfo mempty mempty
+    mappend a b = HoTcInfo {
hunk ./src/Ho/Type.hs 164
-
+ -}
hunk ./src/Interactive.hs 69
-    stateHo :: HoBuild,
+    stateHo :: HoTcInfo,
hunk ./src/Interactive.hs 101
-    hoE = hoExp $ choHo cho
+    hoE = hoTcInfo $ choHo cho
hunk ./src/Interactive.hs 148
-    ptype k | Just r <- Map.lookup k (hoAssumps hoB) = show (pprint r:: PP.Doc)
-    ptype x | nameType x == ClassName = hsep (map kindShow $ kindOfClass x (hoKinds hoB))
+    ptype k | Just r <- Map.lookup k (hoAssumps hoE) = show (pprint r:: PP.Doc)
+    ptype x | nameType x == ClassName = hsep (map kindShow $ kindOfClass x (hoKinds hoE))
hunk ./src/Interactive.hs 151
-    isStart =  isInitial { stateHo = hoB, stateImports = runIdentity $ calcImports hoE False (Module "Prelude") }
+    isStart =  isInitial { stateHo = hoE, stateImports = runIdentity $ calcImports hoE False (Module "Prelude") }
hunk ./src/Interactive.hs 159
-        | Just d <- showSynonym (show . (pprint :: HsType -> PP.Doc) ) v (hoTypeSynonyms hoB) = nameTag (nameType v):' ':d
+        | Just d <- showSynonym (show . (pprint :: HsType -> PP.Doc) ) v (hoTypeSynonyms hoE) = nameTag (nameType v):' ':d
hunk ./src/Interactive.hs 181
-    is@IS { stateHo = hoB } <- ask
+    is@IS { stateHo = hoE } <- ask
hunk ./src/Interactive.hs 186
-    stmt'' <- expandTypeSynsStmt (hoTypeSynonyms hoB) (stateModule is) stmt'
-    stmt''' <- return $ FrontEnd.Infix.infixStatement (hoFixities hoB) stmt''
+    stmt'' <- expandTypeSynsStmt (hoTypeSynonyms hoE) (stateModule is) stmt'
+    stmt''' <- return $ FrontEnd.Infix.infixStatement (hoFixities hoE) stmt''
hunk ./src/Interactive.hs 247
-calcImports :: Monad m => HoExp -> Bool -> Module -> m [(Name,[Name])]
+calcImports :: Monad m => HoTcInfo -> Bool -> Module -> m [(Name,[Name])]
hunk ./src/Main.hs 116
-processFiles [] | Nothing <- optMainFunc options = do
-    int <- Interactive.isInteractive
-    when (not int) $ putErrDie "jhc: no input files"
-    processFilesModules [Left (Module "Prelude")]
-processFiles [] | Just (b,m) <- optMainFunc options = do
-    m <- return $ parseName Val m
-    m <- getModule m
-    processFilesModules [Left m]
-processFiles cs = do processFilesModules (map fileOrModule cs)
-
-processFilesModules fs = do
-    compileModEnv =<< parseFiles fs processInitialHo processDecls
-
-fileOrModule f = case reverse f of
-                   ('s':'h':'.':_)     -> Right f
-                   ('s':'h':'l':'.':_) -> Right f
-                   _                   -> Left $ Module f
+processFiles :: [String] -> IO ()
+processFiles cs = f cs (optMainFunc options) where
+    f [] Nothing  = do
+        int <- Interactive.isInteractive
+        when (not int) $ putErrDie "jhc: no input files"
+        g [Left (Module "Prelude")]
+    f [] (Just (b,m)) = do
+        m <- getModule (parseName Val m)
+        g [Left m]
+    f cs _ = g (map fileOrModule cs)
+    g fs =  compileModEnv =<< parseFiles fs processInitialHo processDecls
+    fileOrModule f = case reverse f of
+       ('s':'h':'.':_)     -> Right f
+       ('s':'h':'l':'.':_) -> Right f
+       _                   -> Left $ Module f
hunk ./src/Main.hs 147
-    -> Ho    -- ^ new ho, freshly read from file
+    -> Ho             -- ^ new ho, freshly read from file
hunk ./src/Main.hs 166
-        (mod:_) = Map.keys $ hoExports $ hoExp aho
+        (mod:_) = Map.keys $ hoExports $ hoTcInfo aho
hunk ./src/Main.hs 195
+        htc = hoTcInfo ho
hunk ./src/Main.hs 201
-    let dataTable = toDataTable (getConstructorKinds (hoKinds $ hoBuild ho')) (tiAllAssumptions tiData) originalDecls (hoDataTable $ hoBuild ho)
+    let dataTable = toDataTable (getConstructorKinds (hoKinds $ hoTcInfo ho')) (tiAllAssumptions tiData) originalDecls (hoDataTable $ hoBuild ho)
hunk ./src/Main.hs 210
-            progClassHierarchy = hoClassHierarchy $ hoBuild allHo,
+            progClassHierarchy = hoClassHierarchy $ hoTcInfo allHo,
hunk ./src/Main.hs 217
-    let allAssumps = (tiAllAssumptions tiData `mappend` hoAssumps (hoBuild ho))
+    let allAssumps = (tiAllAssumptions tiData `mappend` hoAssumps (hoTcInfo ho))
hunk ./src/Main.hs 219
-    ds' <- convertDecls tiData theProps (hoClassHierarchy $ hoBuild ho') allAssumps  fullDataTable decls
+    ds' <- convertDecls tiData theProps (hoClassHierarchy $ hoTcInfo ho') allAssumps  fullDataTable decls
hunk ./src/Main.hs 224
-    instanceRules <- createInstanceRules fullDataTable (hoClassHierarchy $ hoBuild ho')  (ds `mappend` hoEs (hoBuild ho))
-    userRules <- convertRules (progModule prog) tiData (hoClassHierarchy  $ hoBuild ho') allAssumps fullDataTable decls
+    instanceRules <- createInstanceRules fullDataTable (hoClassHierarchy $ hoTcInfo ho')  (ds `mappend` hoEs (hoBuild ho))
+    userRules <- convertRules (progModule prog) tiData (hoClassHierarchy  $ hoTcInfo ho') allAssumps fullDataTable decls
hunk ./src/Main.hs 246
-    Identity prog <- return $ programMapDs (\ (t,e) -> return (shouldBeExported (getExports $ hoExp ho') t,e)) $ atomizeApps False (programSetDs ds prog)
+    Identity prog <- return $ programMapDs (\ (t,e) -> return (shouldBeExported (getExports $ hoTcInfo ho') t,e)) $ atomizeApps False (programSetDs ds prog)
hunk ./src/Main.hs 412
-        (mod:_) = Map.keys $ hoExports $ hoExp ho'
+        (mod:_) = Map.keys $ hoExports $ hoTcInfo ho'