{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE OverloadedRecordDot #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Stack.Package
( readDotBuildinfo
, resolvePackage
, packageFromPackageDescription
, Package (..)
, PackageConfig (..)
, buildLogPath
, PackageException (..)
, resolvePackageDescription
, packageDependencies
, applyForceCustomBuild
, hasBuildableMainLibrary
, mainLibraryHasExposedModules
, packageUnknownTools
, buildableForeignLibs
, buildableSubLibs
, buildableExes
, buildableTestSuites
, buildableBenchmarks
, getPackageOpts
, processPackageDepsEither
, listOfPackageDeps
, setOfPackageDeps
, topSortPackageComponent
) where
import qualified Data.Map.Strict as M
import qualified Data.Set as S
import qualified Data.Text as T
import Distribution.CabalSpecVersion ( cabalSpecToVersionDigits )
import Distribution.Compiler
( CompilerFlavor (..), PerCompilerFlavor (..) )
import Distribution.ModuleName ( ModuleName )
import Distribution.Package ( mkPackageName )
import Distribution.PackageDescription
( Benchmark (..), BuildInfo (..), BuildType (..)
, CondTree (..), Condition (..), ConfVar (..)
, Dependency (..), Executable (..), ForeignLib (..)
, GenericPackageDescription (..), HookedBuildInfo
, Library (..), PackageDescription (..), PackageFlag (..)
, SetupBuildInfo (..), TestSuite (..), allLibraries
, buildType, depPkgName, depVerRange
, unqualComponentNameToPackageName
)
import qualified Distribution.PackageDescription as Executable
( Executable (..) )
import Distribution.Simple.PackageDescription ( readHookedBuildInfo )
import Distribution.System ( OS (..), Arch, Platform (..) )
import Distribution.Text ( display )
import qualified Distribution.Types.CondTree as Cabal
import Distribution.Utils.Path ( getSymbolicPath )
import Distribution.Verbosity ( silent )
import Distribution.Version
( anyVersion, mkVersion, orLaterVersion )
import Path
( (</>), parent, parseAbsDir, parseRelDir, parseRelFile
, stripProperPrefix
)
import Path.Extra ( concatAndCollapseAbsDir, toFilePathNoTrailingSep )
import Stack.Component
( componentDependencyMap, foldOnNameAndBuildInfo
, isComponentBuildable, stackBenchmarkFromCabal
, stackExecutableFromCabal, stackForeignLibraryFromCabal
, stackLibraryFromCabal, stackTestFromCabal
)
import Stack.ComponentFile
( buildDir, componentAutogenDir, componentBuildDir
, componentOutputDir, packageAutogenDir
)
import Stack.Constants ( relFileCabalMacrosH, relDirLogs )
import Stack.Constants.Config ( distDirFromDir )
import Stack.PackageFile ( getPackageFile, stackPackageFileFromCabal )
import Stack.Prelude hiding ( Display (..) )
import Stack.Types.BuildConfig ( HasBuildConfig (..), getWorkDir )
import Stack.Types.CompCollection
( CompCollection, collectionLookup, foldAndMakeCollection
, foldComponentToAnotherCollection, getBuildableSet
, getBuildableSetText
)
import Stack.Types.Compiler ( ActualCompiler (..) )
import Stack.Types.CompilerPaths ( cabalVersionL )
import Stack.Types.Component
( HasBuildInfo, HasComponentInfo, StackUnqualCompName (..) )
import Stack.Types.ComponentUtils ( emptyCompName, toCabalName )
import qualified Stack.Types.Component as Component
import Stack.Types.Config ( Config (..), HasConfig (..) )
import Stack.Types.Dependency
( DepLibrary (..), DepType (..), DepValue (..)
, cabalSetupDepsToStackDep, libraryDepFromVersionRange
)
import Stack.Types.EnvConfig ( HasEnvConfig )
import Stack.Types.Installed
( InstallMap, Installed (..), InstalledMap
, installedToPackageIdOpt
)
import Stack.Types.NamedComponent
( NamedComponent (..), isPotentialDependency
, subLibComponents
)
import Stack.Types.Package
( BioInput(..), BuildInfoOpts (..), Package (..)
, PackageConfig (..), PackageException (..)
, dotCabalCFilePath, packageIdentifier
)
import Stack.Types.PackageFile
( DotCabalPath, PackageComponentFile (..) )
import Stack.Types.SourceMap ( Target(..), PackageType (..) )
import Stack.Types.Version
( VersionRange, intersectVersionRanges, withinRange )
import System.FilePath ( replaceExtension )
import RIO.Seq ((|>))
readDotBuildinfo :: MonadIO m => Path Abs File -> m HookedBuildInfo
readDotBuildinfo :: forall (m :: * -> *).
MonadIO m =>
Path Abs File -> m HookedBuildInfo
readDotBuildinfo Path Abs File
buildinfofp =
IO HookedBuildInfo -> m HookedBuildInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HookedBuildInfo -> m HookedBuildInfo)
-> IO HookedBuildInfo -> m HookedBuildInfo
forall a b. (a -> b) -> a -> b
$ Verbosity -> String -> IO HookedBuildInfo
readHookedBuildInfo Verbosity
silent (Path Abs File -> String
forall b t. Path b t -> String
toFilePath Path Abs File
buildinfofp)
resolvePackage :: PackageConfig -> GenericPackageDescription -> Package
resolvePackage :: PackageConfig -> GenericPackageDescription -> Package
resolvePackage PackageConfig
packageConfig GenericPackageDescription
gpkg =
PackageConfig -> [PackageFlag] -> PackageDescription -> Package
packageFromPackageDescription
PackageConfig
packageConfig
(GenericPackageDescription -> [PackageFlag]
genPackageFlags GenericPackageDescription
gpkg)
(PackageConfig -> GenericPackageDescription -> PackageDescription
resolvePackageDescription PackageConfig
packageConfig GenericPackageDescription
gpkg)
packageFromPackageDescription ::
PackageConfig
-> [PackageFlag]
-> PackageDescription
-> Package
packageFromPackageDescription :: PackageConfig -> [PackageFlag] -> PackageDescription -> Package
packageFromPackageDescription
PackageConfig
packageConfig
[PackageFlag]
pkgFlags
PackageDescription
pkg
= Package
{ name :: PackageName
name = PackageName
name
, version :: Version
version = PackageIdentifier -> Version
pkgVersion PackageIdentifier
pkgId
, license :: Either License License
license = PackageDescription -> Either License License
licenseRaw PackageDescription
pkg
, ghcOptions :: [Text]
ghcOptions = PackageConfig
packageConfig.ghcOptions
, cabalConfigOpts :: [Text]
cabalConfigOpts = PackageConfig
packageConfig.cabalConfigOpts
, flags :: Map FlagName Bool
flags = PackageConfig
packageConfig.flags
, defaultFlags :: Map FlagName Bool
defaultFlags = [(FlagName, Bool)] -> Map FlagName Bool
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
[(PackageFlag -> FlagName
flagName PackageFlag
flag, PackageFlag -> Bool
flagDefault PackageFlag
flag) | PackageFlag
flag <- [PackageFlag]
pkgFlags]
, library :: Maybe StackLibrary
library = Library -> StackLibrary
stackLibraryFromCabal (Library -> StackLibrary) -> Maybe Library -> Maybe StackLibrary
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackageDescription -> Maybe Library
library PackageDescription
pkg
, subLibraries :: CompCollection StackLibrary
subLibraries =
(Library -> StackLibrary)
-> [Library] -> CompCollection StackLibrary
forall compB (sourceCollection :: * -> *) compA.
(HasBuildInfo compB, HasName compB, Foldable sourceCollection) =>
(compA -> compB) -> sourceCollection compA -> CompCollection compB
foldAndMakeCollection Library -> StackLibrary
stackLibraryFromCabal ([Library] -> CompCollection StackLibrary)
-> [Library] -> CompCollection StackLibrary
forall a b. (a -> b) -> a -> b
$ PackageDescription -> [Library]
subLibraries PackageDescription
pkg
, foreignLibraries :: CompCollection StackForeignLibrary
foreignLibraries =
(ForeignLib -> StackForeignLibrary)
-> [ForeignLib] -> CompCollection StackForeignLibrary
forall compB (sourceCollection :: * -> *) compA.
(HasBuildInfo compB, HasName compB, Foldable sourceCollection) =>
(compA -> compB) -> sourceCollection compA -> CompCollection compB
foldAndMakeCollection ForeignLib -> StackForeignLibrary
stackForeignLibraryFromCabal ([ForeignLib] -> CompCollection StackForeignLibrary)
-> [ForeignLib] -> CompCollection StackForeignLibrary
forall a b. (a -> b) -> a -> b
$ PackageDescription -> [ForeignLib]
foreignLibs PackageDescription
pkg
, testSuites :: CompCollection StackTestSuite
testSuites =
(TestSuite -> StackTestSuite)
-> [TestSuite] -> CompCollection StackTestSuite
forall compB (sourceCollection :: * -> *) compA.
(HasBuildInfo compB, HasName compB, Foldable sourceCollection) =>
(compA -> compB) -> sourceCollection compA -> CompCollection compB
foldAndMakeCollection TestSuite -> StackTestSuite
stackTestFromCabal ([TestSuite] -> CompCollection StackTestSuite)
-> [TestSuite] -> CompCollection StackTestSuite
forall a b. (a -> b) -> a -> b
$ PackageDescription -> [TestSuite]
testSuites PackageDescription
pkg
, benchmarks :: CompCollection StackBenchmark
benchmarks =
(Benchmark -> StackBenchmark)
-> [Benchmark] -> CompCollection StackBenchmark
forall compB (sourceCollection :: * -> *) compA.
(HasBuildInfo compB, HasName compB, Foldable sourceCollection) =>
(compA -> compB) -> sourceCollection compA -> CompCollection compB
foldAndMakeCollection Benchmark -> StackBenchmark
stackBenchmarkFromCabal ([Benchmark] -> CompCollection StackBenchmark)
-> [Benchmark] -> CompCollection StackBenchmark
forall a b. (a -> b) -> a -> b
$ PackageDescription -> [Benchmark]
benchmarks PackageDescription
pkg
, executables :: CompCollection StackExecutable
executables =
(Executable -> StackExecutable)
-> [Executable] -> CompCollection StackExecutable
forall compB (sourceCollection :: * -> *) compA.
(HasBuildInfo compB, HasName compB, Foldable sourceCollection) =>
(compA -> compB) -> sourceCollection compA -> CompCollection compB
foldAndMakeCollection Executable -> StackExecutable
stackExecutableFromCabal ([Executable] -> CompCollection StackExecutable)
-> [Executable] -> CompCollection StackExecutable
forall a b. (a -> b) -> a -> b
$ PackageDescription -> [Executable]
executables PackageDescription
pkg
, buildType :: BuildType
buildType = PackageDescription -> BuildType
buildType PackageDescription
pkg
, setupDeps :: Maybe (Map PackageName DepValue)
setupDeps = (SetupBuildInfo -> Map PackageName DepValue)
-> Maybe SetupBuildInfo -> Maybe (Map PackageName DepValue)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SetupBuildInfo -> Map PackageName DepValue
cabalSetupDepsToStackDep (PackageDescription -> Maybe SetupBuildInfo
setupBuildInfo PackageDescription
pkg)
, cabalSpec :: CabalSpecVersion
cabalSpec = PackageDescription -> CabalSpecVersion
specVersion PackageDescription
pkg
, file :: StackPackageFile
file = PackageDescription -> StackPackageFile
stackPackageFileFromCabal PackageDescription
pkg
, testEnabled :: Bool
testEnabled = PackageConfig
packageConfig.enableTests
, benchmarkEnabled :: Bool
benchmarkEnabled = PackageConfig
packageConfig.enableBenchmarks
}
where
pkgId :: PackageIdentifier
pkgId = PackageDescription -> PackageIdentifier
package PackageDescription
pkg
name :: PackageName
name = PackageIdentifier -> PackageName
pkgName PackageIdentifier
pkgId
getPackageOpts ::
(HasEnvConfig env, MonadReader env m, MonadThrow m, MonadUnliftIO m )
=> Package
-> InstallMap
-> InstalledMap
-> [PackageName]
-> [PackageName]
-> Path Abs File
-> m ( Map NamedComponent (Map ModuleName (Path Abs File))
, Map NamedComponent [DotCabalPath]
, Map NamedComponent BuildInfoOpts
)
getPackageOpts :: forall env (m :: * -> *).
(HasEnvConfig env, MonadReader env m, MonadThrow m,
MonadUnliftIO m) =>
Package
-> InstallMap
-> InstalledMap
-> [PackageName]
-> [PackageName]
-> Path Abs File
-> m (Map NamedComponent (Map ModuleName (Path Abs File)),
Map NamedComponent [DotCabalPath],
Map NamedComponent BuildInfoOpts)
getPackageOpts
Package
stackPackage
InstallMap
installMap
InstalledMap
installedMap
[PackageName]
omitPkgs
[PackageName]
addPkgs
Path Abs File
cabalFP
= do
PackageComponentFile !Map NamedComponent (Map ModuleName (Path Abs File))
componentsModules Map NamedComponent [DotCabalPath]
componentFiles Set (Path Abs File)
_ [PackageWarning]
_ <-
Package -> Path Abs File -> m PackageComponentFile
forall s (m :: * -> *).
(HasEnvConfig s, MonadReader s m, MonadThrow m, MonadUnliftIO m) =>
Package -> Path Abs File -> m PackageComponentFile
getPackageFile Package
stackPackage Path Abs File
cabalFP
let subLibs :: [StackUnqualCompName]
subLibs =
Set StackUnqualCompName -> [StackUnqualCompName]
forall a. Set a -> [a]
S.toList (Set StackUnqualCompName -> [StackUnqualCompName])
-> Set StackUnqualCompName -> [StackUnqualCompName]
forall a b. (a -> b) -> a -> b
$ Set NamedComponent -> Set StackUnqualCompName
subLibComponents (Set NamedComponent -> Set StackUnqualCompName)
-> Set NamedComponent -> Set StackUnqualCompName
forall a b. (a -> b) -> a -> b
$ Map NamedComponent (Map ModuleName (Path Abs File))
-> Set NamedComponent
forall k a. Map k a -> Set k
M.keysSet Map NamedComponent (Map ModuleName (Path Abs File))
componentsModules
excludedSubLibs :: [PackageName]
excludedSubLibs =
(StackUnqualCompName -> PackageName)
-> [StackUnqualCompName] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map (UnqualComponentName -> PackageName
unqualComponentNameToPackageName (UnqualComponentName -> PackageName)
-> (StackUnqualCompName -> UnqualComponentName)
-> StackUnqualCompName
-> PackageName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StackUnqualCompName -> UnqualComponentName
toCabalName) [StackUnqualCompName]
subLibs
Map NamedComponent BuildInfoOpts
componentsOpts <- InstallMap
-> InstalledMap
-> [PackageName]
-> [PackageName]
-> Path Abs File
-> Package
-> Map NamedComponent [DotCabalPath]
-> m (Map NamedComponent BuildInfoOpts)
forall env (m :: * -> *).
(HasEnvConfig env, MonadThrow m, MonadReader env m, MonadIO m) =>
InstallMap
-> InstalledMap
-> [PackageName]
-> [PackageName]
-> Path Abs File
-> Package
-> Map NamedComponent [DotCabalPath]
-> m (Map NamedComponent BuildInfoOpts)
generatePkgDescOpts
InstallMap
installMap
InstalledMap
installedMap
([PackageName]
excludedSubLibs [PackageName] -> [PackageName] -> [PackageName]
forall a. [a] -> [a] -> [a]
++ [PackageName]
omitPkgs)
[PackageName]
addPkgs
Path Abs File
cabalFP
Package
stackPackage
Map NamedComponent [DotCabalPath]
componentFiles
(Map NamedComponent (Map ModuleName (Path Abs File)),
Map NamedComponent [DotCabalPath],
Map NamedComponent BuildInfoOpts)
-> m (Map NamedComponent (Map ModuleName (Path Abs File)),
Map NamedComponent [DotCabalPath],
Map NamedComponent BuildInfoOpts)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map NamedComponent (Map ModuleName (Path Abs File))
componentsModules, Map NamedComponent [DotCabalPath]
componentFiles, Map NamedComponent BuildInfoOpts
componentsOpts)
generatePkgDescOpts ::
(HasEnvConfig env, MonadThrow m, MonadReader env m, MonadIO m)
=> InstallMap
-> InstalledMap
-> [PackageName]
-> [PackageName]
-> Path Abs File
-> Package
-> Map NamedComponent [DotCabalPath]
-> m (Map NamedComponent BuildInfoOpts)
generatePkgDescOpts :: forall env (m :: * -> *).
(HasEnvConfig env, MonadThrow m, MonadReader env m, MonadIO m) =>
InstallMap
-> InstalledMap
-> [PackageName]
-> [PackageName]
-> Path Abs File
-> Package
-> Map NamedComponent [DotCabalPath]
-> m (Map NamedComponent BuildInfoOpts)
generatePkgDescOpts
InstallMap
installMap
InstalledMap
installedMap
[PackageName]
omitPackages
[PackageName]
addPackages
Path Abs File
cabalFP
Package
pkg
Map NamedComponent [DotCabalPath]
componentPaths
= do
Config
config <- Getting Config env Config -> m Config
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Config env Config
forall env. HasConfig env => Lens' env Config
Lens' env Config
configL
Version
cabalVersion <- Getting Version env Version -> m Version
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Version env Version
forall env. HasCompiler env => SimpleGetter env Version
SimpleGetter env Version
cabalVersionL
Path Abs Dir
distDir <- Path Abs Dir -> m (Path Abs Dir)
forall env (m :: * -> *).
(HasEnvConfig env, MonadReader env m, MonadThrow m) =>
Path Abs Dir -> m (Path Abs Dir)
distDirFromDir Path Abs Dir
cabalDir
let generate :: NamedComponent -> StackBuildInfo -> BuildInfoOpts
generate NamedComponent
componentName StackBuildInfo
buildInfo = BioInput -> BuildInfoOpts
generateBuildInfoOpts BioInput
{ InstallMap
installMap :: InstallMap
installMap :: InstallMap
installMap
, InstalledMap
installedMap :: InstalledMap
installedMap :: InstalledMap
installedMap
, Path Abs Dir
cabalDir :: Path Abs Dir
cabalDir :: Path Abs Dir
cabalDir
, Path Abs Dir
distDir :: Path Abs Dir
distDir :: Path Abs Dir
distDir
, [PackageName]
omitPackages :: [PackageName]
omitPackages :: [PackageName]
omitPackages
, [PackageName]
addPackages :: [PackageName]
addPackages :: [PackageName]
addPackages
, StackBuildInfo
buildInfo :: StackBuildInfo
buildInfo :: StackBuildInfo
buildInfo
, dotCabalPaths :: [DotCabalPath]
dotCabalPaths =
[DotCabalPath] -> Maybe [DotCabalPath] -> [DotCabalPath]
forall a. a -> Maybe a -> a
fromMaybe [] (NamedComponent
-> Map NamedComponent [DotCabalPath] -> Maybe [DotCabalPath]
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup NamedComponent
componentName Map NamedComponent [DotCabalPath]
componentPaths)
, configLibDirs :: [String]
configLibDirs = Config
config.extraLibDirs
, configIncludeDirs :: [String]
configIncludeDirs = Config
config.extraIncludeDirs
, NamedComponent
componentName :: NamedComponent
componentName :: NamedComponent
componentName
, Version
cabalVersion :: Version
cabalVersion :: Version
cabalVersion
}
let insertInMap :: NamedComponent
-> StackBuildInfo
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
insertInMap NamedComponent
name StackBuildInfo
compVal = NamedComponent
-> BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert NamedComponent
name (NamedComponent -> StackBuildInfo -> BuildInfoOpts
generate NamedComponent
name StackBuildInfo
compVal)
let translatedInsertInMap :: (t -> NamedComponent)
-> t
-> StackBuildInfo
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
translatedInsertInMap t -> NamedComponent
constructor t
name =
NamedComponent
-> StackBuildInfo
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
insertInMap (t -> NamedComponent
constructor t
name)
let makeBuildInfoOpts :: (Package -> c a)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
makeBuildInfoOpts Package -> c a
selector StackUnqualCompName -> NamedComponent
constructor =
c a
-> (StackUnqualCompName
-> StackBuildInfo
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall a (c :: * -> *) t.
(HasField "buildInfo" a StackBuildInfo,
HasField "name" a StackUnqualCompName, Foldable c) =>
c a -> (StackUnqualCompName -> StackBuildInfo -> t -> t) -> t -> t
foldOnNameAndBuildInfo
(Package -> c a
selector Package
pkg)
((StackUnqualCompName -> NamedComponent)
-> StackUnqualCompName
-> StackBuildInfo
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall {t}.
(t -> NamedComponent)
-> t
-> StackBuildInfo
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
translatedInsertInMap StackUnqualCompName -> NamedComponent
constructor)
let aggregateAllBuildInfoOpts :: Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
aggregateAllBuildInfoOpts =
(Package -> Maybe StackLibrary)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall {a} {c :: * -> *}.
(HasField "name" a StackUnqualCompName,
HasField "buildInfo" a StackBuildInfo, Foldable c) =>
(Package -> c a)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
makeBuildInfoOpts (.library) (NamedComponent -> StackUnqualCompName -> NamedComponent
forall a b. a -> b -> a
const NamedComponent
CLib)
(Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> (Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Package -> CompCollection StackLibrary)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall {a} {c :: * -> *}.
(HasField "name" a StackUnqualCompName,
HasField "buildInfo" a StackBuildInfo, Foldable c) =>
(Package -> c a)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
makeBuildInfoOpts (.subLibraries) StackUnqualCompName -> NamedComponent
CSubLib
(Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> (Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Package -> CompCollection StackExecutable)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall {a} {c :: * -> *}.
(HasField "name" a StackUnqualCompName,
HasField "buildInfo" a StackBuildInfo, Foldable c) =>
(Package -> c a)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
makeBuildInfoOpts (.executables) StackUnqualCompName -> NamedComponent
CExe
(Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> (Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Package -> CompCollection StackBenchmark)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall {a} {c :: * -> *}.
(HasField "name" a StackUnqualCompName,
HasField "buildInfo" a StackBuildInfo, Foldable c) =>
(Package -> c a)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
makeBuildInfoOpts (.benchmarks) StackUnqualCompName -> NamedComponent
CBench
(Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> (Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Package -> CompCollection StackTestSuite)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
forall {a} {c :: * -> *}.
(HasField "name" a StackUnqualCompName,
HasField "buildInfo" a StackBuildInfo, Foldable c) =>
(Package -> c a)
-> (StackUnqualCompName -> NamedComponent)
-> Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
makeBuildInfoOpts (.testSuites) StackUnqualCompName -> NamedComponent
CTest
Map NamedComponent BuildInfoOpts
-> m (Map NamedComponent BuildInfoOpts)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map NamedComponent BuildInfoOpts
-> m (Map NamedComponent BuildInfoOpts))
-> Map NamedComponent BuildInfoOpts
-> m (Map NamedComponent BuildInfoOpts)
forall a b. (a -> b) -> a -> b
$ Map NamedComponent BuildInfoOpts
-> Map NamedComponent BuildInfoOpts
aggregateAllBuildInfoOpts Map NamedComponent BuildInfoOpts
forall a. Monoid a => a
mempty
where
cabalDir :: Path Abs Dir
cabalDir = Path Abs File -> Path Abs Dir
forall b t. Path b t -> Path b Dir
parent Path Abs File
cabalFP
generateBuildInfoOpts :: BioInput -> BuildInfoOpts
generateBuildInfoOpts :: BioInput -> BuildInfoOpts
generateBuildInfoOpts BioInput
bi =
BuildInfoOpts
{ opts :: [String]
opts =
[String]
ghcOpts
[String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (String
"-optP" <>) BioInput
bi.buildInfo.cppOptions
, oneWordOpts :: [String]
oneWordOpts = [String] -> [String]
forall a. Ord a => [a] -> [a]
nubOrd ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ [[String]] -> [String]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
[[String]
extOpts, [String]
srcOpts, [String]
includeOpts, [String]
libOpts, [String]
fworks, [String]
cObjectFiles]
, packageFlags :: [String]
packageFlags = [String]
deps
, cabalMacros :: Path Abs File
cabalMacros = Path Abs Dir
componentAutogen Path Abs Dir -> Path Rel File -> Path Abs File
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel File
relFileCabalMacrosH
}
where
cObjectFiles :: [String]
cObjectFiles = (Path Abs File -> Maybe String) -> [Path Abs File] -> [String]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe
( (Path Abs File -> String) -> Maybe (Path Abs File) -> Maybe String
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path Abs File -> String
forall b t. Path b t -> String
toFilePath
(Maybe (Path Abs File) -> Maybe String)
-> (Path Abs File -> Maybe (Path Abs File))
-> Path Abs File
-> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir
-> NamedComponent
-> Path Abs Dir
-> Path Abs File
-> Maybe (Path Abs File)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir
-> NamedComponent
-> Path Abs Dir
-> Path Abs File
-> m (Path Abs File)
makeObjectFilePathFromC BioInput
bi.cabalDir BioInput
bi.componentName BioInput
bi.distDir
)
[Path Abs File]
cfiles
cfiles :: [Path Abs File]
cfiles = (DotCabalPath -> Maybe (Path Abs File))
-> [DotCabalPath] -> [Path Abs File]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe DotCabalPath -> Maybe (Path Abs File)
dotCabalCFilePath BioInput
bi.dotCabalPaths
installVersion :: (a, b) -> b
installVersion = (a, b) -> b
forall a b. (a, b) -> b
snd
deps :: [String]
deps =
[[String]] -> [String]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
[ case PackageName -> InstalledMap -> Maybe (InstallLocation, Installed)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup PackageName
name BioInput
bi.installedMap of
Just (InstallLocation
_, Stack.Types.Installed.Library PackageIdentifier
_ident InstalledLibraryInfo
installedInfo) ->
InstalledLibraryInfo -> [String]
installedToPackageIdOpt InstalledLibraryInfo
installedInfo
Maybe (InstallLocation, Installed)
_ -> [String
"-package=" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> PackageName -> String
packageNameString PackageName
name String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
String
-> ((InstallLocation, Version) -> String)
-> Maybe (InstallLocation, Version)
-> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
""
(((String
"-" <>) (String -> String) -> (Version -> String) -> Version -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> String
versionString) (Version -> String)
-> ((InstallLocation, Version) -> Version)
-> (InstallLocation, Version)
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InstallLocation, Version) -> Version
forall a b. (a, b) -> b
installVersion)
(PackageName -> InstallMap -> Maybe (InstallLocation, Version)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup PackageName
name BioInput
bi.installMap)]
| PackageName
name <- [PackageName]
pkgs
]
pkgs :: [PackageName]
pkgs =
BioInput
bi.addPackages [PackageName] -> [PackageName] -> [PackageName]
forall a. [a] -> [a] -> [a]
++
[ PackageName
name
| Dependency PackageName
name VersionRange
_ NonEmptySet LibraryName
_ <- BioInput
bi.buildInfo.targetBuildDepends
, PackageName
name PackageName -> [PackageName] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` BioInput
bi.omitPackages
]
PerCompilerFlavor [String]
ghcOpts [String]
_ = BioInput
bi.buildInfo.options
extOpts :: [String]
extOpts =
(Language -> String) -> [Language] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map ((String
"-X" ++) (String -> String) -> (Language -> String) -> Language -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Language -> String
forall a. Pretty a => a -> String
display) BioInput
bi.buildInfo.allLanguages
[String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Extension -> String) -> [Extension] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map ((String
"-X" ++) (String -> String) -> (Extension -> String) -> Extension -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Extension -> String
forall a. Pretty a => a -> String
display) BioInput
bi.buildInfo.usedExtensions
srcOpts :: [String]
srcOpts =
(Path Abs Dir -> String) -> [Path Abs Dir] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map ((String
"-i" <>) (String -> String)
-> (Path Abs Dir -> String) -> Path Abs Dir -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir -> String
forall loc. Path loc Dir -> String
toFilePathNoTrailingSep)
([[Path Abs Dir]] -> [Path Abs Dir]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
[ [ NamedComponent -> Path Abs Dir -> Path Abs Dir
componentBuildDir BioInput
bi.componentName BioInput
bi.distDir ]
, [ BioInput
bi.cabalDir
| [SymbolicPath PackageDir SourceDir] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null BioInput
bi.buildInfo.hsSourceDirs
]
, (SymbolicPath PackageDir SourceDir -> Maybe (Path Abs Dir))
-> [SymbolicPath PackageDir SourceDir] -> [Path Abs Dir]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe
(String -> Maybe (Path Abs Dir)
toIncludeDir (String -> Maybe (Path Abs Dir))
-> (SymbolicPath PackageDir SourceDir -> String)
-> SymbolicPath PackageDir SourceDir
-> Maybe (Path Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SymbolicPath PackageDir SourceDir -> String
forall from to. SymbolicPath from to -> String
getSymbolicPath)
BioInput
bi.buildInfo.hsSourceDirs
, [ Path Abs Dir
componentAutogen ]
, [ Path Abs Dir -> Path Abs Dir
packageAutogenDir BioInput
bi.distDir ]
, [ NamedComponent -> Path Abs Dir -> Path Abs Dir
componentOutputDir BioInput
bi.componentName BioInput
bi.distDir ]
]) [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++
[ String
"-stubdir=" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Path Abs Dir -> String
forall loc. Path loc Dir -> String
toFilePathNoTrailingSep (Path Abs Dir -> Path Abs Dir
buildDir BioInput
bi.distDir) ]
componentAutogen :: Path Abs Dir
componentAutogen = NamedComponent -> Path Abs Dir -> Path Abs Dir
componentAutogenDir BioInput
bi.componentName BioInput
bi.distDir
toIncludeDir :: String -> Maybe (Path Abs Dir)
toIncludeDir String
"." = Path Abs Dir -> Maybe (Path Abs Dir)
forall a. a -> Maybe a
Just BioInput
bi.cabalDir
toIncludeDir String
relDir = Path Abs Dir -> String -> Maybe (Path Abs Dir)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> String -> m (Path Abs Dir)
concatAndCollapseAbsDir BioInput
bi.cabalDir String
relDir
includeOpts :: [String]
includeOpts =
(String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String
"-I" <>) (BioInput
bi.configIncludeDirs [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [String]
pkgIncludeOpts)
pkgIncludeOpts :: [String]
pkgIncludeOpts =
[ Path Abs Dir -> String
forall loc. Path loc Dir -> String
toFilePathNoTrailingSep Path Abs Dir
absDir
| String
dir <- BioInput
bi.buildInfo.includeDirs
, Path Abs Dir
absDir <- String -> [Path Abs Dir]
handleDir String
dir
]
libOpts :: [String]
libOpts =
(String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String
"-l" <>) BioInput
bi.buildInfo.extraLibs [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
(String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String
"-L" <>) (BioInput
bi.configLibDirs [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [String]
pkgLibDirs)
pkgLibDirs :: [String]
pkgLibDirs =
[ Path Abs Dir -> String
forall loc. Path loc Dir -> String
toFilePathNoTrailingSep Path Abs Dir
absDir
| String
dir <- BioInput
bi.buildInfo.extraLibDirs
, Path Abs Dir
absDir <- String -> [Path Abs Dir]
handleDir String
dir
]
handleDir :: String -> [Path Abs Dir]
handleDir String
dir = case (String -> Maybe (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => String -> m (Path Abs Dir)
parseAbsDir String
dir, String -> Maybe (Path Rel Dir)
forall (m :: * -> *). MonadThrow m => String -> m (Path Rel Dir)
parseRelDir String
dir) of
(Just Path Abs Dir
ab, Maybe (Path Rel Dir)
_ ) -> [Path Abs Dir
ab]
(Maybe (Path Abs Dir)
_ , Just Path Rel Dir
rel) -> [BioInput
bi.cabalDir Path Abs Dir -> Path Rel Dir -> Path Abs Dir
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel Dir
rel]
(Maybe (Path Abs Dir)
Nothing, Maybe (Path Rel Dir)
Nothing ) -> []
fworks :: [String]
fworks = (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String
"-framework=" <>) BioInput
bi.buildInfo.frameworks
makeObjectFilePathFromC ::
MonadThrow m
=> Path Abs Dir
-> NamedComponent
-> Path Abs Dir
-> Path Abs File
-> m (Path Abs File)
makeObjectFilePathFromC :: forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir
-> NamedComponent
-> Path Abs Dir
-> Path Abs File
-> m (Path Abs File)
makeObjectFilePathFromC Path Abs Dir
cabalDir NamedComponent
namedComponent Path Abs Dir
distDir Path Abs File
cFilePath = do
Path Rel File
relCFilePath <- Path Abs Dir -> Path Abs File -> m (Path Rel File)
forall (m :: * -> *) b t.
MonadThrow m =>
Path b Dir -> Path b t -> m (Path Rel t)
stripProperPrefix Path Abs Dir
cabalDir Path Abs File
cFilePath
Path Rel File
relOFilePath <-
String -> m (Path Rel File)
forall (m :: * -> *). MonadThrow m => String -> m (Path Rel File)
parseRelFile (String -> String -> String
replaceExtension (Path Rel File -> String
forall b t. Path b t -> String
toFilePath Path Rel File
relCFilePath) String
"o")
Path Abs File -> m (Path Abs File)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NamedComponent -> Path Abs Dir -> Path Abs Dir
componentOutputDir NamedComponent
namedComponent Path Abs Dir
distDir Path Abs Dir -> Path Rel File -> Path Abs File
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel File
relOFilePath)
packageDependencies ::
PackageDescription
-> Map PackageName VersionRange
packageDependencies :: PackageDescription -> Map PackageName VersionRange
packageDependencies PackageDescription
pkg =
(VersionRange -> VersionRange -> VersionRange)
-> [(PackageName, VersionRange)] -> Map PackageName VersionRange
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
M.fromListWith VersionRange -> VersionRange -> VersionRange
intersectVersionRanges ([(PackageName, VersionRange)] -> Map PackageName VersionRange)
-> [(PackageName, VersionRange)] -> Map PackageName VersionRange
forall a b. (a -> b) -> a -> b
$
(Dependency -> (PackageName, VersionRange))
-> [Dependency] -> [(PackageName, VersionRange)]
forall a b. (a -> b) -> [a] -> [b]
map (Dependency -> PackageName
depPkgName (Dependency -> PackageName)
-> (Dependency -> VersionRange)
-> Dependency
-> (PackageName, VersionRange)
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& Dependency -> VersionRange
depVerRange) ([Dependency] -> [(PackageName, VersionRange)])
-> [Dependency] -> [(PackageName, VersionRange)]
forall a b. (a -> b) -> a -> b
$
(BuildInfo -> [Dependency]) -> [BuildInfo] -> [Dependency]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap BuildInfo -> [Dependency]
targetBuildDepends (PackageDescription -> [BuildInfo]
allBuildInfo' PackageDescription
pkg)
[Dependency] -> [Dependency] -> [Dependency]
forall a. Semigroup a => a -> a -> a
<> [Dependency]
-> (SetupBuildInfo -> [Dependency])
-> Maybe SetupBuildInfo
-> [Dependency]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] SetupBuildInfo -> [Dependency]
setupDepends (PackageDescription -> Maybe SetupBuildInfo
setupBuildInfo PackageDescription
pkg)
allBuildInfo' :: PackageDescription -> [BuildInfo]
allBuildInfo' :: PackageDescription -> [BuildInfo]
allBuildInfo' PackageDescription
pkg_descr = [ BuildInfo
bi | Library
lib <- PackageDescription -> [Library]
allLibraries PackageDescription
pkg_descr
, let bi :: BuildInfo
bi = Library -> BuildInfo
libBuildInfo Library
lib
, BuildInfo -> Bool
buildable BuildInfo
bi ]
[BuildInfo] -> [BuildInfo] -> [BuildInfo]
forall a. [a] -> [a] -> [a]
++ [ BuildInfo
bi | ForeignLib
flib <- PackageDescription -> [ForeignLib]
foreignLibs PackageDescription
pkg_descr
, let bi :: BuildInfo
bi = ForeignLib -> BuildInfo
foreignLibBuildInfo ForeignLib
flib
, BuildInfo -> Bool
buildable BuildInfo
bi ]
[BuildInfo] -> [BuildInfo] -> [BuildInfo]
forall a. [a] -> [a] -> [a]
++ [ BuildInfo
bi | Executable
exe <- PackageDescription -> [Executable]
executables PackageDescription
pkg_descr
, let bi :: BuildInfo
bi = Executable -> BuildInfo
buildInfo Executable
exe
, BuildInfo -> Bool
buildable BuildInfo
bi ]
[BuildInfo] -> [BuildInfo] -> [BuildInfo]
forall a. [a] -> [a] -> [a]
++ [ BuildInfo
bi | TestSuite
tst <- PackageDescription -> [TestSuite]
testSuites PackageDescription
pkg_descr
, let bi :: BuildInfo
bi = TestSuite -> BuildInfo
testBuildInfo TestSuite
tst
, BuildInfo -> Bool
buildable BuildInfo
bi ]
[BuildInfo] -> [BuildInfo] -> [BuildInfo]
forall a. [a] -> [a] -> [a]
++ [ BuildInfo
bi | Benchmark
tst <- PackageDescription -> [Benchmark]
benchmarks PackageDescription
pkg_descr
, let bi :: BuildInfo
bi = Benchmark -> BuildInfo
benchmarkBuildInfo Benchmark
tst
, BuildInfo -> Bool
buildable BuildInfo
bi ]
resolvePackageDescription ::
PackageConfig
-> GenericPackageDescription
-> PackageDescription
resolvePackageDescription :: PackageConfig -> GenericPackageDescription -> PackageDescription
resolvePackageDescription
PackageConfig
packageConfig
( GenericPackageDescription
PackageDescription
desc Maybe Version
_ [PackageFlag]
defaultFlags Maybe (CondTree ConfVar [Dependency] Library)
mlib [(UnqualComponentName, CondTree ConfVar [Dependency] Library)]
subLibs [(UnqualComponentName, CondTree ConfVar [Dependency] ForeignLib)]
foreignLibs' [(UnqualComponentName, CondTree ConfVar [Dependency] Executable)]
exes [(UnqualComponentName, CondTree ConfVar [Dependency] TestSuite)]
tests [(UnqualComponentName, CondTree ConfVar [Dependency] Benchmark)]
benches
)
= PackageDescription
desc
{ library = fmap (resolveConditions rc updateLibDeps) mlib
, subLibraries = map
( \(UnqualComponentName
n, CondTree ConfVar [Dependency] Library
v) ->
(ResolveConditions
-> (Library -> [Dependency] -> Library)
-> CondTree ConfVar [Dependency] Library
-> Library
forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc Library -> [Dependency] -> Library
updateLibDeps CondTree ConfVar [Dependency] Library
v){libName = LSubLibName n}
)
subLibs
, foreignLibs = map
( \(UnqualComponentName
n, CondTree ConfVar [Dependency] ForeignLib
v) ->
(ResolveConditions
-> (ForeignLib -> [Dependency] -> ForeignLib)
-> CondTree ConfVar [Dependency] ForeignLib
-> ForeignLib
forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc ForeignLib -> [Dependency] -> ForeignLib
updateForeignLibDeps CondTree ConfVar [Dependency] ForeignLib
v){foreignLibName = n}
)
foreignLibs'
, executables = map
( \(UnqualComponentName
n, CondTree ConfVar [Dependency] Executable
v) -> (ResolveConditions
-> (Executable -> [Dependency] -> Executable)
-> CondTree ConfVar [Dependency] Executable
-> Executable
forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc Executable -> [Dependency] -> Executable
updateExeDeps CondTree ConfVar [Dependency] Executable
v){exeName = n} )
exes
, testSuites = map
( \(UnqualComponentName
n, CondTree ConfVar [Dependency] TestSuite
v) ->
(ResolveConditions
-> (TestSuite -> [Dependency] -> TestSuite)
-> CondTree ConfVar [Dependency] TestSuite
-> TestSuite
forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc TestSuite -> [Dependency] -> TestSuite
updateTestDeps CondTree ConfVar [Dependency] TestSuite
v){testName = n}
)
tests
, benchmarks = map
( \(UnqualComponentName
n, CondTree ConfVar [Dependency] Benchmark
v) ->
(ResolveConditions
-> (Benchmark -> [Dependency] -> Benchmark)
-> CondTree ConfVar [Dependency] Benchmark
-> Benchmark
forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc Benchmark -> [Dependency] -> Benchmark
updateBenchmarkDeps CondTree ConfVar [Dependency] Benchmark
v){benchmarkName = n}
)
benches
}
where
flags :: Map FlagName Bool
flags = Map FlagName Bool -> Map FlagName Bool -> Map FlagName Bool
forall k a. Ord k => Map k a -> Map k a -> Map k a
M.union PackageConfig
packageConfig.flags ([PackageFlag] -> Map FlagName Bool
flagMap [PackageFlag]
defaultFlags)
rc :: ResolveConditions
rc = ActualCompiler
-> Platform -> Map FlagName Bool -> ResolveConditions
mkResolveConditions
PackageConfig
packageConfig.compilerVersion
PackageConfig
packageConfig.platform
Map FlagName Bool
flags
updateLibDeps :: Library -> [Dependency] -> Library
updateLibDeps Library
lib [Dependency]
deps = Library
lib
{ libBuildInfo = (libBuildInfo lib) {targetBuildDepends = deps} }
updateForeignLibDeps :: ForeignLib -> [Dependency] -> ForeignLib
updateForeignLibDeps ForeignLib
lib [Dependency]
deps = ForeignLib
lib
{ foreignLibBuildInfo =
(foreignLibBuildInfo lib) {targetBuildDepends = deps}
}
updateExeDeps :: Executable -> [Dependency] -> Executable
updateExeDeps Executable
exe [Dependency]
deps = Executable
exe
{ Executable.buildInfo = (buildInfo exe) {targetBuildDepends = deps} }
updateTestDeps :: TestSuite -> [Dependency] -> TestSuite
updateTestDeps TestSuite
test [Dependency]
deps = TestSuite
test
{ testBuildInfo = (testBuildInfo test) {targetBuildDepends = deps} }
updateBenchmarkDeps :: Benchmark -> [Dependency] -> Benchmark
updateBenchmarkDeps Benchmark
bench [Dependency]
deps = Benchmark
bench
{ benchmarkBuildInfo =
(benchmarkBuildInfo bench) {targetBuildDepends = deps}
}
flagMap :: [PackageFlag] -> Map FlagName Bool
flagMap :: [PackageFlag] -> Map FlagName Bool
flagMap = [(FlagName, Bool)] -> Map FlagName Bool
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(FlagName, Bool)] -> Map FlagName Bool)
-> ([PackageFlag] -> [(FlagName, Bool)])
-> [PackageFlag]
-> Map FlagName Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageFlag -> (FlagName, Bool))
-> [PackageFlag] -> [(FlagName, Bool)]
forall a b. (a -> b) -> [a] -> [b]
map PackageFlag -> (FlagName, Bool)
pair
where
pair :: PackageFlag -> (FlagName, Bool)
pair :: PackageFlag -> (FlagName, Bool)
pair = PackageFlag -> FlagName
flagName (PackageFlag -> FlagName)
-> (PackageFlag -> Bool) -> PackageFlag -> (FlagName, Bool)
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& PackageFlag -> Bool
flagDefault
data ResolveConditions = ResolveConditions
{ ResolveConditions -> Map FlagName Bool
flags :: Map FlagName Bool
, ResolveConditions -> ActualCompiler
compilerVersion :: ActualCompiler
, ResolveConditions -> OS
os :: OS
, ResolveConditions -> Arch
arch :: Arch
}
mkResolveConditions ::
ActualCompiler
-> Platform
-> Map FlagName Bool
-> ResolveConditions
mkResolveConditions :: ActualCompiler
-> Platform -> Map FlagName Bool -> ResolveConditions
mkResolveConditions ActualCompiler
compilerVersion (Platform Arch
arch OS
os) Map FlagName Bool
flags = ResolveConditions
{ Map FlagName Bool
flags :: Map FlagName Bool
flags :: Map FlagName Bool
flags
, ActualCompiler
compilerVersion :: ActualCompiler
compilerVersion :: ActualCompiler
compilerVersion
, OS
os :: OS
os :: OS
os
, Arch
arch :: Arch
arch :: Arch
arch
}
resolveConditions ::
(Semigroup target, Monoid target, Show target)
=> ResolveConditions
-> (target -> cs -> target)
-> CondTree ConfVar cs target
-> target
resolveConditions :: forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc target -> cs -> target
addDeps (CondNode target
lib cs
deps [CondBranch ConfVar cs target]
cs) = target
basic target -> target -> target
forall a. Semigroup a => a -> a -> a
<> target
children
where
basic :: target
basic = target -> cs -> target
addDeps target
lib cs
deps
children :: target
children = [target] -> target
forall a. Monoid a => [a] -> a
mconcat ((CondBranch ConfVar cs target -> target)
-> [CondBranch ConfVar cs target] -> [target]
forall a b. (a -> b) -> [a] -> [b]
map CondBranch ConfVar cs target -> target
apply [CondBranch ConfVar cs target]
cs)
where
apply :: CondBranch ConfVar cs target -> target
apply (Cabal.CondBranch Condition ConfVar
cond CondTree ConfVar cs target
node Maybe (CondTree ConfVar cs target)
mcs) =
if Condition ConfVar -> Bool
condSatisfied Condition ConfVar
cond
then ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc target -> cs -> target
addDeps CondTree ConfVar cs target
node
else target
-> (CondTree ConfVar cs target -> target)
-> Maybe (CondTree ConfVar cs target)
-> target
forall b a. b -> (a -> b) -> Maybe a -> b
maybe target
forall a. Monoid a => a
mempty (ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
forall target cs.
(Semigroup target, Monoid target, Show target) =>
ResolveConditions
-> (target -> cs -> target) -> CondTree ConfVar cs target -> target
resolveConditions ResolveConditions
rc target -> cs -> target
addDeps) Maybe (CondTree ConfVar cs target)
mcs
condSatisfied :: Condition ConfVar -> Bool
condSatisfied Condition ConfVar
c =
case Condition ConfVar
c of
Var ConfVar
v -> ConfVar -> Bool
varSatisfied ConfVar
v
Lit Bool
b -> Bool
b
CNot Condition ConfVar
c' -> Bool -> Bool
not (Condition ConfVar -> Bool
condSatisfied Condition ConfVar
c')
COr Condition ConfVar
cx Condition ConfVar
cy -> Condition ConfVar -> Bool
condSatisfied Condition ConfVar
cx Bool -> Bool -> Bool
|| Condition ConfVar -> Bool
condSatisfied Condition ConfVar
cy
CAnd Condition ConfVar
cx Condition ConfVar
cy -> Condition ConfVar -> Bool
condSatisfied Condition ConfVar
cx Bool -> Bool -> Bool
&& Condition ConfVar -> Bool
condSatisfied Condition ConfVar
cy
varSatisfied :: ConfVar -> Bool
varSatisfied ConfVar
v =
case ConfVar
v of
OS OS
os -> OS
os OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== ResolveConditions
rc.os
Arch Arch
arch -> Arch
arch Arch -> Arch -> Bool
forall a. Eq a => a -> a -> Bool
== ResolveConditions
rc.arch
PackageFlag FlagName
flag -> Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False (Maybe Bool -> Bool) -> Maybe Bool -> Bool
forall a b. (a -> b) -> a -> b
$ FlagName -> Map FlagName Bool -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup FlagName
flag ResolveConditions
rc.flags
Impl CompilerFlavor
flavor VersionRange
range ->
case (CompilerFlavor
flavor, ResolveConditions
rc.compilerVersion) of
(CompilerFlavor
GHC, ACGhc Version
vghc) -> Version
vghc Version -> VersionRange -> Bool
`withinRange` VersionRange
range
(CompilerFlavor, ActualCompiler)
_ -> Bool
False
buildLogPath ::
(MonadReader env m, HasBuildConfig env, MonadThrow m)
=> Package
-> Maybe String
-> m (Path Abs File)
buildLogPath :: forall env (m :: * -> *).
(MonadReader env m, HasBuildConfig env, MonadThrow m) =>
Package -> Maybe String -> m (Path Abs File)
buildLogPath Package
package' Maybe String
msuffix = do
env
env <- m env
forall r (m :: * -> *). MonadReader r m => m r
ask
let workDir :: Path Abs Dir
workDir = env -> Path Abs Dir
forall env (m :: * -> *).
(HasBuildConfig env, MonadReader env m) =>
m (Path Abs Dir)
getWorkDir env
env
Path Rel File
fp <- String -> m (Path Rel File)
forall (m :: * -> *). MonadThrow m => String -> m (Path Rel File)
parseRelFile (String -> m (Path Rel File)) -> String -> m (Path Rel File)
forall a b. (a -> b) -> a -> b
$ [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$
PackageIdentifier -> String
packageIdentifierString (Package -> PackageIdentifier
packageIdentifier Package
package') String -> [String] -> [String]
forall a. a -> [a] -> [a]
:
([String] -> [String])
-> (String -> [String] -> [String])
-> Maybe String
-> [String]
-> [String]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [String] -> [String]
forall a. a -> a
id (\String
suffix -> (String
"-" :) ([String] -> [String])
-> ([String] -> [String]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
suffix :)) Maybe String
msuffix [String
".log"]
Path Abs File -> m (Path Abs File)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Path Abs File -> m (Path Abs File))
-> Path Abs File -> m (Path Abs File)
forall a b. (a -> b) -> a -> b
$ Path Abs Dir
workDir Path Abs Dir -> Path Rel File -> Path Abs File
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel Dir
relDirLogs Path Rel Dir -> Path Rel File -> Path Rel File
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel File
fp
applyForceCustomBuild ::
Version
-> Package
-> Package
applyForceCustomBuild :: Version -> Package -> Package
applyForceCustomBuild Version
cabalVersion Package
package
| Bool
forceCustomBuild =
Package
package
{ buildType = Custom
, setupDeps = Just $ M.fromList
[ ("Cabal", libraryDepFromVersionRange cabalVersionRange)
, ("base", libraryDepFromVersionRange anyVersion)
]
}
| Bool
otherwise = Package
package
where
cabalVersionRange :: VersionRange
cabalVersionRange =
Version -> VersionRange
orLaterVersion (Version -> VersionRange) -> Version -> VersionRange
forall a b. (a -> b) -> a -> b
$ [Int] -> Version
mkVersion ([Int] -> Version) -> [Int] -> Version
forall a b. (a -> b) -> a -> b
$ CabalSpecVersion -> [Int]
cabalSpecToVersionDigits
Package
package.cabalSpec
forceCustomBuild :: Bool
forceCustomBuild = Package
package.buildType BuildType -> BuildType -> Bool
forall a. Eq a => a -> a -> Bool
== BuildType
Simple
Bool -> Bool -> Bool
&& Bool -> Bool
not (Version
cabalVersion Version -> VersionRange -> Bool
`withinRange` VersionRange
cabalVersionRange)
hasBuildableMainLibrary :: Package -> Bool
hasBuildableMainLibrary :: Package -> Bool
hasBuildableMainLibrary Package
package =
Bool -> (StackLibrary -> Bool) -> Maybe StackLibrary -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False StackLibrary -> Bool
forall component. HasBuildInfo component => component -> Bool
isComponentBuildable Package
package.library
mainLibraryHasExposedModules :: Package -> Bool
mainLibraryHasExposedModules :: Package -> Bool
mainLibraryHasExposedModules Package
package =
Bool -> (StackLibrary -> Bool) -> Maybe StackLibrary -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Bool -> Bool
not (Bool -> Bool) -> (StackLibrary -> Bool) -> StackLibrary -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ModuleName] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([ModuleName] -> Bool)
-> (StackLibrary -> [ModuleName]) -> StackLibrary -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (.exposedModules)) Package
package.library
packageUnknownTools :: Package -> Set Text
packageUnknownTools :: Package -> Set Text
packageUnknownTools Package
pkg = Set Text -> Set Text
lib (Set Text
bench Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
tests Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
flib Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
sublib Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
exe)
where
lib :: Set Text -> Set Text
lib Set Text
setT = case Package
pkg.library of
Just StackLibrary
libV -> StackLibrary -> Set Text -> Set Text
forall x. HasBuildInfo x => x -> Set Text -> Set Text
addUnknownTools StackLibrary
libV Set Text
setT
Maybe StackLibrary
Nothing -> Set Text
setT
bench :: Set Text
bench = CompCollection StackBenchmark -> Set Text
forall x. HasBuildInfo x => CompCollection x -> Set Text
gatherUnknownTools Package
pkg.benchmarks
tests :: Set Text
tests = CompCollection StackTestSuite -> Set Text
forall x. HasBuildInfo x => CompCollection x -> Set Text
gatherUnknownTools Package
pkg.testSuites
flib :: Set Text
flib = CompCollection StackForeignLibrary -> Set Text
forall x. HasBuildInfo x => CompCollection x -> Set Text
gatherUnknownTools Package
pkg.foreignLibraries
sublib :: Set Text
sublib = CompCollection StackLibrary -> Set Text
forall x. HasBuildInfo x => CompCollection x -> Set Text
gatherUnknownTools Package
pkg.subLibraries
exe :: Set Text
exe = CompCollection StackExecutable -> Set Text
forall x. HasBuildInfo x => CompCollection x -> Set Text
gatherUnknownTools Package
pkg.executables
addUnknownTools :: HasBuildInfo x => x -> Set Text -> Set Text
addUnknownTools :: forall x. HasBuildInfo x => x -> Set Text -> Set Text
addUnknownTools = Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
(<>) (Set Text -> Set Text -> Set Text)
-> (x -> Set Text) -> x -> Set Text -> Set Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (.buildInfo.unknownTools)
gatherUnknownTools :: HasBuildInfo x => CompCollection x -> Set Text
gatherUnknownTools :: forall x. HasBuildInfo x => CompCollection x -> Set Text
gatherUnknownTools = (x -> Set Text -> Set Text)
-> Set Text -> CompCollection x -> Set Text
forall a b. (a -> b -> b) -> b -> CompCollection a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr' x -> Set Text -> Set Text
forall x. HasBuildInfo x => x -> Set Text -> Set Text
addUnknownTools Set Text
forall a. Monoid a => a
mempty
buildableForeignLibs :: Package -> Set StackUnqualCompName
buildableForeignLibs :: Package -> Set StackUnqualCompName
buildableForeignLibs Package
pkg = CompCollection StackForeignLibrary -> Set StackUnqualCompName
forall component.
CompCollection component -> Set StackUnqualCompName
getBuildableSet Package
pkg.foreignLibraries
buildableSubLibs :: Package -> Set StackUnqualCompName
buildableSubLibs :: Package -> Set StackUnqualCompName
buildableSubLibs Package
pkg = CompCollection StackLibrary -> Set StackUnqualCompName
forall component.
CompCollection component -> Set StackUnqualCompName
getBuildableSet Package
pkg.subLibraries
buildableExes :: Package -> Set StackUnqualCompName
buildableExes :: Package -> Set StackUnqualCompName
buildableExes Package
pkg = CompCollection StackExecutable -> Set StackUnqualCompName
forall component.
CompCollection component -> Set StackUnqualCompName
getBuildableSet Package
pkg.executables
buildableTestSuites :: Package -> Set StackUnqualCompName
buildableTestSuites :: Package -> Set StackUnqualCompName
buildableTestSuites Package
pkg = CompCollection StackTestSuite -> Set StackUnqualCompName
forall component.
CompCollection component -> Set StackUnqualCompName
getBuildableSet Package
pkg.testSuites
buildableBenchmarks :: Package -> Set StackUnqualCompName
buildableBenchmarks :: Package -> Set StackUnqualCompName
buildableBenchmarks Package
pkg = CompCollection StackBenchmark -> Set StackUnqualCompName
forall component.
CompCollection component -> Set StackUnqualCompName
getBuildableSet Package
pkg.benchmarks
processPackageComponent ::
forall m a. (Monad m)
=> Package
-> (forall component. HasComponentInfo component => component -> m a -> m a)
-> m a
-> m a
processPackageComponent :: forall (m :: * -> *) a.
Monad m =>
Package
-> (forall component.
HasComponentInfo component =>
component -> m a -> m a)
-> m a
-> m a
processPackageComponent Package
pkg forall component.
HasComponentInfo component =>
component -> m a -> m a
componentFn = do
let componentKindProcessor ::
forall component. HasComponentInfo component
=> (Package -> CompCollection component)
-> m a
-> m a
componentKindProcessor :: forall component.
HasComponentInfo component =>
(Package -> CompCollection component) -> m a -> m a
componentKindProcessor Package -> CompCollection component
target =
CompCollection component -> (component -> m a -> m a) -> m a -> m a
forall (m :: * -> *) component a.
Monad m =>
CompCollection component -> (component -> m a -> m a) -> m a -> m a
foldComponentToAnotherCollection
(Package -> CompCollection component
target Package
pkg)
component -> m a -> m a
forall component.
HasComponentInfo component =>
component -> m a -> m a
componentFn
processMainLib :: m a -> m a
processMainLib = (m a -> m a)
-> (StackLibrary -> m a -> m a) -> Maybe StackLibrary -> m a -> m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe m a -> m a
forall a. a -> a
id StackLibrary -> m a -> m a
forall component.
HasComponentInfo component =>
component -> m a -> m a
componentFn Package
pkg.library
processAllComp :: m a -> m a
processAllComp =
( if Package
pkg.benchmarkEnabled
then (Package -> CompCollection StackBenchmark) -> m a -> m a
forall component.
HasComponentInfo component =>
(Package -> CompCollection component) -> m a -> m a
componentKindProcessor (.benchmarks)
else m a -> m a
forall a. a -> a
id
)
(m a -> m a) -> (m a -> m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ( if Package
pkg.testEnabled
then (Package -> CompCollection StackTestSuite) -> m a -> m a
forall component.
HasComponentInfo component =>
(Package -> CompCollection component) -> m a -> m a
componentKindProcessor (.testSuites)
else m a -> m a
forall a. a -> a
id
)
(m a -> m a) -> (m a -> m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Package -> CompCollection StackForeignLibrary) -> m a -> m a
forall component.
HasComponentInfo component =>
(Package -> CompCollection component) -> m a -> m a
componentKindProcessor (.foreignLibraries)
(m a -> m a) -> (m a -> m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Package -> CompCollection StackExecutable) -> m a -> m a
forall component.
HasComponentInfo component =>
(Package -> CompCollection component) -> m a -> m a
componentKindProcessor (.executables)
(m a -> m a) -> (m a -> m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Package -> CompCollection StackLibrary) -> m a -> m a
forall component.
HasComponentInfo component =>
(Package -> CompCollection component) -> m a -> m a
componentKindProcessor (.subLibraries)
(m a -> m a) -> (m a -> m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> m a
processMainLib
m a -> m a
processAllComp
processPackageMapDeps ::
(Monad m)
=> Package
-> (Map PackageName DepValue -> m a -> m a)
-> m a
-> m a
processPackageMapDeps :: forall (m :: * -> *) a.
Monad m =>
Package -> (Map PackageName DepValue -> m a -> m a) -> m a -> m a
processPackageMapDeps Package
pkg Map PackageName DepValue -> m a -> m a
fn = do
let packageSetupDepsProcessor :: m a -> m a
packageSetupDepsProcessor m a
resAction = case Package
pkg.setupDeps of
Maybe (Map PackageName DepValue)
Nothing -> m a
resAction
Just Map PackageName DepValue
v -> Map PackageName DepValue -> m a -> m a
fn Map PackageName DepValue
v m a
resAction
processAllComp :: m a -> m a
processAllComp = Package
-> (forall component.
HasComponentInfo component =>
component -> m a -> m a)
-> m a
-> m a
forall (m :: * -> *) a.
Monad m =>
Package
-> (forall component.
HasComponentInfo component =>
component -> m a -> m a)
-> m a
-> m a
processPackageComponent Package
pkg (Map PackageName DepValue -> m a -> m a
fn (Map PackageName DepValue -> m a -> m a)
-> (component -> Map PackageName DepValue)
-> component
-> m a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. component -> Map PackageName DepValue
forall r1 r2 a.
(HasField "buildInfo" r1 r2, HasField "dependency" r2 a) =>
r1 -> a
componentDependencyMap)
(m a -> m a) -> (m a -> m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> m a
packageSetupDepsProcessor
m a -> m a
processAllComp
processPackageDeps ::
(Monad m)
=> Package
-> (smallResT -> resT -> resT)
-> (PackageName -> DepValue -> m smallResT)
-> m resT
-> m resT
processPackageDeps :: forall (m :: * -> *) smallResT resT.
Monad m =>
Package
-> (smallResT -> resT -> resT)
-> (PackageName -> DepValue -> m smallResT)
-> m resT
-> m resT
processPackageDeps Package
pkg smallResT -> resT -> resT
combineResults PackageName -> DepValue -> m smallResT
fn = do
let asPackageNameSet :: (Package -> CompCollection component) -> Set PackageName
asPackageNameSet Package -> CompCollection component
accessor =
(Text -> PackageName) -> Set Text -> Set PackageName
forall b a. Ord b => (a -> b) -> Set a -> Set b
S.map (String -> PackageName
mkPackageName (String -> PackageName) -> (Text -> String) -> Text -> PackageName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack) (Set Text -> Set PackageName) -> Set Text -> Set PackageName
forall a b. (a -> b) -> a -> b
$ CompCollection component -> Set Text
forall component. CompCollection component -> Set Text
getBuildableSetText (CompCollection component -> Set Text)
-> CompCollection component -> Set Text
forall a b. (a -> b) -> a -> b
$ Package -> CompCollection component
accessor Package
pkg
(!Set PackageName
subLibNames, !Set PackageName
foreignLibNames) =
( (Package -> CompCollection StackLibrary) -> Set PackageName
forall {component}.
(Package -> CompCollection component) -> Set PackageName
asPackageNameSet (.subLibraries)
, (Package -> CompCollection StackForeignLibrary) -> Set PackageName
forall {component}.
(Package -> CompCollection component) -> Set PackageName
asPackageNameSet (.foreignLibraries)
)
shouldIgnoreDep :: PackageName -> Bool
shouldIgnoreDep (PackageName
packageNameV :: PackageName)
| PackageName
packageNameV PackageName -> PackageName -> Bool
forall a. Eq a => a -> a -> Bool
== Package
pkg.name = Bool
True
| PackageName
packageNameV PackageName -> Set PackageName -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set PackageName
subLibNames = Bool
True
| PackageName
packageNameV PackageName -> Set PackageName -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set PackageName
foreignLibNames = Bool
True
| Bool
otherwise = Bool
False
innerIterator :: PackageName -> DepValue -> m resT -> m resT
innerIterator PackageName
packageName DepValue
depValue m resT
resListInMonad
| PackageName -> Bool
shouldIgnoreDep PackageName
packageName = m resT
resListInMonad
| Bool
otherwise = do
resT
resList <- m resT
resListInMonad
smallResT
newResElement <- PackageName -> DepValue -> m smallResT
fn PackageName
packageName DepValue
depValue
resT -> m resT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (resT -> m resT) -> resT -> m resT
forall a b. (a -> b) -> a -> b
$ smallResT -> resT -> resT
combineResults smallResT
newResElement resT
resList
Package
-> (Map PackageName DepValue -> m resT -> m resT)
-> m resT
-> m resT
forall (m :: * -> *) a.
Monad m =>
Package -> (Map PackageName DepValue -> m a -> m a) -> m a -> m a
processPackageMapDeps Package
pkg ((m resT -> Map PackageName DepValue -> m resT)
-> Map PackageName DepValue -> m resT -> m resT
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((PackageName -> DepValue -> m resT -> m resT)
-> m resT -> Map PackageName DepValue -> m resT
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
M.foldrWithKey' PackageName -> DepValue -> m resT -> m resT
innerIterator))
processPackageDepsToList ::
Monad m
=> Package
-> (PackageName -> DepValue -> m resT)
-> m [resT]
processPackageDepsToList :: forall (m :: * -> *) resT.
Monad m =>
Package -> (PackageName -> DepValue -> m resT) -> m [resT]
processPackageDepsToList Package
pkg PackageName -> DepValue -> m resT
fn = Package
-> (resT -> [resT] -> [resT])
-> (PackageName -> DepValue -> m resT)
-> m [resT]
-> m [resT]
forall (m :: * -> *) smallResT resT.
Monad m =>
Package
-> (smallResT -> resT -> resT)
-> (PackageName -> DepValue -> m smallResT)
-> m resT
-> m resT
processPackageDeps Package
pkg (:) PackageName -> DepValue -> m resT
fn ([resT] -> m [resT]
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [])
processPackageDepsEither ::
(Monad m, Monoid a, Monoid b)
=> Package
-> (PackageName -> DepValue -> m (Either a b))
-> m (Either a b)
processPackageDepsEither :: forall (m :: * -> *) a b.
(Monad m, Monoid a, Monoid b) =>
Package
-> (PackageName -> DepValue -> m (Either a b)) -> m (Either a b)
processPackageDepsEither Package
pkg PackageName -> DepValue -> m (Either a b)
fn =
Package
-> (Either a b -> Either a b -> Either a b)
-> (PackageName -> DepValue -> m (Either a b))
-> m (Either a b)
-> m (Either a b)
forall (m :: * -> *) smallResT resT.
Monad m =>
Package
-> (smallResT -> resT -> resT)
-> (PackageName -> DepValue -> m smallResT)
-> m resT
-> m resT
processPackageDeps Package
pkg Either a b -> Either a b -> Either a b
forall {a} {b}.
(Semigroup a, Semigroup b) =>
Either a b -> Either a b -> Either a b
combineRes PackageName -> DepValue -> m (Either a b)
fn (Either a b -> m (Either a b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b -> Either a b
forall a b. b -> Either a b
Right b
forall a. Monoid a => a
mempty))
where
combineRes :: Either a b -> Either a b -> Either a b
combineRes (Left a
err) (Left a
errs) = a -> Either a b
forall a b. a -> Either a b
Left (a
errs a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
err)
combineRes Either a b
_ (Left a
b) = a -> Either a b
forall a b. a -> Either a b
Left a
b
combineRes (Left a
err) Either a b
_ = a -> Either a b
forall a b. a -> Either a b
Left a
err
combineRes (Right b
a) (Right b
b) = b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> b -> Either a b
forall a b. (a -> b) -> a -> b
$ b
a b -> b -> b
forall a. Semigroup a => a -> a -> a
<> b
b
listOfPackageDeps :: Package -> [PackageName]
listOfPackageDeps :: Package -> [PackageName]
listOfPackageDeps Package
pkg =
Identity [PackageName] -> [PackageName]
forall a. Identity a -> a
runIdentity (Identity [PackageName] -> [PackageName])
-> Identity [PackageName] -> [PackageName]
forall a b. (a -> b) -> a -> b
$ Package
-> (PackageName -> DepValue -> Identity PackageName)
-> Identity [PackageName]
forall (m :: * -> *) resT.
Monad m =>
Package -> (PackageName -> DepValue -> m resT) -> m [resT]
processPackageDepsToList Package
pkg (\PackageName
pn DepValue
_ -> PackageName -> Identity PackageName
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PackageName
pn)
setOfPackageDeps :: Package -> Set PackageName
setOfPackageDeps :: Package -> Set PackageName
setOfPackageDeps Package
pkg =
Identity (Set PackageName) -> Set PackageName
forall a. Identity a -> a
runIdentity (Identity (Set PackageName) -> Set PackageName)
-> Identity (Set PackageName) -> Set PackageName
forall a b. (a -> b) -> a -> b
$ Package
-> (PackageName -> Set PackageName -> Set PackageName)
-> (PackageName -> DepValue -> Identity PackageName)
-> Identity (Set PackageName)
-> Identity (Set PackageName)
forall (m :: * -> *) smallResT resT.
Monad m =>
Package
-> (smallResT -> resT -> resT)
-> (PackageName -> DepValue -> m smallResT)
-> m resT
-> m resT
processPackageDeps Package
pkg PackageName -> Set PackageName -> Set PackageName
forall a. Ord a => a -> Set a -> Set a
S.insert (\PackageName
pn DepValue
_ -> PackageName -> Identity PackageName
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PackageName
pn) (Set PackageName -> Identity (Set PackageName)
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Set PackageName
forall a. Monoid a => a
mempty)
topSortPackageComponent ::
Package
-> Target
-> Bool
-> Seq NamedComponent
topSortPackageComponent :: Package -> Target -> Bool -> Seq NamedComponent
topSortPackageComponent Package
package Target
target Bool
includeDirectTarget =
Package
-> Target
-> (forall component.
HasComponentInfo component =>
PackageType
-> component -> Seq NamedComponent -> Seq NamedComponent)
-> Seq NamedComponent
-> Seq NamedComponent
forall b.
Package
-> Target
-> (forall component.
HasComponentInfo component =>
PackageType -> component -> b -> b)
-> b
-> b
topProcessPackageComponent Package
package Target
target PackageType
-> component -> Seq NamedComponent -> Seq NamedComponent
forall component.
HasComponentInfo component =>
PackageType
-> component -> Seq NamedComponent -> Seq NamedComponent
forall {r} {a}.
HasField "qualifiedName" r a =>
PackageType -> r -> Seq a -> Seq a
processor Seq NamedComponent
forall a. Monoid a => a
mempty
where
processor :: PackageType -> r -> Seq a -> Seq a
processor PackageType
packageType r
component
| Bool -> Bool
not Bool
includeDirectTarget Bool -> Bool -> Bool
&& PackageType
packageType PackageType -> PackageType -> Bool
forall a. Eq a => a -> a -> Bool
== PackageType
PTProject = Seq a -> Seq a
forall a. a -> a
id
| Bool
otherwise = \Seq a
v -> Seq a
v Seq a -> a -> Seq a
forall a. Seq a -> a -> Seq a
|> r
component.qualifiedName
topProcessPackageComponent ::
forall b.
Package
-> Target
-> ( forall component. (HasComponentInfo component)
=> PackageType
-> component
-> b
-> b
)
-> b
-> b
topProcessPackageComponent :: forall b.
Package
-> Target
-> (forall component.
HasComponentInfo component =>
PackageType -> component -> b -> b)
-> b
-> b
topProcessPackageComponent Package
package Target
target forall component.
HasComponentInfo component =>
PackageType -> component -> b -> b
fn b
res = do
let initialState :: (Set NamedComponent, b)
initialState = (Set NamedComponent
forall a. Monoid a => a
mempty, b
res)
processInitialComponents :: component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processInitialComponents component
c = case Target
target of
TargetAll{} -> PackageType
-> component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall component.
HasComponentInfo component =>
PackageType
-> component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processComponent PackageType
PTProject component
c
TargetComps Set NamedComponent
targetSet -> if NamedComponent -> Set NamedComponent -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member component
c.qualifiedName Set NamedComponent
targetSet
then PackageType
-> component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall component.
HasComponentInfo component =>
PackageType
-> component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processComponent PackageType
PTProject component
c
else (Set NamedComponent, b) -> (Set NamedComponent, b)
forall a. a -> a
id
(Set NamedComponent, b) -> b
forall a b. (a, b) -> b
snd ((Set NamedComponent, b) -> b) -> (Set NamedComponent, b) -> b
forall a b. (a -> b) -> a -> b
$ Package
-> (forall component.
HasComponentInfo component =>
component -> (Set NamedComponent, b) -> (Set NamedComponent, b))
-> (Set NamedComponent, b)
-> (Set NamedComponent, b)
forall (m :: * -> *) a.
Monad m =>
Package
-> (forall component.
HasComponentInfo component =>
component -> m a -> m a)
-> m a
-> m a
processPackageComponent Package
package component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall {component}.
(HasName component, HasBuildInfo component,
HasField "qualifiedName" component NamedComponent) =>
component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall component.
HasComponentInfo component =>
component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processInitialComponents (Set NamedComponent, b)
initialState
where
processComponent :: HasComponentInfo component
=> PackageType
-> component
-> (Set NamedComponent, b)
-> (Set NamedComponent, b)
processComponent :: forall component.
HasComponentInfo component =>
PackageType
-> component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processComponent PackageType
packageType component
component currentRes :: (Set NamedComponent, b)
currentRes@(Set NamedComponent
_a, !b
_b) = do
let depMap :: Map PackageName DepValue
depMap = component -> Map PackageName DepValue
forall r1 r2 a.
(HasField "buildInfo" r1 r2, HasField "dependency" r2 a) =>
r1 -> a
componentDependencyMap component
component
internalDep :: Maybe DepValue
internalDep = PackageName -> Map PackageName DepValue -> Maybe DepValue
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Package
package.name Map PackageName DepValue
depMap
qualName :: NamedComponent
qualName = component
component.qualifiedName
alreadyProcessed :: Set NamedComponent
alreadyProcessed = (Set NamedComponent, b) -> Set NamedComponent
forall a b. (a, b) -> a
fst (Set NamedComponent, b)
currentRes
!appendToResult :: b -> b
appendToResult = PackageType -> component -> b -> b
forall component.
HasComponentInfo component =>
PackageType -> component -> b -> b
fn PackageType
packageType component
component
processedDeps :: (Set NamedComponent, b)
processedDeps = Maybe DepValue
-> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall {a}.
HasField "depType" a DepType =>
Maybe a -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processOneDep Maybe DepValue
internalDep (Set NamedComponent, b)
currentRes
if NamedComponent -> Bool
isPotentialDependency NamedComponent
qualName
then
if NamedComponent -> Set NamedComponent -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member NamedComponent
qualName Set NamedComponent
alreadyProcessed
then (Set NamedComponent, b)
currentRes
else (Set NamedComponent -> Set NamedComponent)
-> (b -> b) -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (NamedComponent -> Set NamedComponent -> Set NamedComponent
forall a. Ord a => a -> Set a -> Set a
S.insert NamedComponent
qualName) b -> b
appendToResult (Set NamedComponent, b)
processedDeps
else (b -> b) -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second b -> b
appendToResult (Set NamedComponent, b)
processedDeps
lookupLibName :: Bool -> StackUnqualCompName -> Maybe StackLibrary
lookupLibName Bool
isMain StackUnqualCompName
name = if Bool
isMain
then Package
package.library
else StackUnqualCompName
-> CompCollection StackLibrary -> Maybe StackLibrary
forall component.
StackUnqualCompName -> CompCollection component -> Maybe component
collectionLookup StackUnqualCompName
name Package
package.subLibraries
processOneDep :: Maybe a -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processOneDep Maybe a
mDependency (Set NamedComponent, b)
res' =
case (.depType) (a -> DepType) -> Maybe a -> Maybe DepType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a
mDependency of
Just (AsLibrary (DepLibrary Bool
mainLibDep Set StackUnqualCompName
subLibDeps)) -> do
let processMainLibDep :: (Set NamedComponent, b) -> (Set NamedComponent, b)
processMainLibDep =
case (Bool
mainLibDep, Bool -> StackUnqualCompName -> Maybe StackLibrary
lookupLibName Bool
True StackUnqualCompName
emptyCompName) of
(Bool
True, Just StackLibrary
mainLib) ->
PackageType
-> StackLibrary
-> (Set NamedComponent, b)
-> (Set NamedComponent, b)
forall component.
HasComponentInfo component =>
PackageType
-> component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processComponent PackageType
PTDependency StackLibrary
mainLib
(Bool, Maybe StackLibrary)
_ -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall a. a -> a
id
processSingleSubLib :: StackUnqualCompName
-> (Set NamedComponent, b) -> (Set NamedComponent, b)
processSingleSubLib StackUnqualCompName
name =
case Bool -> StackUnqualCompName -> Maybe StackLibrary
lookupLibName Bool
False StackUnqualCompName
name of
Just StackLibrary
lib -> PackageType
-> StackLibrary
-> (Set NamedComponent, b)
-> (Set NamedComponent, b)
forall component.
HasComponentInfo component =>
PackageType
-> component -> (Set NamedComponent, b) -> (Set NamedComponent, b)
processComponent PackageType
PTDependency StackLibrary
lib
Maybe StackLibrary
Nothing -> (Set NamedComponent, b) -> (Set NamedComponent, b)
forall a. a -> a
id
processSubLibDep :: (Set NamedComponent, b) -> (Set NamedComponent, b)
processSubLibDep (Set NamedComponent, b)
r = (StackUnqualCompName
-> (Set NamedComponent, b) -> (Set NamedComponent, b))
-> (Set NamedComponent, b)
-> Set StackUnqualCompName
-> (Set NamedComponent, b)
forall a b. (a -> b -> b) -> b -> Set a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr' StackUnqualCompName
-> (Set NamedComponent, b) -> (Set NamedComponent, b)
processSingleSubLib (Set NamedComponent, b)
r Set StackUnqualCompName
subLibDeps
(Set NamedComponent, b) -> (Set NamedComponent, b)
processSubLibDep ((Set NamedComponent, b) -> (Set NamedComponent, b)
processMainLibDep (Set NamedComponent, b)
res')
Maybe DepType
_ -> (Set NamedComponent, b)
res'