{-# LANGUAGE RecordWildCards, NamedFieldPuns, DeriveGeneric, ConstraintKinds, FlexibleInstances #-}

-- | Project configuration, implementation in terms of legacy types.
--
module Distribution.Client.ProjectConfig.Legacy (

   -- Project config skeletons
    ProjectConfigSkeleton,
    parseProjectSkeleton,
    instantiateProjectConfigSkeletonFetchingCompiler,
    instantiateProjectConfigSkeletonWithCompiler,
    singletonProjectConfigSkeleton,
    projectSkeletonImports,

    -- * Project config in terms of legacy types
    LegacyProjectConfig,
    parseLegacyProjectConfig,
    showLegacyProjectConfig,

    -- * Conversion to and from legacy config types
    commandLineFlagsToProjectConfig,
    convertLegacyProjectConfig,
    convertLegacyGlobalConfig,
    convertToLegacyProjectConfig,

    -- * Internals, just for tests
    parsePackageLocationTokenQ,
    renderPackageLocationToken
  ) where

import Distribution.Client.Compat.Prelude

import Distribution.Types.Flag (parsecFlagAssignment, FlagName)

import Distribution.Client.ProjectConfig.Types
import Distribution.Client.Types.RepoName (RepoName (..), unRepoName)
import Distribution.Client.Types.Repo (RemoteRepo(..), LocalRepo (..), emptyRemoteRepo)
import Distribution.Client.Types.AllowNewer (AllowNewer(..), AllowOlder(..))
import Distribution.Client.Types.SourceRepo (sourceRepositoryPackageGrammar, SourceRepoList)

import Distribution.Client.Config
         ( SavedConfig(..), remoteRepoFields, postProcessRepo )

import Distribution.Client.CmdInstall.ClientInstallFlags
         ( ClientInstallFlags(..), defaultClientInstallFlags
         , clientInstallOptions )

import Distribution.Compat.Lens (view, toListOf)

import Distribution.Solver.Types.ConstraintSource

import Distribution.FieldGrammar
import Distribution.Package
import Distribution.Types.SourceRepo (RepoType)
import Distribution.Types.CondTree
         ( CondTree (..), CondBranch (..), mapTreeConds, traverseCondTreeC, traverseCondTreeV, ignoreConditions )
import Distribution.PackageDescription
         ( dispFlagAssignment, Condition (..), ConfVar (..), FlagAssignment )
import Distribution.PackageDescription.Configuration (simplifyWithSysParams)
import Distribution.Simple.Compiler
         ( OptimisationLevel(..), DebugInfoLevel(..), CompilerInfo(..) )
import Distribution.Simple.InstallDirs ( CopyDest (NoCopyDest) )
import Distribution.Simple.Setup
         ( Flag(..), toFlag, fromFlagOrDefault
         , ConfigFlags(..), configureOptions
         , HaddockFlags(..), haddockOptions, defaultHaddockFlags
         , TestFlags(..), testOptions', defaultTestFlags
         , BenchmarkFlags(..), benchmarkOptions', defaultBenchmarkFlags
         , programDbPaths', splitArgs, DumpBuildInfo (NoDumpBuildInfo, DumpBuildInfo)
         , readPackageDb, showPackageDb, installDirsOptions
         )
import Distribution.Client.NixStyleOptions (NixStyleFlags (..))
import Distribution.Client.ProjectFlags (ProjectFlags (..), projectFlagsOptions, defaultProjectFlags)
import Distribution.Client.Setup
         ( GlobalFlags(..), globalCommand
         , ConfigExFlags(..), configureExOptions, defaultConfigExFlags
         , InstallFlags(..), installOptions, defaultInstallFlags )
import Distribution.Simple.Program
         ( programName, knownPrograms )
import Distribution.Simple.Program.Db
         ( ProgramDb, defaultProgramDb )
import Distribution.Simple.Utils
         ( lowercase )
import Distribution.Utils.NubList
         ( toNubList, fromNubList, overNubList )
import Distribution.Simple.LocalBuildInfo
         ( toPathTemplate, fromPathTemplate )

import qualified Distribution.Deprecated.ReadP as Parse
import Distribution.Deprecated.ReadP
         ( ReadP, (+++) )
import qualified Text.PrettyPrint as Disp
import Text.PrettyPrint
         ( Doc, ($+$) )
import qualified Distribution.Deprecated.ParseUtils as ParseUtils
import Distribution.Deprecated.ParseUtils
         ( ParseResult(..), PError(..), syntaxError, PWarning(..)
         , commaNewLineListFieldParsec, newLineListField, parseTokenQ
         , parseHaskellString, showToken
         , simpleFieldParsec, parseFail
         )
import Distribution.Client.ParseUtils
import Distribution.Simple.Command
         ( CommandUI(commandOptions), ShowOrParseArgs(..)
         , OptionField(..), option, reqArg' )
import Distribution.Types.PackageVersionConstraint
         ( PackageVersionConstraint )
import Distribution.Parsec (ParsecParser, parsecToken)
import Distribution.System (OS, Arch)

import qualified Data.Map as Map
import qualified Data.Set as Set
import qualified Data.ByteString.Char8 as BS

import Network.URI (URI (..), parseURI)

import Distribution.Fields.ConfVar (parseConditionConfVarFromClause)

import Distribution.Client.HttpUtils
import System.FilePath ((</>), isPathSeparator, makeValid, isAbsolute, takeDirectory)
import System.Directory (createDirectoryIfMissing)




------------------------------------------------------------------
-- Handle extended project config files with conditionals and imports.
--

-- | ProjectConfigSkeleton is a tree of conditional blocks and imports wrapping a config. It can be finalized by providing the conditional resolution info
-- and then resolving and downloading the imports
type ProjectConfigSkeleton = CondTree ConfVar [ProjectConfigImport] ProjectConfig
type ProjectConfigImport = String


singletonProjectConfigSkeleton :: ProjectConfig -> ProjectConfigSkeleton
singletonProjectConfigSkeleton :: ProjectConfig -> ProjectConfigSkeleton
singletonProjectConfigSkeleton ProjectConfig
x = forall v c a. a -> c -> [CondBranch v c a] -> CondTree v c a
CondNode ProjectConfig
x forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty

instantiateProjectConfigSkeletonFetchingCompiler :: Monad m =>  m (OS, Arch, CompilerInfo) -> FlagAssignment -> ProjectConfigSkeleton -> m ProjectConfig
instantiateProjectConfigSkeletonFetchingCompiler :: forall (m :: * -> *).
Monad m =>
m (OS, Arch, CompilerInfo)
-> FlagAssignment -> ProjectConfigSkeleton -> m ProjectConfig
instantiateProjectConfigSkeletonFetchingCompiler m (OS, Arch, CompilerInfo)
fetch FlagAssignment
flags ProjectConfigSkeleton
skel
   | forall (t :: * -> *) a. Foldable t => t a -> Bool
null (forall a s. Getting (DList a) s a -> s -> [a]
toListOf forall v c a w. Traversal (CondTree v c a) (CondTree w c a) v w
traverseCondTreeV ProjectConfigSkeleton
skel) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> a
fst (forall a c v.
(Semigroup a, Semigroup c) =>
CondTree v c a -> (a, c)
ignoreConditions ProjectConfigSkeleton
skel)
   | Bool
otherwise = do
       (OS
os, Arch
arch, CompilerInfo
impl) <- m (OS, Arch, CompilerInfo)
fetch
       forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ OS
-> Arch
-> CompilerInfo
-> FlagAssignment
-> ProjectConfigSkeleton
-> ProjectConfig
instantiateProjectConfigSkeletonWithCompiler OS
os Arch
arch CompilerInfo
impl FlagAssignment
flags ProjectConfigSkeleton
skel


instantiateProjectConfigSkeletonWithCompiler :: OS -> Arch -> CompilerInfo -> FlagAssignment -> ProjectConfigSkeleton -> ProjectConfig
instantiateProjectConfigSkeletonWithCompiler :: OS
-> Arch
-> CompilerInfo
-> FlagAssignment
-> ProjectConfigSkeleton
-> ProjectConfig
instantiateProjectConfigSkeletonWithCompiler OS
os Arch
arch CompilerInfo
impl FlagAssignment
_flags ProjectConfigSkeleton
skel = CondTree FlagName [String] ProjectConfig -> ProjectConfig
go forall a b. (a -> b) -> a -> b
$ forall v w c a.
(Condition v -> Condition w) -> CondTree v c a -> CondTree w c a
mapTreeConds (forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. OS
-> Arch
-> CompilerInfo
-> Condition ConfVar
-> (Condition FlagName, [FlagName])
simplifyWithSysParams OS
os Arch
arch CompilerInfo
impl) ProjectConfigSkeleton
skel
    where
        go :: CondTree
               FlagName
               [ProjectConfigImport]
               ProjectConfig
             -> ProjectConfig
        go :: CondTree FlagName [String] ProjectConfig -> ProjectConfig
go (CondNode ProjectConfig
l [String]
_imps [CondBranch FlagName [String] ProjectConfig]
ts) =
           let branches :: [ProjectConfig]
branches = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CondBranch FlagName [String] ProjectConfig -> [ProjectConfig]
processBranch [CondBranch FlagName [String] ProjectConfig]
ts
           in ProjectConfig
l forall a. Semigroup a => a -> a -> a
<> forall a. Monoid a => [a] -> a
mconcat [ProjectConfig]
branches
        processBranch :: CondBranch FlagName [String] ProjectConfig -> [ProjectConfig]
processBranch (CondBranch Condition FlagName
cnd CondTree FlagName [String] ProjectConfig
t Maybe (CondTree FlagName [String] ProjectConfig)
mf) = case Condition FlagName
cnd of
           (Lit Bool
True) ->  [CondTree FlagName [String] ProjectConfig -> ProjectConfig
go CondTree FlagName [String] ProjectConfig
t]
           (Lit Bool
False) -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([]) ((forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. CondTree FlagName [String] ProjectConfig -> ProjectConfig
go) Maybe (CondTree FlagName [String] ProjectConfig)
mf
           Condition FlagName
_ -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"unable to process condition: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Condition FlagName
cnd -- TODO it would be nice if there were a pretty printer

projectSkeletonImports :: ProjectConfigSkeleton -> [ProjectConfigImport]
projectSkeletonImports :: ProjectConfigSkeleton -> [String]
projectSkeletonImports = forall a s. Getting a s a -> s -> a
view forall v c a d. Traversal (CondTree v c a) (CondTree v d a) c d
traverseCondTreeC

parseProjectSkeleton :: FilePath -> HttpTransport -> Verbosity -> [ProjectConfigImport] -> FilePath -> BS.ByteString -> IO (ParseResult ProjectConfigSkeleton)
parseProjectSkeleton :: String
-> HttpTransport
-> Verbosity
-> [String]
-> String
-> ByteString
-> IO (ParseResult ProjectConfigSkeleton)
parseProjectSkeleton String
cacheDir HttpTransport
httpTransport Verbosity
verbosity [String]
seenImports String
source ByteString
bs = (Bool -> ProjectConfigSkeleton -> ParseResult ProjectConfigSkeleton
sanityWalkPCS Bool
False forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(a -> IO (ParseResult b)) -> ParseResult a -> IO (ParseResult b)
liftPR ([Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go []) (ByteString -> ParseResult [Field]
ParseUtils.readFields ByteString
bs)
  where
    go :: [ParseUtils.Field] -> [ParseUtils.Field] -> IO (ParseResult ProjectConfigSkeleton)
    go :: [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go [Field]
acc (Field
x:[Field]
xs) = case Field
x of
         (ParseUtils.F Int
l String
"import" String
importLoc) ->
            if String
importLoc forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String]
seenImports
              then forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. PError -> ParseResult a
parseFail forall a b. (a -> b) -> a -> b
$ String -> Maybe Int -> PError
ParseUtils.FromString (String
"cyclical import of " forall a. [a] -> [a] -> [a]
++ String
importLoc) (forall a. a -> Maybe a
Just Int
l)
              else do
                let fs :: ParseResult (CondTree v [String] ProjectConfig)
fs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\ProjectConfig
z -> forall v c a. a -> c -> [CondBranch v c a] -> CondTree v c a
CondNode ProjectConfig
z [String
importLoc] forall a. Monoid a => a
mempty) forall a b. (a -> b) -> a -> b
$ [Field] -> ParseResult ProjectConfig
fieldsToConfig (forall a. [a] -> [a]
reverse [Field]
acc)
                ParseResult ProjectConfigSkeleton
res <- String
-> HttpTransport
-> Verbosity
-> [String]
-> String
-> ByteString
-> IO (ParseResult ProjectConfigSkeleton)
parseProjectSkeleton String
cacheDir HttpTransport
httpTransport Verbosity
verbosity (String
importLoc forall a. a -> [a] -> [a]
: [String]
seenImports) String
importLoc forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> IO ByteString
fetchImportConfig String
importLoc
                ParseResult ProjectConfigSkeleton
rest <- [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go [] [Field]
xs
                forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence forall a b. (a -> b) -> a -> b
$ [forall {v}. ParseResult (CondTree v [String] ProjectConfig)
fs, ParseResult ProjectConfigSkeleton
res, ParseResult ProjectConfigSkeleton
rest]
         (ParseUtils.Section Int
l String
"if" String
p [Field]
xs') -> do
                ParseResult ProjectConfigSkeleton
subpcs <- [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go [] [Field]
xs'
                let fs :: ParseResult ProjectConfigSkeleton
fs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ProjectConfig -> ProjectConfigSkeleton
singletonProjectConfigSkeleton forall a b. (a -> b) -> a -> b
$ [Field] -> ParseResult ProjectConfig
fieldsToConfig (forall a. [a] -> [a]
reverse [Field]
acc)
                (ParseResult (Maybe ProjectConfigSkeleton)
elseClauses, ParseResult ProjectConfigSkeleton
rest) <- [Field]
-> IO
     (ParseResult (Maybe ProjectConfigSkeleton),
      ParseResult ProjectConfigSkeleton)
parseElseClauses [Field]
xs
                let condNode :: ParseResult ProjectConfigSkeleton
condNode =  (\Condition ConfVar
c ProjectConfigSkeleton
pcs Maybe ProjectConfigSkeleton
e -> forall v c a. a -> c -> [CondBranch v c a] -> CondTree v c a
CondNode forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty [forall v c a.
Condition v
-> CondTree v c a -> Maybe (CondTree v c a) -> CondBranch v c a
CondBranch Condition ConfVar
c ProjectConfigSkeleton
pcs Maybe ProjectConfigSkeleton
e]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                      -- we rewrap as as a section so the readFields lexer of the conditional parser doesn't get confused
                      forall {a} {a}. Show a => Int -> Either a a -> ParseResult a
adaptParseError Int
l (ByteString -> Either ParseError (Condition ConfVar)
parseConditionConfVarFromClause forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BS.pack forall a b. (a -> b) -> a -> b
$ String
"if(" forall a. Semigroup a => a -> a -> a
<> String
p forall a. Semigroup a => a -> a -> a
<> String
")") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                      ParseResult ProjectConfigSkeleton
subpcs forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                      ParseResult (Maybe ProjectConfigSkeleton)
elseClauses
                forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence forall a b. (a -> b) -> a -> b
$ [ParseResult ProjectConfigSkeleton
fs, ParseResult ProjectConfigSkeleton
condNode, ParseResult ProjectConfigSkeleton
rest]
         Field
_ -> [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go (Field
xforall a. a -> [a] -> [a]
:[Field]
acc) [Field]
xs
    go [Field]
acc [] = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ProjectConfig -> ProjectConfigSkeleton
singletonProjectConfigSkeleton forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Field] -> ParseResult ProjectConfig
fieldsToConfig forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
reverse [Field]
acc

    parseElseClauses :: [ParseUtils.Field] -> IO (ParseResult (Maybe ProjectConfigSkeleton), ParseResult ProjectConfigSkeleton)
    parseElseClauses :: [Field]
-> IO
     (ParseResult (Maybe ProjectConfigSkeleton),
      ParseResult ProjectConfigSkeleton)
parseElseClauses [Field]
x = case [Field]
x of
         (ParseUtils.Section Int
_l String
"else" String
_p [Field]
xs':[Field]
xs) -> do
               ParseResult ProjectConfigSkeleton
subpcs <- [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go [] [Field]
xs'
               ParseResult ProjectConfigSkeleton
rest <- [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go [] [Field]
xs
               forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParseResult ProjectConfigSkeleton
subpcs, ParseResult ProjectConfigSkeleton
rest)
         (ParseUtils.Section Int
l String
"elif" String
p [Field]
xs':[Field]
xs) -> do
               ParseResult ProjectConfigSkeleton
subpcs <- [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go [] [Field]
xs'
               (ParseResult (Maybe ProjectConfigSkeleton)
elseClauses, ParseResult ProjectConfigSkeleton
rest) <- [Field]
-> IO
     (ParseResult (Maybe ProjectConfigSkeleton),
      ParseResult ProjectConfigSkeleton)
parseElseClauses [Field]
xs
               let condNode :: ParseResult ProjectConfigSkeleton
condNode = (\Condition ConfVar
c ProjectConfigSkeleton
pcs Maybe ProjectConfigSkeleton
e -> forall v c a. a -> c -> [CondBranch v c a] -> CondTree v c a
CondNode forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty [forall v c a.
Condition v
-> CondTree v c a -> Maybe (CondTree v c a) -> CondBranch v c a
CondBranch Condition ConfVar
c ProjectConfigSkeleton
pcs Maybe ProjectConfigSkeleton
e]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                  forall {a} {a}. Show a => Int -> Either a a -> ParseResult a
adaptParseError Int
l (ByteString -> Either ParseError (Condition ConfVar)
parseConditionConfVarFromClause forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BS.pack forall a b. (a -> b) -> a -> b
$ String
"else("forall a. Semigroup a => a -> a -> a
<> String
p forall a. Semigroup a => a -> a -> a
<> String
")") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  ParseResult ProjectConfigSkeleton
subpcs forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  ParseResult (Maybe ProjectConfigSkeleton)
elseClauses
               forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParseResult ProjectConfigSkeleton
condNode, ParseResult ProjectConfigSkeleton
rest)
         [Field]
_ -> (\ParseResult ProjectConfigSkeleton
r -> (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing,ParseResult ProjectConfigSkeleton
r)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Field] -> [Field] -> IO (ParseResult ProjectConfigSkeleton)
go [] [Field]
x

    fieldsToConfig :: [Field] -> ParseResult ProjectConfig
fieldsToConfig [Field]
xs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ProjectConfig -> ProjectConfig
addProvenance forall b c a. (b -> c) -> (a -> b) -> a -> c
. LegacyProjectConfig -> ProjectConfig
convertLegacyProjectConfig) forall a b. (a -> b) -> a -> b
$ String -> [Field] -> ParseResult LegacyProjectConfig
parseLegacyProjectConfigFields String
source [Field]
xs
    addProvenance :: ProjectConfig -> ProjectConfig
addProvenance ProjectConfig
x = ProjectConfig
x {projectConfigProvenance :: Set ProjectConfigProvenance
projectConfigProvenance = forall a. a -> Set a
Set.singleton (String -> ProjectConfigProvenance
Explicit String
source)}

    adaptParseError :: Int -> Either a a -> ParseResult a
adaptParseError Int
_ (Right a
x) = forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x
    adaptParseError Int
l (Left a
e) = forall a. PError -> ParseResult a
parseFail forall a b. (a -> b) -> a -> b
$ String -> Maybe Int -> PError
ParseUtils.FromString (forall a. Show a => a -> String
show a
e) (forall a. a -> Maybe a
Just Int
l)

    liftPR :: (a -> IO (ParseResult b)) -> ParseResult a -> IO (ParseResult b)
    liftPR :: forall a b.
(a -> IO (ParseResult b)) -> ParseResult a -> IO (ParseResult b)
liftPR a -> IO (ParseResult b)
f (ParseOk [PWarning]
ws a
x) = forall {a}. ParseResult a -> ParseResult a
addWarnings forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> IO (ParseResult b)
f a
x
       where addWarnings :: ParseResult a -> ParseResult a
addWarnings (ParseOk [PWarning]
ws' a
x') = forall a. [PWarning] -> a -> ParseResult a
ParseOk ([PWarning]
ws' forall a. [a] -> [a] -> [a]
++ [PWarning]
ws) a
x'
             addWarnings ParseResult a
x' = ParseResult a
x'
    liftPR a -> IO (ParseResult b)
_ (ParseFailed PError
e) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. PError -> ParseResult a
ParseFailed PError
e

    fetchImportConfig :: ProjectConfigImport -> IO BS.ByteString
    fetchImportConfig :: String -> IO ByteString
fetchImportConfig String
pci = case String -> Maybe URI
parseURI String
pci of
         Just URI
uri -> do
            let fp :: String
fp = String
cacheDir String -> String -> String
</> forall a b. (a -> b) -> [a] -> [b]
map (\Char
x -> if Char -> Bool
isPathSeparator Char
x then Char
'_' else Char
x) (String -> String
makeValid forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show URI
uri)
            Bool -> String -> IO ()
createDirectoryIfMissing Bool
True String
cacheDir
            DownloadResult
_ <- HttpTransport -> Verbosity -> URI -> String -> IO DownloadResult
downloadURI HttpTransport
httpTransport Verbosity
verbosity URI
uri String
fp
            String -> IO ByteString
BS.readFile String
fp
         Maybe URI
Nothing -> String -> IO ByteString
BS.readFile forall a b. (a -> b) -> a -> b
$
           if String -> Bool
isAbsolute String
pci then String
pci else String -> String
takeDirectory String
source String -> String -> String
</> String
pci

    modifiesCompiler :: ProjectConfig -> Bool
    modifiesCompiler :: ProjectConfig -> Bool
modifiesCompiler ProjectConfig
pc = forall {a}. Eq a => (ProjectConfigShared -> Flag a) -> Bool
isSet ProjectConfigShared -> Flag CompilerFlavor
projectConfigHcFlavor Bool -> Bool -> Bool
|| forall {a}. Eq a => (ProjectConfigShared -> Flag a) -> Bool
isSet ProjectConfigShared -> Flag String
projectConfigHcPath Bool -> Bool -> Bool
|| forall {a}. Eq a => (ProjectConfigShared -> Flag a) -> Bool
isSet ProjectConfigShared -> Flag String
projectConfigHcPkg
      where
         isSet :: (ProjectConfigShared -> Flag a) -> Bool
isSet ProjectConfigShared -> Flag a
f = ProjectConfigShared -> Flag a
f (ProjectConfig -> ProjectConfigShared
projectConfigShared ProjectConfig
pc) forall a. Eq a => a -> a -> Bool
/= forall a. Flag a
NoFlag

    sanityWalkPCS :: Bool -> ProjectConfigSkeleton -> ParseResult ProjectConfigSkeleton
    sanityWalkPCS :: Bool -> ProjectConfigSkeleton -> ParseResult ProjectConfigSkeleton
sanityWalkPCS Bool
underConditional t :: ProjectConfigSkeleton
t@(CondNode ProjectConfig
d [String]
_c [CondBranch ConfVar [String] ProjectConfig]
comps)
           | Bool
underConditional Bool -> Bool -> Bool
&& ProjectConfig -> Bool
modifiesCompiler ProjectConfig
d = forall a. PError -> ParseResult a
parseFail forall a b. (a -> b) -> a -> b
$ String -> Maybe Int -> PError
ParseUtils.FromString String
"Cannot set compiler in a conditional clause of a cabal project file" forall a. Maybe a
Nothing
           | Bool
otherwise = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ CondBranch ConfVar [String] ProjectConfig -> ParseResult ()
sanityWalkBranch [CondBranch ConfVar [String] ProjectConfig]
comps forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (f :: * -> *) a. Applicative f => a -> f a
pure ProjectConfigSkeleton
t

    sanityWalkBranch:: CondBranch ConfVar [ProjectConfigImport] ProjectConfig -> ParseResult ()
    sanityWalkBranch :: CondBranch ConfVar [String] ProjectConfig -> ParseResult ()
sanityWalkBranch (CondBranch Condition ConfVar
_c ProjectConfigSkeleton
t Maybe ProjectConfigSkeleton
f) = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (Bool -> ProjectConfigSkeleton -> ParseResult ProjectConfigSkeleton
sanityWalkPCS Bool
True) Maybe ProjectConfigSkeleton
f forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> ProjectConfigSkeleton -> ParseResult ProjectConfigSkeleton
sanityWalkPCS Bool
True ProjectConfigSkeleton
t forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

------------------------------------------------------------------
-- Representing the project config file in terms of legacy types
--

-- | We already have parsers\/pretty-printers for almost all the fields in the
-- project config file, but they're in terms of the types used for the command
-- line flags for Setup.hs or cabal commands. We don't want to redefine them
-- all, at least not yet so for the moment we use the parsers at the old types
-- and use conversion functions.
--
-- Ultimately if\/when this project-based approach becomes the default then we
-- can redefine the parsers directly for the new types.
--
data LegacyProjectConfig = LegacyProjectConfig {
       LegacyProjectConfig -> [String]
legacyPackages          :: [String],
       LegacyProjectConfig -> [String]
legacyPackagesOptional  :: [String],
       LegacyProjectConfig -> [SourceRepoList]
legacyPackagesRepo      :: [SourceRepoList],
       LegacyProjectConfig -> [PackageVersionConstraint]
legacyPackagesNamed     :: [PackageVersionConstraint],

       LegacyProjectConfig -> LegacySharedConfig
legacySharedConfig      :: LegacySharedConfig,
       LegacyProjectConfig -> LegacyPackageConfig
legacyAllConfig         :: LegacyPackageConfig,
       LegacyProjectConfig -> LegacyPackageConfig
legacyLocalConfig       :: LegacyPackageConfig,
       LegacyProjectConfig -> MapMappend PackageName LegacyPackageConfig
legacySpecificConfig    :: MapMappend PackageName LegacyPackageConfig
     } deriving (Int -> LegacyProjectConfig -> String -> String
[LegacyProjectConfig] -> String -> String
LegacyProjectConfig -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [LegacyProjectConfig] -> String -> String
$cshowList :: [LegacyProjectConfig] -> String -> String
show :: LegacyProjectConfig -> String
$cshow :: LegacyProjectConfig -> String
showsPrec :: Int -> LegacyProjectConfig -> String -> String
$cshowsPrec :: Int -> LegacyProjectConfig -> String -> String
Show, forall x. Rep LegacyProjectConfig x -> LegacyProjectConfig
forall x. LegacyProjectConfig -> Rep LegacyProjectConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LegacyProjectConfig x -> LegacyProjectConfig
$cfrom :: forall x. LegacyProjectConfig -> Rep LegacyProjectConfig x
Generic)

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

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

data LegacyPackageConfig = LegacyPackageConfig {
       LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags    :: ConfigFlags,
       LegacyPackageConfig -> InstallFlags
legacyInstallPkgFlags   :: InstallFlags,
       LegacyPackageConfig -> HaddockFlags
legacyHaddockFlags      :: HaddockFlags,
       LegacyPackageConfig -> TestFlags
legacyTestFlags         :: TestFlags,
       LegacyPackageConfig -> BenchmarkFlags
legacyBenchmarkFlags    :: BenchmarkFlags
     } deriving (Int -> LegacyPackageConfig -> String -> String
[LegacyPackageConfig] -> String -> String
LegacyPackageConfig -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [LegacyPackageConfig] -> String -> String
$cshowList :: [LegacyPackageConfig] -> String -> String
show :: LegacyPackageConfig -> String
$cshow :: LegacyPackageConfig -> String
showsPrec :: Int -> LegacyPackageConfig -> String -> String
$cshowsPrec :: Int -> LegacyPackageConfig -> String -> String
Show, forall x. Rep LegacyPackageConfig x -> LegacyPackageConfig
forall x. LegacyPackageConfig -> Rep LegacyPackageConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LegacyPackageConfig x -> LegacyPackageConfig
$cfrom :: forall x. LegacyPackageConfig -> Rep LegacyPackageConfig x
Generic)

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

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

data LegacySharedConfig = LegacySharedConfig {
       LegacySharedConfig -> GlobalFlags
legacyGlobalFlags       :: GlobalFlags,
       LegacySharedConfig -> ConfigFlags
legacyConfigureShFlags  :: ConfigFlags,
       LegacySharedConfig -> ConfigExFlags
legacyConfigureExFlags  :: ConfigExFlags,
       LegacySharedConfig -> InstallFlags
legacyInstallFlags      :: InstallFlags,
       LegacySharedConfig -> ClientInstallFlags
legacyClientInstallFlags:: ClientInstallFlags,
       LegacySharedConfig -> ProjectFlags
legacyProjectFlags      :: ProjectFlags
     } deriving (Int -> LegacySharedConfig -> String -> String
[LegacySharedConfig] -> String -> String
LegacySharedConfig -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [LegacySharedConfig] -> String -> String
$cshowList :: [LegacySharedConfig] -> String -> String
show :: LegacySharedConfig -> String
$cshow :: LegacySharedConfig -> String
showsPrec :: Int -> LegacySharedConfig -> String -> String
$cshowsPrec :: Int -> LegacySharedConfig -> String -> String
Show, forall x. Rep LegacySharedConfig x -> LegacySharedConfig
forall x. LegacySharedConfig -> Rep LegacySharedConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LegacySharedConfig x -> LegacySharedConfig
$cfrom :: forall x. LegacySharedConfig -> Rep LegacySharedConfig x
Generic)

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

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


------------------------------------------------------------------
-- Converting from and to the legacy types
--

-- | Convert configuration from the @cabal configure@ or @cabal build@ command
-- line into a 'ProjectConfig' value that can combined with configuration from
-- other sources.
--
-- At the moment this uses the legacy command line flag types. See
-- 'LegacyProjectConfig' for an explanation.
--
commandLineFlagsToProjectConfig :: GlobalFlags
                                -> NixStyleFlags a
                                -> ClientInstallFlags
                                -> ProjectConfig
commandLineFlagsToProjectConfig :: forall a.
GlobalFlags
-> NixStyleFlags a -> ClientInstallFlags -> ProjectConfig
commandLineFlagsToProjectConfig GlobalFlags
globalFlags NixStyleFlags {a
ConfigFlags
HaddockFlags
TestFlags
BenchmarkFlags
ProjectFlags
InstallFlags
ConfigExFlags
extraFlags :: forall a. NixStyleFlags a -> a
projectFlags :: forall a. NixStyleFlags a -> ProjectFlags
benchmarkFlags :: forall a. NixStyleFlags a -> BenchmarkFlags
testFlags :: forall a. NixStyleFlags a -> TestFlags
haddockFlags :: forall a. NixStyleFlags a -> HaddockFlags
installFlags :: forall a. NixStyleFlags a -> InstallFlags
configExFlags :: forall a. NixStyleFlags a -> ConfigExFlags
configFlags :: forall a. NixStyleFlags a -> ConfigFlags
extraFlags :: a
projectFlags :: ProjectFlags
benchmarkFlags :: BenchmarkFlags
testFlags :: TestFlags
haddockFlags :: HaddockFlags
installFlags :: InstallFlags
configExFlags :: ConfigExFlags
configFlags :: ConfigFlags
..} ClientInstallFlags
clientInstallFlags =
    forall a. Monoid a => a
mempty {
      projectConfigBuildOnly :: ProjectConfigBuildOnly
projectConfigBuildOnly     = GlobalFlags
-> ConfigFlags
-> InstallFlags
-> ClientInstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> ProjectConfigBuildOnly
convertLegacyBuildOnlyFlags
                                     GlobalFlags
globalFlags ConfigFlags
configFlags
                                     InstallFlags
installFlags ClientInstallFlags
clientInstallFlags
                                     HaddockFlags
haddockFlags TestFlags
testFlags BenchmarkFlags
benchmarkFlags,
      projectConfigShared :: ProjectConfigShared
projectConfigShared        = GlobalFlags
-> ConfigFlags
-> ConfigExFlags
-> InstallFlags
-> ProjectFlags
-> ProjectConfigShared
convertLegacyAllPackageFlags
                                     GlobalFlags
globalFlags ConfigFlags
configFlags
                                     ConfigExFlags
configExFlags InstallFlags
installFlags ProjectFlags
projectFlags,
      projectConfigLocalPackages :: PackageConfig
projectConfigLocalPackages = PackageConfig
localConfig,
      projectConfigAllPackages :: PackageConfig
projectConfigAllPackages   = PackageConfig
allConfig
    }
  where (PackageConfig
localConfig, PackageConfig
allConfig) = PackageConfig -> (PackageConfig, PackageConfig)
splitConfig
                                 (ConfigFlags
-> InstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> PackageConfig
convertLegacyPerPackageFlags
                                    ConfigFlags
configFlags InstallFlags
installFlags
                                    HaddockFlags
haddockFlags TestFlags
testFlags BenchmarkFlags
benchmarkFlags)
        -- split the package config (from command line arguments) into
        -- those applied to all packages and those to local only.
        --
        -- for now we will just copy over the ProgramPaths/Extra into
        -- the AllPackages.  The LocalPackages do not inherit them from
        -- AllPackages, and as such need to retain them.
        --
        -- The general decision rule for what to put into allConfig
        -- into localConfig is the following:
        --
        -- - anything that is host/toolchain/env specific should be applied
        --   to all packages, as packagesets have to be host/toolchain/env
        --   consistent.
        -- - anything else should be in the local config and could potentially
        --   be lifted into all-packages vial the `package *` cabal.project
        --   section.
        --
        splitConfig :: PackageConfig -> (PackageConfig, PackageConfig)
        splitConfig :: PackageConfig -> (PackageConfig, PackageConfig)
splitConfig PackageConfig
pc = (PackageConfig
pc
                         , forall a. Monoid a => a
mempty { packageConfigProgramPaths :: MapLast String String
packageConfigProgramPaths = PackageConfig -> MapLast String String
packageConfigProgramPaths PackageConfig
pc
                                  , packageConfigProgramPathExtra :: NubList String
packageConfigProgramPathExtra = PackageConfig -> NubList String
packageConfigProgramPathExtra PackageConfig
pc

                                  -- Some flags to haddock should be passed to dependencies
                                  , packageConfigDocumentation :: Flag Bool
packageConfigDocumentation = PackageConfig -> Flag Bool
packageConfigDocumentation PackageConfig
pc
                                  , packageConfigHaddockHoogle :: Flag Bool
packageConfigHaddockHoogle = PackageConfig -> Flag Bool
packageConfigHaddockHoogle PackageConfig
pc
                                  , packageConfigHaddockHtml :: Flag Bool
packageConfigHaddockHtml = PackageConfig -> Flag Bool
packageConfigHaddockHtml PackageConfig
pc
                                  , packageConfigHaddockInternal :: Flag Bool
packageConfigHaddockInternal = PackageConfig -> Flag Bool
packageConfigHaddockInternal PackageConfig
pc
                                  , packageConfigHaddockQuickJump :: Flag Bool
packageConfigHaddockQuickJump = PackageConfig -> Flag Bool
packageConfigHaddockQuickJump PackageConfig
pc
                                  , packageConfigHaddockLinkedSource :: Flag Bool
packageConfigHaddockLinkedSource = PackageConfig -> Flag Bool
packageConfigHaddockLinkedSource PackageConfig
pc
                                  })

-- | Convert from the types currently used for the user-wide Cabal config
-- file into the 'ProjectConfig' type.
--
-- Only a subset of the 'ProjectConfig' can be represented in the user-wide
-- config. In particular it does not include packages that are in the project,
-- and it also doesn't support package-specific configuration (only
-- configuration that applies to all packages).
--
convertLegacyGlobalConfig :: SavedConfig -> ProjectConfig
convertLegacyGlobalConfig :: SavedConfig -> ProjectConfig
convertLegacyGlobalConfig
    SavedConfig {
      savedGlobalFlags :: SavedConfig -> GlobalFlags
savedGlobalFlags       = GlobalFlags
globalFlags,
      savedInstallFlags :: SavedConfig -> InstallFlags
savedInstallFlags      = InstallFlags
installFlags,
      savedClientInstallFlags :: SavedConfig -> ClientInstallFlags
savedClientInstallFlags= ClientInstallFlags
clientInstallFlags,
      savedConfigureFlags :: SavedConfig -> ConfigFlags
savedConfigureFlags    = ConfigFlags
configFlags,
      savedConfigureExFlags :: SavedConfig -> ConfigExFlags
savedConfigureExFlags  = ConfigExFlags
configExFlags,
      savedUserInstallDirs :: SavedConfig -> InstallDirs (Flag PathTemplate)
savedUserInstallDirs   = InstallDirs (Flag PathTemplate)
_,
      savedGlobalInstallDirs :: SavedConfig -> InstallDirs (Flag PathTemplate)
savedGlobalInstallDirs = InstallDirs (Flag PathTemplate)
_,
      savedUploadFlags :: SavedConfig -> UploadFlags
savedUploadFlags       = UploadFlags
_,
      savedReportFlags :: SavedConfig -> ReportFlags
savedReportFlags       = ReportFlags
_,
      savedHaddockFlags :: SavedConfig -> HaddockFlags
savedHaddockFlags      = HaddockFlags
haddockFlags,
      savedTestFlags :: SavedConfig -> TestFlags
savedTestFlags         = TestFlags
testFlags,
      savedBenchmarkFlags :: SavedConfig -> BenchmarkFlags
savedBenchmarkFlags    = BenchmarkFlags
benchmarkFlags,
      savedProjectFlags :: SavedConfig -> ProjectFlags
savedProjectFlags      = ProjectFlags
projectFlags
    } =
    forall a. Monoid a => a
mempty {
      projectConfigBuildOnly :: ProjectConfigBuildOnly
projectConfigBuildOnly   = ProjectConfigBuildOnly
configBuildOnly,
      projectConfigShared :: ProjectConfigShared
projectConfigShared      = ProjectConfigShared
configShared,
      projectConfigAllPackages :: PackageConfig
projectConfigAllPackages = PackageConfig
configAllPackages
    }
  where
    --TODO: [code cleanup] eliminate use of default*Flags here and specify the
    -- defaults in the various resolve functions in terms of the new types.
    configExFlags' :: ConfigExFlags
configExFlags'      = ConfigExFlags
defaultConfigExFlags      forall a. Semigroup a => a -> a -> a
<> ConfigExFlags
configExFlags
    installFlags' :: InstallFlags
installFlags'       = InstallFlags
defaultInstallFlags       forall a. Semigroup a => a -> a -> a
<> InstallFlags
installFlags
    clientInstallFlags' :: ClientInstallFlags
clientInstallFlags' = ClientInstallFlags
defaultClientInstallFlags forall a. Semigroup a => a -> a -> a
<> ClientInstallFlags
clientInstallFlags
    haddockFlags' :: HaddockFlags
haddockFlags'       = HaddockFlags
defaultHaddockFlags       forall a. Semigroup a => a -> a -> a
<> HaddockFlags
haddockFlags
    testFlags' :: TestFlags
testFlags'          = TestFlags
defaultTestFlags          forall a. Semigroup a => a -> a -> a
<> TestFlags
testFlags
    benchmarkFlags' :: BenchmarkFlags
benchmarkFlags'     = BenchmarkFlags
defaultBenchmarkFlags     forall a. Semigroup a => a -> a -> a
<> BenchmarkFlags
benchmarkFlags
    projectFlags' :: ProjectFlags
projectFlags'       = ProjectFlags
defaultProjectFlags       forall a. Semigroup a => a -> a -> a
<> ProjectFlags
projectFlags

    configAllPackages :: PackageConfig
configAllPackages   = ConfigFlags
-> InstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> PackageConfig
convertLegacyPerPackageFlags
                            ConfigFlags
configFlags InstallFlags
installFlags'
                            HaddockFlags
haddockFlags' TestFlags
testFlags' BenchmarkFlags
benchmarkFlags'
    configShared :: ProjectConfigShared
configShared        = GlobalFlags
-> ConfigFlags
-> ConfigExFlags
-> InstallFlags
-> ProjectFlags
-> ProjectConfigShared
convertLegacyAllPackageFlags
                            GlobalFlags
globalFlags ConfigFlags
configFlags
                            ConfigExFlags
configExFlags' InstallFlags
installFlags' ProjectFlags
projectFlags'
    configBuildOnly :: ProjectConfigBuildOnly
configBuildOnly     = GlobalFlags
-> ConfigFlags
-> InstallFlags
-> ClientInstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> ProjectConfigBuildOnly
convertLegacyBuildOnlyFlags
                            GlobalFlags
globalFlags ConfigFlags
configFlags
                            InstallFlags
installFlags' ClientInstallFlags
clientInstallFlags'
                            HaddockFlags
haddockFlags' TestFlags
testFlags' BenchmarkFlags
benchmarkFlags'


-- | Convert the project config from the legacy types to the 'ProjectConfig'
-- and associated types. See 'LegacyProjectConfig' for an explanation of the
-- approach.
--
convertLegacyProjectConfig :: LegacyProjectConfig -> ProjectConfig
convertLegacyProjectConfig :: LegacyProjectConfig -> ProjectConfig
convertLegacyProjectConfig
  LegacyProjectConfig {
    [String]
legacyPackages :: [String]
legacyPackages :: LegacyProjectConfig -> [String]
legacyPackages,
    [String]
legacyPackagesOptional :: [String]
legacyPackagesOptional :: LegacyProjectConfig -> [String]
legacyPackagesOptional,
    [SourceRepoList]
legacyPackagesRepo :: [SourceRepoList]
legacyPackagesRepo :: LegacyProjectConfig -> [SourceRepoList]
legacyPackagesRepo,
    [PackageVersionConstraint]
legacyPackagesNamed :: [PackageVersionConstraint]
legacyPackagesNamed :: LegacyProjectConfig -> [PackageVersionConstraint]
legacyPackagesNamed,
    legacySharedConfig :: LegacyProjectConfig -> LegacySharedConfig
legacySharedConfig = LegacySharedConfig GlobalFlags
globalFlags ConfigFlags
configShFlags
                                            ConfigExFlags
configExFlags InstallFlags
installSharedFlags
                                            ClientInstallFlags
clientInstallFlags ProjectFlags
projectFlags,
    LegacyPackageConfig
legacyAllConfig :: LegacyPackageConfig
legacyAllConfig :: LegacyProjectConfig -> LegacyPackageConfig
legacyAllConfig,
    legacyLocalConfig :: LegacyProjectConfig -> LegacyPackageConfig
legacyLocalConfig  = LegacyPackageConfig ConfigFlags
configFlags InstallFlags
installPerPkgFlags
                                             HaddockFlags
haddockFlags TestFlags
testFlags BenchmarkFlags
benchmarkFlags,
    MapMappend PackageName LegacyPackageConfig
legacySpecificConfig :: MapMappend PackageName LegacyPackageConfig
legacySpecificConfig :: LegacyProjectConfig -> MapMappend PackageName LegacyPackageConfig
legacySpecificConfig
  } =

    ProjectConfig {
      projectPackages :: [String]
projectPackages              = [String]
legacyPackages,
      projectPackagesOptional :: [String]
projectPackagesOptional      = [String]
legacyPackagesOptional,
      projectPackagesRepo :: [SourceRepoList]
projectPackagesRepo          = [SourceRepoList]
legacyPackagesRepo,
      projectPackagesNamed :: [PackageVersionConstraint]
projectPackagesNamed         = [PackageVersionConstraint]
legacyPackagesNamed,

      projectConfigBuildOnly :: ProjectConfigBuildOnly
projectConfigBuildOnly       = ProjectConfigBuildOnly
configBuildOnly,
      projectConfigShared :: ProjectConfigShared
projectConfigShared          = ProjectConfigShared
configPackagesShared,
      projectConfigProvenance :: Set ProjectConfigProvenance
projectConfigProvenance      = forall a. Monoid a => a
mempty,
      projectConfigAllPackages :: PackageConfig
projectConfigAllPackages     = PackageConfig
configAllPackages,
      projectConfigLocalPackages :: PackageConfig
projectConfigLocalPackages   = PackageConfig
configLocalPackages,
      projectConfigSpecificPackage :: MapMappend PackageName PackageConfig
projectConfigSpecificPackage = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LegacyPackageConfig -> PackageConfig
perPackage MapMappend PackageName LegacyPackageConfig
legacySpecificConfig
    }
  where
    configAllPackages :: PackageConfig
configAllPackages   = ConfigFlags
-> InstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> PackageConfig
convertLegacyPerPackageFlags ConfigFlags
g InstallFlags
i HaddockFlags
h TestFlags
t BenchmarkFlags
b
                            where LegacyPackageConfig ConfigFlags
g InstallFlags
i HaddockFlags
h TestFlags
t BenchmarkFlags
b = LegacyPackageConfig
legacyAllConfig
    configLocalPackages :: PackageConfig
configLocalPackages = ConfigFlags
-> InstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> PackageConfig
convertLegacyPerPackageFlags
                            ConfigFlags
configFlags InstallFlags
installPerPkgFlags HaddockFlags
haddockFlags
                            TestFlags
testFlags BenchmarkFlags
benchmarkFlags
    configPackagesShared :: ProjectConfigShared
configPackagesShared= GlobalFlags
-> ConfigFlags
-> ConfigExFlags
-> InstallFlags
-> ProjectFlags
-> ProjectConfigShared
convertLegacyAllPackageFlags
                            GlobalFlags
globalFlags (ConfigFlags
configFlags forall a. Semigroup a => a -> a -> a
<> ConfigFlags
configShFlags)
                            ConfigExFlags
configExFlags InstallFlags
installSharedFlags ProjectFlags
projectFlags
    configBuildOnly :: ProjectConfigBuildOnly
configBuildOnly     = GlobalFlags
-> ConfigFlags
-> InstallFlags
-> ClientInstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> ProjectConfigBuildOnly
convertLegacyBuildOnlyFlags
                            GlobalFlags
globalFlags ConfigFlags
configShFlags
                            InstallFlags
installSharedFlags ClientInstallFlags
clientInstallFlags
                            HaddockFlags
haddockFlags TestFlags
testFlags BenchmarkFlags
benchmarkFlags

    perPackage :: LegacyPackageConfig -> PackageConfig
perPackage (LegacyPackageConfig ConfigFlags
perPkgConfigFlags InstallFlags
perPkgInstallFlags
                                    HaddockFlags
perPkgHaddockFlags TestFlags
perPkgTestFlags
                                    BenchmarkFlags
perPkgBenchmarkFlags) =
      ConfigFlags
-> InstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> PackageConfig
convertLegacyPerPackageFlags
        ConfigFlags
perPkgConfigFlags InstallFlags
perPkgInstallFlags HaddockFlags
perPkgHaddockFlags
                          TestFlags
perPkgTestFlags BenchmarkFlags
perPkgBenchmarkFlags


-- | Helper used by other conversion functions that returns the
-- 'ProjectConfigShared' subset of the 'ProjectConfig'.
--
convertLegacyAllPackageFlags
    :: GlobalFlags
    -> ConfigFlags
    -> ConfigExFlags
    -> InstallFlags
    -> ProjectFlags
    -> ProjectConfigShared
convertLegacyAllPackageFlags :: GlobalFlags
-> ConfigFlags
-> ConfigExFlags
-> InstallFlags
-> ProjectFlags
-> ProjectConfigShared
convertLegacyAllPackageFlags GlobalFlags
globalFlags ConfigFlags
configFlags ConfigExFlags
configExFlags InstallFlags
installFlags ProjectFlags
projectFlags =
    ProjectConfigShared{[Maybe PackageDB]
[(UserConstraint, ConstraintSource)]
[PackageVersionConstraint]
Maybe AllowOlder
Maybe AllowNewer
NubList String
NubList LocalRepo
NubList RemoteRepo
InstallDirs (Flag PathTemplate)
Flag Bool
Flag Int
Flag String
Flag CompilerFlavor
Flag PathTemplate
Flag Version
Flag ReorderGoals
Flag CountConflicts
Flag FineGrainedConflicts
Flag MinimizeConflictSet
Flag IndependentGoals
Flag PreferOldest
Flag StrongFlags
Flag AllowBootLibInstalls
Flag OnlyConstrained
Flag PreSolver
Flag TotalIndexState
Flag ActiveRepos
Flag WriteGhcEnvironmentFilesPolicy
projectConfigProgPathExtra :: NubList String
projectConfigPreferOldest :: Flag PreferOldest
projectConfigIndependentGoals :: Flag IndependentGoals
projectConfigPerComponent :: Flag Bool
projectConfigOnlyConstrained :: Flag OnlyConstrained
projectConfigAllowBootLibInstalls :: Flag AllowBootLibInstalls
projectConfigStrongFlags :: Flag StrongFlags
projectConfigMinimizeConflictSet :: Flag MinimizeConflictSet
projectConfigFineGrainedConflicts :: Flag FineGrainedConflicts
projectConfigCountConflicts :: Flag CountConflicts
projectConfigReorderGoals :: Flag ReorderGoals
projectConfigMaxBackjumps :: Flag Int
projectConfigWriteGhcEnvironmentFilesPolicy :: Flag WriteGhcEnvironmentFilesPolicy
projectConfigAllowNewer :: Maybe AllowNewer
projectConfigAllowOlder :: Maybe AllowOlder
projectConfigSolver :: Flag PreSolver
projectConfigCabalVersion :: Flag Version
projectConfigPreferences :: [PackageVersionConstraint]
projectConfigConstraints :: [(UserConstraint, ConstraintSource)]
projectConfigStoreDir :: Flag String
projectConfigIndexState :: Flag TotalIndexState
projectConfigActiveRepos :: Flag ActiveRepos
projectConfigLocalNoIndexRepos :: NubList LocalRepo
projectConfigRemoteRepos :: NubList RemoteRepo
projectConfigPackageDBs :: [Maybe PackageDB]
projectConfigInstallDirs :: InstallDirs (Flag PathTemplate)
projectConfigHaddockIndex :: Flag PathTemplate
projectConfigIgnoreProject :: Flag Bool
projectConfigProjectFile :: Flag String
projectConfigConfigFile :: Flag String
projectConfigDistDir :: Flag String
projectConfigIgnoreProject :: Flag Bool
projectConfigProjectFile :: Flag String
projectConfigOnlyConstrained :: Flag OnlyConstrained
projectConfigAllowBootLibInstalls :: Flag AllowBootLibInstalls
projectConfigStrongFlags :: Flag StrongFlags
projectConfigPreferOldest :: Flag PreferOldest
projectConfigIndependentGoals :: Flag IndependentGoals
projectConfigPerComponent :: Flag Bool
projectConfigMinimizeConflictSet :: Flag MinimizeConflictSet
projectConfigFineGrainedConflicts :: Flag FineGrainedConflicts
projectConfigCountConflicts :: Flag CountConflicts
projectConfigReorderGoals :: Flag ReorderGoals
projectConfigMaxBackjumps :: Flag Int
projectConfigIndexState :: Flag TotalIndexState
projectConfigHaddockIndex :: Flag PathTemplate
projectConfigWriteGhcEnvironmentFilesPolicy :: Flag WriteGhcEnvironmentFilesPolicy
projectConfigAllowNewer :: Maybe AllowNewer
projectConfigAllowOlder :: Maybe AllowOlder
projectConfigSolver :: Flag PreSolver
projectConfigPreferences :: [PackageVersionConstraint]
projectConfigConstraints :: [(UserConstraint, ConstraintSource)]
projectConfigCabalVersion :: Flag Version
projectConfigPackageDBs :: [Maybe PackageDB]
projectConfigInstallDirs :: InstallDirs (Flag PathTemplate)
projectConfigHcPkg :: Flag String
projectConfigHcPath :: Flag String
projectConfigHcFlavor :: Flag CompilerFlavor
projectConfigDistDir :: Flag String
projectConfigStoreDir :: Flag String
projectConfigProgPathExtra :: NubList String
projectConfigActiveRepos :: Flag ActiveRepos
projectConfigLocalNoIndexRepos :: NubList LocalRepo
projectConfigRemoteRepos :: NubList RemoteRepo
projectConfigConfigFile :: Flag String
projectConfigHcPkg :: Flag String
projectConfigHcPath :: Flag String
projectConfigHcFlavor :: Flag CompilerFlavor
..}
  where
    GlobalFlags {
      globalConfigFile :: GlobalFlags -> Flag String
globalConfigFile        = Flag String
projectConfigConfigFile,
      globalRemoteRepos :: GlobalFlags -> NubList RemoteRepo
globalRemoteRepos       = NubList RemoteRepo
projectConfigRemoteRepos,
      globalLocalNoIndexRepos :: GlobalFlags -> NubList LocalRepo
globalLocalNoIndexRepos = NubList LocalRepo
projectConfigLocalNoIndexRepos,
      globalActiveRepos :: GlobalFlags -> Flag ActiveRepos
globalActiveRepos       = Flag ActiveRepos
projectConfigActiveRepos,
      globalProgPathExtra :: GlobalFlags -> NubList String
globalProgPathExtra     = NubList String
projectConfigProgPathExtra,
      globalStoreDir :: GlobalFlags -> Flag String
globalStoreDir          = Flag String
projectConfigStoreDir
    } = GlobalFlags
globalFlags

    ConfigFlags {
      configDistPref :: ConfigFlags -> Flag String
configDistPref            = Flag String
projectConfigDistDir,
      configHcFlavor :: ConfigFlags -> Flag CompilerFlavor
configHcFlavor            = Flag CompilerFlavor
projectConfigHcFlavor,
      configHcPath :: ConfigFlags -> Flag String
configHcPath              = Flag String
projectConfigHcPath,
      configHcPkg :: ConfigFlags -> Flag String
configHcPkg               = Flag String
projectConfigHcPkg,
    --configProgramPathExtra    = projectConfigProgPathExtra DELETE ME
      configInstallDirs :: ConfigFlags -> InstallDirs (Flag PathTemplate)
configInstallDirs         = InstallDirs (Flag PathTemplate)
projectConfigInstallDirs,
    --configUserInstall         = projectConfigUserInstall,
      configPackageDBs :: ConfigFlags -> [Maybe PackageDB]
configPackageDBs          = [Maybe PackageDB]
projectConfigPackageDBs
    } = ConfigFlags
configFlags

    ConfigExFlags {
      configCabalVersion :: ConfigExFlags -> Flag Version
configCabalVersion        = Flag Version
projectConfigCabalVersion,
      configExConstraints :: ConfigExFlags -> [(UserConstraint, ConstraintSource)]
configExConstraints       = [(UserConstraint, ConstraintSource)]
projectConfigConstraints,
      configPreferences :: ConfigExFlags -> [PackageVersionConstraint]
configPreferences         = [PackageVersionConstraint]
projectConfigPreferences,
      configSolver :: ConfigExFlags -> Flag PreSolver
configSolver              = Flag PreSolver
projectConfigSolver,
      configAllowOlder :: ConfigExFlags -> Maybe AllowOlder
configAllowOlder          = Maybe AllowOlder
projectConfigAllowOlder,
      configAllowNewer :: ConfigExFlags -> Maybe AllowNewer
configAllowNewer          = Maybe AllowNewer
projectConfigAllowNewer,
      configWriteGhcEnvironmentFilesPolicy :: ConfigExFlags -> Flag WriteGhcEnvironmentFilesPolicy
configWriteGhcEnvironmentFilesPolicy
                                = Flag WriteGhcEnvironmentFilesPolicy
projectConfigWriteGhcEnvironmentFilesPolicy
    } = ConfigExFlags
configExFlags

    InstallFlags {
      installHaddockIndex :: InstallFlags -> Flag PathTemplate
installHaddockIndex       = Flag PathTemplate
projectConfigHaddockIndex,
    --installReinstall          = projectConfigReinstall,
    --installAvoidReinstalls    = projectConfigAvoidReinstalls,
    --installOverrideReinstall  = projectConfigOverrideReinstall,
      installIndexState :: InstallFlags -> Flag TotalIndexState
installIndexState         = Flag TotalIndexState
projectConfigIndexState,
      installMaxBackjumps :: InstallFlags -> Flag Int
installMaxBackjumps       = Flag Int
projectConfigMaxBackjumps,
    --installUpgradeDeps        = projectConfigUpgradeDeps,
      installReorderGoals :: InstallFlags -> Flag ReorderGoals
installReorderGoals       = Flag ReorderGoals
projectConfigReorderGoals,
      installCountConflicts :: InstallFlags -> Flag CountConflicts
installCountConflicts     = Flag CountConflicts
projectConfigCountConflicts,
      installFineGrainedConflicts :: InstallFlags -> Flag FineGrainedConflicts
installFineGrainedConflicts = Flag FineGrainedConflicts
projectConfigFineGrainedConflicts,
      installMinimizeConflictSet :: InstallFlags -> Flag MinimizeConflictSet
installMinimizeConflictSet = Flag MinimizeConflictSet
projectConfigMinimizeConflictSet,
      installPerComponent :: InstallFlags -> Flag Bool
installPerComponent       = Flag Bool
projectConfigPerComponent,
      installIndependentGoals :: InstallFlags -> Flag IndependentGoals
installIndependentGoals   = Flag IndependentGoals
projectConfigIndependentGoals,
      installPreferOldest :: InstallFlags -> Flag PreferOldest
installPreferOldest       = Flag PreferOldest
projectConfigPreferOldest,
    --installShadowPkgs         = projectConfigShadowPkgs,
      installStrongFlags :: InstallFlags -> Flag StrongFlags
installStrongFlags        = Flag StrongFlags
projectConfigStrongFlags,
      installAllowBootLibInstalls :: InstallFlags -> Flag AllowBootLibInstalls
installAllowBootLibInstalls = Flag AllowBootLibInstalls
projectConfigAllowBootLibInstalls,
      installOnlyConstrained :: InstallFlags -> Flag OnlyConstrained
installOnlyConstrained    = Flag OnlyConstrained
projectConfigOnlyConstrained
    } = InstallFlags
installFlags

    ProjectFlags
        { flagProjectFileName :: ProjectFlags -> Flag String
flagProjectFileName = Flag String
projectConfigProjectFile
        , flagIgnoreProject :: ProjectFlags -> Flag Bool
flagIgnoreProject   = Flag Bool
projectConfigIgnoreProject
        } = ProjectFlags
projectFlags

-- | Helper used by other conversion functions that returns the
-- 'PackageConfig' subset of the 'ProjectConfig'.
--
convertLegacyPerPackageFlags :: ConfigFlags -> InstallFlags -> HaddockFlags
                             -> TestFlags -> BenchmarkFlags -> PackageConfig
convertLegacyPerPackageFlags :: ConfigFlags
-> InstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> PackageConfig
convertLegacyPerPackageFlags ConfigFlags
configFlags InstallFlags
installFlags
                             HaddockFlags
haddockFlags TestFlags
testFlags BenchmarkFlags
benchmarkFlags =
    PackageConfig{[String]
[PathTemplate]
NubList String
Flag Bool
Flag String
Flag HaddockTarget
Flag TestShowDetails
Flag OptimisationLevel
Flag DebugInfoLevel
Flag ProfDetailLevel
Flag DumpBuildInfo
Flag PathTemplate
FlagAssignment
MapMappend String [String]
MapLast String String
packageConfigBenchmarkOptions :: [PathTemplate]
packageConfigTestTestOptions :: [PathTemplate]
packageConfigTestFailWhenNoTestSuites :: Flag Bool
packageConfigTestWrapper :: Flag String
packageConfigTestKeepTix :: Flag Bool
packageConfigTestShowDetails :: Flag TestShowDetails
packageConfigTestMachineLog :: Flag PathTemplate
packageConfigTestHumanLog :: Flag PathTemplate
packageConfigHaddockForHackage :: Flag HaddockTarget
packageConfigHaddockLib :: Flag String
packageConfigHaddockBaseUrl :: Flag String
packageConfigHaddockIndex :: Flag PathTemplate
packageConfigHaddockContents :: Flag PathTemplate
packageConfigHaddockHscolourCss :: Flag String
packageConfigHaddockCss :: Flag String
packageConfigHaddockBenchmarks :: Flag Bool
packageConfigHaddockTestSuites :: Flag Bool
packageConfigHaddockExecutables :: Flag Bool
packageConfigHaddockForeignLibs :: Flag Bool
packageConfigHaddockHtmlLocation :: Flag String
packageConfigRunTests :: Flag Bool
packageConfigDumpBuildInfo :: Flag DumpBuildInfo
packageConfigDebugInfo :: Flag DebugInfoLevel
packageConfigRelocatable :: Flag Bool
packageConfigCoverage :: Flag Bool
packageConfigBenchmarks :: Flag Bool
packageConfigTests :: Flag Bool
packageConfigStripLibs :: Flag Bool
packageConfigStripExes :: Flag Bool
packageConfigSplitObjs :: Flag Bool
packageConfigSplitSections :: Flag Bool
packageConfigGHCiLib :: Flag Bool
packageConfigExtraIncludeDirs :: [String]
packageConfigExtraFrameworkDirs :: [String]
packageConfigExtraLibDirsStatic :: [String]
packageConfigExtraLibDirs :: [String]
packageConfigProgSuffix :: Flag PathTemplate
packageConfigProgPrefix :: Flag PathTemplate
packageConfigOptimization :: Flag OptimisationLevel
packageConfigConfigureArgs :: [String]
packageConfigProfLibDetail :: Flag ProfDetailLevel
packageConfigProfDetail :: Flag ProfDetailLevel
packageConfigProfExe :: Flag Bool
packageConfigProfLib :: Flag Bool
packageConfigProf :: Flag Bool
packageConfigFullyStaticExe :: Flag Bool
packageConfigDynExe :: Flag Bool
packageConfigStaticLib :: Flag Bool
packageConfigSharedLib :: Flag Bool
packageConfigVanillaLib :: Flag Bool
packageConfigFlagAssignment :: FlagAssignment
packageConfigProgramArgs :: MapMappend String [String]
packageConfigBenchmarkOptions :: [PathTemplate]
packageConfigTestTestOptions :: [PathTemplate]
packageConfigTestFailWhenNoTestSuites :: Flag Bool
packageConfigTestWrapper :: Flag String
packageConfigTestKeepTix :: Flag Bool
packageConfigTestShowDetails :: Flag TestShowDetails
packageConfigTestMachineLog :: Flag PathTemplate
packageConfigTestHumanLog :: Flag PathTemplate
packageConfigHaddockLib :: Flag String
packageConfigHaddockBaseUrl :: Flag String
packageConfigHaddockIndex :: Flag PathTemplate
packageConfigHaddockContents :: Flag PathTemplate
packageConfigHaddockHscolourCss :: Flag String
packageConfigHaddockQuickJump :: Flag Bool
packageConfigHaddockLinkedSource :: Flag Bool
packageConfigHaddockCss :: Flag String
packageConfigHaddockInternal :: Flag Bool
packageConfigHaddockBenchmarks :: Flag Bool
packageConfigHaddockTestSuites :: Flag Bool
packageConfigHaddockExecutables :: Flag Bool
packageConfigHaddockForHackage :: Flag HaddockTarget
packageConfigHaddockForeignLibs :: Flag Bool
packageConfigHaddockHtmlLocation :: Flag String
packageConfigHaddockHtml :: Flag Bool
packageConfigHaddockHoogle :: Flag Bool
packageConfigRunTests :: Flag Bool
packageConfigDocumentation :: Flag Bool
packageConfigCoverage :: Flag Bool
packageConfigProgramArgs :: MapMappend String [String]
packageConfigProgramPaths :: MapLast String String
packageConfigRelocatable :: Flag Bool
packageConfigDumpBuildInfo :: Flag DumpBuildInfo
packageConfigDebugInfo :: Flag DebugInfoLevel
packageConfigBenchmarks :: Flag Bool
packageConfigTests :: Flag Bool
packageConfigFlagAssignment :: FlagAssignment
packageConfigExtraIncludeDirs :: [String]
packageConfigExtraFrameworkDirs :: [String]
packageConfigExtraLibDirsStatic :: [String]
packageConfigExtraLibDirs :: [String]
packageConfigStripLibs :: Flag Bool
packageConfigStripExes :: Flag Bool
packageConfigSplitObjs :: Flag Bool
packageConfigSplitSections :: Flag Bool
packageConfigGHCiLib :: Flag Bool
packageConfigProgSuffix :: Flag PathTemplate
packageConfigProgPrefix :: Flag PathTemplate
packageConfigOptimization :: Flag OptimisationLevel
packageConfigConfigureArgs :: [String]
packageConfigProfLibDetail :: Flag ProfDetailLevel
packageConfigProfDetail :: Flag ProfDetailLevel
packageConfigProf :: Flag Bool
packageConfigProfExe :: Flag Bool
packageConfigFullyStaticExe :: Flag Bool
packageConfigDynExe :: Flag Bool
packageConfigStaticLib :: Flag Bool
packageConfigSharedLib :: Flag Bool
packageConfigProfLib :: Flag Bool
packageConfigVanillaLib :: Flag Bool
packageConfigProgramPathExtra :: NubList String
packageConfigHaddockLinkedSource :: Flag Bool
packageConfigHaddockQuickJump :: Flag Bool
packageConfigHaddockInternal :: Flag Bool
packageConfigHaddockHtml :: Flag Bool
packageConfigHaddockHoogle :: Flag Bool
packageConfigDocumentation :: Flag Bool
packageConfigProgramPathExtra :: NubList String
packageConfigProgramPaths :: MapLast String String
..}
  where
    ConfigFlags {
      [(String, String)]
configProgramPaths :: ConfigFlags -> [(String, String)]
configProgramPaths :: [(String, String)]
configProgramPaths,
      [(String, [String])]
configProgramArgs :: ConfigFlags -> [(String, [String])]
configProgramArgs :: [(String, [String])]
configProgramArgs,
      configProgramPathExtra :: ConfigFlags -> NubList String
configProgramPathExtra    = NubList String
packageConfigProgramPathExtra,
      configVanillaLib :: ConfigFlags -> Flag Bool
configVanillaLib          = Flag Bool
packageConfigVanillaLib,
      configProfLib :: ConfigFlags -> Flag Bool
configProfLib             = Flag Bool
packageConfigProfLib,
      configSharedLib :: ConfigFlags -> Flag Bool
configSharedLib           = Flag Bool
packageConfigSharedLib,
      configStaticLib :: ConfigFlags -> Flag Bool
configStaticLib           = Flag Bool
packageConfigStaticLib,
      configDynExe :: ConfigFlags -> Flag Bool
configDynExe              = Flag Bool
packageConfigDynExe,
      configFullyStaticExe :: ConfigFlags -> Flag Bool
configFullyStaticExe      = Flag Bool
packageConfigFullyStaticExe,
      configProfExe :: ConfigFlags -> Flag Bool
configProfExe             = Flag Bool
packageConfigProfExe,
      configProf :: ConfigFlags -> Flag Bool
configProf                = Flag Bool
packageConfigProf,
      configProfDetail :: ConfigFlags -> Flag ProfDetailLevel
configProfDetail          = Flag ProfDetailLevel
packageConfigProfDetail,
      configProfLibDetail :: ConfigFlags -> Flag ProfDetailLevel
configProfLibDetail       = Flag ProfDetailLevel
packageConfigProfLibDetail,
      configConfigureArgs :: ConfigFlags -> [String]
configConfigureArgs       = [String]
packageConfigConfigureArgs,
      configOptimization :: ConfigFlags -> Flag OptimisationLevel
configOptimization        = Flag OptimisationLevel
packageConfigOptimization,
      configProgPrefix :: ConfigFlags -> Flag PathTemplate
configProgPrefix          = Flag PathTemplate
packageConfigProgPrefix,
      configProgSuffix :: ConfigFlags -> Flag PathTemplate
configProgSuffix          = Flag PathTemplate
packageConfigProgSuffix,
      configGHCiLib :: ConfigFlags -> Flag Bool
configGHCiLib             = Flag Bool
packageConfigGHCiLib,
      configSplitSections :: ConfigFlags -> Flag Bool
configSplitSections       = Flag Bool
packageConfigSplitSections,
      configSplitObjs :: ConfigFlags -> Flag Bool
configSplitObjs           = Flag Bool
packageConfigSplitObjs,
      configStripExes :: ConfigFlags -> Flag Bool
configStripExes           = Flag Bool
packageConfigStripExes,
      configStripLibs :: ConfigFlags -> Flag Bool
configStripLibs           = Flag Bool
packageConfigStripLibs,
      configExtraLibDirs :: ConfigFlags -> [String]
configExtraLibDirs        = [String]
packageConfigExtraLibDirs,
      configExtraLibDirsStatic :: ConfigFlags -> [String]
configExtraLibDirsStatic  = [String]
packageConfigExtraLibDirsStatic,
      configExtraFrameworkDirs :: ConfigFlags -> [String]
configExtraFrameworkDirs  = [String]
packageConfigExtraFrameworkDirs,
      configExtraIncludeDirs :: ConfigFlags -> [String]
configExtraIncludeDirs    = [String]
packageConfigExtraIncludeDirs,
      configConfigurationsFlags :: ConfigFlags -> FlagAssignment
configConfigurationsFlags = FlagAssignment
packageConfigFlagAssignment,
      configTests :: ConfigFlags -> Flag Bool
configTests               = Flag Bool
packageConfigTests,
      configBenchmarks :: ConfigFlags -> Flag Bool
configBenchmarks          = Flag Bool
packageConfigBenchmarks,
      configCoverage :: ConfigFlags -> Flag Bool
configCoverage            = Flag Bool
coverage,
      configLibCoverage :: ConfigFlags -> Flag Bool
configLibCoverage         = Flag Bool
libcoverage, --deprecated
      configDebugInfo :: ConfigFlags -> Flag DebugInfoLevel
configDebugInfo           = Flag DebugInfoLevel
packageConfigDebugInfo,
      configDumpBuildInfo :: ConfigFlags -> Flag DumpBuildInfo
configDumpBuildInfo       = Flag DumpBuildInfo
packageConfigDumpBuildInfo,
      configRelocatable :: ConfigFlags -> Flag Bool
configRelocatable         = Flag Bool
packageConfigRelocatable
    } = ConfigFlags
configFlags
    packageConfigProgramPaths :: MapLast String String
packageConfigProgramPaths   = forall k v. Map k v -> MapLast k v
MapLast    (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String, String)]
configProgramPaths)
    packageConfigProgramArgs :: MapMappend String [String]
packageConfigProgramArgs    = forall k v. Map k v -> MapMappend k v
MapMappend (forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith forall a. [a] -> [a] -> [a]
(++) [(String, [String])]
configProgramArgs)

    packageConfigCoverage :: Flag Bool
packageConfigCoverage       = Flag Bool
coverage forall a. Semigroup a => a -> a -> a
<> Flag Bool
libcoverage
    --TODO: defer this merging to the resolve phase

    InstallFlags {
      installDocumentation :: InstallFlags -> Flag Bool
installDocumentation      = Flag Bool
packageConfigDocumentation,
      installRunTests :: InstallFlags -> Flag Bool
installRunTests           = Flag Bool
packageConfigRunTests
    } = InstallFlags
installFlags

    HaddockFlags {
      haddockHoogle :: HaddockFlags -> Flag Bool
haddockHoogle             = Flag Bool
packageConfigHaddockHoogle,
      haddockHtml :: HaddockFlags -> Flag Bool
haddockHtml               = Flag Bool
packageConfigHaddockHtml,
      haddockHtmlLocation :: HaddockFlags -> Flag String
haddockHtmlLocation       = Flag String
packageConfigHaddockHtmlLocation,
      haddockForeignLibs :: HaddockFlags -> Flag Bool
haddockForeignLibs        = Flag Bool
packageConfigHaddockForeignLibs,
      haddockForHackage :: HaddockFlags -> Flag HaddockTarget
haddockForHackage         = Flag HaddockTarget
packageConfigHaddockForHackage,
      haddockExecutables :: HaddockFlags -> Flag Bool
haddockExecutables        = Flag Bool
packageConfigHaddockExecutables,
      haddockTestSuites :: HaddockFlags -> Flag Bool
haddockTestSuites         = Flag Bool
packageConfigHaddockTestSuites,
      haddockBenchmarks :: HaddockFlags -> Flag Bool
haddockBenchmarks         = Flag Bool
packageConfigHaddockBenchmarks,
      haddockInternal :: HaddockFlags -> Flag Bool
haddockInternal           = Flag Bool
packageConfigHaddockInternal,
      haddockCss :: HaddockFlags -> Flag String
haddockCss                = Flag String
packageConfigHaddockCss,
      haddockLinkedSource :: HaddockFlags -> Flag Bool
haddockLinkedSource       = Flag Bool
packageConfigHaddockLinkedSource,
      haddockQuickJump :: HaddockFlags -> Flag Bool
haddockQuickJump          = Flag Bool
packageConfigHaddockQuickJump,
      haddockHscolourCss :: HaddockFlags -> Flag String
haddockHscolourCss        = Flag String
packageConfigHaddockHscolourCss,
      haddockContents :: HaddockFlags -> Flag PathTemplate
haddockContents           = Flag PathTemplate
packageConfigHaddockContents,
      haddockIndex :: HaddockFlags -> Flag PathTemplate
haddockIndex              = Flag PathTemplate
packageConfigHaddockIndex,
      haddockBaseUrl :: HaddockFlags -> Flag String
haddockBaseUrl            = Flag String
packageConfigHaddockBaseUrl,
      haddockLib :: HaddockFlags -> Flag String
haddockLib                = Flag String
packageConfigHaddockLib
    } = HaddockFlags
haddockFlags

    TestFlags {
      testHumanLog :: TestFlags -> Flag PathTemplate
testHumanLog              = Flag PathTemplate
packageConfigTestHumanLog,
      testMachineLog :: TestFlags -> Flag PathTemplate
testMachineLog            = Flag PathTemplate
packageConfigTestMachineLog,
      testShowDetails :: TestFlags -> Flag TestShowDetails
testShowDetails           = Flag TestShowDetails
packageConfigTestShowDetails,
      testKeepTix :: TestFlags -> Flag Bool
testKeepTix               = Flag Bool
packageConfigTestKeepTix,
      testWrapper :: TestFlags -> Flag String
testWrapper               = Flag String
packageConfigTestWrapper,
      testFailWhenNoTestSuites :: TestFlags -> Flag Bool
testFailWhenNoTestSuites  = Flag Bool
packageConfigTestFailWhenNoTestSuites,
      testOptions :: TestFlags -> [PathTemplate]
testOptions               = [PathTemplate]
packageConfigTestTestOptions
    } = TestFlags
testFlags

    BenchmarkFlags {
      benchmarkOptions :: BenchmarkFlags -> [PathTemplate]
benchmarkOptions          = [PathTemplate]
packageConfigBenchmarkOptions
    } = BenchmarkFlags
benchmarkFlags


-- | Helper used by other conversion functions that returns the
-- 'ProjectConfigBuildOnly' subset of the 'ProjectConfig'.
--
convertLegacyBuildOnlyFlags :: GlobalFlags -> ConfigFlags
                            -> InstallFlags -> ClientInstallFlags
                            -> HaddockFlags -> TestFlags
                            -> BenchmarkFlags
                            -> ProjectConfigBuildOnly
convertLegacyBuildOnlyFlags :: GlobalFlags
-> ConfigFlags
-> InstallFlags
-> ClientInstallFlags
-> HaddockFlags
-> TestFlags
-> BenchmarkFlags
-> ProjectConfigBuildOnly
convertLegacyBuildOnlyFlags GlobalFlags
globalFlags ConfigFlags
configFlags
                              InstallFlags
installFlags ClientInstallFlags
clientInstallFlags
                              HaddockFlags
haddockFlags TestFlags
_ BenchmarkFlags
_ =
    ProjectConfigBuildOnly{NubList PathTemplate
Flag Bool
Flag String
Flag (Maybe Int)
Flag Verbosity
Flag PathTemplate
Flag ReportLevel
ClientInstallFlags
projectConfigClientInstallFlags :: ClientInstallFlags
projectConfigLogsDir :: Flag String
projectConfigCacheDir :: Flag String
projectConfigIgnoreExpiry :: Flag Bool
projectConfigHttpTransport :: Flag String
projectConfigKeepTempFiles :: Flag Bool
projectConfigOfflineMode :: Flag Bool
projectConfigKeepGoing :: Flag Bool
projectConfigNumJobs :: Flag (Maybe Int)
projectConfigSymlinkBinDir :: Flag String
projectConfigReportPlanningFailure :: Flag Bool
projectConfigBuildReports :: Flag ReportLevel
projectConfigLogFile :: Flag PathTemplate
projectConfigSummaryFile :: NubList PathTemplate
projectConfigOnlyDownload :: Flag Bool
projectConfigOnlyDeps :: Flag Bool
projectConfigDryRun :: Flag Bool
projectConfigVerbosity :: Flag Verbosity
projectConfigKeepTempFiles :: Flag Bool
projectConfigOfflineMode :: Flag Bool
projectConfigKeepGoing :: Flag Bool
projectConfigNumJobs :: Flag (Maybe Int)
projectConfigSymlinkBinDir :: Flag String
projectConfigReportPlanningFailure :: Flag Bool
projectConfigBuildReports :: Flag ReportLevel
projectConfigLogFile :: Flag PathTemplate
projectConfigSummaryFile :: NubList PathTemplate
projectConfigOnlyDeps :: Flag Bool
projectConfigOnlyDownload :: Flag Bool
projectConfigDryRun :: Flag Bool
projectConfigVerbosity :: Flag Verbosity
projectConfigIgnoreExpiry :: Flag Bool
projectConfigHttpTransport :: Flag String
projectConfigLogsDir :: Flag String
projectConfigCacheDir :: Flag String
projectConfigClientInstallFlags :: ClientInstallFlags
..}
  where
    projectConfigClientInstallFlags :: ClientInstallFlags
projectConfigClientInstallFlags = ClientInstallFlags
clientInstallFlags
    GlobalFlags {
      globalCacheDir :: GlobalFlags -> Flag String
globalCacheDir          = Flag String
projectConfigCacheDir,
      globalLogsDir :: GlobalFlags -> Flag String
globalLogsDir           = Flag String
projectConfigLogsDir,
      globalHttpTransport :: GlobalFlags -> Flag String
globalHttpTransport     = Flag String
projectConfigHttpTransport,
      globalIgnoreExpiry :: GlobalFlags -> Flag Bool
globalIgnoreExpiry      = Flag Bool
projectConfigIgnoreExpiry
    } = GlobalFlags
globalFlags

    ConfigFlags {
      configVerbosity :: ConfigFlags -> Flag Verbosity
configVerbosity           = Flag Verbosity
projectConfigVerbosity
    } = ConfigFlags
configFlags

    InstallFlags {
      installDryRun :: InstallFlags -> Flag Bool
installDryRun             = Flag Bool
projectConfigDryRun,
      installOnlyDownload :: InstallFlags -> Flag Bool
installOnlyDownload       = Flag Bool
projectConfigOnlyDownload,
      installOnly :: InstallFlags -> Flag Bool
installOnly               = Flag Bool
_,
      installOnlyDeps :: InstallFlags -> Flag Bool
installOnlyDeps           = Flag Bool
projectConfigOnlyDeps,
      installRootCmd :: InstallFlags -> Flag String
installRootCmd            = Flag String
_,
      installSummaryFile :: InstallFlags -> NubList PathTemplate
installSummaryFile        = NubList PathTemplate
projectConfigSummaryFile,
      installLogFile :: InstallFlags -> Flag PathTemplate
installLogFile            = Flag PathTemplate
projectConfigLogFile,
      installBuildReports :: InstallFlags -> Flag ReportLevel
installBuildReports       = Flag ReportLevel
projectConfigBuildReports,
      installReportPlanningFailure :: InstallFlags -> Flag Bool
installReportPlanningFailure = Flag Bool
projectConfigReportPlanningFailure,
      installSymlinkBinDir :: InstallFlags -> Flag String
installSymlinkBinDir      = Flag String
projectConfigSymlinkBinDir,
      installNumJobs :: InstallFlags -> Flag (Maybe Int)
installNumJobs            = Flag (Maybe Int)
projectConfigNumJobs,
      installKeepGoing :: InstallFlags -> Flag Bool
installKeepGoing          = Flag Bool
projectConfigKeepGoing,
      installOfflineMode :: InstallFlags -> Flag Bool
installOfflineMode        = Flag Bool
projectConfigOfflineMode
    } = InstallFlags
installFlags

    HaddockFlags {
      haddockKeepTempFiles :: HaddockFlags -> Flag Bool
haddockKeepTempFiles      = Flag Bool
projectConfigKeepTempFiles --TODO: this ought to live elsewhere
    } = HaddockFlags
haddockFlags


convertToLegacyProjectConfig :: ProjectConfig -> LegacyProjectConfig
convertToLegacyProjectConfig :: ProjectConfig -> LegacyProjectConfig
convertToLegacyProjectConfig
    projectConfig :: ProjectConfig
projectConfig@ProjectConfig {
      [String]
projectPackages :: [String]
projectPackages :: ProjectConfig -> [String]
projectPackages,
      [String]
projectPackagesOptional :: [String]
projectPackagesOptional :: ProjectConfig -> [String]
projectPackagesOptional,
      [SourceRepoList]
projectPackagesRepo :: [SourceRepoList]
projectPackagesRepo :: ProjectConfig -> [SourceRepoList]
projectPackagesRepo,
      [PackageVersionConstraint]
projectPackagesNamed :: [PackageVersionConstraint]
projectPackagesNamed :: ProjectConfig -> [PackageVersionConstraint]
projectPackagesNamed,
      PackageConfig
projectConfigAllPackages :: PackageConfig
projectConfigAllPackages :: ProjectConfig -> PackageConfig
projectConfigAllPackages,
      PackageConfig
projectConfigLocalPackages :: PackageConfig
projectConfigLocalPackages :: ProjectConfig -> PackageConfig
projectConfigLocalPackages,
      MapMappend PackageName PackageConfig
projectConfigSpecificPackage :: MapMappend PackageName PackageConfig
projectConfigSpecificPackage :: ProjectConfig -> MapMappend PackageName PackageConfig
projectConfigSpecificPackage
    } =
    LegacyProjectConfig {
      legacyPackages :: [String]
legacyPackages         = [String]
projectPackages,
      legacyPackagesOptional :: [String]
legacyPackagesOptional = [String]
projectPackagesOptional,
      legacyPackagesRepo :: [SourceRepoList]
legacyPackagesRepo     = [SourceRepoList]
projectPackagesRepo,
      legacyPackagesNamed :: [PackageVersionConstraint]
legacyPackagesNamed    = [PackageVersionConstraint]
projectPackagesNamed,
      legacySharedConfig :: LegacySharedConfig
legacySharedConfig     = ProjectConfig -> LegacySharedConfig
convertToLegacySharedConfig ProjectConfig
projectConfig,
      legacyAllConfig :: LegacyPackageConfig
legacyAllConfig        = PackageConfig -> LegacyPackageConfig
convertToLegacyPerPackageConfig
                                 PackageConfig
projectConfigAllPackages,
      legacyLocalConfig :: LegacyPackageConfig
legacyLocalConfig      = ProjectConfig -> LegacyPackageConfig
convertToLegacyAllPackageConfig ProjectConfig
projectConfig
                            forall a. Semigroup a => a -> a -> a
<> PackageConfig -> LegacyPackageConfig
convertToLegacyPerPackageConfig
                                 PackageConfig
projectConfigLocalPackages,
      legacySpecificConfig :: MapMappend PackageName LegacyPackageConfig
legacySpecificConfig   = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PackageConfig -> LegacyPackageConfig
convertToLegacyPerPackageConfig
                                    MapMappend PackageName PackageConfig
projectConfigSpecificPackage
    }

convertToLegacySharedConfig :: ProjectConfig -> LegacySharedConfig
convertToLegacySharedConfig :: ProjectConfig -> LegacySharedConfig
convertToLegacySharedConfig
    ProjectConfig {
      projectConfigBuildOnly :: ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly     = ProjectConfigBuildOnly {NubList PathTemplate
Flag Bool
Flag String
Flag (Maybe Int)
Flag Verbosity
Flag PathTemplate
Flag ReportLevel
ClientInstallFlags
projectConfigClientInstallFlags :: ClientInstallFlags
projectConfigLogsDir :: Flag String
projectConfigCacheDir :: Flag String
projectConfigIgnoreExpiry :: Flag Bool
projectConfigHttpTransport :: Flag String
projectConfigKeepTempFiles :: Flag Bool
projectConfigOfflineMode :: Flag Bool
projectConfigKeepGoing :: Flag Bool
projectConfigNumJobs :: Flag (Maybe Int)
projectConfigSymlinkBinDir :: Flag String
projectConfigReportPlanningFailure :: Flag Bool
projectConfigBuildReports :: Flag ReportLevel
projectConfigLogFile :: Flag PathTemplate
projectConfigSummaryFile :: NubList PathTemplate
projectConfigOnlyDownload :: Flag Bool
projectConfigOnlyDeps :: Flag Bool
projectConfigDryRun :: Flag Bool
projectConfigVerbosity :: Flag Verbosity
projectConfigClientInstallFlags :: ProjectConfigBuildOnly -> ClientInstallFlags
projectConfigLogsDir :: ProjectConfigBuildOnly -> Flag String
projectConfigCacheDir :: ProjectConfigBuildOnly -> Flag String
projectConfigIgnoreExpiry :: ProjectConfigBuildOnly -> Flag Bool
projectConfigHttpTransport :: ProjectConfigBuildOnly -> Flag String
projectConfigKeepTempFiles :: ProjectConfigBuildOnly -> Flag Bool
projectConfigOfflineMode :: ProjectConfigBuildOnly -> Flag Bool
projectConfigKeepGoing :: ProjectConfigBuildOnly -> Flag Bool
projectConfigNumJobs :: ProjectConfigBuildOnly -> Flag (Maybe Int)
projectConfigSymlinkBinDir :: ProjectConfigBuildOnly -> Flag String
projectConfigReportPlanningFailure :: ProjectConfigBuildOnly -> Flag Bool
projectConfigBuildReports :: ProjectConfigBuildOnly -> Flag ReportLevel
projectConfigLogFile :: ProjectConfigBuildOnly -> Flag PathTemplate
projectConfigSummaryFile :: ProjectConfigBuildOnly -> NubList PathTemplate
projectConfigOnlyDownload :: ProjectConfigBuildOnly -> Flag Bool
projectConfigOnlyDeps :: ProjectConfigBuildOnly -> Flag Bool
projectConfigDryRun :: ProjectConfigBuildOnly -> Flag Bool
projectConfigVerbosity :: ProjectConfigBuildOnly -> Flag Verbosity
..},
      projectConfigShared :: ProjectConfig -> ProjectConfigShared
projectConfigShared        = ProjectConfigShared {[Maybe PackageDB]
[(UserConstraint, ConstraintSource)]
[PackageVersionConstraint]
Maybe AllowOlder
Maybe AllowNewer
NubList String
NubList LocalRepo
NubList RemoteRepo
InstallDirs (Flag PathTemplate)
Flag Bool
Flag Int
Flag String
Flag CompilerFlavor
Flag PathTemplate
Flag Version
Flag ReorderGoals
Flag CountConflicts
Flag FineGrainedConflicts
Flag MinimizeConflictSet
Flag IndependentGoals
Flag PreferOldest
Flag StrongFlags
Flag AllowBootLibInstalls
Flag OnlyConstrained
Flag PreSolver
Flag TotalIndexState
Flag ActiveRepos
Flag WriteGhcEnvironmentFilesPolicy
projectConfigProgPathExtra :: NubList String
projectConfigPreferOldest :: Flag PreferOldest
projectConfigIndependentGoals :: Flag IndependentGoals
projectConfigPerComponent :: Flag Bool
projectConfigOnlyConstrained :: Flag OnlyConstrained
projectConfigAllowBootLibInstalls :: Flag AllowBootLibInstalls
projectConfigStrongFlags :: Flag StrongFlags
projectConfigMinimizeConflictSet :: Flag MinimizeConflictSet
projectConfigFineGrainedConflicts :: Flag FineGrainedConflicts
projectConfigCountConflicts :: Flag CountConflicts
projectConfigReorderGoals :: Flag ReorderGoals
projectConfigMaxBackjumps :: Flag Int
projectConfigWriteGhcEnvironmentFilesPolicy :: Flag WriteGhcEnvironmentFilesPolicy
projectConfigAllowNewer :: Maybe AllowNewer
projectConfigAllowOlder :: Maybe AllowOlder
projectConfigSolver :: Flag PreSolver
projectConfigCabalVersion :: Flag Version
projectConfigPreferences :: [PackageVersionConstraint]
projectConfigConstraints :: [(UserConstraint, ConstraintSource)]
projectConfigStoreDir :: Flag String
projectConfigIndexState :: Flag TotalIndexState
projectConfigActiveRepos :: Flag ActiveRepos
projectConfigLocalNoIndexRepos :: NubList LocalRepo
projectConfigRemoteRepos :: NubList RemoteRepo
projectConfigPackageDBs :: [Maybe PackageDB]
projectConfigInstallDirs :: InstallDirs (Flag PathTemplate)
projectConfigHaddockIndex :: Flag PathTemplate
projectConfigHcPkg :: Flag String
projectConfigHcPath :: Flag String
projectConfigHcFlavor :: Flag CompilerFlavor
projectConfigIgnoreProject :: Flag Bool
projectConfigProjectFile :: Flag String
projectConfigConfigFile :: Flag String
projectConfigDistDir :: Flag String
projectConfigProgPathExtra :: ProjectConfigShared -> NubList String
projectConfigPreferOldest :: ProjectConfigShared -> Flag PreferOldest
projectConfigIndependentGoals :: ProjectConfigShared -> Flag IndependentGoals
projectConfigPerComponent :: ProjectConfigShared -> Flag Bool
projectConfigOnlyConstrained :: ProjectConfigShared -> Flag OnlyConstrained
projectConfigAllowBootLibInstalls :: ProjectConfigShared -> Flag AllowBootLibInstalls
projectConfigStrongFlags :: ProjectConfigShared -> Flag StrongFlags
projectConfigMinimizeConflictSet :: ProjectConfigShared -> Flag MinimizeConflictSet
projectConfigFineGrainedConflicts :: ProjectConfigShared -> Flag FineGrainedConflicts
projectConfigCountConflicts :: ProjectConfigShared -> Flag CountConflicts
projectConfigReorderGoals :: ProjectConfigShared -> Flag ReorderGoals
projectConfigMaxBackjumps :: ProjectConfigShared -> Flag Int
projectConfigWriteGhcEnvironmentFilesPolicy :: ProjectConfigShared -> Flag WriteGhcEnvironmentFilesPolicy
projectConfigAllowNewer :: ProjectConfigShared -> Maybe AllowNewer
projectConfigAllowOlder :: ProjectConfigShared -> Maybe AllowOlder
projectConfigSolver :: ProjectConfigShared -> Flag PreSolver
projectConfigCabalVersion :: ProjectConfigShared -> Flag Version
projectConfigPreferences :: ProjectConfigShared -> [PackageVersionConstraint]
projectConfigConstraints :: ProjectConfigShared -> [(UserConstraint, ConstraintSource)]
projectConfigStoreDir :: ProjectConfigShared -> Flag String
projectConfigIndexState :: ProjectConfigShared -> Flag TotalIndexState
projectConfigActiveRepos :: ProjectConfigShared -> Flag ActiveRepos
projectConfigLocalNoIndexRepos :: ProjectConfigShared -> NubList LocalRepo
projectConfigRemoteRepos :: ProjectConfigShared -> NubList RemoteRepo
projectConfigPackageDBs :: ProjectConfigShared -> [Maybe PackageDB]
projectConfigInstallDirs :: ProjectConfigShared -> InstallDirs (Flag PathTemplate)
projectConfigHaddockIndex :: ProjectConfigShared -> Flag PathTemplate
projectConfigIgnoreProject :: ProjectConfigShared -> Flag Bool
projectConfigProjectFile :: ProjectConfigShared -> Flag String
projectConfigConfigFile :: ProjectConfigShared -> Flag String
projectConfigDistDir :: ProjectConfigShared -> Flag String
projectConfigHcPkg :: ProjectConfigShared -> Flag String
projectConfigHcPath :: ProjectConfigShared -> Flag String
projectConfigHcFlavor :: ProjectConfigShared -> Flag CompilerFlavor
..},
      projectConfigAllPackages :: ProjectConfig -> PackageConfig
projectConfigAllPackages   = PackageConfig {
        Flag Bool
packageConfigDocumentation :: Flag Bool
packageConfigDocumentation :: PackageConfig -> Flag Bool
packageConfigDocumentation
      }
    } =

    LegacySharedConfig
      { legacyGlobalFlags :: GlobalFlags
legacyGlobalFlags        = GlobalFlags
globalFlags
      , legacyConfigureShFlags :: ConfigFlags
legacyConfigureShFlags   = ConfigFlags
configFlags
      , legacyConfigureExFlags :: ConfigExFlags
legacyConfigureExFlags   = ConfigExFlags
configExFlags
      , legacyInstallFlags :: InstallFlags
legacyInstallFlags       = InstallFlags
installFlags
      , legacyClientInstallFlags :: ClientInstallFlags
legacyClientInstallFlags = ClientInstallFlags
projectConfigClientInstallFlags
      , legacyProjectFlags :: ProjectFlags
legacyProjectFlags       = ProjectFlags
projectFlags
      }
  where
    globalFlags :: GlobalFlags
globalFlags = GlobalFlags {
      globalVersion :: Flag Bool
globalVersion           = forall a. Monoid a => a
mempty,
      globalNumericVersion :: Flag Bool
globalNumericVersion    = forall a. Monoid a => a
mempty,
      globalConfigFile :: Flag String
globalConfigFile        = Flag String
projectConfigConfigFile,
      globalConstraintsFile :: Flag String
globalConstraintsFile   = forall a. Monoid a => a
mempty,
      globalRemoteRepos :: NubList RemoteRepo
globalRemoteRepos       = NubList RemoteRepo
projectConfigRemoteRepos,
      globalCacheDir :: Flag String
globalCacheDir          = Flag String
projectConfigCacheDir,
      globalLocalNoIndexRepos :: NubList LocalRepo
globalLocalNoIndexRepos = NubList LocalRepo
projectConfigLocalNoIndexRepos,
      globalActiveRepos :: Flag ActiveRepos
globalActiveRepos       = Flag ActiveRepos
projectConfigActiveRepos,
      globalLogsDir :: Flag String
globalLogsDir           = Flag String
projectConfigLogsDir,
      globalIgnoreExpiry :: Flag Bool
globalIgnoreExpiry      = Flag Bool
projectConfigIgnoreExpiry,
      globalHttpTransport :: Flag String
globalHttpTransport     = Flag String
projectConfigHttpTransport,
      globalNix :: Flag Bool
globalNix               = forall a. Monoid a => a
mempty,
      globalStoreDir :: Flag String
globalStoreDir          = Flag String
projectConfigStoreDir,
      globalProgPathExtra :: NubList String
globalProgPathExtra     = NubList String
projectConfigProgPathExtra
    }

    configFlags :: ConfigFlags
configFlags = forall a. Monoid a => a
mempty {
      configVerbosity :: Flag Verbosity
configVerbosity     = Flag Verbosity
projectConfigVerbosity,
      configDistPref :: Flag String
configDistPref      = Flag String
projectConfigDistDir,
      configPackageDBs :: [Maybe PackageDB]
configPackageDBs    = [Maybe PackageDB]
projectConfigPackageDBs,
      configInstallDirs :: InstallDirs (Flag PathTemplate)
configInstallDirs   = InstallDirs (Flag PathTemplate)
projectConfigInstallDirs
    }

    configExFlags :: ConfigExFlags
configExFlags = ConfigExFlags {
      configCabalVersion :: Flag Version
configCabalVersion  = Flag Version
projectConfigCabalVersion,
      configAppend :: Flag Bool
configAppend        = forall a. Monoid a => a
mempty,
      configBackup :: Flag Bool
configBackup        = forall a. Monoid a => a
mempty,
      configExConstraints :: [(UserConstraint, ConstraintSource)]
configExConstraints = [(UserConstraint, ConstraintSource)]
projectConfigConstraints,
      configPreferences :: [PackageVersionConstraint]
configPreferences   = [PackageVersionConstraint]
projectConfigPreferences,
      configSolver :: Flag PreSolver
configSolver        = Flag PreSolver
projectConfigSolver,
      configAllowOlder :: Maybe AllowOlder
configAllowOlder    = Maybe AllowOlder
projectConfigAllowOlder,
      configAllowNewer :: Maybe AllowNewer
configAllowNewer    = Maybe AllowNewer
projectConfigAllowNewer,
      configWriteGhcEnvironmentFilesPolicy :: Flag WriteGhcEnvironmentFilesPolicy
configWriteGhcEnvironmentFilesPolicy
                          = Flag WriteGhcEnvironmentFilesPolicy
projectConfigWriteGhcEnvironmentFilesPolicy
    }

    installFlags :: InstallFlags
installFlags = InstallFlags {
      installDocumentation :: Flag Bool
installDocumentation     = Flag Bool
packageConfigDocumentation,
      installHaddockIndex :: Flag PathTemplate
installHaddockIndex      = Flag PathTemplate
projectConfigHaddockIndex,
      installDest :: Flag CopyDest
installDest              = forall a. a -> Flag a
Flag CopyDest
NoCopyDest,
      installDryRun :: Flag Bool
installDryRun            = Flag Bool
projectConfigDryRun,
      installOnlyDownload :: Flag Bool
installOnlyDownload      = Flag Bool
projectConfigOnlyDownload,
      installReinstall :: Flag Bool
installReinstall         = forall a. Monoid a => a
mempty, --projectConfigReinstall,
      installAvoidReinstalls :: Flag AvoidReinstalls
installAvoidReinstalls   = forall a. Monoid a => a
mempty, --projectConfigAvoidReinstalls,
      installOverrideReinstall :: Flag Bool
installOverrideReinstall = forall a. Monoid a => a
mempty, --projectConfigOverrideReinstall,
      installMaxBackjumps :: Flag Int
installMaxBackjumps      = Flag Int
projectConfigMaxBackjumps,
      installUpgradeDeps :: Flag Bool
installUpgradeDeps       = forall a. Monoid a => a
mempty, --projectConfigUpgradeDeps,
      installReorderGoals :: Flag ReorderGoals
installReorderGoals      = Flag ReorderGoals
projectConfigReorderGoals,
      installCountConflicts :: Flag CountConflicts
installCountConflicts    = Flag CountConflicts
projectConfigCountConflicts,
      installFineGrainedConflicts :: Flag FineGrainedConflicts
installFineGrainedConflicts = Flag FineGrainedConflicts
projectConfigFineGrainedConflicts,
      installMinimizeConflictSet :: Flag MinimizeConflictSet
installMinimizeConflictSet = Flag MinimizeConflictSet
projectConfigMinimizeConflictSet,
      installIndependentGoals :: Flag IndependentGoals
installIndependentGoals  = Flag IndependentGoals
projectConfigIndependentGoals,
      installPreferOldest :: Flag PreferOldest
installPreferOldest      = Flag PreferOldest
projectConfigPreferOldest,
      installShadowPkgs :: Flag ShadowPkgs
installShadowPkgs        = forall a. Monoid a => a
mempty, --projectConfigShadowPkgs,
      installStrongFlags :: Flag StrongFlags
installStrongFlags       = Flag StrongFlags
projectConfigStrongFlags,
      installAllowBootLibInstalls :: Flag AllowBootLibInstalls
installAllowBootLibInstalls = Flag AllowBootLibInstalls
projectConfigAllowBootLibInstalls,
      installOnlyConstrained :: Flag OnlyConstrained
installOnlyConstrained   = Flag OnlyConstrained
projectConfigOnlyConstrained,
      installOnly :: Flag Bool
installOnly              = forall a. Monoid a => a
mempty,
      installOnlyDeps :: Flag Bool
installOnlyDeps          = Flag Bool
projectConfigOnlyDeps,
      installIndexState :: Flag TotalIndexState
installIndexState        = Flag TotalIndexState
projectConfigIndexState,
      installRootCmd :: Flag String
installRootCmd           = forall a. Monoid a => a
mempty, --no longer supported
      installSummaryFile :: NubList PathTemplate
installSummaryFile       = NubList PathTemplate
projectConfigSummaryFile,
      installLogFile :: Flag PathTemplate
installLogFile           = Flag PathTemplate
projectConfigLogFile,
      installBuildReports :: Flag ReportLevel
installBuildReports      = Flag ReportLevel
projectConfigBuildReports,
      installReportPlanningFailure :: Flag Bool
installReportPlanningFailure = Flag Bool
projectConfigReportPlanningFailure,
      installSymlinkBinDir :: Flag String
installSymlinkBinDir     = Flag String
projectConfigSymlinkBinDir,
      installPerComponent :: Flag Bool
installPerComponent      = Flag Bool
projectConfigPerComponent,
      installNumJobs :: Flag (Maybe Int)
installNumJobs           = Flag (Maybe Int)
projectConfigNumJobs,
      installKeepGoing :: Flag Bool
installKeepGoing         = Flag Bool
projectConfigKeepGoing,
      installRunTests :: Flag Bool
installRunTests          = forall a. Monoid a => a
mempty,
      installOfflineMode :: Flag Bool
installOfflineMode       = Flag Bool
projectConfigOfflineMode
    }

    projectFlags :: ProjectFlags
projectFlags = ProjectFlags
        { flagProjectFileName :: Flag String
flagProjectFileName = Flag String
projectConfigProjectFile
        , flagIgnoreProject :: Flag Bool
flagIgnoreProject   = Flag Bool
projectConfigIgnoreProject
        }


convertToLegacyAllPackageConfig :: ProjectConfig -> LegacyPackageConfig
convertToLegacyAllPackageConfig :: ProjectConfig -> LegacyPackageConfig
convertToLegacyAllPackageConfig
    ProjectConfig {
      projectConfigBuildOnly :: ProjectConfig -> ProjectConfigBuildOnly
projectConfigBuildOnly = ProjectConfigBuildOnly {NubList PathTemplate
Flag Bool
Flag String
Flag (Maybe Int)
Flag Verbosity
Flag PathTemplate
Flag ReportLevel
ClientInstallFlags
projectConfigClientInstallFlags :: ClientInstallFlags
projectConfigLogsDir :: Flag String
projectConfigCacheDir :: Flag String
projectConfigIgnoreExpiry :: Flag Bool
projectConfigHttpTransport :: Flag String
projectConfigKeepTempFiles :: Flag Bool
projectConfigOfflineMode :: Flag Bool
projectConfigKeepGoing :: Flag Bool
projectConfigNumJobs :: Flag (Maybe Int)
projectConfigSymlinkBinDir :: Flag String
projectConfigReportPlanningFailure :: Flag Bool
projectConfigBuildReports :: Flag ReportLevel
projectConfigLogFile :: Flag PathTemplate
projectConfigSummaryFile :: NubList PathTemplate
projectConfigOnlyDownload :: Flag Bool
projectConfigOnlyDeps :: Flag Bool
projectConfigDryRun :: Flag Bool
projectConfigVerbosity :: Flag Verbosity
projectConfigClientInstallFlags :: ProjectConfigBuildOnly -> ClientInstallFlags
projectConfigLogsDir :: ProjectConfigBuildOnly -> Flag String
projectConfigCacheDir :: ProjectConfigBuildOnly -> Flag String
projectConfigIgnoreExpiry :: ProjectConfigBuildOnly -> Flag Bool
projectConfigHttpTransport :: ProjectConfigBuildOnly -> Flag String
projectConfigKeepTempFiles :: ProjectConfigBuildOnly -> Flag Bool
projectConfigOfflineMode :: ProjectConfigBuildOnly -> Flag Bool
projectConfigKeepGoing :: ProjectConfigBuildOnly -> Flag Bool
projectConfigNumJobs :: ProjectConfigBuildOnly -> Flag (Maybe Int)
projectConfigSymlinkBinDir :: ProjectConfigBuildOnly -> Flag String
projectConfigReportPlanningFailure :: ProjectConfigBuildOnly -> Flag Bool
projectConfigBuildReports :: ProjectConfigBuildOnly -> Flag ReportLevel
projectConfigLogFile :: ProjectConfigBuildOnly -> Flag PathTemplate
projectConfigSummaryFile :: ProjectConfigBuildOnly -> NubList PathTemplate
projectConfigOnlyDownload :: ProjectConfigBuildOnly -> Flag Bool
projectConfigOnlyDeps :: ProjectConfigBuildOnly -> Flag Bool
projectConfigDryRun :: ProjectConfigBuildOnly -> Flag Bool
projectConfigVerbosity :: ProjectConfigBuildOnly -> Flag Verbosity
..},
      projectConfigShared :: ProjectConfig -> ProjectConfigShared
projectConfigShared    = ProjectConfigShared {[Maybe PackageDB]
[(UserConstraint, ConstraintSource)]
[PackageVersionConstraint]
Maybe AllowOlder
Maybe AllowNewer
NubList String
NubList LocalRepo
NubList RemoteRepo
InstallDirs (Flag PathTemplate)
Flag Bool
Flag Int
Flag String
Flag CompilerFlavor
Flag PathTemplate
Flag Version
Flag ReorderGoals
Flag CountConflicts
Flag FineGrainedConflicts
Flag MinimizeConflictSet
Flag IndependentGoals
Flag PreferOldest
Flag StrongFlags
Flag AllowBootLibInstalls
Flag OnlyConstrained
Flag PreSolver
Flag TotalIndexState
Flag ActiveRepos
Flag WriteGhcEnvironmentFilesPolicy
projectConfigProgPathExtra :: NubList String
projectConfigPreferOldest :: Flag PreferOldest
projectConfigIndependentGoals :: Flag IndependentGoals
projectConfigPerComponent :: Flag Bool
projectConfigOnlyConstrained :: Flag OnlyConstrained
projectConfigAllowBootLibInstalls :: Flag AllowBootLibInstalls
projectConfigStrongFlags :: Flag StrongFlags
projectConfigMinimizeConflictSet :: Flag MinimizeConflictSet
projectConfigFineGrainedConflicts :: Flag FineGrainedConflicts
projectConfigCountConflicts :: Flag CountConflicts
projectConfigReorderGoals :: Flag ReorderGoals
projectConfigMaxBackjumps :: Flag Int
projectConfigWriteGhcEnvironmentFilesPolicy :: Flag WriteGhcEnvironmentFilesPolicy
projectConfigAllowNewer :: Maybe AllowNewer
projectConfigAllowOlder :: Maybe AllowOlder
projectConfigSolver :: Flag PreSolver
projectConfigCabalVersion :: Flag Version
projectConfigPreferences :: [PackageVersionConstraint]
projectConfigConstraints :: [(UserConstraint, ConstraintSource)]
projectConfigStoreDir :: Flag String
projectConfigIndexState :: Flag TotalIndexState
projectConfigActiveRepos :: Flag ActiveRepos
projectConfigLocalNoIndexRepos :: NubList LocalRepo
projectConfigRemoteRepos :: NubList RemoteRepo
projectConfigPackageDBs :: [Maybe PackageDB]
projectConfigInstallDirs :: InstallDirs (Flag PathTemplate)
projectConfigHaddockIndex :: Flag PathTemplate
projectConfigHcPkg :: Flag String
projectConfigHcPath :: Flag String
projectConfigHcFlavor :: Flag CompilerFlavor
projectConfigIgnoreProject :: Flag Bool
projectConfigProjectFile :: Flag String
projectConfigConfigFile :: Flag String
projectConfigDistDir :: Flag String
projectConfigProgPathExtra :: ProjectConfigShared -> NubList String
projectConfigPreferOldest :: ProjectConfigShared -> Flag PreferOldest
projectConfigIndependentGoals :: ProjectConfigShared -> Flag IndependentGoals
projectConfigPerComponent :: ProjectConfigShared -> Flag Bool
projectConfigOnlyConstrained :: ProjectConfigShared -> Flag OnlyConstrained
projectConfigAllowBootLibInstalls :: ProjectConfigShared -> Flag AllowBootLibInstalls
projectConfigStrongFlags :: ProjectConfigShared -> Flag StrongFlags
projectConfigMinimizeConflictSet :: ProjectConfigShared -> Flag MinimizeConflictSet
projectConfigFineGrainedConflicts :: ProjectConfigShared -> Flag FineGrainedConflicts
projectConfigCountConflicts :: ProjectConfigShared -> Flag CountConflicts
projectConfigReorderGoals :: ProjectConfigShared -> Flag ReorderGoals
projectConfigMaxBackjumps :: ProjectConfigShared -> Flag Int
projectConfigWriteGhcEnvironmentFilesPolicy :: ProjectConfigShared -> Flag WriteGhcEnvironmentFilesPolicy
projectConfigAllowNewer :: ProjectConfigShared -> Maybe AllowNewer
projectConfigAllowOlder :: ProjectConfigShared -> Maybe AllowOlder
projectConfigSolver :: ProjectConfigShared -> Flag PreSolver
projectConfigCabalVersion :: ProjectConfigShared -> Flag Version
projectConfigPreferences :: ProjectConfigShared -> [PackageVersionConstraint]
projectConfigConstraints :: ProjectConfigShared -> [(UserConstraint, ConstraintSource)]
projectConfigStoreDir :: ProjectConfigShared -> Flag String
projectConfigIndexState :: ProjectConfigShared -> Flag TotalIndexState
projectConfigActiveRepos :: ProjectConfigShared -> Flag ActiveRepos
projectConfigLocalNoIndexRepos :: ProjectConfigShared -> NubList LocalRepo
projectConfigRemoteRepos :: ProjectConfigShared -> NubList RemoteRepo
projectConfigPackageDBs :: ProjectConfigShared -> [Maybe PackageDB]
projectConfigInstallDirs :: ProjectConfigShared -> InstallDirs (Flag PathTemplate)
projectConfigHaddockIndex :: ProjectConfigShared -> Flag PathTemplate
projectConfigIgnoreProject :: ProjectConfigShared -> Flag Bool
projectConfigProjectFile :: ProjectConfigShared -> Flag String
projectConfigConfigFile :: ProjectConfigShared -> Flag String
projectConfigDistDir :: ProjectConfigShared -> Flag String
projectConfigHcPkg :: ProjectConfigShared -> Flag String
projectConfigHcPath :: ProjectConfigShared -> Flag String
projectConfigHcFlavor :: ProjectConfigShared -> Flag CompilerFlavor
..}
    } =

    LegacyPackageConfig {
      legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags = ConfigFlags
configFlags,
      legacyInstallPkgFlags :: InstallFlags
legacyInstallPkgFlags= forall a. Monoid a => a
mempty,
      legacyHaddockFlags :: HaddockFlags
legacyHaddockFlags   = HaddockFlags
haddockFlags,
      legacyTestFlags :: TestFlags
legacyTestFlags      = forall a. Monoid a => a
mempty,
      legacyBenchmarkFlags :: BenchmarkFlags
legacyBenchmarkFlags = forall a. Monoid a => a
mempty
    }
  where
    configFlags :: ConfigFlags
configFlags = ConfigFlags {
      configArgs :: [String]
configArgs                = forall a. Monoid a => a
mempty,
      configPrograms_ :: Option' (Last' ProgramDb)
configPrograms_           = forall a. Monoid a => a
mempty,
      configProgramPaths :: [(String, String)]
configProgramPaths        = forall a. Monoid a => a
mempty,
      configProgramArgs :: [(String, [String])]
configProgramArgs         = forall a. Monoid a => a
mempty,
      configProgramPathExtra :: NubList String
configProgramPathExtra    = forall a. Monoid a => a
mempty,
      configHcFlavor :: Flag CompilerFlavor
configHcFlavor            = Flag CompilerFlavor
projectConfigHcFlavor,
      configHcPath :: Flag String
configHcPath              = Flag String
projectConfigHcPath,
      configHcPkg :: Flag String
configHcPkg               = Flag String
projectConfigHcPkg,
      configInstantiateWith :: [(ModuleName, Module)]
configInstantiateWith     = forall a. Monoid a => a
mempty,
      configVanillaLib :: Flag Bool
configVanillaLib          = forall a. Monoid a => a
mempty,
      configProfLib :: Flag Bool
configProfLib             = forall a. Monoid a => a
mempty,
      configSharedLib :: Flag Bool
configSharedLib           = forall a. Monoid a => a
mempty,
      configStaticLib :: Flag Bool
configStaticLib           = forall a. Monoid a => a
mempty,
      configDynExe :: Flag Bool
configDynExe              = forall a. Monoid a => a
mempty,
      configFullyStaticExe :: Flag Bool
configFullyStaticExe      = forall a. Monoid a => a
mempty,
      configProfExe :: Flag Bool
configProfExe             = forall a. Monoid a => a
mempty,
      configProf :: Flag Bool
configProf                = forall a. Monoid a => a
mempty,
      configProfDetail :: Flag ProfDetailLevel
configProfDetail          = forall a. Monoid a => a
mempty,
      configProfLibDetail :: Flag ProfDetailLevel
configProfLibDetail       = forall a. Monoid a => a
mempty,
      configConfigureArgs :: [String]
configConfigureArgs       = forall a. Monoid a => a
mempty,
      configOptimization :: Flag OptimisationLevel
configOptimization        = forall a. Monoid a => a
mempty,
      configProgPrefix :: Flag PathTemplate
configProgPrefix          = forall a. Monoid a => a
mempty,
      configProgSuffix :: Flag PathTemplate
configProgSuffix          = forall a. Monoid a => a
mempty,
      configInstallDirs :: InstallDirs (Flag PathTemplate)
configInstallDirs         = InstallDirs (Flag PathTemplate)
projectConfigInstallDirs,
      configScratchDir :: Flag String
configScratchDir          = forall a. Monoid a => a
mempty,
      configDistPref :: Flag String
configDistPref            = forall a. Monoid a => a
mempty,
      configCabalFilePath :: Flag String
configCabalFilePath       = forall a. Monoid a => a
mempty,
      configVerbosity :: Flag Verbosity
configVerbosity           = forall a. Monoid a => a
mempty,
      configUserInstall :: Flag Bool
configUserInstall         = forall a. Monoid a => a
mempty, --projectConfigUserInstall,
      configPackageDBs :: [Maybe PackageDB]
configPackageDBs          = forall a. Monoid a => a
mempty,
      configGHCiLib :: Flag Bool
configGHCiLib             = forall a. Monoid a => a
mempty,
      configSplitSections :: Flag Bool
configSplitSections       = forall a. Monoid a => a
mempty,
      configSplitObjs :: Flag Bool
configSplitObjs           = forall a. Monoid a => a
mempty,
      configStripExes :: Flag Bool
configStripExes           = forall a. Monoid a => a
mempty,
      configStripLibs :: Flag Bool
configStripLibs           = forall a. Monoid a => a
mempty,
      configExtraLibDirs :: [String]
configExtraLibDirs        = forall a. Monoid a => a
mempty,
      configExtraLibDirsStatic :: [String]
configExtraLibDirsStatic  = forall a. Monoid a => a
mempty,
      configExtraFrameworkDirs :: [String]
configExtraFrameworkDirs  = forall a. Monoid a => a
mempty,
      configConstraints :: [PackageVersionConstraint]
configConstraints         = forall a. Monoid a => a
mempty,
      configDependencies :: [GivenComponent]
configDependencies        = forall a. Monoid a => a
mempty,
      configExtraIncludeDirs :: [String]
configExtraIncludeDirs    = forall a. Monoid a => a
mempty,
      configDeterministic :: Flag Bool
configDeterministic       = forall a. Monoid a => a
mempty,
      configIPID :: Flag String
configIPID                = forall a. Monoid a => a
mempty,
      configCID :: Flag ComponentId
configCID                 = forall a. Monoid a => a
mempty,
      configConfigurationsFlags :: FlagAssignment
configConfigurationsFlags = forall a. Monoid a => a
mempty,
      configTests :: Flag Bool
configTests               = forall a. Monoid a => a
mempty,
      configCoverage :: Flag Bool
configCoverage            = forall a. Monoid a => a
mempty, --TODO: don't merge
      configLibCoverage :: Flag Bool
configLibCoverage         = forall a. Monoid a => a
mempty, --TODO: don't merge
      configExactConfiguration :: Flag Bool
configExactConfiguration  = forall a. Monoid a => a
mempty,
      configBenchmarks :: Flag Bool
configBenchmarks          = forall a. Monoid a => a
mempty,
      configFlagError :: Flag String
configFlagError           = forall a. Monoid a => a
mempty,                --TODO: ???
      configRelocatable :: Flag Bool
configRelocatable         = forall a. Monoid a => a
mempty,
      configDebugInfo :: Flag DebugInfoLevel
configDebugInfo           = forall a. Monoid a => a
mempty,
      configUseResponseFiles :: Flag Bool
configUseResponseFiles    = forall a. Monoid a => a
mempty,
      configDumpBuildInfo :: Flag DumpBuildInfo
configDumpBuildInfo       = forall a. Monoid a => a
mempty,
      configAllowDependingOnPrivateLibs :: Flag Bool
configAllowDependingOnPrivateLibs = forall a. Monoid a => a
mempty
    }

    haddockFlags :: HaddockFlags
haddockFlags = forall a. Monoid a => a
mempty {
      haddockKeepTempFiles :: Flag Bool
haddockKeepTempFiles = Flag Bool
projectConfigKeepTempFiles
    }


convertToLegacyPerPackageConfig :: PackageConfig -> LegacyPackageConfig
convertToLegacyPerPackageConfig :: PackageConfig -> LegacyPackageConfig
convertToLegacyPerPackageConfig PackageConfig {[String]
[PathTemplate]
NubList String
Flag Bool
Flag String
Flag HaddockTarget
Flag TestShowDetails
Flag OptimisationLevel
Flag DebugInfoLevel
Flag ProfDetailLevel
Flag DumpBuildInfo
Flag PathTemplate
FlagAssignment
MapMappend String [String]
MapLast String String
packageConfigBenchmarkOptions :: [PathTemplate]
packageConfigTestTestOptions :: [PathTemplate]
packageConfigTestFailWhenNoTestSuites :: Flag Bool
packageConfigTestWrapper :: Flag String
packageConfigTestKeepTix :: Flag Bool
packageConfigTestShowDetails :: Flag TestShowDetails
packageConfigTestMachineLog :: Flag PathTemplate
packageConfigTestHumanLog :: Flag PathTemplate
packageConfigHaddockForHackage :: Flag HaddockTarget
packageConfigHaddockLib :: Flag String
packageConfigHaddockBaseUrl :: Flag String
packageConfigHaddockIndex :: Flag PathTemplate
packageConfigHaddockContents :: Flag PathTemplate
packageConfigHaddockHscolourCss :: Flag String
packageConfigHaddockQuickJump :: Flag Bool
packageConfigHaddockLinkedSource :: Flag Bool
packageConfigHaddockCss :: Flag String
packageConfigHaddockInternal :: Flag Bool
packageConfigHaddockBenchmarks :: Flag Bool
packageConfigHaddockTestSuites :: Flag Bool
packageConfigHaddockExecutables :: Flag Bool
packageConfigHaddockForeignLibs :: Flag Bool
packageConfigHaddockHtmlLocation :: Flag String
packageConfigHaddockHtml :: Flag Bool
packageConfigHaddockHoogle :: Flag Bool
packageConfigDocumentation :: Flag Bool
packageConfigRunTests :: Flag Bool
packageConfigDumpBuildInfo :: Flag DumpBuildInfo
packageConfigDebugInfo :: Flag DebugInfoLevel
packageConfigRelocatable :: Flag Bool
packageConfigCoverage :: Flag Bool
packageConfigBenchmarks :: Flag Bool
packageConfigTests :: Flag Bool
packageConfigStripLibs :: Flag Bool
packageConfigStripExes :: Flag Bool
packageConfigSplitObjs :: Flag Bool
packageConfigSplitSections :: Flag Bool
packageConfigGHCiLib :: Flag Bool
packageConfigExtraIncludeDirs :: [String]
packageConfigExtraFrameworkDirs :: [String]
packageConfigExtraLibDirsStatic :: [String]
packageConfigExtraLibDirs :: [String]
packageConfigProgSuffix :: Flag PathTemplate
packageConfigProgPrefix :: Flag PathTemplate
packageConfigOptimization :: Flag OptimisationLevel
packageConfigConfigureArgs :: [String]
packageConfigProfLibDetail :: Flag ProfDetailLevel
packageConfigProfDetail :: Flag ProfDetailLevel
packageConfigProfExe :: Flag Bool
packageConfigProfLib :: Flag Bool
packageConfigProf :: Flag Bool
packageConfigFullyStaticExe :: Flag Bool
packageConfigDynExe :: Flag Bool
packageConfigStaticLib :: Flag Bool
packageConfigSharedLib :: Flag Bool
packageConfigVanillaLib :: Flag Bool
packageConfigFlagAssignment :: FlagAssignment
packageConfigProgramPathExtra :: NubList String
packageConfigProgramArgs :: MapMappend String [String]
packageConfigProgramPaths :: MapLast String String
packageConfigBenchmarkOptions :: PackageConfig -> [PathTemplate]
packageConfigTestTestOptions :: PackageConfig -> [PathTemplate]
packageConfigTestFailWhenNoTestSuites :: PackageConfig -> Flag Bool
packageConfigTestWrapper :: PackageConfig -> Flag String
packageConfigTestKeepTix :: PackageConfig -> Flag Bool
packageConfigTestShowDetails :: PackageConfig -> Flag TestShowDetails
packageConfigTestMachineLog :: PackageConfig -> Flag PathTemplate
packageConfigTestHumanLog :: PackageConfig -> Flag PathTemplate
packageConfigHaddockForHackage :: PackageConfig -> Flag HaddockTarget
packageConfigHaddockLib :: PackageConfig -> Flag String
packageConfigHaddockBaseUrl :: PackageConfig -> Flag String
packageConfigHaddockIndex :: PackageConfig -> Flag PathTemplate
packageConfigHaddockContents :: PackageConfig -> Flag PathTemplate
packageConfigHaddockHscolourCss :: PackageConfig -> Flag String
packageConfigHaddockCss :: PackageConfig -> Flag String
packageConfigHaddockBenchmarks :: PackageConfig -> Flag Bool
packageConfigHaddockTestSuites :: PackageConfig -> Flag Bool
packageConfigHaddockExecutables :: PackageConfig -> Flag Bool
packageConfigHaddockForeignLibs :: PackageConfig -> Flag Bool
packageConfigHaddockHtmlLocation :: PackageConfig -> Flag String
packageConfigRunTests :: PackageConfig -> Flag Bool
packageConfigDumpBuildInfo :: PackageConfig -> Flag DumpBuildInfo
packageConfigDebugInfo :: PackageConfig -> Flag DebugInfoLevel
packageConfigRelocatable :: PackageConfig -> Flag Bool
packageConfigCoverage :: PackageConfig -> Flag Bool
packageConfigBenchmarks :: PackageConfig -> Flag Bool
packageConfigTests :: PackageConfig -> Flag Bool
packageConfigStripLibs :: PackageConfig -> Flag Bool
packageConfigStripExes :: PackageConfig -> Flag Bool
packageConfigSplitObjs :: PackageConfig -> Flag Bool
packageConfigSplitSections :: PackageConfig -> Flag Bool
packageConfigGHCiLib :: PackageConfig -> Flag Bool
packageConfigExtraIncludeDirs :: PackageConfig -> [String]
packageConfigExtraFrameworkDirs :: PackageConfig -> [String]
packageConfigExtraLibDirsStatic :: PackageConfig -> [String]
packageConfigExtraLibDirs :: PackageConfig -> [String]
packageConfigProgSuffix :: PackageConfig -> Flag PathTemplate
packageConfigProgPrefix :: PackageConfig -> Flag PathTemplate
packageConfigOptimization :: PackageConfig -> Flag OptimisationLevel
packageConfigConfigureArgs :: PackageConfig -> [String]
packageConfigProfLibDetail :: PackageConfig -> Flag ProfDetailLevel
packageConfigProfDetail :: PackageConfig -> Flag ProfDetailLevel
packageConfigProfExe :: PackageConfig -> Flag Bool
packageConfigProfLib :: PackageConfig -> Flag Bool
packageConfigProf :: PackageConfig -> Flag Bool
packageConfigFullyStaticExe :: PackageConfig -> Flag Bool
packageConfigDynExe :: PackageConfig -> Flag Bool
packageConfigStaticLib :: PackageConfig -> Flag Bool
packageConfigSharedLib :: PackageConfig -> Flag Bool
packageConfigVanillaLib :: PackageConfig -> Flag Bool
packageConfigFlagAssignment :: PackageConfig -> FlagAssignment
packageConfigProgramArgs :: PackageConfig -> MapMappend String [String]
packageConfigHaddockLinkedSource :: PackageConfig -> Flag Bool
packageConfigHaddockQuickJump :: PackageConfig -> Flag Bool
packageConfigHaddockInternal :: PackageConfig -> Flag Bool
packageConfigHaddockHtml :: PackageConfig -> Flag Bool
packageConfigHaddockHoogle :: PackageConfig -> Flag Bool
packageConfigDocumentation :: PackageConfig -> Flag Bool
packageConfigProgramPathExtra :: PackageConfig -> NubList String
packageConfigProgramPaths :: PackageConfig -> MapLast String String
..} =
    LegacyPackageConfig {
      legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags  = ConfigFlags
configFlags,
      legacyInstallPkgFlags :: InstallFlags
legacyInstallPkgFlags = InstallFlags
installFlags,
      legacyHaddockFlags :: HaddockFlags
legacyHaddockFlags    = HaddockFlags
haddockFlags,
      legacyTestFlags :: TestFlags
legacyTestFlags       = TestFlags
testFlags,
      legacyBenchmarkFlags :: BenchmarkFlags
legacyBenchmarkFlags  = BenchmarkFlags
benchmarkFlags
    }
  where
    configFlags :: ConfigFlags
configFlags = ConfigFlags {
      configArgs :: [String]
configArgs                = forall a. Monoid a => a
mempty,
      configPrograms_ :: Option' (Last' ProgramDb)
configPrograms_           = ConfigFlags -> Option' (Last' ProgramDb)
configPrograms_ forall a. Monoid a => a
mempty,
      configProgramPaths :: [(String, String)]
configProgramPaths        = forall k a. Map k a -> [(k, a)]
Map.toList (forall k v. MapLast k v -> Map k v
getMapLast MapLast String String
packageConfigProgramPaths),
      configProgramArgs :: [(String, [String])]
configProgramArgs         = forall k a. Map k a -> [(k, a)]
Map.toList (forall k v. MapMappend k v -> Map k v
getMapMappend MapMappend String [String]
packageConfigProgramArgs),
      configProgramPathExtra :: NubList String
configProgramPathExtra    = NubList String
packageConfigProgramPathExtra,
      configHcFlavor :: Flag CompilerFlavor
configHcFlavor            = forall a. Monoid a => a
mempty,
      configHcPath :: Flag String
configHcPath              = forall a. Monoid a => a
mempty,
      configHcPkg :: Flag String
configHcPkg               = forall a. Monoid a => a
mempty,
      configInstantiateWith :: [(ModuleName, Module)]
configInstantiateWith     = forall a. Monoid a => a
mempty,
      configVanillaLib :: Flag Bool
configVanillaLib          = Flag Bool
packageConfigVanillaLib,
      configProfLib :: Flag Bool
configProfLib             = Flag Bool
packageConfigProfLib,
      configSharedLib :: Flag Bool
configSharedLib           = Flag Bool
packageConfigSharedLib,
      configStaticLib :: Flag Bool
configStaticLib           = Flag Bool
packageConfigStaticLib,
      configDynExe :: Flag Bool
configDynExe              = Flag Bool
packageConfigDynExe,
      configFullyStaticExe :: Flag Bool
configFullyStaticExe      = Flag Bool
packageConfigFullyStaticExe,
      configProfExe :: Flag Bool
configProfExe             = Flag Bool
packageConfigProfExe,
      configProf :: Flag Bool
configProf                = Flag Bool
packageConfigProf,
      configProfDetail :: Flag ProfDetailLevel
configProfDetail          = Flag ProfDetailLevel
packageConfigProfDetail,
      configProfLibDetail :: Flag ProfDetailLevel
configProfLibDetail       = Flag ProfDetailLevel
packageConfigProfLibDetail,
      configConfigureArgs :: [String]
configConfigureArgs       = [String]
packageConfigConfigureArgs,
      configOptimization :: Flag OptimisationLevel
configOptimization        = Flag OptimisationLevel
packageConfigOptimization,
      configProgPrefix :: Flag PathTemplate
configProgPrefix          = Flag PathTemplate
packageConfigProgPrefix,
      configProgSuffix :: Flag PathTemplate
configProgSuffix          = Flag PathTemplate
packageConfigProgSuffix,
      configInstallDirs :: InstallDirs (Flag PathTemplate)
configInstallDirs         = forall a. Monoid a => a
mempty,
      configScratchDir :: Flag String
configScratchDir          = forall a. Monoid a => a
mempty,
      configDistPref :: Flag String
configDistPref            = forall a. Monoid a => a
mempty,
      configCabalFilePath :: Flag String
configCabalFilePath       = forall a. Monoid a => a
mempty,
      configVerbosity :: Flag Verbosity
configVerbosity           = forall a. Monoid a => a
mempty,
      configUserInstall :: Flag Bool
configUserInstall         = forall a. Monoid a => a
mempty,
      configPackageDBs :: [Maybe PackageDB]
configPackageDBs          = forall a. Monoid a => a
mempty,
      configGHCiLib :: Flag Bool
configGHCiLib             = Flag Bool
packageConfigGHCiLib,
      configSplitSections :: Flag Bool
configSplitSections       = Flag Bool
packageConfigSplitSections,
      configSplitObjs :: Flag Bool
configSplitObjs           = Flag Bool
packageConfigSplitObjs,
      configStripExes :: Flag Bool
configStripExes           = Flag Bool
packageConfigStripExes,
      configStripLibs :: Flag Bool
configStripLibs           = Flag Bool
packageConfigStripLibs,
      configExtraLibDirs :: [String]
configExtraLibDirs        = [String]
packageConfigExtraLibDirs,
      configExtraLibDirsStatic :: [String]
configExtraLibDirsStatic  = [String]
packageConfigExtraLibDirsStatic,
      configExtraFrameworkDirs :: [String]
configExtraFrameworkDirs  = [String]
packageConfigExtraFrameworkDirs,
      configConstraints :: [PackageVersionConstraint]
configConstraints         = forall a. Monoid a => a
mempty,
      configDependencies :: [GivenComponent]
configDependencies        = forall a. Monoid a => a
mempty,
      configExtraIncludeDirs :: [String]
configExtraIncludeDirs    = [String]
packageConfigExtraIncludeDirs,
      configIPID :: Flag String
configIPID                = forall a. Monoid a => a
mempty,
      configCID :: Flag ComponentId
configCID                 = forall a. Monoid a => a
mempty,
      configDeterministic :: Flag Bool
configDeterministic       = forall a. Monoid a => a
mempty,
      configConfigurationsFlags :: FlagAssignment
configConfigurationsFlags = FlagAssignment
packageConfigFlagAssignment,
      configTests :: Flag Bool
configTests               = Flag Bool
packageConfigTests,
      configCoverage :: Flag Bool
configCoverage            = Flag Bool
packageConfigCoverage, --TODO: don't merge
      configLibCoverage :: Flag Bool
configLibCoverage         = Flag Bool
packageConfigCoverage, --TODO: don't merge
      configExactConfiguration :: Flag Bool
configExactConfiguration  = forall a. Monoid a => a
mempty,
      configBenchmarks :: Flag Bool
configBenchmarks          = Flag Bool
packageConfigBenchmarks,
      configFlagError :: Flag String
configFlagError           = forall a. Monoid a => a
mempty,                --TODO: ???
      configRelocatable :: Flag Bool
configRelocatable         = Flag Bool
packageConfigRelocatable,
      configDebugInfo :: Flag DebugInfoLevel
configDebugInfo           = Flag DebugInfoLevel
packageConfigDebugInfo,
      configUseResponseFiles :: Flag Bool
configUseResponseFiles    = forall a. Monoid a => a
mempty,
      configDumpBuildInfo :: Flag DumpBuildInfo
configDumpBuildInfo       = Flag DumpBuildInfo
packageConfigDumpBuildInfo,
      configAllowDependingOnPrivateLibs :: Flag Bool
configAllowDependingOnPrivateLibs = forall a. Monoid a => a
mempty
    }

    installFlags :: InstallFlags
installFlags = forall a. Monoid a => a
mempty {
      installDocumentation :: Flag Bool
installDocumentation      = Flag Bool
packageConfigDocumentation,
      installRunTests :: Flag Bool
installRunTests           = Flag Bool
packageConfigRunTests
    }

    haddockFlags :: HaddockFlags
haddockFlags = HaddockFlags {
      haddockProgramPaths :: [(String, String)]
haddockProgramPaths  = forall a. Monoid a => a
mempty,
      haddockProgramArgs :: [(String, [String])]
haddockProgramArgs   = forall a. Monoid a => a
mempty,
      haddockHoogle :: Flag Bool
haddockHoogle        = Flag Bool
packageConfigHaddockHoogle,
      haddockHtml :: Flag Bool
haddockHtml          = Flag Bool
packageConfigHaddockHtml,
      haddockHtmlLocation :: Flag String
haddockHtmlLocation  = Flag String
packageConfigHaddockHtmlLocation,
      haddockForHackage :: Flag HaddockTarget
haddockForHackage    = Flag HaddockTarget
packageConfigHaddockForHackage,
      haddockForeignLibs :: Flag Bool
haddockForeignLibs   = Flag Bool
packageConfigHaddockForeignLibs,
      haddockExecutables :: Flag Bool
haddockExecutables   = Flag Bool
packageConfigHaddockExecutables,
      haddockTestSuites :: Flag Bool
haddockTestSuites    = Flag Bool
packageConfigHaddockTestSuites,
      haddockBenchmarks :: Flag Bool
haddockBenchmarks    = Flag Bool
packageConfigHaddockBenchmarks,
      haddockInternal :: Flag Bool
haddockInternal      = Flag Bool
packageConfigHaddockInternal,
      haddockCss :: Flag String
haddockCss           = Flag String
packageConfigHaddockCss,
      haddockLinkedSource :: Flag Bool
haddockLinkedSource  = Flag Bool
packageConfigHaddockLinkedSource,
      haddockQuickJump :: Flag Bool
haddockQuickJump     = Flag Bool
packageConfigHaddockQuickJump,
      haddockHscolourCss :: Flag String
haddockHscolourCss   = Flag String
packageConfigHaddockHscolourCss,
      haddockContents :: Flag PathTemplate
haddockContents      = Flag PathTemplate
packageConfigHaddockContents,
      haddockDistPref :: Flag String
haddockDistPref      = forall a. Monoid a => a
mempty,
      haddockKeepTempFiles :: Flag Bool
haddockKeepTempFiles = forall a. Monoid a => a
mempty,
      haddockVerbosity :: Flag Verbosity
haddockVerbosity     = forall a. Monoid a => a
mempty,
      haddockCabalFilePath :: Flag String
haddockCabalFilePath = forall a. Monoid a => a
mempty,
      haddockIndex :: Flag PathTemplate
haddockIndex         = Flag PathTemplate
packageConfigHaddockIndex,
      haddockBaseUrl :: Flag String
haddockBaseUrl       = Flag String
packageConfigHaddockBaseUrl,
      haddockLib :: Flag String
haddockLib           = Flag String
packageConfigHaddockLib,
      haddockArgs :: [String]
haddockArgs          = forall a. Monoid a => a
mempty
    }

    testFlags :: TestFlags
testFlags = TestFlags {
      testDistPref :: Flag String
testDistPref    = forall a. Monoid a => a
mempty,
      testVerbosity :: Flag Verbosity
testVerbosity   = forall a. Monoid a => a
mempty,
      testHumanLog :: Flag PathTemplate
testHumanLog    = Flag PathTemplate
packageConfigTestHumanLog,
      testMachineLog :: Flag PathTemplate
testMachineLog  = Flag PathTemplate
packageConfigTestMachineLog,
      testShowDetails :: Flag TestShowDetails
testShowDetails = Flag TestShowDetails
packageConfigTestShowDetails,
      testKeepTix :: Flag Bool
testKeepTix     = Flag Bool
packageConfigTestKeepTix,
      testWrapper :: Flag String
testWrapper     = Flag String
packageConfigTestWrapper,
      testFailWhenNoTestSuites :: Flag Bool
testFailWhenNoTestSuites = Flag Bool
packageConfigTestFailWhenNoTestSuites,
      testOptions :: [PathTemplate]
testOptions     = [PathTemplate]
packageConfigTestTestOptions
    }

    benchmarkFlags :: BenchmarkFlags
benchmarkFlags = BenchmarkFlags {
      benchmarkDistPref :: Flag String
benchmarkDistPref  = forall a. Monoid a => a
mempty,
      benchmarkVerbosity :: Flag Verbosity
benchmarkVerbosity = forall a. Monoid a => a
mempty,
      benchmarkOptions :: [PathTemplate]
benchmarkOptions   = [PathTemplate]
packageConfigBenchmarkOptions
    }

------------------------------------------------
-- Parsing and showing the project config file
--

parseLegacyProjectConfigFields :: FilePath -> [ParseUtils.Field] -> ParseResult LegacyProjectConfig
parseLegacyProjectConfigFields :: String -> [Field] -> ParseResult LegacyProjectConfig
parseLegacyProjectConfigFields String
source =
    forall a.
[FieldDescr a]
-> [SectionDescr a]
-> [FGSectionDescr ParsecFieldGrammar a]
-> a
-> [Field]
-> ParseResult a
parseFieldsAndSections (ConstraintSource -> [FieldDescr LegacyProjectConfig]
legacyProjectConfigFieldDescrs ConstraintSource
constraintSrc)
                [SectionDescr LegacyProjectConfig]
legacyPackageConfigSectionDescrs
                forall (c :: * -> Constraint) (g :: * -> * -> *).
(FieldGrammar c g, Applicative (g SourceRepoList),
 c (Identity RepoType), c (List NoCommaFSep FilePathNT String),
 c (NonEmpty' NoCommaFSep Token String)) =>
[FGSectionDescr g LegacyProjectConfig]
legacyPackageConfigFGSectionDescrs
                forall a. Monoid a => a
mempty
  where
    constraintSrc :: ConstraintSource
constraintSrc = String -> ConstraintSource
ConstraintSourceProjectConfig String
source

parseLegacyProjectConfig :: FilePath -> BS.ByteString -> ParseResult LegacyProjectConfig
parseLegacyProjectConfig :: String -> ByteString -> ParseResult LegacyProjectConfig
parseLegacyProjectConfig String
source ByteString
bs = String -> [Field] -> ParseResult LegacyProjectConfig
parseLegacyProjectConfigFields String
source forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ByteString -> ParseResult [Field]
ParseUtils.readFields ByteString
bs

showLegacyProjectConfig :: LegacyProjectConfig -> String
showLegacyProjectConfig :: LegacyProjectConfig -> String
showLegacyProjectConfig LegacyProjectConfig
config =
    Doc -> String
Disp.render forall a b. (a -> b) -> a -> b
$
    forall a.
[FieldDescr a]
-> [SectionDescr a]
-> [FGSectionDescr PrettyFieldGrammar a]
-> a
-> Doc
showConfig  (ConstraintSource -> [FieldDescr LegacyProjectConfig]
legacyProjectConfigFieldDescrs ConstraintSource
constraintSrc)
                [SectionDescr LegacyProjectConfig]
legacyPackageConfigSectionDescrs
                forall (c :: * -> Constraint) (g :: * -> * -> *).
(FieldGrammar c g, Applicative (g SourceRepoList),
 c (Identity RepoType), c (List NoCommaFSep FilePathNT String),
 c (NonEmpty' NoCommaFSep Token String)) =>
[FGSectionDescr g LegacyProjectConfig]
legacyPackageConfigFGSectionDescrs
                LegacyProjectConfig
config
  Doc -> Doc -> Doc
$+$
    String -> Doc
Disp.text String
""
  where
    -- Note: ConstraintSource is unused when pretty-printing. We fake
    -- it here to avoid having to pass it on call-sites. It's not great
    -- but requires re-work of how we annotate provenance.
    constraintSrc :: ConstraintSource
constraintSrc = String -> ConstraintSource
ConstraintSourceProjectConfig String
"unused"


legacyProjectConfigFieldDescrs :: ConstraintSource -> [FieldDescr LegacyProjectConfig]
legacyProjectConfigFieldDescrs :: ConstraintSource -> [FieldDescr LegacyProjectConfig]
legacyProjectConfigFieldDescrs ConstraintSource
constraintSrc =

    [ forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"packages"
        (String -> Doc
Disp.text forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
renderPackageLocationToken) forall r. ReadP r String
parsePackageLocationTokenQ
        LegacyProjectConfig -> [String]
legacyPackages
        (\[String]
v LegacyProjectConfig
flags -> LegacyProjectConfig
flags { legacyPackages :: [String]
legacyPackages = [String]
v })
    , forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"optional-packages"
        (String -> Doc
Disp.text forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
renderPackageLocationToken) forall r. ReadP r String
parsePackageLocationTokenQ
        LegacyProjectConfig -> [String]
legacyPackagesOptional
        (\[String]
v LegacyProjectConfig
flags -> LegacyProjectConfig
flags { legacyPackagesOptional :: [String]
legacyPackagesOptional = [String]
v })
    , forall a b.
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
commaNewLineListFieldParsec String
"extra-packages"
        forall a. Pretty a => a -> Doc
pretty forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec
        LegacyProjectConfig -> [PackageVersionConstraint]
legacyPackagesNamed
        (\[PackageVersionConstraint]
v LegacyProjectConfig
flags -> LegacyProjectConfig
flags { legacyPackagesNamed :: [PackageVersionConstraint]
legacyPackagesNamed = [PackageVersionConstraint]
v })
    ]

 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall b a.
(b -> a) -> (a -> b -> b) -> FieldDescr a -> FieldDescr b
liftField
           LegacyProjectConfig -> LegacySharedConfig
legacySharedConfig
           (\LegacySharedConfig
flags LegacyProjectConfig
conf -> LegacyProjectConfig
conf { legacySharedConfig :: LegacySharedConfig
legacySharedConfig = LegacySharedConfig
flags }))
        (ConstraintSource -> [FieldDescr LegacySharedConfig]
legacySharedConfigFieldDescrs ConstraintSource
constraintSrc)

 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall b a.
(b -> a) -> (a -> b -> b) -> FieldDescr a -> FieldDescr b
liftField
           LegacyProjectConfig -> LegacyPackageConfig
legacyLocalConfig
           (\LegacyPackageConfig
flags LegacyProjectConfig
conf -> LegacyProjectConfig
conf { legacyLocalConfig :: LegacyPackageConfig
legacyLocalConfig = LegacyPackageConfig
flags }))
        [FieldDescr LegacyPackageConfig]
legacyPackageConfigFieldDescrs

-- | This is a bit tricky since it has to cover globs which have embedded @,@
-- chars. But we don't just want to parse strictly as a glob since we want to
-- allow http urls which don't parse as globs, and possibly some
-- system-dependent file paths. So we parse fairly liberally as a token, but
-- we allow @,@ inside matched @{}@ braces.
--
parsePackageLocationTokenQ :: ReadP r String
parsePackageLocationTokenQ :: forall r. ReadP r String
parsePackageLocationTokenQ = forall r. ReadP r String
parseHaskellString
                   forall a r. ReadP a a -> ReadP r a -> ReadP r a
Parse.<++ forall r. ReadP r String
parsePackageLocationToken
  where
    parsePackageLocationToken :: ReadP r String
    parsePackageLocationToken :: forall r. ReadP r String
parsePackageLocationToken = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> a
fst (forall r a. ReadP (String -> P Char r) a -> ReadP r (String, a)
Parse.gather forall {r}. ReadP r ()
outerTerm)
      where
        outerTerm :: ReadP r ()
outerTerm   = forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternateEither1 forall {r}. ReadP r ()
outerToken (forall {r} {a}. ReadP r a -> ReadP r a
braces forall {r}. ReadP r ()
innerTerm)
        innerTerm :: ReadP r ()
innerTerm   = forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternateEither  forall {r}. ReadP r ()
innerToken (forall {r} {a}. ReadP r a -> ReadP r a
braces ReadP r ()
innerTerm)
        outerToken :: Parser r Char ()
outerToken  = forall r. (Char -> Bool) -> ReadP r String
Parse.munch1 Char -> Bool
outerChar forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
        innerToken :: Parser r Char ()
innerToken  = forall r. (Char -> Bool) -> ReadP r String
Parse.munch1 Char -> Bool
innerChar forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
        outerChar :: Char -> Bool
outerChar Char
c = Bool -> Bool
not (Char -> Bool
isSpace Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'{' Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'}' Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
',')
        innerChar :: Char -> Bool
innerChar Char
c = Bool -> Bool
not (Char -> Bool
isSpace Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'{' Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'}')
        braces :: ReadP r a -> ReadP r a
braces      = forall r open close a.
ReadP r open -> ReadP r close -> ReadP r a -> ReadP r a
Parse.between (forall r. Char -> ReadP r Char
Parse.char Char
'{') (forall r. Char -> ReadP r Char
Parse.char Char
'}')

    alternateEither, alternateEither1,
      alternatePQs, alternate1PQs, alternateQsP, alternate1QsP
      :: ReadP r () -> ReadP r () -> ReadP r ()

    alternateEither1 :: forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternateEither1 ReadP r ()
p ReadP r ()
q = forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternate1PQs ReadP r ()
p ReadP r ()
q forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternate1QsP ReadP r ()
q ReadP r ()
p
    alternateEither :: forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternateEither  ReadP r ()
p ReadP r ()
q = forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternateEither1 ReadP r ()
p ReadP r ()
q forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ forall (m :: * -> *) a. Monad m => a -> m a
return ()
    alternate1PQs :: forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternate1PQs    ReadP r ()
p ReadP r ()
q = ReadP r ()
p forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternateQsP ReadP r ()
q ReadP r ()
p
    alternatePQs :: forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternatePQs     ReadP r ()
p ReadP r ()
q = forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternate1PQs ReadP r ()
p ReadP r ()
q forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ forall (m :: * -> *) a. Monad m => a -> m a
return ()
    alternate1QsP :: forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternate1QsP    ReadP r ()
q ReadP r ()
p = forall r a. ReadP r a -> ReadP r [a]
Parse.many1 ReadP r ()
q forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternatePQs ReadP r ()
p ReadP r ()
q
    alternateQsP :: forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternateQsP     ReadP r ()
q ReadP r ()
p = forall r. ReadP r () -> ReadP r () -> ReadP r ()
alternate1QsP ReadP r ()
q ReadP r ()
p forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ forall (m :: * -> *) a. Monad m => a -> m a
return ()

renderPackageLocationToken :: String -> String
renderPackageLocationToken :: String -> String
renderPackageLocationToken String
s | Bool
needsQuoting = forall a. Show a => a -> String
show String
s
                             | Bool
otherwise    = String
s
  where
    needsQuoting :: Bool
needsQuoting  = Bool -> Bool
not (Int -> String -> Bool
ok Int
0 String
s)
                 Bool -> Bool -> Bool
|| String
s forall a. Eq a => a -> a -> Bool
== String
"." -- . on its own on a line has special meaning
                 Bool -> Bool -> Bool
|| forall a. Int -> [a] -> [a]
take Int
2 String
s forall a. Eq a => a -> a -> Bool
== String
"--" -- on its own line is comment syntax
                 --TODO: [code cleanup] these "." and "--" escaping issues
                 -- ought to be dealt with systematically in ParseUtils.
    ok :: Int -> String -> Bool
    ok :: Int -> String -> Bool
ok Int
n []       = Int
n forall a. Eq a => a -> a -> Bool
== Int
0
    ok Int
_ (Char
'"':String
_)  = Bool
False
    ok Int
n (Char
'{':String
cs) = Int -> String -> Bool
ok (Int
nforall a. Num a => a -> a -> a
+Int
1) String
cs
    ok Int
n (Char
'}':String
cs) = Int -> String -> Bool
ok (Int
nforall a. Num a => a -> a -> a
-Int
1) String
cs
    ok Int
n (Char
',':String
cs) = (Int
n forall a. Ord a => a -> a -> Bool
> Int
0) Bool -> Bool -> Bool
&& Int -> String -> Bool
ok Int
n String
cs
    ok Int
_ (Char
c:String
_)
      | Char -> Bool
isSpace Char
c = Bool
False
    ok Int
n (Char
_  :String
cs) = Int -> String -> Bool
ok Int
n String
cs


legacySharedConfigFieldDescrs :: ConstraintSource -> [FieldDescr LegacySharedConfig]
legacySharedConfigFieldDescrs :: ConstraintSource -> [FieldDescr LegacySharedConfig]
legacySharedConfigFieldDescrs ConstraintSource
constraintSrc = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
  [ forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacySharedConfig -> GlobalFlags
legacyGlobalFlags
      (\GlobalFlags
flags LegacySharedConfig
conf -> LegacySharedConfig
conf { legacyGlobalFlags :: GlobalFlags
legacyGlobalFlags = GlobalFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"extra-prog-path-shared-only"
          String -> Doc
showTokenQ forall r. ReadP r String
parseTokenQ
          (forall a. NubList a -> [a]
fromNubList forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalFlags -> NubList String
globalProgPathExtra)
          (\[String]
v GlobalFlags
conf -> GlobalFlags
conf { globalProgPathExtra :: NubList String
globalProgPathExtra = forall a. Ord a => [a] -> NubList a
toNubList [String]
v })
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      [ String
"remote-repo-cache"
      , String
"logs-dir", String
"store-dir", String
"ignore-expiry", String
"http-transport"
      , String
"active-repositories"
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  forall a b. (a -> b) -> a -> b
$ forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions (forall action. [Command action] -> CommandUI GlobalFlags
globalCommand []) ShowOrParseArgs
ParseArgs

  , forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacySharedConfig -> ConfigFlags
legacyConfigureShFlags
      (\ConfigFlags
flags LegacySharedConfig
conf -> LegacySharedConfig
conf { legacyConfigureShFlags :: ConfigFlags
legacyConfigureShFlags = ConfigFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
commaNewLineListFieldParsec String
"package-dbs"
        (String -> Doc
Disp.text forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe PackageDB -> String
showPackageDb) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Maybe PackageDB
readPackageDb forall (m :: * -> *). CabalParsing m => m String
parsecToken)
        ConfigFlags -> [Maybe PackageDB]
configPackageDBs (\[Maybe PackageDB]
v ConfigFlags
conf -> ConfigFlags
conf { configPackageDBs :: [Maybe PackageDB]
configPackageDBs = [Maybe PackageDB]
v })
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields ([String
"verbose", String
"builddir"] forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map forall a. OptionField a -> String
optionName [OptionField (InstallDirs (Flag PathTemplate))]
installDirsOptions)
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  forall a b. (a -> b) -> a -> b
$ ShowOrParseArgs -> [OptionField ConfigFlags]
configureOptions ShowOrParseArgs
ParseArgs

  , forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacySharedConfig -> ConfigExFlags
legacyConfigureExFlags
      (\ConfigExFlags
flags LegacySharedConfig
conf -> LegacySharedConfig
conf { legacyConfigureExFlags :: ConfigExFlags
legacyConfigureExFlags = ConfigExFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
commaNewLineListFieldParsec String
"constraints"
        (forall a. Pretty a => a -> Doc
pretty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\UserConstraint
constraint -> (UserConstraint
constraint, ConstraintSource
constraintSrc)) forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec)
        ConfigExFlags -> [(UserConstraint, ConstraintSource)]
configExConstraints (\[(UserConstraint, ConstraintSource)]
v ConfigExFlags
conf -> ConfigExFlags
conf { configExConstraints :: [(UserConstraint, ConstraintSource)]
configExConstraints = [(UserConstraint, ConstraintSource)]
v })

      , forall a b.
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
commaNewLineListFieldParsec String
"preferences"
        forall a. Pretty a => a -> Doc
pretty forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec
        ConfigExFlags -> [PackageVersionConstraint]
configPreferences (\[PackageVersionConstraint]
v ConfigExFlags
conf -> ConfigExFlags
conf { configPreferences :: [PackageVersionConstraint]
configPreferences = [PackageVersionConstraint]
v })

      , forall a b.
Monoid a =>
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> a)
-> (a -> b -> b)
-> FieldDescr b
monoidFieldParsec String
"allow-older"
        (forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Monoid a => a
mempty forall a. Pretty a => a -> Doc
pretty) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec)
        (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AllowOlder -> RelaxDeps
unAllowOlder forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConfigExFlags -> Maybe AllowOlder
configAllowOlder)
        (\Maybe RelaxDeps
v ConfigExFlags
conf -> ConfigExFlags
conf { configAllowOlder :: Maybe AllowOlder
configAllowOlder = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RelaxDeps -> AllowOlder
AllowOlder Maybe RelaxDeps
v })

      , forall a b.
Monoid a =>
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> a)
-> (a -> b -> b)
-> FieldDescr b
monoidFieldParsec String
"allow-newer"
        (forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Monoid a => a
mempty forall a. Pretty a => a -> Doc
pretty) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec)
        (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AllowNewer -> RelaxDeps
unAllowNewer forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConfigExFlags -> Maybe AllowNewer
configAllowNewer)
        (\Maybe RelaxDeps
v ConfigExFlags
conf -> ConfigExFlags
conf { configAllowNewer :: Maybe AllowNewer
configAllowNewer = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RelaxDeps -> AllowNewer
AllowNewer Maybe RelaxDeps
v })
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      [ String
"cabal-lib-version", String
"solver", String
"write-ghc-environment-files"
        -- not "constraint" or "preference", we use our own plural ones above
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  forall a b. (a -> b) -> a -> b
$ ShowOrParseArgs -> ConstraintSource -> [OptionField ConfigExFlags]
configureExOptions ShowOrParseArgs
ParseArgs ConstraintSource
constraintSrc

  , forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacySharedConfig -> InstallFlags
legacyInstallFlags
      (\InstallFlags
flags LegacySharedConfig
conf -> LegacySharedConfig
conf { legacyInstallFlags :: InstallFlags
legacyInstallFlags = InstallFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"build-summary"
          (String -> Doc
showTokenQ forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTemplate -> String
fromPathTemplate) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> PathTemplate
toPathTemplate forall r. ReadP r String
parseTokenQ)
          (forall a. NubList a -> [a]
fromNubList forall b c a. (b -> c) -> (a -> b) -> a -> c
. InstallFlags -> NubList PathTemplate
installSummaryFile)
          (\[PathTemplate]
v InstallFlags
conf -> InstallFlags
conf { installSummaryFile :: NubList PathTemplate
installSummaryFile = forall a. Ord a => [a] -> NubList a
toNubList [PathTemplate]
v })
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      [ String
"doc-index-file"
      , String
"root-cmd", String
"symlink-bindir"
      , String
"build-log"
      , String
"remote-build-reporting", String
"report-planning-failure"
      , String
"jobs", String
"keep-going", String
"offline", String
"per-component"
        -- solver flags:
      , String
"max-backjumps", String
"reorder-goals", String
"count-conflicts"
      , String
"fine-grained-conflicts" , String
"minimize-conflict-set", String
"independent-goals", String
"prefer-oldest"
      , String
"strong-flags" , String
"allow-boot-library-installs"
      , String
"reject-unconstrained-dependencies", String
"index-state"
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  forall a b. (a -> b) -> a -> b
$ ShowOrParseArgs -> [OptionField InstallFlags]
installOptions ShowOrParseArgs
ParseArgs

  , forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacySharedConfig -> ClientInstallFlags
legacyClientInstallFlags
      (\ClientInstallFlags
flags LegacySharedConfig
conf -> LegacySharedConfig
conf { legacyClientInstallFlags :: ClientInstallFlags
legacyClientInstallFlags = ClientInstallFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  forall a b. (a -> b) -> a -> b
$ ShowOrParseArgs -> [OptionField ClientInstallFlags]
clientInstallOptions ShowOrParseArgs
ParseArgs

  , forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacySharedConfig -> ProjectFlags
legacyProjectFlags
      (\ProjectFlags
flags LegacySharedConfig
conf -> LegacySharedConfig
conf { legacyProjectFlags :: ProjectFlags
legacyProjectFlags = ProjectFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  forall a b. (a -> b) -> a -> b
$ ShowOrParseArgs -> [OptionField ProjectFlags]
projectFlagsOptions ShowOrParseArgs
ParseArgs

  ]


legacyPackageConfigFieldDescrs :: [FieldDescr LegacyPackageConfig]
legacyPackageConfigFieldDescrs :: [FieldDescr LegacyPackageConfig]
legacyPackageConfigFieldDescrs =
  ( forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags
      (\ConfigFlags
flags LegacyPackageConfig
conf -> LegacyPackageConfig
conf { legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags = ConfigFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"extra-include-dirs"
          String -> Doc
showTokenQ forall r. ReadP r String
parseTokenQ
          ConfigFlags -> [String]
configExtraIncludeDirs
          (\[String]
v ConfigFlags
conf -> ConfigFlags
conf { configExtraIncludeDirs :: [String]
configExtraIncludeDirs = [String]
v })
      , forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"extra-lib-dirs"
          String -> Doc
showTokenQ forall r. ReadP r String
parseTokenQ
          ConfigFlags -> [String]
configExtraLibDirs
          (\[String]
v ConfigFlags
conf -> ConfigFlags
conf { configExtraLibDirs :: [String]
configExtraLibDirs = [String]
v })
      , forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"extra-lib-dirs-static"
          String -> Doc
showTokenQ forall r. ReadP r String
parseTokenQ
          ConfigFlags -> [String]
configExtraLibDirsStatic
          (\[String]
v ConfigFlags
conf -> ConfigFlags
conf { configExtraLibDirsStatic :: [String]
configExtraLibDirsStatic = [String]
v })
      , forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"extra-framework-dirs"
          String -> Doc
showTokenQ forall r. ReadP r String
parseTokenQ
          ConfigFlags -> [String]
configExtraFrameworkDirs
          (\[String]
v ConfigFlags
conf -> ConfigFlags
conf { configExtraFrameworkDirs :: [String]
configExtraFrameworkDirs = [String]
v })
      , forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"extra-prog-path"
          String -> Doc
showTokenQ forall r. ReadP r String
parseTokenQ
          (forall a. NubList a -> [a]
fromNubList forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConfigFlags -> NubList String
configProgramPathExtra)
          (\[String]
v ConfigFlags
conf -> ConfigFlags
conf { configProgramPathExtra :: NubList String
configProgramPathExtra = forall a. Ord a => [a] -> NubList a
toNubList [String]
v })
      , forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"configure-options"
          String -> Doc
showTokenQ forall r. ReadP r String
parseTokenQ
          ConfigFlags -> [String]
configConfigureArgs
          (\[String]
v ConfigFlags
conf -> ConfigFlags
conf { configConfigureArgs :: [String]
configConfigureArgs = [String]
v })
      , forall a b.
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> a)
-> (a -> b -> b)
-> FieldDescr b
simpleFieldParsec String
"flags"
          FlagAssignment -> Doc
dispFlagAssignment forall (m :: * -> *). CabalParsing m => m FlagAssignment
parsecFlagAssignment
          ConfigFlags -> FlagAssignment
configConfigurationsFlags
          (\FlagAssignment
v ConfigFlags
conf -> ConfigFlags
conf { configConfigurationsFlags :: FlagAssignment
configConfigurationsFlags = FlagAssignment
v })
      , FieldDescr ConfigFlags
overrideDumpBuildInfo
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      [ String
"with-compiler", String
"with-hc-pkg"
      , String
"program-prefix", String
"program-suffix"
      , String
"library-vanilla", String
"library-profiling"
      , String
"shared", String
"static", String
"executable-dynamic", String
"executable-static"
      , String
"profiling", String
"executable-profiling"
      , String
"profiling-detail", String
"library-profiling-detail"
      , String
"library-for-ghci", String
"split-objs", String
"split-sections"
      , String
"executable-stripping", String
"library-stripping"
      , String
"tests", String
"benchmarks"
      , String
"coverage", String
"library-coverage"
      , String
"relocatable"
        -- not "extra-include-dirs", "extra-lib-dirs", "extra-framework-dirs"
        -- or "extra-prog-path". We use corrected ones above that parse
        -- as list fields.
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  ) (ShowOrParseArgs -> [OptionField ConfigFlags]
configureOptions ShowOrParseArgs
ParseArgs)
 forall a. [a] -> [a] -> [a]
++
    forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags
      (\ConfigFlags
flags LegacyPackageConfig
conf -> LegacyPackageConfig
conf { legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags = ConfigFlags
flags })
    [ FieldDescr ConfigFlags
overrideFieldCompiler
    , FieldDescr ConfigFlags
overrideFieldOptimization
    , FieldDescr ConfigFlags
overrideFieldDebugInfo
    ]
 forall a. [a] -> [a] -> [a]
++
  ( forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacyPackageConfig -> InstallFlags
legacyInstallPkgFlags
      (\InstallFlags
flags LegacyPackageConfig
conf -> LegacyPackageConfig
conf { legacyInstallPkgFlags :: InstallFlags
legacyInstallPkgFlags = InstallFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      [ String
"documentation", String
"run-tests"
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  ) (ShowOrParseArgs -> [OptionField InstallFlags]
installOptions ShowOrParseArgs
ParseArgs)
 forall a. [a] -> [a] -> [a]
++
  ( forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacyPackageConfig -> HaddockFlags
legacyHaddockFlags
      (\HaddockFlags
flags LegacyPackageConfig
conf -> LegacyPackageConfig
conf { legacyHaddockFlags :: HaddockFlags
legacyHaddockFlags = HaddockFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (String -> String) -> [FieldDescr a] -> [FieldDescr a]
mapFieldNames
      (String
"haddock-"forall a. [a] -> [a] -> [a]
++)
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> a)
-> (a -> b -> b)
-> FieldDescr b
simpleFieldParsec String
"for-hackage"
          -- TODO: turn this into a library function
          (forall a. a -> Flag a -> a
fromFlagOrDefault Doc
Disp.empty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> Doc
pretty) (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Monoid a => a
mempty)
          HaddockFlags -> Flag HaddockTarget
haddockForHackage (\Flag HaddockTarget
v HaddockFlags
conf -> HaddockFlags
conf { haddockForHackage :: Flag HaddockTarget
haddockForHackage = Flag HaddockTarget
v })
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      [ String
"hoogle", String
"html", String
"html-location"
      , String
"foreign-libraries"
      , String
"executables", String
"tests", String
"benchmarks", String
"all", String
"internal", String
"css"
      , String
"hyperlink-source", String
"quickjump", String
"hscolour-css"
      , String
"contents-location", String
"index-location", String
"keep-temp-files", String
"base-url"
      , String
"lib"
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  ) (ShowOrParseArgs -> [OptionField HaddockFlags]
haddockOptions ShowOrParseArgs
ParseArgs)
 forall a. [a] -> [a] -> [a]
++
  ( forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacyPackageConfig -> TestFlags
legacyTestFlags
      (\TestFlags
flags LegacyPackageConfig
conf -> LegacyPackageConfig
conf { legacyTestFlags :: TestFlags
legacyTestFlags = TestFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (String -> String) -> [FieldDescr a] -> [FieldDescr a]
mapFieldNames
      String -> String
prefixTest
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"test-options"
          (String -> Doc
showTokenQ forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTemplate -> String
fromPathTemplate) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> PathTemplate
toPathTemplate forall r. ReadP r String
parseTokenQ)
          TestFlags -> [PathTemplate]
testOptions
          (\[PathTemplate]
v TestFlags
conf -> TestFlags
conf { testOptions :: [PathTemplate]
testOptions = [PathTemplate]
v })
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      [ String
"log", String
"machine-log", String
"show-details", String
"keep-tix-files"
      , String
"fail-when-no-test-suites", String
"test-wrapper" ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  ) (ShowOrParseArgs -> [OptionField TestFlags]
testOptions' ShowOrParseArgs
ParseArgs)
 forall a. [a] -> [a] -> [a]
++
  ( forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacyPackageConfig -> BenchmarkFlags
legacyBenchmarkFlags
      (\BenchmarkFlags
flags LegacyPackageConfig
conf -> LegacyPackageConfig
conf { legacyBenchmarkFlags :: BenchmarkFlags
legacyBenchmarkFlags = BenchmarkFlags
flags })
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields
      [ forall a b.
String
-> (a -> Doc)
-> ReadP [a] a
-> (b -> [a])
-> ([a] -> b -> b)
-> FieldDescr b
newLineListField String
"benchmark-options"
          (String -> Doc
showTokenQ forall b c a. (b -> c) -> (a -> b) -> a -> c
. PathTemplate -> String
fromPathTemplate) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> PathTemplate
toPathTemplate forall r. ReadP r String
parseTokenQ)
          BenchmarkFlags -> [PathTemplate]
benchmarkOptions
          (\[PathTemplate]
v BenchmarkFlags
conf -> BenchmarkFlags
conf { benchmarkOptions :: [PathTemplate]
benchmarkOptions = [PathTemplate]
v })
      ]
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [String] -> [FieldDescr a] -> [FieldDescr a]
filterFields
      []
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  ) (ShowOrParseArgs -> [OptionField BenchmarkFlags]
benchmarkOptions' ShowOrParseArgs
ParseArgs)

  where
    overrideFieldCompiler :: FieldDescr ConfigFlags
overrideFieldCompiler =
      forall a b.
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> a)
-> (a -> b -> b)
-> FieldDescr b
simpleFieldParsec String
"compiler"
        (forall a. a -> Flag a -> a
fromFlagOrDefault Doc
Disp.empty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> Doc
pretty)
        (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Monoid a => a
mempty)
        ConfigFlags -> Flag CompilerFlavor
configHcFlavor (\Flag CompilerFlavor
v ConfigFlags
flags -> ConfigFlags
flags { configHcFlavor :: Flag CompilerFlavor
configHcFlavor = Flag CompilerFlavor
v })

    overrideDumpBuildInfo :: FieldDescr ConfigFlags
overrideDumpBuildInfo =
      forall b a.
(b -> a) -> (a -> b -> b) -> FieldDescr a -> FieldDescr b
liftField ConfigFlags -> Flag DumpBuildInfo
configDumpBuildInfo
                (\Flag DumpBuildInfo
v ConfigFlags
flags -> ConfigFlags
flags { configDumpBuildInfo :: Flag DumpBuildInfo
configDumpBuildInfo = Flag DumpBuildInfo
v }) forall a b. (a -> b) -> a -> b
$
      let name :: String
name = String
"build-info" in
      forall a.
String
-> (a -> Doc)
-> (Int -> String -> a -> ParseResult a)
-> FieldDescr a
FieldDescr String
name
        (\Flag DumpBuildInfo
f -> case Flag DumpBuildInfo
f of
                 Flag DumpBuildInfo
NoDumpBuildInfo -> String -> Doc
Disp.text String
"False"
                 Flag DumpBuildInfo
DumpBuildInfo   -> String -> Doc
Disp.text String
"True"
                 Flag DumpBuildInfo
_                    -> Doc
Disp.empty)
        (\Int
line String
str Flag DumpBuildInfo
_ -> case () of
         ()
_ |  String
str forall a. Eq a => a -> a -> Bool
== String
"False" -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DumpBuildInfo
NoDumpBuildInfo)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"True"  -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DumpBuildInfo
DumpBuildInfo)
           | String
lstr forall a. Eq a => a -> a -> Bool
== String
"false" -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [String -> PWarning
caseWarning String
name] (forall a. a -> Flag a
Flag DumpBuildInfo
NoDumpBuildInfo)
           | String
lstr forall a. Eq a => a -> a -> Bool
== String
"true"  -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [String -> PWarning
caseWarning String
name] (forall a. a -> Flag a
Flag DumpBuildInfo
DumpBuildInfo)
           | Bool
otherwise       -> forall a. PError -> ParseResult a
ParseFailed (String -> Int -> PError
NoParse String
name Int
line)
           where
             lstr :: String
lstr = String -> String
lowercase String
str)

    -- TODO: [code cleanup] The following is a hack. The "optimization" and
    -- "debug-info" fields are OptArg, and viewAsFieldDescr fails on that.
    -- Instead of a hand-written parser and printer, we should handle this case
    -- properly in the library.

    overrideFieldOptimization :: FieldDescr ConfigFlags
overrideFieldOptimization =
      forall b a.
(b -> a) -> (a -> b -> b) -> FieldDescr a -> FieldDescr b
liftField ConfigFlags -> Flag OptimisationLevel
configOptimization
                (\Flag OptimisationLevel
v ConfigFlags
flags -> ConfigFlags
flags { configOptimization :: Flag OptimisationLevel
configOptimization = Flag OptimisationLevel
v }) forall a b. (a -> b) -> a -> b
$
      let name :: String
name = String
"optimization" in
      forall a.
String
-> (a -> Doc)
-> (Int -> String -> a -> ParseResult a)
-> FieldDescr a
FieldDescr String
name
        (\Flag OptimisationLevel
f -> case Flag OptimisationLevel
f of
                 Flag OptimisationLevel
NoOptimisation      -> String -> Doc
Disp.text String
"False"
                 Flag OptimisationLevel
NormalOptimisation  -> String -> Doc
Disp.text String
"True"
                 Flag OptimisationLevel
MaximumOptimisation -> String -> Doc
Disp.text String
"2"
                 Flag OptimisationLevel
_                        -> Doc
Disp.empty)
        (\Int
line String
str Flag OptimisationLevel
_ -> case () of
         ()
_ |  String
str forall a. Eq a => a -> a -> Bool
== String
"False" -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag OptimisationLevel
NoOptimisation)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"True"  -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag OptimisationLevel
NormalOptimisation)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"0"     -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag OptimisationLevel
NoOptimisation)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"1"     -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag OptimisationLevel
NormalOptimisation)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"2"     -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag OptimisationLevel
MaximumOptimisation)
           | String
lstr forall a. Eq a => a -> a -> Bool
== String
"false" -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [String -> PWarning
caseWarning String
name] (forall a. a -> Flag a
Flag OptimisationLevel
NoOptimisation)
           | String
lstr forall a. Eq a => a -> a -> Bool
== String
"true"  -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [String -> PWarning
caseWarning String
name] (forall a. a -> Flag a
Flag OptimisationLevel
NormalOptimisation)
           | Bool
otherwise       -> forall a. PError -> ParseResult a
ParseFailed (String -> Int -> PError
NoParse String
name Int
line)
           where
             lstr :: String
lstr = String -> String
lowercase String
str)

    overrideFieldDebugInfo :: FieldDescr ConfigFlags
overrideFieldDebugInfo =
      forall b a.
(b -> a) -> (a -> b -> b) -> FieldDescr a -> FieldDescr b
liftField ConfigFlags -> Flag DebugInfoLevel
configDebugInfo (\Flag DebugInfoLevel
v ConfigFlags
flags -> ConfigFlags
flags { configDebugInfo :: Flag DebugInfoLevel
configDebugInfo = Flag DebugInfoLevel
v }) forall a b. (a -> b) -> a -> b
$
      let name :: String
name = String
"debug-info" in
      forall a.
String
-> (a -> Doc)
-> (Int -> String -> a -> ParseResult a)
-> FieldDescr a
FieldDescr String
name
        (\Flag DebugInfoLevel
f -> case Flag DebugInfoLevel
f of
                 Flag DebugInfoLevel
NoDebugInfo      -> String -> Doc
Disp.text String
"False"
                 Flag DebugInfoLevel
MinimalDebugInfo -> String -> Doc
Disp.text String
"1"
                 Flag DebugInfoLevel
NormalDebugInfo  -> String -> Doc
Disp.text String
"True"
                 Flag DebugInfoLevel
MaximalDebugInfo -> String -> Doc
Disp.text String
"3"
                 Flag DebugInfoLevel
_                     -> Doc
Disp.empty)
        (\Int
line String
str Flag DebugInfoLevel
_ -> case () of
         ()
_ |  String
str forall a. Eq a => a -> a -> Bool
== String
"False" -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DebugInfoLevel
NoDebugInfo)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"True"  -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DebugInfoLevel
NormalDebugInfo)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"0"     -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DebugInfoLevel
NoDebugInfo)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"1"     -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DebugInfoLevel
MinimalDebugInfo)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"2"     -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DebugInfoLevel
NormalDebugInfo)
           |  String
str forall a. Eq a => a -> a -> Bool
== String
"3"     -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [] (forall a. a -> Flag a
Flag DebugInfoLevel
MaximalDebugInfo)
           | String
lstr forall a. Eq a => a -> a -> Bool
== String
"false" -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [String -> PWarning
caseWarning String
name] (forall a. a -> Flag a
Flag DebugInfoLevel
NoDebugInfo)
           | String
lstr forall a. Eq a => a -> a -> Bool
== String
"true"  -> forall a. [PWarning] -> a -> ParseResult a
ParseOk [String -> PWarning
caseWarning String
name] (forall a. a -> Flag a
Flag DebugInfoLevel
NormalDebugInfo)
           | Bool
otherwise       -> forall a. PError -> ParseResult a
ParseFailed (String -> Int -> PError
NoParse String
name Int
line)
           where
             lstr :: String
lstr = String -> String
lowercase String
str)

    caseWarning :: String -> PWarning
caseWarning String
name = String -> PWarning
PWarning forall a b. (a -> b) -> a -> b
$
      String
"The '" forall a. [a] -> [a] -> [a]
++ String
name forall a. [a] -> [a] -> [a]
++ String
"' field is case sensitive, use 'True' or 'False'."

    prefixTest :: String -> String
prefixTest String
name | String
"test-" forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` String
name = String
name
                    | Bool
otherwise = String
"test-" forall a. [a] -> [a] -> [a]
++ String
name


legacyPackageConfigFGSectionDescrs
    :: ( FieldGrammar c g, Applicative (g SourceRepoList)
       , c (Identity RepoType)
       , c (List NoCommaFSep FilePathNT String)
       , c (NonEmpty' NoCommaFSep Token String)
       )
    => [FGSectionDescr g LegacyProjectConfig]
legacyPackageConfigFGSectionDescrs :: forall (c :: * -> Constraint) (g :: * -> * -> *).
(FieldGrammar c g, Applicative (g SourceRepoList),
 c (Identity RepoType), c (List NoCommaFSep FilePathNT String),
 c (NonEmpty' NoCommaFSep Token String)) =>
[FGSectionDescr g LegacyProjectConfig]
legacyPackageConfigFGSectionDescrs =
    [ forall (c :: * -> Constraint) (g :: * -> * -> *).
(FieldGrammar c g, Applicative (g SourceRepoList),
 c (Identity RepoType), c (List NoCommaFSep FilePathNT String),
 c (NonEmpty' NoCommaFSep Token String)) =>
FGSectionDescr g LegacyProjectConfig
packageRepoSectionDescr
    ]

legacyPackageConfigSectionDescrs :: [SectionDescr LegacyProjectConfig]
legacyPackageConfigSectionDescrs :: [SectionDescr LegacyProjectConfig]
legacyPackageConfigSectionDescrs =
    [ SectionDescr LegacyProjectConfig
packageSpecificOptionsSectionDescr
    , forall b a.
(b -> a) -> (a -> b -> b) -> SectionDescr a -> SectionDescr b
liftSection
        LegacyProjectConfig -> LegacyPackageConfig
legacyLocalConfig
        (\LegacyPackageConfig
flags LegacyProjectConfig
conf -> LegacyProjectConfig
conf { legacyLocalConfig :: LegacyPackageConfig
legacyLocalConfig = LegacyPackageConfig
flags })
        SectionDescr LegacyPackageConfig
programOptionsSectionDescr
    , forall b a.
(b -> a) -> (a -> b -> b) -> SectionDescr a -> SectionDescr b
liftSection
        LegacyProjectConfig -> LegacyPackageConfig
legacyLocalConfig
        (\LegacyPackageConfig
flags LegacyProjectConfig
conf -> LegacyProjectConfig
conf { legacyLocalConfig :: LegacyPackageConfig
legacyLocalConfig = LegacyPackageConfig
flags })
        SectionDescr LegacyPackageConfig
programLocationsSectionDescr
    , forall b a.
(b -> a) -> (a -> b -> b) -> SectionDescr a -> SectionDescr b
liftSection
        LegacyProjectConfig -> LegacySharedConfig
legacySharedConfig
        (\LegacySharedConfig
flags LegacyProjectConfig
conf -> LegacyProjectConfig
conf { legacySharedConfig :: LegacySharedConfig
legacySharedConfig = LegacySharedConfig
flags }) forall a b. (a -> b) -> a -> b
$
      forall b a.
(b -> a) -> (a -> b -> b) -> SectionDescr a -> SectionDescr b
liftSection
        LegacySharedConfig -> GlobalFlags
legacyGlobalFlags
        (\GlobalFlags
flags LegacySharedConfig
conf -> LegacySharedConfig
conf { legacyGlobalFlags :: GlobalFlags
legacyGlobalFlags = GlobalFlags
flags })
        SectionDescr GlobalFlags
remoteRepoSectionDescr
    ]

packageRepoSectionDescr
    :: ( FieldGrammar c g, Applicative (g SourceRepoList)
       , c (Identity RepoType)
       , c (List NoCommaFSep FilePathNT String)
       , c (NonEmpty' NoCommaFSep Token String)
       )
    => FGSectionDescr g LegacyProjectConfig
packageRepoSectionDescr :: forall (c :: * -> Constraint) (g :: * -> * -> *).
(FieldGrammar c g, Applicative (g SourceRepoList),
 c (Identity RepoType), c (List NoCommaFSep FilePathNT String),
 c (NonEmpty' NoCommaFSep Token String)) =>
FGSectionDescr g LegacyProjectConfig
packageRepoSectionDescr = FGSectionDescr
  { fgSectionName :: String
fgSectionName        = String
"source-repository-package"
  , fgSectionGrammar :: g SourceRepoList SourceRepoList
fgSectionGrammar     = forall (c :: * -> Constraint) (g :: * -> * -> *).
(FieldGrammar c g, Applicative (g SourceRepoList),
 c (Identity RepoType), c (List NoCommaFSep FilePathNT String),
 c (NonEmpty' NoCommaFSep Token String)) =>
g SourceRepoList SourceRepoList
sourceRepositoryPackageGrammar
  , fgSectionGet :: LegacyProjectConfig -> [(String, SourceRepoList)]
fgSectionGet         = forall a b. (a -> b) -> [a] -> [b]
map (\SourceRepoList
x->(String
"", SourceRepoList
x)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. LegacyProjectConfig -> [SourceRepoList]
legacyPackagesRepo
  , fgSectionSet :: Int
-> String
-> SourceRepoList
-> LegacyProjectConfig
-> ParseResult LegacyProjectConfig
fgSectionSet         =
        \Int
lineno String
unused SourceRepoList
pkgrepo LegacyProjectConfig
projconf -> do
          forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
unused) forall a b. (a -> b) -> a -> b
$
            forall a. Int -> String -> ParseResult a
syntaxError Int
lineno String
"the section 'source-repository-package' takes no arguments"
          forall (m :: * -> *) a. Monad m => a -> m a
return LegacyProjectConfig
projconf {
            legacyPackagesRepo :: [SourceRepoList]
legacyPackagesRepo = LegacyProjectConfig -> [SourceRepoList]
legacyPackagesRepo LegacyProjectConfig
projconf forall a. [a] -> [a] -> [a]
++ [SourceRepoList
pkgrepo]
          }
  }

-- | The definitions of all the fields that can appear in the @package pkgfoo@
-- and @package *@ sections of the @cabal.project@-format files.
--
packageSpecificOptionsFieldDescrs :: [FieldDescr LegacyPackageConfig]
packageSpecificOptionsFieldDescrs :: [FieldDescr LegacyPackageConfig]
packageSpecificOptionsFieldDescrs =
    [FieldDescr LegacyPackageConfig]
legacyPackageConfigFieldDescrs
 forall a. [a] -> [a] -> [a]
++ forall a.
(a -> [(String, [String])])
-> ([(String, [String])] -> a -> a) -> [FieldDescr a]
programOptionsFieldDescrs
      (ConfigFlags -> [(String, [String])]
configProgramArgs forall b c a. (b -> c) -> (a -> b) -> a -> c
. LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags)
      (\[(String, [String])]
args LegacyPackageConfig
pkgconf -> LegacyPackageConfig
pkgconf {
          legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags = (LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags LegacyPackageConfig
pkgconf) {
            configProgramArgs :: [(String, [String])]
configProgramArgs  = [(String, [String])]
args
          }
        }
      )
 forall a. [a] -> [a] -> [a]
++ forall b a.
(b -> a) -> (a -> b -> b) -> [FieldDescr a] -> [FieldDescr b]
liftFields
      LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags
      (\ConfigFlags
flags LegacyPackageConfig
pkgconf -> LegacyPackageConfig
pkgconf {
          legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags = ConfigFlags
flags
        }
      )
      [FieldDescr ConfigFlags]
programLocationsFieldDescrs

-- | The definition of the @package pkgfoo@ sections of the @cabal.project@-format
-- files. This section is per-package name. The special package @*@ applies to all
-- packages used anywhere by the project, locally or as dependencies.
--
packageSpecificOptionsSectionDescr :: SectionDescr LegacyProjectConfig
packageSpecificOptionsSectionDescr :: SectionDescr LegacyProjectConfig
packageSpecificOptionsSectionDescr =
    SectionDescr {
      sectionName :: String
sectionName        = String
"package",
      sectionFields :: [FieldDescr LegacyPackageConfig]
sectionFields      = [FieldDescr LegacyPackageConfig]
packageSpecificOptionsFieldDescrs,
      sectionSubsections :: [SectionDescr LegacyPackageConfig]
sectionSubsections = [],
      sectionGet :: LegacyProjectConfig -> [(String, LegacyPackageConfig)]
sectionGet         = \LegacyProjectConfig
projconf ->
                             [ (forall a. Pretty a => a -> String
prettyShow PackageName
pkgname, LegacyPackageConfig
pkgconf)
                             | (PackageName
pkgname, LegacyPackageConfig
pkgconf) <-
                                 forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v. MapMappend k v -> Map k v
getMapMappend
                               forall b c a. (b -> c) -> (a -> b) -> a -> c
. LegacyProjectConfig -> MapMappend PackageName LegacyPackageConfig
legacySpecificConfig forall a b. (a -> b) -> a -> b
$ LegacyProjectConfig
projconf ]
                          forall a. [a] -> [a] -> [a]
++ [ (String
"*", LegacyProjectConfig -> LegacyPackageConfig
legacyAllConfig LegacyProjectConfig
projconf) ],
      sectionSet :: Int
-> String
-> LegacyPackageConfig
-> LegacyProjectConfig
-> ParseResult LegacyProjectConfig
sectionSet         =
        \Int
lineno String
pkgnamestr LegacyPackageConfig
pkgconf LegacyProjectConfig
projconf -> case String
pkgnamestr of
          String
"*" -> forall (m :: * -> *) a. Monad m => a -> m a
return LegacyProjectConfig
projconf {
                   legacyAllConfig :: LegacyPackageConfig
legacyAllConfig = LegacyProjectConfig -> LegacyPackageConfig
legacyAllConfig LegacyProjectConfig
projconf forall a. Semigroup a => a -> a -> a
<> LegacyPackageConfig
pkgconf
                 }
          String
_   -> do
            PackageName
pkgname <- case forall a. Parsec a => String -> Maybe a
simpleParsec String
pkgnamestr of
              Just PackageName
pkgname -> forall (m :: * -> *) a. Monad m => a -> m a
return PackageName
pkgname
              Maybe PackageName
Nothing      -> forall a. Int -> String -> ParseResult a
syntaxError Int
lineno forall a b. (a -> b) -> a -> b
$
                                  String
"a 'package' section requires a package name "
                               forall a. [a] -> [a] -> [a]
++ String
"as an argument"
            forall (m :: * -> *) a. Monad m => a -> m a
return LegacyProjectConfig
projconf {
              legacySpecificConfig :: MapMappend PackageName LegacyPackageConfig
legacySpecificConfig =
                forall k v. Map k v -> MapMappend k v
MapMappend forall a b. (a -> b) -> a -> b
$
                forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. Monoid a => a -> a -> a
mappend PackageName
pkgname LegacyPackageConfig
pkgconf
                               (forall k v. MapMappend k v -> Map k v
getMapMappend forall a b. (a -> b) -> a -> b
$ LegacyProjectConfig -> MapMappend PackageName LegacyPackageConfig
legacySpecificConfig LegacyProjectConfig
projconf)
            },
      sectionEmpty :: LegacyPackageConfig
sectionEmpty       = forall a. Monoid a => a
mempty
    }

programOptionsFieldDescrs :: (a -> [(String, [String])])
                          -> ([(String, [String])] -> a -> a)
                          -> [FieldDescr a]
programOptionsFieldDescrs :: forall a.
(a -> [(String, [String])])
-> ([(String, [String])] -> a -> a) -> [FieldDescr a]
programOptionsFieldDescrs a -> [(String, [String])]
get' [(String, [String])] -> a -> a
set =
    forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
  forall a b. (a -> b) -> a -> b
$ forall flags.
ProgramDb
-> ShowOrParseArgs
-> (flags -> [(String, [String])])
-> ([(String, [String])] -> flags -> flags)
-> [OptionField flags]
programDbOptions
      ProgramDb
defaultProgramDb
      ShowOrParseArgs
ParseArgs a -> [(String, [String])]
get' [(String, [String])] -> a -> a
set

programOptionsSectionDescr :: SectionDescr LegacyPackageConfig
programOptionsSectionDescr :: SectionDescr LegacyPackageConfig
programOptionsSectionDescr =
    SectionDescr {
      sectionName :: String
sectionName        = String
"program-options",
      sectionFields :: [FieldDescr ConfigFlags]
sectionFields      = forall a.
(a -> [(String, [String])])
-> ([(String, [String])] -> a -> a) -> [FieldDescr a]
programOptionsFieldDescrs
                             ConfigFlags -> [(String, [String])]
configProgramArgs
                             (\[(String, [String])]
args ConfigFlags
conf -> ConfigFlags
conf { configProgramArgs :: [(String, [String])]
configProgramArgs = [(String, [String])]
args }),
      sectionSubsections :: [SectionDescr ConfigFlags]
sectionSubsections = [],
      sectionGet :: LegacyPackageConfig -> [(String, ConfigFlags)]
sectionGet         = (\ConfigFlags
x->[(String
"", ConfigFlags
x)])
                         forall b c a. (b -> c) -> (a -> b) -> a -> c
. LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags,
      sectionSet :: Int
-> String
-> ConfigFlags
-> LegacyPackageConfig
-> ParseResult LegacyPackageConfig
sectionSet         =
        \Int
lineno String
unused ConfigFlags
confflags LegacyPackageConfig
pkgconf -> do
          forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
unused) forall a b. (a -> b) -> a -> b
$
            forall a. Int -> String -> ParseResult a
syntaxError Int
lineno String
"the section 'program-options' takes no arguments"
          forall (m :: * -> *) a. Monad m => a -> m a
return LegacyPackageConfig
pkgconf {
            legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags = LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags LegacyPackageConfig
pkgconf forall a. Semigroup a => a -> a -> a
<> ConfigFlags
confflags
          },
      sectionEmpty :: ConfigFlags
sectionEmpty       = forall a. Monoid a => a
mempty
    }

programLocationsFieldDescrs :: [FieldDescr ConfigFlags]
programLocationsFieldDescrs :: [FieldDescr ConfigFlags]
programLocationsFieldDescrs =
     forall a. [OptionField a] -> [FieldDescr a]
commandOptionsToFields
   forall a b. (a -> b) -> a -> b
$ forall flags.
(String -> String)
-> ProgramDb
-> ShowOrParseArgs
-> (flags -> [(String, String)])
-> ([(String, String)] -> flags -> flags)
-> [OptionField flags]
programDbPaths'
       (forall a. [a] -> [a] -> [a]
++ String
"-location")
       ProgramDb
defaultProgramDb
       ShowOrParseArgs
ParseArgs
       ConfigFlags -> [(String, String)]
configProgramPaths
       (\[(String, String)]
paths ConfigFlags
conf -> ConfigFlags
conf { configProgramPaths :: [(String, String)]
configProgramPaths = [(String, String)]
paths })

programLocationsSectionDescr :: SectionDescr LegacyPackageConfig
programLocationsSectionDescr :: SectionDescr LegacyPackageConfig
programLocationsSectionDescr =
    SectionDescr {
      sectionName :: String
sectionName        = String
"program-locations",
      sectionFields :: [FieldDescr ConfigFlags]
sectionFields      = [FieldDescr ConfigFlags]
programLocationsFieldDescrs,
      sectionSubsections :: [SectionDescr ConfigFlags]
sectionSubsections = [],
      sectionGet :: LegacyPackageConfig -> [(String, ConfigFlags)]
sectionGet         = (\ConfigFlags
x->[(String
"", ConfigFlags
x)])
                         forall b c a. (b -> c) -> (a -> b) -> a -> c
. LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags,
      sectionSet :: Int
-> String
-> ConfigFlags
-> LegacyPackageConfig
-> ParseResult LegacyPackageConfig
sectionSet         =
        \Int
lineno String
unused ConfigFlags
confflags LegacyPackageConfig
pkgconf -> do
          forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
unused) forall a b. (a -> b) -> a -> b
$
            forall a. Int -> String -> ParseResult a
syntaxError Int
lineno String
"the section 'program-locations' takes no arguments"
          forall (m :: * -> *) a. Monad m => a -> m a
return LegacyPackageConfig
pkgconf {
            legacyConfigureFlags :: ConfigFlags
legacyConfigureFlags = LegacyPackageConfig -> ConfigFlags
legacyConfigureFlags LegacyPackageConfig
pkgconf forall a. Semigroup a => a -> a -> a
<> ConfigFlags
confflags
          },
      sectionEmpty :: ConfigFlags
sectionEmpty       = forall a. Monoid a => a
mempty
    }


-- | For each known program @PROG@ in 'progDb', produce a @PROG-options@
-- 'OptionField'.
programDbOptions
  :: ProgramDb
  -> ShowOrParseArgs
  -> (flags -> [(String, [String])])
  -> ([(String, [String])] -> (flags -> flags))
  -> [OptionField flags]
programDbOptions :: forall flags.
ProgramDb
-> ShowOrParseArgs
-> (flags -> [(String, [String])])
-> ([(String, [String])] -> flags -> flags)
-> [OptionField flags]
programDbOptions ProgramDb
progDb ShowOrParseArgs
showOrParseArgs flags -> [(String, [String])]
get' [(String, [String])] -> flags -> flags
set =
  case ShowOrParseArgs
showOrParseArgs of
    -- we don't want a verbose help text list so we just show a generic one:
    ShowOrParseArgs
ShowArgs  -> [String -> OptionField flags
programOptions  String
"PROG"]
    ShowOrParseArgs
ParseArgs -> forall a b. (a -> b) -> [a] -> [b]
map (String -> OptionField flags
programOptions forall b c a. (b -> c) -> (a -> b) -> a -> c
. Program -> String
programName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst)
                 (ProgramDb -> [(Program, Maybe ConfiguredProgram)]
knownPrograms ProgramDb
progDb)
  where
    programOptions :: String -> OptionField flags
programOptions String
prog =
      forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
prog forall a. [a] -> [a] -> [a]
++ String
"-options"]
        (String
"give extra options to " forall a. [a] -> [a] -> [a]
++ String
prog)
        flags -> [(String, [String])]
get' [(String, [String])] -> flags -> flags
set
        (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"OPTS" (\String
args -> [(String
prog, String -> [String]
splitArgs String
args)])
           (\[(String, [String])]
progArgs -> [ [String] -> String
joinsArgs [String]
args
                         | (String
prog', [String]
args) <- [(String, [String])]
progArgs, String
progforall a. Eq a => a -> a -> Bool
==String
prog' ]))


    joinsArgs :: [String] -> String
joinsArgs = [String] -> String
unwords forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map String -> String
escape
    escape :: String -> String
escape String
arg | forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Char -> Bool
isSpace String
arg = String
"\"" forall a. [a] -> [a] -> [a]
++ String
arg forall a. [a] -> [a] -> [a]
++ String
"\""
               | Bool
otherwise       = String
arg


-- The implementation is slight hack: we parse all as remote repository
-- but if the url schema is file+noindex, we switch to local.
remoteRepoSectionDescr :: SectionDescr GlobalFlags
remoteRepoSectionDescr :: SectionDescr GlobalFlags
remoteRepoSectionDescr = SectionDescr
    { sectionName :: String
sectionName        = String
"repository"
    , sectionEmpty :: RemoteRepo
sectionEmpty       = RepoName -> RemoteRepo
emptyRemoteRepo (String -> RepoName
RepoName String
"")
    , sectionFields :: [FieldDescr RemoteRepo]
sectionFields      = [FieldDescr RemoteRepo]
remoteRepoFields
    , sectionSubsections :: [SectionDescr RemoteRepo]
sectionSubsections = []
    , sectionGet :: GlobalFlags -> [(String, RemoteRepo)]
sectionGet         = GlobalFlags -> [(String, RemoteRepo)]
getS
    , sectionSet :: Int
-> String -> RemoteRepo -> GlobalFlags -> ParseResult GlobalFlags
sectionSet         = Int
-> String -> RemoteRepo -> GlobalFlags -> ParseResult GlobalFlags
setS
    }
  where
    getS :: GlobalFlags -> [(String, RemoteRepo)]
    getS :: GlobalFlags -> [(String, RemoteRepo)]
getS GlobalFlags
gf =
        forall a b. (a -> b) -> [a] -> [b]
map (\RemoteRepo
x->(RepoName -> String
unRepoName forall a b. (a -> b) -> a -> b
$ RemoteRepo -> RepoName
remoteRepoName RemoteRepo
x, RemoteRepo
x)) (forall a. NubList a -> [a]
fromNubList (GlobalFlags -> NubList RemoteRepo
globalRemoteRepos GlobalFlags
gf))
        forall a. [a] -> [a] -> [a]
++
        forall a b. (a -> b) -> [a] -> [b]
map (\LocalRepo
x->(RepoName -> String
unRepoName forall a b. (a -> b) -> a -> b
$ LocalRepo -> RepoName
localRepoName LocalRepo
x, LocalRepo -> RemoteRepo
localToRemote LocalRepo
x)) (forall a. NubList a -> [a]
fromNubList (GlobalFlags -> NubList LocalRepo
globalLocalNoIndexRepos GlobalFlags
gf))

    setS :: Int -> String -> RemoteRepo -> GlobalFlags -> ParseResult GlobalFlags
    setS :: Int
-> String -> RemoteRepo -> GlobalFlags -> ParseResult GlobalFlags
setS Int
lineno String
reponame RemoteRepo
repo0 GlobalFlags
conf = do
        Either LocalRepo RemoteRepo
repo1 <- Int
-> String
-> RemoteRepo
-> ParseResult (Either LocalRepo RemoteRepo)
postProcessRepo Int
lineno String
reponame RemoteRepo
repo0
        case Either LocalRepo RemoteRepo
repo1 of
            Left LocalRepo
repo -> forall (m :: * -> *) a. Monad m => a -> m a
return GlobalFlags
conf
                { globalLocalNoIndexRepos :: NubList LocalRepo
globalLocalNoIndexRepos  = forall a. Ord a => ([a] -> [a]) -> NubList a -> NubList a
overNubList (forall a. [a] -> [a] -> [a]
++[LocalRepo
repo]) (GlobalFlags -> NubList LocalRepo
globalLocalNoIndexRepos GlobalFlags
conf)
                }
            Right RemoteRepo
repo -> forall (m :: * -> *) a. Monad m => a -> m a
return GlobalFlags
conf
                { globalRemoteRepos :: NubList RemoteRepo
globalRemoteRepos = forall a. Ord a => ([a] -> [a]) -> NubList a -> NubList a
overNubList (forall a. [a] -> [a] -> [a]
++[RemoteRepo
repo]) (GlobalFlags -> NubList RemoteRepo
globalRemoteRepos GlobalFlags
conf)
                }

    localToRemote :: LocalRepo -> RemoteRepo
    localToRemote :: LocalRepo -> RemoteRepo
localToRemote (LocalRepo RepoName
name String
path Bool
sharedCache) = (RepoName -> RemoteRepo
emptyRemoteRepo RepoName
name)
        { remoteRepoURI :: URI
remoteRepoURI = String -> Maybe URIAuth -> String -> String -> String -> URI
URI String
"file+noindex:" forall a. Maybe a
Nothing String
path String
"" (if Bool
sharedCache then String
"#shared-cache" else String
"")
        }

-------------------------------
-- Local field utils
--

-- | Parser combinator for simple fields which uses the field type's
-- 'Monoid' instance for combining multiple occurrences of the field.
monoidFieldParsec
    :: Monoid a => String -> (a -> Doc) -> ParsecParser a
    -> (b -> a) -> (a -> b -> b) -> FieldDescr b
monoidFieldParsec :: forall a b.
Monoid a =>
String
-> (a -> Doc)
-> ParsecParser a
-> (b -> a)
-> (a -> b -> b)
-> FieldDescr b
monoidFieldParsec String
name a -> Doc
showF ParsecParser a
readF b -> a
get' a -> b -> b
set =
  forall b a.
(b -> a) -> (a -> b -> b) -> FieldDescr a -> FieldDescr b
liftField b -> a
get' a -> b -> b
set' forall a b. (a -> b) -> a -> b
$ forall a. String -> (a -> Doc) -> ParsecParser a -> FieldDescr a
ParseUtils.fieldParsec String
name a -> Doc
showF ParsecParser a
readF
  where
    set' :: a -> b -> b
set' a
xs b
b = a -> b -> b
set (b -> a
get' b
b forall a. Monoid a => a -> a -> a
`mappend` a
xs) b
b


--TODO: [code cleanup] local redefinition that should replace the version in
-- D.ParseUtils called showFilePath. This version escapes "." and "--" which
-- otherwise are special syntax.
showTokenQ :: String -> Doc
showTokenQ :: String -> Doc
showTokenQ String
""            = Doc
Disp.empty
showTokenQ x :: String
x@(Char
'-':Char
'-':String
_) = String -> Doc
Disp.text (forall a. Show a => a -> String
show String
x)
showTokenQ x :: String
x@(Char
'.':[])    = String -> Doc
Disp.text (forall a. Show a => a -> String
show String
x)
showTokenQ String
x             = String -> Doc
showToken String
x


-- Handy util
addFields :: [FieldDescr a]
          -> ([FieldDescr a] -> [FieldDescr a])
addFields :: forall a. [FieldDescr a] -> [FieldDescr a] -> [FieldDescr a]
addFields = forall a. [a] -> [a] -> [a]
(++)