{-# LANGUAGE DeriveGeneric, DeriveDataTypeable, GeneralizedNewtypeDeriving #-}

-- | Handling project configuration, types.
--
module Distribution.Client.ProjectConfig.Types (

    -- * Types for project config
    ProjectConfig(..),
    ProjectConfigBuildOnly(..),
    ProjectConfigShared(..),
    ProjectConfigProvenance(..),
    PackageConfig(..),

    -- * Resolving configuration
    SolverSettings(..),
    BuildTimeSettings(..),

    -- * Extra useful Monoids
    MapLast(..),
    MapMappend(..),
  ) where

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

import Distribution.Client.Types.Repo ( RemoteRepo, LocalRepo )
import Distribution.Client.Types.AllowNewer ( AllowNewer(..), AllowOlder(..) )
import Distribution.Client.Types.WriteGhcEnvironmentFilesPolicy ( WriteGhcEnvironmentFilesPolicy )
import Distribution.Client.Dependency.Types
         ( PreSolver )
import Distribution.Client.Targets
         ( UserConstraint )
import Distribution.Client.BuildReports.Types
         ( ReportLevel(..) )
import Distribution.Client.Types.SourceRepo (SourceRepoList)

import Distribution.Client.IndexUtils.IndexState
         ( TotalIndexState )
import Distribution.Client.IndexUtils.ActiveRepos
         ( ActiveRepos )

import Distribution.Client.CmdInstall.ClientInstallFlags
         ( ClientInstallFlags(..) )

import Distribution.Solver.Types.Settings
import Distribution.Solver.Types.ConstraintSource

import Distribution.Package
         ( PackageName, PackageId, UnitId )
import Distribution.Types.PackageVersionConstraint
         ( PackageVersionConstraint )
import Distribution.Version
         ( Version )
import Distribution.System
         ( Platform )
import Distribution.PackageDescription
         ( FlagAssignment )
import Distribution.Simple.Compiler
         ( Compiler, CompilerFlavor, PackageDB
         , OptimisationLevel(..), ProfDetailLevel, DebugInfoLevel(..) )
import Distribution.Simple.Setup
         ( Flag, HaddockTarget(..), TestShowDetails(..), DumpBuildInfo (..) )
import Distribution.Simple.InstallDirs
         ( PathTemplate )
import Distribution.Utils.NubList
         ( NubList )

import qualified Data.Map as Map

-------------------------------
-- Project config types
--

-- | This type corresponds directly to what can be written in the
-- @cabal.project@ file. Other sources of configuration can also be injected
-- into this type, such as the user-wide @~/.cabal/config@ file and the
-- command line of @cabal configure@ or @cabal build@.
--
-- Since it corresponds to the external project file it is an instance of
-- 'Monoid' and all the fields can be empty. This also means there has to
-- be a step where we resolve configuration. At a minimum resolving means
-- applying defaults but it can also mean merging information from multiple
-- sources. For example for package-specific configuration the project file
-- can specify configuration that applies to all local packages, and then
-- additional configuration for a specific package.
--
-- Future directions: multiple profiles, conditionals. If we add these
-- features then the gap between configuration as written in the config file
-- and resolved settings we actually use will become even bigger.
--
data ProjectConfig
   = ProjectConfig {

       -- | Packages in this project, including local dirs, local .cabal files
       -- local and remote tarballs. When these are file globs, they must
       -- match at least one package.
       ProjectConfig -> [String]
projectPackages              :: [String],

       -- | Like 'projectConfigPackageGlobs' but /optional/ in the sense that
       -- file globs are allowed to match nothing. The primary use case for
       -- this is to be able to say @optional-packages: */@ to automagically
       -- pick up deps that we unpack locally without erroring when
       -- there aren't any.
       ProjectConfig -> [String]
projectPackagesOptional      :: [String],

       -- | Packages in this project from remote source repositories.
       ProjectConfig -> [SourceRepoList]
projectPackagesRepo          :: [SourceRepoList],

       -- | Packages in this project from hackage repositories.
       ProjectConfig -> [PackageVersionConstraint]
projectPackagesNamed         :: [PackageVersionConstraint],

       -- See respective types for an explanation of what these
       -- values are about:
       ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly       :: ProjectConfigBuildOnly,
       ProjectConfig -> ProjectConfigShared
projectConfigShared          :: ProjectConfigShared,
       ProjectConfig -> Set ProjectConfigProvenance
projectConfigProvenance      :: Set ProjectConfigProvenance,

       -- | Configuration to be applied to *all* packages,
       -- whether named in `cabal.project` or not.
       ProjectConfig -> PackageConfig
projectConfigAllPackages     :: PackageConfig,

       -- | Configuration to be applied to *local* packages; i.e.,
       -- any packages which are explicitly named in `cabal.project`.
       ProjectConfig -> PackageConfig
projectConfigLocalPackages   :: PackageConfig,
       ProjectConfig -> MapMappend PackageName PackageConfig
projectConfigSpecificPackage :: MapMappend PackageName PackageConfig
     }
  deriving (ProjectConfig -> ProjectConfig -> Bool
(ProjectConfig -> ProjectConfig -> Bool)
-> (ProjectConfig -> ProjectConfig -> Bool) -> Eq ProjectConfig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectConfig -> ProjectConfig -> Bool
$c/= :: ProjectConfig -> ProjectConfig -> Bool
== :: ProjectConfig -> ProjectConfig -> Bool
$c== :: ProjectConfig -> ProjectConfig -> Bool
Eq, Int -> ProjectConfig -> ShowS
[ProjectConfig] -> ShowS
ProjectConfig -> String
(Int -> ProjectConfig -> ShowS)
-> (ProjectConfig -> String)
-> ([ProjectConfig] -> ShowS)
-> Show ProjectConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectConfig] -> ShowS
$cshowList :: [ProjectConfig] -> ShowS
show :: ProjectConfig -> String
$cshow :: ProjectConfig -> String
showsPrec :: Int -> ProjectConfig -> ShowS
$cshowsPrec :: Int -> ProjectConfig -> ShowS
Show, (forall x. ProjectConfig -> Rep ProjectConfig x)
-> (forall x. Rep ProjectConfig x -> ProjectConfig)
-> Generic ProjectConfig
forall x. Rep ProjectConfig x -> ProjectConfig
forall x. ProjectConfig -> Rep ProjectConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectConfig x -> ProjectConfig
$cfrom :: forall x. ProjectConfig -> Rep ProjectConfig x
Generic, Typeable)

