{-# LANGUAGE CPP, RecordWildCards, NamedFieldPuns, RankNTypes #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoMonoLocalBinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFunctor #-}

-- | Planning how to build everything in a project.
--
module Distribution.Client.ProjectPlanning (
    -- * elaborated install plan types
    ElaboratedInstallPlan,
    ElaboratedConfiguredPackage(..),
    ElaboratedPlanPackage,
    ElaboratedSharedConfig(..),
    ElaboratedReadyPackage,
    BuildStyle(..),
    CabalFileText,

    -- * Producing the elaborated install plan
    rebuildProjectConfig,
    rebuildInstallPlan,

    -- * Build targets
    availableTargets,
    AvailableTarget(..),
    AvailableTargetStatus(..),
    TargetRequested(..),
    ComponentTarget(..),
    SubComponentTarget(..),
    showComponentTarget,
    nubComponentTargets,

    -- * Selecting a plan subset
    pruneInstallPlanToTargets,
    TargetAction(..),
    pruneInstallPlanToDependencies,
    CannotPruneDependencies(..),

    -- * Utils required for building
    pkgHasEphemeralBuildTargets,
    elabBuildTargetWholeComponents,
    configureCompiler,

    -- * Setup.hs CLI flags for building
    setupHsScriptOptions,
    setupHsConfigureFlags,
    setupHsConfigureArgs,
    setupHsBuildFlags,
    setupHsBuildArgs,
    setupHsReplFlags,
    setupHsReplArgs,
    setupHsTestFlags,
    setupHsTestArgs,
    setupHsBenchFlags,
    setupHsBenchArgs,
    setupHsCopyFlags,
    setupHsRegisterFlags,
    setupHsHaddockFlags,
    setupHsHaddockArgs,

    packageHashInputs,

    -- * Path construction
    binDirectoryFor,
    binDirectories,
    storePackageInstallDirs,
    storePackageInstallDirs'
  ) where

import Prelude ()
import Distribution.Client.Compat.Prelude

import           Distribution.Client.HashValue
import           Distribution.Client.HttpUtils
import           Distribution.Client.ProjectPlanning.Types as Ty
import           Distribution.Client.PackageHash
import           Distribution.Client.RebuildMonad
import           Distribution.Client.Store
import           Distribution.Client.ProjectConfig
import           Distribution.Client.ProjectConfig.Legacy
import           Distribution.Client.ProjectPlanOutput

import           Distribution.Client.Types
import qualified Distribution.Client.InstallPlan as InstallPlan
import qualified Distribution.Client.SolverInstallPlan as SolverInstallPlan
import           Distribution.Client.Dependency
import           Distribution.Client.Dependency.Types
import qualified Distribution.Client.IndexUtils as IndexUtils
import           Distribution.Client.Utils (incVersion)
import           Distribution.Client.Targets (userToPackageConstraint)
import           Distribution.Client.DistDirLayout
import           Distribution.Client.SetupWrapper
import           Distribution.Client.JobControl
import           Distribution.Client.FetchUtils
import           Distribution.Client.Config
import qualified Hackage.Security.Client as Sec
import           Distribution.Client.Setup hiding (packageName, cabalVersion)
import           Distribution.Utils.NubList
import           Distribution.Utils.LogProgress
import           Distribution.Utils.MapAccum

import qualified Distribution.Client.BuildReports.Storage as BuildReports
         ( storeLocal, fromPlanningFailure )

import qualified Distribution.Solver.Types.ComponentDeps as CD
import           Distribution.Solver.Types.ComponentDeps (ComponentDeps)
import           Distribution.Solver.Types.ConstraintSource
import           Distribution.Solver.Types.LabeledPackageConstraint
import           Distribution.Solver.Types.OptionalStanza
import           Distribution.Solver.Types.PkgConfigDb
import           Distribution.Solver.Types.ResolverPackage
import           Distribution.Solver.Types.SolverId
import           Distribution.Solver.Types.SolverPackage
import           Distribution.Solver.Types.InstSolverPackage
import           Distribution.Solver.Types.SourcePackage
import           Distribution.Solver.Types.Settings

import           Distribution.CabalSpecVersion
import           Distribution.ModuleName
import           Distribution.Package
import           Distribution.Types.AnnotatedId
import           Distribution.Types.ComponentName
import           Distribution.Types.DumpBuildInfo
                   ( DumpBuildInfo (..) )
import           Distribution.Types.LibraryName
import           Distribution.Types.GivenComponent
  (GivenComponent(..))
import           Distribution.Types.PackageVersionConstraint
import           Distribution.Types.PkgconfigDependency
import           Distribution.Types.UnqualComponentName
import           Distribution.System
import qualified Distribution.PackageDescription as Cabal
import qualified Distribution.PackageDescription as PD
import qualified Distribution.PackageDescription.Configuration as PD
import           Distribution.Simple.PackageIndex (InstalledPackageIndex)
import           Distribution.Simple.Compiler
import qualified Distribution.Simple.GHC   as GHC   --TODO: [code cleanup] eliminate
import qualified Distribution.Simple.GHCJS as GHCJS --TODO: [code cleanup] eliminate
import           Distribution.Simple.Program
import           Distribution.Simple.Program.Db
import           Distribution.Simple.Program.Find
import qualified Distribution.Simple.Setup as Cabal
import           Distribution.Simple.Setup
  (Flag(..), toFlag, flagToMaybe, flagToList, fromFlagOrDefault)
import qualified Distribution.Simple.Configure as Cabal
import qualified Distribution.Simple.LocalBuildInfo as Cabal
import           Distribution.Simple.LocalBuildInfo
                   ( Component(..), pkgComponents, componentBuildInfo
                   , componentName )
import qualified Distribution.Simple.InstallDirs as InstallDirs
import qualified Distribution.InstalledPackageInfo as IPI

import           Distribution.Backpack.ConfiguredComponent
import           Distribution.Backpack.LinkedComponent
import           Distribution.Backpack.ComponentsGraph
import           Distribution.Backpack.ModuleShape
import           Distribution.Backpack.FullUnitId
import           Distribution.Backpack
import           Distribution.Types.ComponentInclude

import           Distribution.Simple.Utils
import           Distribution.Version

import qualified Distribution.Compat.Graph as Graph
import           Distribution.Compat.Graph(IsNode(..))

import           Data.Foldable (fold)
import           Text.PrettyPrint (text, hang, quotes, colon, vcat, ($$), fsep, punctuate, comma)
import qualified Text.PrettyPrint as Disp
import qualified Data.Map as Map
import qualified Data.Set as Set
import           Control.Monad.State as State
import           Control.Exception (assert)
import           Data.List (groupBy, deleteBy)
import qualified Data.List.NonEmpty as NE
import           System.FilePath

------------------------------------------------------------------------------
-- * Elaborated install plan
------------------------------------------------------------------------------

-- "Elaborated" -- worked out with great care and nicety of detail;
--                 executed with great minuteness: elaborate preparations;
--                 elaborate care.
--
-- So here's the idea:
--
-- Rather than a miscellaneous collection of 'ConfigFlags', 'InstallFlags' etc
-- all passed in as separate args and which are then further selected,
-- transformed etc during the execution of the build. Instead we construct
-- an elaborated install plan that includes everything we will need, and then
-- during the execution of the plan we do as little transformation of this
-- info as possible.
--
-- So we're trying to split the work into two phases: construction of the
-- elaborated install plan (which as far as possible should be pure) and
-- then simple execution of that plan without any smarts, just doing what the
-- plan says to do.
--
-- So that means we need a representation of this fully elaborated install
-- plan. The representation consists of two parts:
--
-- * A 'ElaboratedInstallPlan'. This is a 'GenericInstallPlan' with a
--   representation of source packages that includes a lot more detail about
--   that package's individual configuration
--
-- * A 'ElaboratedSharedConfig'. Some package configuration is the same for
--   every package in a plan. Rather than duplicate that info every entry in
--   the 'GenericInstallPlan' we keep that separately.
--
-- The division between the shared and per-package config is /not set in stone
-- for all time/. For example if we wanted to generalise the install plan to
-- describe a situation where we want to build some packages with GHC and some
-- with GHCJS then the platform and compiler would no longer be shared between
-- all packages but would have to be per-package (probably with some sanity
-- condition on the graph structure).
--

-- Refer to ProjectPlanning.Types for details of these important types:

-- type ElaboratedInstallPlan = ...
-- type ElaboratedPlanPackage = ...
-- data ElaboratedSharedConfig = ...
-- data ElaboratedConfiguredPackage = ...
-- data BuildStyle =


-- | Check that an 'ElaboratedConfiguredPackage' actually makes
-- sense under some 'ElaboratedSharedConfig'.
sanityCheckElaboratedConfiguredPackage
    :: ElaboratedSharedConfig
    -> ElaboratedConfiguredPackage
    -> a
    -> a
sanityCheckElaboratedConfiguredPackage :: ElaboratedSharedConfig -> ElaboratedConfiguredPackage -> a -> a
sanityCheckElaboratedConfiguredPackage ElaboratedSharedConfig
sharedConfig
                             elab :: ElaboratedConfiguredPackage
elab@ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
..} =
    (case ElaboratedPackageOrComponent
elabPkgOrComp of
        ElabPackage ElaboratedPackage
pkg -> ElaboratedConfiguredPackage -> ElaboratedPackage -> a -> a
forall a.
ElaboratedConfiguredPackage -> ElaboratedPackage -> a -> a
sanityCheckElaboratedPackage ElaboratedConfiguredPackage
elab ElaboratedPackage
pkg
        ElabComponent ElaboratedComponent
comp -> ElaboratedConfiguredPackage -> ElaboratedComponent -> a -> a
forall a.
ElaboratedConfiguredPackage -> ElaboratedComponent -> a -> a
sanityCheckElaboratedComponent ElaboratedConfiguredPackage
elab ElaboratedComponent
comp)

    -- either a package is being built inplace, or the
    -- 'installedPackageId' we assigned is consistent with
    -- the 'hashedInstalledPackageId' we would compute from
    -- the elaborated configured package
  (a -> a) -> (a -> a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> a -> a
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (BuildStyle
elabBuildStyle BuildStyle -> BuildStyle -> Bool
forall a. Eq a => a -> a -> Bool
== BuildStyle
BuildInplaceOnly Bool -> Bool -> Bool
||
     ComponentId
elabComponentId ComponentId -> ComponentId -> Bool
forall a. Eq a => a -> a -> Bool
== PackageHashInputs -> ComponentId
hashedInstalledPackageId
                            (ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> PackageHashInputs
packageHashInputs ElaboratedSharedConfig
sharedConfig ElaboratedConfiguredPackage
elab))

    -- the stanzas explicitly disabled should not be available
  (a -> a) -> (a -> a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> a -> a
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (OptionalStanzaSet -> Bool
optStanzaSetNull (OptionalStanzaSet -> Bool) -> OptionalStanzaSet -> Bool
forall a b. (a -> b) -> a -> b
$
        (Maybe Bool -> Bool)
-> OptionalStanzaMap (Maybe Bool) -> OptionalStanzaSet
forall a. (a -> Bool) -> OptionalStanzaMap a -> OptionalStanzaSet
optStanzaKeysFilteredByValue (Bool -> (Bool -> Bool) -> Maybe Bool -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False Bool -> Bool
not) OptionalStanzaMap (Maybe Bool)
elabStanzasRequested OptionalStanzaSet -> OptionalStanzaSet -> OptionalStanzaSet
`optStanzaSetIntersection` OptionalStanzaSet
elabStanzasAvailable)

    -- either a package is built inplace, or we are not attempting to
    -- build any test suites or benchmarks (we never build these
    -- for remote packages!)
  (a -> a) -> (a -> a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> a -> a
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (BuildStyle
elabBuildStyle BuildStyle -> BuildStyle -> Bool
forall a. Eq a => a -> a -> Bool
== BuildStyle
BuildInplaceOnly Bool -> Bool -> Bool
||
     OptionalStanzaSet -> Bool
optStanzaSetNull OptionalStanzaSet
elabStanzasAvailable)

sanityCheckElaboratedComponent
    :: ElaboratedConfiguredPackage
    -> ElaboratedComponent
    -> a
    -> a
sanityCheckElaboratedComponent :: ElaboratedConfiguredPackage -> ElaboratedComponent -> a -> a
sanityCheckElaboratedComponent ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..}
                               ElaboratedComponent{[(PkgconfigName, Maybe PkgconfigVersion)]
[(ConfiguredId, FilePath)]
[OpenUnitId]
[UnitId]
[ConfiguredId]
Maybe ComponentName
Component
compOrderLibDependencies :: ElaboratedComponent -> [UnitId]
compExeDependencyPaths :: ElaboratedComponent -> [(ConfiguredId, FilePath)]
compPkgConfigDependencies :: ElaboratedComponent -> [(PkgconfigName, Maybe PkgconfigVersion)]
compExeDependencies :: ElaboratedComponent -> [ConfiguredId]
compLinkedLibDependencies :: ElaboratedComponent -> [OpenUnitId]
compLibDependencies :: ElaboratedComponent -> [ConfiguredId]
compComponentName :: ElaboratedComponent -> Maybe ComponentName
compSolverName :: ElaboratedComponent -> Component
compOrderLibDependencies :: [UnitId]
compExeDependencyPaths :: [(ConfiguredId, FilePath)]
compPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
compExeDependencies :: [ConfiguredId]
compLinkedLibDependencies :: [OpenUnitId]
compLibDependencies :: [ConfiguredId]
compComponentName :: Maybe ComponentName
compSolverName :: Component
..} =

    -- Should not be building bench or test if not inplace.
    Bool -> a -> a
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (BuildStyle
elabBuildStyle BuildStyle -> BuildStyle -> Bool
forall a. Eq a => a -> a -> Bool
== BuildStyle
BuildInplaceOnly Bool -> Bool -> Bool
||
     case Maybe ComponentName
compComponentName of
        Maybe ComponentName
Nothing              -> Bool
True
        Just (CLibName LibraryName
_)    -> Bool
True
        Just (CExeName UnqualComponentName
_)    -> Bool
True
        -- This is interesting: there's no way to declare a dependency
        -- on a foreign library at the moment, but you may still want
        -- to install these to the store
        Just (CFLibName UnqualComponentName
_)   -> Bool
True
        Just (CBenchName UnqualComponentName
_)  -> Bool
False
        Just (CTestName UnqualComponentName
_)   -> Bool
False)


sanityCheckElaboratedPackage
    :: ElaboratedConfiguredPackage
    -> ElaboratedPackage
    -> a
    -> a
sanityCheckElaboratedPackage :: ElaboratedConfiguredPackage -> ElaboratedPackage -> a -> a
sanityCheckElaboratedPackage ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..}
                             ElaboratedPackage{[(PkgconfigName, Maybe PkgconfigVersion)]
ComponentId
OptionalStanzaSet
ComponentDeps [()]
ComponentDeps [(ConfiguredId, FilePath)]
ComponentDeps [ConfiguredId]
pkgStanzasEnabled :: ElaboratedPackage -> OptionalStanzaSet
pkgPkgConfigDependencies :: ElaboratedPackage -> [(PkgconfigName, Maybe PkgconfigVersion)]
pkgExeDependencyPaths :: ElaboratedPackage -> ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencies :: ElaboratedPackage -> ComponentDeps [ConfiguredId]
pkgDependsOnSelfLib :: ElaboratedPackage -> ComponentDeps [()]
pkgLibDependencies :: ElaboratedPackage -> ComponentDeps [ConfiguredId]
pkgInstalledId :: ElaboratedPackage -> ComponentId
pkgStanzasEnabled :: OptionalStanzaSet
pkgPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
pkgExeDependencyPaths :: ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencies :: ComponentDeps [ConfiguredId]
pkgDependsOnSelfLib :: ComponentDeps [()]
pkgLibDependencies :: ComponentDeps [ConfiguredId]
pkgInstalledId :: ComponentId
..} =
    -- we should only have enabled stanzas that actually can be built
    -- (according to the solver)
    Bool -> a -> a
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (OptionalStanzaSet
pkgStanzasEnabled OptionalStanzaSet -> OptionalStanzaSet -> Bool
`optStanzaSetIsSubset` OptionalStanzaSet
elabStanzasAvailable)

    -- the stanzas that the user explicitly requested should be
    -- enabled (by the previous test, they are also available)
  (a -> a) -> (a -> a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> a -> a
forall a. (?callStack::CallStack) => Bool -> a -> a
assert ((Maybe Bool -> Bool)
-> OptionalStanzaMap (Maybe Bool) -> OptionalStanzaSet
forall a. (a -> Bool) -> OptionalStanzaMap a -> OptionalStanzaSet
optStanzaKeysFilteredByValue (Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False) OptionalStanzaMap (Maybe Bool)
elabStanzasRequested
                OptionalStanzaSet -> OptionalStanzaSet -> Bool
`optStanzaSetIsSubset` OptionalStanzaSet
pkgStanzasEnabled)

------------------------------------------------------------------------------
-- * Deciding what to do: making an 'ElaboratedInstallPlan'
------------------------------------------------------------------------------

-- | Return the up-to-date project config and information about the local
-- packages within the project.
--
rebuildProjectConfig :: Verbosity
                     -> HttpTransport
                     -> DistDirLayout
                     -> ProjectConfig
                     -> IO ( ProjectConfig
                           , [PackageSpecifier UnresolvedSourcePackage] )
rebuildProjectConfig :: Verbosity
-> HttpTransport
-> DistDirLayout
-> ProjectConfig
-> IO (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
rebuildProjectConfig Verbosity
verbosity
                     HttpTransport
httpTransport
                     distDirLayout :: DistDirLayout
distDirLayout@DistDirLayout {
                       FilePath
distProjectRootDirectory :: DistDirLayout -> FilePath
distProjectRootDirectory :: FilePath
distProjectRootDirectory,
                       FilePath
distDirectory :: DistDirLayout -> FilePath
distDirectory :: FilePath
distDirectory,
                       FilePath -> FilePath
distProjectCacheFile :: DistDirLayout -> FilePath -> FilePath
distProjectCacheFile :: FilePath -> FilePath
distProjectCacheFile,
                       FilePath
distProjectCacheDirectory :: DistDirLayout -> FilePath
distProjectCacheDirectory :: FilePath
distProjectCacheDirectory,
                       FilePath -> FilePath
distProjectFile :: DistDirLayout -> FilePath -> FilePath
distProjectFile :: FilePath -> FilePath
distProjectFile
                     }
                     ProjectConfig
cliConfig = do

    (FilePath, FilePath)
fileMonitorProjectConfigKey <- do
      FilePath
configPath <- Flag FilePath -> IO FilePath
getConfigFilePath Flag FilePath
projectConfigConfigFile
      (FilePath, FilePath) -> IO (FilePath, FilePath)
forall (m :: * -> *) a. Monad m => a -> m a
return (FilePath
configPath, FilePath -> FilePath
distProjectFile FilePath
"")

    (ProjectConfig
projectConfig, [PackageSpecifier UnresolvedSourcePackage]
localPackages) <-
      FilePath
-> Rebuild
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
-> IO (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
forall a. FilePath -> Rebuild a -> IO a
runRebuild FilePath
distProjectRootDirectory
      (Rebuild
   (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
 -> IO (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage]))
-> Rebuild
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
-> IO (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
forall a b. (a -> b) -> a -> b
$ Verbosity
-> FileMonitor
     (FilePath, FilePath)
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
-> (FilePath, FilePath)
-> Rebuild
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
-> Rebuild
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
forall a b.
(Binary a, Structured a, Binary b, Structured b) =>
Verbosity -> FileMonitor a b -> a -> Rebuild b -> Rebuild b
rerunIfChanged Verbosity
verbosity
                       FileMonitor
  (FilePath, FilePath)
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
fileMonitorProjectConfig
                       (FilePath, FilePath)
fileMonitorProjectConfigKey -- todo check deps too?
      (Rebuild
   (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
 -> Rebuild
      (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage]))
-> Rebuild
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
-> Rebuild
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
forall a b. (a -> b) -> a -> b
$ do
          IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> FilePath -> IO ()
info Verbosity
verbosity FilePath
"Project settings changed, reconfiguring..."
          IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> Bool -> FilePath -> IO ()
createDirectoryIfMissingVerbose Verbosity
verbosity Bool
True FilePath
distProjectCacheDirectory
          ProjectConfigSkeleton
projectConfigSkeleton <- Rebuild ProjectConfigSkeleton
phaseReadProjectConfig
          -- have to create the cache directory before configuring the compiler
          (Compiler
compiler, Platform Arch
arch OS
os, ProgramDb
_) <- Verbosity
-> DistDirLayout
-> ProjectConfig
-> Rebuild (Compiler, Platform, ProgramDb)
configureCompiler Verbosity
verbosity DistDirLayout
distDirLayout (((ProjectConfig, [FilePath]) -> ProjectConfig
forall a b. (a, b) -> a
fst ((ProjectConfig, [FilePath]) -> ProjectConfig)
-> (ProjectConfig, [FilePath]) -> ProjectConfig
forall a b. (a -> b) -> a -> b
$ ProjectConfigSkeleton -> (ProjectConfig, [FilePath])
forall a c v.
(Semigroup a, Semigroup c) =>
CondTree v c a -> (a, c)
PD.ignoreConditions ProjectConfigSkeleton
projectConfigSkeleton) ProjectConfig -> ProjectConfig -> ProjectConfig
forall a. Semigroup a => a -> a -> a
<> ProjectConfig
cliConfig)
          let projectConfig :: ProjectConfig
projectConfig = OS
-> Arch
-> CompilerInfo
-> FlagAssignment
-> ProjectConfigSkeleton
-> ProjectConfig
instantiateProjectConfigSkeleton OS
os Arch
arch (Compiler -> CompilerInfo
compilerInfo Compiler
compiler) FlagAssignment
forall a. Monoid a => a
mempty ProjectConfigSkeleton
projectConfigSkeleton
          [PackageSpecifier UnresolvedSourcePackage]
localPackages <- ProjectConfig -> Rebuild [PackageSpecifier UnresolvedSourcePackage]
phaseReadLocalPackages (ProjectConfig
projectConfig ProjectConfig -> ProjectConfig -> ProjectConfig
forall a. Semigroup a => a -> a -> a
<> ProjectConfig
cliConfig)
          (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
-> Rebuild
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectConfig
projectConfig, [PackageSpecifier UnresolvedSourcePackage]
localPackages)

    Verbosity -> FilePath -> IO ()
info Verbosity
verbosity
      (FilePath -> IO ()) -> FilePath -> IO ()
forall a b. (a -> b) -> a -> b
$ [FilePath] -> FilePath
unlines
      ([FilePath] -> FilePath) -> [FilePath] -> FilePath
forall a b. (a -> b) -> a -> b
$ (FilePath
"this build was affected by the following (project) config files:" FilePath -> [FilePath] -> [FilePath]
forall a. a -> [a] -> [a]
:)
      ([FilePath] -> [FilePath]) -> [FilePath] -> [FilePath]
forall a b. (a -> b) -> a -> b
$ [ FilePath
"- " FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ FilePath
path
        | Explicit FilePath
path <- Set ProjectConfigProvenance -> [ProjectConfigProvenance]
forall a. Set a -> [a]
Set.toList (Set ProjectConfigProvenance -> [ProjectConfigProvenance])
-> Set ProjectConfigProvenance -> [ProjectConfigProvenance]
forall a b. (a -> b) -> a -> b
$ ProjectConfig -> Set ProjectConfigProvenance
projectConfigProvenance ProjectConfig
projectConfig
        ]

    (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
-> IO (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectConfig
projectConfig ProjectConfig -> ProjectConfig -> ProjectConfig
forall a. Semigroup a => a -> a -> a
<> ProjectConfig
cliConfig, [PackageSpecifier UnresolvedSourcePackage]
localPackages)

  where

    ProjectConfigShared { Flag FilePath
projectConfigConfigFile :: ProjectConfigShared -> Flag FilePath
projectConfigConfigFile :: Flag FilePath
projectConfigConfigFile } =
      ProjectConfig -> ProjectConfigShared
projectConfigShared ProjectConfig
cliConfig

    ProjectConfigShared { Flag Bool
projectConfigIgnoreProject :: ProjectConfigShared -> Flag Bool
projectConfigIgnoreProject :: Flag Bool
projectConfigIgnoreProject } =
      ProjectConfig -> ProjectConfigShared
projectConfigShared ProjectConfig
cliConfig

    fileMonitorProjectConfig ::
      FileMonitor
        (FilePath, FilePath)
        (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
    fileMonitorProjectConfig :: FileMonitor
  (FilePath, FilePath)
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
fileMonitorProjectConfig =
      FilePath
-> FileMonitor
     (FilePath, FilePath)
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage])
forall a b. Eq a => FilePath -> FileMonitor a b
newFileMonitor (FilePath -> FilePath
distProjectCacheFile FilePath
"config")

    -- Read the cabal.project (or implicit config) and combine it with
    -- arguments from the command line
    --
    phaseReadProjectConfig :: Rebuild ProjectConfigSkeleton
    phaseReadProjectConfig :: Rebuild ProjectConfigSkeleton
phaseReadProjectConfig = do
      Verbosity
-> HttpTransport
-> Flag Bool
-> Flag FilePath
-> DistDirLayout
-> Rebuild ProjectConfigSkeleton
readProjectConfig Verbosity
verbosity HttpTransport
httpTransport Flag Bool
projectConfigIgnoreProject Flag FilePath
projectConfigConfigFile DistDirLayout
distDirLayout

    -- Look for all the cabal packages in the project
    -- some of which may be local src dirs, tarballs etc
    --
    phaseReadLocalPackages :: ProjectConfig
                           -> Rebuild [PackageSpecifier UnresolvedSourcePackage]
    phaseReadLocalPackages :: ProjectConfig -> Rebuild [PackageSpecifier UnresolvedSourcePackage]
phaseReadLocalPackages projectConfig :: ProjectConfig
projectConfig@ProjectConfig {
                               ProjectConfigShared
projectConfigShared :: ProjectConfigShared
projectConfigShared :: ProjectConfig -> ProjectConfigShared
projectConfigShared,
                               ProjectConfigBuildOnly
projectConfigBuildOnly :: ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly :: ProjectConfigBuildOnly
projectConfigBuildOnly
                             } = do

      [ProjectPackageLocation]
pkgLocations <- DistDirLayout -> ProjectConfig -> Rebuild [ProjectPackageLocation]
findProjectPackages DistDirLayout
distDirLayout ProjectConfig
projectConfig
      -- Create folder only if findProjectPackages did not throw a
      -- BadPackageLocations exception.
      IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ do
        Verbosity -> Bool -> FilePath -> IO ()
createDirectoryIfMissingVerbose Verbosity
verbosity Bool
True FilePath
distDirectory
        Verbosity -> Bool -> FilePath -> IO ()
createDirectoryIfMissingVerbose Verbosity
verbosity Bool
True FilePath
distProjectCacheDirectory

      Verbosity
-> DistDirLayout
-> ProjectConfigShared
-> ProjectConfigBuildOnly
-> [ProjectPackageLocation]
-> Rebuild [PackageSpecifier UnresolvedSourcePackage]
fetchAndReadSourcePackages Verbosity
verbosity DistDirLayout
distDirLayout
                                 ProjectConfigShared
projectConfigShared
                                 ProjectConfigBuildOnly
projectConfigBuildOnly
                                 [ProjectPackageLocation]
pkgLocations


configureCompiler :: Verbosity ->
                     DistDirLayout ->
                     ProjectConfig ->
                     Rebuild (Compiler, Platform, ProgramDb)
configureCompiler :: Verbosity
-> DistDirLayout
-> ProjectConfig
-> Rebuild (Compiler, Platform, ProgramDb)
configureCompiler Verbosity
verbosity
                  DistDirLayout {
                     FilePath -> FilePath
distProjectCacheFile :: FilePath -> FilePath
distProjectCacheFile :: DistDirLayout -> FilePath -> FilePath
distProjectCacheFile
                   }
                  ProjectConfig {
                             projectConfigShared :: ProjectConfig -> ProjectConfigShared
projectConfigShared = ProjectConfigShared {
                               Flag CompilerFlavor
projectConfigHcFlavor :: ProjectConfigShared -> Flag CompilerFlavor
projectConfigHcFlavor :: Flag CompilerFlavor
projectConfigHcFlavor,
                               Flag FilePath
projectConfigHcPath :: ProjectConfigShared -> Flag FilePath
projectConfigHcPath :: Flag FilePath
projectConfigHcPath,
                               Flag FilePath
projectConfigHcPkg :: ProjectConfigShared -> Flag FilePath
projectConfigHcPkg :: Flag FilePath
projectConfigHcPkg
                             },
                             projectConfigLocalPackages :: ProjectConfig -> PackageConfig
projectConfigLocalPackages = PackageConfig {
                               MapLast FilePath FilePath
packageConfigProgramPaths :: PackageConfig -> MapLast FilePath FilePath
packageConfigProgramPaths :: MapLast FilePath FilePath
packageConfigProgramPaths,
                               NubList FilePath
packageConfigProgramPathExtra :: PackageConfig -> NubList FilePath
packageConfigProgramPathExtra :: NubList FilePath
packageConfigProgramPathExtra
                             }
                           } = do
        let fileMonitorCompiler :: FileMonitor
  (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
   MapLast FilePath FilePath, NubList FilePath)
  b
fileMonitorCompiler       = FilePath
-> FileMonitor
     (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
      MapLast FilePath FilePath, NubList FilePath)
     b
forall a b. Eq a => FilePath -> FileMonitor a b
newFileMonitor (FilePath
 -> FileMonitor
      (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
       MapLast FilePath FilePath, NubList FilePath)
      b)
-> (FilePath -> FilePath)
-> FilePath
-> FileMonitor
     (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
      MapLast FilePath FilePath, NubList FilePath)
     b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> FilePath
distProjectCacheFile (FilePath
 -> FileMonitor
      (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
       MapLast FilePath FilePath, NubList FilePath)
      b)
-> FilePath
-> FileMonitor
     (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
      MapLast FilePath FilePath, NubList FilePath)
     b
forall a b. (a -> b) -> a -> b
$ FilePath
"compiler"

        [FilePath]
progsearchpath <- IO [FilePath] -> Rebuild [FilePath]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [FilePath] -> Rebuild [FilePath])
-> IO [FilePath] -> Rebuild [FilePath]
forall a b. (a -> b) -> a -> b
$ IO [FilePath]
getSystemSearchPath
        Verbosity
-> FileMonitor
     (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
      MapLast FilePath FilePath, NubList FilePath)
     (Compiler, Platform, ProgramDb)
-> (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath,
    [FilePath], MapLast FilePath FilePath, NubList FilePath)
-> Rebuild (Compiler, Platform, ProgramDb)
-> Rebuild (Compiler, Platform, ProgramDb)
forall a b.
(Binary a, Structured a, Binary b, Structured b) =>
Verbosity -> FileMonitor a b -> a -> Rebuild b -> Rebuild b
rerunIfChanged Verbosity
verbosity FileMonitor
  (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
   MapLast FilePath FilePath, NubList FilePath)
  (Compiler, Platform, ProgramDb)
forall b.
FileMonitor
  (Maybe CompilerFlavor, Maybe FilePath, Maybe FilePath, [FilePath],
   MapLast FilePath FilePath, NubList FilePath)
  b
fileMonitorCompiler
                       (Maybe CompilerFlavor
hcFlavor, Maybe FilePath
hcPath, Maybe FilePath
hcPkg, [FilePath]
progsearchpath,
                        MapLast FilePath FilePath
packageConfigProgramPaths,
                        NubList FilePath
packageConfigProgramPathExtra) (Rebuild (Compiler, Platform, ProgramDb)
 -> Rebuild (Compiler, Platform, ProgramDb))
-> Rebuild (Compiler, Platform, ProgramDb)
-> Rebuild (Compiler, Platform, ProgramDb)
forall a b. (a -> b) -> a -> b
$ do

          IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> FilePath -> IO ()
info Verbosity
verbosity FilePath
"Compiler settings changed, reconfiguring..."
          result :: (Compiler, Platform, ProgramDb)
result@(Compiler
_, Platform
_, ProgramDb
progdb') <- IO (Compiler, Platform, ProgramDb)
-> Rebuild (Compiler, Platform, ProgramDb)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Compiler, Platform, ProgramDb)
 -> Rebuild (Compiler, Platform, ProgramDb))
-> IO (Compiler, Platform, ProgramDb)
-> Rebuild (Compiler, Platform, ProgramDb)
forall a b. (a -> b) -> a -> b
$
            Maybe CompilerFlavor
-> Maybe FilePath
-> Maybe FilePath
-> ProgramDb
-> Verbosity
-> IO (Compiler, Platform, ProgramDb)
Cabal.configCompilerEx
              Maybe CompilerFlavor
hcFlavor Maybe FilePath
hcPath Maybe FilePath
hcPkg
              ProgramDb
progdb Verbosity
verbosity

        -- Note that we added the user-supplied program locations and args
        -- for /all/ programs, not just those for the compiler prog and
        -- compiler-related utils. In principle we don't know which programs
        -- the compiler will configure (and it does vary between compilers).
        -- We do know however that the compiler will only configure the
        -- programs it cares about, and those are the ones we monitor here.
          [MonitorFilePath] -> Rebuild ()
monitorFiles (ProgramDb -> [MonitorFilePath]
programsMonitorFiles ProgramDb
progdb')

          (Compiler, Platform, ProgramDb)
-> Rebuild (Compiler, Platform, ProgramDb)
forall (m :: * -> *) a. Monad m => a -> m a
return (Compiler, Platform, ProgramDb)
result
      where
        hcFlavor :: Maybe CompilerFlavor
hcFlavor = Flag CompilerFlavor -> Maybe CompilerFlavor
forall a. Flag a -> Maybe a
flagToMaybe Flag CompilerFlavor
projectConfigHcFlavor
        hcPath :: Maybe FilePath
hcPath   = Flag FilePath -> Maybe FilePath
forall a. Flag a -> Maybe a
flagToMaybe Flag FilePath
projectConfigHcPath
        hcPkg :: Maybe FilePath
hcPkg    = Flag FilePath -> Maybe FilePath
forall a. Flag a -> Maybe a
flagToMaybe Flag FilePath
projectConfigHcPkg
        progdb :: ProgramDb
progdb   =
            [(FilePath, FilePath)] -> ProgramDb -> ProgramDb
userSpecifyPaths (Map FilePath FilePath -> [(FilePath, FilePath)]
forall k a. Map k a -> [(k, a)]
Map.toList (MapLast FilePath FilePath -> Map FilePath FilePath
forall k v. MapLast k v -> Map k v
getMapLast MapLast FilePath FilePath
packageConfigProgramPaths))
          (ProgramDb -> ProgramDb)
-> (ProgramDb -> ProgramDb) -> ProgramDb -> ProgramDb
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ProgramSearchPath -> ProgramSearchPath) -> ProgramDb -> ProgramDb
modifyProgramSearchPath
              (ProgramSearchPath -> ProgramSearchPath -> ProgramSearchPath
forall a. [a] -> [a] -> [a]
++ [ FilePath -> ProgramSearchPathEntry
ProgramSearchPathDir FilePath
dir
                  | FilePath
dir <- NubList FilePath -> [FilePath]
forall a. NubList a -> [a]
fromNubList NubList FilePath
packageConfigProgramPathExtra ])
          (ProgramDb -> ProgramDb) -> ProgramDb -> ProgramDb
forall a b. (a -> b) -> a -> b
$ ProgramDb
defaultProgramDb


-- | Return an up-to-date elaborated install plan.
--
-- Two variants of the install plan are returned: with and without packages
-- from the store. That is, the \"improved\" plan where source packages are
-- replaced by pre-existing installed packages from the store (when their ids
-- match), and also the original elaborated plan which uses primarily source
-- packages.

-- The improved plan is what we use for building, but the original elaborated
-- plan is useful for reporting and configuration. For example the @freeze@
-- command needs the source package info to know about flag choices and
-- dependencies of executables and setup scripts.
--
rebuildInstallPlan :: Verbosity
                   -> DistDirLayout -> CabalDirLayout
                   -> ProjectConfig
                   -> [PackageSpecifier UnresolvedSourcePackage]
                   -> IO ( ElaboratedInstallPlan  -- with store packages
                         , ElaboratedInstallPlan  -- with source packages
                         , ElaboratedSharedConfig
                         , IndexUtils.TotalIndexState
                         , IndexUtils.ActiveRepos
                         )
                      -- ^ @(improvedPlan, elaboratedPlan, _, _, _)@
rebuildInstallPlan :: Verbosity
-> DistDirLayout
-> CabalDirLayout
-> ProjectConfig
-> [PackageSpecifier UnresolvedSourcePackage]
-> IO
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
rebuildInstallPlan Verbosity
verbosity
                   distDirLayout :: DistDirLayout
distDirLayout@DistDirLayout {
                     FilePath
distProjectRootDirectory :: FilePath
distProjectRootDirectory :: DistDirLayout -> FilePath
distProjectRootDirectory,
                     FilePath -> FilePath
distProjectCacheFile :: FilePath -> FilePath
distProjectCacheFile :: DistDirLayout -> FilePath -> FilePath
distProjectCacheFile
                   }
                   CabalDirLayout {
                     StoreDirLayout
cabalStoreDirLayout :: CabalDirLayout -> StoreDirLayout
cabalStoreDirLayout :: StoreDirLayout
cabalStoreDirLayout
                   } = \ProjectConfig
projectConfig [PackageSpecifier UnresolvedSourcePackage]
localPackages ->
    FilePath
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
-> IO
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
forall a. FilePath -> Rebuild a -> IO a
runRebuild FilePath
distProjectRootDirectory (Rebuild
   (ElaboratedInstallPlan, ElaboratedInstallPlan,
    ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
 -> IO
      (ElaboratedInstallPlan, ElaboratedInstallPlan,
       ElaboratedSharedConfig, TotalIndexState, ActiveRepos))
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
-> IO
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
forall a b. (a -> b) -> a -> b
$ do
    [FilePath]
progsearchpath <- IO [FilePath] -> Rebuild [FilePath]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [FilePath] -> Rebuild [FilePath])
-> IO [FilePath] -> Rebuild [FilePath]
forall a b. (a -> b) -> a -> b
$ IO [FilePath]
getSystemSearchPath
    let projectConfigMonitored :: ProjectConfig
projectConfigMonitored = ProjectConfig
projectConfig { projectConfigBuildOnly :: ProjectConfigBuildOnly
projectConfigBuildOnly = ProjectConfigBuildOnly
forall a. Monoid a => a
mempty }

    -- The overall improved plan is cached
    Verbosity
-> FileMonitor
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
      [FilePath])
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
-> (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
    [FilePath])
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
forall a b.
(Binary a, Structured a, Binary b, Structured b) =>
Verbosity -> FileMonitor a b -> a -> Rebuild b -> Rebuild b
rerunIfChanged Verbosity
verbosity FileMonitor
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
   [FilePath])
  (ElaboratedInstallPlan, ElaboratedInstallPlan,
   ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
forall b.
FileMonitor
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
   [FilePath])
  b
fileMonitorImprovedPlan
                   -- react to changes in the project config,
                   -- the package .cabal files and the path
                   (ProjectConfig
projectConfigMonitored, [PackageSpecifier UnresolvedSourcePackage]
localPackages, [FilePath]
progsearchpath) (Rebuild
   (ElaboratedInstallPlan, ElaboratedInstallPlan,
    ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
 -> Rebuild
      (ElaboratedInstallPlan, ElaboratedInstallPlan,
       ElaboratedSharedConfig, TotalIndexState, ActiveRepos))
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
forall a b. (a -> b) -> a -> b
$ do

      -- And so is the elaborated plan that the improved plan based on
      (ElaboratedInstallPlan
elaboratedPlan, ElaboratedSharedConfig
elaboratedShared, TotalIndexState
totalIndexState, ActiveRepos
activeRepos) <-
        Verbosity
-> FileMonitor
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
      [FilePath])
     (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
      ActiveRepos)
-> (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
    [FilePath])
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
      ActiveRepos)
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
      ActiveRepos)
forall a b.
(Binary a, Structured a, Binary b, Structured b) =>
Verbosity -> FileMonitor a b -> a -> Rebuild b -> Rebuild b
rerunIfChanged Verbosity
verbosity FileMonitor
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
   [FilePath])
  (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
   ActiveRepos)
forall b.
FileMonitor
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
   [FilePath])
  b
fileMonitorElaboratedPlan
                       (ProjectConfig
projectConfigMonitored, [PackageSpecifier UnresolvedSourcePackage]
localPackages,
                        [FilePath]
progsearchpath) (Rebuild
   (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
    ActiveRepos)
 -> Rebuild
      (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
       ActiveRepos))
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
      ActiveRepos)
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
      ActiveRepos)
forall a b. (a -> b) -> a -> b
$ do

          (Compiler, Platform, ProgramDb)
compilerEtc   <- ProjectConfig -> Rebuild (Compiler, Platform, ProgramDb)
phaseConfigureCompiler ProjectConfig
projectConfig
          ()
_             <- ProjectConfig -> (Compiler, Platform, ProgramDb) -> Rebuild ()
phaseConfigurePrograms ProjectConfig
projectConfig (Compiler, Platform, ProgramDb)
compilerEtc
          (SolverInstallPlan
solverPlan, PkgConfigDb
pkgConfigDB, TotalIndexState
totalIndexState, ActiveRepos
activeRepos)
                        <- ProjectConfig
-> (Compiler, Platform, ProgramDb)
-> [PackageSpecifier UnresolvedSourcePackage]
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
phaseRunSolver         ProjectConfig
projectConfig
                                                  (Compiler, Platform, ProgramDb)
compilerEtc
                                                  [PackageSpecifier UnresolvedSourcePackage]
localPackages
          (ElaboratedInstallPlan
elaboratedPlan,
           ElaboratedSharedConfig
elaboratedShared) <- ProjectConfig
-> (Compiler, Platform, ProgramDb)
-> PkgConfigDb
-> SolverInstallPlan
-> [PackageSpecifier UnresolvedSourcePackage]
-> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall loc.
ProjectConfig
-> (Compiler, Platform, ProgramDb)
-> PkgConfigDb
-> SolverInstallPlan
-> [PackageSpecifier (SourcePackage (PackageLocation loc))]
-> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig)
phaseElaboratePlan ProjectConfig
projectConfig
                                                   (Compiler, Platform, ProgramDb)
compilerEtc PkgConfigDb
pkgConfigDB
                                                   SolverInstallPlan
solverPlan
                                                   [PackageSpecifier UnresolvedSourcePackage]
localPackages

          ElaboratedInstallPlan -> ElaboratedSharedConfig -> Rebuild ()
phaseMaintainPlanOutputs ElaboratedInstallPlan
elaboratedPlan ElaboratedSharedConfig
elaboratedShared
          (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
 ActiveRepos)
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedSharedConfig, TotalIndexState,
      ActiveRepos)
forall (m :: * -> *) a. Monad m => a -> m a
return (ElaboratedInstallPlan
elaboratedPlan, ElaboratedSharedConfig
elaboratedShared, TotalIndexState
totalIndexState, ActiveRepos
activeRepos)

      -- The improved plan changes each time we install something, whereas
      -- the underlying elaborated plan only changes when input config
      -- changes, so it's worth caching them separately.
      ElaboratedInstallPlan
improvedPlan <- ElaboratedInstallPlan
-> ElaboratedSharedConfig -> Rebuild ElaboratedInstallPlan
phaseImprovePlan ElaboratedInstallPlan
elaboratedPlan ElaboratedSharedConfig
elaboratedShared

      (ElaboratedInstallPlan, ElaboratedInstallPlan,
 ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
-> Rebuild
     (ElaboratedInstallPlan, ElaboratedInstallPlan,
      ElaboratedSharedConfig, TotalIndexState, ActiveRepos)
forall (m :: * -> *) a. Monad m => a -> m a
return (ElaboratedInstallPlan
improvedPlan, ElaboratedInstallPlan
elaboratedPlan, ElaboratedSharedConfig
elaboratedShared, TotalIndexState
totalIndexState, ActiveRepos
activeRepos)

  where
    fileMonitorSolverPlan :: FileMonitor
  (SolverSettings, [PackageSpecifier UnresolvedSourcePackage],
   Map PackageName (Map OptionalStanza Bool), Compiler, Platform,
   [ConfiguredProgram])
  b
fileMonitorSolverPlan     = FilePath
-> FileMonitor
     (SolverSettings, [PackageSpecifier UnresolvedSourcePackage],
      Map PackageName (Map OptionalStanza Bool), Compiler, Platform,
      [ConfiguredProgram])
     b
forall a b. Eq a => FilePath -> FileMonitor a b
newFileMonitorInCacheDir FilePath
"solver-plan"
    fileMonitorSourceHashes :: FileMonitor [(PackageId, PackageLocation (Maybe FilePath))] b
fileMonitorSourceHashes   = FilePath
-> FileMonitor [(PackageId, PackageLocation (Maybe FilePath))] b
forall a b. Eq a => FilePath -> FileMonitor a b
newFileMonitorInCacheDir FilePath
"source-hashes"
    fileMonitorElaboratedPlan :: FileMonitor
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
   [FilePath])
  b
fileMonitorElaboratedPlan = FilePath
-> FileMonitor
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
      [FilePath])
     b
forall a b. Eq a => FilePath -> FileMonitor a b
newFileMonitorInCacheDir FilePath
"elaborated-plan"
    fileMonitorImprovedPlan :: FileMonitor
  (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
   [FilePath])
  b
fileMonitorImprovedPlan   = FilePath
-> FileMonitor
     (ProjectConfig, [PackageSpecifier UnresolvedSourcePackage],
      [FilePath])
     b
forall a b. Eq a => FilePath -> FileMonitor a b
newFileMonitorInCacheDir FilePath
"improved-plan"

    newFileMonitorInCacheDir :: Eq a => FilePath -> FileMonitor a b
    newFileMonitorInCacheDir :: FilePath -> FileMonitor a b
newFileMonitorInCacheDir  = FilePath -> FileMonitor a b
forall a b. Eq a => FilePath -> FileMonitor a b
newFileMonitor (FilePath -> FileMonitor a b)
-> (FilePath -> FilePath) -> FilePath -> FileMonitor a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> FilePath
distProjectCacheFile


    -- Configure the compiler we're using.
    --
    -- This is moderately expensive and doesn't change that often so we cache
    -- it independently.
    --
    phaseConfigureCompiler :: ProjectConfig
                           -> Rebuild (Compiler, Platform, ProgramDb)
    phaseConfigureCompiler :: ProjectConfig -> Rebuild (Compiler, Platform, ProgramDb)
phaseConfigureCompiler = Verbosity
-> DistDirLayout
-> ProjectConfig
-> Rebuild (Compiler, Platform, ProgramDb)
configureCompiler Verbosity
verbosity DistDirLayout
distDirLayout

    -- Configuring other programs.
    --
    -- Having configred the compiler, now we configure all the remaining
    -- programs. This is to check we can find them, and to monitor them for
    -- changes.
    --
    -- TODO: [required eventually] we don't actually do this yet.
    --
    -- We rely on the fact that the previous phase added the program config for
    -- all local packages, but that all the programs configured so far are the
    -- compiler program or related util programs.
    --
    phaseConfigurePrograms :: ProjectConfig
                           -> (Compiler, Platform, ProgramDb)
                           -> Rebuild ()
    phaseConfigurePrograms :: ProjectConfig -> (Compiler, Platform, ProgramDb) -> Rebuild ()
phaseConfigurePrograms ProjectConfig
projectConfig (Compiler
_, Platform
_, ProgramDb
compilerprogdb) = do
        -- Users are allowed to specify program locations independently for
        -- each package (e.g. to use a particular version of a pre-processor
        -- for some packages). However they cannot do this for the compiler
        -- itself as that's just not going to work. So we check for this.
        IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ [ConfiguredProgram] -> Map PackageName PackageConfig -> IO ()
checkBadPerPackageCompilerPaths
          (ProgramDb -> [ConfiguredProgram]
configuredPrograms ProgramDb
compilerprogdb)
          (MapMappend PackageName PackageConfig
-> Map PackageName PackageConfig
forall k v. MapMappend k v -> Map k v
getMapMappend (ProjectConfig -> MapMappend PackageName PackageConfig
projectConfigSpecificPackage ProjectConfig
projectConfig))

        --TODO: [required eventually] find/configure other programs that the
        -- user specifies.

        --TODO: [required eventually] find/configure all build-tools
        -- but note that some of them may be built as part of the plan.


    -- Run the solver to get the initial install plan.
    -- This is expensive so we cache it independently.
    --
    phaseRunSolver
        :: ProjectConfig
        -> (Compiler, Platform, ProgramDb)
        -> [PackageSpecifier UnresolvedSourcePackage]
        -> Rebuild (SolverInstallPlan, PkgConfigDb, IndexUtils.TotalIndexState, IndexUtils.ActiveRepos)
    phaseRunSolver :: ProjectConfig
-> (Compiler, Platform, ProgramDb)
-> [PackageSpecifier UnresolvedSourcePackage]
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
phaseRunSolver projectConfig :: ProjectConfig
projectConfig@ProjectConfig {
                     ProjectConfigShared
projectConfigShared :: ProjectConfigShared
projectConfigShared :: ProjectConfig -> ProjectConfigShared
projectConfigShared,
                     ProjectConfigBuildOnly
projectConfigBuildOnly :: ProjectConfigBuildOnly
projectConfigBuildOnly :: ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly
                   }
                   (Compiler
compiler, Platform
platform, ProgramDb
progdb)
                   [PackageSpecifier UnresolvedSourcePackage]
localPackages =
        Verbosity
-> FileMonitor
     (SolverSettings, [PackageSpecifier UnresolvedSourcePackage],
      Map PackageName (Map OptionalStanza Bool), Compiler, Platform,
      [ConfiguredProgram])
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
-> (SolverSettings, [PackageSpecifier UnresolvedSourcePackage],
    Map PackageName (Map OptionalStanza Bool), Compiler, Platform,
    [ConfiguredProgram])
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
forall a b.
(Binary a, Structured a, Binary b, Structured b) =>
Verbosity -> FileMonitor a b -> a -> Rebuild b -> Rebuild b
rerunIfChanged Verbosity
verbosity FileMonitor
  (SolverSettings, [PackageSpecifier UnresolvedSourcePackage],
   Map PackageName (Map OptionalStanza Bool), Compiler, Platform,
   [ConfiguredProgram])
  (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
forall b.
FileMonitor
  (SolverSettings, [PackageSpecifier UnresolvedSourcePackage],
   Map PackageName (Map OptionalStanza Bool), Compiler, Platform,
   [ConfiguredProgram])
  b
fileMonitorSolverPlan
                       (SolverSettings
solverSettings,
                        [PackageSpecifier UnresolvedSourcePackage]
localPackages, Map PackageName (Map OptionalStanza Bool)
localPackagesEnabledStanzas,
                        Compiler
compiler, Platform
platform, ProgramDb -> [ConfiguredProgram]
programDbSignature ProgramDb
progdb) (Rebuild
   (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
 -> Rebuild
      (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos))
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
forall a b. (a -> b) -> a -> b
$ do

          InstalledPackageIndex
installedPkgIndex <- Verbosity
-> Compiler
-> ProgramDb
-> Platform
-> PackageDBStack
-> Rebuild InstalledPackageIndex
getInstalledPackages Verbosity
verbosity
                                                    Compiler
compiler ProgramDb
progdb Platform
platform
                                                    PackageDBStack
corePackageDbs
          (SourcePackageDb
sourcePkgDb, TotalIndexState
tis, ActiveRepos
ar) <- Verbosity
-> (forall a. (RepoContext -> IO a) -> IO a)
-> Maybe TotalIndexState
-> Maybe ActiveRepos
-> Rebuild (SourcePackageDb, TotalIndexState, ActiveRepos)
getSourcePackages Verbosity
verbosity forall a. (RepoContext -> IO a) -> IO a
withRepoCtx
              (SolverSettings -> Maybe TotalIndexState
solverSettingIndexState SolverSettings
solverSettings)
              (SolverSettings -> Maybe ActiveRepos
solverSettingActiveRepos SolverSettings
solverSettings)
          PkgConfigDb
pkgConfigDB       <- Verbosity -> ProgramDb -> Rebuild PkgConfigDb
getPkgConfigDb Verbosity
verbosity ProgramDb
progdb

          --TODO: [code cleanup] it'd be better if the Compiler contained the
          -- ConfiguredPrograms that it needs, rather than relying on the progdb
          -- since we don't need to depend on all the programs here, just the
          -- ones relevant for the compiler.

          IO (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
 -> Rebuild
      (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos))
-> IO
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
-> Rebuild
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
forall a b. (a -> b) -> a -> b
$ do
            Solver
solver <- Verbosity -> PreSolver -> CompilerInfo -> IO Solver
chooseSolver Verbosity
verbosity
                                   (SolverSettings -> PreSolver
solverSettingSolver SolverSettings
solverSettings)
                                   (Compiler -> CompilerInfo
compilerInfo Compiler
compiler)

            Verbosity -> FilePath -> IO ()
notice Verbosity
verbosity FilePath
"Resolving dependencies..."
            Either FilePath SolverInstallPlan
planOrError <- (FilePath
 -> IO (Either FilePath SolverInstallPlan)
 -> IO (Either FilePath SolverInstallPlan))
-> (FilePath -> IO (Either FilePath SolverInstallPlan))
-> (SolverInstallPlan -> IO (Either FilePath SolverInstallPlan))
-> Progress FilePath FilePath SolverInstallPlan
-> IO (Either FilePath SolverInstallPlan)
forall step a fail done.
(step -> a -> a)
-> (fail -> a) -> (done -> a) -> Progress step fail done -> a
foldProgress FilePath
-> IO (Either FilePath SolverInstallPlan)
-> IO (Either FilePath SolverInstallPlan)
forall b. FilePath -> IO b -> IO b
logMsg (Either FilePath SolverInstallPlan
-> IO (Either FilePath SolverInstallPlan)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either FilePath SolverInstallPlan
 -> IO (Either FilePath SolverInstallPlan))
-> (FilePath -> Either FilePath SolverInstallPlan)
-> FilePath
-> IO (Either FilePath SolverInstallPlan)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> Either FilePath SolverInstallPlan
forall a b. a -> Either a b
Left) (Either FilePath SolverInstallPlan
-> IO (Either FilePath SolverInstallPlan)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either FilePath SolverInstallPlan
 -> IO (Either FilePath SolverInstallPlan))
-> (SolverInstallPlan -> Either FilePath SolverInstallPlan)
-> SolverInstallPlan
-> IO (Either FilePath SolverInstallPlan)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SolverInstallPlan -> Either FilePath SolverInstallPlan
forall a b. b -> Either a b
Right) (Progress FilePath FilePath SolverInstallPlan
 -> IO (Either FilePath SolverInstallPlan))
-> Progress FilePath FilePath SolverInstallPlan
-> IO (Either FilePath SolverInstallPlan)
forall a b. (a -> b) -> a -> b
$
              Verbosity
-> Compiler
-> Platform
-> Solver
-> SolverSettings
-> InstalledPackageIndex
-> SourcePackageDb
-> PkgConfigDb
-> [PackageSpecifier UnresolvedSourcePackage]
-> Map PackageName (Map OptionalStanza Bool)
-> Progress FilePath FilePath SolverInstallPlan
planPackages Verbosity
verbosity Compiler
compiler Platform
platform Solver
solver SolverSettings
solverSettings
                           InstalledPackageIndex
installedPkgIndex SourcePackageDb
sourcePkgDb PkgConfigDb
pkgConfigDB
                           [PackageSpecifier UnresolvedSourcePackage]
localPackages Map PackageName (Map OptionalStanza Bool)
localPackagesEnabledStanzas
            case Either FilePath SolverInstallPlan
planOrError of
              Left FilePath
msg -> do ProjectConfig
-> Compiler
-> Platform
-> [PackageSpecifier UnresolvedSourcePackage]
-> IO ()
reportPlanningFailure ProjectConfig
projectConfig Compiler
compiler Platform
platform [PackageSpecifier UnresolvedSourcePackage]
localPackages
                             Verbosity
-> FilePath
-> IO
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
forall a. Verbosity -> FilePath -> IO a
die' Verbosity
verbosity FilePath
msg
              Right SolverInstallPlan
plan -> (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
-> IO
     (SolverInstallPlan, PkgConfigDb, TotalIndexState, ActiveRepos)
forall (m :: * -> *) a. Monad m => a -> m a
return (SolverInstallPlan
plan, PkgConfigDb
pkgConfigDB, TotalIndexState
tis, ActiveRepos
ar)
      where
        corePackageDbs :: [PackageDB]
        corePackageDbs :: PackageDBStack
corePackageDbs = PackageDBStack -> [Maybe PackageDB] -> PackageDBStack
applyPackageDbFlags [PackageDB
GlobalPackageDB]
                                             (ProjectConfigShared -> [Maybe PackageDB]
projectConfigPackageDBs ProjectConfigShared
projectConfigShared)

        withRepoCtx :: (RepoContext -> IO a) -> IO a
withRepoCtx    = Verbosity
-> ProjectConfigShared
-> ProjectConfigBuildOnly
-> (RepoContext -> IO a)
-> IO a
forall a.
Verbosity
-> ProjectConfigShared
-> ProjectConfigBuildOnly
-> (RepoContext -> IO a)
-> IO a
projectConfigWithSolverRepoContext Verbosity
verbosity
                           ProjectConfigShared
projectConfigShared
                           ProjectConfigBuildOnly
projectConfigBuildOnly
        solverSettings :: SolverSettings
solverSettings = ProjectConfig -> SolverSettings
resolveSolverSettings ProjectConfig
projectConfig
        logMsg :: FilePath -> IO b -> IO b
logMsg FilePath
message IO b
rest = Verbosity -> FilePath -> IO ()
debugNoWrap Verbosity
verbosity FilePath
message IO () -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IO b
rest

        localPackagesEnabledStanzas :: Map PackageName (Map OptionalStanza Bool)
localPackagesEnabledStanzas =
          [(PackageName, Map OptionalStanza Bool)]
-> Map PackageName (Map OptionalStanza Bool)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
            [ (PackageName
pkgname, Map OptionalStanza Bool
stanzas)
            | PackageSpecifier UnresolvedSourcePackage
pkg <- [PackageSpecifier UnresolvedSourcePackage]
localPackages
              -- TODO: misnomer: we should separate
              -- builtin/global/inplace/local packages
              -- and packages explicitly mentioned in the project
              --
            , let pkgname :: PackageName
pkgname            = PackageSpecifier UnresolvedSourcePackage -> PackageName
forall pkg. Package pkg => PackageSpecifier pkg -> PackageName
pkgSpecifierTarget PackageSpecifier UnresolvedSourcePackage
pkg
                  testsEnabled :: Flag Bool
testsEnabled       = (PackageConfig -> Flag Bool)
-> ProjectConfig -> PackageName -> Flag Bool
forall a.
(Semigroup a, Monoid a) =>
(PackageConfig -> a) -> ProjectConfig -> PackageName -> a
lookupLocalPackageConfig
                                         PackageConfig -> Flag Bool
packageConfigTests
                                         ProjectConfig
projectConfig PackageName
pkgname
                  benchmarksEnabled :: Flag Bool
benchmarksEnabled  = (PackageConfig -> Flag Bool)
-> ProjectConfig -> PackageName -> Flag Bool
forall a.
(Semigroup a, Monoid a) =>
(PackageConfig -> a) -> ProjectConfig -> PackageName -> a
lookupLocalPackageConfig
                                         PackageConfig -> Flag Bool
packageConfigBenchmarks
                                         ProjectConfig
projectConfig PackageName
pkgname
                  isLocal :: Bool
isLocal = Maybe PackageId -> Bool
forall a. Maybe a -> Bool
isJust (PackageSpecifier UnresolvedSourcePackage -> Maybe PackageId
forall loc.
PackageSpecifier (SourcePackage (PackageLocation loc))
-> Maybe PackageId
shouldBeLocal PackageSpecifier UnresolvedSourcePackage
pkg)
                  stanzas :: Map OptionalStanza Bool
stanzas
                    | Bool
isLocal = [(OptionalStanza, Bool)] -> Map OptionalStanza Bool
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(OptionalStanza, Bool)] -> Map OptionalStanza Bool)
-> [(OptionalStanza, Bool)] -> Map OptionalStanza Bool
forall a b. (a -> b) -> a -> b
$
                      [ (OptionalStanza
TestStanzas, Bool
enabled)
                      | Bool
enabled <- Flag Bool -> [Bool]
forall a. Flag a -> [a]
flagToList Flag Bool
testsEnabled ] [(OptionalStanza, Bool)]
-> [(OptionalStanza, Bool)] -> [(OptionalStanza, Bool)]
forall a. [a] -> [a] -> [a]
++
                      [ (OptionalStanza
BenchStanzas , Bool
enabled)
                      | Bool
enabled <- Flag Bool -> [Bool]
forall a. Flag a -> [a]
flagToList Flag Bool
benchmarksEnabled ]
                    | Bool
otherwise = [(OptionalStanza, Bool)] -> Map OptionalStanza Bool
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(OptionalStanza
TestStanzas, Bool
False), (OptionalStanza
BenchStanzas, Bool
False) ]
            ]

    -- Elaborate the solver's install plan to get a fully detailed plan. This
    -- version of the plan has the final nix-style hashed ids.
    --
    phaseElaboratePlan :: ProjectConfig
                       -> (Compiler, Platform, ProgramDb)
                       -> PkgConfigDb
                       -> SolverInstallPlan
                       -> [PackageSpecifier (SourcePackage (PackageLocation loc))]
                       -> Rebuild ( ElaboratedInstallPlan
                                  , ElaboratedSharedConfig )
    phaseElaboratePlan :: ProjectConfig
-> (Compiler, Platform, ProgramDb)
-> PkgConfigDb
-> SolverInstallPlan
-> [PackageSpecifier (SourcePackage (PackageLocation loc))]
-> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig)
phaseElaboratePlan ProjectConfig {
                         ProjectConfigShared
projectConfigShared :: ProjectConfigShared
projectConfigShared :: ProjectConfig -> ProjectConfigShared
projectConfigShared,
                         PackageConfig
projectConfigAllPackages :: ProjectConfig -> PackageConfig
projectConfigAllPackages :: PackageConfig
projectConfigAllPackages,
                         PackageConfig
projectConfigLocalPackages :: PackageConfig
projectConfigLocalPackages :: ProjectConfig -> PackageConfig
projectConfigLocalPackages,
                         MapMappend PackageName PackageConfig
projectConfigSpecificPackage :: MapMappend PackageName PackageConfig
projectConfigSpecificPackage :: ProjectConfig -> MapMappend PackageName PackageConfig
projectConfigSpecificPackage,
                         ProjectConfigBuildOnly
projectConfigBuildOnly :: ProjectConfigBuildOnly
projectConfigBuildOnly :: ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly
                       }
                       (Compiler
compiler, Platform
platform, ProgramDb
progdb) PkgConfigDb
pkgConfigDB
                       SolverInstallPlan
solverPlan [PackageSpecifier (SourcePackage (PackageLocation loc))]
localPackages = do

        IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> FilePath -> IO ()
debug Verbosity
verbosity FilePath
"Elaborating the install plan..."

        Map PackageId PackageSourceHash
sourcePackageHashes <-
          Verbosity
-> FileMonitor
     [(PackageId, PackageLocation (Maybe FilePath))]
     (Map PackageId PackageSourceHash)
-> [(PackageId, PackageLocation (Maybe FilePath))]
-> Rebuild (Map PackageId PackageSourceHash)
-> Rebuild (Map PackageId PackageSourceHash)
forall a b.
(Binary a, Structured a, Binary b, Structured b) =>
Verbosity -> FileMonitor a b -> a -> Rebuild b -> Rebuild b
rerunIfChanged Verbosity
verbosity FileMonitor
  [(PackageId, PackageLocation (Maybe FilePath))]
  (Map PackageId PackageSourceHash)
forall b.
FileMonitor [(PackageId, PackageLocation (Maybe FilePath))] b
fileMonitorSourceHashes
                         (SolverInstallPlan
-> [(PackageId, PackageLocation (Maybe FilePath))]
packageLocationsSignature SolverInstallPlan
solverPlan) (Rebuild (Map PackageId PackageSourceHash)
 -> Rebuild (Map PackageId PackageSourceHash))
-> Rebuild (Map PackageId PackageSourceHash)
-> Rebuild (Map PackageId PackageSourceHash)
forall a b. (a -> b) -> a -> b
$
            Verbosity
-> (forall a. (RepoContext -> IO a) -> IO a)
-> SolverInstallPlan
-> Rebuild (Map PackageId PackageSourceHash)
getPackageSourceHashes Verbosity
verbosity forall a. (RepoContext -> IO a) -> IO a
withRepoCtx SolverInstallPlan
solverPlan

        InstallDirTemplates
defaultInstallDirs <- IO InstallDirTemplates -> Rebuild InstallDirTemplates
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InstallDirTemplates -> Rebuild InstallDirTemplates)
-> IO InstallDirTemplates -> Rebuild InstallDirTemplates
forall a b. (a -> b) -> a -> b
$ Compiler -> IO InstallDirTemplates
userInstallDirTemplates Compiler
compiler
        (ElaboratedInstallPlan
elaboratedPlan, ElaboratedSharedConfig
elaboratedShared)
          <- IO (ElaboratedInstallPlan, ElaboratedSharedConfig)
-> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (ElaboratedInstallPlan, ElaboratedSharedConfig)
 -> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig))
-> (LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
    -> IO (ElaboratedInstallPlan, ElaboratedSharedConfig))
-> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
-> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Verbosity
-> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
-> IO (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall a. Verbosity -> LogProgress a -> IO a
runLogProgress Verbosity
verbosity (LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
 -> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig))
-> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
-> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall a b. (a -> b) -> a -> b
$
              Verbosity
-> Platform
-> Compiler
-> ProgramDb
-> PkgConfigDb
-> DistDirLayout
-> StoreDirLayout
-> SolverInstallPlan
-> [PackageSpecifier (SourcePackage (PackageLocation loc))]
-> Map PackageId PackageSourceHash
-> InstallDirTemplates
-> ProjectConfigShared
-> PackageConfig
-> PackageConfig
-> Map PackageName PackageConfig
-> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall loc.
Verbosity
-> Platform
-> Compiler
-> ProgramDb
-> PkgConfigDb
-> DistDirLayout
-> StoreDirLayout
-> SolverInstallPlan
-> [PackageSpecifier (SourcePackage (PackageLocation loc))]
-> Map PackageId PackageSourceHash
-> InstallDirTemplates
-> ProjectConfigShared
-> PackageConfig
-> PackageConfig
-> Map PackageName PackageConfig
-> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
elaborateInstallPlan
                Verbosity
verbosity
                Platform
platform Compiler
compiler ProgramDb
progdb PkgConfigDb
pkgConfigDB
                DistDirLayout
distDirLayout
                StoreDirLayout
cabalStoreDirLayout
                SolverInstallPlan
solverPlan
                [PackageSpecifier (SourcePackage (PackageLocation loc))]
localPackages
                Map PackageId PackageSourceHash
sourcePackageHashes
                InstallDirTemplates
defaultInstallDirs
                ProjectConfigShared
projectConfigShared
                PackageConfig
projectConfigAllPackages
                PackageConfig
projectConfigLocalPackages
                (MapMappend PackageName PackageConfig
-> Map PackageName PackageConfig
forall k v. MapMappend k v -> Map k v
getMapMappend MapMappend PackageName PackageConfig
projectConfigSpecificPackage)
        let instantiatedPlan :: ElaboratedInstallPlan
instantiatedPlan
              = StoreDirLayout
-> InstallDirTemplates
-> ElaboratedSharedConfig
-> ElaboratedInstallPlan
-> ElaboratedInstallPlan
instantiateInstallPlan
                  StoreDirLayout
cabalStoreDirLayout
                  InstallDirTemplates
defaultInstallDirs
                  ElaboratedSharedConfig
elaboratedShared
                  ElaboratedInstallPlan
elaboratedPlan
        IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> FilePath -> IO ()
debugNoWrap Verbosity
verbosity (ElaboratedInstallPlan -> FilePath
forall ipkg srcpkg.
(Package ipkg, Package srcpkg, IsUnit ipkg, IsUnit srcpkg) =>
GenericInstallPlan ipkg srcpkg -> FilePath
InstallPlan.showInstallPlan ElaboratedInstallPlan
instantiatedPlan)
        (ElaboratedInstallPlan, ElaboratedSharedConfig)
-> Rebuild (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall (m :: * -> *) a. Monad m => a -> m a
return (ElaboratedInstallPlan
instantiatedPlan, ElaboratedSharedConfig
elaboratedShared)
      where
        withRepoCtx :: (RepoContext -> IO a) -> IO a
withRepoCtx = Verbosity
-> ProjectConfigShared
-> ProjectConfigBuildOnly
-> (RepoContext -> IO a)
-> IO a
forall a.
Verbosity
-> ProjectConfigShared
-> ProjectConfigBuildOnly
-> (RepoContext -> IO a)
-> IO a
projectConfigWithSolverRepoContext Verbosity
verbosity
                        ProjectConfigShared
projectConfigShared
                        ProjectConfigBuildOnly
projectConfigBuildOnly

    -- Update the files we maintain that reflect our current build environment.
    -- In particular we maintain a JSON representation of the elaborated
    -- install plan (but not the improved plan since that reflects the state
    -- of the build rather than just the input environment).
    --
    phaseMaintainPlanOutputs :: ElaboratedInstallPlan
                             -> ElaboratedSharedConfig
                             -> Rebuild ()
    phaseMaintainPlanOutputs :: ElaboratedInstallPlan -> ElaboratedSharedConfig -> Rebuild ()
phaseMaintainPlanOutputs ElaboratedInstallPlan
elaboratedPlan ElaboratedSharedConfig
elaboratedShared = IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ do
        Verbosity -> FilePath -> IO ()
debug Verbosity
verbosity FilePath
"Updating plan.json"
        DistDirLayout
-> ElaboratedInstallPlan -> ElaboratedSharedConfig -> IO ()
writePlanExternalRepresentation
          DistDirLayout
distDirLayout
          ElaboratedInstallPlan
elaboratedPlan
          ElaboratedSharedConfig
elaboratedShared


    -- Improve the elaborated install plan. The elaborated plan consists
    -- mostly of source packages (with full nix-style hashed ids). Where
    -- corresponding installed packages already exist in the store, replace
    -- them in the plan.
    --
    -- Note that we do monitor the store's package db here, so we will redo
    -- this improvement phase when the db changes -- including as a result of
    -- executing a plan and installing things.
    --
    phaseImprovePlan :: ElaboratedInstallPlan
                     -> ElaboratedSharedConfig
                     -> Rebuild ElaboratedInstallPlan
    phaseImprovePlan :: ElaboratedInstallPlan
-> ElaboratedSharedConfig -> Rebuild ElaboratedInstallPlan
phaseImprovePlan ElaboratedInstallPlan
elaboratedPlan ElaboratedSharedConfig
elaboratedShared = do

        IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> FilePath -> IO ()
debug Verbosity
verbosity FilePath
"Improving the install plan..."
        Set UnitId
storePkgIdSet <- StoreDirLayout -> CompilerId -> Rebuild (Set UnitId)
getStoreEntries StoreDirLayout
cabalStoreDirLayout CompilerId
compid
        let improvedPlan :: ElaboratedInstallPlan
improvedPlan = Set UnitId -> ElaboratedInstallPlan -> ElaboratedInstallPlan
improveInstallPlanWithInstalledPackages
                             Set UnitId
storePkgIdSet
                             ElaboratedInstallPlan
elaboratedPlan
        IO () -> Rebuild ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Rebuild ()) -> IO () -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> FilePath -> IO ()
debugNoWrap Verbosity
verbosity (ElaboratedInstallPlan -> FilePath
forall ipkg srcpkg.
(Package ipkg, Package srcpkg, IsUnit ipkg, IsUnit srcpkg) =>
GenericInstallPlan ipkg srcpkg -> FilePath
InstallPlan.showInstallPlan ElaboratedInstallPlan
improvedPlan)
        -- TODO: [nice to have] having checked which packages from the store
        -- we're using, it may be sensible to sanity check those packages
        -- by loading up the compiler package db and checking everything
        -- matches up as expected, e.g. no dangling deps, files deleted.
        ElaboratedInstallPlan -> Rebuild ElaboratedInstallPlan
forall (m :: * -> *) a. Monad m => a -> m a
return ElaboratedInstallPlan
improvedPlan
      where
        compid :: CompilerId
compid = Compiler -> CompilerId
compilerId (ElaboratedSharedConfig -> Compiler
pkgConfigCompiler ElaboratedSharedConfig
elaboratedShared)


-- | If a 'PackageSpecifier' refers to a single package, return Just that
-- package.


reportPlanningFailure :: ProjectConfig -> Compiler -> Platform -> [PackageSpecifier UnresolvedSourcePackage] -> IO ()
reportPlanningFailure :: ProjectConfig
-> Compiler
-> Platform
-> [PackageSpecifier UnresolvedSourcePackage]
-> IO ()
reportPlanningFailure ProjectConfig
projectConfig Compiler
comp Platform
platform [PackageSpecifier UnresolvedSourcePackage]
pkgSpecifiers = Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
reportFailure (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$

    CompilerInfo
-> [PathTemplate]
-> [(BuildReport, Maybe Repo)]
-> Platform
-> IO ()
BuildReports.storeLocal (Compiler -> CompilerInfo
compilerInfo Compiler
comp)
                            (NubList PathTemplate -> [PathTemplate]
forall a. NubList a -> [a]
fromNubList (NubList PathTemplate -> [PathTemplate])
-> NubList PathTemplate -> [PathTemplate]
forall a b. (a -> b) -> a -> b
$ ProjectConfigBuildOnly -> NubList PathTemplate
projectConfigSummaryFile (ProjectConfigBuildOnly -> NubList PathTemplate)
-> (ProjectConfig -> ProjectConfigBuildOnly)
-> ProjectConfig
-> NubList PathTemplate
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly (ProjectConfig -> NubList PathTemplate)
-> ProjectConfig -> NubList PathTemplate
forall a b. (a -> b) -> a -> b
$ ProjectConfig
projectConfig)
                            [(BuildReport, Maybe Repo)]
buildReports Platform
platform

    -- TODO may want to handle the projectConfigLogFile paramenter here, or just remove it entirely?
  where
    reportFailure :: Bool
reportFailure = Flag Bool -> Bool
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag Bool -> Bool)
-> (ProjectConfig -> Flag Bool) -> ProjectConfig -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProjectConfigBuildOnly -> Flag Bool
projectConfigReportPlanningFailure (ProjectConfigBuildOnly -> Flag Bool)
-> (ProjectConfig -> ProjectConfigBuildOnly)
-> ProjectConfig
-> Flag Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly (ProjectConfig -> Bool) -> ProjectConfig -> Bool
forall a b. (a -> b) -> a -> b
$ ProjectConfig
projectConfig
    pkgids :: [PackageId]
pkgids = (PackageSpecifier UnresolvedSourcePackage -> Maybe PackageId)
-> [PackageSpecifier UnresolvedSourcePackage] -> [PackageId]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe PackageSpecifier UnresolvedSourcePackage -> Maybe PackageId
forall pkg. Package pkg => PackageSpecifier pkg -> Maybe PackageId
theSpecifiedPackage [PackageSpecifier UnresolvedSourcePackage]
pkgSpecifiers
    buildReports :: [(BuildReport, Maybe Repo)]
buildReports = Platform
-> CompilerId
-> [PackageId]
-> FlagAssignment
-> [(BuildReport, Maybe Repo)]
BuildReports.fromPlanningFailure Platform
platform
                       (Compiler -> CompilerId
compilerId Compiler
comp) [PackageId]
pkgids
                       -- TODO we may want to get more flag assignments and merge them here?
                       (PackageConfig -> FlagAssignment
packageConfigFlagAssignment (PackageConfig -> FlagAssignment)
-> (ProjectConfig -> PackageConfig)
-> ProjectConfig
-> FlagAssignment
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProjectConfig -> PackageConfig
projectConfigAllPackages (ProjectConfig -> FlagAssignment)
-> ProjectConfig -> FlagAssignment
forall a b. (a -> b) -> a -> b
$ ProjectConfig
projectConfig)

    theSpecifiedPackage :: Package pkg => PackageSpecifier pkg -> Maybe PackageId
    theSpecifiedPackage :: PackageSpecifier pkg -> Maybe PackageId
theSpecifiedPackage PackageSpecifier pkg
pkgSpec =
       case PackageSpecifier pkg
pkgSpec of
          NamedPackage PackageName
name [PackagePropertyVersion VersionRange
version]
            -> PackageName -> Version -> PackageId
PackageIdentifier PackageName
name (Version -> PackageId) -> Maybe Version -> Maybe PackageId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VersionRange -> Maybe Version
trivialRange VersionRange
version
          NamedPackage PackageName
_ [PackageProperty]
_ -> Maybe PackageId
forall a. Maybe a
Nothing
          SpecificSourcePackage pkg
pkg -> PackageId -> Maybe PackageId
forall a. a -> Maybe a
Just (PackageId -> Maybe PackageId) -> PackageId -> Maybe PackageId
forall a b. (a -> b) -> a -> b
$ pkg -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId pkg
pkg
    -- | If a range includes only a single version, return Just that version.
    trivialRange :: VersionRange -> Maybe Version
    trivialRange :: VersionRange -> Maybe Version
trivialRange = Maybe Version
-> (Version -> Maybe Version)
-> (Version -> Maybe Version)
-> (Version -> Maybe Version)
-> (Maybe Version -> Maybe Version -> Maybe Version)
-> (Maybe Version -> Maybe Version -> Maybe Version)
-> VersionRange
-> Maybe Version
forall a.
a
-> (Version -> a)
-> (Version -> a)
-> (Version -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> VersionRange
-> a
foldVersionRange
        Maybe Version
forall a. Maybe a
Nothing
        Version -> Maybe Version
forall a. a -> Maybe a
Just     -- "== v"
        (\Version
_ -> Maybe Version
forall a. Maybe a
Nothing)
        (\Version
_ -> Maybe Version
forall a. Maybe a
Nothing)
        (\Maybe Version
_ Maybe Version
_ -> Maybe Version
forall a. Maybe a
Nothing)
        (\Maybe Version
_ Maybe Version
_ -> Maybe Version
forall a. Maybe a
Nothing)


programsMonitorFiles :: ProgramDb -> [MonitorFilePath]
programsMonitorFiles :: ProgramDb -> [MonitorFilePath]
programsMonitorFiles ProgramDb
progdb =
    [ MonitorFilePath
monitor
    | ConfiguredProgram
prog    <- ProgramDb -> [ConfiguredProgram]
configuredPrograms ProgramDb
progdb
    , MonitorFilePath
monitor <- [FilePath] -> FilePath -> [MonitorFilePath]
monitorFileSearchPath (ConfiguredProgram -> [FilePath]
programMonitorFiles ConfiguredProgram
prog)
                                       (ConfiguredProgram -> FilePath
programPath ConfiguredProgram
prog)
    ]

-- | Select the bits of a 'ProgramDb' to monitor for value changes.
-- Use 'programsMonitorFiles' for the files to monitor.
--
programDbSignature :: ProgramDb -> [ConfiguredProgram]
programDbSignature :: ProgramDb -> [ConfiguredProgram]
programDbSignature ProgramDb
progdb =
    [ ConfiguredProgram
prog { programMonitorFiles :: [FilePath]
programMonitorFiles = []
           , programOverrideEnv :: [(FilePath, Maybe FilePath)]
programOverrideEnv  = ((FilePath, Maybe FilePath) -> Bool)
-> [(FilePath, Maybe FilePath)] -> [(FilePath, Maybe FilePath)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((FilePath -> FilePath -> Bool
forall a. Eq a => a -> a -> Bool
/=FilePath
"PATH") (FilePath -> Bool)
-> ((FilePath, Maybe FilePath) -> FilePath)
-> (FilePath, Maybe FilePath)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FilePath, Maybe FilePath) -> FilePath
forall a b. (a, b) -> a
fst)
                                          (ConfiguredProgram -> [(FilePath, Maybe FilePath)]
programOverrideEnv ConfiguredProgram
prog) }
    | ConfiguredProgram
prog <- ProgramDb -> [ConfiguredProgram]
configuredPrograms ProgramDb
progdb ]

getInstalledPackages :: Verbosity
                     -> Compiler -> ProgramDb -> Platform
                     -> PackageDBStack
                     -> Rebuild InstalledPackageIndex
getInstalledPackages :: Verbosity
-> Compiler
-> ProgramDb
-> Platform
-> PackageDBStack
-> Rebuild InstalledPackageIndex
getInstalledPackages Verbosity
verbosity Compiler
compiler ProgramDb
progdb Platform
platform PackageDBStack
packagedbs = do
    [MonitorFilePath] -> Rebuild ()
monitorFiles ([MonitorFilePath] -> Rebuild ())
-> ([FilePath] -> [MonitorFilePath]) -> [FilePath] -> Rebuild ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FilePath -> MonitorFilePath) -> [FilePath] -> [MonitorFilePath]
forall a b. (a -> b) -> [a] -> [b]
map FilePath -> MonitorFilePath
monitorFileOrDirectory
      ([FilePath] -> Rebuild ()) -> Rebuild [FilePath] -> Rebuild ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO [FilePath] -> Rebuild [FilePath]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Verbosity
-> Compiler
-> PackageDBStack
-> ProgramDb
-> Platform
-> IO [FilePath]
IndexUtils.getInstalledPackagesMonitorFiles
                    Verbosity
verbosity Compiler
compiler
                    PackageDBStack
packagedbs ProgramDb
progdb Platform
platform)
    IO InstalledPackageIndex -> Rebuild InstalledPackageIndex
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InstalledPackageIndex -> Rebuild InstalledPackageIndex)
-> IO InstalledPackageIndex -> Rebuild InstalledPackageIndex
forall a b. (a -> b) -> a -> b
$ Verbosity
-> Compiler
-> PackageDBStack
-> ProgramDb
-> IO InstalledPackageIndex
IndexUtils.getInstalledPackages
               Verbosity
verbosity Compiler
compiler
               PackageDBStack
packagedbs ProgramDb
progdb

{-
--TODO: [nice to have] use this but for sanity / consistency checking
getPackageDBContents :: Verbosity
                     -> Compiler -> ProgramDb -> Platform
                     -> PackageDB
                     -> Rebuild InstalledPackageIndex
getPackageDBContents verbosity compiler progdb platform packagedb = do
    monitorFiles . map monitorFileOrDirectory
      =<< liftIO (IndexUtils.getInstalledPackagesMonitorFiles
                    verbosity compiler
                    [packagedb] progdb platform)
    liftIO $ do
      createPackageDBIfMissing verbosity compiler progdb packagedb
      Cabal.getPackageDBContents verbosity compiler
                                 packagedb progdb
-}

getSourcePackages
    :: Verbosity
    -> (forall a. (RepoContext -> IO a) -> IO a)
    -> Maybe IndexUtils.TotalIndexState
    -> Maybe IndexUtils.ActiveRepos
    -> Rebuild (SourcePackageDb, IndexUtils.TotalIndexState, IndexUtils.ActiveRepos)
getSourcePackages :: Verbosity
-> (forall a. (RepoContext -> IO a) -> IO a)
-> Maybe TotalIndexState
-> Maybe ActiveRepos
-> Rebuild (SourcePackageDb, TotalIndexState, ActiveRepos)
getSourcePackages Verbosity
verbosity forall a. (RepoContext -> IO a) -> IO a
withRepoCtx Maybe TotalIndexState
idxState Maybe ActiveRepos
activeRepos = do
    ((SourcePackageDb, TotalIndexState, ActiveRepos)
sourcePkgDbWithTIS, [Repo]
repos) <-
      IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
-> Rebuild
     ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
 -> Rebuild
      ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo]))
-> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
-> Rebuild
     ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
forall a b. (a -> b) -> a -> b
$
        (RepoContext
 -> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo]))
-> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
forall a. (RepoContext -> IO a) -> IO a
withRepoCtx ((RepoContext
  -> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo]))
 -> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo]))
-> (RepoContext
    -> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo]))
-> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
forall a b. (a -> b) -> a -> b
$ \RepoContext
repoctx -> do
          (SourcePackageDb, TotalIndexState, ActiveRepos)
sourcePkgDbWithTIS <- Verbosity
-> RepoContext
-> Maybe TotalIndexState
-> Maybe ActiveRepos
-> IO (SourcePackageDb, TotalIndexState, ActiveRepos)
IndexUtils.getSourcePackagesAtIndexState Verbosity
verbosity RepoContext
repoctx Maybe TotalIndexState
idxState Maybe ActiveRepos
activeRepos
          ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
-> IO ((SourcePackageDb, TotalIndexState, ActiveRepos), [Repo])
forall (m :: * -> *) a. Monad m => a -> m a
return ((SourcePackageDb, TotalIndexState, ActiveRepos)
sourcePkgDbWithTIS, RepoContext -> [Repo]
repoContextRepos RepoContext
repoctx)

    (FilePath -> Rebuild ()) -> [FilePath] -> Rebuild ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ FilePath -> Rebuild ()
needIfExists
        ([FilePath] -> Rebuild ())
-> ([Repo] -> [FilePath]) -> [Repo] -> Rebuild ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Repo] -> [FilePath]
IndexUtils.getSourcePackagesMonitorFiles
        ([Repo] -> Rebuild ()) -> [Repo] -> Rebuild ()
forall a b. (a -> b) -> a -> b
$ [Repo]
repos
    (SourcePackageDb, TotalIndexState, ActiveRepos)
-> Rebuild (SourcePackageDb, TotalIndexState, ActiveRepos)
forall (m :: * -> *) a. Monad m => a -> m a
return (SourcePackageDb, TotalIndexState, ActiveRepos)
sourcePkgDbWithTIS


getPkgConfigDb :: Verbosity -> ProgramDb -> Rebuild PkgConfigDb
getPkgConfigDb :: Verbosity -> ProgramDb -> Rebuild PkgConfigDb
getPkgConfigDb Verbosity
verbosity ProgramDb
progdb = do
    [FilePath]
dirs <- IO [FilePath] -> Rebuild [FilePath]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [FilePath] -> Rebuild [FilePath])
-> IO [FilePath] -> Rebuild [FilePath]
forall a b. (a -> b) -> a -> b
$ Verbosity -> ProgramDb -> IO [FilePath]
getPkgConfigDbDirs Verbosity
verbosity ProgramDb
progdb
    -- Just monitor the dirs so we'll notice new .pc files.
    -- Alternatively we could monitor all the .pc files too.
    (FilePath -> Rebuild Bool) -> [FilePath] -> Rebuild ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ FilePath -> Rebuild Bool
monitorDirectoryStatus [FilePath]
dirs
    IO PkgConfigDb -> Rebuild PkgConfigDb
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PkgConfigDb -> Rebuild PkgConfigDb)
-> IO PkgConfigDb -> Rebuild PkgConfigDb
forall a b. (a -> b) -> a -> b
$ Verbosity -> ProgramDb -> IO PkgConfigDb
readPkgConfigDb Verbosity
verbosity ProgramDb
progdb


-- | Select the config values to monitor for changes package source hashes.
packageLocationsSignature :: SolverInstallPlan
                          -> [(PackageId, PackageLocation (Maybe FilePath))]
packageLocationsSignature :: SolverInstallPlan
-> [(PackageId, PackageLocation (Maybe FilePath))]
packageLocationsSignature SolverInstallPlan
solverPlan =
    [ (UnresolvedSourcePackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId UnresolvedSourcePackage
pkg, UnresolvedSourcePackage -> PackageLocation (Maybe FilePath)
forall loc. SourcePackage loc -> loc
srcpkgSource UnresolvedSourcePackage
pkg)
    | SolverInstallPlan.Configured (SolverPackage { solverPkgSource :: forall loc. SolverPackage loc -> SourcePackage loc
solverPkgSource = UnresolvedSourcePackage
pkg})
        <- SolverInstallPlan
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
SolverInstallPlan.toList SolverInstallPlan
solverPlan
    ]


-- | Get the 'HashValue' for all the source packages where we use hashes,
-- and download any packages required to do so.
--
-- Note that we don't get hashes for local unpacked packages.
--
getPackageSourceHashes :: Verbosity
                       -> (forall a. (RepoContext -> IO a) -> IO a)
                       -> SolverInstallPlan
                       -> Rebuild (Map PackageId PackageSourceHash)
getPackageSourceHashes :: Verbosity
-> (forall a. (RepoContext -> IO a) -> IO a)
-> SolverInstallPlan
-> Rebuild (Map PackageId PackageSourceHash)
getPackageSourceHashes Verbosity
verbosity forall a. (RepoContext -> IO a) -> IO a
withRepoCtx SolverInstallPlan
solverPlan = do

    -- Determine if and where to get the package's source hash from.
    --
    let allPkgLocations :: [(PackageId, PackageLocation (Maybe FilePath))]
        allPkgLocations :: [(PackageId, PackageLocation (Maybe FilePath))]
allPkgLocations =
          [ (UnresolvedSourcePackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId UnresolvedSourcePackage
pkg, UnresolvedSourcePackage -> PackageLocation (Maybe FilePath)
forall loc. SourcePackage loc -> loc
srcpkgSource UnresolvedSourcePackage
pkg)
          | SolverInstallPlan.Configured (SolverPackage { solverPkgSource :: forall loc. SolverPackage loc -> SourcePackage loc
solverPkgSource = UnresolvedSourcePackage
pkg})
              <- SolverInstallPlan
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
SolverInstallPlan.toList SolverInstallPlan
solverPlan ]

        -- Tarballs that were local in the first place.
        -- We'll hash these tarball files directly.
        localTarballPkgs :: [(PackageId, FilePath)]
        localTarballPkgs :: [(PackageId, FilePath)]
localTarballPkgs =
          [ (PackageId
pkgid, FilePath
tarball)
          | (PackageId
pkgid, LocalTarballPackage FilePath
tarball) <- [(PackageId, PackageLocation (Maybe FilePath))]
allPkgLocations ]

        -- Tarballs from remote URLs. We must have downloaded these already
        -- (since we extracted the .cabal file earlier)
        remoteTarballPkgs :: [(PackageId, FilePath)]
remoteTarballPkgs =
          [ (PackageId
pkgid, FilePath
tarball)
          | (PackageId
pkgid, RemoteTarballPackage URI
_ (Just FilePath
tarball)) <- [(PackageId, PackageLocation (Maybe FilePath))]
allPkgLocations ]

        -- tarballs from source-repository-package stanzas
        sourceRepoTarballPkgs :: [(PackageId, FilePath)]
sourceRepoTarballPkgs =
          [ (PackageId
pkgid, FilePath
tarball)
          | (PackageId
pkgid, RemoteSourceRepoPackage SourceRepoMaybe
_ (Just FilePath
tarball)) <- [(PackageId, PackageLocation (Maybe FilePath))]
allPkgLocations ]

        -- Tarballs from repositories, either where the repository provides
        -- hashes as part of the repo metadata, or where we will have to
        -- download and hash the tarball.
        repoTarballPkgsWithMetadata    :: [(PackageId, Repo)]
        repoTarballPkgsWithoutMetadata :: [(PackageId, Repo)]
        ([(PackageId, Repo)]
repoTarballPkgsWithMetadata,
         [(PackageId, Repo)]
repoTarballPkgsWithoutMetadata) =
          [Either (PackageId, Repo) (PackageId, Repo)]
-> ([(PackageId, Repo)], [(PackageId, Repo)])
forall a b. [Either a b] -> ([a], [b])
partitionEithers
          [ case Repo
repo of
              RepoSecure{} -> (PackageId, Repo) -> Either (PackageId, Repo) (PackageId, Repo)
forall a b. a -> Either a b
Left  (PackageId
pkgid, Repo
repo)
              Repo
_            -> (PackageId, Repo) -> Either (PackageId, Repo) (PackageId, Repo)
forall a b. b -> Either a b
Right (PackageId
pkgid, Repo
repo)
          | (PackageId
pkgid, RepoTarballPackage Repo
repo PackageId
_ Maybe FilePath
_) <- [(PackageId, PackageLocation (Maybe FilePath))]
allPkgLocations ]

    -- For tarballs from repos that do not have hashes available we now have
    -- to check if the packages were downloaded already.
    --
    ([(PackageId, Repo)]
repoTarballPkgsToDownload,
     [(PackageId, FilePath)]
repoTarballPkgsDownloaded)
      <- ([Either (PackageId, Repo) (PackageId, FilePath)]
 -> ([(PackageId, Repo)], [(PackageId, FilePath)]))
-> Rebuild [Either (PackageId, Repo) (PackageId, FilePath)]
-> Rebuild ([(PackageId, Repo)], [(PackageId, FilePath)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Either (PackageId, Repo) (PackageId, FilePath)]
-> ([(PackageId, Repo)], [(PackageId, FilePath)])
forall a b. [Either a b] -> ([a], [b])
partitionEithers (Rebuild [Either (PackageId, Repo) (PackageId, FilePath)]
 -> Rebuild ([(PackageId, Repo)], [(PackageId, FilePath)]))
-> Rebuild [Either (PackageId, Repo) (PackageId, FilePath)]
-> Rebuild ([(PackageId, Repo)], [(PackageId, FilePath)])
forall a b. (a -> b) -> a -> b
$
         IO [Either (PackageId, Repo) (PackageId, FilePath)]
-> Rebuild [Either (PackageId, Repo) (PackageId, FilePath)]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Either (PackageId, Repo) (PackageId, FilePath)]
 -> Rebuild [Either (PackageId, Repo) (PackageId, FilePath)])
-> IO [Either (PackageId, Repo) (PackageId, FilePath)]
-> Rebuild [Either (PackageId, Repo) (PackageId, FilePath)]
forall a b. (a -> b) -> a -> b
$ [IO (Either (PackageId, Repo) (PackageId, FilePath))]
-> IO [Either (PackageId, Repo) (PackageId, FilePath)]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence
           [ do Maybe FilePath
mtarball <- Repo -> PackageId -> IO (Maybe FilePath)
checkRepoTarballFetched Repo
repo PackageId
pkgid
                case Maybe FilePath
mtarball of
                  Maybe FilePath
Nothing      -> Either (PackageId, Repo) (PackageId, FilePath)
-> IO (Either (PackageId, Repo) (PackageId, FilePath))
forall (m :: * -> *) a. Monad m => a -> m a
return ((PackageId, Repo) -> Either (PackageId, Repo) (PackageId, FilePath)
forall a b. a -> Either a b
Left  (PackageId
pkgid, Repo
repo))
                  Just FilePath
tarball -> Either (PackageId, Repo) (PackageId, FilePath)
-> IO (Either (PackageId, Repo) (PackageId, FilePath))
forall (m :: * -> *) a. Monad m => a -> m a
return ((PackageId, FilePath)
-> Either (PackageId, Repo) (PackageId, FilePath)
forall a b. b -> Either a b
Right (PackageId
pkgid, FilePath
tarball))
           | (PackageId
pkgid, Repo
repo) <- [(PackageId, Repo)]
repoTarballPkgsWithoutMetadata ]

    (Map PackageId PackageSourceHash
hashesFromRepoMetadata,
     [(PackageId, FilePath)]
repoTarballPkgsNewlyDownloaded) <-
      -- Avoid having to initialise the repository (ie 'withRepoCtx') if we
      -- don't have to. (The main cost is configuring the http client.)
      if [(PackageId, Repo)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(PackageId, Repo)]
repoTarballPkgsToDownload Bool -> Bool -> Bool
&& [(PackageId, Repo)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(PackageId, Repo)]
repoTarballPkgsWithMetadata
      then (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
-> Rebuild
     (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
forall (m :: * -> *) a. Monad m => a -> m a
return (Map PackageId PackageSourceHash
forall k a. Map k a
Map.empty, [])
      else IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
-> Rebuild
     (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
 -> Rebuild
      (Map PackageId PackageSourceHash, [(PackageId, FilePath)]))
-> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
-> Rebuild
     (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
forall a b. (a -> b) -> a -> b
$ (RepoContext
 -> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)]))
-> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
forall a. (RepoContext -> IO a) -> IO a
withRepoCtx ((RepoContext
  -> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)]))
 -> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)]))
-> (RepoContext
    -> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)]))
-> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
forall a b. (a -> b) -> a -> b
$ \RepoContext
repoctx -> do

      -- For tarballs from repos that do have hashes available as part of the
      -- repo metadata we now load up the index for each repo and retrieve
      -- the hashes for the packages
      --
      Map PackageId PackageSourceHash
hashesFromRepoMetadata <-
        ((Throws VerificationError, Throws SomeRemoteError,
  Throws InvalidPackageException) =>
 IO (Map PackageId PackageSourceHash))
-> IO (Map PackageId PackageSourceHash)
forall a.
((Throws VerificationError, Throws SomeRemoteError,
  Throws InvalidPackageException) =>
 IO a)
-> IO a
Sec.uncheckClientErrors (((Throws VerificationError, Throws SomeRemoteError,
   Throws InvalidPackageException) =>
  IO (Map PackageId PackageSourceHash))
 -> IO (Map PackageId PackageSourceHash))
-> ((Throws VerificationError, Throws SomeRemoteError,
     Throws InvalidPackageException) =>
    IO (Map PackageId PackageSourceHash))
-> IO (Map PackageId PackageSourceHash)
forall a b. (a -> b) -> a -> b
$ --TODO: [code cleanup] wrap in our own exceptions
        ([[(PackageId, PackageSourceHash)]]
 -> Map PackageId PackageSourceHash)
-> IO [[(PackageId, PackageSourceHash)]]
-> IO (Map PackageId PackageSourceHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([(PackageId, PackageSourceHash)] -> Map PackageId PackageSourceHash
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(PackageId, PackageSourceHash)]
 -> Map PackageId PackageSourceHash)
-> ([[(PackageId, PackageSourceHash)]]
    -> [(PackageId, PackageSourceHash)])
-> [[(PackageId, PackageSourceHash)]]
-> Map PackageId PackageSourceHash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[(PackageId, PackageSourceHash)]]
-> [(PackageId, PackageSourceHash)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat) (IO [[(PackageId, PackageSourceHash)]]
 -> IO (Map PackageId PackageSourceHash))
-> IO [[(PackageId, PackageSourceHash)]]
-> IO (Map PackageId PackageSourceHash)
forall a b. (a -> b) -> a -> b
$
        [IO [(PackageId, PackageSourceHash)]]
-> IO [[(PackageId, PackageSourceHash)]]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence
          -- Reading the repo index is expensive so we group the packages by repo
          [ RepoContext
-> Repo
-> (forall (down :: * -> *).
    Repository down -> IO [(PackageId, PackageSourceHash)])
-> IO [(PackageId, PackageSourceHash)]
RepoContext
-> forall a.
   Repo -> (forall (down :: * -> *). Repository down -> IO a) -> IO a
repoContextWithSecureRepo RepoContext
repoctx Repo
repo ((forall (down :: * -> *).
  Repository down -> IO [(PackageId, PackageSourceHash)])
 -> IO [(PackageId, PackageSourceHash)])
-> (forall (down :: * -> *).
    Repository down -> IO [(PackageId, PackageSourceHash)])
-> IO [(PackageId, PackageSourceHash)]
forall a b. (a -> b) -> a -> b
$ \Repository down
secureRepo ->
              Repository down
-> (IndexCallbacks -> IO [(PackageId, PackageSourceHash)])
-> IO [(PackageId, PackageSourceHash)]
forall (down :: * -> *) a.
Repository down -> (IndexCallbacks -> IO a) -> IO a
Sec.withIndex Repository down
secureRepo ((IndexCallbacks -> IO [(PackageId, PackageSourceHash)])
 -> IO [(PackageId, PackageSourceHash)])
-> (IndexCallbacks -> IO [(PackageId, PackageSourceHash)])
-> IO [(PackageId, PackageSourceHash)]
forall a b. (a -> b) -> a -> b
$ \IndexCallbacks
repoIndex ->
                [IO (PackageId, PackageSourceHash)]
-> IO [(PackageId, PackageSourceHash)]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence
                  [ do Hash
hash <- Trusted Hash -> Hash
forall a. Trusted a -> a
Sec.trusted (Trusted Hash -> Hash) -> IO (Trusted Hash) -> IO Hash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> -- strip off Trusted tag
                               IndexCallbacks -> PackageId -> IO (Trusted Hash)
IndexCallbacks
-> (Throws InvalidPackageException, Throws VerificationError) =>
   PackageId -> IO (Trusted Hash)
Sec.indexLookupHash IndexCallbacks
repoIndex PackageId
pkgid
                       -- Note that hackage-security currently uses SHA256
                       -- but this API could in principle give us some other
                       -- choice in future.
                       (PackageId, PackageSourceHash) -> IO (PackageId, PackageSourceHash)
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageId
pkgid, Hash -> PackageSourceHash
hashFromTUF Hash
hash)
                  | PackageId
pkgid <- [PackageId]
pkgids ]
          | (Repo
repo, [PackageId]
pkgids) <-
                (NonEmpty (PackageId, Repo) -> (Repo, [PackageId]))
-> [NonEmpty (PackageId, Repo)] -> [(Repo, [PackageId])]
forall a b. (a -> b) -> [a] -> [b]
map (\grp :: NonEmpty (PackageId, Repo)
grp@((PackageId
_,Repo
repo):|[(PackageId, Repo)]
_) -> (Repo
repo, ((PackageId, Repo) -> PackageId)
-> [(PackageId, Repo)] -> [PackageId]
forall a b. (a -> b) -> [a] -> [b]
map (PackageId, Repo) -> PackageId
forall a b. (a, b) -> a
fst (NonEmpty (PackageId, Repo) -> [(PackageId, Repo)]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (PackageId, Repo)
grp)))
              ([NonEmpty (PackageId, Repo)] -> [(Repo, [PackageId])])
-> ([(PackageId, Repo)] -> [NonEmpty (PackageId, Repo)])
-> [(PackageId, Repo)]
-> [(Repo, [PackageId])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((PackageId, Repo) -> (PackageId, Repo) -> Bool)
-> [(PackageId, Repo)] -> [NonEmpty (PackageId, Repo)]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> Bool) -> f a -> [NonEmpty a]
NE.groupBy (RepoName -> RepoName -> Bool
forall a. Eq a => a -> a -> Bool
(==)    (RepoName -> RepoName -> Bool)
-> ((PackageId, Repo) -> RepoName)
-> (PackageId, Repo)
-> (PackageId, Repo)
-> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (RemoteRepo -> RepoName
remoteRepoName (RemoteRepo -> RepoName)
-> ((PackageId, Repo) -> RemoteRepo)
-> (PackageId, Repo)
-> RepoName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Repo -> RemoteRepo
repoRemote (Repo -> RemoteRepo)
-> ((PackageId, Repo) -> Repo) -> (PackageId, Repo) -> RemoteRepo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageId, Repo) -> Repo
forall a b. (a, b) -> b
snd))
              ([(PackageId, Repo)] -> [NonEmpty (PackageId, Repo)])
-> ([(PackageId, Repo)] -> [(PackageId, Repo)])
-> [(PackageId, Repo)]
-> [NonEmpty (PackageId, Repo)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((PackageId, Repo) -> (PackageId, Repo) -> Ordering)
-> [(PackageId, Repo)] -> [(PackageId, Repo)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy  (RepoName -> RepoName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (RepoName -> RepoName -> Ordering)
-> ((PackageId, Repo) -> RepoName)
-> (PackageId, Repo)
-> (PackageId, Repo)
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (RemoteRepo -> RepoName
remoteRepoName (RemoteRepo -> RepoName)
-> ((PackageId, Repo) -> RemoteRepo)
-> (PackageId, Repo)
-> RepoName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Repo -> RemoteRepo
repoRemote (Repo -> RemoteRepo)
-> ((PackageId, Repo) -> Repo) -> (PackageId, Repo) -> RemoteRepo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageId, Repo) -> Repo
forall a b. (a, b) -> b
snd))
              ([(PackageId, Repo)] -> [(Repo, [PackageId])])
-> [(PackageId, Repo)] -> [(Repo, [PackageId])]
forall a b. (a -> b) -> a -> b
$ [(PackageId, Repo)]
repoTarballPkgsWithMetadata
          ]

      -- For tarballs from repos that do not have hashes available, download
      -- the ones we previously determined we need.
      --
      [(PackageId, FilePath)]
repoTarballPkgsNewlyDownloaded <-
        [IO (PackageId, FilePath)] -> IO [(PackageId, FilePath)]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence
          [ do FilePath
tarball <- Verbosity -> RepoContext -> Repo -> PackageId -> IO FilePath
fetchRepoTarball Verbosity
verbosity RepoContext
repoctx Repo
repo PackageId
pkgid
               (PackageId, FilePath) -> IO (PackageId, FilePath)
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageId
pkgid, FilePath
tarball)
          | (PackageId
pkgid, Repo
repo) <- [(PackageId, Repo)]
repoTarballPkgsToDownload ]

      (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
-> IO (Map PackageId PackageSourceHash, [(PackageId, FilePath)])
forall (m :: * -> *) a. Monad m => a -> m a
return (Map PackageId PackageSourceHash
hashesFromRepoMetadata,
              [(PackageId, FilePath)]
repoTarballPkgsNewlyDownloaded)

    -- Hash tarball files for packages where we have to do that. This includes
    -- tarballs that were local in the first place, plus tarballs from repos,
    -- either previously cached or freshly downloaded.
    --
    let allTarballFilePkgs :: [(PackageId, FilePath)]
        allTarballFilePkgs :: [(PackageId, FilePath)]
allTarballFilePkgs = [(PackageId, FilePath)]
localTarballPkgs
                          [(PackageId, FilePath)]
-> [(PackageId, FilePath)] -> [(PackageId, FilePath)]
forall a. [a] -> [a] -> [a]
++ [(PackageId, FilePath)]
remoteTarballPkgs
                          [(PackageId, FilePath)]
-> [(PackageId, FilePath)] -> [(PackageId, FilePath)]
forall a. [a] -> [a] -> [a]
++ [(PackageId, FilePath)]
sourceRepoTarballPkgs
                          [(PackageId, FilePath)]
-> [(PackageId, FilePath)] -> [(PackageId, FilePath)]
forall a. [a] -> [a] -> [a]
++ [(PackageId, FilePath)]
repoTarballPkgsDownloaded
                          [(PackageId, FilePath)]
-> [(PackageId, FilePath)] -> [(PackageId, FilePath)]
forall a. [a] -> [a] -> [a]
++ [(PackageId, FilePath)]
repoTarballPkgsNewlyDownloaded
    Map PackageId PackageSourceHash
hashesFromTarballFiles <- IO (Map PackageId PackageSourceHash)
-> Rebuild (Map PackageId PackageSourceHash)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Map PackageId PackageSourceHash)
 -> Rebuild (Map PackageId PackageSourceHash))
-> IO (Map PackageId PackageSourceHash)
-> Rebuild (Map PackageId PackageSourceHash)
forall a b. (a -> b) -> a -> b
$
      ([(PackageId, PackageSourceHash)]
 -> Map PackageId PackageSourceHash)
-> IO [(PackageId, PackageSourceHash)]
-> IO (Map PackageId PackageSourceHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(PackageId, PackageSourceHash)] -> Map PackageId PackageSourceHash
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (IO [(PackageId, PackageSourceHash)]
 -> IO (Map PackageId PackageSourceHash))
-> IO [(PackageId, PackageSourceHash)]
-> IO (Map PackageId PackageSourceHash)
forall a b. (a -> b) -> a -> b
$
      [IO (PackageId, PackageSourceHash)]
-> IO [(PackageId, PackageSourceHash)]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence
        [ do PackageSourceHash
srchash <- FilePath -> IO PackageSourceHash
readFileHashValue FilePath
tarball
             (PackageId, PackageSourceHash) -> IO (PackageId, PackageSourceHash)
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageId
pkgid, PackageSourceHash
srchash)
        | (PackageId
pkgid, FilePath
tarball) <- [(PackageId, FilePath)]
allTarballFilePkgs
        ]
    [MonitorFilePath] -> Rebuild ()
monitorFiles [ FilePath -> MonitorFilePath
monitorFile FilePath
tarball
                 | (PackageId
_pkgid, FilePath
tarball) <- [(PackageId, FilePath)]
allTarballFilePkgs ]

    -- Return the combination
    Map PackageId PackageSourceHash
-> Rebuild (Map PackageId PackageSourceHash)
forall (m :: * -> *) a. Monad m => a -> m a
return (Map PackageId PackageSourceHash
 -> Rebuild (Map PackageId PackageSourceHash))
-> Map PackageId PackageSourceHash
-> Rebuild (Map PackageId PackageSourceHash)
forall a b. (a -> b) -> a -> b
$! Map PackageId PackageSourceHash
hashesFromRepoMetadata
           Map PackageId PackageSourceHash
-> Map PackageId PackageSourceHash
-> Map PackageId PackageSourceHash
forall a. Semigroup a => a -> a -> a
<> Map PackageId PackageSourceHash
hashesFromTarballFiles

-- | Append the given package databases to an existing PackageDBStack.
-- A @Nothing@ entry will clear everything before it.
applyPackageDbFlags :: PackageDBStack -> [Maybe PackageDB] -> PackageDBStack
applyPackageDbFlags :: PackageDBStack -> [Maybe PackageDB] -> PackageDBStack
applyPackageDbFlags PackageDBStack
dbs' []            = PackageDBStack
dbs'
applyPackageDbFlags PackageDBStack
_    (Maybe PackageDB
Nothing:[Maybe PackageDB]
dbs) = PackageDBStack -> [Maybe PackageDB] -> PackageDBStack
applyPackageDbFlags []             [Maybe PackageDB]
dbs
applyPackageDbFlags PackageDBStack
dbs' (Just PackageDB
db:[Maybe PackageDB]
dbs) = PackageDBStack -> [Maybe PackageDB] -> PackageDBStack
applyPackageDbFlags (PackageDBStack
dbs' PackageDBStack -> PackageDBStack -> PackageDBStack
forall a. [a] -> [a] -> [a]
++ [PackageDB
db]) [Maybe PackageDB]
dbs

-- ------------------------------------------------------------
-- * Installation planning
-- ------------------------------------------------------------

planPackages :: Verbosity
             -> Compiler
             -> Platform
             -> Solver -> SolverSettings
             -> InstalledPackageIndex
             -> SourcePackageDb
             -> PkgConfigDb
             -> [PackageSpecifier UnresolvedSourcePackage]
             -> Map PackageName (Map OptionalStanza Bool)
             -> Progress String String SolverInstallPlan
planPackages :: Verbosity
-> Compiler
-> Platform
-> Solver
-> SolverSettings
-> InstalledPackageIndex
-> SourcePackageDb
-> PkgConfigDb
-> [PackageSpecifier UnresolvedSourcePackage]
-> Map PackageName (Map OptionalStanza Bool)
-> Progress FilePath FilePath SolverInstallPlan
planPackages Verbosity
verbosity Compiler
comp Platform
platform Solver
solver SolverSettings{[(UserConstraint, ConstraintSource)]
[PackageVersionConstraint]
[LocalRepo]
[RemoteRepo]
Maybe Int
Maybe Version
Maybe TotalIndexState
Maybe ActiveRepos
Map PackageName FlagAssignment
FlagAssignment
ReorderGoals
CountConflicts
FineGrainedConflicts
MinimizeConflictSet
IndependentGoals
StrongFlags
AllowBootLibInstalls
OnlyConstrained
PreSolver
AllowOlder
AllowNewer
solverSettingIndependentGoals :: SolverSettings -> IndependentGoals
solverSettingOnlyConstrained :: SolverSettings -> OnlyConstrained
solverSettingAllowBootLibInstalls :: SolverSettings -> AllowBootLibInstalls
solverSettingStrongFlags :: SolverSettings -> StrongFlags
solverSettingMinimizeConflictSet :: SolverSettings -> MinimizeConflictSet
solverSettingFineGrainedConflicts :: SolverSettings -> FineGrainedConflicts
solverSettingCountConflicts :: SolverSettings -> CountConflicts
solverSettingReorderGoals :: SolverSettings -> ReorderGoals
solverSettingMaxBackjumps :: SolverSettings -> Maybe Int
solverSettingAllowNewer :: SolverSettings -> AllowNewer
solverSettingAllowOlder :: SolverSettings -> AllowOlder
solverSettingCabalVersion :: SolverSettings -> Maybe Version
solverSettingFlagAssignments :: SolverSettings -> Map PackageName FlagAssignment
solverSettingFlagAssignment :: SolverSettings -> FlagAssignment
solverSettingPreferences :: SolverSettings -> [PackageVersionConstraint]
solverSettingConstraints :: SolverSettings -> [(UserConstraint, ConstraintSource)]
solverSettingLocalNoIndexRepos :: SolverSettings -> [LocalRepo]
solverSettingRemoteRepos :: SolverSettings -> [RemoteRepo]
solverSettingIndependentGoals :: IndependentGoals
solverSettingActiveRepos :: Maybe ActiveRepos
solverSettingIndexState :: Maybe TotalIndexState
solverSettingOnlyConstrained :: OnlyConstrained
solverSettingAllowBootLibInstalls :: AllowBootLibInstalls
solverSettingStrongFlags :: StrongFlags
solverSettingMinimizeConflictSet :: MinimizeConflictSet
solverSettingFineGrainedConflicts :: FineGrainedConflicts
solverSettingCountConflicts :: CountConflicts
solverSettingReorderGoals :: ReorderGoals
solverSettingMaxBackjumps :: Maybe Int
solverSettingAllowNewer :: AllowNewer
solverSettingAllowOlder :: AllowOlder
solverSettingSolver :: PreSolver
solverSettingCabalVersion :: Maybe Version
solverSettingFlagAssignments :: Map PackageName FlagAssignment
solverSettingFlagAssignment :: FlagAssignment
solverSettingPreferences :: [PackageVersionConstraint]
solverSettingConstraints :: [(UserConstraint, ConstraintSource)]
solverSettingLocalNoIndexRepos :: [LocalRepo]
solverSettingRemoteRepos :: [RemoteRepo]
solverSettingSolver :: SolverSettings -> PreSolver
solverSettingActiveRepos :: SolverSettings -> Maybe ActiveRepos
solverSettingIndexState :: SolverSettings -> Maybe TotalIndexState
..}
             InstalledPackageIndex
installedPkgIndex SourcePackageDb
sourcePkgDb PkgConfigDb
pkgConfigDB
             [PackageSpecifier UnresolvedSourcePackage]
localPackages Map PackageName (Map OptionalStanza Bool)
pkgStanzasEnable =

    Platform
-> CompilerInfo
-> PkgConfigDb
-> Solver
-> DepResolverParams
-> Progress FilePath FilePath SolverInstallPlan
resolveDependencies
      Platform
platform (Compiler -> CompilerInfo
compilerInfo Compiler
comp)
      PkgConfigDb
pkgConfigDB Solver
solver
      DepResolverParams
resolverParams

  where

    --TODO: [nice to have] disable multiple instances restriction in
    -- the solver, but then make sure we can cope with that in the
    -- output.
    resolverParams :: DepResolverParams
    resolverParams :: DepResolverParams
resolverParams =

        Maybe Int -> DepResolverParams -> DepResolverParams
setMaxBackjumps Maybe Int
solverSettingMaxBackjumps

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndependentGoals -> DepResolverParams -> DepResolverParams
setIndependentGoals IndependentGoals
solverSettingIndependentGoals

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReorderGoals -> DepResolverParams -> DepResolverParams
setReorderGoals ReorderGoals
solverSettingReorderGoals

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CountConflicts -> DepResolverParams -> DepResolverParams
setCountConflicts CountConflicts
solverSettingCountConflicts

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FineGrainedConflicts -> DepResolverParams -> DepResolverParams
setFineGrainedConflicts FineGrainedConflicts
solverSettingFineGrainedConflicts

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MinimizeConflictSet -> DepResolverParams -> DepResolverParams
setMinimizeConflictSet MinimizeConflictSet
solverSettingMinimizeConflictSet

        --TODO: [required eventually] should only be configurable for
        --custom installs
   -- . setAvoidReinstalls solverSettingAvoidReinstalls

        --TODO: [required eventually] should only be configurable for
        --custom installs
   -- . setShadowPkgs solverSettingShadowPkgs

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StrongFlags -> DepResolverParams -> DepResolverParams
setStrongFlags StrongFlags
solverSettingStrongFlags

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AllowBootLibInstalls -> DepResolverParams -> DepResolverParams
setAllowBootLibInstalls AllowBootLibInstalls
solverSettingAllowBootLibInstalls

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OnlyConstrained -> DepResolverParams -> DepResolverParams
setOnlyConstrained OnlyConstrained
solverSettingOnlyConstrained

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Verbosity -> DepResolverParams -> DepResolverParams
setSolverVerbosity Verbosity
verbosity

        --TODO: [required eventually] decide if we need to prefer
        -- installed for global packages, or prefer latest even for
        -- global packages. Perhaps should be configurable but with a
        -- different name than "upgrade-dependencies".
      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackagesPreferenceDefault -> DepResolverParams -> DepResolverParams
setPreferenceDefault PackagesPreferenceDefault
PreferLatestForSelected
                           {-(if solverSettingUpgradeDeps
                                then PreferAllLatest
                                else PreferLatestForSelected)-}

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AllowOlder -> DepResolverParams -> DepResolverParams
removeLowerBounds AllowOlder
solverSettingAllowOlder
      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AllowNewer -> DepResolverParams -> DepResolverParams
removeUpperBounds AllowNewer
solverSettingAllowNewer

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnresolvedSourcePackage -> Maybe [Dependency])
-> DepResolverParams -> DepResolverParams
addDefaultSetupDependencies (Compiler -> Platform -> PackageDescription -> Maybe [Dependency]
defaultSetupDeps Compiler
comp Platform
platform
                                   (PackageDescription -> Maybe [Dependency])
-> (UnresolvedSourcePackage -> PackageDescription)
-> UnresolvedSourcePackage
-> Maybe [Dependency]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericPackageDescription -> PackageDescription
PD.packageDescription
                                   (GenericPackageDescription -> PackageDescription)
-> (UnresolvedSourcePackage -> GenericPackageDescription)
-> UnresolvedSourcePackage
-> PackageDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnresolvedSourcePackage -> GenericPackageDescription
forall loc. SourcePackage loc -> GenericPackageDescription
srcpkgDescription)

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> DepResolverParams -> DepResolverParams
addSetupCabalMinVersionConstraint Version
setupMinCabalVersionConstraint
      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> DepResolverParams -> DepResolverParams
addSetupCabalMaxVersionConstraint Version
setupMaxCabalVersionConstraint

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PackagePreference] -> DepResolverParams -> DepResolverParams
addPreferences
          -- preferences from the config file or command line
          [ PackageName -> VersionRange -> PackagePreference
PackageVersionPreference PackageName
name VersionRange
ver
          | PackageVersionConstraint PackageName
name VersionRange
ver <- [PackageVersionConstraint]
solverSettingPreferences ]

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [LabeledPackageConstraint]
-> DepResolverParams -> DepResolverParams
addConstraints
          -- version constraints from the config file or command line
            [ PackageConstraint -> ConstraintSource -> LabeledPackageConstraint
LabeledPackageConstraint (UserConstraint -> PackageConstraint
userToPackageConstraint UserConstraint
pc) ConstraintSource
src
            | (UserConstraint
pc, ConstraintSource
src) <- [(UserConstraint, ConstraintSource)]
solverSettingConstraints ]

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PackagePreference] -> DepResolverParams -> DepResolverParams
addPreferences
          -- enable stanza preference unilaterally, regardless if the user asked
          -- accordingly or expressed no preference, to help hint the solver
          [ PackageName -> [OptionalStanza] -> PackagePreference
PackageStanzasPreference PackageName
pkgname [OptionalStanza]
stanzas
          | PackageSpecifier UnresolvedSourcePackage
pkg <- [PackageSpecifier UnresolvedSourcePackage]
localPackages
          , let pkgname :: PackageName
pkgname = PackageSpecifier UnresolvedSourcePackage -> PackageName
forall pkg. Package pkg => PackageSpecifier pkg -> PackageName
pkgSpecifierTarget PackageSpecifier UnresolvedSourcePackage
pkg
                stanzaM :: Map OptionalStanza Bool
stanzaM = Map OptionalStanza Bool
-> PackageName
-> Map PackageName (Map OptionalStanza Bool)
-> Map OptionalStanza Bool
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault Map OptionalStanza Bool
forall k a. Map k a
Map.empty PackageName
pkgname Map PackageName (Map OptionalStanza Bool)
pkgStanzasEnable
                stanzas :: [OptionalStanza]
stanzas = [ OptionalStanza
stanza | OptionalStanza
stanza <- [OptionalStanza
forall a. Bounded a => a
minBound..OptionalStanza
forall a. Bounded a => a
maxBound]
                          , OptionalStanza -> Map OptionalStanza Bool -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup OptionalStanza
stanza Map OptionalStanza Bool
stanzaM Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
/= Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False ]
          , Bool -> Bool
not ([OptionalStanza] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [OptionalStanza]
stanzas)
          ]

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [LabeledPackageConstraint]
-> DepResolverParams -> DepResolverParams
addConstraints
          -- enable stanza constraints where the user asked to enable
          [ PackageConstraint -> ConstraintSource -> LabeledPackageConstraint
LabeledPackageConstraint
              (ConstraintScope -> PackageProperty -> PackageConstraint
PackageConstraint (PackageName -> ConstraintScope
scopeToplevel PackageName
pkgname)
                                 ([OptionalStanza] -> PackageProperty
PackagePropertyStanzas [OptionalStanza]
stanzas))
              ConstraintSource
ConstraintSourceConfigFlagOrTarget
          | PackageSpecifier UnresolvedSourcePackage
pkg <- [PackageSpecifier UnresolvedSourcePackage]
localPackages
          , let pkgname :: PackageName
pkgname = PackageSpecifier UnresolvedSourcePackage -> PackageName
forall pkg. Package pkg => PackageSpecifier pkg -> PackageName
pkgSpecifierTarget PackageSpecifier UnresolvedSourcePackage
pkg
                stanzaM :: Map OptionalStanza Bool
stanzaM = Map OptionalStanza Bool
-> PackageName
-> Map PackageName (Map OptionalStanza Bool)
-> Map OptionalStanza Bool
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault Map OptionalStanza Bool
forall k a. Map k a
Map.empty PackageName
pkgname Map PackageName (Map OptionalStanza Bool)
pkgStanzasEnable
                stanzas :: [OptionalStanza]
stanzas = [ OptionalStanza
stanza | OptionalStanza
stanza <- [OptionalStanza
forall a. Bounded a => a
minBound..OptionalStanza
forall a. Bounded a => a
maxBound]
                          , OptionalStanza -> Map OptionalStanza Bool -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup OptionalStanza
stanza Map OptionalStanza Bool
stanzaM Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True ]
          , Bool -> Bool
not ([OptionalStanza] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [OptionalStanza]
stanzas)
          ]

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [LabeledPackageConstraint]
-> DepResolverParams -> DepResolverParams
addConstraints
          --TODO: [nice to have] should have checked at some point that the
          -- package in question actually has these flags.
          [ PackageConstraint -> ConstraintSource -> LabeledPackageConstraint
LabeledPackageConstraint
              (ConstraintScope -> PackageProperty -> PackageConstraint
PackageConstraint (PackageName -> ConstraintScope
scopeToplevel PackageName
pkgname)
                                 (FlagAssignment -> PackageProperty
PackagePropertyFlags FlagAssignment
flags))
              ConstraintSource
ConstraintSourceConfigFlagOrTarget
          | (PackageName
pkgname, FlagAssignment
flags) <- Map PackageName FlagAssignment -> [(PackageName, FlagAssignment)]
forall k a. Map k a -> [(k, a)]
Map.toList Map PackageName FlagAssignment
solverSettingFlagAssignments ]

      (DepResolverParams -> DepResolverParams)
-> (DepResolverParams -> DepResolverParams)
-> DepResolverParams
-> DepResolverParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [LabeledPackageConstraint]
-> DepResolverParams -> DepResolverParams
addConstraints
          --TODO: [nice to have] we have user-supplied flags for unspecified
          -- local packages (as well as specific per-package flags). For the
          -- former we just apply all these flags to all local targets which
          -- is silly. We should check if the flags are appropriate.
          [ PackageConstraint -> ConstraintSource -> LabeledPackageConstraint
LabeledPackageConstraint
              (ConstraintScope -> PackageProperty -> PackageConstraint
PackageConstraint (PackageName -> ConstraintScope
scopeToplevel PackageName
pkgname)
                                 (FlagAssignment -> PackageProperty
PackagePropertyFlags FlagAssignment
flags))
              ConstraintSource
ConstraintSourceConfigFlagOrTarget
          | let flags :: FlagAssignment
flags = FlagAssignment
solverSettingFlagAssignment
          , Bool -> Bool
not (FlagAssignment -> Bool
PD.nullFlagAssignment FlagAssignment
flags)
          , PackageSpecifier UnresolvedSourcePackage
pkg <- [PackageSpecifier UnresolvedSourcePackage]
localPackages
          , let pkgname :: PackageName
pkgname = PackageSpecifier UnresolvedSourcePackage -> PackageName
forall pkg. Package pkg => PackageSpecifier pkg -> PackageName
pkgSpecifierTarget PackageSpecifier UnresolvedSourcePackage
pkg ]

      (DepResolverParams -> DepResolverParams)
-> DepResolverParams -> DepResolverParams
forall a b. (a -> b) -> a -> b
$ DepResolverParams
stdResolverParams

    stdResolverParams :: DepResolverParams
    stdResolverParams :: DepResolverParams
stdResolverParams =
      -- Note: we don't use the standardInstallPolicy here, since that uses
      -- its own addDefaultSetupDependencies that is not appropriate for us.
      InstalledPackageIndex
-> SourcePackageDb
-> [PackageSpecifier UnresolvedSourcePackage]
-> DepResolverParams
basicInstallPolicy
        InstalledPackageIndex
installedPkgIndex SourcePackageDb
sourcePkgDb
        [PackageSpecifier UnresolvedSourcePackage]
localPackages

    -- While we can talk to older Cabal versions (we need to be able to
    -- do so for custom Setup scripts that require older Cabal lib
    -- versions), we have problems talking to some older versions that
    -- don't support certain features.
    --
    -- For example, Cabal-1.16 and older do not know about build targets.
    -- Even worse, 1.18 and older only supported the --constraint flag
    -- with source package ids, not --dependency with installed package
    -- ids. That is bad because we cannot reliably select the right
    -- dependencies in the presence of multiple instances (i.e. the
    -- store). See issue #3932. So we require Cabal 1.20 as a minimum.
    --
    -- Moreover, lib:Cabal generally only supports the interface of
    -- current and past compilers; in fact recent lib:Cabal versions
    -- will warn when they encounter a too new or unknown GHC compiler
    -- version (c.f. #415). To avoid running into unsupported
    -- configurations we encode the compatibility matrix as lower
    -- bounds on lib:Cabal here (effectively corresponding to the
    -- respective major Cabal version bundled with the respective GHC
    -- release).
    --
    -- GHC 9.2   needs  Cabal >= 3.6
    -- GHC 9.0   needs  Cabal >= 3.4
    -- GHC 8.10  needs  Cabal >= 3.2
    -- GHC 8.8   needs  Cabal >= 3.0
    -- GHC 8.6   needs  Cabal >= 2.4
    -- GHC 8.4   needs  Cabal >= 2.2
    -- GHC 8.2   needs  Cabal >= 2.0
    -- GHC 8.0   needs  Cabal >= 1.24
    -- GHC 7.10  needs  Cabal >= 1.22
    --
    -- (NB: we don't need to consider older GHCs as Cabal >= 1.20 is
    -- the absolute lower bound)
    --
    -- TODO: long-term, this compatibility matrix should be
    --       stored as a field inside 'Distribution.Compiler.Compiler'
    setupMinCabalVersionConstraint :: Version
setupMinCabalVersionConstraint
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
9,Int
4]  = [Int] -> Version
mkVersion [Int
3,Int
8]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
9,Int
2]  = [Int] -> Version
mkVersion [Int
3,Int
6]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
9,Int
0]  = [Int] -> Version
mkVersion [Int
3,Int
4]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
8,Int
10] = [Int] -> Version
mkVersion [Int
3,Int
2]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
8,Int
8]  = [Int] -> Version
mkVersion [Int
3,Int
0]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
8,Int
6]  = [Int] -> Version
mkVersion [Int
2,Int
4]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
8,Int
4]  = [Int] -> Version
mkVersion [Int
2,Int
2]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
8,Int
2]  = [Int] -> Version
mkVersion [Int
2,Int
0]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
8,Int
0]  = [Int] -> Version
mkVersion [Int
1,Int
24]
      | Bool
isGHC, Version
compVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
7,Int
10] = [Int] -> Version
mkVersion [Int
1,Int
22]
      | Bool
otherwise                          = [Int] -> Version
mkVersion [Int
1,Int
20]
      where
        isGHC :: Bool
isGHC    = CompilerFlavor
compFlav CompilerFlavor -> [CompilerFlavor] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [CompilerFlavor
GHC,CompilerFlavor
GHCJS]
        compFlav :: CompilerFlavor
compFlav = Compiler -> CompilerFlavor
compilerFlavor Compiler
comp
        compVer :: Version
compVer  = Compiler -> Version
compilerVersion Compiler
comp

    -- As we can't predict the future, we also place a global upper
    -- bound on the lib:Cabal version we know how to interact with:
    --
    -- The upper bound is computed by incrementing the current major
    -- version twice in order to allow for the current version, as
    -- well as the next adjacent major version (one of which will not
    -- be released, as only "even major" versions of Cabal are
    -- released to Hackage or bundled with proper GHC releases).
    --
    -- For instance, if the current version of cabal-install is an odd
    -- development version, e.g.  Cabal-2.1.0.0, then we impose an
    -- upper bound `setup.Cabal < 2.3`; if `cabal-install` is on a
    -- stable/release even version, e.g. Cabal-2.2.1.0, the upper
    -- bound is `setup.Cabal < 2.4`. This gives us enough flexibility
    -- when dealing with development snapshots of Cabal and cabal-install.
    --
    setupMaxCabalVersionConstraint :: Version
setupMaxCabalVersionConstraint =
      ([Int] -> [Int]) -> Version -> Version
alterVersion (Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take Int
2) (Version -> Version) -> Version -> Version
forall a b. (a -> b) -> a -> b
$ Int -> Version -> Version
incVersion Int
1 (Version -> Version) -> Version -> Version
forall a b. (a -> b) -> a -> b
$ Int -> Version -> Version
incVersion Int
1 Version
cabalVersion

------------------------------------------------------------------------------
-- * Install plan post-processing
------------------------------------------------------------------------------

-- This phase goes from the InstallPlan we get from the solver and has to
-- make an elaborated install plan.
--
-- We go in two steps:
--
--  1. elaborate all the source packages that the solver has chosen.
--  2. swap source packages for pre-existing installed packages wherever
--     possible.
--
-- We do it in this order, elaborating and then replacing, because the easiest
-- way to calculate the installed package ids used for the replacement step is
-- from the elaborated configuration for each package.




------------------------------------------------------------------------------
-- * Install plan elaboration
------------------------------------------------------------------------------

-- Note [SolverId to ConfiguredId]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Dependency solving is a per package affair, so after we're done, we
-- end up with 'SolverInstallPlan' that records in 'solverPkgLibDeps'
-- and 'solverPkgExeDeps' what packages provide the libraries and executables
-- needed by each component of the package (phew!)  For example, if I have
--
--      library
--          build-depends: lib
--          build-tool-depends: pkg:exe1
--          build-tools: alex
--
-- After dependency solving, I find out that this library component has
-- library dependencies on lib-0.2, and executable dependencies on pkg-0.1
-- and alex-0.3 (other components of the package may have different
-- dependencies).  Note that I've "lost" the knowledge that I depend
-- *specifically* on the exe1 executable from pkg.
--
-- So, we have a this graph of packages, and we need to transform it into
-- a graph of components which we are actually going to build.  In particular:
--
-- NODE changes from PACKAGE (SolverPackage) to COMPONENTS (ElaboratedConfiguredPackage)
-- EDGE changes from PACKAGE DEP (SolverId) to COMPONENT DEPS (ConfiguredId)
--
-- In both cases, what was previously a single node/edge may turn into multiple
-- nodes/edges.  Multiple components, because there may be multiple components
-- in a package; multiple component deps, because we may depend upon multiple
-- executables from the same package (and maybe, some day, multiple libraries
-- from the same package.)
--
-- Let's talk about how to do this transformation. Naively, we might consider
-- just processing each package, converting it into (zero or) one or more
-- components.  But we also have to update the edges; this leads to
-- two complications:
--
--      1. We don't know what the ConfiguredId of a component is until
--      we've configured it, but we cannot configure a component unless
--      we know the ConfiguredId of all its dependencies.  Thus, we must
--      process the 'SolverInstallPlan' in topological order.
--
--      2. When we process a package, we know the SolverIds of its
--      dependencies, but we have to do some work to turn these into
--      ConfiguredIds.  For example, in the case of build-tool-depends, the
--      SolverId isn't enough to uniquely determine the ConfiguredId we should
--      elaborate to: we have to look at the executable name attached to
--      the package name in the package description to figure it out.
--      At the same time, we NEED to use the SolverId, because there might
--      be multiple versions of the same package in the build plan
--      (due to setup dependencies); we can't just look up the package name
--      from the package description.
--
-- We can adopt the following strategy:
--
--      * When a package is transformed into components, record
--        a mapping from SolverId to ALL of the components
--        which were elaborated.
--
--      * When we look up an edge, we use our knowledge of the
--        component name to *filter* the list of components into
--        the ones we actually wanted to refer to.
--
-- By the way, we can tell that SolverInstallPlan is not the "right" type
-- because a SolverId cannot adequately represent all possible dependency
-- solver states: we may need to record foo-0.1 multiple times in
-- the solver install plan with different dependencies.  This imprecision in the
-- type currently doesn't cause any problems because the dependency solver
-- continues to enforce the single instance restriction regardless of compiler
-- version.  The right way to solve this is to come up with something very much
-- like a 'ConfiguredId', in that it incorporates the version choices of its
-- dependencies, but less fine grained.


-- | Produce an elaborated install plan using the policy for local builds with
-- a nix-style shared store.
--
-- In theory should be able to make an elaborated install plan with a policy
-- matching that of the classic @cabal install --user@ or @--global@
--
elaborateInstallPlan
  :: Verbosity -> Platform -> Compiler -> ProgramDb -> PkgConfigDb
  -> DistDirLayout
  -> StoreDirLayout
  -> SolverInstallPlan
  -> [PackageSpecifier (SourcePackage (PackageLocation loc))]
  -> Map PackageId PackageSourceHash
  -> InstallDirs.InstallDirTemplates
  -> ProjectConfigShared
  -> PackageConfig
  -> PackageConfig
  -> Map PackageName PackageConfig
  -> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
elaborateInstallPlan :: Verbosity
-> Platform
-> Compiler
-> ProgramDb
-> PkgConfigDb
-> DistDirLayout
-> StoreDirLayout
-> SolverInstallPlan
-> [PackageSpecifier (SourcePackage (PackageLocation loc))]
-> Map PackageId PackageSourceHash
-> InstallDirTemplates
-> ProjectConfigShared
-> PackageConfig
-> PackageConfig
-> Map PackageName PackageConfig
-> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
elaborateInstallPlan Verbosity
verbosity Platform
platform Compiler
compiler ProgramDb
compilerprogdb PkgConfigDb
pkgConfigDB
                     distDirLayout :: DistDirLayout
distDirLayout@DistDirLayout{FilePath
FilePath -> FilePath
PackageId -> FilePath
CompilerId -> PackageDB
DistDirParams -> FilePath
DistDirParams -> FilePath -> FilePath
distPackageDB :: DistDirLayout -> CompilerId -> PackageDB
distBinDirectory :: DistDirLayout -> FilePath
distTempDirectory :: DistDirLayout -> FilePath
distSdistDirectory :: DistDirLayout -> FilePath
distSdistFile :: DistDirLayout -> PackageId -> FilePath
distPackageCacheDirectory :: DistDirLayout -> DistDirParams -> FilePath
distPackageCacheFile :: DistDirLayout -> DistDirParams -> FilePath -> FilePath
distUnpackedSrcRootDirectory :: DistDirLayout -> FilePath
distUnpackedSrcDirectory :: DistDirLayout -> PackageId -> FilePath
distDownloadSrcDirectory :: DistDirLayout -> FilePath
distBuildRootDirectory :: DistDirLayout -> FilePath
distBuildDirectory :: DistDirLayout -> DistDirParams -> FilePath
distPackageDB :: CompilerId -> PackageDB
distBinDirectory :: FilePath
distTempDirectory :: FilePath
distSdistDirectory :: FilePath
distSdistFile :: PackageId -> FilePath
distPackageCacheDirectory :: DistDirParams -> FilePath
distPackageCacheFile :: DistDirParams -> FilePath -> FilePath
distProjectCacheDirectory :: FilePath
distProjectCacheFile :: FilePath -> FilePath
distUnpackedSrcRootDirectory :: FilePath
distUnpackedSrcDirectory :: PackageId -> FilePath
distDownloadSrcDirectory :: FilePath
distBuildRootDirectory :: FilePath
distBuildDirectory :: DistDirParams -> FilePath
distDirectory :: FilePath
distProjectFile :: FilePath -> FilePath
distProjectRootDirectory :: FilePath
distProjectFile :: DistDirLayout -> FilePath -> FilePath
distProjectCacheDirectory :: DistDirLayout -> FilePath
distProjectCacheFile :: DistDirLayout -> FilePath -> FilePath
distDirectory :: DistDirLayout -> FilePath
distProjectRootDirectory :: DistDirLayout -> FilePath
..}
                     storeDirLayout :: StoreDirLayout
storeDirLayout@StoreDirLayout{CompilerId -> PackageDBStack
storePackageDBStack :: StoreDirLayout -> CompilerId -> PackageDBStack
storePackageDBStack :: CompilerId -> PackageDBStack
storePackageDBStack}
                     SolverInstallPlan
solverPlan [PackageSpecifier (SourcePackage (PackageLocation loc))]
localPackages
                     Map PackageId PackageSourceHash
sourcePackageHashes
                     InstallDirTemplates
defaultInstallDirs
                     ProjectConfigShared
sharedPackageConfig
                     PackageConfig
allPackagesConfig
                     PackageConfig
localPackagesConfig
                     Map PackageName PackageConfig
perPackageConfig = do
    ElaboratedInstallPlan
x <- LogProgress ElaboratedInstallPlan
elaboratedInstallPlan
    (ElaboratedInstallPlan, ElaboratedSharedConfig)
-> LogProgress (ElaboratedInstallPlan, ElaboratedSharedConfig)
forall (m :: * -> *) a. Monad m => a -> m a
return (ElaboratedInstallPlan
x, ElaboratedSharedConfig
elaboratedSharedConfig)
  where
    elaboratedSharedConfig :: ElaboratedSharedConfig
elaboratedSharedConfig =
      ElaboratedSharedConfig :: Platform
-> Compiler -> ProgramDb -> ReplOptions -> ElaboratedSharedConfig
ElaboratedSharedConfig {
        pkgConfigPlatform :: Platform
pkgConfigPlatform      = Platform
platform,
        pkgConfigCompiler :: Compiler
pkgConfigCompiler      = Compiler
compiler,
        pkgConfigCompilerProgs :: ProgramDb
pkgConfigCompilerProgs = ProgramDb
compilerprogdb,
        pkgConfigReplOptions :: ReplOptions
pkgConfigReplOptions   = ReplOptions
forall a. Monoid a => a
mempty
      }

    preexistingInstantiatedPkgs :: Map UnitId FullUnitId
    preexistingInstantiatedPkgs :: Map UnitId FullUnitId
preexistingInstantiatedPkgs =
        [(UnitId, FullUnitId)] -> Map UnitId FullUnitId
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ((ResolverPackage (PackageLocation (Maybe FilePath))
 -> Maybe (UnitId, FullUnitId))
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
-> [(UnitId, FullUnitId)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ResolverPackage (PackageLocation (Maybe FilePath))
-> Maybe (UnitId, FullUnitId)
forall loc. ResolverPackage loc -> Maybe (UnitId, FullUnitId)
f (SolverInstallPlan
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
SolverInstallPlan.toList SolverInstallPlan
solverPlan))
      where
        f :: ResolverPackage loc -> Maybe (UnitId, FullUnitId)
f (SolverInstallPlan.PreExisting InstSolverPackage
inst)
            | let ipkg :: InstalledPackageInfo
ipkg = InstSolverPackage -> InstalledPackageInfo
instSolverPkgIPI InstSolverPackage
inst
            , Bool -> Bool
not (InstalledPackageInfo -> Bool
IPI.indefinite InstalledPackageInfo
ipkg)
            = (UnitId, FullUnitId) -> Maybe (UnitId, FullUnitId)
forall a. a -> Maybe a
Just (InstalledPackageInfo -> UnitId
IPI.installedUnitId InstalledPackageInfo
ipkg,
                     (ComponentId -> Map ModuleName OpenModule -> FullUnitId
FullUnitId (InstalledPackageInfo -> ComponentId
IPI.installedComponentId InstalledPackageInfo
ipkg)
                                 ([(ModuleName, OpenModule)] -> Map ModuleName OpenModule
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (InstalledPackageInfo -> [(ModuleName, OpenModule)]
IPI.instantiatedWith InstalledPackageInfo
ipkg))))
        f ResolverPackage loc
_ = Maybe (UnitId, FullUnitId)
forall a. Maybe a
Nothing

    elaboratedInstallPlan ::
      LogProgress (InstallPlan.GenericInstallPlan IPI.InstalledPackageInfo ElaboratedConfiguredPackage)
    elaboratedInstallPlan :: LogProgress ElaboratedInstallPlan
elaboratedInstallPlan =
      (((SolverId
   -> [GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage])
  -> ResolverPackage (PackageLocation (Maybe FilePath))
  -> LogProgress
       [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
 -> SolverInstallPlan -> LogProgress ElaboratedInstallPlan)
-> SolverInstallPlan
-> ((SolverId
     -> [GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage])
    -> ResolverPackage (PackageLocation (Maybe FilePath))
    -> LogProgress
         [GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage])
-> LogProgress ElaboratedInstallPlan
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((SolverId
  -> [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage])
 -> ResolverPackage (PackageLocation (Maybe FilePath))
 -> LogProgress
      [GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage])
-> SolverInstallPlan -> LogProgress ElaboratedInstallPlan
forall ipkg srcpkg.
(IsUnit ipkg, IsUnit srcpkg) =>
((SolverId -> [GenericPlanPackage ipkg srcpkg])
 -> ResolverPackage (PackageLocation (Maybe FilePath))
 -> LogProgress [GenericPlanPackage ipkg srcpkg])
-> SolverInstallPlan
-> LogProgress (GenericInstallPlan ipkg srcpkg)
InstallPlan.fromSolverInstallPlanWithProgress SolverInstallPlan
solverPlan (((SolverId
   -> [GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage])
  -> ResolverPackage (PackageLocation (Maybe FilePath))
  -> LogProgress
       [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
 -> LogProgress ElaboratedInstallPlan)
-> ((SolverId
     -> [GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage])
    -> ResolverPackage (PackageLocation (Maybe FilePath))
    -> LogProgress
         [GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage])
-> LogProgress ElaboratedInstallPlan
forall a b. (a -> b) -> a -> b
$ \SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep ResolverPackage (PackageLocation (Maybe FilePath))
planpkg ->
        case ResolverPackage (PackageLocation (Maybe FilePath))
planpkg of
          SolverInstallPlan.PreExisting InstSolverPackage
pkg ->
            [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> LogProgress
     [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage]
forall (m :: * -> *) a. Monad m => a -> m a
return [InstalledPackageInfo
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
forall ipkg srcpkg. ipkg -> GenericPlanPackage ipkg srcpkg
InstallPlan.PreExisting (InstSolverPackage -> InstalledPackageInfo
instSolverPkgIPI InstSolverPackage
pkg)]

          SolverInstallPlan.Configured  SolverPackage (PackageLocation (Maybe FilePath))
pkg ->
            let inplace_doc :: Doc
inplace_doc | SolverPackage (PackageLocation (Maybe FilePath)) -> Bool
forall loc. SolverPackage loc -> Bool
shouldBuildInplaceOnly SolverPackage (PackageLocation (Maybe FilePath))
pkg = FilePath -> Doc
text FilePath
"inplace"
                            | Bool
otherwise                  = Doc
Disp.empty
            in Doc
-> LogProgress
     [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage]
-> LogProgress
     [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage]
forall a. Doc -> LogProgress a -> LogProgress a
addProgressCtx (FilePath -> Doc
text FilePath
"In the" Doc -> Doc -> Doc
<+> Doc
inplace_doc Doc -> Doc -> Doc
<+> FilePath -> Doc
text FilePath
"package" Doc -> Doc -> Doc
<+>
                             Doc -> Doc
quotes (PackageId -> Doc
forall a. Pretty a => a -> Doc
pretty (SolverPackage (PackageLocation (Maybe FilePath)) -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId SolverPackage (PackageLocation (Maybe FilePath))
pkg))) (LogProgress
   [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
 -> LogProgress
      [GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage])
-> LogProgress
     [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage]
-> LogProgress
     [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> a -> b
$
               (ElaboratedConfiguredPackage
 -> GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
-> [ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> [a] -> [b]
map ElaboratedConfiguredPackage
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
forall ipkg srcpkg. srcpkg -> GenericPlanPackage ipkg srcpkg
InstallPlan.Configured ([ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> LogProgress [ElaboratedConfiguredPackage]
-> LogProgress
     [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> SolverPackage (PackageLocation (Maybe FilePath))
-> LogProgress [ElaboratedConfiguredPackage]
elaborateSolverToComponents SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep SolverPackage (PackageLocation (Maybe FilePath))
pkg

    -- NB: We don't INSTANTIATE packages at this point.  That's
    -- a post-pass.  This makes it simpler to compute dependencies.
    elaborateSolverToComponents
        :: (SolverId -> [ElaboratedPlanPackage])
        -> SolverPackage UnresolvedPkgLoc
        -> LogProgress [ElaboratedConfiguredPackage]
    elaborateSolverToComponents :: (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> SolverPackage (PackageLocation (Maybe FilePath))
-> LogProgress [ElaboratedConfiguredPackage]
elaborateSolverToComponents SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep spkg :: SolverPackage (PackageLocation (Maybe FilePath))
spkg@(SolverPackage UnresolvedSourcePackage
_ FlagAssignment
_ OptionalStanzaSet
_ ComponentDeps [SolverId]
deps0 ComponentDeps [SolverId]
exe_deps0)
        = case ComponentRequestedSpec
-> PackageDescription -> Either [ComponentName] ComponentsGraph
mkComponentsGraph (ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabEnabledSpec ElaboratedConfiguredPackage
elab0) PackageDescription
pd of
           Right ComponentsGraph
g -> do
            let src_comps :: ComponentsWithDeps
src_comps = ComponentsGraph -> ComponentsWithDeps
componentsGraphToList ComponentsGraph
g
            Doc -> LogProgress ()
infoProgress (Doc -> LogProgress ()) -> Doc -> LogProgress ()
forall a b. (a -> b) -> a -> b
$ Doc -> Int -> Doc -> Doc
hang (FilePath -> Doc
text FilePath
"Component graph for" Doc -> Doc -> Doc
<+> PackageId -> Doc
forall a. Pretty a => a -> Doc
pretty PackageId
pkgid Doc -> Doc -> Doc
<<>> Doc
colon)
                            Int
4 (ComponentsWithDeps -> Doc
dispComponentsWithDeps ComponentsWithDeps
src_comps)
            ((ConfiguredComponentMap, LinkedComponentMap,
 Map ComponentId FilePath)
_, [ElaboratedConfiguredPackage]
comps) <- ((ConfiguredComponentMap, LinkedComponentMap,
  Map ComponentId FilePath)
 -> Component
 -> LogProgress
      ((ConfiguredComponentMap, LinkedComponentMap,
        Map ComponentId FilePath),
       ElaboratedConfiguredPackage))
-> (ConfiguredComponentMap, LinkedComponentMap,
    Map ComponentId FilePath)
-> [Component]
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      [ElaboratedConfiguredPackage])
forall (m :: * -> *) (t :: * -> *) a b c.
(Monad m, Traversable t) =>
(a -> b -> m (a, c)) -> a -> t b -> m (a, t c)
mapAccumM (ConfiguredComponentMap, LinkedComponentMap,
 Map ComponentId FilePath)
-> Component
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      ElaboratedConfiguredPackage)
buildComponent
                            (ConfiguredComponentMap
forall k a. Map k a
Map.empty, LinkedComponentMap
forall k a. Map k a
Map.empty, Map ComponentId FilePath
forall k a. Map k a
Map.empty)
                            (((Component, [ComponentName]) -> Component)
-> ComponentsWithDeps -> [Component]
forall a b. (a -> b) -> [a] -> [b]
map (Component, [ComponentName]) -> Component
forall a b. (a, b) -> a
fst ComponentsWithDeps
src_comps)
            let not_per_component_reasons :: [Doc]
not_per_component_reasons = ComponentsWithDeps -> [Doc]
forall (t :: * -> *) a. Foldable t => t a -> [Doc]
why_not_per_component ComponentsWithDeps
src_comps
            if [Doc] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Doc]
not_per_component_reasons
                then [ElaboratedConfiguredPackage]
-> LogProgress [ElaboratedConfiguredPackage]
forall (m :: * -> *) a. Monad m => a -> m a
return [ElaboratedConfiguredPackage]
comps
                else do [ElaboratedConfiguredPackage] -> [Doc] -> LogProgress ()
forall (t :: * -> *).
Foldable t =>
t ElaboratedConfiguredPackage -> [Doc] -> LogProgress ()
checkPerPackageOk [ElaboratedConfiguredPackage]
comps [Doc]
not_per_component_reasons
                        [ElaboratedConfiguredPackage]
-> LogProgress [ElaboratedConfiguredPackage]
forall (m :: * -> *) a. Monad m => a -> m a
return [SolverPackage (PackageLocation (Maybe FilePath))
-> ComponentsGraph
-> [ElaboratedConfiguredPackage]
-> ElaboratedConfiguredPackage
elaborateSolverToPackage SolverPackage (PackageLocation (Maybe FilePath))
spkg ComponentsGraph
g ([ElaboratedConfiguredPackage] -> ElaboratedConfiguredPackage)
-> [ElaboratedConfiguredPackage] -> ElaboratedConfiguredPackage
forall a b. (a -> b) -> a -> b
$
                                [ElaboratedConfiguredPackage]
comps [ElaboratedConfiguredPackage]
-> [ElaboratedConfiguredPackage] -> [ElaboratedConfiguredPackage]
forall a. [a] -> [a] -> [a]
++ Maybe ElaboratedConfiguredPackage -> [ElaboratedConfiguredPackage]
forall a. Maybe a -> [a]
maybeToList Maybe ElaboratedConfiguredPackage
setupComponent]
           Left [ComponentName]
cns ->
            Doc -> LogProgress [ElaboratedConfiguredPackage]
forall a. Doc -> LogProgress a
dieProgress (Doc -> LogProgress [ElaboratedConfiguredPackage])
-> Doc -> LogProgress [ElaboratedConfiguredPackage]
forall a b. (a -> b) -> a -> b
$
                Doc -> Int -> Doc -> Doc
hang (FilePath -> Doc
text FilePath
"Dependency cycle between the following components:") Int
4
                     ([Doc] -> Doc
vcat ((ComponentName -> Doc) -> [ComponentName] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (FilePath -> Doc
text (FilePath -> Doc)
-> (ComponentName -> FilePath) -> ComponentName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentName -> FilePath
componentNameStanza) [ComponentName]
cns))
      where
        -- You are eligible to per-component build if this list is empty
        why_not_per_component :: t a -> [Doc]
why_not_per_component t a
g
            = [Doc]
cuz_buildtype [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++ [Doc]
cuz_spec [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++ [Doc]
cuz_length [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++ [Doc]
cuz_flag [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++ [Doc]
cuz_coverage
          where
            cuz :: FilePath -> [Doc]
cuz FilePath
reason = [FilePath -> Doc
text FilePath
reason]
            -- We have to disable per-component for now with
            -- Configure-type scripts in order to prevent parallel
            -- invocation of the same `./configure` script.
            -- See https://github.com/haskell/cabal/issues/4548
            --
            -- Moreover, at this point in time, only non-Custom setup scripts
            -- are supported.  Implementing per-component builds with
            -- Custom would require us to create a new 'ElabSetup'
            -- type, and teach all of the code paths how to handle it.
            -- Once you've implemented this, swap it for the code below.
            cuz_buildtype :: [Doc]
cuz_buildtype =
                case PackageDescription -> BuildType
PD.buildType (ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
elab0) of
                    BuildType
PD.Configure -> FilePath -> [Doc]
cuz FilePath
"build-type is Configure"
                    BuildType
PD.Custom -> FilePath -> [Doc]
cuz FilePath
"build-type is Custom"
                    BuildType
_         -> []
            -- cabal-format versions prior to 1.8 have different build-depends semantics
            -- for now it's easier to just fallback to legacy-mode when specVersion < 1.8
            -- see, https://github.com/haskell/cabal/issues/4121
            cuz_spec :: [Doc]
cuz_spec
                | PackageDescription -> CabalSpecVersion
PD.specVersion PackageDescription
pd CabalSpecVersion -> CabalSpecVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= CabalSpecVersion
CabalSpecV1_8 = []
                | Bool
otherwise = FilePath -> [Doc]
cuz FilePath
"cabal-version is less than 1.8"
            -- In the odd corner case that a package has no components at all
            -- then keep it as a whole package, since otherwise it turns into
            -- 0 component graph nodes and effectively vanishes. We want to
            -- keep it around at least for error reporting purposes.
            cuz_length :: [Doc]
cuz_length
                | t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
g Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 = []
                | Bool
otherwise    = FilePath -> [Doc]
cuz FilePath
"there are no buildable components"
            -- For ease of testing, we let per-component builds be toggled
            -- at the top level
            cuz_flag :: [Doc]
cuz_flag
                | Bool -> Flag Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
True (ProjectConfigShared -> Flag Bool
projectConfigPerComponent ProjectConfigShared
sharedPackageConfig)
                = []
                | Bool
otherwise = FilePath -> [Doc]
cuz FilePath
"you passed --disable-per-component"
            -- Enabling program coverage introduces odd runtime dependencies
            -- between components.
            cuz_coverage :: [Doc]
cuz_coverage
                | Bool -> Flag Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False (PackageConfig -> Flag Bool
packageConfigCoverage PackageConfig
localPackagesConfig)
                = FilePath -> [Doc]
cuz FilePath
"program coverage is enabled"
                | Bool
otherwise = []

        -- | Sometimes a package may make use of features which are only
        -- supported in per-package mode.  If this is the case, we should
        -- give an error when this occurs.
        checkPerPackageOk :: t ElaboratedConfiguredPackage -> [Doc] -> LogProgress ()
checkPerPackageOk t ElaboratedConfiguredPackage
comps [Doc]
reasons = do
            let is_sublib :: ComponentName -> Bool
is_sublib (CLibName (LSubLibName UnqualComponentName
_)) = Bool
True
                is_sublib ComponentName
_ = Bool
False
            Bool -> LogProgress () -> LogProgress ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ((ElaboratedConfiguredPackage -> Bool)
-> t ElaboratedConfiguredPackage -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((ComponentName -> Bool) -> ElaboratedConfiguredPackage -> Bool
matchElabPkg ComponentName -> Bool
is_sublib) t ElaboratedConfiguredPackage
comps) (LogProgress () -> LogProgress ())
-> LogProgress () -> LogProgress ()
forall a b. (a -> b) -> a -> b
$
                Doc -> LogProgress ()
forall a. Doc -> LogProgress a
dieProgress (Doc -> LogProgress ()) -> Doc -> LogProgress ()
forall a b. (a -> b) -> a -> b
$
                    FilePath -> Doc
text FilePath
"Internal libraries only supported with per-component builds." Doc -> Doc -> Doc
$$
                    FilePath -> Doc
text FilePath
"Per-component builds were disabled because" Doc -> Doc -> Doc
<+>
                        [Doc] -> Doc
fsep (Doc -> [Doc] -> [Doc]
punctuate Doc
comma [Doc]
reasons)
            -- TODO: Maybe exclude Backpack too

        elab0 :: ElaboratedConfiguredPackage
elab0 = SolverPackage (PackageLocation (Maybe FilePath))
-> ElaboratedConfiguredPackage
elaborateSolverToCommon SolverPackage (PackageLocation (Maybe FilePath))
spkg
        pkgid :: PackageId
pkgid = ElaboratedConfiguredPackage -> PackageId
elabPkgSourceId    ElaboratedConfiguredPackage
elab0
        pd :: PackageDescription
pd    = ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
elab0

        -- TODO: This is just a skeleton to get elaborateSolverToPackage
        -- working correctly
        -- TODO: When we actually support building these components, we
        -- have to add dependencies on this from all other components
        setupComponent :: Maybe ElaboratedConfiguredPackage
        setupComponent :: Maybe ElaboratedConfiguredPackage
setupComponent
            | PackageDescription -> BuildType
PD.buildType (ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
elab0) BuildType -> BuildType -> Bool
forall a. Eq a => a -> a -> Bool
== BuildType
PD.Custom
            = ElaboratedConfiguredPackage -> Maybe ElaboratedConfiguredPackage
forall a. a -> Maybe a
Just ElaboratedConfiguredPackage
elab0 {
                elabModuleShape :: ModuleShape
elabModuleShape = ModuleShape
emptyModuleShape,
                elabUnitId :: UnitId
elabUnitId = FilePath -> UnitId
forall a. FilePath -> a
notImpl FilePath
"elabUnitId",
                elabComponentId :: ComponentId
elabComponentId = FilePath -> ComponentId
forall a. FilePath -> a
notImpl FilePath
"elabComponentId",
                elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabLinkedInstantiatedWith = Map ModuleName OpenModule
forall k a. Map k a
Map.empty,
                elabInstallDirs :: InstallDirs FilePath
elabInstallDirs = FilePath -> InstallDirs FilePath
forall a. FilePath -> a
notImpl FilePath
"elabInstallDirs",
                elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp = ElaboratedComponent -> ElaboratedPackageOrComponent
ElabComponent (ElaboratedComponent :: Component
-> Maybe ComponentName
-> [ConfiguredId]
-> [OpenUnitId]
-> [ConfiguredId]
-> [(PkgconfigName, Maybe PkgconfigVersion)]
-> [(ConfiguredId, FilePath)]
-> [UnitId]
-> ElaboratedComponent
ElaboratedComponent {[(PkgconfigName, Maybe PkgconfigVersion)]
[(ConfiguredId, FilePath)]
[OpenUnitId]
[UnitId]
[ConfiguredId]
Maybe ComponentName
Component
forall a. a
forall a. [a]
forall a. Maybe a
compPkgConfigDependencies :: forall a. [a]
compExeDependencyPaths :: forall a. [a]
compExeDependencies :: forall a. [a]
compOrderLibDependencies :: forall a. a
compLinkedLibDependencies :: forall a. a
compLibDependencies :: [ConfiguredId]
compComponentName :: forall a. Maybe a
compSolverName :: Component
compOrderLibDependencies :: [UnitId]
compExeDependencyPaths :: [(ConfiguredId, FilePath)]
compPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
compExeDependencies :: [ConfiguredId]
compLinkedLibDependencies :: [OpenUnitId]
compLibDependencies :: [ConfiguredId]
compComponentName :: Maybe ComponentName
compSolverName :: Component
..})
              }
            | Bool
otherwise
            = Maybe ElaboratedConfiguredPackage
forall a. Maybe a
Nothing
          where
            compSolverName :: Component
compSolverName      = Component
CD.ComponentSetup
            compComponentName :: Maybe a
compComponentName   = Maybe a
forall a. Maybe a
Nothing
            dep_pkgs :: [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
dep_pkgs = (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
elaborateLibSolverId SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> [SolverId]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ComponentDeps [SolverId] -> [SolverId]
forall a. Monoid a => ComponentDeps a -> a
CD.setupDeps ComponentDeps [SolverId]
deps0
            compLibDependencies :: [ConfiguredId]
compLibDependencies
                = (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> ConfiguredId)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [ConfiguredId]
forall a b. (a -> b) -> [a] -> [b]
map GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> ConfiguredId
forall a. HasConfiguredId a => a -> ConfiguredId
configuredId [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
dep_pkgs
            compLinkedLibDependencies :: a
compLinkedLibDependencies = FilePath -> a
forall a. FilePath -> a
notImpl FilePath
"compLinkedLibDependencies"
            compOrderLibDependencies :: a
compOrderLibDependencies = FilePath -> a
forall a. FilePath -> a
notImpl FilePath
"compOrderLibDependencies"
            -- Not supported:
            compExeDependencies :: [a]
compExeDependencies         = []
            compExeDependencyPaths :: [a]
compExeDependencyPaths      = []
            compPkgConfigDependencies :: [a]
compPkgConfigDependencies   = []

            notImpl :: FilePath -> a
notImpl FilePath
f =
                FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath -> a) -> FilePath -> a
forall a b. (a -> b) -> a -> b
$ FilePath
"Distribution.Client.ProjectPlanning.setupComponent: " FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++
                        FilePath
f FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ FilePath
" not implemented yet"


        buildComponent
            :: (ConfiguredComponentMap,
                LinkedComponentMap,
                Map ComponentId FilePath)
            -> Cabal.Component
            -> LogProgress
                ((ConfiguredComponentMap,
                  LinkedComponentMap,
                  Map ComponentId FilePath),
                ElaboratedConfiguredPackage)
        buildComponent :: (ConfiguredComponentMap, LinkedComponentMap,
 Map ComponentId FilePath)
-> Component
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      ElaboratedConfiguredPackage)
buildComponent (ConfiguredComponentMap
cc_map, LinkedComponentMap
lc_map, Map ComponentId FilePath
exe_map) Component
comp =
          Doc
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      ElaboratedConfiguredPackage)
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      ElaboratedConfiguredPackage)
forall a. Doc -> LogProgress a -> LogProgress a
addProgressCtx (FilePath -> Doc
text FilePath
"In the stanza" Doc -> Doc -> Doc
<+>
                          Doc -> Doc
quotes (FilePath -> Doc
text (ComponentName -> FilePath
componentNameStanza ComponentName
cname))) (LogProgress
   ((ConfiguredComponentMap, LinkedComponentMap,
     Map ComponentId FilePath),
    ElaboratedConfiguredPackage)
 -> LogProgress
      ((ConfiguredComponentMap, LinkedComponentMap,
        Map ComponentId FilePath),
       ElaboratedConfiguredPackage))
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      ElaboratedConfiguredPackage)
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      ElaboratedConfiguredPackage)
forall a b. (a -> b) -> a -> b
$ do

            -- 1. Configure the component, but with a place holder ComponentId.
            ConfiguredComponent
cc0 <- PackageDescription
-> ComponentId
-> ConfiguredComponentMap
-> ConfiguredComponentMap
-> Component
-> LogProgress ConfiguredComponent
toConfiguredComponent
                    PackageDescription
pd
                    (FilePath -> ComponentId
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"Distribution.Client.ProjectPlanning.cc_cid: filled in later")
                    ((Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId))
-> ConfiguredComponentMap
-> ConfiguredComponentMap
-> ConfiguredComponentMap
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union ConfiguredComponentMap
external_lib_cc_map ConfiguredComponentMap
cc_map)
                    ((Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId))
-> ConfiguredComponentMap
-> ConfiguredComponentMap
-> ConfiguredComponentMap
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union ConfiguredComponentMap
external_exe_cc_map ConfiguredComponentMap
cc_map)
                    Component
comp


            -- 2. Read out the dependencies from the ConfiguredComponent cc0
            let compLibDependencies :: [ConfiguredId]
compLibDependencies =
                    -- Nub because includes can show up multiple times
                    [ConfiguredId] -> [ConfiguredId]
forall a. Ord a => [a] -> [a]
ordNub ((ComponentInclude ComponentId IncludeRenaming -> ConfiguredId)
-> [ComponentInclude ComponentId IncludeRenaming] -> [ConfiguredId]
forall a b. (a -> b) -> [a] -> [b]
map (AnnotatedId ComponentId -> ConfiguredId
annotatedIdToConfiguredId (AnnotatedId ComponentId -> ConfiguredId)
-> (ComponentInclude ComponentId IncludeRenaming
    -> AnnotatedId ComponentId)
-> ComponentInclude ComponentId IncludeRenaming
-> ConfiguredId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentInclude ComponentId IncludeRenaming
-> AnnotatedId ComponentId
forall id rn. ComponentInclude id rn -> AnnotatedId id
ci_ann_id)
                                (ConfiguredComponent
-> [ComponentInclude ComponentId IncludeRenaming]
cc_includes ConfiguredComponent
cc0))
                compExeDependencies :: [ConfiguredId]
compExeDependencies =
                    (AnnotatedId ComponentId -> ConfiguredId)
-> [AnnotatedId ComponentId] -> [ConfiguredId]
forall a b. (a -> b) -> [a] -> [b]
map AnnotatedId ComponentId -> ConfiguredId
annotatedIdToConfiguredId
                        (ConfiguredComponent -> [AnnotatedId ComponentId]
cc_exe_deps ConfiguredComponent
cc0)
                compExeDependencyPaths :: [(ConfiguredId, FilePath)]
compExeDependencyPaths =
                    [ (AnnotatedId ComponentId -> ConfiguredId
annotatedIdToConfiguredId AnnotatedId ComponentId
aid', FilePath
path)
                    | AnnotatedId ComponentId
aid' <- ConfiguredComponent -> [AnnotatedId ComponentId]
cc_exe_deps ConfiguredComponent
cc0
                    , Just [FilePath]
paths <- [ComponentId -> Map ComponentId [FilePath] -> Maybe [FilePath]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (AnnotatedId ComponentId -> ComponentId
forall id. AnnotatedId id -> id
ann_id AnnotatedId ComponentId
aid') Map ComponentId [FilePath]
exe_map1]
                    , FilePath
path <- [FilePath]
paths ]
                elab_comp :: ElaboratedComponent
elab_comp = ElaboratedComponent :: Component
-> Maybe ComponentName
-> [ConfiguredId]
-> [OpenUnitId]
-> [ConfiguredId]
-> [(PkgconfigName, Maybe PkgconfigVersion)]
-> [(ConfiguredId, FilePath)]
-> [UnitId]
-> ElaboratedComponent
ElaboratedComponent {[(PkgconfigName, Maybe PkgconfigVersion)]
[(ConfiguredId, FilePath)]
[OpenUnitId]
[UnitId]
[ConfiguredId]
Maybe ComponentName
Component
forall a. a
compPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
compSolverName :: Component
compComponentName :: Maybe ComponentName
compOrderLibDependencies :: forall a. a
compLinkedLibDependencies :: forall a. a
compExeDependencyPaths :: [(ConfiguredId, FilePath)]
compExeDependencies :: [ConfiguredId]
compLibDependencies :: [ConfiguredId]
compOrderLibDependencies :: [UnitId]
compExeDependencyPaths :: [(ConfiguredId, FilePath)]
compPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
compExeDependencies :: [ConfiguredId]
compLinkedLibDependencies :: [OpenUnitId]
compLibDependencies :: [ConfiguredId]
compComponentName :: Maybe ComponentName
compSolverName :: Component
..}

            -- 3. Construct a preliminary ElaboratedConfiguredPackage,
            -- and use this to compute the component ID.  Fix up cc_id
            -- correctly.
            let elab1 :: ElaboratedConfiguredPackage
elab1 = ElaboratedConfiguredPackage
elab0 {
                        elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp = ElaboratedComponent -> ElaboratedPackageOrComponent
ElabComponent (ElaboratedComponent -> ElaboratedPackageOrComponent)
-> ElaboratedComponent -> ElaboratedPackageOrComponent
forall a b. (a -> b) -> a -> b
$ ElaboratedComponent
elab_comp
                     }
                cid :: ComponentId
cid = case ElaboratedConfiguredPackage -> BuildStyle
elabBuildStyle ElaboratedConfiguredPackage
elab0 of
                        BuildStyle
BuildInplaceOnly ->
                          FilePath -> ComponentId
mkComponentId (FilePath -> ComponentId) -> FilePath -> ComponentId
forall a b. (a -> b) -> a -> b
$
                            PackageId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow PackageId
pkgid FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ FilePath
"-inplace" FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++
                              (case ComponentName -> Maybe UnqualComponentName
Cabal.componentNameString ComponentName
cname of
                                  Maybe UnqualComponentName
Nothing -> FilePath
""
                                  Just UnqualComponentName
s -> FilePath
"-" FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ UnqualComponentName -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow UnqualComponentName
s)
                        BuildStyle
BuildAndInstall ->
                          PackageHashInputs -> ComponentId
hashedInstalledPackageId
                            (ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> PackageHashInputs
packageHashInputs
                                ElaboratedSharedConfig
elaboratedSharedConfig
                                ElaboratedConfiguredPackage
elab1) -- knot tied
                cc :: ConfiguredComponent
cc = ConfiguredComponent
cc0 { cc_ann_id :: AnnotatedId ComponentId
cc_ann_id = (ComponentId -> ComponentId)
-> AnnotatedId ComponentId -> AnnotatedId ComponentId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ComponentId -> ComponentId -> ComponentId
forall a b. a -> b -> a
const ComponentId
cid) (ConfiguredComponent -> AnnotatedId ComponentId
cc_ann_id ConfiguredComponent
cc0) }
            Doc -> LogProgress ()
infoProgress (Doc -> LogProgress ()) -> Doc -> LogProgress ()
forall a b. (a -> b) -> a -> b
$ ConfiguredComponent -> Doc
dispConfiguredComponent ConfiguredComponent
cc

            -- 4. Perform mix-in linking
            let lookup_uid :: DefUnitId -> FullUnitId
lookup_uid DefUnitId
def_uid =
                    case UnitId -> Map UnitId FullUnitId -> Maybe FullUnitId
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (DefUnitId -> UnitId
unDefUnitId DefUnitId
def_uid) Map UnitId FullUnitId
preexistingInstantiatedPkgs of
                        Just FullUnitId
full -> FullUnitId
full
                        Maybe FullUnitId
Nothing -> FilePath -> FullUnitId
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath
"lookup_uid: " FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ DefUnitId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow DefUnitId
def_uid)
            LinkedComponent
lc <- Verbosity
-> (DefUnitId -> FullUnitId)
-> PackageId
-> LinkedComponentMap
-> ConfiguredComponent
-> LogProgress LinkedComponent
toLinkedComponent Verbosity
verbosity DefUnitId -> FullUnitId
lookup_uid (ElaboratedConfiguredPackage -> PackageId
elabPkgSourceId ElaboratedConfiguredPackage
elab0)
                        (LinkedComponentMap -> LinkedComponentMap -> LinkedComponentMap
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union LinkedComponentMap
external_lc_map LinkedComponentMap
lc_map) ConfiguredComponent
cc
            Doc -> LogProgress ()
infoProgress (Doc -> LogProgress ()) -> Doc -> LogProgress ()
forall a b. (a -> b) -> a -> b
$ LinkedComponent -> Doc
dispLinkedComponent LinkedComponent
lc
            -- NB: elab is setup to be the correct form for an
            -- indefinite library, or a definite library with no holes.
            -- We will modify it in 'instantiateInstallPlan' to handle
            -- instantiated packages.

            -- 5. Construct the final ElaboratedConfiguredPackage
            let
                elab2 :: ElaboratedConfiguredPackage
elab2 = ElaboratedConfiguredPackage
elab1 {
                    elabModuleShape :: ModuleShape
elabModuleShape = LinkedComponent -> ModuleShape
lc_shape LinkedComponent
lc,
                    elabUnitId :: UnitId
elabUnitId      = OpenUnitId -> UnitId
abstractUnitId (LinkedComponent -> OpenUnitId
lc_uid LinkedComponent
lc),
                    elabComponentId :: ComponentId
elabComponentId = LinkedComponent -> ComponentId
lc_cid LinkedComponent
lc,
                    elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabLinkedInstantiatedWith = [(ModuleName, OpenModule)] -> Map ModuleName OpenModule
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (LinkedComponent -> [(ModuleName, OpenModule)]
lc_insts LinkedComponent
lc),
                    elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp = ElaboratedComponent -> ElaboratedPackageOrComponent
ElabComponent (ElaboratedComponent -> ElaboratedPackageOrComponent)
-> ElaboratedComponent -> ElaboratedPackageOrComponent
forall a b. (a -> b) -> a -> b
$ ElaboratedComponent
elab_comp {
                        compLinkedLibDependencies :: [OpenUnitId]
compLinkedLibDependencies = [OpenUnitId] -> [OpenUnitId]
forall a. Ord a => [a] -> [a]
ordNub ((ComponentInclude OpenUnitId ModuleRenaming -> OpenUnitId)
-> [ComponentInclude OpenUnitId ModuleRenaming] -> [OpenUnitId]
forall a b. (a -> b) -> [a] -> [b]
map ComponentInclude OpenUnitId ModuleRenaming -> OpenUnitId
forall id rn. ComponentInclude id rn -> id
ci_id (LinkedComponent -> [ComponentInclude OpenUnitId ModuleRenaming]
lc_includes LinkedComponent
lc)),
                        compOrderLibDependencies :: [UnitId]
compOrderLibDependencies =
                          [UnitId] -> [UnitId]
forall a. Ord a => [a] -> [a]
ordNub ((ComponentInclude OpenUnitId ModuleRenaming -> UnitId)
-> [ComponentInclude OpenUnitId ModuleRenaming] -> [UnitId]
forall a b. (a -> b) -> [a] -> [b]
map (OpenUnitId -> UnitId
abstractUnitId (OpenUnitId -> UnitId)
-> (ComponentInclude OpenUnitId ModuleRenaming -> OpenUnitId)
-> ComponentInclude OpenUnitId ModuleRenaming
-> UnitId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentInclude OpenUnitId ModuleRenaming -> OpenUnitId
forall id rn. ComponentInclude id rn -> id
ci_id)
                                      (LinkedComponent -> [ComponentInclude OpenUnitId ModuleRenaming]
lc_includes LinkedComponent
lc [ComponentInclude OpenUnitId ModuleRenaming]
-> [ComponentInclude OpenUnitId ModuleRenaming]
-> [ComponentInclude OpenUnitId ModuleRenaming]
forall a. [a] -> [a] -> [a]
++ LinkedComponent -> [ComponentInclude OpenUnitId ModuleRenaming]
lc_sig_includes LinkedComponent
lc))
                      }
                   }
                elab :: ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage
elab2 {
                    elabInstallDirs :: InstallDirs FilePath
elabInstallDirs = StoreDirLayout
-> InstallDirTemplates
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> InstallDirs FilePath
computeInstallDirs
                      StoreDirLayout
storeDirLayout
                      InstallDirTemplates
defaultInstallDirs
                      ElaboratedSharedConfig
elaboratedSharedConfig
                      ElaboratedConfiguredPackage
elab2
                   }

            -- 6. Construct the updated local maps
            let cc_map' :: ConfiguredComponentMap
cc_map'  = ConfiguredComponent
-> ConfiguredComponentMap -> ConfiguredComponentMap
extendConfiguredComponentMap ConfiguredComponent
cc ConfiguredComponentMap
cc_map
                lc_map' :: LinkedComponentMap
lc_map'  = LinkedComponent -> LinkedComponentMap -> LinkedComponentMap
extendLinkedComponentMap LinkedComponent
lc LinkedComponentMap
lc_map
                exe_map' :: Map ComponentId FilePath
exe_map' = ComponentId
-> FilePath -> Map ComponentId FilePath -> Map ComponentId FilePath
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ComponentId
cid (ElaboratedConfiguredPackage -> FilePath
inplace_bin_dir ElaboratedConfiguredPackage
elab) Map ComponentId FilePath
exe_map

            ((ConfiguredComponentMap, LinkedComponentMap,
  Map ComponentId FilePath),
 ElaboratedConfiguredPackage)
-> LogProgress
     ((ConfiguredComponentMap, LinkedComponentMap,
       Map ComponentId FilePath),
      ElaboratedConfiguredPackage)
forall (m :: * -> *) a. Monad m => a -> m a
return ((ConfiguredComponentMap
cc_map', LinkedComponentMap
lc_map', Map ComponentId FilePath
exe_map'), ElaboratedConfiguredPackage
elab)
          where
            compLinkedLibDependencies :: a
compLinkedLibDependencies = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"buildComponent: compLinkedLibDependencies"
            compOrderLibDependencies :: a
compOrderLibDependencies = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"buildComponent: compOrderLibDependencies"

            cname :: ComponentName
cname = Component -> ComponentName
Cabal.componentName Component
comp
            compComponentName :: Maybe ComponentName
compComponentName = ComponentName -> Maybe ComponentName
forall a. a -> Maybe a
Just ComponentName
cname
            compSolverName :: Component
compSolverName = ComponentName -> Component
CD.componentNameToComponent ComponentName
cname

            -- NB: compLinkedLibDependencies and
            -- compOrderLibDependencies are defined when we define
            -- 'elab'.
            external_lib_dep_sids :: [SolverId]
external_lib_dep_sids = (Component -> Bool) -> ComponentDeps [SolverId] -> [SolverId]
forall a. Monoid a => (Component -> Bool) -> ComponentDeps a -> a
CD.select (Component -> Component -> Bool
forall a. Eq a => a -> a -> Bool
== Component
compSolverName) ComponentDeps [SolverId]
deps0
            external_exe_dep_sids :: [SolverId]
external_exe_dep_sids = (Component -> Bool) -> ComponentDeps [SolverId] -> [SolverId]
forall a. Monoid a => (Component -> Bool) -> ComponentDeps a -> a
CD.select (Component -> Component -> Bool
forall a. Eq a => a -> a -> Bool
== Component
compSolverName) ComponentDeps [SolverId]
exe_deps0

            external_lib_dep_pkgs :: [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
external_lib_dep_pkgs = (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> [SolverId]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep [SolverId]
external_lib_dep_sids

            -- Combine library and build-tool dependencies, for backwards
            -- compatibility (See issue #5412 and the documentation for
            -- InstallPlan.fromSolverInstallPlan), but prefer the versions
            -- specified as build-tools.
            external_exe_dep_pkgs :: [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
external_exe_dep_pkgs =
                (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> [SolverId]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep ([SolverId]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> [SolverId]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> a -> b
$
                (SolverId -> PackageName) -> [SolverId] -> [SolverId]
forall b a. Ord b => (a -> b) -> [a] -> [a]
ordNubBy (PackageId -> PackageName
pkgName (PackageId -> PackageName)
-> (SolverId -> PackageId) -> SolverId -> PackageName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SolverId -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId) ([SolverId] -> [SolverId]) -> [SolverId] -> [SolverId]
forall a b. (a -> b) -> a -> b
$
                [SolverId]
external_exe_dep_sids [SolverId] -> [SolverId] -> [SolverId]
forall a. [a] -> [a] -> [a]
++ [SolverId]
external_lib_dep_sids

            external_exe_map :: Map ComponentId [FilePath]
external_exe_map = [(ComponentId, [FilePath])] -> Map ComponentId [FilePath]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(ComponentId, [FilePath])] -> Map ComponentId [FilePath])
-> [(ComponentId, [FilePath])] -> Map ComponentId [FilePath]
forall a b. (a -> b) -> a -> b
$
                [ (GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> ComponentId
getComponentId GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg, [FilePath]
paths)
                | GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg <- [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
external_exe_dep_pkgs
                , let paths :: [FilePath]
paths = GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> [FilePath]
planPackageExePaths GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg ]
            exe_map1 :: Map ComponentId [FilePath]
exe_map1 = Map ComponentId [FilePath]
-> Map ComponentId [FilePath] -> Map ComponentId [FilePath]
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map ComponentId [FilePath]
external_exe_map (Map ComponentId [FilePath] -> Map ComponentId [FilePath])
-> Map ComponentId [FilePath] -> Map ComponentId [FilePath]
forall a b. (a -> b) -> a -> b
$ (FilePath -> [FilePath])
-> Map ComponentId FilePath -> Map ComponentId [FilePath]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\FilePath
x -> [FilePath
x]) Map ComponentId FilePath
exe_map

            external_lib_cc_map :: ConfiguredComponentMap
external_lib_cc_map = (Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId))
-> [(PackageName, Map ComponentName (AnnotatedId ComponentId))]
-> ConfiguredComponentMap
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union
                                ([(PackageName, Map ComponentName (AnnotatedId ComponentId))]
 -> ConfiguredComponentMap)
-> [(PackageName, Map ComponentName (AnnotatedId ComponentId))]
-> ConfiguredComponentMap
forall a b. (a -> b) -> a -> b
$ (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> (PackageName, Map ComponentName (AnnotatedId ComponentId)))
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [(PackageName, Map ComponentName (AnnotatedId ComponentId))]
forall a b. (a -> b) -> [a] -> [b]
map GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> (PackageName, Map ComponentName (AnnotatedId ComponentId))
mkCCMapping [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
external_lib_dep_pkgs
            external_exe_cc_map :: ConfiguredComponentMap
external_exe_cc_map = (Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId)
 -> Map ComponentName (AnnotatedId ComponentId))
-> [(PackageName, Map ComponentName (AnnotatedId ComponentId))]
-> ConfiguredComponentMap
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
-> Map ComponentName (AnnotatedId ComponentId)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union
                                ([(PackageName, Map ComponentName (AnnotatedId ComponentId))]
 -> ConfiguredComponentMap)
-> [(PackageName, Map ComponentName (AnnotatedId ComponentId))]
-> ConfiguredComponentMap
forall a b. (a -> b) -> a -> b
$ (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> (PackageName, Map ComponentName (AnnotatedId ComponentId)))
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [(PackageName, Map ComponentName (AnnotatedId ComponentId))]
forall a b. (a -> b) -> [a] -> [b]
map GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> (PackageName, Map ComponentName (AnnotatedId ComponentId))
mkCCMapping [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
external_exe_dep_pkgs
            external_lc_map :: LinkedComponentMap
external_lc_map =
                [(ComponentId, (OpenUnitId, ModuleShape))] -> LinkedComponentMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(ComponentId, (OpenUnitId, ModuleShape))] -> LinkedComponentMap)
-> [(ComponentId, (OpenUnitId, ModuleShape))] -> LinkedComponentMap
forall a b. (a -> b) -> a -> b
$ (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> (ComponentId, (OpenUnitId, ModuleShape)))
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [(ComponentId, (OpenUnitId, ModuleShape))]
forall a b. (a -> b) -> [a] -> [b]
map GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> (ComponentId, (OpenUnitId, ModuleShape))
mkShapeMapping ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [(ComponentId, (OpenUnitId, ModuleShape))])
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [(ComponentId, (OpenUnitId, ModuleShape))]
forall a b. (a -> b) -> a -> b
$
                [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
external_lib_dep_pkgs [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a. [a] -> [a] -> [a]
++ (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> [SolverId]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep [SolverId]
external_exe_dep_sids

            compPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
compPkgConfigDependencies =
                [ (PkgconfigName
pn, Maybe PkgconfigVersion
-> Maybe (Maybe PkgconfigVersion) -> Maybe PkgconfigVersion
forall a. a -> Maybe a -> a
fromMaybe (FilePath -> Maybe PkgconfigVersion
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath -> Maybe PkgconfigVersion)
-> FilePath -> Maybe PkgconfigVersion
forall a b. (a -> b) -> a -> b
$ FilePath
"compPkgConfigDependencies: impossible! "
                                            FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ PkgconfigName -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow PkgconfigName
pn FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ FilePath
" from "
                                            FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ PackageId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow (ElaboratedConfiguredPackage -> PackageId
elabPkgSourceId ElaboratedConfiguredPackage
elab0))
                                 (PkgConfigDb -> PkgconfigName -> Maybe (Maybe PkgconfigVersion)
pkgConfigDbPkgVersion PkgConfigDb
pkgConfigDB PkgconfigName
pn))
                | PkgconfigDependency PkgconfigName
pn PkgconfigVersionRange
_ <- BuildInfo -> [PkgconfigDependency]
PD.pkgconfigDepends
                                                (Component -> BuildInfo
Cabal.componentBuildInfo Component
comp) ]

            inplace_bin_dir :: ElaboratedConfiguredPackage -> FilePath
inplace_bin_dir ElaboratedConfiguredPackage
elab =
                DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> FilePath
-> FilePath
binDirectoryFor
                    DistDirLayout
distDirLayout
                    ElaboratedSharedConfig
elaboratedSharedConfig
                    ElaboratedConfiguredPackage
elab (FilePath -> FilePath) -> FilePath -> FilePath
forall a b. (a -> b) -> a -> b
$
                    case ComponentName -> Maybe UnqualComponentName
Cabal.componentNameString ComponentName
cname of
                             Just UnqualComponentName
n -> UnqualComponentName -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow UnqualComponentName
n
                             Maybe UnqualComponentName
Nothing -> FilePath
""


    -- | Given a 'SolverId' referencing a dependency on a library, return
    -- the 'ElaboratedPlanPackage' corresponding to the library.  This
    -- returns at most one result.
    elaborateLibSolverId :: (SolverId -> [ElaboratedPlanPackage])
                         -> SolverId -> [ElaboratedPlanPackage]
    elaborateLibSolverId :: (SolverId
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
elaborateLibSolverId SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep = (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> Bool)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a. (a -> Bool) -> [a] -> [a]
filter ((ComponentName -> Bool)
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> Bool
matchPlanPkg (ComponentName -> ComponentName -> Bool
forall a. Eq a => a -> a -> Bool
== (LibraryName -> ComponentName
CLibName LibraryName
LMainLibName))) ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> (SolverId
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SolverId
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
mapDep

    -- | Given an 'ElaboratedPlanPackage', return the paths to where the
    -- executables that this package represents would be installed.
    -- The only case where multiple paths can be returned is the inplace
    -- monolithic package one, since there can be multiple exes and each one
    -- has its own directory.
    planPackageExePaths :: ElaboratedPlanPackage -> [FilePath]
    planPackageExePaths :: GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> [FilePath]
planPackageExePaths =
        -- Pre-existing executables are assumed to be in PATH
        -- already.  In fact, this should be impossible.
        (InstalledPackageInfo -> [FilePath])
-> (ElaboratedConfiguredPackage -> [FilePath])
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> [FilePath]
forall ipkg a srcpkg.
(ipkg -> a) -> (srcpkg -> a) -> GenericPlanPackage ipkg srcpkg -> a
InstallPlan.foldPlanPackage ([FilePath] -> InstalledPackageInfo -> [FilePath]
forall a b. a -> b -> a
const []) ((ElaboratedConfiguredPackage -> [FilePath])
 -> GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage
 -> [FilePath])
-> (ElaboratedConfiguredPackage -> [FilePath])
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> [FilePath]
forall a b. (a -> b) -> a -> b
$ \ElaboratedConfiguredPackage
elab ->
            let
              executables :: [FilePath]
              executables :: [FilePath]
executables =
                case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
                    -- Monolithic mode: all exes of the package
                    ElabPackage ElaboratedPackage
_ -> UnqualComponentName -> FilePath
unUnqualComponentName (UnqualComponentName -> FilePath)
-> (Executable -> UnqualComponentName) -> Executable -> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> UnqualComponentName
PD.exeName
                                 (Executable -> FilePath) -> [Executable] -> [FilePath]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackageDescription -> [Executable]
PD.executables (ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
elab)
                    -- Per-component mode: just the selected exe
                    ElabComponent ElaboratedComponent
comp ->
                        case (ComponentName -> Maybe UnqualComponentName)
-> Maybe ComponentName -> Maybe (Maybe UnqualComponentName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ComponentName -> Maybe UnqualComponentName
Cabal.componentNameString
                                  (ElaboratedComponent -> Maybe ComponentName
compComponentName ElaboratedComponent
comp) of
                            Just (Just UnqualComponentName
n) -> [UnqualComponentName -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow UnqualComponentName
n]
                            Maybe (Maybe UnqualComponentName)
_ -> [FilePath
""]
            in
              DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> FilePath
-> FilePath
binDirectoryFor
                 DistDirLayout
distDirLayout
                 ElaboratedSharedConfig
elaboratedSharedConfig
                 ElaboratedConfiguredPackage
elab
                 (FilePath -> FilePath) -> [FilePath] -> [FilePath]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [FilePath]
executables

    elaborateSolverToPackage :: SolverPackage UnresolvedPkgLoc
                             -> ComponentsGraph
                             -> [ElaboratedConfiguredPackage]
                             -> ElaboratedConfiguredPackage
    elaborateSolverToPackage :: SolverPackage (PackageLocation (Maybe FilePath))
-> ComponentsGraph
-> [ElaboratedConfiguredPackage]
-> ElaboratedConfiguredPackage
elaborateSolverToPackage
        pkg :: SolverPackage (PackageLocation (Maybe FilePath))
pkg@(SolverPackage (SourcePackage PackageId
pkgid GenericPackageDescription
_gpd PackageLocation (Maybe FilePath)
_srcloc Maybe CabalFileText
_descOverride)
                           FlagAssignment
_flags OptionalStanzaSet
_stanzas ComponentDeps [SolverId]
_deps0 ComponentDeps [SolverId]
_exe_deps0)
        ComponentsGraph
compGraph [ElaboratedConfiguredPackage]
comps =
        -- Knot tying: the final elab includes the
        -- pkgInstalledId, which is calculated by hashing many
        -- of the other fields of the elaboratedPackage.
        ElaboratedConfiguredPackage
elab
      where
        elab0 :: ElaboratedConfiguredPackage
elab0@ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..} = SolverPackage (PackageLocation (Maybe FilePath))
-> ElaboratedConfiguredPackage
elaborateSolverToCommon SolverPackage (PackageLocation (Maybe FilePath))
pkg
        elab1 :: ElaboratedConfiguredPackage
elab1 = ElaboratedConfiguredPackage
elab0 {
                elabUnitId :: UnitId
elabUnitId = ComponentId -> UnitId
newSimpleUnitId ComponentId
pkgInstalledId,
                elabComponentId :: ComponentId
elabComponentId = ComponentId
pkgInstalledId,
                elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabLinkedInstantiatedWith = Map ModuleName OpenModule
forall k a. Map k a
Map.empty,
                elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp = ElaboratedPackage -> ElaboratedPackageOrComponent
ElabPackage (ElaboratedPackage -> ElaboratedPackageOrComponent)
-> ElaboratedPackage -> ElaboratedPackageOrComponent
forall a b. (a -> b) -> a -> b
$ ElaboratedPackage :: ComponentId
-> ComponentDeps [ConfiguredId]
-> ComponentDeps [()]
-> ComponentDeps [ConfiguredId]
-> ComponentDeps [(ConfiguredId, FilePath)]
-> [(PkgconfigName, Maybe PkgconfigVersion)]
-> OptionalStanzaSet
-> ElaboratedPackage
ElaboratedPackage {[(PkgconfigName, Maybe PkgconfigVersion)]
ComponentId
OptionalStanzaSet
ComponentDeps [()]
ComponentDeps [(ConfiguredId, FilePath)]
ComponentDeps [ConfiguredId]
pkgStanzasEnabled :: OptionalStanzaSet
pkgDependsOnSelfLib :: ComponentDeps [()]
pkgPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
pkgExeDependencyPaths :: ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencies :: ComponentDeps [ConfiguredId]
pkgLibDependencies :: ComponentDeps [ConfiguredId]
pkgInstalledId :: ComponentId
pkgStanzasEnabled :: OptionalStanzaSet
pkgPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
pkgExeDependencyPaths :: ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencies :: ComponentDeps [ConfiguredId]
pkgDependsOnSelfLib :: ComponentDeps [()]
pkgLibDependencies :: ComponentDeps [ConfiguredId]
pkgInstalledId :: ComponentId
..},
                elabModuleShape :: ModuleShape
elabModuleShape = ModuleShape
modShape
            }
        elab :: ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage
elab1 {
                elabInstallDirs :: InstallDirs FilePath
elabInstallDirs =
                  StoreDirLayout
-> InstallDirTemplates
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> InstallDirs FilePath
computeInstallDirs StoreDirLayout
storeDirLayout
                                     InstallDirTemplates
defaultInstallDirs
                                     ElaboratedSharedConfig
elaboratedSharedConfig
                                     ElaboratedConfiguredPackage
elab1
            }

        modShape :: ModuleShape
modShape = case (ElaboratedConfiguredPackage -> Bool)
-> [ElaboratedConfiguredPackage]
-> Maybe ElaboratedConfiguredPackage
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((ComponentName -> Bool) -> ElaboratedConfiguredPackage -> Bool
matchElabPkg (ComponentName -> ComponentName -> Bool
forall a. Eq a => a -> a -> Bool
== (LibraryName -> ComponentName
CLibName LibraryName
LMainLibName))) [ElaboratedConfiguredPackage]
comps of
                        Maybe ElaboratedConfiguredPackage
Nothing -> ModuleShape
emptyModuleShape
                        Just ElaboratedConfiguredPackage
e -> ElaboratedConfiguredPackage -> ModuleShape
Ty.elabModuleShape ElaboratedConfiguredPackage
e

        pkgInstalledId :: ComponentId
pkgInstalledId
          | SolverPackage (PackageLocation (Maybe FilePath)) -> Bool
forall loc. SolverPackage loc -> Bool
shouldBuildInplaceOnly SolverPackage (PackageLocation (Maybe FilePath))
pkg
          = FilePath -> ComponentId
mkComponentId (PackageId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow PackageId
pkgid FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ FilePath
"-inplace")

          | Bool
otherwise
          = Bool -> ComponentId -> ComponentId
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (Maybe PackageSourceHash -> Bool
forall a. Maybe a -> Bool
isJust Maybe PackageSourceHash
elabPkgSourceHash) (ComponentId -> ComponentId) -> ComponentId -> ComponentId
forall a b. (a -> b) -> a -> b
$
            PackageHashInputs -> ComponentId
hashedInstalledPackageId
              (ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> PackageHashInputs
packageHashInputs
                ElaboratedSharedConfig
elaboratedSharedConfig
                ElaboratedConfiguredPackage
elab)  -- recursive use of elab

        -- Need to filter out internal dependencies, because they don't
        -- correspond to anything real anymore.
        isExt :: ConfiguredId -> Bool
isExt ConfiguredId
confid = ConfiguredId -> PackageId
confSrcId ConfiguredId
confid PackageId -> PackageId -> Bool
forall a. Eq a => a -> a -> Bool
/= PackageId
pkgid
        filterExt :: [ConfiguredId] -> [ConfiguredId]
filterExt  = (ConfiguredId -> Bool) -> [ConfiguredId] -> [ConfiguredId]
forall a. (a -> Bool) -> [a] -> [a]
filter ConfiguredId -> Bool
isExt
        filterExt' :: [(ConfiguredId, b)] -> [(ConfiguredId, b)]
filterExt' = ((ConfiguredId, b) -> Bool)
-> [(ConfiguredId, b)] -> [(ConfiguredId, b)]
forall a. (a -> Bool) -> [a] -> [a]
filter (ConfiguredId -> Bool
isExt (ConfiguredId -> Bool)
-> ((ConfiguredId, b) -> ConfiguredId) -> (ConfiguredId, b) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ConfiguredId, b) -> ConfiguredId
forall a b. (a, b) -> a
fst)

        pkgLibDependencies :: ComponentDeps [ConfiguredId]
pkgLibDependencies
            = (ElaboratedComponent -> [ConfiguredId])
-> ComponentDeps [ConfiguredId]
forall a. Monoid a => (ElaboratedComponent -> a) -> ComponentDeps a
buildComponentDeps ([ConfiguredId] -> [ConfiguredId]
filterExt  ([ConfiguredId] -> [ConfiguredId])
-> (ElaboratedComponent -> [ConfiguredId])
-> ElaboratedComponent
-> [ConfiguredId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedComponent -> [ConfiguredId]
compLibDependencies)
        pkgExeDependencies :: ComponentDeps [ConfiguredId]
pkgExeDependencies
            = (ElaboratedComponent -> [ConfiguredId])
-> ComponentDeps [ConfiguredId]
forall a. Monoid a => (ElaboratedComponent -> a) -> ComponentDeps a
buildComponentDeps ([ConfiguredId] -> [ConfiguredId]
filterExt  ([ConfiguredId] -> [ConfiguredId])
-> (ElaboratedComponent -> [ConfiguredId])
-> ElaboratedComponent
-> [ConfiguredId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedComponent -> [ConfiguredId]
compExeDependencies)
        pkgExeDependencyPaths :: ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencyPaths
            = (ElaboratedComponent -> [(ConfiguredId, FilePath)])
-> ComponentDeps [(ConfiguredId, FilePath)]
forall a. Monoid a => (ElaboratedComponent -> a) -> ComponentDeps a
buildComponentDeps ([(ConfiguredId, FilePath)] -> [(ConfiguredId, FilePath)]
forall b. [(ConfiguredId, b)] -> [(ConfiguredId, b)]
filterExt' ([(ConfiguredId, FilePath)] -> [(ConfiguredId, FilePath)])
-> (ElaboratedComponent -> [(ConfiguredId, FilePath)])
-> ElaboratedComponent
-> [(ConfiguredId, FilePath)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedComponent -> [(ConfiguredId, FilePath)]
compExeDependencyPaths)
        -- TODO: Why is this flat?
        pkgPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
pkgPkgConfigDependencies
            = ComponentDeps [(PkgconfigName, Maybe PkgconfigVersion)]
-> [(PkgconfigName, Maybe PkgconfigVersion)]
forall a. Monoid a => ComponentDeps a -> a
CD.flatDeps (ComponentDeps [(PkgconfigName, Maybe PkgconfigVersion)]
 -> [(PkgconfigName, Maybe PkgconfigVersion)])
-> ComponentDeps [(PkgconfigName, Maybe PkgconfigVersion)]
-> [(PkgconfigName, Maybe PkgconfigVersion)]
forall a b. (a -> b) -> a -> b
$ (ElaboratedComponent -> [(PkgconfigName, Maybe PkgconfigVersion)])
-> ComponentDeps [(PkgconfigName, Maybe PkgconfigVersion)]
forall a. Monoid a => (ElaboratedComponent -> a) -> ComponentDeps a
buildComponentDeps ElaboratedComponent -> [(PkgconfigName, Maybe PkgconfigVersion)]
compPkgConfigDependencies

        pkgDependsOnSelfLib :: ComponentDeps [()]
pkgDependsOnSelfLib
            = [ComponentDep [()]] -> ComponentDeps [()]
forall a. Monoid a => [ComponentDep a] -> ComponentDeps a
CD.fromList [ (ComponentName -> Component
CD.componentNameToComponent ComponentName
cn, [()])
                          | Graph.N Component
_ ComponentName
cn [ComponentName]
_ <- [Node ComponentName Component]
-> Maybe [Node ComponentName Component]
-> [Node ComponentName Component]
forall a. a -> Maybe a -> a
fromMaybe [] Maybe [Node ComponentName Component]
mb_closure ]
          where
            mb_closure :: Maybe [Node ComponentName Component]
mb_closure = ComponentsGraph
-> [Key (Node ComponentName Component)]
-> Maybe [Node ComponentName Component]
forall a. Graph a -> [Key a] -> Maybe [a]
Graph.revClosure ComponentsGraph
compGraph [ ComponentName
Key (Node ComponentName Component)
k | ComponentName
k <- ComponentsGraph -> [Key (Node ComponentName Component)]
forall a. Graph a -> [Key a]
Graph.keys ComponentsGraph
compGraph, ComponentName -> Bool
is_lib ComponentName
k ]
            -- NB: the sublib case should not occur, because sub-libraries
            -- are not supported without per-component builds
            is_lib :: ComponentName -> Bool
is_lib (CLibName LibraryName
_) = Bool
True
            is_lib ComponentName
_ = Bool
False

        buildComponentDeps :: (ElaboratedComponent -> a) -> ComponentDeps a
buildComponentDeps ElaboratedComponent -> a
f
            = [ComponentDep a] -> ComponentDeps a
forall a. Monoid a => [ComponentDep a] -> ComponentDeps a
CD.fromList [ (ElaboratedComponent -> Component
compSolverName ElaboratedComponent
comp, ElaboratedComponent -> a
f ElaboratedComponent
comp)
                          | ElaboratedConfiguredPackage{
                                elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabComponent ElaboratedComponent
comp
                            } <- [ElaboratedConfiguredPackage]
comps
                          ]

        -- NB: This is not the final setting of 'pkgStanzasEnabled'.
        -- See [Sticky enabled testsuites]; we may enable some extra
        -- stanzas opportunistically when it is cheap to do so.
        --
        -- However, we start off by enabling everything that was
        -- requested, so that we can maintain an invariant that
        -- pkgStanzasEnabled is a superset of elabStanzasRequested
        pkgStanzasEnabled :: OptionalStanzaSet
pkgStanzasEnabled  = (Maybe Bool -> Bool)
-> OptionalStanzaMap (Maybe Bool) -> OptionalStanzaSet
forall a. (a -> Bool) -> OptionalStanzaMap a -> OptionalStanzaSet
optStanzaKeysFilteredByValue (Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False) OptionalStanzaMap (Maybe Bool)
elabStanzasRequested

    elaborateSolverToCommon :: SolverPackage UnresolvedPkgLoc
                            -> ElaboratedConfiguredPackage
    elaborateSolverToCommon :: SolverPackage (PackageLocation (Maybe FilePath))
-> ElaboratedConfiguredPackage
elaborateSolverToCommon
        pkg :: SolverPackage (PackageLocation (Maybe FilePath))
pkg@(SolverPackage (SourcePackage PackageId
pkgid GenericPackageDescription
gdesc PackageLocation (Maybe FilePath)
srcloc Maybe CabalFileText
descOverride)
                           FlagAssignment
flags OptionalStanzaSet
stanzas ComponentDeps [SolverId]
deps0 ComponentDeps [SolverId]
_exe_deps0) =
        ElaboratedConfiguredPackage
elaboratedPackage
      where
        elaboratedPackage :: ElaboratedConfiguredPackage
elaboratedPackage = ElaboratedConfiguredPackage :: UnitId
-> ComponentId
-> Map ModuleName Module
-> Map ModuleName OpenModule
-> Bool
-> PackageId
-> ModuleShape
-> FlagAssignment
-> FlagAssignment
-> PackageDescription
-> PackageLocation (Maybe FilePath)
-> Maybe PackageSourceHash
-> Bool
-> BuildStyle
-> ComponentRequestedSpec
-> OptionalStanzaSet
-> OptionalStanzaMap (Maybe Bool)
-> [Maybe PackageDB]
-> PackageDBStack
-> PackageDBStack
-> PackageDBStack
-> PackageDBStack
-> PackageDBStack
-> PackageDBStack
-> Maybe CabalFileText
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ProfDetailLevel
-> ProfDetailLevel
-> Bool
-> OptimisationLevel
-> Bool
-> Bool
-> Bool
-> Bool
-> DebugInfoLevel
-> DumpBuildInfo
-> Map FilePath FilePath
-> Map FilePath [FilePath]
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> Maybe PathTemplate
-> Maybe PathTemplate
-> InstallDirs FilePath
-> Bool
-> Bool
-> Maybe FilePath
-> Bool
-> HaddockTarget
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe FilePath
-> Bool
-> Bool
-> Maybe FilePath
-> Maybe PathTemplate
-> Maybe PathTemplate
-> Maybe PathTemplate
-> Maybe TestShowDetails
-> Bool
-> Maybe FilePath
-> Bool
-> [PathTemplate]
-> [PathTemplate]
-> SetupScriptStyle
-> Version
-> [ComponentTarget]
-> [ComponentTarget]
-> [ComponentTarget]
-> [ComponentTarget]
-> Maybe ComponentTarget
-> [ComponentTarget]
-> Bool
-> ElaboratedPackageOrComponent
-> ElaboratedConfiguredPackage
ElaboratedConfiguredPackage {Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
forall a. a
forall a. [a]
forall a. Maybe a
forall k a. Map k a
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfLibDetail :: ProfDetailLevel
elabProfExeDetail :: ProfDetailLevel
elabProfLib :: Bool
elabProfExe :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceSetupPackageDBStack :: PackageDBStack
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabBuildHaddocks :: Bool
elabHaddockTargets :: forall a. [a]
elabReplTarget :: forall a. Maybe a
elabBenchTargets :: forall a. [a]
elabTestTargets :: forall a. [a]
elabBuildTargets :: forall a. [a]
elabConfigureTargets :: forall a. [a]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabPkgDescription :: PackageDescription
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabModuleShape :: forall a. a
elabInstallDirs :: forall a. a
elabPkgOrComp :: forall a. a
elabLinkedInstantiatedWith :: forall a. a
elabInstantiatedWith :: forall k a. Map k a
elabComponentId :: forall a. a
elabUnitId :: forall a. a
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
..}

        -- These get filled in later
        elabUnitId :: a
elabUnitId          = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"elaborateSolverToCommon: elabUnitId"
        elabComponentId :: a
elabComponentId     = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"elaborateSolverToCommon: elabComponentId"
        elabInstantiatedWith :: Map k a
elabInstantiatedWith = Map k a
forall k a. Map k a
Map.empty
        elabLinkedInstantiatedWith :: a
elabLinkedInstantiatedWith = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"elaborateSolverToCommon: elabLinkedInstantiatedWith"
        elabPkgOrComp :: a
elabPkgOrComp       = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"elaborateSolverToCommon: elabPkgOrComp"
        elabInstallDirs :: a
elabInstallDirs     = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"elaborateSolverToCommon: elabInstallDirs"
        elabModuleShape :: a
elabModuleShape     = FilePath -> a
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"elaborateSolverToCommon: elabModuleShape"

        elabIsCanonical :: Bool
elabIsCanonical     = Bool
True
        elabPkgSourceId :: PackageId
elabPkgSourceId     = PackageId
pkgid
        elabPkgDescription :: PackageDescription
elabPkgDescription  = case FlagAssignment
-> ComponentRequestedSpec
-> (Dependency -> Bool)
-> Platform
-> CompilerInfo
-> [PackageVersionConstraint]
-> GenericPackageDescription
-> Either [Dependency] (PackageDescription, FlagAssignment)
PD.finalizePD
                                    FlagAssignment
flags ComponentRequestedSpec
elabEnabledSpec (Bool -> Dependency -> Bool
forall a b. a -> b -> a
const Bool
True)
                                    Platform
platform (Compiler -> CompilerInfo
compilerInfo Compiler
compiler)
                                    [] GenericPackageDescription
gdesc of
                               Right (PackageDescription
desc, FlagAssignment
_) -> PackageDescription
desc
                               Left [Dependency]
_          -> FilePath -> PackageDescription
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"Failed to finalizePD in elaborateSolverToCommon"
        elabFlagAssignment :: FlagAssignment
elabFlagAssignment  = FlagAssignment
flags
        elabFlagDefaults :: FlagAssignment
elabFlagDefaults    = [(FlagName, Bool)] -> FlagAssignment
PD.mkFlagAssignment
                              [ (PackageFlag -> FlagName
Cabal.flagName PackageFlag
flag, PackageFlag -> Bool
Cabal.flagDefault PackageFlag
flag)
                              | PackageFlag
flag <- GenericPackageDescription -> [PackageFlag]
PD.genPackageFlags GenericPackageDescription
gdesc ]

        elabEnabledSpec :: ComponentRequestedSpec
elabEnabledSpec      = OptionalStanzaSet -> ComponentRequestedSpec
enableStanzas OptionalStanzaSet
stanzas
        elabStanzasAvailable :: OptionalStanzaSet
elabStanzasAvailable = OptionalStanzaSet
stanzas

        elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
        elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasRequested = (OptionalStanza -> Maybe Bool) -> OptionalStanzaMap (Maybe Bool)
forall a. (OptionalStanza -> a) -> OptionalStanzaMap a
optStanzaTabulate ((OptionalStanza -> Maybe Bool) -> OptionalStanzaMap (Maybe Bool))
-> (OptionalStanza -> Maybe Bool) -> OptionalStanzaMap (Maybe Bool)
forall a b. (a -> b) -> a -> b
$ \OptionalStanza
o -> case OptionalStanza
o of
            -- NB: even if a package stanza is requested, if the package
            -- doesn't actually have any of that stanza we omit it from
            -- the request, to ensure that we don't decide that this
            -- package needs to be rebuilt.  (It needs to be done here,
            -- because the ElaboratedConfiguredPackage is where we test
            -- whether or not there have been changes.)
            OptionalStanza
TestStanzas  -> [Bool] -> Maybe Bool
forall a. [a] -> Maybe a
listToMaybe [ Bool
v | Bool
v <- Maybe Bool -> [Bool]
forall a. Maybe a -> [a]
maybeToList Maybe Bool
tests, TestSuite
_ <- PackageDescription -> [TestSuite]
PD.testSuites PackageDescription
elabPkgDescription ]
            OptionalStanza
BenchStanzas -> [Bool] -> Maybe Bool
forall a. [a] -> Maybe a
listToMaybe [ Bool
v | Bool
v <- Maybe Bool -> [Bool]
forall a. Maybe a -> [a]
maybeToList Maybe Bool
benchmarks, Benchmark
_ <- PackageDescription -> [Benchmark]
PD.benchmarks PackageDescription
elabPkgDescription ]
          where
            tests, benchmarks :: Maybe Bool
            tests :: Maybe Bool
tests      = PackageId -> (PackageConfig -> Flag Bool) -> Maybe Bool
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag Bool
packageConfigTests
            benchmarks :: Maybe Bool
benchmarks = PackageId -> (PackageConfig -> Flag Bool) -> Maybe Bool
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag Bool
packageConfigBenchmarks

        -- This is a placeholder which will get updated by 'pruneInstallPlanPass1'
        -- and 'pruneInstallPlanPass2'.  We can't populate it here
        -- because whether or not tests/benchmarks should be enabled
        -- is heuristically calculated based on whether or not the
        -- dependencies of the test suite have already been installed,
        -- but this function doesn't know what is installed (since
        -- we haven't improved the plan yet), so we do it in another pass.
        -- Check the comments of those functions for more details.
        elabConfigureTargets :: [a]
elabConfigureTargets = []
        elabBuildTargets :: [a]
elabBuildTargets    = []
        elabTestTargets :: [a]
elabTestTargets     = []
        elabBenchTargets :: [a]
elabBenchTargets    = []
        elabReplTarget :: Maybe a
elabReplTarget      = Maybe a
forall a. Maybe a
Nothing
        elabHaddockTargets :: [a]
elabHaddockTargets  = []

        elabBuildHaddocks :: Bool
elabBuildHaddocks   =
          PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigDocumentation

        elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgSourceLocation = PackageLocation (Maybe FilePath)
srcloc
        elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceHash   = PackageId
-> Map PackageId PackageSourceHash -> Maybe PackageSourceHash
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup PackageId
pkgid Map PackageId PackageSourceHash
sourcePackageHashes
        elabLocalToProject :: Bool
elabLocalToProject  = SolverPackage (PackageLocation (Maybe FilePath)) -> Bool
forall pkg. Package pkg => pkg -> Bool
isLocalToProject SolverPackage (PackageLocation (Maybe FilePath))
pkg
        elabBuildStyle :: BuildStyle
elabBuildStyle      = if SolverPackage (PackageLocation (Maybe FilePath)) -> Bool
forall loc. SolverPackage loc -> Bool
shouldBuildInplaceOnly SolverPackage (PackageLocation (Maybe FilePath))
pkg
                                then BuildStyle
BuildInplaceOnly else BuildStyle
BuildAndInstall
        elabPackageDbs :: [Maybe PackageDB]
elabPackageDbs             = ProjectConfigShared -> [Maybe PackageDB]
projectConfigPackageDBs ProjectConfigShared
sharedPackageConfig
        elabBuildPackageDBStack :: PackageDBStack
elabBuildPackageDBStack    = PackageDBStack
buildAndRegisterDbs
        elabRegisterPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack = PackageDBStack
buildAndRegisterDbs

        elabSetupScriptStyle :: SetupScriptStyle
elabSetupScriptStyle       = PackageDescription -> SetupScriptStyle
packageSetupScriptStyle PackageDescription
elabPkgDescription
        elabSetupScriptCliVersion :: Version
elabSetupScriptCliVersion  =
          SetupScriptStyle
-> PackageDescription
-> Graph NonSetupLibDepSolverPlanPackage
-> ComponentDeps [SolverId]
-> Version
packageSetupScriptSpecVersion
          SetupScriptStyle
elabSetupScriptStyle PackageDescription
elabPkgDescription Graph NonSetupLibDepSolverPlanPackage
libDepGraph ComponentDeps [SolverId]
deps0
        elabSetupPackageDBStack :: PackageDBStack
elabSetupPackageDBStack    = PackageDBStack
buildAndRegisterDbs

        elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack = PackageDBStack
inplacePackageDbs
        elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceRegisterPackageDBStack = PackageDBStack
inplacePackageDbs
        elabInplaceSetupPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack = PackageDBStack
inplacePackageDbs

        buildAndRegisterDbs :: PackageDBStack
buildAndRegisterDbs
          | SolverPackage (PackageLocation (Maybe FilePath)) -> Bool
forall loc. SolverPackage loc -> Bool
shouldBuildInplaceOnly SolverPackage (PackageLocation (Maybe FilePath))
pkg = PackageDBStack
inplacePackageDbs
          | Bool
otherwise                  = PackageDBStack
corePackageDbs

        elabPkgDescriptionOverride :: Maybe CabalFileText
elabPkgDescriptionOverride = Maybe CabalFileText
descOverride

        elabVanillaLib :: Bool
elabVanillaLib    = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
True PackageConfig -> Flag Bool
packageConfigVanillaLib --TODO: [required feature]: also needs to be handled recursively
        elabSharedLib :: Bool
elabSharedLib     = PackageId
pkgid PackageId -> Set PackageId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set PackageId
pkgsUseSharedLibrary
        elabStaticLib :: Bool
elabStaticLib     = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigStaticLib
        elabDynExe :: Bool
elabDynExe        = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigDynExe
        elabFullyStaticExe :: Bool
elabFullyStaticExe = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigFullyStaticExe
        elabGHCiLib :: Bool
elabGHCiLib       = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigGHCiLib --TODO: [required feature] needs to default to enabled on windows still

        elabProfExe :: Bool
elabProfExe       = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigProf
        elabProfLib :: Bool
elabProfLib       = PackageId
pkgid PackageId -> Set PackageId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set PackageId
pkgsUseProfilingLibrary

        (ProfDetailLevel
elabProfExeDetail,
         ProfDetailLevel
elabProfLibDetail) = PackageId
-> ProfDetailLevel
-> (PackageConfig -> Flag ProfDetailLevel)
-> (PackageConfig -> Flag ProfDetailLevel)
-> (ProfDetailLevel, ProfDetailLevel)
forall pkg a.
Package pkg =>
pkg
-> a
-> (PackageConfig -> Flag a)
-> (PackageConfig -> Flag a)
-> (a, a)
perPkgOptionLibExeFlag PackageId
pkgid ProfDetailLevel
ProfDetailDefault
                               PackageConfig -> Flag ProfDetailLevel
packageConfigProfDetail
                               PackageConfig -> Flag ProfDetailLevel
packageConfigProfLibDetail
        elabCoverage :: Bool
elabCoverage      = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigCoverage

        elabOptimization :: OptimisationLevel
elabOptimization  = PackageId
-> OptimisationLevel
-> (PackageConfig -> Flag OptimisationLevel)
-> OptimisationLevel
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid OptimisationLevel
NormalOptimisation PackageConfig -> Flag OptimisationLevel
packageConfigOptimization
        elabSplitObjs :: Bool
elabSplitObjs     = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigSplitObjs
        elabSplitSections :: Bool
elabSplitSections = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigSplitSections
        elabStripLibs :: Bool
elabStripLibs     = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigStripLibs
        elabStripExes :: Bool
elabStripExes     = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigStripExes
        elabDebugInfo :: DebugInfoLevel
elabDebugInfo     = PackageId
-> DebugInfoLevel
-> (PackageConfig -> Flag DebugInfoLevel)
-> DebugInfoLevel
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid DebugInfoLevel
NoDebugInfo PackageConfig -> Flag DebugInfoLevel
packageConfigDebugInfo
        elabDumpBuildInfo :: DumpBuildInfo
elabDumpBuildInfo = PackageId
-> DumpBuildInfo
-> (PackageConfig -> Flag DumpBuildInfo)
-> DumpBuildInfo
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid DumpBuildInfo
NoDumpBuildInfo PackageConfig -> Flag DumpBuildInfo
packageConfigDumpBuildInfo

        -- Combine the configured compiler prog settings with the user-supplied
        -- config. For the compiler progs any user-supplied config was taken
        -- into account earlier when configuring the compiler so its ok that
        -- our configured settings for the compiler override the user-supplied
        -- config here.
        elabProgramPaths :: Map FilePath FilePath
elabProgramPaths  = [(FilePath, FilePath)] -> Map FilePath FilePath
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
                             [ (ConfiguredProgram -> FilePath
programId ConfiguredProgram
prog, ConfiguredProgram -> FilePath
programPath ConfiguredProgram
prog)
                             | ConfiguredProgram
prog <- ProgramDb -> [ConfiguredProgram]
configuredPrograms ProgramDb
compilerprogdb ]
                        Map FilePath FilePath
-> Map FilePath FilePath -> Map FilePath FilePath
forall a. Semigroup a => a -> a -> a
<> PackageId
-> (PackageConfig -> MapLast FilePath FilePath)
-> Map FilePath FilePath
forall pkg k v.
(Package pkg, Ord k) =>
pkg -> (PackageConfig -> MapLast k v) -> Map k v
perPkgOptionMapLast PackageId
pkgid PackageConfig -> MapLast FilePath FilePath
packageConfigProgramPaths
        elabProgramArgs :: Map FilePath [FilePath]
elabProgramArgs   = [(FilePath, [FilePath])] -> Map FilePath [FilePath]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
                             [ (ConfiguredProgram -> FilePath
programId ConfiguredProgram
prog, [FilePath]
args)
                             | ConfiguredProgram
prog <- ProgramDb -> [ConfiguredProgram]
configuredPrograms ProgramDb
compilerprogdb
                             , let args :: [FilePath]
args = ConfiguredProgram -> [FilePath]
programOverrideArgs ConfiguredProgram
prog
                             , Bool -> Bool
not ([FilePath] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [FilePath]
args)
                             ]
                        Map FilePath [FilePath]
-> Map FilePath [FilePath] -> Map FilePath [FilePath]
forall a. Semigroup a => a -> a -> a
<> PackageId
-> (PackageConfig -> MapMappend FilePath [FilePath])
-> Map FilePath [FilePath]
forall pkg v k.
(Package pkg, Semigroup v, Ord k) =>
pkg -> (PackageConfig -> MapMappend k v) -> Map k v
perPkgOptionMapMappend PackageId
pkgid PackageConfig -> MapMappend FilePath [FilePath]
packageConfigProgramArgs
        elabProgramPathExtra :: [FilePath]
elabProgramPathExtra    = PackageId -> (PackageConfig -> NubList FilePath) -> [FilePath]
forall pkg a.
(Package pkg, Ord a) =>
pkg -> (PackageConfig -> NubList a) -> [a]
perPkgOptionNubList PackageId
pkgid PackageConfig -> NubList FilePath
packageConfigProgramPathExtra
        elabConfigureScriptArgs :: [FilePath]
elabConfigureScriptArgs = PackageId -> (PackageConfig -> [FilePath]) -> [FilePath]
forall a. PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList PackageId
pkgid PackageConfig -> [FilePath]
packageConfigConfigureArgs
        elabExtraLibDirs :: [FilePath]
elabExtraLibDirs        = PackageId -> (PackageConfig -> [FilePath]) -> [FilePath]
forall a. PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList PackageId
pkgid PackageConfig -> [FilePath]
packageConfigExtraLibDirs
        elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirsStatic  = PackageId -> (PackageConfig -> [FilePath]) -> [FilePath]
forall a. PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList PackageId
pkgid PackageConfig -> [FilePath]
packageConfigExtraLibDirsStatic
        elabExtraFrameworkDirs :: [FilePath]
elabExtraFrameworkDirs  = PackageId -> (PackageConfig -> [FilePath]) -> [FilePath]
forall a. PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList PackageId
pkgid PackageConfig -> [FilePath]
packageConfigExtraFrameworkDirs
        elabExtraIncludeDirs :: [FilePath]
elabExtraIncludeDirs    = PackageId -> (PackageConfig -> [FilePath]) -> [FilePath]
forall a. PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList PackageId
pkgid PackageConfig -> [FilePath]
packageConfigExtraIncludeDirs
        elabProgPrefix :: Maybe PathTemplate
elabProgPrefix          = PackageId
-> (PackageConfig -> Flag PathTemplate) -> Maybe PathTemplate
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag PathTemplate
packageConfigProgPrefix
        elabProgSuffix :: Maybe PathTemplate
elabProgSuffix          = PackageId
-> (PackageConfig -> Flag PathTemplate) -> Maybe PathTemplate
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag PathTemplate
packageConfigProgSuffix


        elabHaddockHoogle :: Bool
elabHaddockHoogle       = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockHoogle
        elabHaddockHtml :: Bool
elabHaddockHtml         = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockHtml
        elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtmlLocation = PackageId -> (PackageConfig -> Flag FilePath) -> Maybe FilePath
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag FilePath
packageConfigHaddockHtmlLocation
        elabHaddockForeignLibs :: Bool
elabHaddockForeignLibs  = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockForeignLibs
        elabHaddockForHackage :: HaddockTarget
elabHaddockForHackage   = PackageId
-> HaddockTarget
-> (PackageConfig -> Flag HaddockTarget)
-> HaddockTarget
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid HaddockTarget
Cabal.ForDevelopment PackageConfig -> Flag HaddockTarget
packageConfigHaddockForHackage
        elabHaddockExecutables :: Bool
elabHaddockExecutables  = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockExecutables
        elabHaddockTestSuites :: Bool
elabHaddockTestSuites   = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockTestSuites
        elabHaddockBenchmarks :: Bool
elabHaddockBenchmarks   = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockBenchmarks
        elabHaddockInternal :: Bool
elabHaddockInternal     = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockInternal
        elabHaddockCss :: Maybe FilePath
elabHaddockCss          = PackageId -> (PackageConfig -> Flag FilePath) -> Maybe FilePath
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag FilePath
packageConfigHaddockCss
        elabHaddockLinkedSource :: Bool
elabHaddockLinkedSource = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockLinkedSource
        elabHaddockQuickJump :: Bool
elabHaddockQuickJump    = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigHaddockQuickJump
        elabHaddockHscolourCss :: Maybe FilePath
elabHaddockHscolourCss  = PackageId -> (PackageConfig -> Flag FilePath) -> Maybe FilePath
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag FilePath
packageConfigHaddockHscolourCss
        elabHaddockContents :: Maybe PathTemplate
elabHaddockContents     = PackageId
-> (PackageConfig -> Flag PathTemplate) -> Maybe PathTemplate
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag PathTemplate
packageConfigHaddockContents

        elabTestMachineLog :: Maybe PathTemplate
elabTestMachineLog      = PackageId
-> (PackageConfig -> Flag PathTemplate) -> Maybe PathTemplate
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag PathTemplate
packageConfigTestMachineLog
        elabTestHumanLog :: Maybe PathTemplate
elabTestHumanLog        = PackageId
-> (PackageConfig -> Flag PathTemplate) -> Maybe PathTemplate
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag PathTemplate
packageConfigTestHumanLog
        elabTestShowDetails :: Maybe TestShowDetails
elabTestShowDetails     = PackageId
-> (PackageConfig -> Flag TestShowDetails) -> Maybe TestShowDetails
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag TestShowDetails
packageConfigTestShowDetails
        elabTestKeepTix :: Bool
elabTestKeepTix         = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigTestKeepTix
        elabTestWrapper :: Maybe FilePath
elabTestWrapper         = PackageId -> (PackageConfig -> Flag FilePath) -> Maybe FilePath
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag FilePath
packageConfigTestWrapper
        elabTestFailWhenNoTestSuites :: Bool
elabTestFailWhenNoTestSuites = PackageId -> Bool -> (PackageConfig -> Flag Bool) -> Bool
forall a. PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag PackageId
pkgid Bool
False PackageConfig -> Flag Bool
packageConfigTestFailWhenNoTestSuites
        elabTestTestOptions :: [PathTemplate]
elabTestTestOptions     = PackageId -> (PackageConfig -> [PathTemplate]) -> [PathTemplate]
forall a. PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList PackageId
pkgid PackageConfig -> [PathTemplate]
packageConfigTestTestOptions

        elabBenchmarkOptions :: [PathTemplate]
elabBenchmarkOptions    = PackageId -> (PackageConfig -> [PathTemplate]) -> [PathTemplate]
forall a. PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList PackageId
pkgid PackageConfig -> [PathTemplate]
packageConfigBenchmarkOptions

    perPkgOptionFlag  :: PackageId -> a ->  (PackageConfig -> Flag a) -> a
    perPkgOptionMaybe :: PackageId ->       (PackageConfig -> Flag a) -> Maybe a
    perPkgOptionList  :: PackageId ->       (PackageConfig -> [a])    -> [a]

    perPkgOptionFlag :: PackageId -> a -> (PackageConfig -> Flag a) -> a
perPkgOptionFlag  PackageId
pkgid a
def PackageConfig -> Flag a
f = a -> Flag a -> a
forall a. a -> Flag a -> a
fromFlagOrDefault a
def (PackageId -> (PackageConfig -> Flag a) -> Flag a
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption PackageId
pkgid PackageConfig -> Flag a
f)
    perPkgOptionMaybe :: PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid     PackageConfig -> Flag a
f = Flag a -> Maybe a
forall a. Flag a -> Maybe a
flagToMaybe (PackageId -> (PackageConfig -> Flag a) -> Flag a
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption PackageId
pkgid PackageConfig -> Flag a
f)
    perPkgOptionList :: PackageId -> (PackageConfig -> [a]) -> [a]
perPkgOptionList  PackageId
pkgid     PackageConfig -> [a]
f = PackageId -> (PackageConfig -> [a]) -> [a]
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption PackageId
pkgid PackageConfig -> [a]
f
    perPkgOptionNubList :: pkg -> (PackageConfig -> NubList a) -> [a]
perPkgOptionNubList    pkg
pkgid PackageConfig -> NubList a
f = NubList a -> [a]
forall a. NubList a -> [a]
fromNubList   (pkg -> (PackageConfig -> NubList a) -> NubList a
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption pkg
pkgid PackageConfig -> NubList a
f)
    perPkgOptionMapLast :: pkg -> (PackageConfig -> MapLast k v) -> Map k v
perPkgOptionMapLast    pkg
pkgid PackageConfig -> MapLast k v
f = MapLast k v -> Map k v
forall k v. MapLast k v -> Map k v
getMapLast    (pkg -> (PackageConfig -> MapLast k v) -> MapLast k v
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption pkg
pkgid PackageConfig -> MapLast k v
f)
    perPkgOptionMapMappend :: pkg -> (PackageConfig -> MapMappend k v) -> Map k v
perPkgOptionMapMappend pkg
pkgid PackageConfig -> MapMappend k v
f = MapMappend k v -> Map k v
forall k v. MapMappend k v -> Map k v
getMapMappend (pkg -> (PackageConfig -> MapMappend k v) -> MapMappend k v
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption pkg
pkgid PackageConfig -> MapMappend k v
f)

    perPkgOptionLibExeFlag :: pkg
-> a
-> (PackageConfig -> Flag a)
-> (PackageConfig -> Flag a)
-> (a, a)
perPkgOptionLibExeFlag pkg
pkgid a
def PackageConfig -> Flag a
fboth PackageConfig -> Flag a
flib = (a
exe, a
lib)
      where
        exe :: a
exe = a -> Flag a -> a
forall a. a -> Flag a -> a
fromFlagOrDefault a
def Flag a
bothflag
        lib :: a
lib = a -> Flag a -> a
forall a. a -> Flag a -> a
fromFlagOrDefault a
def (Flag a
bothflag Flag a -> Flag a -> Flag a
forall a. Semigroup a => a -> a -> a
<> Flag a
libflag)

        bothflag :: Flag a
bothflag = pkg -> (PackageConfig -> Flag a) -> Flag a
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption pkg
pkgid PackageConfig -> Flag a
fboth
        libflag :: Flag a
libflag  = pkg -> (PackageConfig -> Flag a) -> Flag a
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption pkg
pkgid PackageConfig -> Flag a
flib

    lookupPerPkgOption :: (Package pkg, Monoid m)
                       => pkg -> (PackageConfig -> m) -> m
    lookupPerPkgOption :: pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption pkg
pkg PackageConfig -> m
f =
        -- This is where we merge the options from the project config that
        -- apply to all packages, all project local packages, and to specific
        -- named packages
        m
global m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` m
local m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` m
perpkg
      where
        global :: m
global = PackageConfig -> m
f PackageConfig
allPackagesConfig
        local :: m
local  | pkg -> Bool
forall pkg. Package pkg => pkg -> Bool
isLocalToProject pkg
pkg
               = PackageConfig -> m
f PackageConfig
localPackagesConfig
               | Bool
otherwise
               = m
forall a. Monoid a => a
mempty
        perpkg :: m
perpkg = m -> (PackageConfig -> m) -> Maybe PackageConfig -> m
forall b a. b -> (a -> b) -> Maybe a -> b
maybe m
forall a. Monoid a => a
mempty PackageConfig -> m
f (PackageName -> Map PackageName PackageConfig -> Maybe PackageConfig
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (pkg -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName pkg
pkg) Map PackageName PackageConfig
perPackageConfig)

    inplacePackageDbs :: PackageDBStack
inplacePackageDbs = PackageDBStack
corePackageDbs
                     PackageDBStack -> PackageDBStack -> PackageDBStack
forall a. [a] -> [a] -> [a]
++ [ CompilerId -> PackageDB
distPackageDB (Compiler -> CompilerId
compilerId Compiler
compiler) ]

    corePackageDbs :: PackageDBStack
corePackageDbs = PackageDBStack -> [Maybe PackageDB] -> PackageDBStack
applyPackageDbFlags (CompilerId -> PackageDBStack
storePackageDBStack (Compiler -> CompilerId
compilerId Compiler
compiler))
                                         (ProjectConfigShared -> [Maybe PackageDB]
projectConfigPackageDBs ProjectConfigShared
sharedPackageConfig)

    -- For this local build policy, every package that lives in a local source
    -- dir (as opposed to a tarball), or depends on such a package, will be
    -- built inplace into a shared dist dir. Tarball packages that depend on
    -- source dir packages will also get unpacked locally.
    shouldBuildInplaceOnly :: SolverPackage loc -> Bool
    shouldBuildInplaceOnly :: SolverPackage loc -> Bool
shouldBuildInplaceOnly SolverPackage loc
pkg = PackageId -> Set PackageId -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member (SolverPackage loc -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId SolverPackage loc
pkg)
                                            Set PackageId
pkgsToBuildInplaceOnly

    pkgsToBuildInplaceOnly :: Set PackageId
    pkgsToBuildInplaceOnly :: Set PackageId
pkgsToBuildInplaceOnly =
        [PackageId] -> Set PackageId
forall a. Ord a => [a] -> Set a
Set.fromList
      ([PackageId] -> Set PackageId) -> [PackageId] -> Set PackageId
forall a b. (a -> b) -> a -> b
$ (ResolverPackage (PackageLocation (Maybe FilePath)) -> PackageId)
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
-> [PackageId]
forall a b. (a -> b) -> [a] -> [b]
map ResolverPackage (PackageLocation (Maybe FilePath)) -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId
      ([ResolverPackage (PackageLocation (Maybe FilePath))]
 -> [PackageId])
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
-> [PackageId]
forall a b. (a -> b) -> a -> b
$ SolverInstallPlan
-> [SolverId]
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
SolverInstallPlan.reverseDependencyClosure
          SolverInstallPlan
solverPlan
          ((PackageId -> SolverId) -> [PackageId] -> [SolverId]
forall a b. (a -> b) -> [a] -> [b]
map PackageId -> SolverId
PlannedId (Set PackageId -> [PackageId]
forall a. Set a -> [a]
Set.toList Set PackageId
pkgsLocalToProject))

    isLocalToProject :: Package pkg => pkg -> Bool
    isLocalToProject :: pkg -> Bool
isLocalToProject pkg
pkg = PackageId -> Set PackageId -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member (pkg -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId pkg
pkg)
                                      Set PackageId
pkgsLocalToProject

    pkgsLocalToProject :: Set PackageId
    pkgsLocalToProject :: Set PackageId
pkgsLocalToProject =
        [PackageId] -> Set PackageId
forall a. Ord a => [a] -> Set a
Set.fromList ([Maybe PackageId] -> [PackageId]
forall a. [Maybe a] -> [a]
catMaybes ((PackageSpecifier (SourcePackage (PackageLocation loc))
 -> Maybe PackageId)
-> [PackageSpecifier (SourcePackage (PackageLocation loc))]
-> [Maybe PackageId]
forall a b. (a -> b) -> [a] -> [b]
map PackageSpecifier (SourcePackage (PackageLocation loc))
-> Maybe PackageId
forall loc.
PackageSpecifier (SourcePackage (PackageLocation loc))
-> Maybe PackageId
shouldBeLocal [PackageSpecifier (SourcePackage (PackageLocation loc))]
localPackages))
        --TODO: localPackages is a misnomer, it's all project packages
        -- here is where we decide which ones will be local!

    pkgsUseSharedLibrary :: Set PackageId
    pkgsUseSharedLibrary :: Set PackageId
pkgsUseSharedLibrary =
        (ResolverPackage (PackageLocation (Maybe FilePath)) -> Bool)
-> Set PackageId
packagesWithLibDepsDownwardClosedProperty ResolverPackage (PackageLocation (Maybe FilePath)) -> Bool
forall pkg. Package pkg => pkg -> Bool
needsSharedLib
      where
        needsSharedLib :: pkg -> Bool
needsSharedLib pkg
pkg =
            Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
compilerShouldUseSharedLibByDefault
                      ((Bool -> Bool -> Bool) -> Maybe Bool -> Maybe Bool -> Maybe Bool
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(||) Maybe Bool
pkgSharedLib Maybe Bool
pkgDynExe)
          where
            pkgid :: PackageId
pkgid        = pkg -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId pkg
pkg
            pkgSharedLib :: Maybe Bool
pkgSharedLib = PackageId -> (PackageConfig -> Flag Bool) -> Maybe Bool
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag Bool
packageConfigSharedLib
            pkgDynExe :: Maybe Bool
pkgDynExe    = PackageId -> (PackageConfig -> Flag Bool) -> Maybe Bool
forall a. PackageId -> (PackageConfig -> Flag a) -> Maybe a
perPkgOptionMaybe PackageId
pkgid PackageConfig -> Flag Bool
packageConfigDynExe

    --TODO: [code cleanup] move this into the Cabal lib. It's currently open
    -- coded in Distribution.Simple.Configure, but should be made a proper
    -- function of the Compiler or CompilerInfo.
    compilerShouldUseSharedLibByDefault :: Bool
compilerShouldUseSharedLibByDefault =
      case Compiler -> CompilerFlavor
compilerFlavor Compiler
compiler of
        CompilerFlavor
GHC   -> Compiler -> Bool
GHC.isDynamic Compiler
compiler
        CompilerFlavor
GHCJS -> Compiler -> Bool
GHCJS.isDynamic Compiler
compiler
        CompilerFlavor
_     -> Bool
False

    pkgsUseProfilingLibrary :: Set PackageId
    pkgsUseProfilingLibrary :: Set PackageId
pkgsUseProfilingLibrary =
        (ResolverPackage (PackageLocation (Maybe FilePath)) -> Bool)
-> Set PackageId
packagesWithLibDepsDownwardClosedProperty ResolverPackage (PackageLocation (Maybe FilePath)) -> Bool
forall pkg. Package pkg => pkg -> Bool
needsProfilingLib
      where
        needsProfilingLib :: pkg -> Bool
needsProfilingLib pkg
pkg =
            Bool -> Flag Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False (Flag Bool
profBothFlag Flag Bool -> Flag Bool -> Flag Bool
forall a. Semigroup a => a -> a -> a
<> Flag Bool
profLibFlag)
          where
            pkgid :: PackageId
pkgid        = pkg -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId pkg
pkg
            profBothFlag :: Flag Bool
profBothFlag = PackageId -> (PackageConfig -> Flag Bool) -> Flag Bool
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption PackageId
pkgid PackageConfig -> Flag Bool
packageConfigProf
            profLibFlag :: Flag Bool
profLibFlag  = PackageId -> (PackageConfig -> Flag Bool) -> Flag Bool
forall pkg m.
(Package pkg, Monoid m) =>
pkg -> (PackageConfig -> m) -> m
lookupPerPkgOption PackageId
pkgid PackageConfig -> Flag Bool
packageConfigProfLib
            --TODO: [code cleanup] unused: the old deprecated packageConfigProfExe

    libDepGraph :: Graph NonSetupLibDepSolverPlanPackage
libDepGraph = [NonSetupLibDepSolverPlanPackage]
-> Graph NonSetupLibDepSolverPlanPackage
forall a. (IsNode a, Show (Key a)) => [a] -> Graph a
Graph.fromDistinctList ([NonSetupLibDepSolverPlanPackage]
 -> Graph NonSetupLibDepSolverPlanPackage)
-> [NonSetupLibDepSolverPlanPackage]
-> Graph NonSetupLibDepSolverPlanPackage
forall a b. (a -> b) -> a -> b
$
                    (ResolverPackage (PackageLocation (Maybe FilePath))
 -> NonSetupLibDepSolverPlanPackage)
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
-> [NonSetupLibDepSolverPlanPackage]
forall a b. (a -> b) -> [a] -> [b]
map ResolverPackage (PackageLocation (Maybe FilePath))
-> NonSetupLibDepSolverPlanPackage
NonSetupLibDepSolverPlanPackage
                        (SolverInstallPlan
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
SolverInstallPlan.toList SolverInstallPlan
solverPlan)

    packagesWithLibDepsDownwardClosedProperty :: (ResolverPackage (PackageLocation (Maybe FilePath)) -> Bool)
-> Set PackageId
packagesWithLibDepsDownwardClosedProperty ResolverPackage (PackageLocation (Maybe FilePath)) -> Bool
property =
        [PackageId] -> Set PackageId
forall a. Ord a => [a] -> Set a
Set.fromList
      ([PackageId] -> Set PackageId)
-> (Maybe [NonSetupLibDepSolverPlanPackage] -> [PackageId])
-> Maybe [NonSetupLibDepSolverPlanPackage]
-> Set PackageId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NonSetupLibDepSolverPlanPackage -> PackageId)
-> [NonSetupLibDepSolverPlanPackage] -> [PackageId]
forall a b. (a -> b) -> [a] -> [b]
map NonSetupLibDepSolverPlanPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId
      ([NonSetupLibDepSolverPlanPackage] -> [PackageId])
-> (Maybe [NonSetupLibDepSolverPlanPackage]
    -> [NonSetupLibDepSolverPlanPackage])
-> Maybe [NonSetupLibDepSolverPlanPackage]
-> [PackageId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [NonSetupLibDepSolverPlanPackage]
-> Maybe [NonSetupLibDepSolverPlanPackage]
-> [NonSetupLibDepSolverPlanPackage]
forall a. a -> Maybe a -> a
fromMaybe []
      (Maybe [NonSetupLibDepSolverPlanPackage] -> Set PackageId)
-> Maybe [NonSetupLibDepSolverPlanPackage] -> Set PackageId
forall a b. (a -> b) -> a -> b
$ Graph NonSetupLibDepSolverPlanPackage
-> [Key NonSetupLibDepSolverPlanPackage]
-> Maybe [NonSetupLibDepSolverPlanPackage]
forall a. Graph a -> [Key a] -> Maybe [a]
Graph.closure
          Graph NonSetupLibDepSolverPlanPackage
libDepGraph
          [ ResolverPackage (PackageLocation (Maybe FilePath))
-> Key (ResolverPackage (PackageLocation (Maybe FilePath)))
forall a. IsNode a => a -> Key a
Graph.nodeKey ResolverPackage (PackageLocation (Maybe FilePath))
pkg
          | ResolverPackage (PackageLocation (Maybe FilePath))
pkg <- SolverInstallPlan
-> [ResolverPackage (PackageLocation (Maybe FilePath))]
SolverInstallPlan.toList SolverInstallPlan
solverPlan
          , ResolverPackage (PackageLocation (Maybe FilePath)) -> Bool
property ResolverPackage (PackageLocation (Maybe FilePath))
pkg ] -- just the packages that satisfy the property
      --TODO: [nice to have] this does not check the config consistency,
      -- e.g. a package explicitly turning off profiling, but something
      -- depending on it that needs profiling. This really needs a separate
      -- package config validation/resolution pass.

      --TODO: [nice to have] config consistency checking:
      -- + profiling libs & exes, exe needs lib, recursive
      -- + shared libs & exes, exe needs lib, recursive
      -- + vanilla libs & exes, exe needs lib, recursive
      -- + ghci or shared lib needed by TH, recursive, ghc version dependent

-- TODO: Drop matchPlanPkg/matchElabPkg in favor of mkCCMapping

shouldBeLocal :: PackageSpecifier (SourcePackage (PackageLocation loc)) -> Maybe PackageId
shouldBeLocal :: PackageSpecifier (SourcePackage (PackageLocation loc))
-> Maybe PackageId
shouldBeLocal NamedPackage{}              = Maybe PackageId
forall a. Maybe a
Nothing
shouldBeLocal (SpecificSourcePackage SourcePackage (PackageLocation loc)
pkg) = case SourcePackage (PackageLocation loc) -> PackageLocation loc
forall loc. SourcePackage loc -> loc
srcpkgSource SourcePackage (PackageLocation loc)
pkg of
    LocalUnpackedPackage FilePath
_ -> PackageId -> Maybe PackageId
forall a. a -> Maybe a
Just (SourcePackage (PackageLocation loc) -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId SourcePackage (PackageLocation loc)
pkg)
    PackageLocation loc
_                      -> Maybe PackageId
forall a. Maybe a
Nothing

-- | Given a 'ElaboratedPlanPackage', report if it matches a 'ComponentName'.
matchPlanPkg :: (ComponentName -> Bool) -> ElaboratedPlanPackage -> Bool
matchPlanPkg :: (ComponentName -> Bool)
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> Bool
matchPlanPkg ComponentName -> Bool
p = (InstalledPackageInfo -> Bool)
-> (ElaboratedConfiguredPackage -> Bool)
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> Bool
forall ipkg a srcpkg.
(ipkg -> a) -> (srcpkg -> a) -> GenericPlanPackage ipkg srcpkg -> a
InstallPlan.foldPlanPackage (ComponentName -> Bool
p (ComponentName -> Bool)
-> (InstalledPackageInfo -> ComponentName)
-> InstalledPackageInfo
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InstalledPackageInfo -> ComponentName
ipiComponentName) ((ComponentName -> Bool) -> ElaboratedConfiguredPackage -> Bool
matchElabPkg ComponentName -> Bool
p)

-- | Get the appropriate 'ComponentName' which identifies an installed
-- component.
ipiComponentName :: IPI.InstalledPackageInfo -> ComponentName
ipiComponentName :: InstalledPackageInfo -> ComponentName
ipiComponentName = LibraryName -> ComponentName
CLibName (LibraryName -> ComponentName)
-> (InstalledPackageInfo -> LibraryName)
-> InstalledPackageInfo
-> ComponentName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InstalledPackageInfo -> LibraryName
IPI.sourceLibName

-- | Given a 'ElaboratedConfiguredPackage', report if it matches a
-- 'ComponentName'.
matchElabPkg :: (ComponentName -> Bool) -> ElaboratedConfiguredPackage -> Bool
matchElabPkg :: (ComponentName -> Bool) -> ElaboratedConfiguredPackage -> Bool
matchElabPkg ComponentName -> Bool
p ElaboratedConfiguredPackage
elab =
    case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
        ElabComponent ElaboratedComponent
comp -> Bool -> (ComponentName -> Bool) -> Maybe ComponentName -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ComponentName -> Bool
p (ElaboratedComponent -> Maybe ComponentName
compComponentName ElaboratedComponent
comp)
        ElabPackage ElaboratedPackage
_ ->
            -- So, what should we do here?  One possibility is to
            -- unconditionally return 'True', because whatever it is
            -- that we're looking for, it better be in this package.
            -- But this is a bit dodgy if the package doesn't actually
            -- have, e.g., a library.  Fortunately, it's not possible
            -- for the build of the library/executables to be toggled
            -- by 'pkgStanzasEnabled', so the only thing we have to
            -- test is if the component in question is *buildable.*
            (Component -> Bool) -> [Component] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (ComponentName -> Bool
p (ComponentName -> Bool)
-> (Component -> ComponentName) -> Component -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Component -> ComponentName
componentName)
                (PackageDescription -> [Component]
Cabal.pkgBuildableComponents (ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
elab))

-- | Given an 'ElaboratedPlanPackage', generate the mapping from 'PackageName'
-- and 'ComponentName' to the 'ComponentId' that should be used
-- in this case.
mkCCMapping :: ElaboratedPlanPackage
            -> (PackageName, Map ComponentName (AnnotatedId ComponentId))
mkCCMapping :: GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> (PackageName, Map ComponentName (AnnotatedId ComponentId))
mkCCMapping =
    (InstalledPackageInfo
 -> (PackageName, Map ComponentName (AnnotatedId ComponentId)))
-> (ElaboratedConfiguredPackage
    -> (PackageName, Map ComponentName (AnnotatedId ComponentId)))
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> (PackageName, Map ComponentName (AnnotatedId ComponentId))
forall ipkg a srcpkg.
(ipkg -> a) -> (srcpkg -> a) -> GenericPlanPackage ipkg srcpkg -> a
InstallPlan.foldPlanPackage
       (\InstalledPackageInfo
ipkg -> (InstalledPackageInfo -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName InstalledPackageInfo
ipkg,
                    ComponentName
-> AnnotatedId ComponentId
-> Map ComponentName (AnnotatedId ComponentId)
forall k a. k -> a -> Map k a
Map.singleton (InstalledPackageInfo -> ComponentName
ipiComponentName InstalledPackageInfo
ipkg)
                                  -- TODO: libify
                                  (AnnotatedId :: forall id. PackageId -> ComponentName -> id -> AnnotatedId id
AnnotatedId {
                                    ann_id :: ComponentId
ann_id = InstalledPackageInfo -> ComponentId
IPI.installedComponentId InstalledPackageInfo
ipkg,
                                    ann_pid :: PackageId
ann_pid = InstalledPackageInfo -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId InstalledPackageInfo
ipkg,
                                    ann_cname :: ComponentName
ann_cname = InstalledPackageInfo -> ComponentName
IPI.sourceComponentName InstalledPackageInfo
ipkg
                                  })))
      ((ElaboratedConfiguredPackage
  -> (PackageName, Map ComponentName (AnnotatedId ComponentId)))
 -> GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage
 -> (PackageName, Map ComponentName (AnnotatedId ComponentId)))
-> (ElaboratedConfiguredPackage
    -> (PackageName, Map ComponentName (AnnotatedId ComponentId)))
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> (PackageName, Map ComponentName (AnnotatedId ComponentId))
forall a b. (a -> b) -> a -> b
$ \ElaboratedConfiguredPackage
elab ->
        let mk_aid :: ComponentName -> AnnotatedId ComponentId
mk_aid ComponentName
cn = AnnotatedId :: forall id. PackageId -> ComponentName -> id -> AnnotatedId id
AnnotatedId {
                            ann_id :: ComponentId
ann_id = ElaboratedConfiguredPackage -> ComponentId
elabComponentId ElaboratedConfiguredPackage
elab,
                            ann_pid :: PackageId
ann_pid = ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab,
                            ann_cname :: ComponentName
ann_cname = ComponentName
cn
                        }
        in (ElaboratedConfiguredPackage -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName ElaboratedConfiguredPackage
elab,
            case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
                ElabComponent ElaboratedComponent
comp ->
                    case ElaboratedComponent -> Maybe ComponentName
compComponentName ElaboratedComponent
comp of
                        Maybe ComponentName
Nothing -> Map ComponentName (AnnotatedId ComponentId)
forall k a. Map k a
Map.empty
                        Just ComponentName
n  -> ComponentName
-> AnnotatedId ComponentId
-> Map ComponentName (AnnotatedId ComponentId)
forall k a. k -> a -> Map k a
Map.singleton ComponentName
n (ComponentName -> AnnotatedId ComponentId
mk_aid ComponentName
n)
                ElabPackage ElaboratedPackage
_ ->
                    [(ComponentName, AnnotatedId ComponentId)]
-> Map ComponentName (AnnotatedId ComponentId)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(ComponentName, AnnotatedId ComponentId)]
 -> Map ComponentName (AnnotatedId ComponentId))
-> [(ComponentName, AnnotatedId ComponentId)]
-> Map ComponentName (AnnotatedId ComponentId)
forall a b. (a -> b) -> a -> b
$
                        (Component -> (ComponentName, AnnotatedId ComponentId))
-> [Component] -> [(ComponentName, AnnotatedId ComponentId)]
forall a b. (a -> b) -> [a] -> [b]
map (\Component
comp -> let cn :: ComponentName
cn = Component -> ComponentName
Cabal.componentName Component
comp in (ComponentName
cn, ComponentName -> AnnotatedId ComponentId
mk_aid ComponentName
cn))
                            (PackageDescription -> [Component]
Cabal.pkgBuildableComponents (ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
elab)))

-- | Given an 'ElaboratedPlanPackage', generate the mapping from 'ComponentId'
-- to the shape of this package, as per mix-in linking.
mkShapeMapping :: ElaboratedPlanPackage
               -> (ComponentId, (OpenUnitId, ModuleShape))
mkShapeMapping :: GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> (ComponentId, (OpenUnitId, ModuleShape))
mkShapeMapping GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
dpkg =
    (GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> ComponentId
getComponentId GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
dpkg, (OpenUnitId
indef_uid, ModuleShape
shape))
  where
    (ComponentId
dcid, ModuleShape
shape) =
        (InstalledPackageInfo -> (ComponentId, ModuleShape))
-> (ElaboratedConfiguredPackage -> (ComponentId, ModuleShape))
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> (ComponentId, ModuleShape)
forall ipkg a srcpkg.
(ipkg -> a) -> (srcpkg -> a) -> GenericPlanPackage ipkg srcpkg -> a
InstallPlan.foldPlanPackage
            -- Uses Monad (->)
            ((ComponentId -> ModuleShape -> (ComponentId, ModuleShape))
-> (InstalledPackageInfo -> ComponentId)
-> (InstalledPackageInfo -> ModuleShape)
-> InstalledPackageInfo
-> (ComponentId, ModuleShape)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) InstalledPackageInfo -> ComponentId
IPI.installedComponentId InstalledPackageInfo -> ModuleShape
shapeInstalledPackage)
            ((ComponentId -> ModuleShape -> (ComponentId, ModuleShape))
-> (ElaboratedConfiguredPackage -> ComponentId)
-> (ElaboratedConfiguredPackage -> ModuleShape)
-> ElaboratedConfiguredPackage
-> (ComponentId, ModuleShape)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) ElaboratedConfiguredPackage -> ComponentId
elabComponentId ElaboratedConfiguredPackage -> ModuleShape
elabModuleShape)
            GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
dpkg
    indef_uid :: OpenUnitId
indef_uid =
        ComponentId -> Map ModuleName OpenModule -> OpenUnitId
IndefFullUnitId ComponentId
dcid
            ([(ModuleName, OpenModule)] -> Map ModuleName OpenModule
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [ (ModuleName
req, ModuleName -> OpenModule
OpenModuleVar ModuleName
req)
                          | ModuleName
req <- Set ModuleName -> [ModuleName]
forall a. Set a -> [a]
Set.toList (ModuleShape -> Set ModuleName
modShapeRequires ModuleShape
shape)])

-- | Get the bin\/ directories that a package's executables should reside in.
--
-- The result may be empty if the package does not build any executables.
--
-- The result may have several entries if this is an inplace build of a package
-- with multiple executables.
binDirectories
  :: DistDirLayout
  -> ElaboratedSharedConfig
  -> ElaboratedConfiguredPackage
  -> [FilePath]
binDirectories :: DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> [FilePath]
binDirectories DistDirLayout
layout ElaboratedSharedConfig
config ElaboratedConfiguredPackage
package = case ElaboratedConfiguredPackage -> BuildStyle
elabBuildStyle ElaboratedConfiguredPackage
package of
  -- quick sanity check: no sense returning a bin directory if we're not going
  -- to put any executables in it, that will just clog up the PATH
  BuildStyle
_ | Bool
noExecutables -> []
  BuildStyle
BuildAndInstall -> [ElaboratedConfiguredPackage -> FilePath
installedBinDirectory ElaboratedConfiguredPackage
package]
  BuildStyle
BuildInplaceOnly -> (FilePath -> FilePath) -> [FilePath] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map (FilePath
rootFilePath -> FilePath -> FilePath
</>) ([FilePath] -> [FilePath]) -> [FilePath] -> [FilePath]
forall a b. (a -> b) -> a -> b
$ case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
package of
    ElabComponent ElaboratedComponent
comp -> case ElaboratedComponent -> Component
compSolverName ElaboratedComponent
comp of
      CD.ComponentExe UnqualComponentName
n -> [UnqualComponentName -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow UnqualComponentName
n]
      Component
_ -> []
    ElabPackage ElaboratedPackage
_ -> (Executable -> FilePath) -> [Executable] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map (UnqualComponentName -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow (UnqualComponentName -> FilePath)
-> (Executable -> UnqualComponentName) -> Executable -> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> UnqualComponentName
PD.exeName)
                   ([Executable] -> [FilePath])
-> (ElaboratedConfiguredPackage -> [Executable])
-> ElaboratedConfiguredPackage
-> [FilePath]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDescription -> [Executable]
PD.executables
                   (PackageDescription -> [Executable])
-> (ElaboratedConfiguredPackage -> PackageDescription)
-> ElaboratedConfiguredPackage
-> [Executable]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription
                   (ElaboratedConfiguredPackage -> [FilePath])
-> ElaboratedConfiguredPackage -> [FilePath]
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage
package
  where
  noExecutables :: Bool
noExecutables = [Executable] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([Executable] -> Bool)
-> (ElaboratedConfiguredPackage -> [Executable])
-> ElaboratedConfiguredPackage
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDescription -> [Executable]
PD.executables (PackageDescription -> [Executable])
-> (ElaboratedConfiguredPackage -> PackageDescription)
-> ElaboratedConfiguredPackage
-> [Executable]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription (ElaboratedConfiguredPackage -> Bool)
-> ElaboratedConfiguredPackage -> Bool
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage
package
  root :: FilePath
root  =  DistDirLayout -> DistDirParams -> FilePath
distBuildDirectory DistDirLayout
layout (ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> DistDirParams
elabDistDirParams ElaboratedSharedConfig
config ElaboratedConfiguredPackage
package)
       FilePath -> FilePath -> FilePath
</> FilePath
"build"

-- | A newtype for 'SolverInstallPlan.SolverPlanPackage' for which the
-- dependency graph considers only dependencies on libraries which are
-- NOT from setup dependencies.  Used to compute the set
-- of packages needed for profiling and dynamic libraries.
newtype NonSetupLibDepSolverPlanPackage
    = NonSetupLibDepSolverPlanPackage
    { NonSetupLibDepSolverPlanPackage
-> ResolverPackage (PackageLocation (Maybe FilePath))
unNonSetupLibDepSolverPlanPackage :: SolverInstallPlan.SolverPlanPackage }

instance Package NonSetupLibDepSolverPlanPackage where
    packageId :: NonSetupLibDepSolverPlanPackage -> PackageId
packageId = ResolverPackage (PackageLocation (Maybe FilePath)) -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId (ResolverPackage (PackageLocation (Maybe FilePath)) -> PackageId)
-> (NonSetupLibDepSolverPlanPackage
    -> ResolverPackage (PackageLocation (Maybe FilePath)))
-> NonSetupLibDepSolverPlanPackage
-> PackageId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonSetupLibDepSolverPlanPackage
-> ResolverPackage (PackageLocation (Maybe FilePath))
unNonSetupLibDepSolverPlanPackage

instance IsNode NonSetupLibDepSolverPlanPackage where
    type Key NonSetupLibDepSolverPlanPackage = SolverId
    nodeKey :: NonSetupLibDepSolverPlanPackage
-> Key NonSetupLibDepSolverPlanPackage
nodeKey = ResolverPackage (PackageLocation (Maybe FilePath)) -> SolverId
forall a. IsNode a => a -> Key a
nodeKey (ResolverPackage (PackageLocation (Maybe FilePath)) -> SolverId)
-> (NonSetupLibDepSolverPlanPackage
    -> ResolverPackage (PackageLocation (Maybe FilePath)))
-> NonSetupLibDepSolverPlanPackage
-> SolverId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonSetupLibDepSolverPlanPackage
-> ResolverPackage (PackageLocation (Maybe FilePath))
unNonSetupLibDepSolverPlanPackage
    nodeNeighbors :: NonSetupLibDepSolverPlanPackage
-> [Key NonSetupLibDepSolverPlanPackage]
nodeNeighbors (NonSetupLibDepSolverPlanPackage ResolverPackage (PackageLocation (Maybe FilePath))
spkg)
        = [SolverId] -> [SolverId]
forall a. Ord a => [a] -> [a]
ordNub ([SolverId] -> [SolverId]) -> [SolverId] -> [SolverId]
forall a b. (a -> b) -> a -> b
$ ComponentDeps [SolverId] -> [SolverId]
forall a. Monoid a => ComponentDeps a -> a
CD.nonSetupDeps (ResolverPackage (PackageLocation (Maybe FilePath))
-> ComponentDeps [SolverId]
forall loc. ResolverPackage loc -> ComponentDeps [SolverId]
resolverPackageLibDeps ResolverPackage (PackageLocation (Maybe FilePath))
spkg)

type InstS = Map UnitId ElaboratedPlanPackage
type InstM a = State InstS a

getComponentId :: ElaboratedPlanPackage
               -> ComponentId
getComponentId :: GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> ComponentId
getComponentId (InstallPlan.PreExisting InstalledPackageInfo
dipkg) = InstalledPackageInfo -> ComponentId
IPI.installedComponentId InstalledPackageInfo
dipkg
getComponentId (InstallPlan.Configured ElaboratedConfiguredPackage
elab) = ElaboratedConfiguredPackage -> ComponentId
elabComponentId ElaboratedConfiguredPackage
elab
getComponentId (InstallPlan.Installed ElaboratedConfiguredPackage
elab) = ElaboratedConfiguredPackage -> ComponentId
elabComponentId ElaboratedConfiguredPackage
elab

extractElabBuildStyle :: InstallPlan.GenericPlanPackage ipkg ElaboratedConfiguredPackage
                      -> BuildStyle
extractElabBuildStyle :: GenericPlanPackage ipkg ElaboratedConfiguredPackage -> BuildStyle
extractElabBuildStyle (InstallPlan.Configured ElaboratedConfiguredPackage
elab) = ElaboratedConfiguredPackage -> BuildStyle
elabBuildStyle ElaboratedConfiguredPackage
elab
extractElabBuildStyle GenericPlanPackage ipkg ElaboratedConfiguredPackage
_ = BuildStyle
BuildAndInstall

-- instantiateInstallPlan is responsible for filling out an InstallPlan
-- with all of the extra Configured packages that would be generated by
-- recursively instantiating the dependencies of packages.
--
-- Suppose we are compiling the following packages:
--
--  unit f where
--    signature H
--
--  unit g where
--    dependency f[H=containers:Data.Map]
--
-- At entry, we have an InstallPlan with a single plan package per
-- actual source package, e.g., only (indefinite!) f and g.  The job of
-- instantiation is to turn this into three plan packages: each of the
-- packages as before, but also a new, definite package f[H=containers:Data.Map]
--
-- How do we do this?  The general strategy is to iterate over every
-- package in the existing plan and recursively create new entries for
-- each of its dependencies which is an instantiated package (e.g.,
-- f[H=p:G]).  This process must be recursive, as f itself may depend on
-- OTHER packages which it instantiated using its hole H.
--
-- Some subtleties:
--
--  * We have to keep track of whether or not we are instantiating with
--    inplace packages, because instantiating a non-inplace package with
--    an inplace packages makes it inplace (since it depends on
--    something in the inplace store)!  The rule is that if any of the
--    modules in an instantiation are inplace, then the instantiated
--    unit itself must be inplace.  There is then a bunch of faffing
--    about to keep track of BuildStyle.
--
--  * ElaboratedConfiguredPackage was never really designed for post
--    facto instantiation, so some of the steps for generating new
--    instantiations are a little fraught.  For example, the act of
--    flipping a package to be inplace involves faffing about with four
--    fields, because these fields are precomputed.  A good refactor
--    would be to reduce the amount of precomputation to simplify the
--    algorithm here.
--
--  * We use the state monad to cache already instantiated modules, so
--    we don't instantiate the same thing multiple times.
--
instantiateInstallPlan :: StoreDirLayout -> InstallDirs.InstallDirTemplates -> ElaboratedSharedConfig -> ElaboratedInstallPlan -> ElaboratedInstallPlan
instantiateInstallPlan :: StoreDirLayout
-> InstallDirTemplates
-> ElaboratedSharedConfig
-> ElaboratedInstallPlan
-> ElaboratedInstallPlan
instantiateInstallPlan StoreDirLayout
storeDirLayout InstallDirTemplates
defaultInstallDirs ElaboratedSharedConfig
elaboratedShared ElaboratedInstallPlan
plan =
    IndependentGoals
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> ElaboratedInstallPlan
forall ipkg srcpkg.
(IsUnit ipkg, IsUnit srcpkg) =>
IndependentGoals
-> Graph (GenericPlanPackage ipkg srcpkg)
-> GenericInstallPlan ipkg srcpkg
InstallPlan.new (Bool -> IndependentGoals
IndependentGoals Bool
False)
                    ([GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall a. (IsNode a, Show (Key a)) => [a] -> Graph a
Graph.fromDistinctList (Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall k a. Map k a -> [a]
Map.elems Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
ready_map))
  where
    pkgs :: [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs = ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> [GenericPlanPackage ipkg srcpkg]
InstallPlan.toList ElaboratedInstallPlan
plan

    cmap :: Map
  ComponentId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
cmap = [(ComponentId,
  GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage)]
-> Map
     ComponentId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [ (GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> ComponentId
getComponentId GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg, GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg) | GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg <- [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs ]

    instantiateUnitId :: ComponentId -> Map ModuleName (Module, BuildStyle)
                      -> InstM (DefUnitId, BuildStyle)
    instantiateUnitId :: ComponentId
-> Map ModuleName (Module, BuildStyle)
-> InstM (DefUnitId, BuildStyle)
instantiateUnitId ComponentId
cid Map ModuleName (Module, BuildStyle)
insts = (Map
   UnitId
   (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
 -> ((DefUnitId, BuildStyle),
     Map
       UnitId
       (GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage)))
-> InstM (DefUnitId, BuildStyle)
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state ((Map
    UnitId
    (GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage)
  -> ((DefUnitId, BuildStyle),
      Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage)))
 -> InstM (DefUnitId, BuildStyle))
-> (Map
      UnitId
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage)
    -> ((DefUnitId, BuildStyle),
        Map
          UnitId
          (GenericPlanPackage
             InstalledPackageInfo ElaboratedConfiguredPackage)))
-> InstM (DefUnitId, BuildStyle)
forall a b. (a -> b) -> a -> b
$ \Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s ->
        case UnitId
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup UnitId
uid Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s of
            Maybe
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
Nothing ->
                -- Knot tied
                -- TODO: I don't think the knot tying actually does
                -- anything useful
                let (GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r, Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s') = State
  (Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage))
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage,
    Map
      UnitId
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
forall s a. State s a -> s -> (a, s)
runState (UnitId
-> ComponentId
-> Map ModuleName (Module, BuildStyle)
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
instantiateComponent UnitId
uid ComponentId
cid Map ModuleName (Module, BuildStyle)
insts)
                                       (UnitId
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert UnitId
uid GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s)
                in ((DefUnitId
def_uid, GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> BuildStyle
forall ipkg.
GenericPlanPackage ipkg ElaboratedConfiguredPackage -> BuildStyle
extractElabBuildStyle GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r), UnitId
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert UnitId
uid GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s')
            Just GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r -> ((DefUnitId
def_uid, GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> BuildStyle
forall ipkg.
GenericPlanPackage ipkg ElaboratedConfiguredPackage -> BuildStyle
extractElabBuildStyle GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r), Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s)
      where
        def_uid :: DefUnitId
def_uid = ComponentId -> Map ModuleName Module -> DefUnitId
mkDefUnitId ComponentId
cid (((Module, BuildStyle) -> Module)
-> Map ModuleName (Module, BuildStyle) -> Map ModuleName Module
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Module, BuildStyle) -> Module
forall a b. (a, b) -> a
fst Map ModuleName (Module, BuildStyle)
insts)
        uid :: UnitId
uid = DefUnitId -> UnitId
unDefUnitId DefUnitId
def_uid

    -- No need to InplaceT; the inplace-ness is properly computed for
    -- the ElaboratedPlanPackage, so that will implicitly pass it on
    instantiateComponent
        :: UnitId -> ComponentId -> Map ModuleName (Module, BuildStyle)
        -> InstM ElaboratedPlanPackage
    instantiateComponent :: UnitId
-> ComponentId
-> Map ModuleName (Module, BuildStyle)
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
instantiateComponent UnitId
uid ComponentId
cid Map ModuleName (Module, BuildStyle)
insts
      | Just GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
planpkg <- ComponentId
-> Map
     ComponentId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ComponentId
cid Map
  ComponentId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
cmap
      = case GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
planpkg of
          InstallPlan.Configured (elab0 :: ElaboratedConfiguredPackage
elab0@ElaboratedConfiguredPackage
                                    { elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabComponent ElaboratedComponent
comp }) -> do
            [DefUnitId]
deps <-
              (OpenUnitId
 -> StateT
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      Identity
      DefUnitId)
-> [OpenUnitId]
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     [DefUnitId]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (((DefUnitId, BuildStyle) -> DefUnitId)
-> InstM (DefUnitId, BuildStyle)
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     DefUnitId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DefUnitId, BuildStyle) -> DefUnitId
forall a b. (a, b) -> a
fst (InstM (DefUnitId, BuildStyle)
 -> StateT
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      Identity
      DefUnitId)
-> (OpenUnitId -> InstM (DefUnitId, BuildStyle))
-> OpenUnitId
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     DefUnitId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map ModuleName (Module, BuildStyle)
-> OpenUnitId -> InstM (DefUnitId, BuildStyle)
substUnitId Map ModuleName (Module, BuildStyle)
insts) (ElaboratedComponent -> [OpenUnitId]
compLinkedLibDependencies ElaboratedComponent
comp)
            let build_style :: BuildStyle
build_style = Map ModuleName BuildStyle -> BuildStyle
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold (((Module, BuildStyle) -> BuildStyle)
-> Map ModuleName (Module, BuildStyle) -> Map ModuleName BuildStyle
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Module, BuildStyle) -> BuildStyle
forall a b. (a, b) -> b
snd Map ModuleName (Module, BuildStyle)
insts)
            let getDep :: Module -> [DefUnitId]
getDep (Module DefUnitId
dep_uid ModuleName
_) = [DefUnitId
dep_uid]
                elab1 :: ElaboratedConfiguredPackage
elab1 = BuildStyle
-> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
fixupBuildStyle BuildStyle
build_style (ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage)
-> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage
elab0 {
                    elabUnitId :: UnitId
elabUnitId = UnitId
uid,
                    elabComponentId :: ComponentId
elabComponentId = ComponentId
cid,
                    elabInstantiatedWith :: Map ModuleName Module
elabInstantiatedWith = ((Module, BuildStyle) -> Module)
-> Map ModuleName (Module, BuildStyle) -> Map ModuleName Module
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Module, BuildStyle) -> Module
forall a b. (a, b) -> a
fst Map ModuleName (Module, BuildStyle)
insts,
                    elabIsCanonical :: Bool
elabIsCanonical = Map ModuleName Module -> Bool
forall k a. Map k a -> Bool
Map.null (((Module, BuildStyle) -> Module)
-> Map ModuleName (Module, BuildStyle) -> Map ModuleName Module
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Module, BuildStyle) -> Module
forall a b. (a, b) -> a
fst Map ModuleName (Module, BuildStyle)
insts),
                    elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp = ElaboratedComponent -> ElaboratedPackageOrComponent
ElabComponent ElaboratedComponent
comp {
                        compOrderLibDependencies :: [UnitId]
compOrderLibDependencies =
                            (if Map ModuleName (Module, BuildStyle) -> Bool
forall k a. Map k a -> Bool
Map.null Map ModuleName (Module, BuildStyle)
insts then [] else [ComponentId -> UnitId
newSimpleUnitId ComponentId
cid]) [UnitId] -> [UnitId] -> [UnitId]
forall a. [a] -> [a] -> [a]
++
                            [UnitId] -> [UnitId]
forall a. Ord a => [a] -> [a]
ordNub ((DefUnitId -> UnitId) -> [DefUnitId] -> [UnitId]
forall a b. (a -> b) -> [a] -> [b]
map DefUnitId -> UnitId
unDefUnitId
                                ([DefUnitId]
deps [DefUnitId] -> [DefUnitId] -> [DefUnitId]
forall a. [a] -> [a] -> [a]
++ ((Module, BuildStyle) -> [DefUnitId])
-> [(Module, BuildStyle)] -> [DefUnitId]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Module -> [DefUnitId]
getDep (Module -> [DefUnitId])
-> ((Module, BuildStyle) -> Module)
-> (Module, BuildStyle)
-> [DefUnitId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Module, BuildStyle) -> Module
forall a b. (a, b) -> a
fst) (Map ModuleName (Module, BuildStyle) -> [(Module, BuildStyle)]
forall k a. Map k a -> [a]
Map.elems Map ModuleName (Module, BuildStyle)
insts)))
                    }
                  }
                elab :: ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage
elab1 {
                    elabInstallDirs :: InstallDirs FilePath
elabInstallDirs = StoreDirLayout
-> InstallDirTemplates
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> InstallDirs FilePath
computeInstallDirs StoreDirLayout
storeDirLayout
                                                         InstallDirTemplates
defaultInstallDirs
                                                         ElaboratedSharedConfig
elaboratedShared
                                                         ElaboratedConfiguredPackage
elab1
                  }
            GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall (m :: * -> *) a. Monad m => a -> m a
return (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> State
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
forall ipkg srcpkg. srcpkg -> GenericPlanPackage ipkg srcpkg
InstallPlan.Configured ElaboratedConfiguredPackage
elab
          GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
_ -> GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall (m :: * -> *) a. Monad m => a -> m a
return GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
planpkg
      | Bool
otherwise = FilePath
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath
"instantiateComponent: " FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ ComponentId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow ComponentId
cid)

    substUnitId :: Map ModuleName (Module, BuildStyle) -> OpenUnitId -> InstM (DefUnitId, BuildStyle)
    substUnitId :: Map ModuleName (Module, BuildStyle)
-> OpenUnitId -> InstM (DefUnitId, BuildStyle)
substUnitId Map ModuleName (Module, BuildStyle)
_ (DefiniteUnitId DefUnitId
uid) =
        -- This COULD actually, secretly, be an inplace package, but in
        -- that case it doesn't matter as it's already been recorded
        -- in the package that depends on this
        (DefUnitId, BuildStyle) -> InstM (DefUnitId, BuildStyle)
forall (m :: * -> *) a. Monad m => a -> m a
return (DefUnitId
uid, BuildStyle
BuildAndInstall)
    substUnitId Map ModuleName (Module, BuildStyle)
subst (IndefFullUnitId ComponentId
cid Map ModuleName OpenModule
insts) = do
        Map ModuleName (Module, BuildStyle)
insts' <- Map ModuleName (Module, BuildStyle)
-> Map ModuleName OpenModule
-> InstM (Map ModuleName (Module, BuildStyle))
substSubst Map ModuleName (Module, BuildStyle)
subst Map ModuleName OpenModule
insts
        ComponentId
-> Map ModuleName (Module, BuildStyle)
-> InstM (DefUnitId, BuildStyle)
instantiateUnitId ComponentId
cid Map ModuleName (Module, BuildStyle)
insts'

    -- NB: NOT composition
    substSubst :: Map ModuleName (Module, BuildStyle)
               -> Map ModuleName OpenModule
               -> InstM (Map ModuleName (Module, BuildStyle))
    substSubst :: Map ModuleName (Module, BuildStyle)
-> Map ModuleName OpenModule
-> InstM (Map ModuleName (Module, BuildStyle))
substSubst Map ModuleName (Module, BuildStyle)
subst Map ModuleName OpenModule
insts = (OpenModule
 -> StateT
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      Identity
      (Module, BuildStyle))
-> Map ModuleName OpenModule
-> InstM (Map ModuleName (Module, BuildStyle))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (Map ModuleName (Module, BuildStyle)
-> OpenModule
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     (Module, BuildStyle)
substModule Map ModuleName (Module, BuildStyle)
subst) Map ModuleName OpenModule
insts

    substModule :: Map ModuleName (Module, BuildStyle) -> OpenModule -> InstM (Module, BuildStyle)
    substModule :: Map ModuleName (Module, BuildStyle)
-> OpenModule
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     (Module, BuildStyle)
substModule Map ModuleName (Module, BuildStyle)
subst (OpenModuleVar ModuleName
mod_name)
        | Just (Module, BuildStyle)
m <- ModuleName
-> Map ModuleName (Module, BuildStyle)
-> Maybe (Module, BuildStyle)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ModuleName
mod_name Map ModuleName (Module, BuildStyle)
subst = (Module, BuildStyle)
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     (Module, BuildStyle)
forall (m :: * -> *) a. Monad m => a -> m a
return (Module, BuildStyle)
m
        | Bool
otherwise = FilePath
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     (Module, BuildStyle)
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"substModule: non-closing substitution"
    substModule Map ModuleName (Module, BuildStyle)
subst (OpenModule OpenUnitId
uid ModuleName
mod_name) = do
        (DefUnitId
uid', BuildStyle
build_style) <- Map ModuleName (Module, BuildStyle)
-> OpenUnitId -> InstM (DefUnitId, BuildStyle)
substUnitId Map ModuleName (Module, BuildStyle)
subst OpenUnitId
uid
        (Module, BuildStyle)
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     (Module, BuildStyle)
forall (m :: * -> *) a. Monad m => a -> m a
return (DefUnitId -> ModuleName -> Module
Module DefUnitId
uid' ModuleName
mod_name, BuildStyle
build_style)

    indefiniteUnitId :: ComponentId -> InstM UnitId
    indefiniteUnitId :: ComponentId -> InstM UnitId
indefiniteUnitId ComponentId
cid = do
        let uid :: UnitId
uid = ComponentId -> UnitId
newSimpleUnitId ComponentId
cid
        GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r <- UnitId
-> ComponentId
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
indefiniteComponent UnitId
uid ComponentId
cid
        (Map
   UnitId
   (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
 -> (UnitId,
     Map
       UnitId
       (GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage)))
-> InstM UnitId
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state ((Map
    UnitId
    (GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage)
  -> (UnitId,
      Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage)))
 -> InstM UnitId)
-> (Map
      UnitId
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage)
    -> (UnitId,
        Map
          UnitId
          (GenericPlanPackage
             InstalledPackageInfo ElaboratedConfiguredPackage)))
-> InstM UnitId
forall a b. (a -> b) -> a -> b
$ \Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s -> (UnitId
uid, UnitId
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert UnitId
uid GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
r Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
s)

    indefiniteComponent :: UnitId -> ComponentId -> InstM ElaboratedPlanPackage
    indefiniteComponent :: UnitId
-> ComponentId
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
indefiniteComponent UnitId
_uid ComponentId
cid
      -- Only need Configured; this phase happens before improvement, so
      -- there shouldn't be any Installed packages here.
      | Just (InstallPlan.Configured ElaboratedConfiguredPackage
epkg) <- ComponentId
-> Map
     ComponentId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ComponentId
cid Map
  ComponentId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
cmap
      , ElabComponent ElaboratedComponent
elab_comp <- ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
epkg
      = do -- We need to do a little more processing of the includes: some
           -- of them are fully definite even without substitution.  We
           -- want to build those too; see #5634.
           --
           -- This code mimics similar code in Distribution.Backpack.ReadyComponent;
           -- however, unlike the conversion from LinkedComponent to
           -- ReadyComponent, this transformation is done *without*
           -- changing the type in question; and what we are simply
           -- doing is enforcing tighter invariants on the data
           -- structure in question.  The new invariant is that there
           -- is no IndefFullUnitId in compLinkedLibDependencies that actually
           -- has no holes.  We couldn't specify this invariant when
           -- we initially created the ElaboratedPlanPackage because
           -- we have no way of actually reifying the UnitId into a
           -- DefiniteUnitId (that's what substUnitId does!)
           [OpenUnitId]
new_deps <- [OpenUnitId]
-> (OpenUnitId
    -> StateT
         (Map
            UnitId
            (GenericPlanPackage
               InstalledPackageInfo ElaboratedConfiguredPackage))
         Identity
         OpenUnitId)
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     [OpenUnitId]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (ElaboratedComponent -> [OpenUnitId]
compLinkedLibDependencies ElaboratedComponent
elab_comp) ((OpenUnitId
  -> StateT
       (Map
          UnitId
          (GenericPlanPackage
             InstalledPackageInfo ElaboratedConfiguredPackage))
       Identity
       OpenUnitId)
 -> StateT
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      Identity
      [OpenUnitId])
-> (OpenUnitId
    -> StateT
         (Map
            UnitId
            (GenericPlanPackage
               InstalledPackageInfo ElaboratedConfiguredPackage))
         Identity
         OpenUnitId)
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     [OpenUnitId]
forall a b. (a -> b) -> a -> b
$ \OpenUnitId
uid ->
             if Set ModuleName -> Bool
forall a. Set a -> Bool
Set.null (OpenUnitId -> Set ModuleName
openUnitIdFreeHoles OpenUnitId
uid)
                then ((DefUnitId, BuildStyle) -> OpenUnitId)
-> InstM (DefUnitId, BuildStyle)
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     OpenUnitId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DefUnitId -> OpenUnitId
DefiniteUnitId (DefUnitId -> OpenUnitId)
-> ((DefUnitId, BuildStyle) -> DefUnitId)
-> (DefUnitId, BuildStyle)
-> OpenUnitId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DefUnitId, BuildStyle) -> DefUnitId
forall a b. (a, b) -> a
fst) (Map ModuleName (Module, BuildStyle)
-> OpenUnitId -> InstM (DefUnitId, BuildStyle)
substUnitId Map ModuleName (Module, BuildStyle)
forall k a. Map k a
Map.empty OpenUnitId
uid)
                else OpenUnitId
-> StateT
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     Identity
     OpenUnitId
forall (m :: * -> *) a. Monad m => a -> m a
return OpenUnitId
uid
           -- NB: no fixupBuildStyle needed here, as if the indefinite
           -- component depends on any inplace packages, it itself must
           -- be indefinite!  There is no substitution here, we can't
           -- post facto add inplace deps
           GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall (m :: * -> *) a. Monad m => a -> m a
return (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> State
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
-> (ElaboratedConfiguredPackage
    -> GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage)
-> ElaboratedConfiguredPackage
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedConfiguredPackage
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
forall ipkg srcpkg. srcpkg -> GenericPlanPackage ipkg srcpkg
InstallPlan.Configured (ElaboratedConfiguredPackage
 -> State
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
-> ElaboratedConfiguredPackage
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage
epkg {
            elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp = ElaboratedComponent -> ElaboratedPackageOrComponent
ElabComponent ElaboratedComponent
elab_comp {
                compLinkedLibDependencies :: [OpenUnitId]
compLinkedLibDependencies = [OpenUnitId]
new_deps,
                -- I think this is right: any new definite unit ids we
                -- minted in the phase above need to be built before us.
                -- Add 'em in.  This doesn't remove any old dependencies
                -- on the indefinite package; they're harmless.
                compOrderLibDependencies :: [UnitId]
compOrderLibDependencies =
                    [UnitId] -> [UnitId]
forall a. Ord a => [a] -> [a]
ordNub ([UnitId] -> [UnitId]) -> [UnitId] -> [UnitId]
forall a b. (a -> b) -> a -> b
$ ElaboratedComponent -> [UnitId]
compOrderLibDependencies ElaboratedComponent
elab_comp [UnitId] -> [UnitId] -> [UnitId]
forall a. [a] -> [a] -> [a]
++
                             [DefUnitId -> UnitId
unDefUnitId DefUnitId
d | DefiniteUnitId DefUnitId
d <- [OpenUnitId]
new_deps]
            }
           }
      | Just GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
planpkg <- ComponentId
-> Map
     ComponentId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ComponentId
cid Map
  ComponentId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
cmap
      = GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall (m :: * -> *) a. Monad m => a -> m a
return GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
planpkg
      | Bool
otherwise = FilePath
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath
"indefiniteComponent: " FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ ComponentId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow ComponentId
cid)

    fixupBuildStyle :: BuildStyle
-> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
fixupBuildStyle BuildStyle
BuildAndInstall ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage
elab
    fixupBuildStyle BuildStyle
_ (elab :: ElaboratedConfiguredPackage
elab@ElaboratedConfiguredPackage { elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabBuildStyle = BuildStyle
BuildInplaceOnly }) = ElaboratedConfiguredPackage
elab
    fixupBuildStyle BuildStyle
BuildInplaceOnly ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage
elab {
      elabBuildStyle :: BuildStyle
elabBuildStyle = BuildStyle
BuildInplaceOnly,
      elabBuildPackageDBStack :: PackageDBStack
elabBuildPackageDBStack = ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack ElaboratedConfiguredPackage
elab,
      elabRegisterPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack = ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceRegisterPackageDBStack ElaboratedConfiguredPackage
elab,
      elabSetupPackageDBStack :: PackageDBStack
elabSetupPackageDBStack = ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack ElaboratedConfiguredPackage
elab
    }

    ready_map :: Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
ready_map = State
  (Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage))
  ()
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall s a. State s a -> s -> s
execState State
  (Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage))
  ()
work Map
  UnitId
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
forall k a. Map k a
Map.empty

    work :: State
  (Map
     UnitId
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage))
  ()
work = [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage
    -> State
         (Map
            UnitId
            (GenericPlanPackage
               InstalledPackageInfo ElaboratedConfiguredPackage))
         ())
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs ((GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage
  -> State
       (Map
          UnitId
          (GenericPlanPackage
             InstalledPackageInfo ElaboratedConfiguredPackage))
       ())
 -> State
      (Map
         UnitId
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
      ())
-> (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage
    -> State
         (Map
            UnitId
            (GenericPlanPackage
               InstalledPackageInfo ElaboratedConfiguredPackage))
         ())
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
forall a b. (a -> b) -> a -> b
$ \GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg ->
            case GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg of
                InstallPlan.Configured ElaboratedConfiguredPackage
elab
                    | Bool -> Bool
not (Map ModuleName OpenModule -> Bool
forall k a. Map k a -> Bool
Map.null (ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabLinkedInstantiatedWith ElaboratedConfiguredPackage
elab))
                    -> ComponentId -> InstM UnitId
indefiniteUnitId (ElaboratedConfiguredPackage -> ComponentId
elabComponentId ElaboratedConfiguredPackage
elab)
                        InstM UnitId
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ()
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
_ -> ComponentId
-> Map ModuleName (Module, BuildStyle)
-> InstM (DefUnitId, BuildStyle)
instantiateUnitId (GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> ComponentId
getComponentId GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg) Map ModuleName (Module, BuildStyle)
forall k a. Map k a
Map.empty
                        InstM (DefUnitId, BuildStyle)
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ()
-> State
     (Map
        UnitId
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
     ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

---------------------------
-- Build targets
--

-- Refer to ProjectPlanning.Types for details of these important types:

-- data ComponentTarget = ...
-- data SubComponentTarget = ...

-- One step in the build system is to translate higher level intentions like
-- "build this package", "test that package", or "repl that component" into
-- a more detailed specification of exactly which components to build (or other
-- actions like repl or build docs). This translation is somewhat different for
-- different commands. For example "test" for a package will build a different
-- set of components than "build". In addition, the translation of these
-- intentions can fail. For example "run" for a package is only unambiguous
-- when the package has a single executable.
--
-- So we need a little bit of infrastructure to make it easy for the command
-- implementations to select what component targets are meant when a user asks
-- to do something with a package or component. To do this (and to be able to
-- produce good error messages for mistakes and when targets are not available)
-- we need to gather and summarise accurate information about all the possible
-- targets, both available and unavailable. Then a command implementation can
-- decide which of the available component targets should be selected.

-- | An available target represents a component within a package that a user
-- command could plausibly refer to. In this sense, all the components defined
-- within the package are things the user could refer to, whether or not it
-- would actually be possible to build that component.
--
-- In particular the available target contains an 'AvailableTargetStatus' which
-- informs us about whether it's actually possible to select this component to
-- be built, and if not why not. This detail makes it possible for command
-- implementations (like @build@, @test@ etc) to accurately report why a target
-- cannot be used.
--
-- Note that the type parameter is used to help enforce that command
-- implementations can only select targets that can actually be built (by
-- forcing them to return the @k@ value for the selected targets).
-- In particular 'resolveTargets' makes use of this (with @k@ as
-- @('UnitId', ComponentName')@) to identify the targets thus selected.
--
data AvailableTarget k = AvailableTarget {
       AvailableTarget k -> PackageId
availableTargetPackageId      :: PackageId,
       AvailableTarget k -> ComponentName
availableTargetComponentName  :: ComponentName,
       AvailableTarget k -> AvailableTargetStatus k
availableTargetStatus         :: AvailableTargetStatus k,
       AvailableTarget k -> Bool
availableTargetLocalToProject :: Bool
     }
  deriving (AvailableTarget k -> AvailableTarget k -> Bool
(AvailableTarget k -> AvailableTarget k -> Bool)
-> (AvailableTarget k -> AvailableTarget k -> Bool)
-> Eq (AvailableTarget k)
forall k. Eq k => AvailableTarget k -> AvailableTarget k -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AvailableTarget k -> AvailableTarget k -> Bool
$c/= :: forall k. Eq k => AvailableTarget k -> AvailableTarget k -> Bool
== :: AvailableTarget k -> AvailableTarget k -> Bool
$c== :: forall k. Eq k => AvailableTarget k -> AvailableTarget k -> Bool
Eq, Int -> AvailableTarget k -> FilePath -> FilePath
[AvailableTarget k] -> FilePath -> FilePath
AvailableTarget k -> FilePath
(Int -> AvailableTarget k -> FilePath -> FilePath)
-> (AvailableTarget k -> FilePath)
-> ([AvailableTarget k] -> FilePath -> FilePath)
-> Show (AvailableTarget k)
forall k.
Show k =>
Int -> AvailableTarget k -> FilePath -> FilePath
forall k. Show k => [AvailableTarget k] -> FilePath -> FilePath
forall k. Show k => AvailableTarget k -> FilePath
forall a.
(Int -> a -> FilePath -> FilePath)
-> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
showList :: [AvailableTarget k] -> FilePath -> FilePath
$cshowList :: forall k. Show k => [AvailableTarget k] -> FilePath -> FilePath
show :: AvailableTarget k -> FilePath
$cshow :: forall k. Show k => AvailableTarget k -> FilePath
showsPrec :: Int -> AvailableTarget k -> FilePath -> FilePath
$cshowsPrec :: forall k.
Show k =>
Int -> AvailableTarget k -> FilePath -> FilePath
Show, a -> AvailableTarget b -> AvailableTarget a
(a -> b) -> AvailableTarget a -> AvailableTarget b
(forall a b. (a -> b) -> AvailableTarget a -> AvailableTarget b)
-> (forall a b. a -> AvailableTarget b -> AvailableTarget a)
-> Functor AvailableTarget
forall a b. a -> AvailableTarget b -> AvailableTarget a
forall a b. (a -> b) -> AvailableTarget a -> AvailableTarget b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AvailableTarget b -> AvailableTarget a
$c<$ :: forall a b. a -> AvailableTarget b -> AvailableTarget a
fmap :: (a -> b) -> AvailableTarget a -> AvailableTarget b
$cfmap :: forall a b. (a -> b) -> AvailableTarget a -> AvailableTarget b
Functor)

-- | The status of a an 'AvailableTarget' component. This tells us whether
-- it's actually possible to select this component to be built, and if not
-- why not.
--
data AvailableTargetStatus k =
       TargetDisabledByUser   -- ^ When the user does @tests: False@
     | TargetDisabledBySolver -- ^ When the solver could not enable tests
     | TargetNotBuildable     -- ^ When the component has @buildable: False@
     | TargetNotLocal         -- ^ When the component is non-core in a non-local package
     | TargetBuildable k TargetRequested -- ^ The target can or should be built
  deriving (AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
(AvailableTargetStatus k -> AvailableTargetStatus k -> Bool)
-> (AvailableTargetStatus k -> AvailableTargetStatus k -> Bool)
-> Eq (AvailableTargetStatus k)
forall k.
Eq k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
$c/= :: forall k.
Eq k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
== :: AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
$c== :: forall k.
Eq k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
Eq, Eq (AvailableTargetStatus k)
Eq (AvailableTargetStatus k)
-> (AvailableTargetStatus k -> AvailableTargetStatus k -> Ordering)
-> (AvailableTargetStatus k -> AvailableTargetStatus k -> Bool)
-> (AvailableTargetStatus k -> AvailableTargetStatus k -> Bool)
-> (AvailableTargetStatus k -> AvailableTargetStatus k -> Bool)
-> (AvailableTargetStatus k -> AvailableTargetStatus k -> Bool)
-> (AvailableTargetStatus k
    -> AvailableTargetStatus k -> AvailableTargetStatus k)
-> (AvailableTargetStatus k
    -> AvailableTargetStatus k -> AvailableTargetStatus k)
-> Ord (AvailableTargetStatus k)
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
AvailableTargetStatus k -> AvailableTargetStatus k -> Ordering
AvailableTargetStatus k
-> AvailableTargetStatus k -> AvailableTargetStatus k
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k. Ord k => Eq (AvailableTargetStatus k)
forall k.
Ord k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
forall k.
Ord k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Ordering
forall k.
Ord k =>
AvailableTargetStatus k
-> AvailableTargetStatus k -> AvailableTargetStatus k
min :: AvailableTargetStatus k
-> AvailableTargetStatus k -> AvailableTargetStatus k
$cmin :: forall k.
Ord k =>
AvailableTargetStatus k
-> AvailableTargetStatus k -> AvailableTargetStatus k
max :: AvailableTargetStatus k
-> AvailableTargetStatus k -> AvailableTargetStatus k
$cmax :: forall k.
Ord k =>
AvailableTargetStatus k
-> AvailableTargetStatus k -> AvailableTargetStatus k
>= :: AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
$c>= :: forall k.
Ord k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
> :: AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
$c> :: forall k.
Ord k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
<= :: AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
$c<= :: forall k.
Ord k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
< :: AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
$c< :: forall k.
Ord k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Bool
compare :: AvailableTargetStatus k -> AvailableTargetStatus k -> Ordering
$ccompare :: forall k.
Ord k =>
AvailableTargetStatus k -> AvailableTargetStatus k -> Ordering
$cp1Ord :: forall k. Ord k => Eq (AvailableTargetStatus k)
Ord, Int -> AvailableTargetStatus k -> FilePath -> FilePath
[AvailableTargetStatus k] -> FilePath -> FilePath
AvailableTargetStatus k -> FilePath
(Int -> AvailableTargetStatus k -> FilePath -> FilePath)
-> (AvailableTargetStatus k -> FilePath)
-> ([AvailableTargetStatus k] -> FilePath -> FilePath)
-> Show (AvailableTargetStatus k)
forall k.
Show k =>
Int -> AvailableTargetStatus k -> FilePath -> FilePath
forall k.
Show k =>
[AvailableTargetStatus k] -> FilePath -> FilePath
forall k. Show k => AvailableTargetStatus k -> FilePath
forall a.
(Int -> a -> FilePath -> FilePath)
-> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
showList :: [AvailableTargetStatus k] -> FilePath -> FilePath
$cshowList :: forall k.
Show k =>
[AvailableTargetStatus k] -> FilePath -> FilePath
show :: AvailableTargetStatus k -> FilePath
$cshow :: forall k. Show k => AvailableTargetStatus k -> FilePath
showsPrec :: Int -> AvailableTargetStatus k -> FilePath -> FilePath
$cshowsPrec :: forall k.
Show k =>
Int -> AvailableTargetStatus k -> FilePath -> FilePath
Show, a -> AvailableTargetStatus b -> AvailableTargetStatus a
(a -> b) -> AvailableTargetStatus a -> AvailableTargetStatus b
(forall a b.
 (a -> b) -> AvailableTargetStatus a -> AvailableTargetStatus b)
-> (forall a b.
    a -> AvailableTargetStatus b -> AvailableTargetStatus a)
-> Functor AvailableTargetStatus
forall a b. a -> AvailableTargetStatus b -> AvailableTargetStatus a
forall a b.
(a -> b) -> AvailableTargetStatus a -> AvailableTargetStatus b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AvailableTargetStatus b -> AvailableTargetStatus a
$c<$ :: forall a b. a -> AvailableTargetStatus b -> AvailableTargetStatus a
fmap :: (a -> b) -> AvailableTargetStatus a -> AvailableTargetStatus b
$cfmap :: forall a b.
(a -> b) -> AvailableTargetStatus a -> AvailableTargetStatus b
Functor)

-- | This tells us whether a target ought to be built by default, or only if
-- specifically requested. The policy is that components like libraries and
-- executables are built by default by @build@, but test suites and benchmarks
-- are not, unless this is overridden in the project configuration.
--
data TargetRequested =
       TargetRequestedByDefault    -- ^ To be built by default
     | TargetNotRequestedByDefault -- ^ Not to be built by default
  deriving (TargetRequested -> TargetRequested -> Bool
(TargetRequested -> TargetRequested -> Bool)
-> (TargetRequested -> TargetRequested -> Bool)
-> Eq TargetRequested
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TargetRequested -> TargetRequested -> Bool
$c/= :: TargetRequested -> TargetRequested -> Bool
== :: TargetRequested -> TargetRequested -> Bool
$c== :: TargetRequested -> TargetRequested -> Bool
Eq, Eq TargetRequested
Eq TargetRequested
-> (TargetRequested -> TargetRequested -> Ordering)
-> (TargetRequested -> TargetRequested -> Bool)
-> (TargetRequested -> TargetRequested -> Bool)
-> (TargetRequested -> TargetRequested -> Bool)
-> (TargetRequested -> TargetRequested -> Bool)
-> (TargetRequested -> TargetRequested -> TargetRequested)
-> (TargetRequested -> TargetRequested -> TargetRequested)
-> Ord TargetRequested
TargetRequested -> TargetRequested -> Bool
TargetRequested -> TargetRequested -> Ordering
TargetRequested -> TargetRequested -> TargetRequested
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TargetRequested -> TargetRequested -> TargetRequested
$cmin :: TargetRequested -> TargetRequested -> TargetRequested
max :: TargetRequested -> TargetRequested -> TargetRequested
$cmax :: TargetRequested -> TargetRequested -> TargetRequested
>= :: TargetRequested -> TargetRequested -> Bool
$c>= :: TargetRequested -> TargetRequested -> Bool
> :: TargetRequested -> TargetRequested -> Bool
$c> :: TargetRequested -> TargetRequested -> Bool
<= :: TargetRequested -> TargetRequested -> Bool
$c<= :: TargetRequested -> TargetRequested -> Bool
< :: TargetRequested -> TargetRequested -> Bool
$c< :: TargetRequested -> TargetRequested -> Bool
compare :: TargetRequested -> TargetRequested -> Ordering
$ccompare :: TargetRequested -> TargetRequested -> Ordering
$cp1Ord :: Eq TargetRequested
Ord, Int -> TargetRequested -> FilePath -> FilePath
[TargetRequested] -> FilePath -> FilePath
TargetRequested -> FilePath
(Int -> TargetRequested -> FilePath -> FilePath)
-> (TargetRequested -> FilePath)
-> ([TargetRequested] -> FilePath -> FilePath)
-> Show TargetRequested
forall a.
(Int -> a -> FilePath -> FilePath)
-> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
showList :: [TargetRequested] -> FilePath -> FilePath
$cshowList :: [TargetRequested] -> FilePath -> FilePath
show :: TargetRequested -> FilePath
$cshow :: TargetRequested -> FilePath
showsPrec :: Int -> TargetRequested -> FilePath -> FilePath
$cshowsPrec :: Int -> TargetRequested -> FilePath -> FilePath
Show)

-- | Given the install plan, produce the set of 'AvailableTarget's for each
-- package-component pair.
--
-- Typically there will only be one such target for each component, but for
-- example if we have a plan with both normal and profiling variants of a
-- component then we would get both as available targets, or similarly if we
-- had a plan that contained two instances of the same version of a package.
-- This approach makes it relatively easy to select all instances\/variants
-- of a component.
--
availableTargets :: ElaboratedInstallPlan
                 -> Map (PackageId, ComponentName)
                        [AvailableTarget (UnitId, ComponentName)]
availableTargets :: ElaboratedInstallPlan
-> Map
     (PackageId, ComponentName)
     [AvailableTarget (UnitId, ComponentName)]
availableTargets ElaboratedInstallPlan
installPlan =
    let rs :: [(PackageId, ComponentName, Bool,
  AvailableTarget (UnitId, ComponentName))]
rs = [ (PackageId
pkgid, ComponentName
cname, Bool
fake, AvailableTarget (UnitId, ComponentName)
target)
             | GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg <- ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> [GenericPlanPackage ipkg srcpkg]
InstallPlan.toList ElaboratedInstallPlan
installPlan
             , (PackageId
pkgid, ComponentName
cname, Bool
fake, AvailableTarget (UnitId, ComponentName)
target) <- case GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg of
                 InstallPlan.PreExisting InstalledPackageInfo
ipkg -> InstalledPackageInfo
-> [(PackageId, ComponentName, Bool,
     AvailableTarget (UnitId, ComponentName))]
availableInstalledTargets InstalledPackageInfo
ipkg
                 InstallPlan.Installed   ElaboratedConfiguredPackage
elab -> ElaboratedConfiguredPackage
-> [(PackageId, ComponentName, Bool,
     AvailableTarget (UnitId, ComponentName))]
availableSourceTargets ElaboratedConfiguredPackage
elab
                 InstallPlan.Configured  ElaboratedConfiguredPackage
elab -> ElaboratedConfiguredPackage
-> [(PackageId, ComponentName, Bool,
     AvailableTarget (UnitId, ComponentName))]
availableSourceTargets ElaboratedConfiguredPackage
elab
             ]
     in Map
  (PackageId, ComponentName)
  [AvailableTarget (UnitId, ComponentName)]
-> Map
     (PackageId, ComponentName)
     [AvailableTarget (UnitId, ComponentName)]
-> Map
     (PackageId, ComponentName)
     [AvailableTarget (UnitId, ComponentName)]
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union
         (([AvailableTarget (UnitId, ComponentName)]
 -> [AvailableTarget (UnitId, ComponentName)]
 -> [AvailableTarget (UnitId, ComponentName)])
-> [((PackageId, ComponentName),
     [AvailableTarget (UnitId, ComponentName)])]
-> Map
     (PackageId, ComponentName)
     [AvailableTarget (UnitId, ComponentName)]
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith [AvailableTarget (UnitId, ComponentName)]
-> [AvailableTarget (UnitId, ComponentName)]
-> [AvailableTarget (UnitId, ComponentName)]
forall a. [a] -> [a] -> [a]
(++)
            [ ((PackageId
pkgid, ComponentName
cname), [AvailableTarget (UnitId, ComponentName)
target])
            | (PackageId
pkgid, ComponentName
cname, Bool
fake, AvailableTarget (UnitId, ComponentName)
target) <- [(PackageId, ComponentName, Bool,
  AvailableTarget (UnitId, ComponentName))]
rs, Bool -> Bool
not Bool
fake])
         ([((PackageId, ComponentName),
  [AvailableTarget (UnitId, ComponentName)])]
-> Map
     (PackageId, ComponentName)
     [AvailableTarget (UnitId, ComponentName)]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
            [ ((PackageId
pkgid, ComponentName
cname), [AvailableTarget (UnitId, ComponentName)
target])
            | (PackageId
pkgid, ComponentName
cname, Bool
fake, AvailableTarget (UnitId, ComponentName)
target) <- [(PackageId, ComponentName, Bool,
  AvailableTarget (UnitId, ComponentName))]
rs, Bool
fake])
    -- The normal targets mask the fake ones. We get all instances of the
    -- normal ones and only one copy of the fake ones (as there are many
    -- duplicates of the fake ones). See 'availableSourceTargets' below for
    -- more details on this fake stuff is about.

availableInstalledTargets :: IPI.InstalledPackageInfo
                          -> [(PackageId, ComponentName, Bool,
                               AvailableTarget (UnitId, ComponentName))]
availableInstalledTargets :: InstalledPackageInfo
-> [(PackageId, ComponentName, Bool,
     AvailableTarget (UnitId, ComponentName))]
availableInstalledTargets InstalledPackageInfo
ipkg =
    let unitid :: UnitId
unitid = InstalledPackageInfo -> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId InstalledPackageInfo
ipkg
        cname :: ComponentName
cname  = LibraryName -> ComponentName
CLibName LibraryName
LMainLibName
        status :: AvailableTargetStatus (UnitId, ComponentName)
status = (UnitId, ComponentName)
-> TargetRequested -> AvailableTargetStatus (UnitId, ComponentName)
forall k. k -> TargetRequested -> AvailableTargetStatus k
TargetBuildable (UnitId
unitid, ComponentName
cname) TargetRequested
TargetRequestedByDefault
        target :: AvailableTarget (UnitId, ComponentName)
target = PackageId
-> ComponentName
-> AvailableTargetStatus (UnitId, ComponentName)
-> Bool
-> AvailableTarget (UnitId, ComponentName)
forall k.
PackageId
-> ComponentName
-> AvailableTargetStatus k
-> Bool
-> AvailableTarget k
AvailableTarget (InstalledPackageInfo -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId InstalledPackageInfo
ipkg) ComponentName
cname AvailableTargetStatus (UnitId, ComponentName)
status Bool
False
        fake :: Bool
fake   = Bool
False
     in [(InstalledPackageInfo -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId InstalledPackageInfo
ipkg, ComponentName
cname, Bool
fake, AvailableTarget (UnitId, ComponentName)
target)]

availableSourceTargets :: ElaboratedConfiguredPackage
                       -> [(PackageId, ComponentName, Bool,
                            AvailableTarget (UnitId, ComponentName))]
availableSourceTargets :: ElaboratedConfiguredPackage
-> [(PackageId, ComponentName, Bool,
     AvailableTarget (UnitId, ComponentName))]
availableSourceTargets ElaboratedConfiguredPackage
elab =
    -- We have a somewhat awkward problem here. We need to know /all/ the
    -- components from /all/ the packages because these are the things that
    -- users could refer to. Unfortunately, at this stage the elaborated install
    -- plan does /not/ contain all components: some components have already
    -- been deleted because they cannot possibly be built. This is the case
    -- for components that are marked @buildable: False@ in their .cabal files.
    -- (It's not unreasonable that the unbuildable components have been pruned
    -- as the plan invariant is considerably simpler if all nodes can be built)
    --
    -- We can recover the missing components but it's not exactly elegant. For
    -- a graph node corresponding to a component we still have the information
    -- about the package that it came from, and this includes the names of
    -- /all/ the other components in the package. So in principle this lets us
    -- find the names of all components, plus full details of the buildable
    -- components.
    --
    -- Consider for example a package with 3 exe components: foo, bar and baz
    -- where foo and bar are buildable, but baz is not. So the plan contains
    -- nodes for the components foo and bar. Now we look at each of these two
    -- nodes and look at the package they come from and the names of the
    -- components in this package. This will give us the names foo, bar and
    -- baz, twice (once for each of the two buildable components foo and bar).
    --
    -- We refer to these reconstructed missing components as fake targets.
    -- It is an invariant that they are not available to be built.
    --
    -- To produce the final set of targets we put the fake targets in a finite
    -- map (thus eliminating the duplicates) and then we overlay that map with
    -- the normal buildable targets. (This is done above in 'availableTargets'.)
    --
    [ (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab, ComponentName
cname, Bool
fake, AvailableTarget (UnitId, ComponentName)
target)
    | Component
component <- PackageDescription -> [Component]
pkgComponents (ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
elab)
    , let cname :: ComponentName
cname  = Component -> ComponentName
componentName Component
component
          status :: AvailableTargetStatus (UnitId, ComponentName)
status = Component -> AvailableTargetStatus (UnitId, ComponentName)
componentAvailableTargetStatus Component
component
          target :: AvailableTarget (UnitId, ComponentName)
target = AvailableTarget :: forall k.
PackageId
-> ComponentName
-> AvailableTargetStatus k
-> Bool
-> AvailableTarget k
AvailableTarget {
                     availableTargetPackageId :: PackageId
availableTargetPackageId      = ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab,
                     availableTargetComponentName :: ComponentName
availableTargetComponentName  = ComponentName
cname,
                     availableTargetStatus :: AvailableTargetStatus (UnitId, ComponentName)
availableTargetStatus         = AvailableTargetStatus (UnitId, ComponentName)
status,
                     availableTargetLocalToProject :: Bool
availableTargetLocalToProject = ElaboratedConfiguredPackage -> Bool
elabLocalToProject ElaboratedConfiguredPackage
elab
                   }
          fake :: Bool
fake   = ComponentName -> Bool
isFakeTarget ComponentName
cname

    -- TODO: The goal of this test is to exclude "instantiated"
    -- packages as available targets. This means that you can't
    -- ask for a particular instantiated component to be built;
    -- it will only get built by a dependency.  Perhaps the
    -- correct way to implement this is to run selection
    -- prior to instantiating packages.  If you refactor
    -- this, then you can delete this test.
    , ElaboratedConfiguredPackage -> Bool
elabIsCanonical ElaboratedConfiguredPackage
elab

      -- Filter out some bogus parts of the cross product that are never needed
    , case AvailableTargetStatus (UnitId, ComponentName)
status of
        TargetBuildable{} | Bool
fake -> Bool
False
        AvailableTargetStatus (UnitId, ComponentName)
_                        -> Bool
True
    ]
  where
    isFakeTarget :: ComponentName -> Bool
isFakeTarget ComponentName
cname =
      case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
        ElabPackage ElaboratedPackage
_               -> Bool
False
        ElabComponent ElaboratedComponent
elabComponent -> ElaboratedComponent -> Maybe ComponentName
compComponentName ElaboratedComponent
elabComponent
                                       Maybe ComponentName -> Maybe ComponentName -> Bool
forall a. Eq a => a -> a -> Bool
/= ComponentName -> Maybe ComponentName
forall a. a -> Maybe a
Just ComponentName
cname

    componentAvailableTargetStatus
      :: Component -> AvailableTargetStatus (UnitId, ComponentName)
    componentAvailableTargetStatus :: Component -> AvailableTargetStatus (UnitId, ComponentName)
componentAvailableTargetStatus Component
component =
        case Component -> Maybe OptionalStanza
componentOptionalStanza (Component -> Maybe OptionalStanza)
-> Component -> Maybe OptionalStanza
forall a b. (a -> b) -> a -> b
$ ComponentName -> Component
CD.componentNameToComponent ComponentName
cname of
          -- it is not an optional stanza, so a library, exe or foreign lib
          Maybe OptionalStanza
Nothing
            | Bool -> Bool
not Bool
buildable  -> AvailableTargetStatus (UnitId, ComponentName)
forall k. AvailableTargetStatus k
TargetNotBuildable
            | Bool
otherwise      -> (UnitId, ComponentName)
-> TargetRequested -> AvailableTargetStatus (UnitId, ComponentName)
forall k. k -> TargetRequested -> AvailableTargetStatus k
TargetBuildable (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
elab, ComponentName
cname)
                                                TargetRequested
TargetRequestedByDefault

          -- it is not an optional stanza, so a testsuite or benchmark
          Just OptionalStanza
stanza ->
            case (OptionalStanza -> OptionalStanzaMap (Maybe Bool) -> Maybe Bool
forall a. OptionalStanza -> OptionalStanzaMap a -> a
optStanzaLookup OptionalStanza
stanza (ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasRequested ElaboratedConfiguredPackage
elab), -- TODO
                  OptionalStanza -> OptionalStanzaSet -> Bool
optStanzaSetMember OptionalStanza
stanza (ElaboratedConfiguredPackage -> OptionalStanzaSet
elabStanzasAvailable ElaboratedConfiguredPackage
elab)) of
              (Maybe Bool, Bool)
_ | Bool -> Bool
not Bool
withinPlan -> AvailableTargetStatus (UnitId, ComponentName)
forall k. AvailableTargetStatus k
TargetNotLocal
              (Just Bool
False,   Bool
_)  -> AvailableTargetStatus (UnitId, ComponentName)
forall k. AvailableTargetStatus k
TargetDisabledByUser
              (Maybe Bool
Nothing,  Bool
False)  -> AvailableTargetStatus (UnitId, ComponentName)
forall k. AvailableTargetStatus k
TargetDisabledBySolver
              (Maybe Bool, Bool)
_ | Bool -> Bool
not Bool
buildable  -> AvailableTargetStatus (UnitId, ComponentName)
forall k. AvailableTargetStatus k
TargetNotBuildable
              (Just Bool
True, Bool
True)  -> (UnitId, ComponentName)
-> TargetRequested -> AvailableTargetStatus (UnitId, ComponentName)
forall k. k -> TargetRequested -> AvailableTargetStatus k
TargetBuildable (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
elab, ComponentName
cname)
                                                    TargetRequested
TargetRequestedByDefault
              (Maybe Bool
Nothing,   Bool
True)  -> (UnitId, ComponentName)
-> TargetRequested -> AvailableTargetStatus (UnitId, ComponentName)
forall k. k -> TargetRequested -> AvailableTargetStatus k
TargetBuildable (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
elab, ComponentName
cname)
                                                    TargetRequested
TargetNotRequestedByDefault
              (Just Bool
True, Bool
False) ->
                FilePath -> AvailableTargetStatus (UnitId, ComponentName)
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath -> AvailableTargetStatus (UnitId, ComponentName))
-> FilePath -> AvailableTargetStatus (UnitId, ComponentName)
forall a b. (a -> b) -> a -> b
$ FilePath
"componentAvailableTargetStatus: impossible; cname=" FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ ComponentName -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow ComponentName
cname
      where
        cname :: ComponentName
cname      = Component -> ComponentName
componentName Component
component
        buildable :: Bool
buildable  = BuildInfo -> Bool
PD.buildable (Component -> BuildInfo
componentBuildInfo Component
component)
        withinPlan :: Bool
withinPlan = ElaboratedConfiguredPackage -> Bool
elabLocalToProject ElaboratedConfiguredPackage
elab
                  Bool -> Bool -> Bool
|| case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
                       ElabComponent ElaboratedComponent
elabComponent ->
                         ElaboratedComponent -> Maybe ComponentName
compComponentName ElaboratedComponent
elabComponent Maybe ComponentName -> Maybe ComponentName -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentName -> Maybe ComponentName
forall a. a -> Maybe a
Just ComponentName
cname
                       ElabPackage ElaboratedPackage
_ ->
                         case Component -> ComponentName
componentName Component
component of
                           CLibName (LibraryName
LMainLibName) -> Bool
True
                           CExeName UnqualComponentName
_ -> Bool
True
                           --TODO: what about sub-libs and foreign libs?
                           ComponentName
_          -> Bool
False

-- | Merge component targets that overlap each other. Specially when we have
-- multiple targets for the same component and one of them refers to the whole
-- component (rather than a module or file within) then all the other targets
-- for that component are subsumed.
--
-- We also allow for information associated with each component target, and
-- whenever we targets subsume each other we aggregate their associated info.
--
nubComponentTargets :: [(ComponentTarget, a)] -> [(ComponentTarget, NonEmpty a)]
nubComponentTargets :: [(ComponentTarget, a)] -> [(ComponentTarget, NonEmpty a)]
nubComponentTargets =
    ([(ComponentName, (ComponentTarget, a))]
 -> [(ComponentTarget, NonEmpty a)])
-> [[(ComponentName, (ComponentTarget, a))]]
-> [(ComponentTarget, NonEmpty a)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ([(ComponentTarget, a)] -> [(ComponentTarget, NonEmpty a)]
forall a. [(ComponentTarget, a)] -> [(ComponentTarget, NonEmpty a)]
wholeComponentOverrides ([(ComponentTarget, a)] -> [(ComponentTarget, NonEmpty a)])
-> ([(ComponentName, (ComponentTarget, a))]
    -> [(ComponentTarget, a)])
-> [(ComponentName, (ComponentTarget, a))]
-> [(ComponentTarget, NonEmpty a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((ComponentName, (ComponentTarget, a)) -> (ComponentTarget, a))
-> [(ComponentName, (ComponentTarget, a))]
-> [(ComponentTarget, a)]
forall a b. (a -> b) -> [a] -> [b]
map (ComponentName, (ComponentTarget, a)) -> (ComponentTarget, a)
forall a b. (a, b) -> b
snd)
  ([[(ComponentName, (ComponentTarget, a))]]
 -> [(ComponentTarget, NonEmpty a)])
-> ([(ComponentTarget, a)]
    -> [[(ComponentName, (ComponentTarget, a))]])
-> [(ComponentTarget, a)]
-> [(ComponentTarget, NonEmpty a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((ComponentName, (ComponentTarget, a))
 -> (ComponentName, (ComponentTarget, a)) -> Bool)
-> [(ComponentName, (ComponentTarget, a))]
-> [[(ComponentName, (ComponentTarget, a))]]
forall a. (a -> a -> Bool) -> [a] -> [[a]]
groupBy (ComponentName -> ComponentName -> Bool
forall a. Eq a => a -> a -> Bool
(==)    (ComponentName -> ComponentName -> Bool)
-> ((ComponentName, (ComponentTarget, a)) -> ComponentName)
-> (ComponentName, (ComponentTarget, a))
-> (ComponentName, (ComponentTarget, a))
-> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (ComponentName, (ComponentTarget, a)) -> ComponentName
forall a b. (a, b) -> a
fst)
  ([(ComponentName, (ComponentTarget, a))]
 -> [[(ComponentName, (ComponentTarget, a))]])
-> ([(ComponentTarget, a)]
    -> [(ComponentName, (ComponentTarget, a))])
-> [(ComponentTarget, a)]
-> [[(ComponentName, (ComponentTarget, a))]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((ComponentName, (ComponentTarget, a))
 -> (ComponentName, (ComponentTarget, a)) -> Ordering)
-> [(ComponentName, (ComponentTarget, a))]
-> [(ComponentName, (ComponentTarget, a))]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy  (ComponentName -> ComponentName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (ComponentName -> ComponentName -> Ordering)
-> ((ComponentName, (ComponentTarget, a)) -> ComponentName)
-> (ComponentName, (ComponentTarget, a))
-> (ComponentName, (ComponentTarget, a))
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (ComponentName, (ComponentTarget, a)) -> ComponentName
forall a b. (a, b) -> a
fst)
  ([(ComponentName, (ComponentTarget, a))]
 -> [(ComponentName, (ComponentTarget, a))])
-> ([(ComponentTarget, a)]
    -> [(ComponentName, (ComponentTarget, a))])
-> [(ComponentTarget, a)]
-> [(ComponentName, (ComponentTarget, a))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((ComponentTarget, a) -> (ComponentName, (ComponentTarget, a)))
-> [(ComponentTarget, a)]
-> [(ComponentName, (ComponentTarget, a))]
forall a b. (a -> b) -> [a] -> [b]
map (\t :: (ComponentTarget, a)
t@((ComponentTarget ComponentName
cname SubComponentTarget
_, a
_)) -> (ComponentName
cname, (ComponentTarget, a)
t))
  ([(ComponentTarget, a)] -> [(ComponentName, (ComponentTarget, a))])
-> ([(ComponentTarget, a)] -> [(ComponentTarget, a)])
-> [(ComponentTarget, a)]
-> [(ComponentName, (ComponentTarget, a))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((ComponentTarget, a) -> (ComponentTarget, a))
-> [(ComponentTarget, a)] -> [(ComponentTarget, a)]
forall a b. (a -> b) -> [a] -> [b]
map (ComponentTarget, a) -> (ComponentTarget, a)
forall a. (ComponentTarget, a) -> (ComponentTarget, a)
compatSubComponentTargets
  where
    -- If we're building the whole component then that the only target all we
    -- need, otherwise we can have several targets within the component.
    wholeComponentOverrides :: [(ComponentTarget,  a )]
                            -> [(ComponentTarget, NonEmpty a)]
    wholeComponentOverrides :: [(ComponentTarget, a)] -> [(ComponentTarget, NonEmpty a)]
wholeComponentOverrides [(ComponentTarget, a)]
ts =
      case [ (ComponentTarget, a)
ta | ta :: (ComponentTarget, a)
ta@(ComponentTarget ComponentName
_ SubComponentTarget
WholeComponent, a
_) <- [(ComponentTarget, a)]
ts ] of
        ((ComponentTarget
t, a
x):[(ComponentTarget, a)]
_) ->
                let
                    -- Delete tuple (t, x) from original list to avoid duplicates.
                    -- Use 'deleteBy', to avoid additional Class constraint on 'nubComponentTargets'.
                    ts' :: [(ComponentTarget, a)]
ts' = ((ComponentTarget, a) -> (ComponentTarget, a) -> Bool)
-> (ComponentTarget, a)
-> [(ComponentTarget, a)]
-> [(ComponentTarget, a)]
forall a. (a -> a -> Bool) -> a -> [a] -> [a]
deleteBy (\(ComponentTarget
t1, a
_) (ComponentTarget
t2, a
_) -> ComponentTarget
t1 ComponentTarget -> ComponentTarget -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentTarget
t2) (ComponentTarget
t, a
x) [(ComponentTarget, a)]
ts
                in
                    [ (ComponentTarget
t, a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| ((ComponentTarget, a) -> a) -> [(ComponentTarget, a)] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map (ComponentTarget, a) -> a
forall a b. (a, b) -> b
snd [(ComponentTarget, a)]
ts') ]
        []    -> [ (ComponentTarget
t, a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| []) | (ComponentTarget
t,a
x) <- [(ComponentTarget, a)]
ts ]

    -- Not all Cabal Setup.hs versions support sub-component targets, so switch
    -- them over to the whole component
    compatSubComponentTargets :: (ComponentTarget, a) -> (ComponentTarget, a)
    compatSubComponentTargets :: (ComponentTarget, a) -> (ComponentTarget, a)
compatSubComponentTargets target :: (ComponentTarget, a)
target@(ComponentTarget ComponentName
cname SubComponentTarget
_subtarget, a
x)
      | Bool -> Bool
not Bool
setupHsSupportsSubComponentTargets
                  = (ComponentName -> SubComponentTarget -> ComponentTarget
ComponentTarget ComponentName
cname SubComponentTarget
WholeComponent, a
x)
      | Bool
otherwise = (ComponentTarget, a)
target

    -- Actually the reality is that no current version of Cabal's Setup.hs
    -- build command actually support building specific files or modules.
    setupHsSupportsSubComponentTargets :: Bool
setupHsSupportsSubComponentTargets = Bool
False
    -- TODO: when that changes, adjust this test, e.g.
    -- | pkgSetupScriptCliVersion >= Version [x,y] []

pkgHasEphemeralBuildTargets :: ElaboratedConfiguredPackage -> Bool
pkgHasEphemeralBuildTargets :: ElaboratedConfiguredPackage -> Bool
pkgHasEphemeralBuildTargets ElaboratedConfiguredPackage
elab =
    Maybe ComponentTarget -> Bool
forall a. Maybe a -> Bool
isJust (ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabReplTarget ElaboratedConfiguredPackage
elab)
 Bool -> Bool -> Bool
|| (Bool -> Bool
not (Bool -> Bool)
-> ([ComponentTarget] -> Bool) -> [ComponentTarget] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) (ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets ElaboratedConfiguredPackage
elab)
 Bool -> Bool -> Bool
|| (Bool -> Bool
not (Bool -> Bool)
-> ([ComponentTarget] -> Bool) -> [ComponentTarget] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) (ElaboratedConfiguredPackage -> [ComponentTarget]
elabBenchTargets ElaboratedConfiguredPackage
elab)
 Bool -> Bool -> Bool
|| (Bool -> Bool
not (Bool -> Bool)
-> ([ComponentTarget] -> Bool) -> [ComponentTarget] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) (ElaboratedConfiguredPackage -> [ComponentTarget]
elabHaddockTargets ElaboratedConfiguredPackage
elab)
 Bool -> Bool -> Bool
|| (Bool -> Bool
not (Bool -> Bool) -> ([()] -> Bool) -> [()] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [()] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) [ () | ComponentTarget ComponentName
_ SubComponentTarget
subtarget <- ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets ElaboratedConfiguredPackage
elab
                      , SubComponentTarget
subtarget SubComponentTarget -> SubComponentTarget -> Bool
forall a. Eq a => a -> a -> Bool
/= SubComponentTarget
WholeComponent ]

-- | The components that we'll build all of, meaning that after they're built
-- we can skip building them again (unlike with building just some modules or
-- other files within a component).
--
elabBuildTargetWholeComponents :: ElaboratedConfiguredPackage
                              -> Set ComponentName
elabBuildTargetWholeComponents :: ElaboratedConfiguredPackage -> Set ComponentName
elabBuildTargetWholeComponents ElaboratedConfiguredPackage
elab =
    [ComponentName] -> Set ComponentName
forall a. Ord a => [a] -> Set a
Set.fromList
      [ ComponentName
cname | ComponentTarget ComponentName
cname SubComponentTarget
WholeComponent <- ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets ElaboratedConfiguredPackage
elab ]



------------------------------------------------------------------------------
-- * Install plan pruning
------------------------------------------------------------------------------

-- | How 'pruneInstallPlanToTargets' should interpret the per-package
-- 'ComponentTarget's: as build, repl or haddock targets.
--
data TargetAction = TargetActionConfigure
                  | TargetActionBuild
                  | TargetActionRepl
                  | TargetActionTest
                  | TargetActionBench
                  | TargetActionHaddock

-- | Given a set of per-package\/per-component targets, take the subset of the
-- install plan needed to build those targets. Also, update the package config
-- to specify which optional stanzas to enable, and which targets within each
-- package to build.
--
-- NB: Pruning happens after improvement, which is important because we
-- will prune differently depending on what is already installed (to
-- implement "sticky" test suite enabling behavior).
--
pruneInstallPlanToTargets :: TargetAction
                          -> Map UnitId [ComponentTarget]
                          -> ElaboratedInstallPlan -> ElaboratedInstallPlan
pruneInstallPlanToTargets :: TargetAction
-> Map UnitId [ComponentTarget]
-> ElaboratedInstallPlan
-> ElaboratedInstallPlan
pruneInstallPlanToTargets TargetAction
targetActionType Map UnitId [ComponentTarget]
perPkgTargetsMap ElaboratedInstallPlan
elaboratedPlan =
    IndependentGoals
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> ElaboratedInstallPlan
forall ipkg srcpkg.
(IsUnit ipkg, IsUnit srcpkg) =>
IndependentGoals
-> Graph (GenericPlanPackage ipkg srcpkg)
-> GenericInstallPlan ipkg srcpkg
InstallPlan.new (ElaboratedInstallPlan -> IndependentGoals
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> IndependentGoals
InstallPlan.planIndepGoals ElaboratedInstallPlan
elaboratedPlan)
  (Graph
   (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
 -> ElaboratedInstallPlan)
-> (ElaboratedInstallPlan
    -> Graph
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
-> ElaboratedInstallPlan
-> ElaboratedInstallPlan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall a. (IsNode a, Show (Key a)) => [a] -> Graph a
Graph.fromDistinctList
    -- We have to do the pruning in two passes
  ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> Graph
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
-> (ElaboratedInstallPlan
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
pruneInstallPlanPass2
  ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
pruneInstallPlanPass1
    -- Set the targets that will be the roots for pruning
  ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetAction
-> Map UnitId [ComponentTarget]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
setRootTargets TargetAction
targetActionType Map UnitId [ComponentTarget]
perPkgTargetsMap
  ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> [GenericPlanPackage ipkg srcpkg]
InstallPlan.toList
  (ElaboratedInstallPlan -> ElaboratedInstallPlan)
-> ElaboratedInstallPlan -> ElaboratedInstallPlan
forall a b. (a -> b) -> a -> b
$ ElaboratedInstallPlan
elaboratedPlan

-- | This is a temporary data type, where we temporarily
-- override the graph dependencies of an 'ElaboratedPackage',
-- so we can take a closure over them.  We'll throw out the
-- overridden dependencies when we're done so it's strictly temporary.
--
-- For 'ElaboratedComponent', this the cached unit IDs always
-- coincide with the real thing.
data PrunedPackage = PrunedPackage ElaboratedConfiguredPackage [UnitId]

instance Package PrunedPackage where
    packageId :: PrunedPackage -> PackageId
packageId (PrunedPackage ElaboratedConfiguredPackage
elab [UnitId]
_) = ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab

instance HasUnitId PrunedPackage where
    installedUnitId :: PrunedPackage -> UnitId
installedUnitId = PrunedPackage -> UnitId
forall a. IsNode a => a -> Key a
nodeKey

instance IsNode PrunedPackage where
    type Key PrunedPackage = UnitId
    nodeKey :: PrunedPackage -> Key PrunedPackage
nodeKey (PrunedPackage ElaboratedConfiguredPackage
elab [UnitId]
_)  = ElaboratedConfiguredPackage -> Key ElaboratedConfiguredPackage
forall a. IsNode a => a -> Key a
nodeKey ElaboratedConfiguredPackage
elab
    nodeNeighbors :: PrunedPackage -> [Key PrunedPackage]
nodeNeighbors (PrunedPackage ElaboratedConfiguredPackage
_ [UnitId]
deps) = [UnitId]
[Key PrunedPackage]
deps

fromPrunedPackage :: PrunedPackage -> ElaboratedConfiguredPackage
fromPrunedPackage :: PrunedPackage -> ElaboratedConfiguredPackage
fromPrunedPackage (PrunedPackage ElaboratedConfiguredPackage
elab [UnitId]
_) = ElaboratedConfiguredPackage
elab

-- | Set the build targets based on the user targets (but not rev deps yet).
-- This is required before we can prune anything.
--
setRootTargets :: TargetAction
               -> Map UnitId [ComponentTarget]
               -> [ElaboratedPlanPackage]
               -> [ElaboratedPlanPackage]
setRootTargets :: TargetAction
-> Map UnitId [ComponentTarget]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
setRootTargets TargetAction
targetAction Map UnitId [ComponentTarget]
perPkgTargetsMap =
    Bool
-> ([GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage]
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (Bool -> Bool
not (Map UnitId [ComponentTarget] -> Bool
forall k a. Map k a -> Bool
Map.null Map UnitId [ComponentTarget]
perPkgTargetsMap)) (([GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage]
  -> [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage])
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> ([GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage]
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> a -> b
$
    Bool
-> ([GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage]
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (([ComponentTarget] -> Bool) -> [[ComponentTarget]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Bool -> Bool
not (Bool -> Bool)
-> ([ComponentTarget] -> Bool) -> [ComponentTarget] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) (Map UnitId [ComponentTarget] -> [[ComponentTarget]]
forall k a. Map k a -> [a]
Map.elems Map UnitId [ComponentTarget]
perPkgTargetsMap)) (([GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage]
  -> [GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage])
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> ([GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage]
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> a -> b
$

    (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> [a] -> [b]
map ((ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage)
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
forall srcpkg srcpkg' ipkg.
(srcpkg -> srcpkg')
-> GenericPlanPackage ipkg srcpkg
-> GenericPlanPackage ipkg srcpkg'
mapConfiguredPackage ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setElabBuildTargets)
  where
    -- Set the targets we'll build for this package/component. This is just
    -- based on the root targets from the user, not targets implied by reverse
    -- dependencies. Those comes in the second pass once we know the rev deps.
    --
    setElabBuildTargets :: ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setElabBuildTargets ElaboratedConfiguredPackage
elab =
      case (UnitId -> Map UnitId [ComponentTarget] -> Maybe [ComponentTarget]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (ElaboratedConfiguredPackage -> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId ElaboratedConfiguredPackage
elab) Map UnitId [ComponentTarget]
perPkgTargetsMap,
            TargetAction
targetAction) of
        (Maybe [ComponentTarget]
Nothing, TargetAction
_)                      -> ElaboratedConfiguredPackage
elab
        (Just [ComponentTarget]
tgts,  TargetAction
TargetActionConfigure) -> ElaboratedConfiguredPackage
elab { elabConfigureTargets :: [ComponentTarget]
elabConfigureTargets = [ComponentTarget]
tgts }
        (Just [ComponentTarget]
tgts,  TargetAction
TargetActionBuild)   -> ElaboratedConfiguredPackage
elab { elabBuildTargets :: [ComponentTarget]
elabBuildTargets = [ComponentTarget]
tgts }
        (Just [ComponentTarget]
tgts,  TargetAction
TargetActionTest)    -> ElaboratedConfiguredPackage
elab { elabTestTargets :: [ComponentTarget]
elabTestTargets  = [ComponentTarget]
tgts }
        (Just [ComponentTarget]
tgts,  TargetAction
TargetActionBench)   -> ElaboratedConfiguredPackage
elab { elabBenchTargets :: [ComponentTarget]
elabBenchTargets  = [ComponentTarget]
tgts }
        (Just [ComponentTarget
tgt], TargetAction
TargetActionRepl)    -> ElaboratedConfiguredPackage
elab { elabReplTarget :: Maybe ComponentTarget
elabReplTarget = ComponentTarget -> Maybe ComponentTarget
forall a. a -> Maybe a
Just ComponentTarget
tgt
                                                  , elabBuildHaddocks :: Bool
elabBuildHaddocks = Bool
False }
        (Just [ComponentTarget]
tgts,  TargetAction
TargetActionHaddock) ->
          (ComponentTarget
 -> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage)
-> ElaboratedConfiguredPackage
-> [ComponentTarget]
-> ElaboratedConfiguredPackage
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ComponentTarget
-> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setElabHaddockTargets (ElaboratedConfiguredPackage
elab { elabHaddockTargets :: [ComponentTarget]
elabHaddockTargets = [ComponentTarget]
tgts
                                            , elabBuildHaddocks :: Bool
elabBuildHaddocks = Bool
True }) [ComponentTarget]
tgts
        (Just [ComponentTarget]
_,     TargetAction
TargetActionRepl)    ->
          FilePath -> ElaboratedConfiguredPackage
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"pruneInstallPlanToTargets: multiple repl targets"

    setElabHaddockTargets :: ComponentTarget
-> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setElabHaddockTargets ComponentTarget
tgt ElaboratedConfiguredPackage
elab
      | ComponentTarget -> Bool
isTestComponentTarget ComponentTarget
tgt       = ElaboratedConfiguredPackage
elab { elabHaddockTestSuites :: Bool
elabHaddockTestSuites  = Bool
True }
      | ComponentTarget -> Bool
isBenchComponentTarget ComponentTarget
tgt      = ElaboratedConfiguredPackage
elab { elabHaddockBenchmarks :: Bool
elabHaddockBenchmarks  = Bool
True }
      | ComponentTarget -> Bool
isForeignLibComponentTarget ComponentTarget
tgt = ElaboratedConfiguredPackage
elab { elabHaddockForeignLibs :: Bool
elabHaddockForeignLibs = Bool
True }
      | ComponentTarget -> Bool
isExeComponentTarget ComponentTarget
tgt        = ElaboratedConfiguredPackage
elab { elabHaddockExecutables :: Bool
elabHaddockExecutables = Bool
True }
      | ComponentTarget -> Bool
isSubLibComponentTarget ComponentTarget
tgt     = ElaboratedConfiguredPackage
elab { elabHaddockInternal :: Bool
elabHaddockInternal    = Bool
True }
      | Bool
otherwise                       = ElaboratedConfiguredPackage
elab

-- | Assuming we have previously set the root build targets (i.e. the user
-- targets but not rev deps yet), the first pruning pass does two things:
--
-- * A first go at determining which optional stanzas (testsuites, benchmarks)
--   are needed. We have a second go in the next pass.
-- * Take the dependency closure using pruned dependencies. We prune deps that
--   are used only by unneeded optional stanzas. These pruned deps are only
--   used for the dependency closure and are not persisted in this pass.
--
pruneInstallPlanPass1 :: [ElaboratedPlanPackage]
                      -> [ElaboratedPlanPackage]
pruneInstallPlanPass1 :: [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
pruneInstallPlanPass1 [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs =
    (GenericPlanPackage InstalledPackageInfo PrunedPackage
 -> GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
-> [GenericPlanPackage InstalledPackageInfo PrunedPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> [a] -> [b]
map ((PrunedPackage -> ElaboratedConfiguredPackage)
-> GenericPlanPackage InstalledPackageInfo PrunedPackage
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
forall srcpkg srcpkg' ipkg.
(srcpkg -> srcpkg')
-> GenericPlanPackage ipkg srcpkg
-> GenericPlanPackage ipkg srcpkg'
mapConfiguredPackage PrunedPackage -> ElaboratedConfiguredPackage
fromPrunedPackage)
        ([GenericPlanPackage InstalledPackageInfo PrunedPackage]
-> Maybe [GenericPlanPackage InstalledPackageInfo PrunedPackage]
-> [GenericPlanPackage InstalledPackageInfo PrunedPackage]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [GenericPlanPackage InstalledPackageInfo PrunedPackage]
 -> [GenericPlanPackage InstalledPackageInfo PrunedPackage])
-> Maybe [GenericPlanPackage InstalledPackageInfo PrunedPackage]
-> [GenericPlanPackage InstalledPackageInfo PrunedPackage]
forall a b. (a -> b) -> a -> b
$ Graph (GenericPlanPackage InstalledPackageInfo PrunedPackage)
-> [Key (GenericPlanPackage InstalledPackageInfo PrunedPackage)]
-> Maybe [GenericPlanPackage InstalledPackageInfo PrunedPackage]
forall a. Graph a -> [Key a] -> Maybe [a]
Graph.closure Graph (GenericPlanPackage InstalledPackageInfo PrunedPackage)
graph [UnitId]
[Key (GenericPlanPackage InstalledPackageInfo PrunedPackage)]
roots)
  where
    pkgs' :: [GenericPlanPackage InstalledPackageInfo PrunedPackage]
pkgs' = (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> GenericPlanPackage InstalledPackageInfo PrunedPackage)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage InstalledPackageInfo PrunedPackage]
forall a b. (a -> b) -> [a] -> [b]
map ((ElaboratedConfiguredPackage -> PrunedPackage)
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> GenericPlanPackage InstalledPackageInfo PrunedPackage
forall srcpkg srcpkg' ipkg.
(srcpkg -> srcpkg')
-> GenericPlanPackage ipkg srcpkg
-> GenericPlanPackage ipkg srcpkg'
mapConfiguredPackage ElaboratedConfiguredPackage -> PrunedPackage
prune) [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs
    graph :: Graph (GenericPlanPackage InstalledPackageInfo PrunedPackage)
graph = [GenericPlanPackage InstalledPackageInfo PrunedPackage]
-> Graph (GenericPlanPackage InstalledPackageInfo PrunedPackage)
forall a. (IsNode a, Show (Key a)) => [a] -> Graph a
Graph.fromDistinctList [GenericPlanPackage InstalledPackageInfo PrunedPackage]
pkgs'
    roots :: [UnitId]
roots = (GenericPlanPackage InstalledPackageInfo PrunedPackage
 -> Maybe UnitId)
-> [GenericPlanPackage InstalledPackageInfo PrunedPackage]
-> [UnitId]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe GenericPlanPackage InstalledPackageInfo PrunedPackage
-> Maybe UnitId
forall ipkg. GenericPlanPackage ipkg PrunedPackage -> Maybe UnitId
find_root [GenericPlanPackage InstalledPackageInfo PrunedPackage]
pkgs'

    prune :: ElaboratedConfiguredPackage -> PrunedPackage
prune ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage -> [UnitId] -> PrunedPackage
PrunedPackage ElaboratedConfiguredPackage
elab' (ElaboratedConfiguredPackage -> [UnitId]
pruneOptionalDependencies ElaboratedConfiguredPackage
elab')
      where elab' :: ElaboratedConfiguredPackage
elab' =
                ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setDocumentation
              (ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage)
-> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
addOptionalStanzas ElaboratedConfiguredPackage
elab

    is_root :: PrunedPackage -> Maybe UnitId
    is_root :: PrunedPackage -> Maybe UnitId
is_root (PrunedPackage ElaboratedConfiguredPackage
elab [UnitId]
_) =
      if Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [ [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets ElaboratedConfiguredPackage
elab)
                   , [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets ElaboratedConfiguredPackage
elab)
                   , [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets ElaboratedConfiguredPackage
elab)
                   , [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (ElaboratedConfiguredPackage -> [ComponentTarget]
elabBenchTargets ElaboratedConfiguredPackage
elab)
                   , Maybe ComponentTarget -> Bool
forall a. Maybe a -> Bool
isNothing (ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabReplTarget ElaboratedConfiguredPackage
elab)
                   , [ComponentTarget] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (ElaboratedConfiguredPackage -> [ComponentTarget]
elabHaddockTargets ElaboratedConfiguredPackage
elab)
                   ]
          then UnitId -> Maybe UnitId
forall a. a -> Maybe a
Just (ElaboratedConfiguredPackage -> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId ElaboratedConfiguredPackage
elab)
          else Maybe UnitId
forall a. Maybe a
Nothing

    find_root :: GenericPlanPackage ipkg PrunedPackage -> Maybe UnitId
find_root (InstallPlan.Configured PrunedPackage
pkg) = PrunedPackage -> Maybe UnitId
is_root PrunedPackage
pkg
    -- When using the extra-packages stanza we need to
    -- look at installed packages as well.
    find_root (InstallPlan.Installed PrunedPackage
pkg)  = PrunedPackage -> Maybe UnitId
is_root PrunedPackage
pkg
    find_root GenericPlanPackage ipkg PrunedPackage
_ = Maybe UnitId
forall a. Maybe a
Nothing

    -- Note [Sticky enabled testsuites]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -- The testsuite and benchmark targets are somewhat special in that we need
    -- to configure the packages with them enabled, and we need to do that even
    -- if we only want to build one of several testsuites.
    --
    -- There are two cases in which we will enable the testsuites (or
    -- benchmarks): if one of the targets is a testsuite, or if all of the
    -- testsuite dependencies are already cached in the store. The rationale
    -- for the latter is to minimise how often we have to reconfigure due to
    -- the particular targets we choose to build. Otherwise choosing to build
    -- a testsuite target, and then later choosing to build an exe target
    -- would involve unnecessarily reconfiguring the package with testsuites
    -- disabled. Technically this introduces a little bit of stateful
    -- behaviour to make this "sticky", but it should be benign.

    -- Decide whether or not to enable testsuites and benchmarks.
    -- See [Sticky enabled testsuites]
    addOptionalStanzas :: ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
    addOptionalStanzas :: ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
addOptionalStanzas elab :: ElaboratedConfiguredPackage
elab@ElaboratedConfiguredPackage{ elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabPackage ElaboratedPackage
pkg } =
        ElaboratedConfiguredPackage
elab {
            elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp = ElaboratedPackage -> ElaboratedPackageOrComponent
ElabPackage (ElaboratedPackage
pkg { pkgStanzasEnabled :: OptionalStanzaSet
pkgStanzasEnabled = OptionalStanzaSet
stanzas })
        }
      where
        stanzas :: OptionalStanzaSet
               -- By default, we enabled all stanzas requested by the user,
               -- as per elabStanzasRequested, done in
               -- 'elaborateSolverToPackage'
        stanzas :: OptionalStanzaSet
stanzas = ElaboratedPackage -> OptionalStanzaSet
pkgStanzasEnabled ElaboratedPackage
pkg
               -- optionalStanzasRequiredByTargets has to be done at
               -- prune-time because it depends on 'elabTestTargets'
               -- et al, which is done by 'setRootTargets' at the
               -- beginning of pruning.
               OptionalStanzaSet -> OptionalStanzaSet -> OptionalStanzaSet
forall a. Semigroup a => a -> a -> a
<> ElaboratedConfiguredPackage -> OptionalStanzaSet
optionalStanzasRequiredByTargets ElaboratedConfiguredPackage
elab
               -- optionalStanzasWithDepsAvailable has to be done at
               -- prune-time because it depends on what packages are
               -- installed, which is not known until after improvement
               -- (pruning is done after improvement)
               OptionalStanzaSet -> OptionalStanzaSet -> OptionalStanzaSet
forall a. Semigroup a => a -> a -> a
<> Set UnitId
-> ElaboratedConfiguredPackage
-> ElaboratedPackage
-> OptionalStanzaSet
optionalStanzasWithDepsAvailable Set UnitId
availablePkgs ElaboratedConfiguredPackage
elab ElaboratedPackage
pkg
    addOptionalStanzas ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage
elab

    setDocumentation :: ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
    setDocumentation :: ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setDocumentation elab :: ElaboratedConfiguredPackage
elab@ElaboratedConfiguredPackage { elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabComponent ElaboratedComponent
comp } =
      ElaboratedConfiguredPackage
elab {
        elabBuildHaddocks :: Bool
elabBuildHaddocks =
            ElaboratedConfiguredPackage -> Bool
elabBuildHaddocks ElaboratedConfiguredPackage
elab Bool -> Bool -> Bool
&& Component -> ElaboratedConfiguredPackage -> Bool
documentationEnabled (ElaboratedComponent -> Component
compSolverName ElaboratedComponent
comp) ElaboratedConfiguredPackage
elab
      }

      where
        documentationEnabled :: Component -> ElaboratedConfiguredPackage -> Bool
documentationEnabled Component
c =
          case Component
c of
            Component
CD.ComponentLib      -> Bool -> ElaboratedConfiguredPackage -> Bool
forall a b. a -> b -> a
const Bool
True
            CD.ComponentSubLib UnqualComponentName
_ -> ElaboratedConfiguredPackage -> Bool
elabHaddockInternal
            CD.ComponentFLib UnqualComponentName
_   -> ElaboratedConfiguredPackage -> Bool
elabHaddockForeignLibs
            CD.ComponentExe UnqualComponentName
_    -> ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables
            CD.ComponentTest UnqualComponentName
_   -> ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites
            CD.ComponentBench UnqualComponentName
_  -> ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks
            Component
CD.ComponentSetup    -> Bool -> ElaboratedConfiguredPackage -> Bool
forall a b. a -> b -> a
const Bool
False

    setDocumentation ElaboratedConfiguredPackage
elab = ElaboratedConfiguredPackage
elab

    -- Calculate package dependencies but cut out those needed only by
    -- optional stanzas that we've determined we will not enable.
    -- These pruned deps are not persisted in this pass since they're based on
    -- the optional stanzas and we'll make further tweaks to the optional
    -- stanzas in the next pass.
    --
    pruneOptionalDependencies :: ElaboratedConfiguredPackage -> [UnitId]
    pruneOptionalDependencies :: ElaboratedConfiguredPackage -> [UnitId]
pruneOptionalDependencies elab :: ElaboratedConfiguredPackage
elab@ElaboratedConfiguredPackage{ elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabComponent ElaboratedComponent
_ }
        = ElaboratedConfiguredPackage -> [UnitId]
forall a. IsUnit a => a -> [UnitId]
InstallPlan.depends ElaboratedConfiguredPackage
elab -- no pruning
    pruneOptionalDependencies ElaboratedConfiguredPackage{ elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabPackage ElaboratedPackage
pkg }
        = (ComponentDeps [UnitId] -> [UnitId]
forall a. Monoid a => ComponentDeps a -> a
CD.flatDeps (ComponentDeps [UnitId] -> [UnitId])
-> (ComponentDeps [UnitId] -> ComponentDeps [UnitId])
-> ComponentDeps [UnitId]
-> [UnitId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Component -> [UnitId] -> Bool)
-> ComponentDeps [UnitId] -> ComponentDeps [UnitId]
forall a.
(Component -> a -> Bool) -> ComponentDeps a -> ComponentDeps a
CD.filterDeps Component -> [UnitId] -> Bool
forall p. Component -> p -> Bool
keepNeeded) (ElaboratedPackage -> ComponentDeps [UnitId]
pkgOrderDependencies ElaboratedPackage
pkg)
      where
        keepNeeded :: Component -> p -> Bool
keepNeeded (CD.ComponentTest  UnqualComponentName
_) p
_ = OptionalStanza
TestStanzas  OptionalStanza -> OptionalStanzaSet -> Bool
`optStanzaSetMember` OptionalStanzaSet
stanzas
        keepNeeded (CD.ComponentBench UnqualComponentName
_) p
_ = OptionalStanza
BenchStanzas OptionalStanza -> OptionalStanzaSet -> Bool
`optStanzaSetMember` OptionalStanzaSet
stanzas
        keepNeeded Component
_                     p
_ = Bool
True
        stanzas :: OptionalStanzaSet
stanzas = ElaboratedPackage -> OptionalStanzaSet
pkgStanzasEnabled ElaboratedPackage
pkg

    optionalStanzasRequiredByTargets :: ElaboratedConfiguredPackage
                                     -> OptionalStanzaSet
    optionalStanzasRequiredByTargets :: ElaboratedConfiguredPackage -> OptionalStanzaSet
optionalStanzasRequiredByTargets ElaboratedConfiguredPackage
pkg =
      [OptionalStanza] -> OptionalStanzaSet
optStanzaSetFromList
        [ OptionalStanza
stanza
        | ComponentTarget ComponentName
cname SubComponentTarget
_ <- ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets ElaboratedConfiguredPackage
pkg
                                  [ComponentTarget] -> [ComponentTarget] -> [ComponentTarget]
forall a. [a] -> [a] -> [a]
++ ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets ElaboratedConfiguredPackage
pkg
                                  [ComponentTarget] -> [ComponentTarget] -> [ComponentTarget]
forall a. [a] -> [a] -> [a]
++ ElaboratedConfiguredPackage -> [ComponentTarget]
elabBenchTargets ElaboratedConfiguredPackage
pkg
                                  [ComponentTarget] -> [ComponentTarget] -> [ComponentTarget]
forall a. [a] -> [a] -> [a]
++ Maybe ComponentTarget -> [ComponentTarget]
forall a. Maybe a -> [a]
maybeToList (ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabReplTarget ElaboratedConfiguredPackage
pkg)
                                  [ComponentTarget] -> [ComponentTarget] -> [ComponentTarget]
forall a. [a] -> [a] -> [a]
++ ElaboratedConfiguredPackage -> [ComponentTarget]
elabHaddockTargets ElaboratedConfiguredPackage
pkg
        , OptionalStanza
stanza <- Maybe OptionalStanza -> [OptionalStanza]
forall a. Maybe a -> [a]
maybeToList (Maybe OptionalStanza -> [OptionalStanza])
-> Maybe OptionalStanza -> [OptionalStanza]
forall a b. (a -> b) -> a -> b
$
                    Component -> Maybe OptionalStanza
componentOptionalStanza (Component -> Maybe OptionalStanza)
-> Component -> Maybe OptionalStanza
forall a b. (a -> b) -> a -> b
$
                    ComponentName -> Component
CD.componentNameToComponent ComponentName
cname
        ]

    availablePkgs :: Set UnitId
availablePkgs =
      [UnitId] -> Set UnitId
forall a. Ord a => [a] -> Set a
Set.fromList
        [ InstalledPackageInfo -> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId InstalledPackageInfo
pkg
        | InstallPlan.PreExisting InstalledPackageInfo
pkg <- [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs ]

-- | Given a set of already installed packages @availablePkgs@,
-- determine the set of available optional stanzas from @pkg@
-- which have all of their dependencies already installed.  This is used
-- to implement "sticky" testsuites, where once we have installed
-- all of the deps needed for the test suite, we go ahead and
-- enable it always.
optionalStanzasWithDepsAvailable :: Set UnitId
                                 -> ElaboratedConfiguredPackage
                                 -> ElaboratedPackage
                                 -> OptionalStanzaSet
optionalStanzasWithDepsAvailable :: Set UnitId
-> ElaboratedConfiguredPackage
-> ElaboratedPackage
-> OptionalStanzaSet
optionalStanzasWithDepsAvailable Set UnitId
availablePkgs ElaboratedConfiguredPackage
elab ElaboratedPackage
pkg =
    [OptionalStanza] -> OptionalStanzaSet
optStanzaSetFromList
      [ OptionalStanza
stanza
      | OptionalStanza
stanza <- OptionalStanzaSet -> [OptionalStanza]
optStanzaSetToList (ElaboratedConfiguredPackage -> OptionalStanzaSet
elabStanzasAvailable ElaboratedConfiguredPackage
elab)
      , let deps :: [UnitId]
            deps :: [UnitId]
deps = (Component -> Bool) -> ComponentDeps [UnitId] -> [UnitId]
forall a. Monoid a => (Component -> Bool) -> ComponentDeps a -> a
CD.select (OptionalStanza -> Component -> Bool
optionalStanzaDeps OptionalStanza
stanza)
                             -- TODO: probably need to select other
                             -- dep types too eventually
                             (ElaboratedPackage -> ComponentDeps [UnitId]
pkgOrderDependencies ElaboratedPackage
pkg)
      , (UnitId -> Bool) -> [UnitId] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (UnitId -> Set UnitId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set UnitId
availablePkgs) [UnitId]
deps
      ]
  where
    optionalStanzaDeps :: OptionalStanza -> Component -> Bool
optionalStanzaDeps OptionalStanza
TestStanzas  (CD.ComponentTest  UnqualComponentName
_) = Bool
True
    optionalStanzaDeps OptionalStanza
BenchStanzas (CD.ComponentBench UnqualComponentName
_) = Bool
True
    optionalStanzaDeps OptionalStanza
_            Component
_                     = Bool
False


-- The second pass does three things:
--
-- * A second go at deciding which optional stanzas to enable.
-- * Prune the dependencies based on the final choice of optional stanzas.
-- * Extend the targets within each package to build, now we know the reverse
--   dependencies, ie we know which libs are needed as deps by other packages.
--
-- Achieving sticky behaviour with enabling\/disabling optional stanzas is
-- tricky. The first approximation was handled by the first pass above, but
-- it's not quite enough. That pass will enable stanzas if all of the deps
-- of the optional stanza are already installed /in the store/. That's important
-- but it does not account for dependencies that get built inplace as part of
-- the project. We cannot take those inplace build deps into account in the
-- pruning pass however because we don't yet know which ones we're going to
-- build. Once we do know, we can have another go and enable stanzas that have
-- all their deps available. Now we can consider all packages in the pruned
-- plan to be available, including ones we already decided to build from
-- source.
--
-- Deciding which targets to build depends on knowing which packages have
-- reverse dependencies (ie are needed). This requires the result of first
-- pass, which is another reason we have to split it into two passes.
--
-- Note that just because we might enable testsuites or benchmarks (in the
-- first or second pass) doesn't mean that we build all (or even any) of them.
-- That depends on which targets we picked in the first pass.
--
pruneInstallPlanPass2 :: [ElaboratedPlanPackage]
                      -> [ElaboratedPlanPackage]
pruneInstallPlanPass2 :: [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
pruneInstallPlanPass2 [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs =
    (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> [a] -> [b]
map ((ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage)
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
forall srcpkg srcpkg' ipkg.
(srcpkg -> srcpkg')
-> GenericPlanPackage ipkg srcpkg
-> GenericPlanPackage ipkg srcpkg'
mapConfiguredPackage ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setStanzasDepsAndTargets) [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs
  where
    setStanzasDepsAndTargets :: ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
setStanzasDepsAndTargets ElaboratedConfiguredPackage
elab =
        ElaboratedConfiguredPackage
elab {
          elabBuildTargets :: [ComponentTarget]
elabBuildTargets = [ComponentTarget] -> [ComponentTarget]
forall a. Ord a => [a] -> [a]
ordNub
                           ([ComponentTarget] -> [ComponentTarget])
-> [ComponentTarget] -> [ComponentTarget]
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets ElaboratedConfiguredPackage
elab
                          [ComponentTarget] -> [ComponentTarget] -> [ComponentTarget]
forall a. [a] -> [a] -> [a]
++ [ComponentTarget]
libTargetsRequiredForRevDeps
                          [ComponentTarget] -> [ComponentTarget] -> [ComponentTarget]
forall a. [a] -> [a] -> [a]
++ [ComponentTarget]
exeTargetsRequiredForRevDeps,
          elabPkgOrComp :: ElaboratedPackageOrComponent
elabPkgOrComp =
            case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
              ElabPackage ElaboratedPackage
pkg ->
                let stanzas :: OptionalStanzaSet
stanzas = ElaboratedPackage -> OptionalStanzaSet
pkgStanzasEnabled ElaboratedPackage
pkg
                           OptionalStanzaSet -> OptionalStanzaSet -> OptionalStanzaSet
forall a. Semigroup a => a -> a -> a
<> Set UnitId
-> ElaboratedConfiguredPackage
-> ElaboratedPackage
-> OptionalStanzaSet
optionalStanzasWithDepsAvailable Set UnitId
availablePkgs ElaboratedConfiguredPackage
elab ElaboratedPackage
pkg
                    keepNeeded :: Component -> p -> Bool
keepNeeded (CD.ComponentTest  UnqualComponentName
_) p
_ = OptionalStanza
TestStanzas  OptionalStanza -> OptionalStanzaSet -> Bool
`optStanzaSetMember` OptionalStanzaSet
stanzas
                    keepNeeded (CD.ComponentBench UnqualComponentName
_) p
_ = OptionalStanza
BenchStanzas OptionalStanza -> OptionalStanzaSet -> Bool
`optStanzaSetMember` OptionalStanzaSet
stanzas
                    keepNeeded Component
_                     p
_ = Bool
True
                in ElaboratedPackage -> ElaboratedPackageOrComponent
ElabPackage (ElaboratedPackage -> ElaboratedPackageOrComponent)
-> ElaboratedPackage -> ElaboratedPackageOrComponent
forall a b. (a -> b) -> a -> b
$ ElaboratedPackage
pkg {
                  pkgStanzasEnabled :: OptionalStanzaSet
pkgStanzasEnabled = OptionalStanzaSet
stanzas,
                  pkgLibDependencies :: ComponentDeps [ConfiguredId]
pkgLibDependencies   = (Component -> [ConfiguredId] -> Bool)
-> ComponentDeps [ConfiguredId] -> ComponentDeps [ConfiguredId]
forall a.
(Component -> a -> Bool) -> ComponentDeps a -> ComponentDeps a
CD.filterDeps Component -> [ConfiguredId] -> Bool
forall p. Component -> p -> Bool
keepNeeded (ElaboratedPackage -> ComponentDeps [ConfiguredId]
pkgLibDependencies ElaboratedPackage
pkg),
                  pkgExeDependencies :: ComponentDeps [ConfiguredId]
pkgExeDependencies   = (Component -> [ConfiguredId] -> Bool)
-> ComponentDeps [ConfiguredId] -> ComponentDeps [ConfiguredId]
forall a.
(Component -> a -> Bool) -> ComponentDeps a -> ComponentDeps a
CD.filterDeps Component -> [ConfiguredId] -> Bool
forall p. Component -> p -> Bool
keepNeeded (ElaboratedPackage -> ComponentDeps [ConfiguredId]
pkgExeDependencies ElaboratedPackage
pkg),
                  pkgExeDependencyPaths :: ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencyPaths = (Component -> [(ConfiguredId, FilePath)] -> Bool)
-> ComponentDeps [(ConfiguredId, FilePath)]
-> ComponentDeps [(ConfiguredId, FilePath)]
forall a.
(Component -> a -> Bool) -> ComponentDeps a -> ComponentDeps a
CD.filterDeps Component -> [(ConfiguredId, FilePath)] -> Bool
forall p. Component -> p -> Bool
keepNeeded (ElaboratedPackage -> ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencyPaths ElaboratedPackage
pkg)
                }
              r :: ElaboratedPackageOrComponent
r@(ElabComponent ElaboratedComponent
_) -> ElaboratedPackageOrComponent
r
        }
      where
        libTargetsRequiredForRevDeps :: [ComponentTarget]
libTargetsRequiredForRevDeps =
          [ ComponentName -> SubComponentTarget -> ComponentTarget
ComponentTarget (LibraryName -> ComponentName
CLibName LibraryName
Cabal.defaultLibName) SubComponentTarget
WholeComponent
          | ElaboratedConfiguredPackage -> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId ElaboratedConfiguredPackage
elab UnitId -> Set UnitId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set UnitId
hasReverseLibDeps
          ]
        exeTargetsRequiredForRevDeps :: [ComponentTarget]
exeTargetsRequiredForRevDeps =
          -- TODO: allow requesting executable with different name
          -- than package name
          [ ComponentName -> SubComponentTarget -> ComponentTarget
ComponentTarget (UnqualComponentName -> ComponentName
Cabal.CExeName
                             (UnqualComponentName -> ComponentName)
-> UnqualComponentName -> ComponentName
forall a b. (a -> b) -> a -> b
$ PackageName -> UnqualComponentName
packageNameToUnqualComponentName
                             (PackageName -> UnqualComponentName)
-> PackageName -> UnqualComponentName
forall a b. (a -> b) -> a -> b
$ PackageId -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName (PackageId -> PackageName) -> PackageId -> PackageName
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage -> PackageId
elabPkgSourceId ElaboratedConfiguredPackage
elab)
                            SubComponentTarget
WholeComponent
          | ElaboratedConfiguredPackage -> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId ElaboratedConfiguredPackage
elab UnitId -> Set UnitId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set UnitId
hasReverseExeDeps
          ]


    availablePkgs :: Set UnitId
    availablePkgs :: Set UnitId
availablePkgs = [UnitId] -> Set UnitId
forall a. Ord a => [a] -> Set a
Set.fromList ((GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> UnitId)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [UnitId]
forall a b. (a -> b) -> [a] -> [b]
map GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs)

    hasReverseLibDeps :: Set UnitId
    hasReverseLibDeps :: Set UnitId
hasReverseLibDeps =
      [UnitId] -> Set UnitId
forall a. Ord a => [a] -> Set a
Set.fromList [ UnitId
depid
                   | InstallPlan.Configured ElaboratedConfiguredPackage
pkg <- [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs
                   , UnitId
depid <- ElaboratedConfiguredPackage -> [UnitId]
elabOrderLibDependencies ElaboratedConfiguredPackage
pkg ]

    hasReverseExeDeps :: Set UnitId
    hasReverseExeDeps :: Set UnitId
hasReverseExeDeps =
      [UnitId] -> Set UnitId
forall a. Ord a => [a] -> Set a
Set.fromList [ UnitId
depid
                   | InstallPlan.Configured ElaboratedConfiguredPackage
pkg <- [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs
                   , UnitId
depid <- ElaboratedConfiguredPackage -> [UnitId]
elabOrderExeDependencies ElaboratedConfiguredPackage
pkg ]

mapConfiguredPackage :: (srcpkg -> srcpkg')
                     -> InstallPlan.GenericPlanPackage ipkg srcpkg
                     -> InstallPlan.GenericPlanPackage ipkg srcpkg'
mapConfiguredPackage :: (srcpkg -> srcpkg')
-> GenericPlanPackage ipkg srcpkg
-> GenericPlanPackage ipkg srcpkg'
mapConfiguredPackage srcpkg -> srcpkg'
f (InstallPlan.Configured srcpkg
pkg) =
  srcpkg' -> GenericPlanPackage ipkg srcpkg'
forall ipkg srcpkg. srcpkg -> GenericPlanPackage ipkg srcpkg
InstallPlan.Configured (srcpkg -> srcpkg'
f srcpkg
pkg)
mapConfiguredPackage srcpkg -> srcpkg'
f (InstallPlan.Installed srcpkg
pkg) =
  srcpkg' -> GenericPlanPackage ipkg srcpkg'
forall ipkg srcpkg. srcpkg -> GenericPlanPackage ipkg srcpkg
InstallPlan.Installed (srcpkg -> srcpkg'
f srcpkg
pkg)
mapConfiguredPackage srcpkg -> srcpkg'
_ (InstallPlan.PreExisting ipkg
pkg) =
  ipkg -> GenericPlanPackage ipkg srcpkg'
forall ipkg srcpkg. ipkg -> GenericPlanPackage ipkg srcpkg
InstallPlan.PreExisting ipkg
pkg

------------------------------------
-- Support for --only-dependencies
--

-- | Try to remove the given targets from the install plan.
--
-- This is not always possible.
--
pruneInstallPlanToDependencies :: Set UnitId
                               -> ElaboratedInstallPlan
                               -> Either CannotPruneDependencies
                                         ElaboratedInstallPlan
pruneInstallPlanToDependencies :: Set UnitId
-> ElaboratedInstallPlan
-> Either CannotPruneDependencies ElaboratedInstallPlan
pruneInstallPlanToDependencies Set UnitId
pkgTargets ElaboratedInstallPlan
installPlan =
    Bool
-> Either CannotPruneDependencies ElaboratedInstallPlan
-> Either CannotPruneDependencies ElaboratedInstallPlan
forall a. (?callStack::CallStack) => Bool -> a -> a
assert ((UnitId -> Bool) -> [UnitId] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Maybe
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
-> Bool
forall a. Maybe a -> Bool
isJust (Maybe
   (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
 -> Bool)
-> (UnitId
    -> Maybe
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
-> UnitId
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedInstallPlan
-> UnitId
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall ipkg srcpkg.
(IsUnit ipkg, IsUnit srcpkg) =>
GenericInstallPlan ipkg srcpkg
-> UnitId -> Maybe (GenericPlanPackage ipkg srcpkg)
InstallPlan.lookup ElaboratedInstallPlan
installPlan)
                (Set UnitId -> [UnitId]
forall a. Set a -> [a]
Set.toList Set UnitId
pkgTargets)) (Either CannotPruneDependencies ElaboratedInstallPlan
 -> Either CannotPruneDependencies ElaboratedInstallPlan)
-> Either CannotPruneDependencies ElaboratedInstallPlan
-> Either CannotPruneDependencies ElaboratedInstallPlan
forall a b. (a -> b) -> a -> b
$

    (Graph
   (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
 -> ElaboratedInstallPlan)
-> Either
     CannotPruneDependencies
     (Graph
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
-> Either CannotPruneDependencies ElaboratedInstallPlan
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (IndependentGoals
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
-> ElaboratedInstallPlan
forall ipkg srcpkg.
(IsUnit ipkg, IsUnit srcpkg) =>
IndependentGoals
-> Graph (GenericPlanPackage ipkg srcpkg)
-> GenericInstallPlan ipkg srcpkg
InstallPlan.new (ElaboratedInstallPlan -> IndependentGoals
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> IndependentGoals
InstallPlan.planIndepGoals ElaboratedInstallPlan
installPlan))
  (Either
   CannotPruneDependencies
   (Graph
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
 -> Either CannotPruneDependencies ElaboratedInstallPlan)
-> (ElaboratedInstallPlan
    -> Either
         CannotPruneDependencies
         (Graph
            (GenericPlanPackage
               InstalledPackageInfo ElaboratedConfiguredPackage)))
-> ElaboratedInstallPlan
-> Either CannotPruneDependencies ElaboratedInstallPlan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Graph
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
-> Either
     CannotPruneDependencies
     (Graph
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
checkBrokenDeps
  (Graph
   (GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage)
 -> Either
      CannotPruneDependencies
      (Graph
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage)))
-> (ElaboratedInstallPlan
    -> Graph
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage))
-> ElaboratedInstallPlan
-> Either
     CannotPruneDependencies
     (Graph
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall a. (IsNode a, Show (Key a)) => [a] -> Graph a
Graph.fromDistinctList
  ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> Graph
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
-> (ElaboratedInstallPlan
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> Graph
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> Bool)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a. (a -> Bool) -> [a] -> [a]
filter (\GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg -> GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg UnitId -> Set UnitId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.notMember` Set UnitId
pkgTargets)
  ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> [GenericPlanPackage ipkg srcpkg]
InstallPlan.toList
  (ElaboratedInstallPlan
 -> Either CannotPruneDependencies ElaboratedInstallPlan)
-> ElaboratedInstallPlan
-> Either CannotPruneDependencies ElaboratedInstallPlan
forall a b. (a -> b) -> a -> b
$ ElaboratedInstallPlan
installPlan
    where
      -- Our strategy is to remove the packages we don't want and then check
      -- if the remaining graph is broken or not, ie any packages with dangling
      -- dependencies. If there are then we cannot prune the given targets.
      checkBrokenDeps :: Graph.Graph ElaboratedPlanPackage
                      -> Either CannotPruneDependencies
                                (Graph.Graph ElaboratedPlanPackage)
      checkBrokenDeps :: Graph
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
-> Either
     CannotPruneDependencies
     (Graph
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
checkBrokenDeps Graph
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
graph =
        case Graph
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
-> [(GenericPlanPackage
       InstalledPackageInfo ElaboratedConfiguredPackage,
     [Key
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage)])]
forall a. Graph a -> [(a, [Key a])]
Graph.broken Graph
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
graph of
          []             -> Graph
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
-> Either
     CannotPruneDependencies
     (Graph
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
forall a b. b -> Either a b
Right Graph
  (GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage)
graph
          [(GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage,
  [Key
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)])]
brokenPackages ->
            CannotPruneDependencies
-> Either
     CannotPruneDependencies
     (Graph
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
forall a b. a -> Either a b
Left (CannotPruneDependencies
 -> Either
      CannotPruneDependencies
      (Graph
         (GenericPlanPackage
            InstalledPackageInfo ElaboratedConfiguredPackage)))
-> CannotPruneDependencies
-> Either
     CannotPruneDependencies
     (Graph
        (GenericPlanPackage
           InstalledPackageInfo ElaboratedConfiguredPackage))
forall a b. (a -> b) -> a -> b
$ [(GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage,
  [GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage])]
-> CannotPruneDependencies
CannotPruneDependencies
             [ (GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg, [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
missingDeps)
             | (GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
pkg, [UnitId]
missingDepIds) <- [(GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage,
  [UnitId])]
[(GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage,
  [Key
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)])]
brokenPackages
             , let missingDeps :: [GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage]
missingDeps = (UnitId
 -> Maybe
      (GenericPlanPackage
         InstalledPackageInfo ElaboratedConfiguredPackage))
-> [UnitId]
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe UnitId
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
lookupDep [UnitId]
missingDepIds
             ]
            where
              -- lookup in the original unpruned graph
              lookupDep :: UnitId
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
lookupDep = ElaboratedInstallPlan
-> UnitId
-> Maybe
     (GenericPlanPackage
        InstalledPackageInfo ElaboratedConfiguredPackage)
forall ipkg srcpkg.
(IsUnit ipkg, IsUnit srcpkg) =>
GenericInstallPlan ipkg srcpkg
-> UnitId -> Maybe (GenericPlanPackage ipkg srcpkg)
InstallPlan.lookup ElaboratedInstallPlan
installPlan

-- | It is not always possible to prune to only the dependencies of a set of
-- targets. It may be the case that removing a package leaves something else
-- that still needed the pruned package.
--
-- This lists all the packages that would be broken, and their dependencies
-- that would be missing if we did prune.
--
newtype CannotPruneDependencies =
        CannotPruneDependencies [(ElaboratedPlanPackage,
                                  [ElaboratedPlanPackage])]
  deriving (Int -> CannotPruneDependencies -> FilePath -> FilePath
[CannotPruneDependencies] -> FilePath -> FilePath
CannotPruneDependencies -> FilePath
(Int -> CannotPruneDependencies -> FilePath -> FilePath)
-> (CannotPruneDependencies -> FilePath)
-> ([CannotPruneDependencies] -> FilePath -> FilePath)
-> Show CannotPruneDependencies
forall a.
(Int -> a -> FilePath -> FilePath)
-> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
showList :: [CannotPruneDependencies] -> FilePath -> FilePath
$cshowList :: [CannotPruneDependencies] -> FilePath -> FilePath
show :: CannotPruneDependencies -> FilePath
$cshow :: CannotPruneDependencies -> FilePath
showsPrec :: Int -> CannotPruneDependencies -> FilePath -> FilePath
$cshowsPrec :: Int -> CannotPruneDependencies -> FilePath -> FilePath
Show)


---------------------------
-- Setup.hs script policy
--

-- Handling for Setup.hs scripts is a bit tricky, part of it lives in the
-- solver phase, and part in the elaboration phase. We keep the helper
-- functions for both phases together here so at least you can see all of it
-- in one place.
--
-- There are four major cases for Setup.hs handling:
--
--  1. @build-type@ Custom with a @custom-setup@ section
--  2. @build-type@ Custom without a @custom-setup@ section
--  3. @build-type@ not Custom with @cabal-version >  $our-cabal-version@
--  4. @build-type@ not Custom with @cabal-version <= $our-cabal-version@
--
-- It's also worth noting that packages specifying @cabal-version: >= 1.23@
-- or later that have @build-type@ Custom will always have a @custom-setup@
-- section. Therefore in case 2, the specified @cabal-version@ will always be
-- less than 1.23.
--
-- In cases 1 and 2 we obviously have to build an external Setup.hs script,
-- while in case 4 we can use the internal library API.
--
-- TODO:In case 3 we should fail. We don't know how to talk to
-- newer ./Setup.hs
--
-- data SetupScriptStyle = ...  -- see ProjectPlanning.Types

-- | Work out the 'SetupScriptStyle' given the package description.
--
packageSetupScriptStyle :: PD.PackageDescription -> SetupScriptStyle
packageSetupScriptStyle :: PackageDescription -> SetupScriptStyle
packageSetupScriptStyle PackageDescription
pkg
  | BuildType
buildType BuildType -> BuildType -> Bool
forall a. Eq a => a -> a -> Bool
== BuildType
PD.Custom
  , Just SetupBuildInfo
setupbi <- PackageDescription -> Maybe SetupBuildInfo
PD.setupBuildInfo PackageDescription
pkg -- does have a custom-setup stanza
  , Bool -> Bool
not (SetupBuildInfo -> Bool
PD.defaultSetupDepends SetupBuildInfo
setupbi)  -- but not one we added internally
  = SetupScriptStyle
SetupCustomExplicitDeps

  | BuildType
buildType BuildType -> BuildType -> Bool
forall a. Eq a => a -> a -> Bool
== BuildType
PD.Custom
  , Just SetupBuildInfo
setupbi <- PackageDescription -> Maybe SetupBuildInfo
PD.setupBuildInfo PackageDescription
pkg -- we get this case post-solver as
  , SetupBuildInfo -> Bool
PD.defaultSetupDepends SetupBuildInfo
setupbi        -- the solver fills in the deps
  = SetupScriptStyle
SetupCustomImplicitDeps

  | BuildType
buildType BuildType -> BuildType -> Bool
forall a. Eq a => a -> a -> Bool
== BuildType
PD.Custom
  , Maybe SetupBuildInfo
Nothing <- PackageDescription -> Maybe SetupBuildInfo
PD.setupBuildInfo PackageDescription
pkg      -- we get this case pre-solver
  = SetupScriptStyle
SetupCustomImplicitDeps

  -- here we should fail.
  | PackageDescription -> CabalSpecVersion
PD.specVersion PackageDescription
pkg CabalSpecVersion -> CabalSpecVersion -> Bool
forall a. Ord a => a -> a -> Bool
> CabalSpecVersion
cabalSpecLatest  -- one cabal-install is built against
  = SetupScriptStyle
SetupNonCustomExternalLib

  | Bool
otherwise
  = SetupScriptStyle
SetupNonCustomInternalLib
  where
    buildType :: BuildType
buildType = PackageDescription -> BuildType
PD.buildType PackageDescription
pkg


-- | Part of our Setup.hs handling policy is implemented by getting the solver
-- to work out setup dependencies for packages. The solver already handles
-- packages that explicitly specify setup dependencies, but we can also tell
-- the solver to treat other packages as if they had setup dependencies.
-- That's what this function does, it gets called by the solver for all
-- packages that don't already have setup dependencies.
--
-- The dependencies we want to add is different for each 'SetupScriptStyle'.
--
-- Note that adding default deps means these deps are actually /added/ to the
-- packages that we get out of the solver in the 'SolverInstallPlan'. Making
-- implicit setup deps explicit is a problem in the post-solver stages because
-- we still need to distinguish the case of explicit and implicit setup deps.
-- See 'rememberImplicitSetupDeps'.
--
-- Note in addition to adding default setup deps, we also use
-- 'addSetupCabalMinVersionConstraint' (in 'planPackages') to require
-- @Cabal >= 1.20@ for Setup scripts.
--
defaultSetupDeps :: Compiler -> Platform
                 -> PD.PackageDescription
                 -> Maybe [Dependency]
defaultSetupDeps :: Compiler -> Platform -> PackageDescription -> Maybe [Dependency]
defaultSetupDeps Compiler
compiler Platform
platform PackageDescription
pkg =
    case PackageDescription -> SetupScriptStyle
packageSetupScriptStyle PackageDescription
pkg of

      -- For packages with build type custom that do not specify explicit
      -- setup dependencies, we add a dependency on Cabal and a number
      -- of other packages.
      SetupScriptStyle
SetupCustomImplicitDeps ->
        [Dependency] -> Maybe [Dependency]
forall a. a -> Maybe a
Just ([Dependency] -> Maybe [Dependency])
-> [Dependency] -> Maybe [Dependency]
forall a b. (a -> b) -> a -> b
$
        [ PackageName
-> VersionRange -> NonEmptySet LibraryName -> Dependency
Dependency PackageName
depPkgname VersionRange
anyVersion NonEmptySet LibraryName
mainLibSet
        | PackageName
depPkgname <- Compiler -> Platform -> [PackageName]
legacyCustomSetupPkgs Compiler
compiler Platform
platform ] [Dependency] -> [Dependency] -> [Dependency]
forall a. [a] -> [a] -> [a]
++
        [ PackageName
-> VersionRange -> NonEmptySet LibraryName -> Dependency
Dependency PackageName
cabalPkgname VersionRange
cabalConstraint NonEmptySet LibraryName
mainLibSet
        | PackageDescription -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageDescription
pkg PackageName -> PackageName -> Bool
forall a. Eq a => a -> a -> Bool
/= PackageName
cabalPkgname ]
        where
          -- The Cabal dep is slightly special:
          -- * We omit the dep for the Cabal lib itself, since it bootstraps.
          -- * We constrain it to be < 1.25
          --
          -- Note: we also add a global constraint to require Cabal >= 1.20
          -- for Setup scripts (see use addSetupCabalMinVersionConstraint).
          --
          cabalConstraint :: VersionRange
cabalConstraint   = Version -> VersionRange
orLaterVersion (CabalSpecVersion -> Version
csvToVersion (PackageDescription -> CabalSpecVersion
PD.specVersion PackageDescription
pkg))
                                VersionRange -> VersionRange -> VersionRange
`intersectVersionRanges`
                              Version -> VersionRange
earlierVersion Version
cabalCompatMaxVer
          -- The idea here is that at some point we will make significant
          -- breaking changes to the Cabal API that Setup.hs scripts use.
          -- So for old custom Setup scripts that do not specify explicit
          -- constraints, we constrain them to use a compatible Cabal version.
          cabalCompatMaxVer :: Version
cabalCompatMaxVer = [Int] -> Version
mkVersion [Int
1,Int
25]

      -- For other build types (like Simple) if we still need to compile an
      -- external Setup.hs, it'll be one of the simple ones that only depends
      -- on Cabal and base.
      SetupScriptStyle
SetupNonCustomExternalLib ->
        [Dependency] -> Maybe [Dependency]
forall a. a -> Maybe a
Just [ PackageName
-> VersionRange -> NonEmptySet LibraryName -> Dependency
Dependency PackageName
cabalPkgname VersionRange
cabalConstraint NonEmptySet LibraryName
mainLibSet
             , PackageName
-> VersionRange -> NonEmptySet LibraryName -> Dependency
Dependency PackageName
basePkgname  VersionRange
anyVersion NonEmptySet LibraryName
mainLibSet]
        where
          cabalConstraint :: VersionRange
cabalConstraint = Version -> VersionRange
orLaterVersion (CabalSpecVersion -> Version
csvToVersion (PackageDescription -> CabalSpecVersion
PD.specVersion PackageDescription
pkg))

      -- The internal setup wrapper method has no deps at all.
      SetupScriptStyle
SetupNonCustomInternalLib -> [Dependency] -> Maybe [Dependency]
forall a. a -> Maybe a
Just []

      -- This case gets ruled out by the caller, planPackages, see the note
      -- above in the SetupCustomImplicitDeps case.
      SetupScriptStyle
SetupCustomExplicitDeps ->
        FilePath -> Maybe [Dependency]
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath -> Maybe [Dependency]) -> FilePath -> Maybe [Dependency]
forall a b. (a -> b) -> a -> b
$ FilePath
"defaultSetupDeps: called for a package with explicit "
             FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ FilePath
"setup deps: " FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ PackageId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow (PackageDescription -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId PackageDescription
pkg)
  where
    -- we require one less
    --
    -- This maps e.g. CabalSpecV3_0 to mkVersion [2,5]
    csvToVersion :: CabalSpecVersion -> Version
    csvToVersion :: CabalSpecVersion -> Version
csvToVersion = [Int] -> Version
mkVersion ([Int] -> Version)
-> (CabalSpecVersion -> [Int]) -> CabalSpecVersion -> Version
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CabalSpecVersion -> [Int]
cabalSpecMinimumLibraryVersion

-- | Work out which version of the Cabal we will be using to talk to the
-- Setup.hs interface for this package.
--
-- This depends somewhat on the 'SetupScriptStyle' but most cases are a result
-- of what the solver picked for us, based on the explicit setup deps or the
-- ones added implicitly by 'defaultSetupDeps'.
--
packageSetupScriptSpecVersion :: SetupScriptStyle
                              -> PD.PackageDescription
                              -> Graph.Graph NonSetupLibDepSolverPlanPackage
                              -> ComponentDeps [SolverId]
                              -> Version

-- We're going to be using the internal Cabal library, so the spec version of
-- that is simply the version of the Cabal library that cabal-install has been
-- built with.
packageSetupScriptSpecVersion :: SetupScriptStyle
-> PackageDescription
-> Graph NonSetupLibDepSolverPlanPackage
-> ComponentDeps [SolverId]
-> Version
packageSetupScriptSpecVersion SetupScriptStyle
SetupNonCustomInternalLib PackageDescription
_ Graph NonSetupLibDepSolverPlanPackage
_ ComponentDeps [SolverId]
_ =
    Version
cabalVersion

-- If we happen to be building the Cabal lib itself then because that
-- bootstraps itself then we use the version of the lib we're building.
packageSetupScriptSpecVersion SetupScriptStyle
SetupCustomImplicitDeps PackageDescription
pkg Graph NonSetupLibDepSolverPlanPackage
_ ComponentDeps [SolverId]
_
  | PackageDescription -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageDescription
pkg PackageName -> PackageName -> Bool
forall a. Eq a => a -> a -> Bool
== PackageName
cabalPkgname
  = PackageDescription -> Version
forall pkg. Package pkg => pkg -> Version
packageVersion PackageDescription
pkg

-- In all other cases we have a look at what version of the Cabal lib the
-- solver picked. Or if it didn't depend on Cabal at all (which is very rare)
-- then we look at the .cabal file to see what spec version it declares.
packageSetupScriptSpecVersion SetupScriptStyle
_ PackageDescription
pkg Graph NonSetupLibDepSolverPlanPackage
libDepGraph ComponentDeps [SolverId]
deps =
    case (PackageId -> Bool) -> [PackageId] -> Maybe PackageId
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((PackageName
cabalPkgname PackageName -> PackageName -> Bool
forall a. Eq a => a -> a -> Bool
==) (PackageName -> Bool)
-> (PackageId -> PackageName) -> PackageId -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageId -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName) [PackageId]
setupLibDeps of
      Just PackageId
dep -> PackageId -> Version
forall pkg. Package pkg => pkg -> Version
packageVersion PackageId
dep
      Maybe PackageId
Nothing  -> [Int] -> Version
mkVersion (CabalSpecVersion -> [Int]
cabalSpecMinimumLibraryVersion (PackageDescription -> CabalSpecVersion
PD.specVersion PackageDescription
pkg))
  where
    setupLibDeps :: [PackageId]
setupLibDeps = (NonSetupLibDepSolverPlanPackage -> PackageId)
-> [NonSetupLibDepSolverPlanPackage] -> [PackageId]
forall a b. (a -> b) -> [a] -> [b]
map NonSetupLibDepSolverPlanPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ([NonSetupLibDepSolverPlanPackage] -> [PackageId])
-> [NonSetupLibDepSolverPlanPackage] -> [PackageId]
forall a b. (a -> b) -> a -> b
$ [NonSetupLibDepSolverPlanPackage]
-> Maybe [NonSetupLibDepSolverPlanPackage]
-> [NonSetupLibDepSolverPlanPackage]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [NonSetupLibDepSolverPlanPackage]
 -> [NonSetupLibDepSolverPlanPackage])
-> Maybe [NonSetupLibDepSolverPlanPackage]
-> [NonSetupLibDepSolverPlanPackage]
forall a b. (a -> b) -> a -> b
$
                   Graph NonSetupLibDepSolverPlanPackage
-> [Key NonSetupLibDepSolverPlanPackage]
-> Maybe [NonSetupLibDepSolverPlanPackage]
forall a. Graph a -> [Key a] -> Maybe [a]
Graph.closure Graph NonSetupLibDepSolverPlanPackage
libDepGraph (ComponentDeps [SolverId] -> [SolverId]
forall a. Monoid a => ComponentDeps a -> a
CD.setupDeps ComponentDeps [SolverId]
deps)


cabalPkgname, basePkgname :: PackageName
cabalPkgname :: PackageName
cabalPkgname = FilePath -> PackageName
mkPackageName FilePath
"Cabal"
basePkgname :: PackageName
basePkgname  = FilePath -> PackageName
mkPackageName FilePath
"base"


legacyCustomSetupPkgs :: Compiler -> Platform -> [PackageName]
legacyCustomSetupPkgs :: Compiler -> Platform -> [PackageName]
legacyCustomSetupPkgs Compiler
compiler (Platform Arch
_ OS
os) =
    (FilePath -> PackageName) -> [FilePath] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map FilePath -> PackageName
mkPackageName ([FilePath] -> [PackageName]) -> [FilePath] -> [PackageName]
forall a b. (a -> b) -> a -> b
$
        [ FilePath
"array", FilePath
"base", FilePath
"binary", FilePath
"bytestring", FilePath
"containers"
        , FilePath
"deepseq", FilePath
"directory", FilePath
"filepath", FilePath
"pretty"
        , FilePath
"process", FilePath
"time", FilePath
"transformers" ]
     [FilePath] -> [FilePath] -> [FilePath]
forall a. [a] -> [a] -> [a]
++ [ FilePath
"Win32" | OS
os OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
Windows ]
     [FilePath] -> [FilePath] -> [FilePath]
forall a. [a] -> [a] -> [a]
++ [ FilePath
"unix"  | OS
os OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
/= OS
Windows ]
     [FilePath] -> [FilePath] -> [FilePath]
forall a. [a] -> [a] -> [a]
++ [ FilePath
"ghc-prim"         | Bool
isGHC ]
     [FilePath] -> [FilePath] -> [FilePath]
forall a. [a] -> [a] -> [a]
++ [ FilePath
"template-haskell" | Bool
isGHC ]
     [FilePath] -> [FilePath] -> [FilePath]
forall a. [a] -> [a] -> [a]
++ [ FilePath
"old-time" | Bool
notGHC710 ]
  where
    isGHC :: Bool
isGHC = CompilerFlavor -> Compiler -> Bool
compilerCompatFlavor CompilerFlavor
GHC Compiler
compiler
    notGHC710 :: Bool
notGHC710 = case CompilerFlavor -> Compiler -> Maybe Version
compilerCompatVersion CompilerFlavor
GHC Compiler
compiler of
        Maybe Version
Nothing -> Bool
False
        Just Version
v  -> Version
v Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
<= [Int] -> Version
mkVersion [Int
7,Int
9]

-- The other aspects of our Setup.hs policy lives here where we decide on
-- the 'SetupScriptOptions'.
--
-- Our current policy for the 'SetupCustomImplicitDeps' case is that we
-- try to make the implicit deps cover everything, and we don't allow the
-- compiler to pick up other deps. This may or may not be sustainable, and
-- we might have to allow the deps to be non-exclusive, but that itself would
-- be tricky since we would have to allow the Setup access to all the packages
-- in the store and local dbs.

setupHsScriptOptions :: ElaboratedReadyPackage
                     -> ElaboratedInstallPlan
                     -> ElaboratedSharedConfig
                     -> DistDirLayout
                     -> FilePath
                     -> FilePath
                     -> Bool
                     -> Lock
                     -> SetupScriptOptions
-- TODO: Fix this so custom is a separate component.  Custom can ALWAYS
-- be a separate component!!!
setupHsScriptOptions :: ElaboratedReadyPackage
-> ElaboratedInstallPlan
-> ElaboratedSharedConfig
-> DistDirLayout
-> FilePath
-> FilePath
-> Bool
-> Lock
-> SetupScriptOptions
setupHsScriptOptions (ReadyPackage elab :: ElaboratedConfiguredPackage
elab@ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..})
                     ElaboratedInstallPlan
plan ElaboratedSharedConfig{Platform
ReplOptions
ProgramDb
Compiler
pkgConfigReplOptions :: ReplOptions
pkgConfigCompilerProgs :: ProgramDb
pkgConfigCompiler :: Compiler
pkgConfigPlatform :: Platform
pkgConfigReplOptions :: ElaboratedSharedConfig -> ReplOptions
pkgConfigCompilerProgs :: ElaboratedSharedConfig -> ProgramDb
pkgConfigPlatform :: ElaboratedSharedConfig -> Platform
pkgConfigCompiler :: ElaboratedSharedConfig -> Compiler
..} DistDirLayout
distdir FilePath
srcdir FilePath
builddir
                     Bool
isParallelBuild Lock
cacheLock =
    SetupScriptOptions :: VersionRange
-> Maybe Version
-> Maybe Compiler
-> Maybe Platform
-> PackageDBStack
-> Maybe InstalledPackageIndex
-> ProgramDb
-> FilePath
-> Maybe Handle
-> Maybe FilePath
-> [FilePath]
-> [(FilePath, Maybe FilePath)]
-> Bool
-> [(ComponentId, PackageId)]
-> Bool
-> Bool
-> Bool
-> Maybe Lock
-> Bool
-> SetupScriptOptions
SetupScriptOptions {
      useCabalVersion :: VersionRange
useCabalVersion          = Version -> VersionRange
thisVersion Version
elabSetupScriptCliVersion,
      useCabalSpecVersion :: Maybe Version
useCabalSpecVersion      = Version -> Maybe Version
forall a. a -> Maybe a
Just Version
elabSetupScriptCliVersion,
      useCompiler :: Maybe Compiler
useCompiler              = Compiler -> Maybe Compiler
forall a. a -> Maybe a
Just Compiler
pkgConfigCompiler,
      usePlatform :: Maybe Platform
usePlatform              = Platform -> Maybe Platform
forall a. a -> Maybe a
Just Platform
pkgConfigPlatform,
      usePackageDB :: PackageDBStack
usePackageDB             = PackageDBStack
elabSetupPackageDBStack,
      usePackageIndex :: Maybe InstalledPackageIndex
usePackageIndex          = Maybe InstalledPackageIndex
forall a. Maybe a
Nothing,
      useDependencies :: [(ComponentId, PackageId)]
useDependencies          = [ (ComponentId
uid, PackageId
srcid)
                                 | ConfiguredId PackageId
srcid (Just (CLibName LibraryName
LMainLibName)) ComponentId
uid
                                 <- ElaboratedConfiguredPackage -> [ConfiguredId]
elabSetupDependencies ElaboratedConfiguredPackage
elab ],
      useDependenciesExclusive :: Bool
useDependenciesExclusive = Bool
True,
      useVersionMacros :: Bool
useVersionMacros         = SetupScriptStyle
elabSetupScriptStyle SetupScriptStyle -> SetupScriptStyle -> Bool
forall a. Eq a => a -> a -> Bool
== SetupScriptStyle
SetupCustomExplicitDeps,
      useProgramDb :: ProgramDb
useProgramDb             = ProgramDb
pkgConfigCompilerProgs,
      useDistPref :: FilePath
useDistPref              = FilePath
builddir,
      useLoggingHandle :: Maybe Handle
useLoggingHandle         = Maybe Handle
forall a. Maybe a
Nothing, -- this gets set later
      useWorkingDir :: Maybe FilePath
useWorkingDir            = FilePath -> Maybe FilePath
forall a. a -> Maybe a
Just FilePath
srcdir,
      useExtraPathEnv :: [FilePath]
useExtraPathEnv          = ElaboratedConfiguredPackage -> [FilePath]
elabExeDependencyPaths ElaboratedConfiguredPackage
elab,
      useExtraEnvOverrides :: [(FilePath, Maybe FilePath)]
useExtraEnvOverrides     = DistDirLayout
-> ElaboratedInstallPlan -> [(FilePath, Maybe FilePath)]
dataDirsEnvironmentForPlan DistDirLayout
distdir ElaboratedInstallPlan
plan,
      useWin32CleanHack :: Bool
useWin32CleanHack        = Bool
False,   --TODO: [required eventually]
      forceExternalSetupMethod :: Bool
forceExternalSetupMethod = Bool
isParallelBuild,
      setupCacheLock :: Maybe Lock
setupCacheLock           = Lock -> Maybe Lock
forall a. a -> Maybe a
Just Lock
cacheLock,
      isInteractive :: Bool
isInteractive            = Bool
False
    }


-- | To be used for the input for elaborateInstallPlan.
--
-- TODO: [code cleanup] make InstallDirs.defaultInstallDirs pure.
--
userInstallDirTemplates :: Compiler
                        -> IO InstallDirs.InstallDirTemplates
userInstallDirTemplates :: Compiler -> IO InstallDirTemplates
userInstallDirTemplates Compiler
compiler = do
    CompilerFlavor -> Bool -> Bool -> IO InstallDirTemplates
InstallDirs.defaultInstallDirs
                  (Compiler -> CompilerFlavor
compilerFlavor Compiler
compiler)
                  Bool
True  -- user install
                  Bool
False -- unused

storePackageInstallDirs :: StoreDirLayout
                        -> CompilerId
                        -> InstalledPackageId
                        -> InstallDirs.InstallDirs FilePath
storePackageInstallDirs :: StoreDirLayout -> CompilerId -> ComponentId -> InstallDirs FilePath
storePackageInstallDirs StoreDirLayout
storeDirLayout CompilerId
compid ComponentId
ipkgid =
  StoreDirLayout -> CompilerId -> UnitId -> InstallDirs FilePath
storePackageInstallDirs' StoreDirLayout
storeDirLayout CompilerId
compid (UnitId -> InstallDirs FilePath) -> UnitId -> InstallDirs FilePath
forall a b. (a -> b) -> a -> b
$ ComponentId -> UnitId
newSimpleUnitId ComponentId
ipkgid

storePackageInstallDirs' :: StoreDirLayout
                         -> CompilerId
                         -> UnitId
                         -> InstallDirs.InstallDirs FilePath
storePackageInstallDirs' :: StoreDirLayout -> CompilerId -> UnitId -> InstallDirs FilePath
storePackageInstallDirs' StoreDirLayout{ CompilerId -> UnitId -> FilePath
storePackageDirectory :: StoreDirLayout -> CompilerId -> UnitId -> FilePath
storePackageDirectory :: CompilerId -> UnitId -> FilePath
storePackageDirectory
                                       , CompilerId -> FilePath
storeDirectory :: StoreDirLayout -> CompilerId -> FilePath
storeDirectory :: CompilerId -> FilePath
storeDirectory }
                         CompilerId
compid UnitId
unitid =
    InstallDirs :: forall dir.
dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> dir
-> InstallDirs dir
InstallDirs.InstallDirs {FilePath
prefix :: FilePath
bindir :: FilePath
libdir :: FilePath
libsubdir :: FilePath
dynlibdir :: FilePath
flibdir :: FilePath
libexecdir :: FilePath
libexecsubdir :: FilePath
includedir :: FilePath
datadir :: FilePath
datasubdir :: FilePath
docdir :: FilePath
mandir :: FilePath
htmldir :: FilePath
haddockdir :: FilePath
sysconfdir :: FilePath
sysconfdir :: FilePath
haddockdir :: FilePath
htmldir :: FilePath
mandir :: FilePath
docdir :: FilePath
datasubdir :: FilePath
datadir :: FilePath
includedir :: FilePath
libexecsubdir :: FilePath
libexecdir :: FilePath
flibdir :: FilePath
dynlibdir :: FilePath
libsubdir :: FilePath
libdir :: FilePath
bindir :: FilePath
prefix :: FilePath
..}
  where
    store :: FilePath
store        = CompilerId -> FilePath
storeDirectory CompilerId
compid
    prefix :: FilePath
prefix       = CompilerId -> UnitId -> FilePath
storePackageDirectory CompilerId
compid UnitId
unitid
    bindir :: FilePath
bindir       = FilePath
prefix FilePath -> FilePath -> FilePath
</> FilePath
"bin"
    libdir :: FilePath
libdir       = FilePath
prefix FilePath -> FilePath -> FilePath
</> FilePath
"lib"
    libsubdir :: FilePath
libsubdir    = FilePath
""
    -- Note: on macOS, we place libraries into
    --       @store/lib@ to work around the load
    --       command size limit of macOSs mach-o linker.
    --       See also @PackageHash.hashedInstalledPackageIdVeryShort@
    dynlibdir :: FilePath
dynlibdir    | OS
buildOS OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
OSX = FilePath
store FilePath -> FilePath -> FilePath
</> FilePath
"lib"
                 | Bool
otherwise      = FilePath
libdir
    flibdir :: FilePath
flibdir      = FilePath
libdir
    libexecdir :: FilePath
libexecdir   = FilePath
prefix FilePath -> FilePath -> FilePath
</> FilePath
"libexec"
    libexecsubdir :: FilePath
libexecsubdir= FilePath
""
    includedir :: FilePath
includedir   = FilePath
libdir FilePath -> FilePath -> FilePath
</> FilePath
"include"
    datadir :: FilePath
datadir      = FilePath
prefix FilePath -> FilePath -> FilePath
</> FilePath
"share"
    datasubdir :: FilePath
datasubdir   = FilePath
""
    docdir :: FilePath
docdir       = FilePath
datadir FilePath -> FilePath -> FilePath
</> FilePath
"doc"
    mandir :: FilePath
mandir       = FilePath
datadir FilePath -> FilePath -> FilePath
</> FilePath
"man"
    htmldir :: FilePath
htmldir      = FilePath
docdir  FilePath -> FilePath -> FilePath
</> FilePath
"html"
    haddockdir :: FilePath
haddockdir   = FilePath
htmldir
    sysconfdir :: FilePath
sysconfdir   = FilePath
prefix FilePath -> FilePath -> FilePath
</> FilePath
"etc"



computeInstallDirs :: StoreDirLayout
                   -> InstallDirs.InstallDirTemplates
                   -> ElaboratedSharedConfig
                   -> ElaboratedConfiguredPackage
                   -> InstallDirs.InstallDirs FilePath
computeInstallDirs :: StoreDirLayout
-> InstallDirTemplates
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> InstallDirs FilePath
computeInstallDirs StoreDirLayout
storeDirLayout InstallDirTemplates
defaultInstallDirs ElaboratedSharedConfig
elaboratedShared ElaboratedConfiguredPackage
elab
  | ElaboratedConfiguredPackage -> BuildStyle
elabBuildStyle ElaboratedConfiguredPackage
elab BuildStyle -> BuildStyle -> Bool
forall a. Eq a => a -> a -> Bool
== BuildStyle
BuildInplaceOnly
  -- use the ordinary default install dirs
  = (PackageId
-> UnitId
-> CompilerInfo
-> CopyDest
-> Platform
-> InstallDirTemplates
-> InstallDirs FilePath
InstallDirs.absoluteInstallDirs
       (ElaboratedConfiguredPackage -> PackageId
elabPkgSourceId ElaboratedConfiguredPackage
elab)
       (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
elab)
       (Compiler -> CompilerInfo
compilerInfo (ElaboratedSharedConfig -> Compiler
pkgConfigCompiler ElaboratedSharedConfig
elaboratedShared))
       CopyDest
InstallDirs.NoCopyDest
       (ElaboratedSharedConfig -> Platform
pkgConfigPlatform ElaboratedSharedConfig
elaboratedShared)
       InstallDirTemplates
defaultInstallDirs) {

      -- absoluteInstallDirs sets these as 'undefined' but we have
      -- to use them as "Setup.hs configure" args
      libsubdir :: FilePath
InstallDirs.libsubdir  = FilePath
"",
      libexecsubdir :: FilePath
InstallDirs.libexecsubdir  = FilePath
"",
      datasubdir :: FilePath
InstallDirs.datasubdir = FilePath
""
    }

  | Bool
otherwise
  -- use special simplified install dirs
  = StoreDirLayout -> CompilerId -> UnitId -> InstallDirs FilePath
storePackageInstallDirs'
      StoreDirLayout
storeDirLayout
      (Compiler -> CompilerId
compilerId (ElaboratedSharedConfig -> Compiler
pkgConfigCompiler ElaboratedSharedConfig
elaboratedShared))
      (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
elab)


--TODO: [code cleanup] perhaps reorder this code
-- based on the ElaboratedInstallPlan + ElaboratedSharedConfig,
-- make the various Setup.hs {configure,build,copy} flags


setupHsConfigureFlags :: ElaboratedReadyPackage
                      -> ElaboratedSharedConfig
                      -> Verbosity
                      -> FilePath
                      -> Cabal.ConfigFlags
setupHsConfigureFlags :: ElaboratedReadyPackage
-> ElaboratedSharedConfig -> Verbosity -> FilePath -> ConfigFlags
setupHsConfigureFlags (ReadyPackage elab :: ElaboratedConfiguredPackage
elab@ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..})
                      sharedConfig :: ElaboratedSharedConfig
sharedConfig@ElaboratedSharedConfig{Platform
ReplOptions
ProgramDb
Compiler
pkgConfigReplOptions :: ReplOptions
pkgConfigCompilerProgs :: ProgramDb
pkgConfigCompiler :: Compiler
pkgConfigPlatform :: Platform
pkgConfigReplOptions :: ElaboratedSharedConfig -> ReplOptions
pkgConfigCompilerProgs :: ElaboratedSharedConfig -> ProgramDb
pkgConfigPlatform :: ElaboratedSharedConfig -> Platform
pkgConfigCompiler :: ElaboratedSharedConfig -> Compiler
..}
                      Verbosity
verbosity FilePath
builddir =
    ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> ConfigFlags -> ConfigFlags
forall a.
ElaboratedSharedConfig -> ElaboratedConfiguredPackage -> a -> a
sanityCheckElaboratedConfiguredPackage ElaboratedSharedConfig
sharedConfig ElaboratedConfiguredPackage
elab
        (ConfigFlags :: [FilePath]
-> Option' (Last' ProgramDb)
-> [(FilePath, FilePath)]
-> [(FilePath, [FilePath])]
-> NubList FilePath
-> Flag CompilerFlavor
-> Flag FilePath
-> Flag FilePath
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag ProfDetailLevel
-> Flag ProfDetailLevel
-> [FilePath]
-> Flag OptimisationLevel
-> Flag PathTemplate
-> Flag PathTemplate
-> InstallDirs (Flag PathTemplate)
-> Flag FilePath
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> Flag FilePath
-> Flag ComponentId
-> Flag Bool
-> Flag FilePath
-> Flag FilePath
-> Flag Verbosity
-> Flag Bool
-> [Maybe PackageDB]
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> [PackageVersionConstraint]
-> [GivenComponent]
-> [(ModuleName, Module)]
-> FlagAssignment
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag FilePath
-> Flag Bool
-> Flag DebugInfoLevel
-> Flag DumpBuildInfo
-> Flag Bool
-> Flag Bool
-> ConfigFlags
Cabal.ConfigFlags {[FilePath]
[Maybe PackageDB]
[(FilePath, FilePath)]
[(FilePath, [FilePath])]
[(ModuleName, Module)]
[GivenComponent]
[PackageVersionConstraint]
NubList FilePath
InstallDirs (Flag PathTemplate)
Flag Bool
Flag FilePath
Flag CompilerFlavor
Flag ComponentId
Flag OptimisationLevel
Flag DebugInfoLevel
Flag ProfDetailLevel
Flag Verbosity
Flag DumpBuildInfo
Flag PathTemplate
FlagAssignment
Option' (Last' ProgramDb)
configArgs :: [FilePath]
configPrograms_ :: Option' (Last' ProgramDb)
configProgramPaths :: [(FilePath, FilePath)]
configProgramArgs :: [(FilePath, [FilePath])]
configProgramPathExtra :: NubList FilePath
configHcFlavor :: Flag CompilerFlavor
configHcPath :: Flag FilePath
configHcPkg :: Flag FilePath
configVanillaLib :: Flag Bool
configProfLib :: Flag Bool
configSharedLib :: Flag Bool
configStaticLib :: Flag Bool
configDynExe :: Flag Bool
configFullyStaticExe :: Flag Bool
configProfExe :: Flag Bool
configProf :: Flag Bool
configProfDetail :: Flag ProfDetailLevel
configProfLibDetail :: Flag ProfDetailLevel
configConfigureArgs :: [FilePath]
configOptimization :: Flag OptimisationLevel
configProgPrefix :: Flag PathTemplate
configProgSuffix :: Flag PathTemplate
configInstallDirs :: InstallDirs (Flag PathTemplate)
configScratchDir :: Flag FilePath
configExtraLibDirs :: [FilePath]
configExtraLibDirsStatic :: [FilePath]
configExtraFrameworkDirs :: [FilePath]
configExtraIncludeDirs :: [FilePath]
configIPID :: Flag FilePath
configCID :: Flag ComponentId
configDeterministic :: Flag Bool
configDistPref :: Flag FilePath
configCabalFilePath :: Flag FilePath
configVerbosity :: Flag Verbosity
configUserInstall :: Flag Bool
configPackageDBs :: [Maybe PackageDB]
configGHCiLib :: Flag Bool
configSplitSections :: Flag Bool
configSplitObjs :: Flag Bool
configStripExes :: Flag Bool
configStripLibs :: Flag Bool
configConstraints :: [PackageVersionConstraint]
configDependencies :: [GivenComponent]
configInstantiateWith :: [(ModuleName, Module)]
configConfigurationsFlags :: FlagAssignment
configTests :: Flag Bool
configBenchmarks :: Flag Bool
configCoverage :: Flag Bool
configLibCoverage :: Flag Bool
configExactConfiguration :: Flag Bool
configFlagError :: Flag FilePath
configRelocatable :: Flag Bool
configDebugInfo :: Flag DebugInfoLevel
configDumpBuildInfo :: Flag DumpBuildInfo
configUseResponseFiles :: Flag Bool
configAllowDependingOnPrivateLibs :: Flag Bool
configAllowDependingOnPrivateLibs :: Flag Bool
configUseResponseFiles :: Flag Bool
configPrograms_ :: Option' (Last' ProgramDb)
configUserInstall :: Flag Bool
configScratchDir :: Flag FilePath
configRelocatable :: Flag Bool
configFlagError :: Flag FilePath
configExactConfiguration :: Flag Bool
configBenchmarks :: Flag Bool
configTests :: Flag Bool
configPackageDBs :: [Maybe PackageDB]
configConstraints :: [PackageVersionConstraint]
configDependencies :: [GivenComponent]
configInstallDirs :: InstallDirs (Flag PathTemplate)
configProgSuffix :: Flag PathTemplate
configProgPrefix :: Flag PathTemplate
configExtraIncludeDirs :: [FilePath]
configExtraFrameworkDirs :: [FilePath]
configExtraLibDirsStatic :: [FilePath]
configExtraLibDirs :: [FilePath]
configConfigureArgs :: [FilePath]
configConfigurationsFlags :: FlagAssignment
configDumpBuildInfo :: Flag DumpBuildInfo
configDebugInfo :: Flag DebugInfoLevel
configStripLibs :: Flag Bool
configStripExes :: Flag Bool
configSplitObjs :: Flag Bool
configSplitSections :: Flag Bool
configOptimization :: Flag OptimisationLevel
configLibCoverage :: Flag Bool
configCoverage :: Flag Bool
configProfLibDetail :: Flag ProfDetailLevel
configProfDetail :: Flag ProfDetailLevel
configProf :: Flag Bool
configProfLib :: Flag Bool
configProfExe :: Flag Bool
configGHCiLib :: Flag Bool
configFullyStaticExe :: Flag Bool
configDynExe :: Flag Bool
configStaticLib :: Flag Bool
configSharedLib :: Flag Bool
configVanillaLib :: Flag Bool
configHcPkg :: Flag FilePath
configHcPath :: Flag FilePath
configHcFlavor :: Flag CompilerFlavor
configProgramPathExtra :: NubList FilePath
configProgramArgs :: [(FilePath, [FilePath])]
configProgramPaths :: [(FilePath, FilePath)]
configCID :: Flag ComponentId
configIPID :: Flag FilePath
configDeterministic :: Flag Bool
configInstantiateWith :: [(ModuleName, Module)]
configVerbosity :: Flag Verbosity
configCabalFilePath :: Flag FilePath
configDistPref :: Flag FilePath
configArgs :: [FilePath]
..})
  where
    configArgs :: [FilePath]
configArgs                = [FilePath]
forall a. Monoid a => a
mempty -- unused, passed via args
    configDistPref :: Flag FilePath
configDistPref            = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir
    configCabalFilePath :: Flag FilePath
configCabalFilePath       = Flag FilePath
forall a. Monoid a => a
mempty
    configVerbosity :: Flag Verbosity
configVerbosity           = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity

    configInstantiateWith :: [(ModuleName, Module)]
configInstantiateWith     = Map ModuleName Module -> [(ModuleName, Module)]
forall k a. Map k a -> [(k, a)]
Map.toList Map ModuleName Module
elabInstantiatedWith

    configDeterministic :: Flag Bool
configDeterministic       = Flag Bool
forall a. Monoid a => a
mempty -- doesn't matter, configIPID/configCID overridese
    configIPID :: Flag FilePath
configIPID                = case ElaboratedPackageOrComponent
elabPkgOrComp of
                                  ElabPackage ElaboratedPackage
pkg -> FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag (ComponentId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow (ElaboratedPackage -> ComponentId
pkgInstalledId ElaboratedPackage
pkg))
                                  ElabComponent ElaboratedComponent
_ -> Flag FilePath
forall a. Monoid a => a
mempty
    configCID :: Flag ComponentId
configCID                 = case ElaboratedPackageOrComponent
elabPkgOrComp of
                                  ElabPackage ElaboratedPackage
_ -> Flag ComponentId
forall a. Monoid a => a
mempty
                                  ElabComponent ElaboratedComponent
_ -> ComponentId -> Flag ComponentId
forall a. a -> Flag a
toFlag ComponentId
elabComponentId

    configProgramPaths :: [(FilePath, FilePath)]
configProgramPaths        = Map FilePath FilePath -> [(FilePath, FilePath)]
forall k a. Map k a -> [(k, a)]
Map.toList Map FilePath FilePath
elabProgramPaths
    configProgramArgs :: [(FilePath, [FilePath])]
configProgramArgs
        | {- elabSetupScriptCliVersion < mkVersion [1,24,3] -} Bool
True
          -- workaround for <https://github.com/haskell/cabal/issues/4010>
          --
          -- It turns out, that even with Cabal 2.0, there's still cases such as e.g.
          -- custom Setup.hs scripts calling out to GHC even when going via
          -- @runProgram ghcProgram@, as e.g. happy does in its
          -- <http://hackage.haskell.org/package/happy-1.19.5/src/Setup.lhs>
          -- (see also <https://github.com/haskell/cabal/pull/4433#issuecomment-299396099>)
          --
          -- So for now, let's pass the rather harmless and idempotent
          -- `-hide-all-packages` flag to all invocations (which has
          -- the benefit that every GHC invocation starts with a
          -- consistently well-defined clean slate) until we find a
          -- better way.
                              = Map FilePath [FilePath] -> [(FilePath, [FilePath])]
forall k a. Map k a -> [(k, a)]
Map.toList (Map FilePath [FilePath] -> [(FilePath, [FilePath])])
-> Map FilePath [FilePath] -> [(FilePath, [FilePath])]
forall a b. (a -> b) -> a -> b
$
                                ([FilePath] -> [FilePath] -> [FilePath])
-> FilePath
-> [FilePath]
-> Map FilePath [FilePath]
-> Map FilePath [FilePath]
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith [FilePath] -> [FilePath] -> [FilePath]
forall a. [a] -> [a] -> [a]
(++) FilePath
"ghc" [FilePath
"-hide-all-packages"]
                                               Map FilePath [FilePath]
elabProgramArgs
    configProgramPathExtra :: NubList FilePath
configProgramPathExtra    = [FilePath] -> NubList FilePath
forall a. Ord a => [a] -> NubList a
toNubList [FilePath]
elabProgramPathExtra
    configHcFlavor :: Flag CompilerFlavor
configHcFlavor            = CompilerFlavor -> Flag CompilerFlavor
forall a. a -> Flag a
toFlag (Compiler -> CompilerFlavor
compilerFlavor Compiler
pkgConfigCompiler)
    configHcPath :: Flag FilePath
configHcPath              = Flag FilePath
forall a. Monoid a => a
mempty -- we use configProgramPaths instead
    configHcPkg :: Flag FilePath
configHcPkg               = Flag FilePath
forall a. Monoid a => a
mempty -- we use configProgramPaths instead

    configVanillaLib :: Flag Bool
configVanillaLib          = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabVanillaLib
    configSharedLib :: Flag Bool
configSharedLib           = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabSharedLib
    configStaticLib :: Flag Bool
configStaticLib           = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabStaticLib

    configDynExe :: Flag Bool
configDynExe              = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabDynExe
    configFullyStaticExe :: Flag Bool
configFullyStaticExe      = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabFullyStaticExe
    configGHCiLib :: Flag Bool
configGHCiLib             = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabGHCiLib
    configProfExe :: Flag Bool
configProfExe             = Flag Bool
forall a. Monoid a => a
mempty
    configProfLib :: Flag Bool
configProfLib             = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabProfLib
    configProf :: Flag Bool
configProf                = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabProfExe

    -- configProfDetail is for exe+lib, but overridden by configProfLibDetail
    -- so we specify both so we can specify independently
    configProfDetail :: Flag ProfDetailLevel
configProfDetail          = ProfDetailLevel -> Flag ProfDetailLevel
forall a. a -> Flag a
toFlag ProfDetailLevel
elabProfExeDetail
    configProfLibDetail :: Flag ProfDetailLevel
configProfLibDetail       = ProfDetailLevel -> Flag ProfDetailLevel
forall a. a -> Flag a
toFlag ProfDetailLevel
elabProfLibDetail

    configCoverage :: Flag Bool
configCoverage            = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabCoverage
    configLibCoverage :: Flag Bool
configLibCoverage         = Flag Bool
forall a. Monoid a => a
mempty

    configOptimization :: Flag OptimisationLevel
configOptimization        = OptimisationLevel -> Flag OptimisationLevel
forall a. a -> Flag a
toFlag OptimisationLevel
elabOptimization
    configSplitSections :: Flag Bool
configSplitSections       = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabSplitSections
    configSplitObjs :: Flag Bool
configSplitObjs           = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabSplitObjs
    configStripExes :: Flag Bool
configStripExes           = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabStripExes
    configStripLibs :: Flag Bool
configStripLibs           = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabStripLibs
    configDebugInfo :: Flag DebugInfoLevel
configDebugInfo           = DebugInfoLevel -> Flag DebugInfoLevel
forall a. a -> Flag a
toFlag DebugInfoLevel
elabDebugInfo
    configDumpBuildInfo :: Flag DumpBuildInfo
configDumpBuildInfo       = DumpBuildInfo -> Flag DumpBuildInfo
forall a. a -> Flag a
toFlag DumpBuildInfo
elabDumpBuildInfo

    configConfigurationsFlags :: FlagAssignment
configConfigurationsFlags = FlagAssignment
elabFlagAssignment
    configConfigureArgs :: [FilePath]
configConfigureArgs       = [FilePath]
elabConfigureScriptArgs
    configExtraLibDirs :: [FilePath]
configExtraLibDirs        = [FilePath]
elabExtraLibDirs
    configExtraLibDirsStatic :: [FilePath]
configExtraLibDirsStatic  = [FilePath]
elabExtraLibDirsStatic
    configExtraFrameworkDirs :: [FilePath]
configExtraFrameworkDirs  = [FilePath]
elabExtraFrameworkDirs
    configExtraIncludeDirs :: [FilePath]
configExtraIncludeDirs    = [FilePath]
elabExtraIncludeDirs
    configProgPrefix :: Flag PathTemplate
configProgPrefix          = Flag PathTemplate
-> (PathTemplate -> Flag PathTemplate)
-> Maybe PathTemplate
-> Flag PathTemplate
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag PathTemplate
forall a. Monoid a => a
mempty PathTemplate -> Flag PathTemplate
forall a. a -> Flag a
toFlag Maybe PathTemplate
elabProgPrefix
    configProgSuffix :: Flag PathTemplate
configProgSuffix          = Flag PathTemplate
-> (PathTemplate -> Flag PathTemplate)
-> Maybe PathTemplate
-> Flag PathTemplate
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag PathTemplate
forall a. Monoid a => a
mempty PathTemplate -> Flag PathTemplate
forall a. a -> Flag a
toFlag Maybe PathTemplate
elabProgSuffix

    configInstallDirs :: InstallDirs (Flag PathTemplate)
configInstallDirs         = (FilePath -> Flag PathTemplate)
-> InstallDirs FilePath -> InstallDirs (Flag PathTemplate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PathTemplate -> Flag PathTemplate
forall a. a -> Flag a
toFlag (PathTemplate -> Flag PathTemplate)
-> (FilePath -> PathTemplate) -> FilePath -> Flag PathTemplate
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> PathTemplate
InstallDirs.toPathTemplate)
                                     InstallDirs FilePath
elabInstallDirs

    -- we only use configDependencies, unless we're talking to an old Cabal
    -- in which case we use configConstraints
    -- NB: This does NOT use InstallPlan.depends, which includes executable
    -- dependencies which should NOT be fed in here (also you don't have
    -- enough info anyway)
    configDependencies :: [GivenComponent]
configDependencies        = [ PackageName -> LibraryName -> ComponentId -> GivenComponent
GivenComponent
                                    (PackageId -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageId
srcid)
                                    LibraryName
ln
                                    ComponentId
cid
                                | ConfiguredId PackageId
srcid Maybe ComponentName
mb_cn ComponentId
cid <- ElaboratedConfiguredPackage -> [ConfiguredId]
elabLibDependencies ElaboratedConfiguredPackage
elab
                                , let ln :: LibraryName
ln = case Maybe ComponentName
mb_cn
                                           of Just (CLibName LibraryName
lname) -> LibraryName
lname
                                              Just ComponentName
_ -> FilePath -> LibraryName
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"non-library dependency"
                                              Maybe ComponentName
Nothing -> LibraryName
LMainLibName
                                ]
    configConstraints :: [PackageVersionConstraint]
configConstraints         =
        case ElaboratedPackageOrComponent
elabPkgOrComp of
            ElabPackage ElaboratedPackage
_ ->
                [ PackageId -> PackageVersionConstraint
thisPackageVersionConstraint PackageId
srcid
                | ConfiguredId PackageId
srcid Maybe ComponentName
_ ComponentId
_uid <- ElaboratedConfiguredPackage -> [ConfiguredId]
elabLibDependencies ElaboratedConfiguredPackage
elab ]
            ElabComponent ElaboratedComponent
_ -> []


    -- explicitly clear, then our package db stack
    -- TODO: [required eventually] have to do this differently for older Cabal versions
    configPackageDBs :: [Maybe PackageDB]
configPackageDBs          = Maybe PackageDB
forall a. Maybe a
Nothing Maybe PackageDB -> [Maybe PackageDB] -> [Maybe PackageDB]
forall a. a -> [a] -> [a]
: (PackageDB -> Maybe PackageDB)
-> PackageDBStack -> [Maybe PackageDB]
forall a b. (a -> b) -> [a] -> [b]
map PackageDB -> Maybe PackageDB
forall a. a -> Maybe a
Just PackageDBStack
elabBuildPackageDBStack

    configTests :: Flag Bool
configTests               = case ElaboratedPackageOrComponent
elabPkgOrComp of
                                    ElabPackage ElaboratedPackage
pkg -> Bool -> Flag Bool
forall a. a -> Flag a
toFlag (OptionalStanza
TestStanzas  OptionalStanza -> OptionalStanzaSet -> Bool
`optStanzaSetMember` ElaboratedPackage -> OptionalStanzaSet
pkgStanzasEnabled ElaboratedPackage
pkg)
                                    ElabComponent ElaboratedComponent
_ -> Flag Bool
forall a. Monoid a => a
mempty
    configBenchmarks :: Flag Bool
configBenchmarks          = case ElaboratedPackageOrComponent
elabPkgOrComp of
                                    ElabPackage ElaboratedPackage
pkg -> Bool -> Flag Bool
forall a. a -> Flag a
toFlag (OptionalStanza
BenchStanzas OptionalStanza -> OptionalStanzaSet -> Bool
`optStanzaSetMember` ElaboratedPackage -> OptionalStanzaSet
pkgStanzasEnabled ElaboratedPackage
pkg)
                                    ElabComponent ElaboratedComponent
_ -> Flag Bool
forall a. Monoid a => a
mempty

    configExactConfiguration :: Flag Bool
configExactConfiguration  = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
True
    configFlagError :: Flag FilePath
configFlagError           = Flag FilePath
forall a. Monoid a => a
mempty --TODO: [research required] appears not to be implemented
    configRelocatable :: Flag Bool
configRelocatable         = Flag Bool
forall a. Monoid a => a
mempty --TODO: [research required] ???
    configScratchDir :: Flag FilePath
configScratchDir          = Flag FilePath
forall a. Monoid a => a
mempty -- never use
    configUserInstall :: Flag Bool
configUserInstall         = Flag Bool
forall a. Monoid a => a
mempty -- don't rely on defaults
    configPrograms_ :: Option' (Last' ProgramDb)
configPrograms_           = Option' (Last' ProgramDb)
forall a. Monoid a => a
mempty -- never use, shouldn't exist
    configUseResponseFiles :: Flag Bool
configUseResponseFiles    = Flag Bool
forall a. Monoid a => a
mempty
    configAllowDependingOnPrivateLibs :: Flag Bool
configAllowDependingOnPrivateLibs = Bool -> Flag Bool
forall a. a -> Flag a
Flag (Bool -> Flag Bool) -> Bool -> Flag Bool
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Compiler -> Bool
libraryVisibilitySupported Compiler
pkgConfigCompiler

setupHsConfigureArgs :: ElaboratedConfiguredPackage
                     -> [String]
setupHsConfigureArgs :: ElaboratedConfiguredPackage -> [FilePath]
setupHsConfigureArgs (ElaboratedConfiguredPackage { elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabPackage ElaboratedPackage
_ }) = []
setupHsConfigureArgs elab :: ElaboratedConfiguredPackage
elab@(ElaboratedConfiguredPackage { elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabComponent ElaboratedComponent
comp }) =
    [PackageId -> ComponentTarget -> FilePath
showComponentTarget (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab) (ComponentName -> SubComponentTarget -> ComponentTarget
ComponentTarget ComponentName
cname SubComponentTarget
WholeComponent)]
  where
    cname :: ComponentName
cname = ComponentName -> Maybe ComponentName -> ComponentName
forall a. a -> Maybe a -> a
fromMaybe (FilePath -> ComponentName
forall a. (?callStack::CallStack) => FilePath -> a
error FilePath
"setupHsConfigureArgs: trying to configure setup")
                      (ElaboratedComponent -> Maybe ComponentName
compComponentName ElaboratedComponent
comp)

setupHsBuildFlags :: ElaboratedConfiguredPackage
                  -> ElaboratedSharedConfig
                  -> Verbosity
                  -> FilePath
                  -> Cabal.BuildFlags
setupHsBuildFlags :: ElaboratedConfiguredPackage
-> ElaboratedSharedConfig -> Verbosity -> FilePath -> BuildFlags
setupHsBuildFlags ElaboratedConfiguredPackage
_ ElaboratedSharedConfig
_ Verbosity
verbosity FilePath
builddir =
    BuildFlags :: [(FilePath, FilePath)]
-> [(FilePath, [FilePath])]
-> Flag FilePath
-> Flag Verbosity
-> Flag (Maybe Int)
-> [FilePath]
-> Flag FilePath
-> BuildFlags
Cabal.BuildFlags {
      buildProgramPaths :: [(FilePath, FilePath)]
buildProgramPaths = [(FilePath, FilePath)]
forall a. Monoid a => a
mempty, --unused, set at configure time
      buildProgramArgs :: [(FilePath, [FilePath])]
buildProgramArgs  = [(FilePath, [FilePath])]
forall a. Monoid a => a
mempty, --unused, set at configure time
      buildVerbosity :: Flag Verbosity
buildVerbosity    = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity,
      buildDistPref :: Flag FilePath
buildDistPref     = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir,
      buildNumJobs :: Flag (Maybe Int)
buildNumJobs      = Flag (Maybe Int)
forall a. Monoid a => a
mempty, --TODO: [nice to have] sometimes want to use toFlag (Just numBuildJobs),
      buildArgs :: [FilePath]
buildArgs         = [FilePath]
forall a. Monoid a => a
mempty, -- unused, passed via args not flags
      buildCabalFilePath :: Flag FilePath
buildCabalFilePath= Flag FilePath
forall a. Monoid a => a
mempty
    }


setupHsBuildArgs :: ElaboratedConfiguredPackage -> [String]
setupHsBuildArgs :: ElaboratedConfiguredPackage -> [FilePath]
setupHsBuildArgs elab :: ElaboratedConfiguredPackage
elab@(ElaboratedConfiguredPackage { elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabPackage ElaboratedPackage
_ })
    -- Fix for #3335, don't pass build arguments if it's not supported
    | ElaboratedConfiguredPackage -> Version
elabSetupScriptCliVersion ElaboratedConfiguredPackage
elab Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
1,Int
17]
    = (ComponentTarget -> FilePath) -> [ComponentTarget] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map (PackageId -> ComponentTarget -> FilePath
showComponentTarget (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab)) (ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets ElaboratedConfiguredPackage
elab)
    | Bool
otherwise
    = []
setupHsBuildArgs (ElaboratedConfiguredPackage { elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp = ElabComponent ElaboratedComponent
_ })
    = []


setupHsTestFlags :: ElaboratedConfiguredPackage
                 -> ElaboratedSharedConfig
                 -> Verbosity
                 -> FilePath
                 -> Cabal.TestFlags
setupHsTestFlags :: ElaboratedConfiguredPackage
-> ElaboratedSharedConfig -> Verbosity -> FilePath -> TestFlags
setupHsTestFlags (ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..}) ElaboratedSharedConfig
_ Verbosity
verbosity FilePath
builddir = TestFlags :: Flag FilePath
-> Flag Verbosity
-> Flag PathTemplate
-> Flag PathTemplate
-> Flag TestShowDetails
-> Flag Bool
-> Flag FilePath
-> Flag Bool
-> [PathTemplate]
-> TestFlags
Cabal.TestFlags
    { testDistPref :: Flag FilePath
testDistPref    = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir
    , testVerbosity :: Flag Verbosity
testVerbosity   = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity
    , testMachineLog :: Flag PathTemplate
testMachineLog  = Flag PathTemplate
-> (PathTemplate -> Flag PathTemplate)
-> Maybe PathTemplate
-> Flag PathTemplate
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag PathTemplate
forall a. Monoid a => a
mempty PathTemplate -> Flag PathTemplate
forall a. a -> Flag a
toFlag Maybe PathTemplate
elabTestMachineLog
    , testHumanLog :: Flag PathTemplate
testHumanLog    = Flag PathTemplate
-> (PathTemplate -> Flag PathTemplate)
-> Maybe PathTemplate
-> Flag PathTemplate
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag PathTemplate
forall a. Monoid a => a
mempty PathTemplate -> Flag PathTemplate
forall a. a -> Flag a
toFlag Maybe PathTemplate
elabTestHumanLog
    , testShowDetails :: Flag TestShowDetails
testShowDetails = Flag TestShowDetails
-> (TestShowDetails -> Flag TestShowDetails)
-> Maybe TestShowDetails
-> Flag TestShowDetails
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (TestShowDetails -> Flag TestShowDetails
forall a. a -> Flag a
Flag TestShowDetails
Cabal.Always) TestShowDetails -> Flag TestShowDetails
forall a. a -> Flag a
toFlag Maybe TestShowDetails
elabTestShowDetails
    , testKeepTix :: Flag Bool
testKeepTix     = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabTestKeepTix
    , testWrapper :: Flag FilePath
testWrapper     = Flag FilePath
-> (FilePath -> Flag FilePath) -> Maybe FilePath -> Flag FilePath
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag FilePath
forall a. Monoid a => a
mempty FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag Maybe FilePath
elabTestWrapper
    , testFailWhenNoTestSuites :: Flag Bool
testFailWhenNoTestSuites = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabTestFailWhenNoTestSuites
    , testOptions :: [PathTemplate]
testOptions     = [PathTemplate]
elabTestTestOptions
    }

setupHsTestArgs :: ElaboratedConfiguredPackage -> [String]
-- TODO: Does the issue #3335 affects test as well
setupHsTestArgs :: ElaboratedConfiguredPackage -> [FilePath]
setupHsTestArgs ElaboratedConfiguredPackage
elab =
    (ComponentTarget -> Maybe FilePath)
-> [ComponentTarget] -> [FilePath]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (PackageId -> ComponentTarget -> Maybe FilePath
showTestComponentTarget (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab)) (ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets ElaboratedConfiguredPackage
elab)


setupHsBenchFlags :: ElaboratedConfiguredPackage
                  -> ElaboratedSharedConfig
                  -> Verbosity
                  -> FilePath
                  -> Cabal.BenchmarkFlags
setupHsBenchFlags :: ElaboratedConfiguredPackage
-> ElaboratedSharedConfig
-> Verbosity
-> FilePath
-> BenchmarkFlags
setupHsBenchFlags (ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..}) ElaboratedSharedConfig
_ Verbosity
verbosity FilePath
builddir = BenchmarkFlags :: Flag FilePath -> Flag Verbosity -> [PathTemplate] -> BenchmarkFlags
Cabal.BenchmarkFlags
    { benchmarkDistPref :: Flag FilePath
benchmarkDistPref  = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir
    , benchmarkVerbosity :: Flag Verbosity
benchmarkVerbosity = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity
    , benchmarkOptions :: [PathTemplate]
benchmarkOptions   = [PathTemplate]
elabBenchmarkOptions
    }

setupHsBenchArgs :: ElaboratedConfiguredPackage -> [String]
setupHsBenchArgs :: ElaboratedConfiguredPackage -> [FilePath]
setupHsBenchArgs ElaboratedConfiguredPackage
elab =
    (ComponentTarget -> Maybe FilePath)
-> [ComponentTarget] -> [FilePath]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (PackageId -> ComponentTarget -> Maybe FilePath
showBenchComponentTarget (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab)) (ElaboratedConfiguredPackage -> [ComponentTarget]
elabBenchTargets ElaboratedConfiguredPackage
elab)


setupHsReplFlags :: ElaboratedConfiguredPackage
                 -> ElaboratedSharedConfig
                 -> Verbosity
                 -> FilePath
                 -> Cabal.ReplFlags
setupHsReplFlags :: ElaboratedConfiguredPackage
-> ElaboratedSharedConfig -> Verbosity -> FilePath -> ReplFlags
setupHsReplFlags ElaboratedConfiguredPackage
_ ElaboratedSharedConfig
sharedConfig Verbosity
verbosity FilePath
builddir =
    ReplFlags :: [(FilePath, FilePath)]
-> [(FilePath, [FilePath])]
-> Flag FilePath
-> Flag Verbosity
-> Flag Bool
-> ReplOptions
-> ReplFlags
Cabal.ReplFlags {
      replProgramPaths :: [(FilePath, FilePath)]
replProgramPaths = [(FilePath, FilePath)]
forall a. Monoid a => a
mempty, --unused, set at configure time
      replProgramArgs :: [(FilePath, [FilePath])]
replProgramArgs  = [(FilePath, [FilePath])]
forall a. Monoid a => a
mempty, --unused, set at configure time
      replVerbosity :: Flag Verbosity
replVerbosity    = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity,
      replDistPref :: Flag FilePath
replDistPref     = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir,
      replReload :: Flag Bool
replReload       = Flag Bool
forall a. Monoid a => a
mempty, --only used as callback from repl
      replReplOptions :: ReplOptions
replReplOptions  = ElaboratedSharedConfig -> ReplOptions
pkgConfigReplOptions ElaboratedSharedConfig
sharedConfig       --runtime override for repl flags
    }


setupHsReplArgs :: ElaboratedConfiguredPackage -> [String]
setupHsReplArgs :: ElaboratedConfiguredPackage -> [FilePath]
setupHsReplArgs ElaboratedConfiguredPackage
elab =
    [FilePath]
-> (ComponentTarget -> [FilePath])
-> Maybe ComponentTarget
-> [FilePath]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ComponentTarget
t -> [PackageId -> ComponentTarget -> FilePath
showComponentTarget (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab) ComponentTarget
t]) (ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabReplTarget ElaboratedConfiguredPackage
elab)
    --TODO: should be able to give multiple modules in one component


setupHsCopyFlags :: ElaboratedConfiguredPackage
                 -> ElaboratedSharedConfig
                 -> Verbosity
                 -> FilePath
                 -> FilePath
                 -> Cabal.CopyFlags
setupHsCopyFlags :: ElaboratedConfiguredPackage
-> ElaboratedSharedConfig
-> Verbosity
-> FilePath
-> FilePath
-> CopyFlags
setupHsCopyFlags ElaboratedConfiguredPackage
_ ElaboratedSharedConfig
_ Verbosity
verbosity FilePath
builddir FilePath
destdir =
    CopyFlags :: Flag CopyDest
-> Flag FilePath
-> Flag Verbosity
-> [FilePath]
-> Flag FilePath
-> CopyFlags
Cabal.CopyFlags {
      copyArgs :: [FilePath]
copyArgs      = [], -- TODO: could use this to only copy what we enabled
      copyDest :: Flag CopyDest
copyDest      = CopyDest -> Flag CopyDest
forall a. a -> Flag a
toFlag (FilePath -> CopyDest
InstallDirs.CopyTo FilePath
destdir),
      copyDistPref :: Flag FilePath
copyDistPref  = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir,
      copyVerbosity :: Flag Verbosity
copyVerbosity = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity,
      copyCabalFilePath :: Flag FilePath
copyCabalFilePath = Flag FilePath
forall a. Monoid a => a
mempty
    }

setupHsRegisterFlags :: ElaboratedConfiguredPackage
                     -> ElaboratedSharedConfig
                     -> Verbosity
                     -> FilePath
                     -> FilePath
                     -> Cabal.RegisterFlags
setupHsRegisterFlags :: ElaboratedConfiguredPackage
-> ElaboratedSharedConfig
-> Verbosity
-> FilePath
-> FilePath
-> RegisterFlags
setupHsRegisterFlags ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..} ElaboratedSharedConfig
_
                     Verbosity
verbosity FilePath
builddir FilePath
pkgConfFile =
    RegisterFlags :: Flag PackageDB
-> Flag Bool
-> Flag (Maybe FilePath)
-> Flag Bool
-> Flag FilePath
-> Flag Bool
-> Flag Verbosity
-> [FilePath]
-> Flag FilePath
-> RegisterFlags
Cabal.RegisterFlags {
      regPackageDB :: Flag PackageDB
regPackageDB   = Flag PackageDB
forall a. Monoid a => a
mempty,  -- misfeature
      regGenScript :: Flag Bool
regGenScript   = Flag Bool
forall a. Monoid a => a
mempty,  -- never use
      regGenPkgConf :: Flag (Maybe FilePath)
regGenPkgConf  = Maybe FilePath -> Flag (Maybe FilePath)
forall a. a -> Flag a
toFlag (FilePath -> Maybe FilePath
forall a. a -> Maybe a
Just FilePath
pkgConfFile),
      regInPlace :: Flag Bool
regInPlace     = case BuildStyle
elabBuildStyle of
                         BuildStyle
BuildInplaceOnly -> Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
True
                         BuildStyle
_                -> Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
False,
      regPrintId :: Flag Bool
regPrintId     = Flag Bool
forall a. Monoid a => a
mempty,  -- never use
      regDistPref :: Flag FilePath
regDistPref    = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir,
      regArgs :: [FilePath]
regArgs        = [],
      regVerbosity :: Flag Verbosity
regVerbosity   = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity,
      regCabalFilePath :: Flag FilePath
regCabalFilePath = Flag FilePath
forall a. Monoid a => a
mempty
    }

setupHsHaddockFlags :: ElaboratedConfiguredPackage
                    -> ElaboratedSharedConfig
                    -> Verbosity
                    -> FilePath
                    -> Cabal.HaddockFlags
setupHsHaddockFlags :: ElaboratedConfiguredPackage
-> ElaboratedSharedConfig -> Verbosity -> FilePath -> HaddockFlags
setupHsHaddockFlags (ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabBuildHaddocks :: Bool
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockContents :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForHackage :: HaddockTarget
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabInstallDirs :: InstallDirs FilePath
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirsStatic :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabConfigureScriptArgs :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitSections :: Bool
elabSplitObjs :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabStaticLib :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabPackageDbs :: [Maybe PackageDB]
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabFlagAssignment :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..}) ElaboratedSharedConfig
_ Verbosity
verbosity FilePath
builddir =
    HaddockFlags :: [(FilePath, FilePath)]
-> [(FilePath, [FilePath])]
-> Flag Bool
-> Flag Bool
-> Flag FilePath
-> Flag HaddockTarget
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag Bool
-> Flag FilePath
-> Flag Bool
-> Flag Bool
-> Flag FilePath
-> Flag PathTemplate
-> Flag FilePath
-> Flag Bool
-> Flag Verbosity
-> Flag FilePath
-> [FilePath]
-> HaddockFlags
Cabal.HaddockFlags {
      haddockProgramPaths :: [(FilePath, FilePath)]
haddockProgramPaths  = [(FilePath, FilePath)]
forall a. Monoid a => a
mempty, --unused, set at configure time
      haddockProgramArgs :: [(FilePath, [FilePath])]
haddockProgramArgs   = [(FilePath, [FilePath])]
forall a. Monoid a => a
mempty, --unused, set at configure time
      haddockHoogle :: Flag Bool
haddockHoogle        = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockHoogle,
      haddockHtml :: Flag Bool
haddockHtml          = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockHtml,
      haddockHtmlLocation :: Flag FilePath
haddockHtmlLocation  = Flag FilePath
-> (FilePath -> Flag FilePath) -> Maybe FilePath -> Flag FilePath
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag FilePath
forall a. Monoid a => a
mempty FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag Maybe FilePath
elabHaddockHtmlLocation,
      haddockForHackage :: Flag HaddockTarget
haddockForHackage    = HaddockTarget -> Flag HaddockTarget
forall a. a -> Flag a
toFlag HaddockTarget
elabHaddockForHackage,
      haddockForeignLibs :: Flag Bool
haddockForeignLibs   = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockForeignLibs,
      haddockExecutables :: Flag Bool
haddockExecutables   = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockExecutables,
      haddockTestSuites :: Flag Bool
haddockTestSuites    = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockTestSuites,
      haddockBenchmarks :: Flag Bool
haddockBenchmarks    = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockBenchmarks,
      haddockInternal :: Flag Bool
haddockInternal      = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockInternal,
      haddockCss :: Flag FilePath
haddockCss           = Flag FilePath
-> (FilePath -> Flag FilePath) -> Maybe FilePath -> Flag FilePath
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag FilePath
forall a. Monoid a => a
mempty FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag Maybe FilePath
elabHaddockCss,
      haddockLinkedSource :: Flag Bool
haddockLinkedSource  = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockLinkedSource,
      haddockQuickJump :: Flag Bool
haddockQuickJump     = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
elabHaddockQuickJump,
      haddockHscolourCss :: Flag FilePath
haddockHscolourCss   = Flag FilePath
-> (FilePath -> Flag FilePath) -> Maybe FilePath -> Flag FilePath
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag FilePath
forall a. Monoid a => a
mempty FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag Maybe FilePath
elabHaddockHscolourCss,
      haddockContents :: Flag PathTemplate
haddockContents      = Flag PathTemplate
-> (PathTemplate -> Flag PathTemplate)
-> Maybe PathTemplate
-> Flag PathTemplate
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Flag PathTemplate
forall a. Monoid a => a
mempty PathTemplate -> Flag PathTemplate
forall a. a -> Flag a
toFlag Maybe PathTemplate
elabHaddockContents,
      haddockDistPref :: Flag FilePath
haddockDistPref      = FilePath -> Flag FilePath
forall a. a -> Flag a
toFlag FilePath
builddir,
      haddockKeepTempFiles :: Flag Bool
haddockKeepTempFiles = Flag Bool
forall a. Monoid a => a
mempty, --TODO: from build settings
      haddockVerbosity :: Flag Verbosity
haddockVerbosity     = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
verbosity,
      haddockCabalFilePath :: Flag FilePath
haddockCabalFilePath = Flag FilePath
forall a. Monoid a => a
mempty,
      haddockArgs :: [FilePath]
haddockArgs          = [FilePath]
forall a. Monoid a => a
mempty
    }

setupHsHaddockArgs :: ElaboratedConfiguredPackage -> [String]
-- TODO: Does the issue #3335 affects test as well
setupHsHaddockArgs :: ElaboratedConfiguredPackage -> [FilePath]
setupHsHaddockArgs ElaboratedConfiguredPackage
elab =
  (ComponentTarget -> FilePath) -> [ComponentTarget] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map (PackageId -> ComponentTarget -> FilePath
showComponentTarget (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab)) (ElaboratedConfiguredPackage -> [ComponentTarget]
elabHaddockTargets ElaboratedConfiguredPackage
elab)

{-
setupHsTestFlags :: ElaboratedConfiguredPackage
                 -> ElaboratedSharedConfig
                 -> Verbosity
                 -> FilePath
                 -> Cabal.TestFlags
setupHsTestFlags _ _ verbosity builddir =
    Cabal.TestFlags {
    }
-}

------------------------------------------------------------------------------
-- * Sharing installed packages
------------------------------------------------------------------------------

--
-- Nix style store management for tarball packages
--
-- So here's our strategy:
--
-- We use a per-user nix-style hashed store, but /only/ for tarball packages.
-- So that includes packages from hackage repos (and other http and local
-- tarballs). For packages in local directories we do not register them into
-- the shared store by default, we just build them locally inplace.
--
-- The reason we do it like this is that it's easy to make stable hashes for
-- tarball packages, and these packages benefit most from sharing. By contrast
-- unpacked dir packages are harder to hash and they tend to change more
-- frequently so there's less benefit to sharing them.
--
-- When using the nix store approach we have to run the solver *without*
-- looking at the packages installed in the store, just at the source packages
-- (plus core\/global installed packages). Then we do a post-processing pass
-- to replace configured packages in the plan with pre-existing ones, where
-- possible. Where possible of course means where the nix-style package hash
-- equals one that's already in the store.
--
-- One extra wrinkle is that unless we know package tarball hashes upfront, we
-- will have to download the tarballs to find their hashes. So we have two
-- options: delay replacing source with pre-existing installed packages until
-- the point during the execution of the install plan where we have the
-- tarball, or try to do as much up-front as possible and then check again
-- during plan execution. The former isn't great because we would end up
-- telling users we're going to re-install loads of packages when in fact we
-- would just share them. It'd be better to give as accurate a prediction as
-- we can. The latter is better for users, but we do still have to check
-- during plan execution because it's important that we don't replace existing
-- installed packages even if they have the same package hash, because we
-- don't guarantee ABI stability.

-- TODO: [required eventually] for safety of concurrent installs, we must make sure we register but
-- not replace installed packages with ghc-pkg.

packageHashInputs :: ElaboratedSharedConfig
                  -> ElaboratedConfiguredPackage
                  -> PackageHashInputs
packageHashInputs :: ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> PackageHashInputs
packageHashInputs
    ElaboratedSharedConfig
pkgshared
    elab :: ElaboratedConfiguredPackage
elab@(ElaboratedConfiguredPackage {
      elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceHash = Just PackageSourceHash
srchash
    }) =
    PackageHashInputs :: PackageId
-> Maybe Component
-> PackageSourceHash
-> Set (PkgconfigName, Maybe PkgconfigVersion)
-> Set ComponentId
-> PackageHashConfigInputs
-> PackageHashInputs
PackageHashInputs {
      pkgHashPkgId :: PackageId
pkgHashPkgId       = ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
elab,
      pkgHashComponent :: Maybe Component
pkgHashComponent   =
        case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
          ElabPackage ElaboratedPackage
_ -> Maybe Component
forall a. Maybe a
Nothing
          ElabComponent ElaboratedComponent
comp -> Component -> Maybe Component
forall a. a -> Maybe a
Just (ElaboratedComponent -> Component
compSolverName ElaboratedComponent
comp),
      pkgHashSourceHash :: PackageSourceHash
pkgHashSourceHash  = PackageSourceHash
srchash,
      pkgHashPkgConfigDeps :: Set (PkgconfigName, Maybe PkgconfigVersion)
pkgHashPkgConfigDeps = [(PkgconfigName, Maybe PkgconfigVersion)]
-> Set (PkgconfigName, Maybe PkgconfigVersion)
forall a. Ord a => [a] -> Set a
Set.fromList (ElaboratedConfiguredPackage
-> [(PkgconfigName, Maybe PkgconfigVersion)]
elabPkgConfigDependencies ElaboratedConfiguredPackage
elab),
      pkgHashDirectDeps :: Set ComponentId
pkgHashDirectDeps  =
        case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
elab of
          ElabPackage (ElaboratedPackage{[(PkgconfigName, Maybe PkgconfigVersion)]
ComponentId
OptionalStanzaSet
ComponentDeps [()]
ComponentDeps [(ConfiguredId, FilePath)]
ComponentDeps [ConfiguredId]
pkgStanzasEnabled :: OptionalStanzaSet
pkgPkgConfigDependencies :: [(PkgconfigName, Maybe PkgconfigVersion)]
pkgExeDependencyPaths :: ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencies :: ComponentDeps [ConfiguredId]
pkgDependsOnSelfLib :: ComponentDeps [()]
pkgLibDependencies :: ComponentDeps [ConfiguredId]
pkgInstalledId :: ComponentId
pkgStanzasEnabled :: ElaboratedPackage -> OptionalStanzaSet
pkgPkgConfigDependencies :: ElaboratedPackage -> [(PkgconfigName, Maybe PkgconfigVersion)]
pkgExeDependencyPaths :: ElaboratedPackage -> ComponentDeps [(ConfiguredId, FilePath)]
pkgExeDependencies :: ElaboratedPackage -> ComponentDeps [ConfiguredId]
pkgDependsOnSelfLib :: ElaboratedPackage -> ComponentDeps [()]
pkgLibDependencies :: ElaboratedPackage -> ComponentDeps [ConfiguredId]
pkgInstalledId :: ElaboratedPackage -> ComponentId
..}) ->
            [ComponentId] -> Set ComponentId
forall a. Ord a => [a] -> Set a
Set.fromList ([ComponentId] -> Set ComponentId)
-> [ComponentId] -> Set ComponentId
forall a b. (a -> b) -> a -> b
$
             [ ConfiguredId -> ComponentId
confInstId ConfiguredId
dep
             | ConfiguredId
dep <- (Component -> Bool)
-> ComponentDeps [ConfiguredId] -> [ConfiguredId]
forall a. Monoid a => (Component -> Bool) -> ComponentDeps a -> a
CD.select Component -> Bool
relevantDeps ComponentDeps [ConfiguredId]
pkgLibDependencies ] [ComponentId] -> [ComponentId] -> [ComponentId]
forall a. [a] -> [a] -> [a]
++
             [ ConfiguredId -> ComponentId
confInstId ConfiguredId
dep
             | ConfiguredId
dep <- (Component -> Bool)
-> ComponentDeps [ConfiguredId] -> [ConfiguredId]
forall a. Monoid a => (Component -> Bool) -> ComponentDeps a -> a
CD.select Component -> Bool
relevantDeps ComponentDeps [ConfiguredId]
pkgExeDependencies ]
          ElabComponent ElaboratedComponent
comp ->
            [ComponentId] -> Set ComponentId
forall a. Ord a => [a] -> Set a
Set.fromList ((ConfiguredId -> ComponentId) -> [ConfiguredId] -> [ComponentId]
forall a b. (a -> b) -> [a] -> [b]
map ConfiguredId -> ComponentId
confInstId (ElaboratedComponent -> [ConfiguredId]
compLibDependencies ElaboratedComponent
comp
                                       [ConfiguredId] -> [ConfiguredId] -> [ConfiguredId]
forall a. [a] -> [a] -> [a]
++ ElaboratedComponent -> [ConfiguredId]
compExeDependencies ElaboratedComponent
comp)),
      pkgHashOtherConfig :: PackageHashConfigInputs
pkgHashOtherConfig = ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> PackageHashConfigInputs
packageHashConfigInputs ElaboratedSharedConfig
pkgshared ElaboratedConfiguredPackage
elab
    }
  where
    -- Obviously the main deps are relevant
    relevantDeps :: Component -> Bool
relevantDeps Component
CD.ComponentLib       = Bool
True
    relevantDeps (CD.ComponentSubLib UnqualComponentName
_) = Bool
True
    relevantDeps (CD.ComponentFLib UnqualComponentName
_)   = Bool
True
    relevantDeps (CD.ComponentExe UnqualComponentName
_)   = Bool
True
    -- Setup deps can affect the Setup.hs behaviour and thus what is built
    relevantDeps  Component
CD.ComponentSetup    = Bool
True
    -- However testsuites and benchmarks do not get installed and should not
    -- affect the result, so we do not include them.
    relevantDeps (CD.ComponentTest  UnqualComponentName
_) = Bool
False
    relevantDeps (CD.ComponentBench UnqualComponentName
_) = Bool
False

packageHashInputs ElaboratedSharedConfig
_ ElaboratedConfiguredPackage
pkg =
    FilePath -> PackageHashInputs
forall a. (?callStack::CallStack) => FilePath -> a
error (FilePath -> PackageHashInputs) -> FilePath -> PackageHashInputs
forall a b. (a -> b) -> a -> b
$ FilePath
"packageHashInputs: only for packages with source hashes. "
         FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ PackageId -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow (ElaboratedConfiguredPackage -> PackageId
forall pkg. Package pkg => pkg -> PackageId
packageId ElaboratedConfiguredPackage
pkg)

packageHashConfigInputs :: ElaboratedSharedConfig
                        -> ElaboratedConfiguredPackage
                        -> PackageHashConfigInputs
packageHashConfigInputs :: ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> PackageHashConfigInputs
packageHashConfigInputs shared :: ElaboratedSharedConfig
shared@ElaboratedSharedConfig{Platform
ReplOptions
ProgramDb
Compiler
pkgConfigReplOptions :: ReplOptions
pkgConfigCompilerProgs :: ProgramDb
pkgConfigCompiler :: Compiler
pkgConfigPlatform :: Platform
pkgConfigReplOptions :: ElaboratedSharedConfig -> ReplOptions
pkgConfigCompilerProgs :: ElaboratedSharedConfig -> ProgramDb
pkgConfigPlatform :: ElaboratedSharedConfig -> Platform
pkgConfigCompiler :: ElaboratedSharedConfig -> Compiler
..} ElaboratedConfiguredPackage
pkg =
    PackageHashConfigInputs :: CompilerId
-> Platform
-> FlagAssignment
-> [FilePath]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ProfDetailLevel
-> ProfDetailLevel
-> Bool
-> OptimisationLevel
-> Bool
-> Bool
-> Bool
-> Bool
-> DebugInfoLevel
-> Map FilePath [FilePath]
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> Maybe PathTemplate
-> Maybe PathTemplate
-> [Maybe PackageDB]
-> Bool
-> Bool
-> Bool
-> Maybe FilePath
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe FilePath
-> Bool
-> Bool
-> Maybe PathTemplate
-> PackageHashConfigInputs
PackageHashConfigInputs {
      pkgHashCompilerId :: CompilerId
pkgHashCompilerId          = Compiler -> CompilerId
compilerId Compiler
pkgConfigCompiler,
      pkgHashPlatform :: Platform
pkgHashPlatform            = Platform
pkgConfigPlatform,
      pkgHashFlagAssignment :: FlagAssignment
pkgHashFlagAssignment      = FlagAssignment
elabFlagAssignment,
      pkgHashConfigureScriptArgs :: [FilePath]
pkgHashConfigureScriptArgs = [FilePath]
elabConfigureScriptArgs,
      pkgHashVanillaLib :: Bool
pkgHashVanillaLib          = Bool
elabVanillaLib,
      pkgHashSharedLib :: Bool
pkgHashSharedLib           = Bool
elabSharedLib,
      pkgHashDynExe :: Bool
pkgHashDynExe              = Bool
elabDynExe,
      pkgHashFullyStaticExe :: Bool
pkgHashFullyStaticExe      = Bool
elabFullyStaticExe,
      pkgHashGHCiLib :: Bool
pkgHashGHCiLib             = Bool
elabGHCiLib,
      pkgHashProfLib :: Bool
pkgHashProfLib             = Bool
elabProfLib,
      pkgHashProfExe :: Bool
pkgHashProfExe             = Bool
elabProfExe,
      pkgHashProfLibDetail :: ProfDetailLevel
pkgHashProfLibDetail       = ProfDetailLevel
elabProfLibDetail,
      pkgHashProfExeDetail :: ProfDetailLevel
pkgHashProfExeDetail       = ProfDetailLevel
elabProfExeDetail,
      pkgHashCoverage :: Bool
pkgHashCoverage            = Bool
elabCoverage,
      pkgHashOptimization :: OptimisationLevel
pkgHashOptimization        = OptimisationLevel
elabOptimization,
      pkgHashSplitSections :: Bool
pkgHashSplitSections       = Bool
elabSplitSections,
      pkgHashSplitObjs :: Bool
pkgHashSplitObjs           = Bool
elabSplitObjs,
      pkgHashStripLibs :: Bool
pkgHashStripLibs           = Bool
elabStripLibs,
      pkgHashStripExes :: Bool
pkgHashStripExes           = Bool
elabStripExes,
      pkgHashDebugInfo :: DebugInfoLevel
pkgHashDebugInfo           = DebugInfoLevel
elabDebugInfo,
      pkgHashProgramArgs :: Map FilePath [FilePath]
pkgHashProgramArgs         = Map FilePath [FilePath]
elabProgramArgs,
      pkgHashExtraLibDirs :: [FilePath]
pkgHashExtraLibDirs        = [FilePath]
elabExtraLibDirs,
      pkgHashExtraFrameworkDirs :: [FilePath]
pkgHashExtraFrameworkDirs  = [FilePath]
elabExtraFrameworkDirs,
      pkgHashExtraIncludeDirs :: [FilePath]
pkgHashExtraIncludeDirs    = [FilePath]
elabExtraIncludeDirs,
      pkgHashProgPrefix :: Maybe PathTemplate
pkgHashProgPrefix          = Maybe PathTemplate
elabProgPrefix,
      pkgHashProgSuffix :: Maybe PathTemplate
pkgHashProgSuffix          = Maybe PathTemplate
elabProgSuffix,
      pkgHashPackageDbs :: [Maybe PackageDB]
pkgHashPackageDbs          = [Maybe PackageDB]
elabPackageDbs,

      pkgHashDocumentation :: Bool
pkgHashDocumentation       = Bool
elabBuildHaddocks,
      pkgHashHaddockHoogle :: Bool
pkgHashHaddockHoogle       = Bool
elabHaddockHoogle,
      pkgHashHaddockHtml :: Bool
pkgHashHaddockHtml         = Bool
elabHaddockHtml,
      pkgHashHaddockHtmlLocation :: Maybe FilePath
pkgHashHaddockHtmlLocation = Maybe FilePath
elabHaddockHtmlLocation,
      pkgHashHaddockForeignLibs :: Bool
pkgHashHaddockForeignLibs  = Bool
elabHaddockForeignLibs,
      pkgHashHaddockExecutables :: Bool
pkgHashHaddockExecutables  = Bool
elabHaddockExecutables,
      pkgHashHaddockTestSuites :: Bool
pkgHashHaddockTestSuites   = Bool
elabHaddockTestSuites,
      pkgHashHaddockBenchmarks :: Bool
pkgHashHaddockBenchmarks   = Bool
elabHaddockBenchmarks,
      pkgHashHaddockInternal :: Bool
pkgHashHaddockInternal     = Bool
elabHaddockInternal,
      pkgHashHaddockCss :: Maybe FilePath
pkgHashHaddockCss          = Maybe FilePath
elabHaddockCss,
      pkgHashHaddockLinkedSource :: Bool
pkgHashHaddockLinkedSource = Bool
elabHaddockLinkedSource,
      pkgHashHaddockQuickJump :: Bool
pkgHashHaddockQuickJump    = Bool
elabHaddockQuickJump,
      pkgHashHaddockContents :: Maybe PathTemplate
pkgHashHaddockContents     = Maybe PathTemplate
elabHaddockContents
    }
  where
    ElaboratedConfiguredPackage{Bool
[FilePath]
[Maybe PackageDB]
PackageDBStack
[PathTemplate]
[ComponentTarget]
Maybe FilePath
Maybe TestShowDetails
Maybe PathTemplate
Maybe CabalFileText
Maybe PackageSourceHash
Maybe ComponentTarget
PackageDescription
PackageId
UnitId
ComponentId
Map FilePath FilePath
Map FilePath [FilePath]
Map ModuleName Module
Map ModuleName OpenModule
HaddockTarget
OptimisationLevel
DebugInfoLevel
ProfDetailLevel
DumpBuildInfo
InstallDirs FilePath
ModuleShape
Version
ComponentRequestedSpec
FlagAssignment
OptionalStanzaSet
OptionalStanzaMap (Maybe Bool)
PackageLocation (Maybe FilePath)
SetupScriptStyle
BuildStyle
ElaboratedPackageOrComponent
elabPkgOrComp :: ElaboratedPackageOrComponent
elabHaddockTargets :: [ComponentTarget]
elabReplTarget :: Maybe ComponentTarget
elabBenchTargets :: [ComponentTarget]
elabTestTargets :: [ComponentTarget]
elabBuildTargets :: [ComponentTarget]
elabConfigureTargets :: [ComponentTarget]
elabSetupScriptCliVersion :: Version
elabSetupScriptStyle :: SetupScriptStyle
elabBenchmarkOptions :: [PathTemplate]
elabTestTestOptions :: [PathTemplate]
elabTestFailWhenNoTestSuites :: Bool
elabTestWrapper :: Maybe FilePath
elabTestKeepTix :: Bool
elabTestShowDetails :: Maybe TestShowDetails
elabTestHumanLog :: Maybe PathTemplate
elabTestMachineLog :: Maybe PathTemplate
elabHaddockHscolourCss :: Maybe FilePath
elabHaddockForHackage :: HaddockTarget
elabInstallDirs :: InstallDirs FilePath
elabExtraLibDirsStatic :: [FilePath]
elabProgramPathExtra :: [FilePath]
elabProgramPaths :: Map FilePath FilePath
elabDumpBuildInfo :: DumpBuildInfo
elabStaticLib :: Bool
elabPkgDescriptionOverride :: Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: PackageDBStack
elabInplaceBuildPackageDBStack :: PackageDBStack
elabInplaceSetupPackageDBStack :: PackageDBStack
elabRegisterPackageDBStack :: PackageDBStack
elabBuildPackageDBStack :: PackageDBStack
elabSetupPackageDBStack :: PackageDBStack
elabStanzasRequested :: OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: OptionalStanzaSet
elabEnabledSpec :: ComponentRequestedSpec
elabBuildStyle :: BuildStyle
elabLocalToProject :: Bool
elabPkgSourceHash :: Maybe PackageSourceHash
elabPkgSourceLocation :: PackageLocation (Maybe FilePath)
elabPkgDescription :: PackageDescription
elabFlagDefaults :: FlagAssignment
elabModuleShape :: ModuleShape
elabPkgSourceId :: PackageId
elabIsCanonical :: Bool
elabLinkedInstantiatedWith :: Map ModuleName OpenModule
elabInstantiatedWith :: Map ModuleName Module
elabComponentId :: ComponentId
elabUnitId :: UnitId
elabHaddockContents :: Maybe PathTemplate
elabHaddockQuickJump :: Bool
elabHaddockLinkedSource :: Bool
elabHaddockCss :: Maybe FilePath
elabHaddockInternal :: Bool
elabHaddockBenchmarks :: Bool
elabHaddockTestSuites :: Bool
elabHaddockExecutables :: Bool
elabHaddockForeignLibs :: Bool
elabHaddockHtmlLocation :: Maybe FilePath
elabHaddockHtml :: Bool
elabHaddockHoogle :: Bool
elabBuildHaddocks :: Bool
elabPackageDbs :: [Maybe PackageDB]
elabProgSuffix :: Maybe PathTemplate
elabProgPrefix :: Maybe PathTemplate
elabExtraIncludeDirs :: [FilePath]
elabExtraFrameworkDirs :: [FilePath]
elabExtraLibDirs :: [FilePath]
elabProgramArgs :: Map FilePath [FilePath]
elabDebugInfo :: DebugInfoLevel
elabStripExes :: Bool
elabStripLibs :: Bool
elabSplitObjs :: Bool
elabSplitSections :: Bool
elabOptimization :: OptimisationLevel
elabCoverage :: Bool
elabProfExeDetail :: ProfDetailLevel
elabProfLibDetail :: ProfDetailLevel
elabProfExe :: Bool
elabProfLib :: Bool
elabGHCiLib :: Bool
elabFullyStaticExe :: Bool
elabDynExe :: Bool
elabSharedLib :: Bool
elabVanillaLib :: Bool
elabConfigureScriptArgs :: [FilePath]
elabFlagAssignment :: FlagAssignment
elabPkgOrComp :: ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabBuildHaddocks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabReplTarget :: ElaboratedConfiguredPackage -> Maybe ComponentTarget
elabBenchTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabTestTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabBuildTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabConfigureTargets :: ElaboratedConfiguredPackage -> [ComponentTarget]
elabSetupScriptCliVersion :: ElaboratedConfiguredPackage -> Version
elabSetupScriptStyle :: ElaboratedConfiguredPackage -> SetupScriptStyle
elabBenchmarkOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestTestOptions :: ElaboratedConfiguredPackage -> [PathTemplate]
elabTestFailWhenNoTestSuites :: ElaboratedConfiguredPackage -> Bool
elabTestWrapper :: ElaboratedConfiguredPackage -> Maybe FilePath
elabTestKeepTix :: ElaboratedConfiguredPackage -> Bool
elabTestShowDetails :: ElaboratedConfiguredPackage -> Maybe TestShowDetails
elabTestHumanLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabTestMachineLog :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockContents :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabHaddockHscolourCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockQuickJump :: ElaboratedConfiguredPackage -> Bool
elabHaddockLinkedSource :: ElaboratedConfiguredPackage -> Bool
elabHaddockCss :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockInternal :: ElaboratedConfiguredPackage -> Bool
elabHaddockBenchmarks :: ElaboratedConfiguredPackage -> Bool
elabHaddockTestSuites :: ElaboratedConfiguredPackage -> Bool
elabHaddockExecutables :: ElaboratedConfiguredPackage -> Bool
elabHaddockForHackage :: ElaboratedConfiguredPackage -> HaddockTarget
elabHaddockForeignLibs :: ElaboratedConfiguredPackage -> Bool
elabHaddockHtmlLocation :: ElaboratedConfiguredPackage -> Maybe FilePath
elabHaddockHtml :: ElaboratedConfiguredPackage -> Bool
elabHaddockHoogle :: ElaboratedConfiguredPackage -> Bool
elabInstallDirs :: ElaboratedConfiguredPackage -> InstallDirs FilePath
elabProgSuffix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabProgPrefix :: ElaboratedConfiguredPackage -> Maybe PathTemplate
elabExtraIncludeDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraFrameworkDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirsStatic :: ElaboratedConfiguredPackage -> [FilePath]
elabExtraLibDirs :: ElaboratedConfiguredPackage -> [FilePath]
elabConfigureScriptArgs :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramPathExtra :: ElaboratedConfiguredPackage -> [FilePath]
elabProgramArgs :: ElaboratedConfiguredPackage -> Map FilePath [FilePath]
elabProgramPaths :: ElaboratedConfiguredPackage -> Map FilePath FilePath
elabDumpBuildInfo :: ElaboratedConfiguredPackage -> DumpBuildInfo
elabDebugInfo :: ElaboratedConfiguredPackage -> DebugInfoLevel
elabStripExes :: ElaboratedConfiguredPackage -> Bool
elabStripLibs :: ElaboratedConfiguredPackage -> Bool
elabSplitSections :: ElaboratedConfiguredPackage -> Bool
elabSplitObjs :: ElaboratedConfiguredPackage -> Bool
elabOptimization :: ElaboratedConfiguredPackage -> OptimisationLevel
elabCoverage :: ElaboratedConfiguredPackage -> Bool
elabProfExeDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfLibDetail :: ElaboratedConfiguredPackage -> ProfDetailLevel
elabProfExe :: ElaboratedConfiguredPackage -> Bool
elabProfLib :: ElaboratedConfiguredPackage -> Bool
elabGHCiLib :: ElaboratedConfiguredPackage -> Bool
elabFullyStaticExe :: ElaboratedConfiguredPackage -> Bool
elabDynExe :: ElaboratedConfiguredPackage -> Bool
elabStaticLib :: ElaboratedConfiguredPackage -> Bool
elabSharedLib :: ElaboratedConfiguredPackage -> Bool
elabVanillaLib :: ElaboratedConfiguredPackage -> Bool
elabPkgDescriptionOverride :: ElaboratedConfiguredPackage -> Maybe CabalFileText
elabInplaceRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabInplaceSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabRegisterPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabBuildPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabSetupPackageDBStack :: ElaboratedConfiguredPackage -> PackageDBStack
elabPackageDbs :: ElaboratedConfiguredPackage -> [Maybe PackageDB]
elabStanzasRequested :: ElaboratedConfiguredPackage -> OptionalStanzaMap (Maybe Bool)
elabStanzasAvailable :: ElaboratedConfiguredPackage -> OptionalStanzaSet
elabEnabledSpec :: ElaboratedConfiguredPackage -> ComponentRequestedSpec
elabBuildStyle :: ElaboratedConfiguredPackage -> BuildStyle
elabLocalToProject :: ElaboratedConfiguredPackage -> Bool
elabPkgSourceHash :: ElaboratedConfiguredPackage -> Maybe PackageSourceHash
elabPkgSourceLocation :: ElaboratedConfiguredPackage -> PackageLocation (Maybe FilePath)
elabPkgDescription :: ElaboratedConfiguredPackage -> PackageDescription
elabFlagDefaults :: ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment :: ElaboratedConfiguredPackage -> FlagAssignment
elabModuleShape :: ElaboratedConfiguredPackage -> ModuleShape
elabPkgSourceId :: ElaboratedConfiguredPackage -> PackageId
elabIsCanonical :: ElaboratedConfiguredPackage -> Bool
elabLinkedInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName OpenModule
elabInstantiatedWith :: ElaboratedConfiguredPackage -> Map ModuleName Module
elabComponentId :: ElaboratedConfiguredPackage -> ComponentId
elabUnitId :: ElaboratedConfiguredPackage -> UnitId
..} = ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> ElaboratedConfiguredPackage
normaliseConfiguredPackage ElaboratedSharedConfig
shared ElaboratedConfiguredPackage
pkg

-- | Given the 'InstalledPackageIndex' for a nix-style package store, and an
-- 'ElaboratedInstallPlan', replace configured source packages by installed
-- packages from the store whenever they exist.
--
improveInstallPlanWithInstalledPackages :: Set UnitId
                                        -> ElaboratedInstallPlan
                                        -> ElaboratedInstallPlan
improveInstallPlanWithInstalledPackages :: Set UnitId -> ElaboratedInstallPlan -> ElaboratedInstallPlan
improveInstallPlanWithInstalledPackages Set UnitId
installedPkgIdSet =
    (ElaboratedConfiguredPackage -> Bool)
-> ElaboratedInstallPlan -> ElaboratedInstallPlan
forall ipkg srcpkg.
(IsUnit ipkg, IsUnit srcpkg) =>
(srcpkg -> Bool)
-> GenericInstallPlan ipkg srcpkg -> GenericInstallPlan ipkg srcpkg
InstallPlan.installed ElaboratedConfiguredPackage -> Bool
forall pkg. HasUnitId pkg => pkg -> Bool
canPackageBeImproved
  where
    canPackageBeImproved :: pkg -> Bool
canPackageBeImproved pkg
pkg =
      pkg -> UnitId
forall pkg. HasUnitId pkg => pkg -> UnitId
installedUnitId pkg
pkg UnitId -> Set UnitId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set UnitId
installedPkgIdSet
    --TODO: sanity checks:
    -- * the installed package must have the expected deps etc
    -- * the installed package must not be broken, valid dep closure

    --TODO: decide what to do if we encounter broken installed packages,
    -- since overwriting is never safe.


-- Path construction
------

-- | The path to the directory that contains a specific executable.
-- NB: For inplace NOT InstallPaths.bindir installDirs; for an
-- inplace build those values are utter nonsense.  So we
-- have to guess where the directory is going to be.
-- Fortunately this is "stable" part of Cabal API.
-- But the way we get the build directory is A HORRIBLE
-- HACK.
binDirectoryFor
  :: DistDirLayout
  -> ElaboratedSharedConfig
  -> ElaboratedConfiguredPackage
  -> FilePath
  -> FilePath
binDirectoryFor :: DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> FilePath
-> FilePath
binDirectoryFor DistDirLayout
layout ElaboratedSharedConfig
config ElaboratedConfiguredPackage
package FilePath
exe = case ElaboratedConfiguredPackage -> BuildStyle
elabBuildStyle ElaboratedConfiguredPackage
package of
  BuildStyle
BuildAndInstall -> ElaboratedConfiguredPackage -> FilePath
installedBinDirectory ElaboratedConfiguredPackage
package
  BuildStyle
BuildInplaceOnly -> DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> FilePath
inplaceBinRoot DistDirLayout
layout ElaboratedSharedConfig
config ElaboratedConfiguredPackage
package FilePath -> FilePath -> FilePath
</> FilePath
exe

-- package has been built and installed.
installedBinDirectory :: ElaboratedConfiguredPackage -> FilePath
installedBinDirectory :: ElaboratedConfiguredPackage -> FilePath
installedBinDirectory = InstallDirs FilePath -> FilePath
forall dir. InstallDirs dir -> dir
InstallDirs.bindir (InstallDirs FilePath -> FilePath)
-> (ElaboratedConfiguredPackage -> InstallDirs FilePath)
-> ElaboratedConfiguredPackage
-> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedConfiguredPackage -> InstallDirs FilePath
elabInstallDirs

-- | The path to the @build@ directory for an inplace build.
inplaceBinRoot
  :: DistDirLayout
  -> ElaboratedSharedConfig
  -> ElaboratedConfiguredPackage
  -> FilePath
inplaceBinRoot :: DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> FilePath
inplaceBinRoot DistDirLayout
layout ElaboratedSharedConfig
config ElaboratedConfiguredPackage
package
  =  DistDirLayout -> DistDirParams -> FilePath
distBuildDirectory DistDirLayout
layout (ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> DistDirParams
elabDistDirParams ElaboratedSharedConfig
config ElaboratedConfiguredPackage
package)
 FilePath -> FilePath -> FilePath
</> FilePath
"build"