diff --git a/ghc-simple.cabal b/ghc-simple.cabal --- a/ghc-simple.cabal +++ b/ghc-simple.cabal @@ -1,5 +1,5 @@ name: ghc-simple -version: 0.1.3 +version: 0.2 synopsis: Simplified interface to the GHC API. description: The GHC API is a great tool for working with Haskell code. Unfortunately, it's also fairly opaque and hard to get @@ -31,11 +31,13 @@ other-extensions: CPP, PatternGuards, FlexibleInstances build-depends: - ghc >=7.8, - base >=4.7 && <4.9, - ghc-paths >=0.1 && <0.2, - directory >=1.2 && <1.3, - filepath >=1.3 && <1.5 + ghc >=7.8 && <7.11, + base >=4.7 && <4.9, + ghc-paths >=0.1 && <0.2, + directory >=1.2 && <1.3, + filepath >=1.3 && <1.5, + bytestring >=0.10 && <0.11, + binary >=0.6 && <0.8 hs-source-dirs: src default-language: diff --git a/src/Language/Haskell/GHC/Simple.hs b/src/Language/Haskell/GHC/Simple.hs --- a/src/Language/Haskell/GHC/Simple.hs +++ b/src/Language/Haskell/GHC/Simple.hs @@ -6,7 +6,6 @@ -- * Configuration, input and output types module Simple.Types, - StgModule, getDynFlagsForConfig, -- * GHC re-exports for processing STG and Core @@ -54,53 +53,76 @@ import Module -- Misc. stuff -import GHC.Paths (libdir) +import Data.Binary +import qualified Data.ByteString.Lazy as BS import Data.IORef +import Data.List (sort, sortBy) import Control.Monad +import GHC.Paths (libdir) +import System.Directory +import System.FilePath +import System.IO +import System.IO.Unsafe + +-- Internals import Language.Haskell.GHC.Simple.PrimIface as Simple.PrimIface import Language.Haskell.GHC.Simple.Types as Simple.Types import Language.Haskell.GHC.Simple.Impl -import System.IO.Unsafe -- | Compile a list of targets and their dependencies into intermediate code. -- Uses settings from the the default 'CompConfig'. -compile :: Compile a - => [String] +compile :: (Intermediate a, Binary b) + => (ModMetadata -> a -> IO b) + -- ^ Compilation function from some intermediate language to the + -- desired output. The output type needs to be an instance of + -- 'Binary', as it will be cached after compilation to speed up + -- future recompilation. + -- This function is called once per module. Due to caching of modules + -- which don't need to be recompiled, it will not necessarily be + -- called once per module included in the return value of @compile@. + -> [String] -- ^ List of compilation targets. A target can be either a module -- or a file name. - -> IO (CompResult [CompiledModule a]) + -> IO (CompResult [CompiledModule b]) compile = compileWith defaultConfig -- | Compile a list of targets and their dependencies using a custom -- configuration. -compileWith :: Compile a - => CompConfig a +compileWith :: (Intermediate a, Binary b) + => CompConfig -- ^ GHC pipeline configuration. + -> (ModMetadata -> a -> IO b) + -- ^ Compilation function. -> [String] -- ^ List of compilation targets. A target can be either a module -- or a file name. Targets may also be read from the specified -- 'CompConfig', if 'cfgUseTargetsFromFlags' is set. - -> IO (CompResult [CompiledModule a]) -compileWith cfg = compileFold (cfg {cfgGhcPipeline = toCode}) consMod [] + -> IO (CompResult [CompiledModule b]) +compileWith cfg comp = compileFold cfg comp consMod [] consMod :: [CompiledModule a] -> CompiledModule a -> IO [CompiledModule a] consMod xs x = return (x:xs) -- | Obtain the dynamic flags and extra targets that would be used to compile -- anything with the given config. -getDynFlagsForConfig :: CompConfig a -> IO (DynFlags, [String]) +getDynFlagsForConfig :: CompConfig -> IO (DynFlags, [String]) getDynFlagsForConfig cfg = initStaticFlags `seq` do ws <- newIORef [] runGhc (maybe (Just libdir) Just (cfgGhcLibDir cfg)) $ do - setDFS cfg (discardStaticFlags (cfgGhcFlags cfg)) ws + setDFS cfg (discardStaticFlags (cfgGhcFlags cfg)) ws noComp +noComp :: FilePath -> ModSummary -> CgGuts -> CompPipeline () +noComp _ _ _ = return () + -- | Set and return the appropriate dynflags and extra targets for the given -- config. -setDFS :: CompConfig a -- ^ Compilation configuration. +setDFS :: CompConfig -- ^ Compilation configuration. -> [String] -- ^ Dynamic GHC command line flags. -> IORef [Warning] -- ^ IORef to use for logging warnings. + -> (FilePath -> ModSummary -> CgGuts -> CompPipeline ()) + -- ^ Per-module compilation function. -> Ghc (DynFlags, [String]) -setDFS cfg flags warns = do +setDFS cfg flags warns comp = do -- Parse and update dynamic flags dfs <- getSessionDynFlags (dfs', files2, _dynwarns) <- parseDynamicFlags dfs (map noLoc flags) @@ -146,34 +168,71 @@ } getSession >>= liftIO . fixPrimopTypes nfo strs + -- TODO: get rid of the @runPhase@ from the HscOut phase + phaseHook _ p@(HscOut src_flavour mod_name result) inp dfs = do + loc <- getLocation src_flavour mod_name + setModLocation loc + let next = hscPostBackendPhase dfs src_flavour (hscTarget dfs) + case result of + HscRecomp cgguts ms -> do + outfile <- phaseOutputFilename next + comp (ml_hi_file loc) ms cgguts + runPhase p inp dfs -- return (RealPhase next, outfile) + _ -> + runPhase p inp dfs -- return (RealPhase next, ml_obj_file loc) phaseHook stop (RealPhase p) inp _ | p `elem` stop = return (RealPhase StopLn, inp) phaseHook _ p inp dfs = runPhase p inp dfs +-- | Write a module to cache file. +writeModCache :: Binary a => CompConfig -> CompiledModule a -> IO () +writeModCache cfg (CompiledModule m meta) = do + createDirectoryIfMissing True (takeDirectory cachefile) + BS.writeFile cachefile (encode m) + where + ext = cfgCacheFileExt cfg + modfile = moduleNameSlashes (ms_mod_name (mmSummary meta)) <.> ext + cachefile = maybe "" id (cfgCacheDirectory cfg) modfile +-- | Read a module from cache file. +readModCache :: Binary a => CompConfig -> ModMetadata -> IO (CompiledModule a) +readModCache cfg meta = do + m <- decode <$> BS.readFile cachefile + return $ CompiledModule m meta + where + ext = cfgCacheFileExt cfg + modfile = moduleNameSlashes (ms_mod_name (mmSummary meta)) <.> ext + cachefile = maybe "" id (cfgCacheDirectory cfg) modfile + -- | Left fold over a list of compilation targets and their dependencies. -- -- Sometimes you don't just want a huge pile of intermediate code lying -- around; chances are you either want to dump it to file or combine it with -- some other intermediate code, without having to keep it all in memory at -- the same time. -compileFold :: CompConfig b +compileFold :: (Intermediate a, Binary b) + => CompConfig -- ^ GHC pipeline configuration. - -> (a -> CompiledModule b -> IO a) - -- ^ Compilation function. - -> a + -> (ModMetadata -> a -> IO b) + -- ^ Per module compilation function. + -> (acc -> CompiledModule b -> IO acc) + -- ^ Folding function. + -> acc -- ^ Initial accumulator. -> [String] -- ^ List of compilation targets. A target can be either a module -- or a file name. Targets may also be read from the specified -- 'CompConfig', if 'cfgUseTargetsFromFlags' is set. - -> IO (CompResult a) -compileFold cfg comp acc files = initStaticFlags `seq` do - warns <- newIORef [] + -> IO (CompResult acc) +compileFold cfg comp f acc files = initStaticFlags `seq` do + warns <- newIORef [] -- all warnings produced by GHC + accref <- newIORef acc -- accumulator for compilation fold function + tgtref <- newIORef [] -- ref containing all compilation targets + recomp <- newIORef [] -- ref containing all modules that were recompiled runGhc (maybe (Just libdir) Just (cfgGhcLibDir cfg)) $ do - (_, files2) <- setDFS cfg (discardStaticFlags (cfgGhcFlags cfg)) warns - ecode <- genCode cfg ghcPipeline comp acc (files ++ files2) + (_, files2) <- setDFS cfg dfs warns (comp' accref recomp tgtref) + ecode <- genCode cfg f accref tgtref recomp (files ++ files2) ws <- liftIO $ readIORef warns case ecode of Right (finaldfs, code) -> @@ -188,7 +247,20 @@ compWarnings = ws } where - ghcPipeline = toCompiledModule cfg $ cfgGhcPipeline cfg + dfs = discardStaticFlags (cfgGhcFlags cfg) + comp' accref recompref tgtref hifile ms cgguts = do + source <- prepare ms cgguts + liftIO $ do + tgts <- readIORef tgtref + let meta = toModMetadata cfg False tgts ms + code <- comp meta source + let cm = CompiledModule code meta + writeModCache cfg cm + -- TODO: if we already recompiled the module, we shouldn't do it + -- again, for instance when recompilation is forced due to + -- missing cache file + atomicModifyIORef' recompref $ \xs -> (ms_mod ms : xs, ()) + readIORef accref >>= flip f cm >>= writeIORef accref {-# NOINLINE initStaticFlags #-} -- | Use lazy evaluation to only call 'parseStaticFlags' once. @@ -197,30 +269,50 @@ -- | Map a compilation function over each 'ModSummary' in the dependency graph -- of a list of targets. -genCode :: GhcMonad m - => CompConfig t - -> (ModSummary -> m a) - -> (b -> a -> IO b) - -> b - -> [String] - -> m (Either [Error] (DynFlags, b)) -genCode cfg comp usercomp acc files = do +genCode :: (GhcMonad m, Binary b) + => CompConfig + -> (a -> CompiledModule b -> IO a) + -> IORef a + -> IORef [Target] + -> IORef [Module] + -> [String] + -> m (Either [Error] (DynFlags, a)) +genCode cfg f accref tgtref recompref files = do dfs <- getSessionDynFlags merrs <- handleSourceError (maybeErrors dfs) $ do ts <- mapM (flip guessTarget Nothing) files + liftIO $ writeIORef tgtref ts setTargets ts loads <- load LoadAllTargets + mss <- depanal [] False + acc <- liftIO $ readIORef accref + recompiled <- liftIO $ readIORef recompref + let cachedmods = sortBy onModId mss \\ sort recompiled + -- TODO: if some cached mod failed to load, recompile it + acc' <- liftIO $ foldM (loadCachedMod ts) acc cachedmods + liftIO $ writeIORef accref acc' return $ if succeeded loads then Nothing else Just [] case merrs of Just errs -> return $ Left errs _ -> do - mss <- depanal [] False - code <- foldM (\a x -> comp (noLog x) >>= liftIO . usercomp a) acc mss + code <- liftIO $ readIORef accref return $ Right (dfs, code) where - -- We logged everything when we did @load@, we don't want to do it twice. - noLog m = - m {ms_hspp_opts = (ms_hspp_opts m) {log_action = \_ _ _ _ _ -> return ()}} + onModId m n = ms_mod m `compare` ms_mod n + + loadCachedMod tgts acc ms = + readModCache cfg (toModMetadata cfg True tgts ms) >>= f acc + + -- remove all mod summaries from msmss whose mod identities exist in mmods. + -- both lists must be sorted. + (\\) :: [ModSummary] -> [Module] -> [ModSummary] + msmss@(ms:mss) \\ mmods@(m:mods) + | ms_mod ms == m = mss \\ mmods -- ms found in mods; remove it + | ms_mod ms < m = msmss \\ mods -- ms < m; ms may still be in mods + | otherwise = ms : (mss \\ mmods) -- ms > m; ms is not in mods + mss \\ [] = mss -- mods empty, keep all remaining + [] \\ _ = [] -- no mss to keep! + maybeErrors dfs | cfgUseGhcErrorLogger cfg = \srcerr -> liftIO $ do let msgs = srcErrorMessages srcerr diff --git a/src/Language/Haskell/GHC/Simple/Impl.hs b/src/Language/Haskell/GHC/Simple/Impl.hs --- a/src/Language/Haskell/GHC/Simple/Impl.hs +++ b/src/Language/Haskell/GHC/Simple/Impl.hs @@ -1,15 +1,10 @@ {-# LANGUAGE FlexibleInstances, CPP, PatternGuards #-} -- | Lower level building blocks for custom code generation. module Language.Haskell.GHC.Simple.Impl ( - Compile (..), - Ghc, StgModule, PkgKey, + Ghc, PkgKey, liftIO, toSimplifiedStg, - toSimplifiedCore, - toModGuts, - simplify, - prepare, toStgBindings, - toCompiledModule, + toModMetadata, modulePkgKey, pkgKeyString ) where @@ -25,6 +20,7 @@ import CoreSyn import CoreToStg import SimplStg +import DriverPipeline #if __GLASGOW_HASKELL__ < 710 import qualified Module as M (modulePackageId, packageIdString, PackageId) #else @@ -37,15 +33,16 @@ import System.Directory (doesFileExist, createDirectoryIfMissing) import Language.Haskell.GHC.Simple.Types -type StgModule = CompiledModule [StgBinding] -instance Compile [StgBinding] where - toCode = toSimplifiedStg +instance Intermediate [StgBinding] where + prepare = toSimplifiedStg -instance Compile CgGuts where - toCode = toSimplifiedCore +instance Intermediate CgGuts where + prepare _ = pure -instance Compile ModGuts where - toCode = toModGuts +instance Intermediate CoreProgram where + prepare ms cgguts = do + env <- hsc_env `fmap` getPipeState + liftIO $ prepareCore env (hsc_dflags env) ms cgguts -- | Package ID/key of a module. modulePkgKey :: Module -> PkgKey @@ -67,43 +64,22 @@ pkgKeyString = M.packageKeyString #endif --- | Compile a 'ModSummary' into a module with metadata using a custom --- compilation function. -toCompiledModule :: GhcMonad m - => CompConfig a - -> (ModSummary -> m a) - -> ModSummary - -> m (CompiledModule a) -toCompiledModule cfg comp ms = do - code <- comp ms - ts <- getTargets - dfs <- getSessionDynFlags - iface <- getModIface dfs - let hifile = ml_hi_file $ ms_location ms - when (cfgAlwaysCreateHiFiles cfg) . liftIO $ do - exists <- doesFileExist hifile - unless exists $ do - createDirectoryIfMissing True (takeDirectory hifile) - writeBinIface dfs hifile iface - return $ CompiledModule { - modSummary = ms, - modName = moduleNameString $ ms_mod_name ms, - modPackageKey = pkgKeyString . modulePkgKey $ ms_mod ms, - modIsTarget = any (`isTargetOf` ms) ts, - modSourceIsHsBoot = ms_hsc_src ms == HsBootFile, - modSourceFile = ml_hs_file $ ms_location ms, - modInterface = iface, - modInterfaceFile = hifile, - modCompiledModule = code - } - where - getModIface dfs = do - env <- getSession - pkgIfaceTbl <- eps_PIT `fmap` liftIO (readIORef (hsc_EPS env)) - let homePkgTbl = hsc_HPT env - case lookupIfaceByModule dfs homePkgTbl pkgIfaceTbl (ms_mod ms) of - Just mi -> return mi - _ -> error "Module interface does not exist!" +-- | Build a 'ModMetadata' out of scattered metadata. +toModMetadata :: CompConfig + -> Bool + -> [Target] + -> ModSummary + -> ModMetadata +toModMetadata cfg cached tgts ms = ModMetadata { + mmSummary = ms, + mmName = moduleNameString $ ms_mod_name ms, + mmPackageKey = pkgKeyString . modulePkgKey $ ms_mod ms, + mmIsTarget = any (`isTargetOf` ms) tgts, + mmSourceIsHsBoot = ms_hsc_src ms == HsBootFile, + mmSourceFile = ml_hs_file $ ms_location ms, + mmInterfaceFile = ml_hi_file $ ms_location ms, + mmCached = cached + } -- | Is @t@ the target that corresponds to @ms@? @@ -118,41 +94,20 @@ -- | Compile a 'ModSummary' into a list of simplified 'StgBinding's. -- See -- for more information about STG and how it relates to core and Haskell. -toSimplifiedStg :: GhcMonad m => ModSummary -> m [StgBinding] -toSimplifiedStg ms = do - dfs <- getSessionDynFlags - toSimplifiedCore ms >>= prepare dfs ms >>= toStgBindings dfs ms - --- | Compile a 'ModSummary' into a 'CgGuts', containing all information about --- a core module that one could wish for. -toSimplifiedCore :: GhcMonad m => ModSummary -> m CgGuts -toSimplifiedCore = toModGuts >=> simplify - --- | Parse, typecheck and desugar a module. Returned 'ModGuts' structure is not --- simplified in any way. -toModGuts :: GhcMonad m => ModSummary -> m ModGuts -toModGuts = - parseModule >=> typecheckModule >=> desugarModule >=> return . coreModule - --- | Simplify a core module for code generation. -simplify :: GhcMonad m => ModGuts -> m CgGuts -simplify mg = do - env <- getSession - liftIO $ hscSimplify env mg >>= tidyProgram env >>= return . fst +toSimplifiedStg :: ModSummary -> CgGuts -> CompPipeline [StgBinding] +toSimplifiedStg ms cgguts = do + env <- hsc_env `fmap` getPipeState + let dfs = hsc_dflags env + liftIO $ do + prog <- prepareCore env dfs ms cgguts + stg <- coreToStg dfs (ms_mod ms) prog + fst `fmap` stg2stg dfs (ms_mod ms) stg -- | Prepare a core module for code generation. -prepare :: GhcMonad m => DynFlags -> ModSummary -> CgGuts -> m CoreProgram -prepare dfs _ms p = do - env <- getSession +prepareCore :: HscEnv -> DynFlags -> ModSummary -> CgGuts -> IO CoreProgram +prepareCore env dfs _ms p = do #if __GLASGOW_HASKELL__ < 710 liftIO $ corePrepPgm dfs env (cg_binds p) (cg_tycons p) #else liftIO $ corePrepPgm env (ms_location _ms) (cg_binds p) (cg_tycons p) #endif - --- | Turn a core module into a list of simplified STG bindings. -toStgBindings :: GhcMonad m - => DynFlags -> ModSummary -> CoreProgram -> m [StgBinding] -toStgBindings dfs ms p = liftIO $ do - stg <- coreToStg dfs (ms_mod ms) p - fst `fmap` stg2stg dfs (ms_mod ms) stg diff --git a/src/Language/Haskell/GHC/Simple/Types.hs b/src/Language/Haskell/GHC/Simple/Types.hs --- a/src/Language/Haskell/GHC/Simple/Types.hs +++ b/src/Language/Haskell/GHC/Simple/Types.hs @@ -1,17 +1,18 @@ -- | Config, input and output types for the simplified GHC API. module Language.Haskell.GHC.Simple.Types ( -- * GHC pipeline configuration - Compile (..), + Intermediate (..), CompConfig, defaultConfig, cfgGhcFlags, cfgUseTargetsFromFlags, cfgUpdateDynFlags, cfgGhcLibDir, - cfgUseGhcErrorLogger, cfgCustomPrimIface, cfgGhcPipeline, - cfgAlwaysCreateHiFiles, cfgStopPhases, + cfgUseGhcErrorLogger, cfgCustomPrimIface, cfgStopPhases, + cfgCacheDirectory, cfgCacheFileExt, -- * Convenience functions for common settings combinations ncgPhases, disableCodeGen, -- * Compilation results and errors + ModMetadata (..), CompiledModule (..), CompResult (..), Error (..), @@ -20,17 +21,20 @@ ) where import GHC +import HscTypes (CgGuts) import DriverPhases +import DriverPipeline (CompPipeline) import Language.Haskell.GHC.Simple.PrimIface +import Data.Binary (Binary) --- | Any type we can generate intermediate code for. -class Compile a where - -- | Generate some sort of code (or other output) from a Haskell module. - toCode :: ModSummary -> Ghc a +-- | An intermediate source language, usable as the the input for a +-- 'Compile' compilation function. +class Intermediate a where + prepare :: ModSummary -> CgGuts -> CompPipeline a -- | GHC pipeline configuration, parameterized over the intermediate code -- produced by the pipeline. -data CompConfig a = CompConfig { +data CompConfig = CompConfig { -- | GHC command line dynamic flags to control the Haskell to STG -- compilation pipeline. -- For instance, passing @["-O2", "-DHELLO"]@ here is equivalent to @@ -84,6 +88,17 @@ cfgCustomPrimIface :: Maybe (PrimOp -> PrimOpInfo, PrimOp -> Arity -> StrictSig), + -- | Cache directory for compiled code. If @Nothing@, the current directory + -- is used. + -- + -- Default: @Nothing@ + cfgCacheDirectory :: Maybe FilePath, + + -- | File extension of cache files. + -- + -- Default: @cache@ + cfgCacheFileExt :: String, + -- | Stop compilation when any of these this phases are reached, -- without performing it. If you are doing custom code generation and -- don't want GHC to generate any code - for instance when writing a @@ -91,31 +106,11 @@ -- @ncgPhases@. -- -- Default: @[]@ - cfgStopPhases :: [Phase], - - -- | Use a custom GHC pipeline to generate intermediate code. Useful if - -- the provided instances for @[StgBinding]@ etc. don't quite do what you - -- want them to. See "Language.Haskell.GHC.Simple.Impl" for more - -- information about custom pipelines. - -- - -- Default: @toCode@ - cfgGhcPipeline :: ModSummary -> Ghc a, - - -- | Always ensure that the interface file indicated by the - -- 'modInterfaceFile' field of 'CompiledModule' exists? - -- When compiling with @hscTarget = HscNothing@, GHC will not - -- automatically create module interface files. - -- This is undesirable if, for instance, one wants the compiler to - -- generate interface files as well as custom generated code, but not - -- invoke any standard GHC code generator such as the LLVM or NCG - -- generators. - -- - -- Default: @True@ - cfgAlwaysCreateHiFiles :: Bool + cfgStopPhases :: [Phase] } -- | Default configuration. -defaultConfig :: Compile a => CompConfig a +defaultConfig :: CompConfig defaultConfig = CompConfig { cfgGhcFlags = [], cfgUseTargetsFromFlags = True, @@ -123,9 +118,9 @@ cfgUseGhcErrorLogger = False, cfgGhcLibDir = Nothing, cfgCustomPrimIface = Nothing, - cfgStopPhases = [], - cfgGhcPipeline = toCode, - cfgAlwaysCreateHiFiles = True + cfgCacheDirectory = Nothing, + cfgCacheFileExt = "cache", + cfgStopPhases = [] } -- | Phases in which the native code generator is invoked. You want to stop @@ -134,7 +129,7 @@ ncgPhases = [CmmCpp, Cmm, As False, As True] -- | Disable any native code generation and linking. -disableCodeGen :: CompConfig a -> CompConfig a +disableCodeGen :: CompConfig -> CompConfig disableCodeGen cfg = cfg { cfgStopPhases = ncgPhases, cfgUpdateDynFlags = asmTarget . cfgUpdateDynFlags cfg @@ -143,40 +138,46 @@ asmTarget dfs = dfs {hscTarget = HscAsm, ghcLink = NoLink} -- | Compiler output and metadata for a given module. -data CompiledModule a = CompiledModule { +data CompiledModule a = CompiledModule { + -- | Module data generated by compilation; usually bindings of some kind. + modCompiledModule :: a, + + -- | Metadata for the compiled module. + modMetaData :: ModMetadata + } + +-- | Metadata for a module under compilation. +data ModMetadata = ModMetadata { -- | 'ModSummary' for the module, as given by GHC. - modSummary :: ModSummary, + mmSummary :: ModSummary, -- | String representation of the module's name, not qualified with a -- package key. -- 'ModuleName' representation can be obtained from the module's -- 'stgModSummary'. - modName :: String, + mmName :: String, -- | String representation of the module's package key. -- 'PackageKey' representation can be obtained from the module's -- 'stgModSummary'. - modPackageKey :: String, + mmPackageKey :: String, -- | Is this module a compilation target (as opposed to a dependency of -- one)? - modIsTarget :: Bool, + mmIsTarget :: Bool, -- | Was the module compiler from a @hs-boot@ file? - modSourceIsHsBoot :: Bool, + mmSourceIsHsBoot :: Bool, -- | The Haskell source the module was compiled from, if any. - modSourceFile :: Maybe FilePath, - - -- | 'ModIface' structure corresponding to this module. - -- If 'modInterfaceFile' exists, it contains this structure. - modInterface :: ModIface, + mmSourceFile :: Maybe FilePath, -- | Interface file corresponding to this module. - modInterfaceFile :: FilePath, + mmInterfaceFile :: FilePath, - -- | Module data generated by compilation; usually bindings of some kind. - modCompiledModule :: a + -- | Was this module loaded from cache, as opposed to recompiled from + -- scratch? + mmCached :: Bool } -- | A GHC error message.