-- | That part of the project configuration that only affects /how/ we build
-- and not the /value/ of the things we build. This means this information
-- does not need to be tracked for changes since it does not affect the
-- outcome.
--
data ProjectConfigBuildOnly
   = ProjectConfigBuildOnly {
       ProjectConfigBuildOnly -> Flag Verbosity
projectConfigVerbosity             :: Flag Verbosity,
       ProjectConfigBuildOnly -> Flag Bool
projectConfigDryRun                :: Flag Bool,
       ProjectConfigBuildOnly -> Flag Bool
projectConfigOnlyDeps              :: Flag Bool,
       ProjectConfigBuildOnly -> Flag Bool
projectConfigOnlyDownload          :: Flag Bool,
       ProjectConfigBuildOnly -> NubList PathTemplate
projectConfigSummaryFile           :: NubList PathTemplate,
       ProjectConfigBuildOnly -> Flag PathTemplate
projectConfigLogFile               :: Flag PathTemplate,
       ProjectConfigBuildOnly -> Flag ReportLevel
projectConfigBuildReports          :: Flag ReportLevel,
       ProjectConfigBuildOnly -> Flag Bool
projectConfigReportPlanningFailure :: Flag Bool,
       ProjectConfigBuildOnly -> Flag String
projectConfigSymlinkBinDir         :: Flag FilePath,
       ProjectConfigBuildOnly -> Flag (Maybe Int)
projectConfigNumJobs               :: Flag (Maybe Int),
       ProjectConfigBuildOnly -> Flag Bool
projectConfigKeepGoing             :: Flag Bool,
       ProjectConfigBuildOnly -> Flag Bool
projectConfigOfflineMode           :: Flag Bool,
       ProjectConfigBuildOnly -> Flag Bool
projectConfigKeepTempFiles         :: Flag Bool,
       ProjectConfigBuildOnly -> Flag String
projectConfigHttpTransport         :: Flag String,
       ProjectConfigBuildOnly -> Flag Bool
projectConfigIgnoreExpiry          :: Flag Bool,
       ProjectConfigBuildOnly -> Flag String
projectConfigCacheDir              :: Flag FilePath,
       ProjectConfigBuildOnly -> Flag String
projectConfigLogsDir               :: Flag FilePath,
       ProjectConfigBuildOnly -> ClientInstallFlags
projectConfigClientInstallFlags    :: ClientInstallFlags
     }
  deriving (ProjectConfigBuildOnly -> ProjectConfigBuildOnly -> Bool
(ProjectConfigBuildOnly -> ProjectConfigBuildOnly -> Bool)
-> (ProjectConfigBuildOnly -> ProjectConfigBuildOnly -> Bool)
-> Eq ProjectConfigBuildOnly
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectConfigBuildOnly -> ProjectConfigBuildOnly -> Bool
$c/= :: ProjectConfigBuildOnly -> ProjectConfigBuildOnly -> Bool
== :: ProjectConfigBuildOnly -> ProjectConfigBuildOnly -> Bool
$c== :: ProjectConfigBuildOnly -> ProjectConfigBuildOnly -> Bool
Eq, Int -> ProjectConfigBuildOnly -> ShowS
[ProjectConfigBuildOnly] -> ShowS
ProjectConfigBuildOnly -> String
(Int -> ProjectConfigBuildOnly -> ShowS)
-> (ProjectConfigBuildOnly -> String)
-> ([ProjectConfigBuildOnly] -> ShowS)
-> Show ProjectConfigBuildOnly
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectConfigBuildOnly] -> ShowS
$cshowList :: [ProjectConfigBuildOnly] -> ShowS
show :: ProjectConfigBuildOnly -> String
$cshow :: ProjectConfigBuildOnly -> String
showsPrec :: Int -> ProjectConfigBuildOnly -> ShowS
$cshowsPrec :: Int -> ProjectConfigBuildOnly -> ShowS
Show, (forall x. ProjectConfigBuildOnly -> Rep ProjectConfigBuildOnly x)
-> (forall x.
    Rep ProjectConfigBuildOnly x -> ProjectConfigBuildOnly)
-> Generic ProjectConfigBuildOnly
forall x. Rep ProjectConfigBuildOnly x -> ProjectConfigBuildOnly
forall x. ProjectConfigBuildOnly -> Rep ProjectConfigBuildOnly x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectConfigBuildOnly x -> ProjectConfigBuildOnly
$cfrom :: forall x. ProjectConfigBuildOnly -> Rep ProjectConfigBuildOnly x
Generic)


