diff options
Diffstat (limited to 'lib/Distribution')
| -rw-r--r-- | lib/Distribution/Helper.hs | 874 |
1 files changed, 525 insertions, 349 deletions
diff --git a/lib/Distribution/Helper.hs b/lib/Distribution/Helper.hs index 622972a..edf71f7 100644 --- a/lib/Distribution/Helper.hs +++ b/lib/Distribution/Helper.hs @@ -16,7 +16,11 @@ {-# LANGUAGE RecordWildCards, FlexibleContexts, ConstraintKinds, GeneralizedNewtypeDeriving, DeriveDataTypeable, DeriveGeneric, DeriveFunctor, - NamedFieldPuns, OverloadedStrings, ViewPatterns #-} + StandaloneDeriving, NamedFieldPuns, OverloadedStrings, ViewPatterns, + TupleSections, TypeFamilies, DataKinds, GADTs, ScopedTypeVariables, + ImplicitParams, RankNTypes #-} + +{-# OPTIONS_GHC -fno-warn-name-shadowing #-} {-| Module : Distribution.Helper @@ -32,48 +36,37 @@ module Distribution.Helper ( -- * Queries against Cabal\'s on disk state - -- ** Package queries - , packageId - , packageDbStack - , packageFlags + -- ** Project queries , compilerVersion + , projectUnits - , ghcMergedPkgOptions - - -- ** cabal-install queries - , configFlags - , nonDefaultConfigFlags - - - -- ** Component queries - , ComponentQuery - , components - - , ghcSrcOptions - , ghcPkgOptions - , ghcLangOptions - , ghcOptions - , sourceDirs - , entrypoints - , needsBuildOutput + -- ** Unit queries + , Unit -- abstract + , UnitId -- abstract + , UnitInfo(..) + , unitQuery -- * Query environment - , QueryEnv + , QueryEnv -- abstract , mkQueryEnv , qeReadProcess , qePrograms , qeProjectDir , qeDistDir - , qeCabalPkgDb - , qeCabalVer + + -- * GADTs + , DistDir(..) + , ProjType(..) + , ProjDir(..) , Programs(..) , defaultPrograms -- * Result types - , ChModuleName(..) + , ChComponentInfo(..) , ChComponentName(..) + , ChModuleName(..) , ChPkgDb(..) , ChEntrypoint(..) , NeedsBuildOutput(..) @@ -93,39 +86,52 @@ module Distribution.Helper ( , module Data.Functor.Apply ) where -import Cabal.Plan +import Cabal.Plan hiding (Unit, UnitId, uDistDir) +import qualified Cabal.Plan as CP import Control.Applicative import Control.Monad +import Control.Monad.Trans.Maybe import Control.Monad.IO.Class -import Control.Monad.State.Strict -import Control.Monad.Reader import Control.Exception as E -import Data.List +import Data.Char +import Data.Coerce +import Data.IORef +import Data.List hiding (filter) +import Data.String +import qualified Data.Text as Text import Data.Maybe +import Data.Either +import Data.Map.Strict (Map) import qualified Data.Map.Strict as Map +import Data.Set (Set) +import qualified Data.Set as Set import Data.Version -import qualified Data.Text as Text import Data.Function import Data.Functor.Apply import System.Environment import System.FilePath hiding ((<.>)) import System.Directory import System.Process +import System.Posix.Types +import System.PosixCompat.Files import Text.Printf import Text.Show.Pretty import Prelude - import CabalHelper.Compiletime.Compile import CabalHelper.Compiletime.Types import CabalHelper.Shared.InterfaceTypes import CabalHelper.Shared.Sandbox +import CabalHelper.Shared.Common +import CabalHelper.Compiletime.Compat.Version +import qualified CabalHelper.Compiletime.Compat.ProgramDb as ProgDb + ( defaultProgramDb, programPath, lookupProgram, ghcProgram, ghcPkgProgram) import Distribution.System (buildPlatform) import Distribution.Text (display) import Distribution.Verbosity (silent, deafening) -import Distribution.Package (packageName, packageVersion) +--import Distribution.Package (packageName, packageVersion) import Distribution.Simple.GHC as GHC (configure) import qualified CabalHelper.Compiletime.Compat.ProgramDb as ProgDb @@ -134,193 +140,275 @@ import CabalHelper.Compiletime.Compat.Version import CabalHelper.Shared.Common +-- | The kind of project being managed by a 'QueryEnv' (pun intended). +data ProjType + = V1 -- ^ @cabal v1-build@ project, see 'DistDirV1' + | V2 -- ^ @cabal v2-build@ project, see 'DistDirV2' + +-- | A project directory. The project type of a given directory can be +-- determined by trying to access a set of marker files. See below. +data ProjDir (pt :: ProjType) where + -- | A @cabal v1-build@ project directory can be identified by one file + -- ending in @.cabal@ existing in the directory. More than one such files + -- existing is a user error. Note: For this project type the concepts of + -- project and package coincide. + ProjDirV1 :: FilePath -> ProjDir 'V1 + + -- | A @cabal v2-build@ project\'s marker file is called + -- @cabal.project@. This configuration file points to the packages that make + -- up this project. + ProjDirV2 :: FilePath -> ProjDir 'V2 + +data DistDir (pt :: ProjType) where + -- | Build directory for cabal /old-build/ aka. /v1-build/ aka. just + -- /build/. Planned to be superceeded by /v2-build/, see 'DistDirV2' for + -- that. + -- + -- You can tell a builddir is a /v1/ builddir by looking for a file + -- called @setup-config@ directly underneath it. + DistDirV1 :: FilePath -> DistDir 'V1 + + -- | Build directory for cabal /new-build/ aka. /v2-build/, as of the time + -- of this writing it is usually called @dist-newstyle/@ but this will + -- presumably change once it becomes the default /build/ command. + -- + -- You can tell a builddir is a /v2/ builddir by trying to access the path + -- @cache/plan.json@ directly underneath it. + DistDirV2 :: FilePath -> DistDir 'V2 + +-- | Environment for running a 'Query' value. The real constructor is +-- not exposed, use the 'mkQueryEnv' smart constructor instead. The field +-- accessors are exported and may be used to override the defaults, see below. +type QueryEnv (proj_type :: ProjType) + = QueryEnvI (QueryCache proj_type) proj_type + +data QueryEnvI cache (proj_type :: ProjType) = QueryEnv + { qeReadProcess + :: Maybe FilePath -> FilePath -> [String] -> String -> IO String + -- ^ Field accessor for 'QueryEnv'. Function used to to start + -- processes. Useful if you need to, for example, redirect standard error + -- output away from the user\'s terminal. + + , qePrograms :: Programs + -- ^ Field accessor for 'QueryEnv'. + + , qeProjectDir :: ProjDir proj_type + -- ^ Field accessor for 'QueryEnv'. Defines path to the project directory, + -- i.e. a directory containing a @cabal.project@ file + + , qeDistDir :: DistDir proj_type + -- ^ Field accessor for 'QueryEnv'. Defines path to the @dist/@ or + -- @dist-newstyle/@ directory, aka. /builddir/ in Cabal terminology. + + , qeCacheRef :: IORef cache + -- ^ Cache for query results, only accessible when type parameter @cache@ is + -- instantiated and not forall quantified. + } --- | Environment for running a 'Query'. The real constructor is not exposed, --- the field accessors are however. See below. Use the 'mkQueryEnv' smart --- constructor to construct one. -data QueryEnv = QueryEnv { - -- | Field accessor for 'QueryEnv'. Defines how to start the cabal-helper - -- process. Useful if you need to capture stderr output from the helper. - qeReadProcess :: FilePath -> [String] -> String -> IO String, +data QueryCache pt = QueryCache + { qcProjInfo :: !(Maybe (ProjInfo pt)) + , qcUnitInfos :: !(Map DistDirLib UnitInfo) + } - -- | Field accessor for 'QueryEnv'. - qePrograms :: Programs, +newtype DistDirLib = DistDirLib FilePath + deriving (Eq, Ord, Read, Show) - -- | Field accessor for 'QueryEnv'. Defines path to the project directory, - -- i.e. a directory containing a @project.cabal@ file - qeProjectDir :: FilePath, +-- | Abstractly speaking a Unit consists of a set of components (exes, libs, +-- tests etc.) which are managed by an instance of the Cabal build system. The +-- distinction between a Unit and a set of components is somewhat hard to +-- explain if you're not already familliar with the concept from +-- cabal-install. Luckily for most purposes the details may be ignored. +-- +-- We merely use the concept of a Unit for caching purposes. It is necessary to +-- extract the information on all components in a Unit at the same time as we +-- must load all of it into memory before extracting any of it. +-- +-- As opposed to components, different 'Unit's can be queried independently +-- since their on-disk information is stored separately. +data Unit = Unit + { uUnitId :: !UnitId + , uPackageDir :: !FilePath + , uDistDir :: !DistDirLib + } +newtype UnitId = UnitId String + deriving (Eq, Ord, Read, Show) - -- | Field accessor for 'QueryEnv'. Defines path to the @dist/@ directory, - -- /builddir/ in Cabal terminology. - qeDistDir :: FilePath, +-- | The information extracted from a 'Unit's on-disk configuration. +data UnitInfo = UnitInfo + { uiUnitId :: !UnitId + -- ^ A unique identifier of this init within the project. - -- | Field accessor for 'QueryEnv'. Defines where to look for the Cabal - -- library when linking the helper. - qeCabalPkgDb :: Maybe FilePath, + , uiComponents :: !(Map ChComponentName ChComponentInfo) + -- ^ The components of the unit: libraries, executables, test-suites, + -- benchmarks and so on. - -- | Field accessor for 'QueryEnv'. If @dist/setup-config@ wasn\'t written - -- by this version of Cabal an error is thrown when running the query. - qeCabalVer :: Maybe Version - } + , uiCompilerVersion :: !(String, Version) + -- ^ The version of GHC the unit is configured to use --- | @mkQueryEnv projdir distdir@. Smart constructor for 'QueryEnv'. --- Sets fields 'qeProjectDir' and 'qeDistDir' to @projdir@ and @distdir@ --- respectively and provides sensible defaults for the other fields. -mkQueryEnv :: FilePath - -- ^ Path to the project directory, i.e. the directory containing a - -- @project.cabal@ file - -> FilePath - -- ^ Path to the @dist/@ directory, called /builddir/ in Cabal - -- terminology. - -> QueryEnv -mkQueryEnv projdir distdir = QueryEnv { - qeReadProcess = readProcess - , qePrograms = defaultPrograms - , qeProjectDir = projdir - , qeDistDir = distdir - , qeCabalPkgDb = Nothing - , qeCabalVer = Nothing - } - -data SomeLocalBuildInfo = SomeLocalBuildInfo { - slbiPackageDbStack :: [ChPkgDb], - slbiPackageFlags :: [(String, Bool)], - slbiCompilerVersion :: (String, Version), - - slbiGhcMergedPkgOptions :: [String], - - slbiConfigFlags :: [(String, Bool)], - slbiNonDefaultConfigFlags :: [(String, Bool)], - - slbiGhcSrcOptions :: [(ChComponentName, [String])], - slbiGhcPkgOptions :: [(ChComponentName, [String])], - slbiGhcLangOptions :: [(ChComponentName, [String])], - slbiGhcOptions :: [(ChComponentName, [String])], - - slbiSourceDirs :: [(ChComponentName, [String])], - slbiEntrypoints :: [(ChComponentName, ChEntrypoint)], - slbiNeedsBuildOutput :: [(ChComponentName, NeedsBuildOutput)] + , uiPackageDbStack :: !([ChPkgDb]) + -- ^ List of package databases to use. + + , uiPackageFlags :: !([(String, Bool)]) + -- ^ Flag definitions from cabal file + + , uiConfigFlags :: ![(String, Bool)] + -- ^ Flag assignments from active configuration + + , uiNonDefaultConfigFlags :: ![(String, Bool)] + -- ^ Flag assignments from setup-config which differ from the default + -- setting. This can also include flags which cabal decided to modify, + -- i.e. don't rely on these being the flags set by the user directly. + + , uiModTimes :: !UnitModTimes + } deriving (Eq, Ord, Read, Show) + +data ProjInfo pt where + ProjInfoV1 :: + { piV1ProjConfModTimes :: !(ProjConfModTimes 'V1) + } -> ProjInfo 'V1 + + ProjInfoV2 :: + { piV2ProjConfModTimes :: !(ProjConfModTimes 'V2) + , piV2Plan :: !PlanJson + , piV2PlanModTime :: !EpochTime + } -> ProjInfo 'V2 + +data ProjConfModTimes pt where + ProjConfModTimesV1 + :: !(FilePath, EpochTime) -> ProjConfModTimes 'V1 + ProjConfModTimesV2 + :: !([(FilePath, EpochTime)]) -> ProjConfModTimes 'V2 + +deriving instance Eq (ProjConfModTimes pt) + +piProjConfModTimes :: ProjInfo pt -> ProjConfModTimes pt +piProjConfModTimes ProjInfoV1 {piV1ProjConfModTimes} = + piV1ProjConfModTimes +piProjConfModTimes ProjInfoV2 {piV2ProjConfModTimes} = + piV2ProjConfModTimes + +data UnitModTimes = UnitModTimes + { umtCabalFile :: !(FilePath, EpochTime) + , umtSetupConfig :: !(FilePath, EpochTime) } deriving (Eq, Ord, Read, Show) -- | A lazy, cached, query against a package's Cabal configuration. Use -- 'runQuery' to execute it. -newtype Query m a = Query { unQuery :: StateT (Maybe SomeLocalBuildInfo) - (ReaderT QueryEnv m) a } - deriving (Functor, Applicative, Monad, MonadIO) - -instance MonadTrans Query where - lift = Query . lift . lift - -type MonadQuery m = ( MonadIO m - , MonadState (Maybe SomeLocalBuildInfo) m - , MonadReader QueryEnv m) - --- | A 'Query' to run on all components of a package. Use 'components' to get a --- regular 'Query'. -newtype ComponentQuery m a = ComponentQuery (Query m [(ChComponentName, a)]) - deriving (Functor) - -instance (Functor m, Monad m) => Apply (ComponentQuery m) where - ComponentQuery flab <.> ComponentQuery fla = - ComponentQuery $ liftM2 go flab fla - where - go :: [(ChComponentName, a -> b)] - -> [(ChComponentName, a)] - -> [(ChComponentName, b)] - go lab la = - [ (cn, ab a) - | (cn, ab) <- lab - , (cn', a) <- la - , cn == cn' - ] - -run :: Monad m => QueryEnv -> Maybe SomeLocalBuildInfo -> Query m a -> m a -run e s action = flip runReaderT e (flip evalStateT s (unQuery action)) - --- | @runQuery env query@. Run a 'Query' under a given 'QueryEnv'. -runQuery :: Monad m - => QueryEnv - -> Query m a - -> m a -runQuery qe action = run qe Nothing action - -getSlbi :: MonadQuery m => m SomeLocalBuildInfo -getSlbi = do - s <- get - case s of - Nothing -> do - slbi <- getSomeConfigState - put (Just slbi) - return slbi - Just slbi -> return slbi - --- | List of package databases to use. -packageDbStack :: MonadIO m => Query m [ChPkgDb] - --- | Like @ghcPkgOptions@ but for the whole package not just one component -ghcMergedPkgOptions :: MonadIO m => Query m [String] - --- | Flag definitions from cabal file -packageFlags :: MonadIO m => Query m [(String, Bool)] - --- | Flag assignments from setup-config -configFlags :: MonadIO m => Query m [(String, Bool)] - --- | Flag assignments from setup-config which differ from the default --- setting. This can also include flags which cabal decided to modify, --- i.e. don't rely on these being the flags set by the user directly. -nonDefaultConfigFlags :: MonadIO m => Query m [(String, Bool)] +newtype Query pt a = Query + { runQuery :: QueryEnv pt -> IO a + -- ^ @runQuery env query@. Run a 'Query' under a given 'QueryEnv. + } --- | The version of GHC the project is configured to use -compilerVersion :: MonadIO m => Query m (String, Version) +instance Functor (Query pt) where + fmap = liftM --- | Package identifier, i.e. package name and version -packageId :: MonadIO m => Query m (String, Version) +instance Applicative (Query pt) where + (<*>) = ap + pure = return --- | Run a ComponentQuery on all components of the package. -components :: Monad m => ComponentQuery m (ChComponentName -> b) -> Query m [b] -components (ComponentQuery sc) = map (\(cn, f) -> f cn) `liftM` sc +instance Monad (Query pt) where + (Query ma) >>= amb = Query $ \qe -> ma qe >>= \a -> runQuery (amb a) qe + return a = Query $ const $ return a --- | Modules or files Cabal would have the compiler build directly. Can be used --- to compute the home module closure for a component. -entrypoints :: MonadIO m => ComponentQuery m ChEntrypoint +-- | @mkQueryEnv projdir distdir@. Smart constructor for 'QueryEnv'. +-- Sets fields 'qeProjectDir' and 'qeDistDir' to @projdir@ and @distdir@ +-- respectively and provides sensible defaults for the other fields. +mkQueryEnv + :: ProjDir pt + -- ^ Path to the project directory + -> DistDir pt + -- ^ Path to the @dist/@ or @dist-newstyle/@ directory, called + -- /builddir/ in Cabal terminology. + -> IO (QueryEnv pt) +mkQueryEnv projdir distdir = do + cr <- newIORef $ QueryCache Nothing Map.empty + return $ QueryEnv + { qeReadProcess = \mcwd exe args stdin -> + readCreateProcess (proc exe args){ cwd = mcwd } stdin + , qePrograms = defaultPrograms + , qeProjectDir = projdir + , qeDistDir = distdir + , qeCacheRef = cr + } --- | The component has a non-default module renaming, so needs build output (). -needsBuildOutput :: MonadIO m => ComponentQuery m NeedsBuildOutput +piUnits :: DistDir pt -> ProjInfo pt -> [Unit] +piUnits (DistDirV1 distdir) (ProjInfoV1 (ProjConfModTimesV1 (cabal_file, _))) = + (:[]) $ Unit + { uUnitId = UnitId "" + , uPackageDir = takeDirectory cabal_file + , uDistDir = DistDirLib distdir + } +piUnits _ ProjInfoV2{..} = + case lefts units of + [] -> rights units + us@(_:_) -> panic $ + msg ++ (concat $ map (unlines . map (" "++) . lines . ppShow) us) + where + msg = "\ +\plan.json doesn't contain 'dist-dir' key for the following local units:\n" + units = catMaybes $ map takeunit $ Map.elems $ pjUnits piV2Plan + takeunit u@CP.Unit + { uType=UnitTypeLocal + , uDistDir=Just distdirv1 + , uPkgSrc=Just (LocalUnpackedPackage pkgdir) + } = Just $ Right $ Unit + { uUnitId = UnitId $ Text.unpack (coerce (uId u)) + , uPackageDir = pkgdir + , uDistDir = DistDirLib distdirv1 + } + takeunit u@CP.Unit {uType=UnitTypeLocal} = + Just $ Left u + takeunit _ = + Nothing --- | A component's @source-dirs@ field, beware since if this is empty implicit --- behaviour in GHC kicks in. -sourceDirs :: MonadIO m => ComponentQuery m [FilePath] --- | All options Cabal would pass to GHC. -ghcOptions :: MonadIO m => ComponentQuery m [String] +-- | Find files relevant to the project-scope configuration. Depending on the +-- 'ProjType' this could be (for example) just a cabal file, one of the +-- @caba.project*@ files or @stack.yaml@. +-- +-- The returned paths include the project-dir path. +projConfModTimes :: ProjDir pt -> IO (ProjConfModTimes pt) +projConfModTimes pd@(ProjDirV1 _) = + ProjConfModTimesV1 <$> (getFileModTime =<< findCabalFile pd) +projConfModTimes (ProjDirV2 projdir) = do + ex_files <- filterM doesFileExist (map (projdir </>) additional_files) + let files = [ projdir </> "cabal.project" ] ++ ex_files + ProjConfModTimesV2 <$> mapM getFileModTime files + where + additional_files = + [ "cabal.project.local" + , "cabal.project.freeze" + ] + +getUnitModTimes :: Unit -> IO UnitModTimes +getUnitModTimes Unit { uDistDir=DistDirLib distdirv1, uPackageDir=pkgdir } = do + cabal_file <- findCabalFile (ProjDirV1 pkgdir) + cabal_file_mtime <- getFileModTime cabal_file + + let setup_config = distdirv1 </> "setup-config" + setup_config_mtime <- getFileModTime setup_config + + return UnitModTimes + { umtCabalFile = cabal_file_mtime + , umtSetupConfig = setup_config_mtime + } --- | Only search path related GHC options. -ghcSrcOptions :: MonadIO m => ComponentQuery m [String] --- | Only package related GHC options, sufficient for things don't need to --- access any home modules. -ghcPkgOptions :: MonadIO m => ComponentQuery m [String] +-- | The version of GHC the project is configured to use +compilerVersion :: Query pt (String, Version) +compilerVersion = undefined + +-- | List of units in a project +projectUnits :: Query pt [Unit] +projectUnits = Query $ \qe@QueryEnv{qeDistDir} -> + piUnits qeDistDir <$> getProjInfo qe --- | Only language related options, i.e. @-XSomeExtension@ -ghcLangOptions :: MonadIO m => ComponentQuery m [String] +-- | Run a 'UnitQuery' on a given unit. To get a a unit see 'projectUnits'. +unitQuery :: Unit -> Query pt UnitInfo +unitQuery u = Query $ \qe -> getUnitInfo qe u -packageId = Query $ getPackageId -packageDbStack = Query $ slbiPackageDbStack `liftM` getSlbi -packageFlags = Query $ slbiPackageFlags `liftM` getSlbi -compilerVersion = Query $ slbiCompilerVersion `liftM` getSlbi -ghcMergedPkgOptions = Query $ slbiGhcMergedPkgOptions `liftM` getSlbi -configFlags = Query $ slbiConfigFlags `liftM` getSlbi -nonDefaultConfigFlags = Query $ slbiNonDefaultConfigFlags `liftM` getSlbi -ghcSrcOptions = ComponentQuery $ Query $ slbiGhcSrcOptions `liftM` getSlbi -ghcPkgOptions = ComponentQuery $ Query $ slbiGhcPkgOptions `liftM` getSlbi -ghcOptions = ComponentQuery $ Query $ slbiGhcOptions `liftM` getSlbi -ghcLangOptions = ComponentQuery $ Query $ slbiGhcLangOptions `liftM` getSlbi -sourceDirs = ComponentQuery $ Query $ slbiSourceDirs `liftM` getSlbi -entrypoints = ComponentQuery $ Query $ slbiEntrypoints `liftM` getSlbi -needsBuildOutput = ComponentQuery $ Query $ slbiNeedsBuildOutput `liftM` getSlbi -- | Run @cabal configure@ reconfigure :: MonadIO m @@ -340,98 +428,205 @@ reconfigure readProc progs cabalOpts = do _ <- liftIO $ readProc (cabalProgram progs) ("configure":progOpts) "" return () -readHelper :: (MonadIO m, MonadQuery m) => [String] -> m [Maybe ChResponse] -readHelper args = ask >>= \qe -> liftIO $ do - out <- invokeHelper qe args - let res = read out - liftIO $ evaluate res `E.catch` \se@(SomeException _) -> do - md <- lookupEnv' "CABAL_HELPER_DEBUG" - let msg = "readHelper: exception: '" ++ show se ++ "'" - panicIO $ msg ++ case md of - Nothing -> ", for more information set the environment variable CABAL_HELPER_DEBUG" - Just _ -> ", output: '"++ out ++"'" - -invokeHelper :: QueryEnv -> [String] -> IO String -invokeHelper QueryEnv {..} args0 = do - let opts = defaultCompileOptions - { oPrograms = qePrograms - , oCabalPkgDb = PackageDbDir <$> qeCabalPkgDb } - opts' <- overrideVerbosityEnvVar =<< guessProgramPaths opts - - exe <- wrapperV1 opts' qeProjectDir qeDistDir +getProjInfo :: QueryEnv pt -> IO (ProjInfo pt) +getProjInfo qe@QueryEnv{..} = do + cache@QueryCache{qcProjInfo, qcUnitInfos} <- readIORef qeCacheRef + proj_info <- checkUpdateProj qe qcProjInfo + let active_units = piUnits qeDistDir proj_info + writeIORef qeCacheRef $ cache + { qcProjInfo = Just proj_info + , qcUnitInfos = discardInactiveUnitInfos active_units qcUnitInfos + } + return proj_info + +checkUpdateProj + :: QueryEnvI c pt + -> Maybe (ProjInfo pt) + -> IO (ProjInfo pt) +checkUpdateProj qe mproj_info = do + mtime <- projConfModTimes (qeProjectDir qe) + + case mproj_info of + Nothing -> reconf mtime + Just proj_info + | piProjConfModTimes proj_info /= mtime + -> reconf mtime + | otherwise + -> return proj_info + where + reconf mtime = do + shallowReconfigureProject qe + readProjInfo qe mtime + + + +getUnitInfo :: QueryEnv pt -> Unit -> IO UnitInfo +getUnitInfo qe@QueryEnv{..} unit@Unit{uDistDir} = do + proj_info <- getProjInfo qe + + cache@QueryCache{qcUnitInfos} <- readIORef qeCacheRef + let munit_info = Map.lookup uDistDir qcUnitInfos + unit_info <- checkUpdateUnitInfo qe proj_info unit munit_info + writeIORef qeCacheRef $ cache + { qcUnitInfos = Map.insert uDistDir unit_info qcUnitInfos } + return unit_info + +checkUpdateUnitInfo + :: QueryEnvI c pt + -> ProjInfo pt + -> Unit + -> Maybe UnitInfo + -> IO UnitInfo +checkUpdateUnitInfo qe proj_info unit munit_info = do + unit_mtimes <- getUnitModTimes unit + case munit_info of + Nothing -> reconf + Just unit_info + | uiModTimes unit_info /= unit_mtimes + -> reconf + | otherwise + -> return unit_info + where + reconf = do + reconfigureUnit qe unit + helper <- wrapper proj_info qe + readUnitInfo qe helper unit + +-- | Restrict 'UnitInfo' cache to units that are still active +discardInactiveUnitInfos + :: [Unit] + -> Map DistDirLib UnitInfo + -> Map DistDirLib UnitInfo +discardInactiveUnitInfos active_units uis0 = + restrictKeysMap uis0 $ Set.fromList $ map uDistDir active_units + where + restrictKeysMap :: Ord k => Map k a -> Set k -> Map k a + restrictKeysMap m s = Map.filterWithKey (\k _ -> Set.member k s) m + + +-- | Regenerate project level information by calling the appropriate build +-- system (@cabal@ or @stack@). +shallowReconfigureProject :: QueryEnvI c pt -> IO () +shallowReconfigureProject QueryEnv + { qeProjectDir = ProjDirV1 _projdir + , qeDistDir = DistDirV1 _distdirv1 } = + return () +shallowReconfigureProject QueryEnv + { qeProjectDir = ProjDirV2 projdir + , qeDistDir = DistDirV2 _distdirv2, .. } = do + _ <- liftIO $ qeReadProcess (Just projdir) (cabalProgram qePrograms) + ["v2-build", "--dry-run", "all"] "" + return () - let args1 = qeProjectDir : qeDistDir : args0 +reconfigureUnit :: QueryEnvI c pt -> Unit -> IO () +reconfigureUnit QueryEnv{qeDistDir=DistDirV1{}, ..} Unit{uPackageDir=_} = do + return () +reconfigureUnit QueryEnv{qeDistDir=DistDirV2{}, ..} Unit{uPackageDir=_} = do + return () + +findCabalFile :: ProjDir 'V1 -> IO FilePath +findCabalFile (ProjDirV1 pkgdir) = do + [cfile] <- filter isCabalFile <$> getDirectoryContents pkgdir + return cfile + +getFileModTime :: FilePath -> IO (FilePath, EpochTime) +getFileModTime f = do + t <- modificationTime <$> getFileStatus f + return (f, t) + +readProjInfo :: QueryEnvI c pt -> ProjConfModTimes pt -> IO (ProjInfo pt) +readProjInfo qe conf_files = do + case (qeProjectDir qe, qeDistDir qe) of + (ProjDirV1 _projdir, DistDirV1 _) -> + return $ ProjInfoV1 { piV1ProjConfModTimes = conf_files } + (ProjDirV2 _projdir, DistDirV2 distdirv2) -> do + let plan_path = distdirv2 </> "cache" </> "plan.json" + plan_mtime <- modificationTime <$> getFileStatus plan_path + plan <- decodePlanJson plan_path + return $ ProjInfoV2 + { piV2ProjConfModTimes = conf_files + , piV2Plan = plan + , piV2PlanModTime = plan_mtime + } + +readUnitInfo :: QueryEnvI c pt -> FilePath -> Unit -> IO UnitInfo +readUnitInfo + qe exe unit@Unit {uUnitId=uiUnitId, uPackageDir=pkgdir, uDistDir=distdir} = do + res <- readHelper qe exe pkgdir distdir + [ "package-db-stack" + , "flags" + , "compiler-version" + , "config-flags" + , "non-default-config-flags" + , "component-info" + ] + let [ Just (ChResponsePkgDbs uiPackageDbStack), + Just (ChResponseFlags uiPackageFlags), + Just (ChResponseVersion comp compVer), + Just (ChResponseFlags uiConfigFlags), + Just (ChResponseFlags uiNonDefaultConfigFlags), + Just (ChResponseComponentsInfo uiComponents) + ] = res + uiCompilerVersion = (comp, compVer) + uiModTimes <- getUnitModTimes unit + return $ UnitInfo {..} + +readHelper + :: QueryEnvI c pt + -> FilePath + -> FilePath + -> DistDirLib + -> [String] + -> IO [Maybe ChResponse] +readHelper qe exe cabal_file distdir args = do + out <- invokeHelper qe exe cabal_file distdir args + let res :: [Maybe ChResponse] + res = read out + liftIO $ evaluate res `E.catch` \ex@ErrorCall{} -> do + md <- lookupEnv' "CABAL_HELPER_DEBUG" + let msg = "readHelper: exception: '" ++ show ex ++ "'" + panicIO $ msg ++ case md of + Nothing -> "\n for more information set the environment variable CABAL_HELPER_DEBUG and try again" + Just _ -> "\n output:\n'"++ out ++"'" - out <- qeReadProcess exe args1 "" - evaluate out `E.catch` \(SomeException _) -> +invokeHelper + :: QueryEnvI c pt + -> FilePath + -> FilePath + -> DistDirLib + -> [String] + -> IO String +invokeHelper QueryEnv {..} exe cabal_file (DistDirLib distdir) args0 = do + let args1 = cabal_file : distdir : args0 + evaluate =<< qeReadProcess Nothing exe args1 "" `E.catch` + \(_ :: E.IOException) -> panicIO $ concat ["invokeHelper", ": ", exe, " " , intercalate " " (map show args1) , " failed!" ] -getPackageId :: (MonadQuery m, MonadIO m) => m (String, Version) -getPackageId = ask >>= \QueryEnv {..} -> liftIO $ do - let v = silent - [cfile] <- filter isCabalFile <$> getDirectoryContents qeProjectDir - gpd <- readPackageDescription v (qeProjectDir </> cfile) - return $ (display (packageName gpd), toDataVersion (packageVersion gpd)) - -getSomeConfigState :: MonadQuery m => m SomeLocalBuildInfo -getSomeConfigState = ask >>= \QueryEnv {..} -> do - res <- readHelper - [ "package-db-stack" - , "flags" - , "compiler-version" - - , "ghc-merged-pkg-options" - - , "config-flags" - , "non-default-config-flags" - - , "ghc-src-options" - , "ghc-pkg-options" - , "ghc-lang-options" - , "ghc-options" - - , "source-dirs" - , "entrypoints" - , "needs-build-output" - ] - let [ Just (ChResponsePkgDbs slbiPackageDbStack), - Just (ChResponseFlags slbiPackageFlags), - Just (ChResponseVersion comp compVer), - - Just (ChResponseList slbiGhcMergedPkgOptions), - - Just (ChResponseFlags slbiConfigFlags), - Just (ChResponseFlags slbiNonDefaultConfigFlags), - - Just (ChResponseCompList slbiGhcSrcOptions), - Just (ChResponseCompList slbiGhcPkgOptions), - Just (ChResponseCompList slbiGhcLangOptions), - Just (ChResponseCompList slbiGhcOptions), - - Just (ChResponseCompList slbiSourceDirs), - Just (ChResponseEntrypoints slbiEntrypoints), - Just (ChResponseNeedsBuild slbiNeedsBuildOutput) - ] = res - slbiCompilerVersion = (comp, compVer) - return $ SomeLocalBuildInfo {..} - +-- getPackageId :: QueryEnv pt -> IO (String, Version) +-- getPackageId QueryEnv{..} = do +-- [cfile] <- filter isCabalFile <$> getDirectoryContents qeProjectDir +-- gpd <- readPackageDescription silent (qeProjectDir </> cfile) +-- return $ (display (packageName gpd), toDataVersion (packageVersion gpd)) -- | Make sure the appropriate helper executable for the given project is -- installed and ready to run queries. -prepare :: MonadIO m => QueryEnv -> m () -prepare qe = - liftIO $ void $ invokeHelper qe [] +prepare :: QueryEnv pt -> IO () +prepare qe = do + proj_info <- getProjInfo qe + void $ wrapper proj_info qe -- | Create @cabal_macros.h@ and @Paths_\<pkg\>@ possibly other generated files -- in the usual place. -writeAutogenFiles :: MonadIO m => QueryEnv -> m () -writeAutogenFiles qe = - liftIO $ void $ invokeHelper qe ["write-autogen-files"] +writeAutogenFiles :: QueryEnv pt -> IO () +writeAutogenFiles qe = do + proj_info <- getProjInfo qe + _exe <- wrapper proj_info qe + undefined -- void $ invokeHelper qe exe ["write-autogen-files"] -- | Get the path to the sandbox package-db in a project getSandboxPkgDb @@ -452,16 +647,15 @@ buildPlatform = display Distribution.System.buildPlatform lookupEnv' :: String -> IO (Maybe String) lookupEnv' k = lookup k <$> getEnvironment +guessProgramPaths :: (Verbose, Progs) => (Progs => IO a) -> IO a +guessProgramPaths act = do + let v | ?verbose = deafening + | otherwise = silent -guessProgramPaths :: CompileOptions -> IO CompileOptions -guessProgramPaths opts = do - let v | oVerbose opts = deafening - | otherwise = silent - - mGhcPath0 | same ghcProgram progs dprogs = Nothing - | otherwise = Just $ ghcProgram progs - mGhcPkgPath0 | same ghcPkgProgram progs dprogs = Nothing - | otherwise = Just $ ghcPkgProgram progs + mGhcPath0 | same ghcProgram ?progs dprogs = Nothing + | otherwise = Just $ ghcProgram ?progs + mGhcPkgPath0 | same ghcPkgProgram ?progs dprogs = Nothing + | otherwise = Just $ ghcPkgProgram ?progs (_compiler, _mplatform, progdb) <- GHC.configure @@ -473,90 +667,72 @@ guessProgramPaths opts = do mghcPath1 = getProg ProgDb.ghcProgram mghcPkgPath1 = getProg ProgDb.ghcPkgProgram - progs' = progs - { ghcProgram = fromMaybe (ghcProgram progs) mghcPath1 - , ghcPkgProgram = fromMaybe (ghcProgram progs) mghcPkgPath1 + let ?progs = ?progs + { ghcProgram = fromMaybe (ghcProgram ?progs) mghcPath1 + , ghcPkgProgram = fromMaybe (ghcProgram ?progs) mghcPkgPath1 } - return opts { oPrograms = progs' } + act where same f o o' = f o == f o' - progs = oPrograms opts dprogs = defaultPrograms -overrideVerbosityEnvVar :: CompileOptions -> IO CompileOptions -overrideVerbosityEnvVar opts = do +withVerbosity :: (Verbose => a) -> IO a +withVerbosity a = do x <- lookup "CABAL_HELPER_DEBUG" <$> getEnvironment - return $ case x of - Just _ -> opts { oVerbose = True } - Nothing -> opts - -wrapperV1 - :: CompileOptions - -> FilePath - -> FilePath + let ?verbose = + case x of + Just xs | not (null xs) -> True + _ -> False + return a + +wrapper + :: ProjInfo pt -> QueryEnvI c pt -> IO FilePath +wrapper proj_info QueryEnv{..} = do + join $ withVerbosity $ do + let ?progs = qePrograms + guessProgramPaths $ wrapper' qeProjectDir qeDistDir proj_info + +wrapper' + :: Env + => ProjDir pt + -> DistDir pt + -> ProjInfo pt -> IO FilePath -wrapperV1 opts projdir distdir = do +wrapper' (ProjDirV1 projdir) (DistDirV1 distdir) _ = do cfgf <- canonicalizePath (distdir </> "setup-config") mhdr <- getCabalConfigHeader cfgf - case (mhdr, oCabalVersion opts) of - (Nothing, _) -> panicIO $ printf "\ + case mhdr of + Nothing -> panicIO $ printf "\ \Could not read Cabal's persistent setup configuration header\n\ \- Check first line of: %s\n\ \- Maybe try: $ cabal configure" cfgf - (Just (hdrCabalVersion, _), Just ver) - | hdrCabalVersion /= ver -> panicIO $ printf "\ -\Cabal version %s was requested but setup configuration was\n\ -\written by version %s" (showVersion ver) (showVersion hdrCabalVersion) - (Just (hdrCabalVersion, _), _) -> do - compileHelper' opts hdrCabalVersion projdir Nothing distdir - -wrapperV2 - :: CompileOptions - -> FilePath - -> FilePath - -> UnitId - -> IO (FilePath, FilePath) -wrapperV2 opts projdir distdir unitid@(UnitId (Text.unpack -> unitid')) = do - let plan_path = distdir </> "cache" </> "plan.json" - plan@PlanJson {pjCabalLibVersion=Ver (makeDataVersion -> pjCabalLibVersion) } - <- decodePlanJson plan_path - case oCabalVersion opts of - Just ver | pjCabalLibVersion /= ver -> let - sver = showVersion ver - spjVer = showVersion pjCabalLibVersion - in panicIO $ printf "\ -\Cabal version %s was requested but plan.json was written by version %s" sver spjVer - _ -> case Map.lookup unitid $ pjUnits plan of - Just u@Unit {uType} | uType /= UnitTypeLocal -> do - panicIO $ "\ -\UnitId '"++ unitid' ++"' points to non-local unit: " ++ ppShow u - Just Unit {uDistDir=Nothing} -> panicIO $ printf "\ -\plan.json doesn't contain 'dist-dir' for UnitId '"++ unitid' ++"'" - Just Unit {uType=UnitTypeLocal, uDistDir=Just distdirv1} -> do - exe <- compileHelper' opts pjCabalLibVersion projdir (Just (plan, distdir)) distdirv1 - return (exe, distdirv1) - _ -> let - units = map (\(UnitId u) -> Text.unpack u) - $ Map.keys - $ Map.filter ((==UnitTypeLocal) . uType) - $ pjUnits plan - units_list = unlines $ map (" "++) units - in - panicIO $ "\ -\UnitId '"++ unitid' ++"' not found in plan.json, available local units:\n" ++ units_list - + Just (hdrCabalVersion, _) -> do + compileHelper' hdrCabalVersion Nothing projdir Nothing distdir +wrapper' + (ProjDirV2 projdir) + (DistDirV2 distdir) + ProjInfoV2{piV2Plan=plan} + = do + let PlanJson {pjCabalLibVersion=Ver (makeDataVersion -> pjCabalLibVersion) } + = plan + compileHelper' pjCabalLibVersion + Nothing + projdir + (Just (plan, distdir)) + (distdir </> "cache") compileHelper' - :: CompileOptions - -> Version + :: Env + => Version + -> Maybe PackageDbDir -> FilePath -> Maybe (PlanJson, FilePath) -> FilePath -> IO FilePath -compileHelper' opts pjCabalLibVersion projdir mnewstyle distdirv1 = do - eexe <- compileHelper opts pjCabalLibVersion projdir mnewstyle distdirv1 +compileHelper' pjCabalLibVersion cabalPkgDb projdir mnewstyle distdirv1 = do + eexe <- compileHelper pjCabalLibVersion cabalPkgDb projdir mnewstyle distdirv1 case eexe of Left rv -> - panicIO $ "compileHelper': compiling helper failed! (exit code "++ show rv + panicIO $ "compileHelper': compiling helper failed! (exit code "++ show rv Right exe -> - return exe + return exe |