-- | Project configuration that is shared between all packages in the project.
-- In particular this includes configuration that affects the solver.
--
data ProjectConfigShared
   = ProjectConfigShared {
       ProjectConfigShared -> Flag String
projectConfigDistDir           :: Flag FilePath,
       ProjectConfigShared -> Flag String
projectConfigConfigFile        :: Flag FilePath,
       ProjectConfigShared -> Flag String
projectConfigProjectFile       :: Flag FilePath,
       ProjectConfigShared -> Flag Bool
projectConfigIgnoreProject     :: Flag Bool,
       ProjectConfigShared -> Flag CompilerFlavor
projectConfigHcFlavor          :: Flag CompilerFlavor,
       ProjectConfigShared -> Flag String
projectConfigHcPath            :: Flag FilePath,
       ProjectConfigShared -> Flag String
projectConfigHcPkg             :: Flag FilePath,
       ProjectConfigShared -> Flag PathTemplate
projectConfigHaddockIndex      :: Flag PathTemplate,

       -- Things that only make sense for manual mode, not --local mode
       -- too much control!
     --projectConfigUserInstall       :: Flag Bool,
     --projectConfigInstallDirs       :: InstallDirs (Flag PathTemplate),
     --TODO: [required eventually] decide what to do with InstallDirs
     -- currently we don't allow it to be specified in the config file
       ProjectConfigShared -> [Maybe PackageDB]
projectConfigPackageDBs        :: [Maybe PackageDB],

       -- configuration used both by the solver and other phases
       ProjectConfigShared -> NubList RemoteRepo
projectConfigRemoteRepos       :: NubList RemoteRepo,     -- ^ Available Hackage servers.
       ProjectConfigShared -> NubList LocalRepo
projectConfigLocalNoIndexRepos :: NubList LocalRepo,
       ProjectConfigShared -> Flag ActiveRepos
projectConfigActiveRepos       :: Flag ActiveRepos,
       ProjectConfigShared -> Flag TotalIndexState
projectConfigIndexState        :: Flag TotalIndexState,
       ProjectConfigShared -> Flag String
projectConfigStoreDir          :: Flag FilePath,

       -- solver configuration
       ProjectConfigShared -> [(UserConstraint, ConstraintSource)]
projectConfigConstraints       :: [(UserConstraint, ConstraintSource)],
       ProjectConfigShared -> [PackageVersionConstraint]
projectConfigPreferences       :: [PackageVersionConstraint],
       ProjectConfigShared -> Flag Version
projectConfigCabalVersion      :: Flag Version,  --TODO: [required eventually] unused
       ProjectConfigShared -> Flag PreSolver
projectConfigSolver            :: Flag PreSolver,
       ProjectConfigShared -> Maybe AllowOlder
projectConfigAllowOlder        :: Maybe AllowOlder,
       ProjectConfigShared -> Maybe AllowNewer
projectConfigAllowNewer        :: Maybe AllowNewer,
       ProjectConfigShared -> Flag WriteGhcEnvironmentFilesPolicy
projectConfigWriteGhcEnvironmentFilesPolicy
                                      :: Flag WriteGhcEnvironmentFilesPolicy,
       ProjectConfigShared -> Flag Int
projectConfigMaxBackjumps      :: Flag Int,
       ProjectConfigShared -> Flag ReorderGoals
projectConfigReorderGoals      :: Flag ReorderGoals,
       ProjectConfigShared -> Flag CountConflicts
projectConfigCountConflicts    :: Flag CountConflicts,
       ProjectConfigShared -> Flag FineGrainedConflicts
projectConfigFineGrainedConflicts :: Flag FineGrainedConflicts,
       ProjectConfigShared -> Flag MinimizeConflictSet
projectConfigMinimizeConflictSet :: Flag MinimizeConflictSet,
       ProjectConfigShared -> Flag StrongFlags
projectConfigStrongFlags       :: Flag StrongFlags,
       ProjectConfigShared -> Flag AllowBootLibInstalls
projectConfigAllowBootLibInstalls :: Flag AllowBootLibInstalls,
       ProjectConfigShared -> Flag OnlyConstrained
projectConfigOnlyConstrained   :: Flag OnlyConstrained,
       ProjectConfigShared -> Flag Bool
projectConfigPerComponent      :: Flag Bool,
       ProjectConfigShared -> Flag IndependentGoals
projectConfigIndependentGoals  :: Flag IndependentGoals,

       ProjectConfigShared -> NubList String
projectConfigProgPathExtra     :: NubList FilePath

       -- More things that only make sense for manual mode, not --local mode
       -- too much control!
     --projectConfigShadowPkgs        :: Flag Bool,
     --projectConfigReinstall         :: Flag Bool,
     --projectConfigAvoidReinstalls   :: Flag Bool,
     --projectConfigOverrideReinstall :: Flag Bool,
     --projectConfigUpgradeDeps       :: Flag Bool
     }
  deriving (ProjectConfigShared -> ProjectConfigShared -> Bool
(ProjectConfigShared -> ProjectConfigShared -> Bool)
-> (ProjectConfigShared -> ProjectConfigShared -> Bool)
-> Eq ProjectConfigShared
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectConfigShared -> ProjectConfigShared -> Bool
$c/= :: ProjectConfigShared -> ProjectConfigShared -> Bool
== :: ProjectConfigShared -> ProjectConfigShared -> Bool
$c== :: ProjectConfigShared -> ProjectConfigShared -> Bool
Eq, Int -> ProjectConfigShared -> ShowS
[ProjectConfigShared] -> ShowS
ProjectConfigShared -> String
(Int -> ProjectConfigShared -> ShowS)
-> (ProjectConfigShared -> String)
-> ([ProjectConfigShared] -> ShowS)
-> Show ProjectConfigShared
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectConfigShared] -> ShowS
$cshowList :: [ProjectConfigShared] -> ShowS
show :: ProjectConfigShared -> String
$cshow :: ProjectConfigShared -> String
showsPrec :: Int -> ProjectConfigShared -> ShowS
$cshowsPrec :: Int -> ProjectConfigShared -> ShowS
Show, (forall x. ProjectConfigShared -> Rep ProjectConfigShared x)
-> (forall x. Rep ProjectConfigShared x -> ProjectConfigShared)
-> Generic ProjectConfigShared
forall x. Rep ProjectConfigShared x -> ProjectConfigShared
forall x. ProjectConfigShared -> Rep ProjectConfigShared x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectConfigShared x -> ProjectConfigShared
$cfrom :: forall x. ProjectConfigShared -> Rep ProjectConfigShared x
Generic)


-- | Specifies the provenance of project configuration, whether defaults were
-- used or if the configuration was read from an explicit file path.
data ProjectConfigProvenance

     -- | The configuration is implicit due to no explicit configuration
     -- being found. See 'Distribution.Client.ProjectConfig.readProjectConfig'
     -- for how implicit configuration is determined.
   = Implicit

     -- | The path the project configuration was explicitly read from.
     -- | The configuration was explicitly read from the specified 'FilePath'.
   | Explicit FilePath
  deriving (ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
(ProjectConfigProvenance -> ProjectConfigProvenance -> Bool)
-> (ProjectConfigProvenance -> ProjectConfigProvenance -> Bool)
-> Eq ProjectConfigProvenance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
$c/= :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
== :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
$c== :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
Eq, Eq ProjectConfigProvenance
Eq ProjectConfigProvenance
-> (ProjectConfigProvenance -> ProjectConfigProvenance -> Ordering)
-> (ProjectConfigProvenance -> ProjectConfigProvenance -> Bool)
-> (ProjectConfigProvenance -> ProjectConfigProvenance -> Bool)
-> (ProjectConfigProvenance -> ProjectConfigProvenance -> Bool)
-> (ProjectConfigProvenance -> ProjectConfigProvenance -> Bool)
-> (ProjectConfigProvenance
    -> ProjectConfigProvenance -> ProjectConfigProvenance)
-> (ProjectConfigProvenance
    -> ProjectConfigProvenance -> ProjectConfigProvenance)
-> Ord ProjectConfigProvenance
ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
ProjectConfigProvenance -> ProjectConfigProvenance -> Ordering
ProjectConfigProvenance
-> ProjectConfigProvenance -> ProjectConfigProvenance
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 :: ProjectConfigProvenance
-> ProjectConfigProvenance -> ProjectConfigProvenance
$cmin :: ProjectConfigProvenance
-> ProjectConfigProvenance -> ProjectConfigProvenance
max :: ProjectConfigProvenance
-> ProjectConfigProvenance -> ProjectConfigProvenance
$cmax :: ProjectConfigProvenance
-> ProjectConfigProvenance -> ProjectConfigProvenance
>= :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
$c>= :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
> :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
$c> :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
<= :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
$c<= :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
< :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
$c< :: ProjectConfigProvenance -> ProjectConfigProvenance -> Bool
compare :: ProjectConfigProvenance -> ProjectConfigProvenance -> Ordering
$ccompare :: ProjectConfigProvenance -> ProjectConfigProvenance -> Ordering
$cp1Ord :: Eq ProjectConfigProvenance
Ord, Int -> ProjectConfigProvenance -> ShowS
[ProjectConfigProvenance] -> ShowS
ProjectConfigProvenance -> String
(Int -> ProjectConfigProvenance -> ShowS)
-> (ProjectConfigProvenance -> String)
-> ([ProjectConfigProvenance] -> ShowS)
-> Show ProjectConfigProvenance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectConfigProvenance] -> ShowS
$cshowList :: [ProjectConfigProvenance] -> ShowS
show :: ProjectConfigProvenance -> String
$cshow :: ProjectConfigProvenance -> String
showsPrec :: Int -> ProjectConfigProvenance -> ShowS
$cshowsPrec :: Int -> ProjectConfigProvenance -> ShowS
Show, (forall x.
 ProjectConfigProvenance -> Rep ProjectConfigProvenance x)
-> (forall x.
    Rep ProjectConfigProvenance x -> ProjectConfigProvenance)
-> Generic ProjectConfigProvenance
forall x. Rep ProjectConfigProvenance x -> ProjectConfigProvenance
forall x. ProjectConfigProvenance -> Rep ProjectConfigProvenance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectConfigProvenance x -> ProjectConfigProvenance
$cfrom :: forall x. ProjectConfigProvenance -> Rep ProjectConfigProvenance x
Generic)


-- | Project configuration that is specific to each package, that is where we
-- can in principle have different values for different packages in the same
-- project.
--
data PackageConfig
   = PackageConfig {
       PackageConfig -> MapLast String String
packageConfigProgramPaths        :: MapLast String FilePath,
       PackageConfig -> MapMappend String [String]
packageConfigProgramArgs         :: MapMappend String [String],
       PackageConfig -> NubList String
packageConfigProgramPathExtra    :: NubList FilePath,
       PackageConfig -> FlagAssignment
packageConfigFlagAssignment      :: FlagAssignment,
       PackageConfig -> Flag Bool
packageConfigVanillaLib          :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigSharedLib           :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigStaticLib           :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigDynExe              :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigFullyStaticExe      :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigProf                :: Flag Bool, --TODO: [code cleanup] sort out
       PackageConfig -> Flag Bool
packageConfigProfLib             :: Flag Bool, --      this duplication
       PackageConfig -> Flag Bool
packageConfigProfExe             :: Flag Bool, --      and consistency
       PackageConfig -> Flag ProfDetailLevel
packageConfigProfDetail          :: Flag ProfDetailLevel,
       PackageConfig -> Flag ProfDetailLevel
packageConfigProfLibDetail       :: Flag ProfDetailLevel,
       PackageConfig -> [String]
packageConfigConfigureArgs       :: [String],
       PackageConfig -> Flag OptimisationLevel
packageConfigOptimization        :: Flag OptimisationLevel,
       PackageConfig -> Flag PathTemplate
packageConfigProgPrefix          :: Flag PathTemplate,
       PackageConfig -> Flag PathTemplate
packageConfigProgSuffix          :: Flag PathTemplate,
       PackageConfig -> [String]
packageConfigExtraLibDirs        :: [FilePath],
       PackageConfig -> [String]
packageConfigExtraLibDirsStatic  :: [FilePath],
       PackageConfig -> [String]
packageConfigExtraFrameworkDirs  :: [FilePath],
       PackageConfig -> [String]
packageConfigExtraIncludeDirs    :: [FilePath],
       PackageConfig -> Flag Bool
packageConfigGHCiLib             :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigSplitSections       :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigSplitObjs           :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigStripExes           :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigStripLibs           :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigTests               :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigBenchmarks          :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigCoverage            :: Flag Bool,
       PackageConfig -> Flag Bool
packageConfigRelocatable         :: Flag Bool,
       PackageConfig -> Flag DebugInfoLevel
packageConfigDebugInfo           :: Flag DebugInfoLevel,
       PackageConfig -> Flag DumpBuildInfo
packageConfigDumpBuildInfo       :: Flag DumpBuildInfo,
       PackageConfig -> Flag Bool
packageConfigRunTests            :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigDocumentation       :: Flag Bool, --TODO: [required eventually] use this
       -- Haddock options
       PackageConfig -> Flag Bool
packageConfigHaddockHoogle       :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockHtml         :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag String
packageConfigHaddockHtmlLocation :: Flag String, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockForeignLibs  :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockExecutables  :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockTestSuites   :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockBenchmarks   :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockInternal     :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag String
packageConfigHaddockCss          :: Flag FilePath, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockLinkedSource :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag Bool
packageConfigHaddockQuickJump    :: Flag Bool, --TODO: [required eventually] use this
       PackageConfig -> Flag String
packageConfigHaddockHscolourCss  :: Flag FilePath, --TODO: [required eventually] use this
       PackageConfig -> Flag PathTemplate
packageConfigHaddockContents     :: Flag PathTemplate, --TODO: [required eventually] use this
       PackageConfig -> Flag HaddockTarget
packageConfigHaddockForHackage   :: Flag HaddockTarget,
       -- Test options
       PackageConfig -> Flag PathTemplate
packageConfigTestHumanLog        :: Flag PathTemplate,
       PackageConfig -> Flag PathTemplate
packageConfigTestMachineLog      :: Flag PathTemplate,
       PackageConfig -> Flag TestShowDetails
packageConfigTestShowDetails     :: Flag TestShowDetails,
       PackageConfig -> Flag Bool
packageConfigTestKeepTix         :: Flag Bool,
       PackageConfig -> Flag String
packageConfigTestWrapper         :: Flag FilePath,
       PackageConfig -> Flag Bool
packageConfigTestFailWhenNoTestSuites :: Flag Bool,
       PackageConfig -> [PathTemplate]
packageConfigTestTestOptions     :: [PathTemplate],
       -- Benchmark options
       PackageConfig -> [PathTemplate]
packageConfigBenchmarkOptions    :: [PathTemplate]
     }
  deriving (PackageConfig -> PackageConfig -> Bool
(PackageConfig -> PackageConfig -> Bool)
-> (PackageConfig -> PackageConfig -> Bool) -> Eq PackageConfig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageConfig -> PackageConfig -> Bool
$c/= :: PackageConfig -> PackageConfig -> Bool
== :: PackageConfig -> PackageConfig -> Bool
$c== :: PackageConfig -> PackageConfig -> Bool
Eq, Int -> PackageConfig -> ShowS
[PackageConfig] -> ShowS
PackageConfig -> String
(Int -> PackageConfig -> ShowS)
-> (PackageConfig -> String)
-> ([PackageConfig] -> ShowS)
-> Show PackageConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackageConfig] -> ShowS
$cshowList :: [PackageConfig] -> ShowS
show :: PackageConfig -> String
$cshow :: PackageConfig -> String
showsPrec :: Int -> PackageConfig -> ShowS
$cshowsPrec :: Int -> PackageConfig -> ShowS
Show, (forall x. PackageConfig -> Rep PackageConfig x)
-> (forall x. Rep PackageConfig x -> PackageConfig)
-> Generic PackageConfig
forall x. Rep PackageConfig x -> PackageConfig
forall x. PackageConfig -> Rep PackageConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PackageConfig x -> PackageConfig
$cfrom :: forall x. PackageConfig -> Rep PackageConfig x
Generic)

instance Binary ProjectConfig
instance Binary ProjectConfigBuildOnly
instance Binary ProjectConfigShared
instance Binary ProjectConfigProvenance
instance Binary PackageConfig

instance Structured ProjectConfig
instance Structured ProjectConfigBuildOnly
instance Structured ProjectConfigShared
instance Structured ProjectConfigProvenance
instance Structured PackageConfig

-- | Newtype wrapper for 'Map' that provides a 'Monoid' instance that takes
-- the last value rather than the first value for overlapping keys.
newtype MapLast k v = MapLast { MapLast k v -> Map k v
getMapLast :: Map k v }
  deriving (MapLast k v -> MapLast k v -> Bool
(MapLast k v -> MapLast k v -> Bool)
-> (MapLast k v -> MapLast k v -> Bool) -> Eq (MapLast k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v. (Eq k, Eq v) => MapLast k v -> MapLast k v -> Bool
/= :: MapLast k v -> MapLast k v -> Bool
$c/= :: forall k v. (Eq k, Eq v) => MapLast k v -> MapLast k v -> Bool
== :: MapLast k v -> MapLast k v -> Bool
$c== :: forall k v. (Eq k, Eq v) => MapLast k v -> MapLast k v -> Bool
Eq, Int -> MapLast k v -> ShowS
[MapLast k v] -> ShowS
MapLast k v -> String
(Int -> MapLast k v -> ShowS)
-> (MapLast k v -> String)
-> ([MapLast k v] -> ShowS)
-> Show (MapLast k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> MapLast k v -> ShowS
forall k v. (Show k, Show v) => [MapLast k v] -> ShowS
forall k v. (Show k, Show v) => MapLast k v -> String
showList :: [MapLast k v] -> ShowS
$cshowList :: forall k v. (Show k, Show v) => [MapLast k v] -> ShowS
show :: MapLast k v -> String
$cshow :: forall k v. (Show k, Show v) => MapLast k v -> String
showsPrec :: Int -> MapLast k v -> ShowS
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> MapLast k v -> ShowS
Show, a -> MapLast k b -> MapLast k a
(a -> b) -> MapLast k a -> MapLast k b
(forall a b. (a -> b) -> MapLast k a -> MapLast k b)
-> (forall a b. a -> MapLast k b -> MapLast k a)
-> Functor (MapLast k)
forall a b. a -> MapLast k b -> MapLast k a
forall a b. (a -> b) -> MapLast k a -> MapLast k b
forall k a b. a -> MapLast k b -> MapLast k a
forall k a b. (a -> b) -> MapLast k a -> MapLast k b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> MapLast k b -> MapLast k a
$c<$ :: forall k a b. a -> MapLast k b -> MapLast k a
fmap :: (a -> b) -> MapLast k a -> MapLast k b
$cfmap :: forall k a b. (a -> b) -> MapLast k a -> MapLast k b
Functor, (forall x. MapLast k v -> Rep (MapLast k v) x)
-> (forall x. Rep (MapLast k v) x -> MapLast k v)
-> Generic (MapLast k v)
forall x. Rep (MapLast k v) x -> MapLast k v
forall x. MapLast k v -> Rep (MapLast k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (MapLast k v) x -> MapLast k v
forall k v x. MapLast k v -> Rep (MapLast k v) x
$cto :: forall k v x. Rep (MapLast k v) x -> MapLast k v
$cfrom :: forall k v x. MapLast k v -> Rep (MapLast k v) x
Generic, Get (MapLast k v)
[MapLast k v] -> Put
MapLast k v -> Put
(MapLast k v -> Put)
-> Get (MapLast k v)
-> ([MapLast k v] -> Put)
-> Binary (MapLast k v)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall k v. (Binary k, Binary v) => Get (MapLast k v)
forall k v. (Binary k, Binary v) => [MapLast k v] -> Put
forall k v. (Binary k, Binary v) => MapLast k v -> Put
putList :: [MapLast k v] -> Put
$cputList :: forall k v. (Binary k, Binary v) => [MapLast k v] -> Put
get :: Get (MapLast k v)
$cget :: forall k v. (Binary k, Binary v) => Get (MapLast k v)
put :: MapLast k v -> Put
$cput :: forall k v. (Binary k, Binary v) => MapLast k v -> Put
Binary, Typeable)

instance (Structured k, Structured v) => Structured (MapLast k v)

instance Ord k => Monoid (MapLast k v) where
  mempty :: MapLast k v
mempty  = Map k v -> MapLast k v
forall k v. Map k v -> MapLast k v
MapLast Map k v
forall k a. Map k a
Map.empty
  mappend :: MapLast k v -> MapLast k v -> MapLast k v
mappend = MapLast k v -> MapLast k v -> MapLast k v
forall a. Semigroup a => a -> a -> a
(<>)

instance Ord k => Semigroup (MapLast k v) where
  MapLast Map k v
a <> :: MapLast k v -> MapLast k v -> MapLast k v
<> MapLast Map k v
b = Map k v -> MapLast k v
forall k v. Map k v -> MapLast k v
MapLast (Map k v -> MapLast k v) -> Map k v -> MapLast k v
forall a b. (a -> b) -> a -> b
$ Map k v -> Map k v -> Map k v
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map k v
b Map k v
a
  -- rather than Map.union which is the normal Map monoid instance


-- | Newtype wrapper for 'Map' that provides a 'Monoid' instance that
-- 'mappend's values of overlapping keys rather than taking the first.
newtype MapMappend k v = MapMappend { MapMappend k v -> Map k v
getMapMappend :: Map k v }
  deriving (MapMappend k v -> MapMappend k v -> Bool
(MapMappend k v -> MapMappend k v -> Bool)
-> (MapMappend k v -> MapMappend k v -> Bool)
-> Eq (MapMappend k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v.
(Eq k, Eq v) =>
MapMappend k v -> MapMappend k v -> Bool
/= :: MapMappend k v -> MapMappend k v -> Bool
$c/= :: forall k v.
(Eq k, Eq v) =>
MapMappend k v -> MapMappend k v -> Bool
== :: MapMappend k v -> MapMappend k v -> Bool
$c== :: forall k v.
(Eq k, Eq v) =>
MapMappend k v -> MapMappend k v -> Bool
Eq, Int -> MapMappend k v -> ShowS
[MapMappend k v] -> ShowS
MapMappend k v -> String
(Int -> MapMappend k v -> ShowS)
-> (MapMappend k v -> String)
-> ([MapMappend k v] -> ShowS)
-> Show (MapMappend k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> MapMappend k v -> ShowS
forall k v. (Show k, Show v) => [MapMappend k v] -> ShowS
forall k v. (Show k, Show v) => MapMappend k v -> String
showList :: [MapMappend k v] -> ShowS
$cshowList :: forall k v. (Show k, Show v) => [MapMappend k v] -> ShowS
show :: MapMappend k v -> String
$cshow :: forall k v. (Show k, Show v) => MapMappend k v -> String
showsPrec :: Int -> MapMappend k v -> ShowS
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> MapMappend k v -> ShowS
Show, a -> MapMappend k b -> MapMappend k a
(a -> b) -> MapMappend k a -> MapMappend k b
(forall a b. (a -> b) -> MapMappend k a -> MapMappend k b)
-> (forall a b. a -> MapMappend k b -> MapMappend k a)
-> Functor (MapMappend k)
forall a b. a -> MapMappend k b -> MapMappend k a
forall a b. (a -> b) -> MapMappend k a -> MapMappend k b
forall k a b. a -> MapMappend k b -> MapMappend k a
forall k a b. (a -> b) -> MapMappend k a -> MapMappend k b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> MapMappend k b -> MapMappend k a
$c<$ :: forall k a b. a -> MapMappend k b -> MapMappend k a
fmap :: (a -> b) -> MapMappend k a -> MapMappend k b
$cfmap :: forall k a b. (a -> b) -> MapMappend k a -> MapMappend k b
Functor, (forall x. MapMappend k v -> Rep (MapMappend k v) x)
-> (forall x. Rep (MapMappend k v) x -> MapMappend k v)
-> Generic (MapMappend k v)
forall x. Rep (MapMappend k v) x -> MapMappend k v
forall x. MapMappend k v -> Rep (MapMappend k v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k v x. Rep (MapMappend k v) x -> MapMappend k v
forall k v x. MapMappend k v -> Rep (MapMappend k v) x
$cto :: forall k v x. Rep (MapMappend k v) x -> MapMappend k v
$cfrom :: forall k v x. MapMappend k v -> Rep (MapMappend k v) x
Generic, Get (MapMappend k v)
[MapMappend k v] -> Put
MapMappend k v -> Put
(MapMappend k v -> Put)
-> Get (MapMappend k v)
-> ([MapMappend k v] -> Put)
-> Binary (MapMappend k v)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall k v. (Binary k, Binary v) => Get (MapMappend k v)
forall k v. (Binary k, Binary v) => [MapMappend k v] -> Put
forall k v. (Binary k, Binary v) => MapMappend k v -> Put
putList :: [MapMappend k v] -> Put
$cputList :: forall k v. (Binary k, Binary v) => [MapMappend k v] -> Put
get :: Get (MapMappend k v)
$cget :: forall k v. (Binary k, Binary v) => Get (MapMappend k v)
put :: MapMappend k v -> Put
$cput :: forall k v. (Binary k, Binary v) => MapMappend k v -> Put
Binary, Typeable)

instance (Structured k, Structured v) => Structured (MapMappend k v)

instance (Semigroup v, Ord k) => Monoid (MapMappend k v) where
  mempty :: MapMappend k v
mempty  = Map k v -> MapMappend k v
forall k v. Map k v -> MapMappend k v
MapMappend Map k v
forall k a. Map k a
Map.empty
  mappend :: MapMappend k v -> MapMappend k v -> MapMappend k v
mappend = MapMappend k v -> MapMappend k v -> MapMappend k v
forall a. Semigroup a => a -> a -> a
(<>)

instance (Semigroup v, Ord k) => Semigroup (MapMappend k v) where
  MapMappend Map k v
a <> :: MapMappend k v -> MapMappend k v -> MapMappend k v
<> MapMappend Map k v
b = Map k v -> MapMappend k v
forall k v. Map k v -> MapMappend k v
MapMappend ((v -> v -> v) -> Map k v -> Map k v -> Map k v
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith v -> v -> v
forall a. Semigroup a => a -> a -> a
(<>) Map k v
a Map k v
b)
  -- rather than Map.union which is the normal Map monoid instance


instance Monoid ProjectConfig where
  mempty :: ProjectConfig
mempty = ProjectConfig
forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: ProjectConfig -> ProjectConfig -> ProjectConfig
mappend = ProjectConfig -> ProjectConfig -> ProjectConfig
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ProjectConfig where
  <> :: ProjectConfig -> ProjectConfig -> ProjectConfig
(<>) = ProjectConfig -> ProjectConfig -> ProjectConfig
forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend


instance Monoid ProjectConfigBuildOnly where
  mempty :: ProjectConfigBuildOnly
mempty = ProjectConfigBuildOnly
forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: ProjectConfigBuildOnly
-> ProjectConfigBuildOnly -> ProjectConfigBuildOnly
mappend = ProjectConfigBuildOnly
-> ProjectConfigBuildOnly -> ProjectConfigBuildOnly
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ProjectConfigBuildOnly where
  <> :: ProjectConfigBuildOnly
-> ProjectConfigBuildOnly -> ProjectConfigBuildOnly
(<>) = ProjectConfigBuildOnly
-> ProjectConfigBuildOnly -> ProjectConfigBuildOnly
forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend


instance Monoid ProjectConfigShared where
  mempty :: ProjectConfigShared
mempty = ProjectConfigShared
forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: ProjectConfigShared -> ProjectConfigShared -> ProjectConfigShared
mappend = ProjectConfigShared -> ProjectConfigShared -> ProjectConfigShared
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ProjectConfigShared where
  <> :: ProjectConfigShared -> ProjectConfigShared -> ProjectConfigShared
(<>) = ProjectConfigShared -> ProjectConfigShared -> ProjectConfigShared
forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend


instance Monoid PackageConfig where
  mempty :: PackageConfig
mempty = PackageConfig
forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: PackageConfig -> PackageConfig -> PackageConfig
mappend = PackageConfig -> PackageConfig -> PackageConfig
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup PackageConfig where
  <> :: PackageConfig -> PackageConfig -> PackageConfig
(<>) = PackageConfig -> PackageConfig -> PackageConfig
forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

----------------------------------------
-- Resolving configuration to settings
--

-- | Resolved configuration for the solver. The idea is that this is easier to
-- use than the raw configuration because in the raw configuration everything
-- is optional (monoidial). In the 'BuildTimeSettings' every field is filled
-- in, if only with the defaults.
--
-- Use 'resolveSolverSettings' to make one from the project config (by
-- applying defaults etc).
--
data SolverSettings
   = SolverSettings {
       SolverSettings -> [RemoteRepo]
solverSettingRemoteRepos       :: [RemoteRepo],     -- ^ Available Hackage servers.
       SolverSettings -> [LocalRepo]
solverSettingLocalNoIndexRepos :: [LocalRepo],
       SolverSettings -> [(UserConstraint, ConstraintSource)]
solverSettingConstraints       :: [(UserConstraint, ConstraintSource)],
       SolverSettings -> [PackageVersionConstraint]
solverSettingPreferences       :: [PackageVersionConstraint],
       SolverSettings -> FlagAssignment
solverSettingFlagAssignment    :: FlagAssignment, -- ^ For all local packages
       SolverSettings -> Map PackageName FlagAssignment
solverSettingFlagAssignments   :: Map PackageName FlagAssignment,
       SolverSettings -> Maybe Version
solverSettingCabalVersion      :: Maybe Version,  --TODO: [required eventually] unused
       SolverSettings -> PreSolver
solverSettingSolver            :: PreSolver,
       SolverSettings -> AllowOlder
solverSettingAllowOlder        :: AllowOlder,
       SolverSettings -> AllowNewer
solverSettingAllowNewer        :: AllowNewer,
       SolverSettings -> Maybe Int
solverSettingMaxBackjumps      :: Maybe Int,
       SolverSettings -> ReorderGoals
solverSettingReorderGoals      :: ReorderGoals,
       SolverSettings -> CountConflicts
solverSettingCountConflicts    :: CountConflicts,
       SolverSettings -> FineGrainedConflicts
solverSettingFineGrainedConflicts :: FineGrainedConflicts,
       SolverSettings -> MinimizeConflictSet
solverSettingMinimizeConflictSet :: MinimizeConflictSet,
       SolverSettings -> StrongFlags
solverSettingStrongFlags       :: StrongFlags,
       SolverSettings -> AllowBootLibInstalls
solverSettingAllowBootLibInstalls :: AllowBootLibInstalls,
       SolverSettings -> OnlyConstrained
solverSettingOnlyConstrained   :: OnlyConstrained,
       SolverSettings -> Maybe TotalIndexState
solverSettingIndexState        :: Maybe TotalIndexState,
       SolverSettings -> Maybe ActiveRepos
solverSettingActiveRepos       :: Maybe ActiveRepos,
       SolverSettings -> IndependentGoals
solverSettingIndependentGoals  :: IndependentGoals
       -- Things that only make sense for manual mode, not --local mode
       -- too much control!
     --solverSettingShadowPkgs        :: Bool,
     --solverSettingReinstall         :: Bool,
     --solverSettingAvoidReinstalls   :: Bool,
     --solverSettingOverrideReinstall :: Bool,
     --solverSettingUpgradeDeps       :: Bool
     }
  deriving (SolverSettings -> SolverSettings -> Bool
(SolverSettings -> SolverSettings -> Bool)
-> (SolverSettings -> SolverSettings -> Bool) -> Eq SolverSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SolverSettings -> SolverSettings -> Bool
$c/= :: SolverSettings -> SolverSettings -> Bool
== :: SolverSettings -> SolverSettings -> Bool
$c== :: SolverSettings -> SolverSettings -> Bool
Eq, Int -> SolverSettings -> ShowS
[SolverSettings] -> ShowS
SolverSettings -> String
(Int -> SolverSettings -> ShowS)
-> (SolverSettings -> String)
-> ([SolverSettings] -> ShowS)
-> Show SolverSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SolverSettings] -> ShowS
$cshowList :: [SolverSettings] -> ShowS
show :: SolverSettings -> String
$cshow :: SolverSettings -> String
showsPrec :: Int -> SolverSettings -> ShowS
$cshowsPrec :: Int -> SolverSettings -> ShowS
Show, (forall x. SolverSettings -> Rep SolverSettings x)
-> (forall x. Rep SolverSettings x -> SolverSettings)
-> Generic SolverSettings
forall x. Rep SolverSettings x -> SolverSettings
forall x. SolverSettings -> Rep SolverSettings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SolverSettings x -> SolverSettings
$cfrom :: forall x. SolverSettings -> Rep SolverSettings x
Generic, Typeable)

instance Binary SolverSettings
instance Structured SolverSettings


-- | Resolved configuration for things that affect how we build and not the
-- value of the things we build. The idea is that this is easier to use than
-- the raw configuration because in the raw configuration everything is
-- optional (monoidial). In the 'BuildTimeSettings' every field is filled in,
-- if only with the defaults.
--
-- Use 'resolveBuildTimeSettings' to make one from the project config (by
-- applying defaults etc).
--
data BuildTimeSettings
   = BuildTimeSettings {
       BuildTimeSettings -> Bool
buildSettingDryRun                :: Bool,
       BuildTimeSettings -> Bool
buildSettingOnlyDeps              :: Bool,
       BuildTimeSettings -> Bool
buildSettingOnlyDownload          :: Bool,
       BuildTimeSettings -> [PathTemplate]
buildSettingSummaryFile           :: [PathTemplate],
       BuildTimeSettings
-> Maybe (Compiler -> Platform -> PackageId -> UnitId -> String)
buildSettingLogFile               :: Maybe (Compiler  -> Platform
                                                -> PackageId -> UnitId
                                                             -> FilePath),
       BuildTimeSettings -> Verbosity
buildSettingLogVerbosity          :: Verbosity,
       BuildTimeSettings -> ReportLevel
buildSettingBuildReports          :: ReportLevel,
       BuildTimeSettings -> Bool
buildSettingReportPlanningFailure :: Bool,
       BuildTimeSettings -> [String]
buildSettingSymlinkBinDir         :: [FilePath],
       BuildTimeSettings -> Int
buildSettingNumJobs               :: Int,
       BuildTimeSettings -> Bool
buildSettingKeepGoing             :: Bool,
       BuildTimeSettings -> Bool
buildSettingOfflineMode           :: Bool,
       BuildTimeSettings -> Bool
buildSettingKeepTempFiles         :: Bool,
       BuildTimeSettings -> [RemoteRepo]
buildSettingRemoteRepos           :: [RemoteRepo],
       BuildTimeSettings -> [LocalRepo]
buildSettingLocalNoIndexRepos     :: [LocalRepo],
       BuildTimeSettings -> String
buildSettingCacheDir              :: FilePath,
       BuildTimeSettings -> Maybe String
buildSettingHttpTransport         :: Maybe String,
       BuildTimeSettings -> Bool
buildSettingIgnoreExpiry          :: Bool,
       BuildTimeSettings -> [String]
buildSettingProgPathExtra         :: [FilePath],
       BuildTimeSettings -> Bool
buildSettingHaddockOpen           :: Bool
     }