-- -Wno-deprecations for use of Map.foldWithKey
{-# OPTIONS_GHC -Wno-deprecations #-}

-----------------------------------------------------------------------------

-- |
-- Module      :  Distribution.PackageDescription.Configuration
-- Copyright   :  Thomas Schilling, 2007
-- License     :  BSD3
--
-- Maintainer  :  cabal-devel@haskell.org
-- Portability :  portable
--
-- This is about the cabal configurations feature. It exports
-- 'finalizePD' and 'flattenPackageDescription' which are
-- functions for converting 'GenericPackageDescription's down to
-- 'PackageDescription's. It has code for working with the tree of conditions
-- and resolving or flattening conditions.
module Distribution.PackageDescription.Configuration
  ( finalizePD
  , flattenPackageDescription
  -- Utils
  , parseCondition
  , freeVars
  , extractCondition
  , extractConditions
  , addBuildableCondition
  , mapCondTree
  , mapTreeData
  , mapTreeConds
  , transformAllBuildInfos
  , transformAllBuildDepends
  , transformAllBuildDependsN
  , simplifyWithSysParams
  ) where

import Data.Functor ((<&>))
import Distribution.Compat.Prelude
import Prelude ()

-- lens
import qualified Distribution.Compat.Lens as L
import qualified Distribution.Types.BuildInfo.Lens as L
import qualified Distribution.Types.GenericPackageDescription.Lens as L
import qualified Distribution.Types.PackageDescription.Lens as L
import qualified Distribution.Types.SetupBuildInfo.Lens as L

import Distribution.Compat.CharParsing hiding (char)
import qualified Distribution.Compat.CharParsing as P
import Distribution.Compat.Lens
import Distribution.Compiler
import Distribution.PackageDescription
import Distribution.PackageDescription.Utils
import Distribution.Parsec
import Distribution.Pretty
import Distribution.System
import Distribution.Types.Component
import Distribution.Types.ComponentRequestedSpec
import Distribution.Types.DependencyMap
import Distribution.Types.DependencySatisfaction (DependencySatisfaction (..))
import Distribution.Types.MissingDependency (MissingDependency (..))
import Distribution.Types.PackageVersionConstraint
import Distribution.Utils.Generic
import Distribution.Utils.Path (sameDirectory)
import Distribution.Version

import Data.Tree (Tree (Node))
import Data.Tuple

------------------------------------------------------------------------------

-- | Simplify a configuration condition using the OS and arch names.  Returns
--   the names of all the flags occurring in the condition.
simplifyWithSysParams
  :: OS
  -> Arch
  -> CompilerInfo
  -> Condition ConfVar
  -> (Condition FlagName, [FlagName])
simplifyWithSysParams :: OS
-> Arch
-> CompilerInfo
-> Condition ConfVar
-> (Condition FlagName, [FlagName])
simplifyWithSysParams OS
os Arch
arch CompilerInfo
cinfo Condition ConfVar
cond = (Condition FlagName
cond', [FlagName]
flags)
  where
    (Condition FlagName
cond', [FlagName]
flags) = Condition ConfVar
-> (ConfVar -> Either FlagName Bool)
-> (Condition FlagName, [FlagName])
forall c d.
Condition c -> (c -> Either d Bool) -> (Condition d, [d])
simplifyCondition Condition ConfVar
cond ConfVar -> Either FlagName Bool
interp
    interp :: ConfVar -> Either FlagName Bool
interp (OS OS
os') = Bool -> Either FlagName Bool
forall a b. b -> Either a b
Right (Bool -> Either FlagName Bool) -> Bool -> Either FlagName Bool
forall a b. (a -> b) -> a -> b
$ OS
os' OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
os
    interp (Arch Arch
arch') = Bool -> Either FlagName Bool
forall a b. b -> Either a b
Right (Bool -> Either FlagName Bool) -> Bool -> Either FlagName Bool
forall a b. (a -> b) -> a -> b
$ Arch
arch' Arch -> Arch -> Bool
forall a. Eq a => a -> a -> Bool
== Arch
arch
    interp (Impl CompilerFlavor
comp VersionRange
vr)
      | CompilerId -> Bool
matchImpl (CompilerInfo -> CompilerId
compilerInfoId CompilerInfo
cinfo) = Bool -> Either FlagName Bool
forall a b. b -> Either a b
Right Bool
True
      | Bool
otherwise = case CompilerInfo -> Maybe [CompilerId]
compilerInfoCompat CompilerInfo
cinfo of
          -- fixme: treat Nothing as unknown, rather than empty list once we
          --        support partial resolution of system parameters
          Maybe [CompilerId]
Nothing -> Bool -> Either FlagName Bool
forall a b. b -> Either a b
Right Bool
False
          Just [CompilerId]
compat -> Bool -> Either FlagName Bool
forall a b. b -> Either a b
Right ((CompilerId -> Bool) -> [CompilerId] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any CompilerId -> Bool
matchImpl [CompilerId]
compat)
      where
        matchImpl :: CompilerId -> Bool
matchImpl (CompilerId CompilerFlavor
c Version
v) = CompilerFlavor
comp CompilerFlavor -> CompilerFlavor -> Bool
forall a. Eq a => a -> a -> Bool
== CompilerFlavor
c Bool -> Bool -> Bool
&& Version
v Version -> VersionRange -> Bool
`withinRange` VersionRange
vr
    interp (PackageFlag FlagName
f) = FlagName -> Either FlagName Bool
forall a b. a -> Either a b
Left FlagName
f

-- TODO: Add instances and check
--
-- prop_sC_idempotent cond a o = cond' == cond''
--   where
--     cond'  = simplifyCondition cond a o
--     cond'' = simplifyCondition cond' a o
--
-- prop_sC_noLits cond a o = isLit res || not (hasLits res)
--   where
--     res = simplifyCondition cond a o
--     hasLits (Lit _) = True
--     hasLits (CNot c) = hasLits c
--     hasLits (COr l r) = hasLits l || hasLits r
--     hasLits (CAnd l r) = hasLits l || hasLits r
--     hasLits _ = False
--

-- | Parse a configuration condition from a string.
parseCondition :: CabalParsing m => m (Condition ConfVar)
parseCondition :: forall (m :: * -> *). CabalParsing m => m (Condition ConfVar)
parseCondition = m (Condition ConfVar)
condOr
  where
    condOr :: m (Condition ConfVar)
condOr = m (Condition ConfVar) -> m () -> m (NonEmpty (Condition ConfVar))
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty m (Condition ConfVar)
condAnd (String -> m ()
oper String
"||") m (NonEmpty (Condition ConfVar))
-> (NonEmpty (Condition ConfVar) -> Condition ConfVar)
-> m (Condition ConfVar)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Condition ConfVar -> Condition ConfVar -> Condition ConfVar)
-> NonEmpty (Condition ConfVar) -> Condition ConfVar
forall a. (a -> a -> a) -> NonEmpty a -> a
foldl1 Condition ConfVar -> Condition ConfVar -> Condition ConfVar
forall c. Condition c -> Condition c -> Condition c
COr
    condAnd :: m (Condition ConfVar)
condAnd = m (Condition ConfVar) -> m () -> m (NonEmpty (Condition ConfVar))
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty m (Condition ConfVar)
cond (String -> m ()
oper String
"&&") m (NonEmpty (Condition ConfVar))
-> (NonEmpty (Condition ConfVar) -> Condition ConfVar)
-> m (Condition ConfVar)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Condition ConfVar -> Condition ConfVar -> Condition ConfVar)
-> NonEmpty (Condition ConfVar) -> Condition ConfVar
forall a. (a -> a -> a) -> NonEmpty a -> a
foldl1 Condition ConfVar -> Condition ConfVar -> Condition ConfVar
forall c. Condition c -> Condition c -> Condition c
CAnd
    -- TODO: try?
    cond :: m (Condition ConfVar)
cond =
      m ()
sp
        m () -> m (Condition ConfVar) -> m (Condition ConfVar)
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ( m (Condition ConfVar)
forall {c}. m (Condition c)
boolLiteral
              m (Condition ConfVar)
-> m (Condition ConfVar) -> m (Condition ConfVar)
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Condition ConfVar) -> m (Condition ConfVar)
forall {a}. m a -> m a
inparens m (Condition ConfVar)
condOr
              m (Condition ConfVar)
-> m (Condition ConfVar) -> m (Condition ConfVar)
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Condition ConfVar)
notCond
              m (Condition ConfVar)
-> m (Condition ConfVar) -> m (Condition ConfVar)
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Condition ConfVar)
osCond
              m (Condition ConfVar)
-> m (Condition ConfVar) -> m (Condition ConfVar)
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Condition ConfVar)
archCond
              m (Condition ConfVar)
-> m (Condition ConfVar) -> m (Condition ConfVar)
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Condition ConfVar)
flagCond
              m (Condition ConfVar)
-> m (Condition ConfVar) -> m (Condition ConfVar)
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m (Condition ConfVar)
implCond
           )
    inparens :: m a -> m a
inparens = m () -> m () -> m a -> m a
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
between (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
'(' m Char -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp) (m ()
sp m () -> m Char -> m Char
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
')' m Char -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp)
    notCond :: m (Condition ConfVar)
notCond = (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
'!' m Char -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp m () -> m (Condition ConfVar) -> m (Condition ConfVar)
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m (Condition ConfVar)
cond) m (Condition ConfVar)
-> (Condition ConfVar -> Condition ConfVar)
-> m (Condition ConfVar)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Condition ConfVar -> Condition ConfVar
forall c. Condition c -> Condition c
CNot
    osCond :: m (Condition ConfVar)
osCond = (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"os" m String -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp m () -> m ConfVar -> m ConfVar
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ConfVar -> m ConfVar
forall {a}. m a -> m a
inparens m ConfVar
osIdent) m ConfVar
-> (ConfVar -> Condition ConfVar) -> m (Condition ConfVar)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> ConfVar -> Condition ConfVar
forall c. c -> Condition c
Var
    archCond :: m (Condition ConfVar)
archCond = (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"arch" m String -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp m () -> m ConfVar -> m ConfVar
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ConfVar -> m ConfVar
forall {a}. m a -> m a
inparens m ConfVar
archIdent) m ConfVar
-> (ConfVar -> Condition ConfVar) -> m (Condition ConfVar)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> ConfVar -> Condition ConfVar
forall c. c -> Condition c
Var
    flagCond :: m (Condition ConfVar)
flagCond = (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"flag" m String -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp m () -> m ConfVar -> m ConfVar
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ConfVar -> m ConfVar
forall {a}. m a -> m a
inparens m ConfVar
flagIdent) m ConfVar
-> (ConfVar -> Condition ConfVar) -> m (Condition ConfVar)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> ConfVar -> Condition ConfVar
forall c. c -> Condition c
Var
    implCond :: m (Condition ConfVar)
implCond = (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"impl" m String -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp m () -> m ConfVar -> m ConfVar
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ConfVar -> m ConfVar
forall {a}. m a -> m a
inparens m ConfVar
implIdent) m ConfVar
-> (ConfVar -> Condition ConfVar) -> m (Condition ConfVar)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> ConfVar -> Condition ConfVar
forall c. c -> Condition c
Var
    boolLiteral :: m (Condition c)
boolLiteral = (Bool -> Condition c) -> m Bool -> m (Condition c)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Condition c
forall c. Bool -> Condition c
Lit m Bool
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
forall (m :: * -> *). CabalParsing m => m Bool
parsec
    archIdent :: m ConfVar
archIdent = (Arch -> ConfVar) -> m Arch -> m ConfVar
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Arch -> ConfVar
Arch m Arch
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
forall (m :: * -> *). CabalParsing m => m Arch
parsec
    osIdent :: m ConfVar
osIdent = (OS -> ConfVar) -> m OS -> m ConfVar
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap OS -> ConfVar
OS m OS
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
forall (m :: * -> *). CabalParsing m => m OS
parsec
    flagIdent :: m ConfVar
flagIdent = (String -> ConfVar) -> m String -> m ConfVar
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (FlagName -> ConfVar
PackageFlag (FlagName -> ConfVar) -> (String -> FlagName) -> String -> ConfVar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> FlagName
mkFlagName (String -> FlagName) -> (String -> String) -> String -> FlagName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
lowercase) ((Char -> Bool) -> m String
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m String
munch1 Char -> Bool
isIdentChar)
    isIdentChar :: Char -> Bool
isIdentChar Char
c = Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'-'
    oper :: String -> m ()
oper String
s = m ()
sp m () -> m String -> m String
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
s m String -> m () -> m ()
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
sp
    sp :: m ()
sp = m ()
forall (m :: * -> *). CharParsing m => m ()
spaces
    implIdent :: m ConfVar
implIdent = do
      i <- m CompilerFlavor
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
forall (m :: * -> *). CabalParsing m => m CompilerFlavor
parsec
      vr <- sp >> option anyVersion parsec
      return $ Impl i vr

------------------------------------------------------------------------------

-- | Result of dependency test. Isomorphic to @Maybe@ but renamed for
--   clarity.
data DepTestRslt
  = DepOk
  | MissingDeps [MissingDependency]

instance Monoid DepTestRslt where
  mempty :: DepTestRslt
mempty = DepTestRslt
DepOk
  mappend :: DepTestRslt -> DepTestRslt -> DepTestRslt
mappend = DepTestRslt -> DepTestRslt -> DepTestRslt
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup DepTestRslt where
  DepTestRslt
DepOk <> :: DepTestRslt -> DepTestRslt -> DepTestRslt
<> DepTestRslt
x = DepTestRslt
x
  DepTestRslt
x <> DepTestRslt
DepOk = DepTestRslt
x
  (MissingDeps [MissingDependency]
d) <> (MissingDeps [MissingDependency]
d') = [MissingDependency] -> DepTestRslt
MissingDeps ([MissingDependency]
d [MissingDependency] -> [MissingDependency] -> [MissingDependency]
forall a. Semigroup a => a -> a -> a
<> [MissingDependency]
d')

-- | Try to find a flag assignment that satisfies the constraints of all trees.
--
-- Returns either the missing dependencies, or a tuple containing the
-- resulting data, the associated dependencies, and the chosen flag
-- assignments.
--
-- In case of failure, the union of the dependencies that led to backtracking
-- on all branches is returned.
-- [TODO: Could also be specified with a function argument.]
--
-- TODO: The current algorithm is rather naive.  A better approach would be to:
--
-- * Rule out possible paths, by taking a look at the associated dependencies.
--
-- * Infer the required values for the conditions of these paths, and
--   calculate the required domains for the variables used in these
--   conditions.  Then picking a flag assignment would be linear (I guess).
--
-- This would require some sort of SAT solving, though, thus it's not
-- implemented unless we really need it.
resolveWithFlags
  :: [(FlagName, [Bool])]
  -- ^ Domain for each flag name, will be tested in order.
  -> ComponentRequestedSpec
  -> OS
  -- ^ OS where the installed artifacts will run (host OS)
  -> Arch
  -- ^ Arch where the installed artifacts will run (host Arch)
  -> CompilerInfo
  -- ^ Compiler information
  -> [PackageVersionConstraint]
  -- ^ Additional constraints
  -> [CondTree ConfVar PDTagged]
  -> ([Dependency] -> DepTestRslt)
  -- ^ Dependency test function.
  -> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
  -- ^ Either the missing dependencies (error case), or a pair of
  -- (set of build targets with dependencies, chosen flag assignments)
resolveWithFlags :: [(FlagName, [Bool])]
-> ComponentRequestedSpec
-> OS
-> Arch
-> CompilerInfo
-> [PackageVersionConstraint]
-> [CondTree ConfVar PDTagged]
-> ([Dependency] -> DepTestRslt)
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
resolveWithFlags [(FlagName, [Bool])]
dom ComponentRequestedSpec
enabled OS
os Arch
arch CompilerInfo
impl [PackageVersionConstraint]
constrs [CondTree ConfVar PDTagged]
trees [Dependency] -> DepTestRslt
checkDeps =
  Tree FlagAssignment
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
explore (FlagAssignment -> [(FlagName, [Bool])] -> Tree FlagAssignment
build FlagAssignment
forall a. Monoid a => a
mempty [(FlagName, [Bool])]
dom)
  where
    -- simplify trees by (partially) evaluating all conditions and converting
    -- dependencies to dependency maps.
    simplifiedTrees :: [CondTree FlagName (PDTagged, DependencyMap)]
    simplifiedTrees :: [CondTree FlagName (PDTagged, DependencyMap)]
simplifiedTrees =
      (CondTree ConfVar PDTagged
 -> CondTree FlagName (PDTagged, DependencyMap))
-> [CondTree ConfVar PDTagged]
-> [CondTree FlagName (PDTagged, DependencyMap)]
forall a b. (a -> b) -> [a] -> [b]
map
        ( (PDTagged -> (PDTagged, DependencyMap))
-> CondTree FlagName PDTagged
-> CondTree FlagName (PDTagged, DependencyMap)
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData (\PDTagged
x -> (PDTagged
x, [Dependency] -> DependencyMap
toDepMap ([Dependency] -> DependencyMap) -> [Dependency] -> DependencyMap
forall a b. (a -> b) -> a -> b
$ Getting [Dependency] PDTagged [Dependency]
-> PDTagged -> [Dependency]
forall a s. Getting a s a -> s -> a
L.view Getting [Dependency] PDTagged [Dependency]
forall a. HasBuildInfo a => Lens' a [Dependency]
Lens' PDTagged [Dependency]
L.targetBuildDepends PDTagged
x))
            (CondTree FlagName PDTagged
 -> CondTree FlagName (PDTagged, DependencyMap))
-> (CondTree ConfVar PDTagged -> CondTree FlagName PDTagged)
-> CondTree ConfVar PDTagged
-> CondTree FlagName (PDTagged, DependencyMap)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CondTree FlagName PDTagged -> CondTree FlagName PDTagged
forall v. Eq v => CondTree v PDTagged -> CondTree v PDTagged
addBuildableConditionPDTagged
            (CondTree FlagName PDTagged -> CondTree FlagName PDTagged)
-> (CondTree ConfVar PDTagged -> CondTree FlagName PDTagged)
-> CondTree ConfVar PDTagged
-> CondTree FlagName PDTagged
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Condition ConfVar -> Condition FlagName)
-> CondTree ConfVar PDTagged -> CondTree FlagName PDTagged
forall v w a.
(Condition v -> Condition w) -> CondTree v a -> CondTree w a
mapTreeConds ((Condition FlagName, [FlagName]) -> Condition FlagName
forall a b. (a, b) -> a
fst ((Condition FlagName, [FlagName]) -> Condition FlagName)
-> (Condition ConfVar -> (Condition FlagName, [FlagName]))
-> Condition ConfVar
-> Condition FlagName
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)
        )
        [CondTree ConfVar PDTagged]
trees

    -- @explore@ searches a tree of assignments, backtracking whenever a flag
    -- introduces a dependency that cannot be satisfied.  If there is no
    -- solution, @explore@ returns the union of all dependencies that caused
    -- it to backtrack.  Since the tree is constructed lazily, we avoid some
    -- computation overhead in the successful case.
    explore
      :: Tree FlagAssignment
      -> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
    explore :: Tree FlagAssignment
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
explore (Node FlagAssignment
flags [Tree FlagAssignment]
ts) =
      let targetSet :: TargetSet PDTagged
targetSet =
            [(DependencyMap, PDTagged)] -> TargetSet PDTagged
forall a. [(DependencyMap, a)] -> TargetSet a
TargetSet ([(DependencyMap, PDTagged)] -> TargetSet PDTagged)
-> [(DependencyMap, PDTagged)] -> TargetSet PDTagged
forall a b. (a -> b) -> a -> b
$
              ((CondTree FlagName (PDTagged, DependencyMap)
  -> (DependencyMap, PDTagged))
 -> [CondTree FlagName (PDTagged, DependencyMap)]
 -> [(DependencyMap, PDTagged)])
-> [CondTree FlagName (PDTagged, DependencyMap)]
-> (CondTree FlagName (PDTagged, DependencyMap)
    -> (DependencyMap, PDTagged))
-> [(DependencyMap, PDTagged)]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (CondTree FlagName (PDTagged, DependencyMap)
 -> (DependencyMap, PDTagged))
-> [CondTree FlagName (PDTagged, DependencyMap)]
-> [(DependencyMap, PDTagged)]
forall a b. (a -> b) -> [a] -> [b]
map [CondTree FlagName (PDTagged, DependencyMap)]
simplifiedTrees ((CondTree FlagName (PDTagged, DependencyMap)
  -> (DependencyMap, PDTagged))
 -> [(DependencyMap, PDTagged)])
-> (CondTree FlagName (PDTagged, DependencyMap)
    -> (DependencyMap, PDTagged))
-> [(DependencyMap, PDTagged)]
forall a b. (a -> b) -> a -> b
$
                -- apply additional constraints to all dependencies
                (DependencyMap -> DependencyMap)
-> (DependencyMap, PDTagged) -> (DependencyMap, PDTagged)
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first (DependencyMap -> [PackageVersionConstraint] -> DependencyMap
`constrainBy` [PackageVersionConstraint]
constrs)
                  ((DependencyMap, PDTagged) -> (DependencyMap, PDTagged))
-> (CondTree FlagName (PDTagged, DependencyMap)
    -> (DependencyMap, PDTagged))
-> CondTree FlagName (PDTagged, DependencyMap)
-> (DependencyMap, PDTagged)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PDTagged, DependencyMap) -> (DependencyMap, PDTagged)
forall a b. (a, b) -> (b, a)
swap
                  ((PDTagged, DependencyMap) -> (DependencyMap, PDTagged))
-> (CondTree FlagName (PDTagged, DependencyMap)
    -> (PDTagged, DependencyMap))
-> CondTree FlagName (PDTagged, DependencyMap)
-> (DependencyMap, PDTagged)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FlagName -> Either FlagName Bool)
-> CondTree FlagName (PDTagged, DependencyMap)
-> (PDTagged, DependencyMap)
forall a v.
Semigroup a =>
(v -> Either v Bool) -> CondTree v a -> a
simplifyCondTree (FlagAssignment -> FlagName -> Either FlagName Bool
env FlagAssignment
flags)
          deps :: DependencyMap
deps = ComponentRequestedSpec -> TargetSet PDTagged -> DependencyMap
overallDependencies ComponentRequestedSpec
enabled TargetSet PDTagged
targetSet
       in case [Dependency] -> DepTestRslt
checkDeps (DependencyMap -> [Dependency]
fromDepMap DependencyMap
deps) of
            DepTestRslt
DepOk
              | [Tree FlagAssignment] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Tree FlagAssignment]
ts -> (TargetSet PDTagged, FlagAssignment)
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
forall a b. b -> Either a b
Right (TargetSet PDTagged
targetSet, FlagAssignment
flags)
              | Bool
otherwise -> [Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)]
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
forall a b. Monoid a => [Either a b] -> Either a b
tryAll ([Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)]
 -> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment))
-> [Either
      [MissingDependency] (TargetSet PDTagged, FlagAssignment)]
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
forall a b. (a -> b) -> a -> b
$ (Tree FlagAssignment
 -> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment))
-> [Tree FlagAssignment]
-> [Either
      [MissingDependency] (TargetSet PDTagged, FlagAssignment)]
forall a b. (a -> b) -> [a] -> [b]
map Tree FlagAssignment
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
explore [Tree FlagAssignment]
ts
            MissingDeps [MissingDependency]
mds -> [MissingDependency]
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
forall a b. a -> Either a b
Left [MissingDependency]
mds

    -- Builds a tree of all possible flag assignments.  Internal nodes
    -- have only partial assignments.
    build :: FlagAssignment -> [(FlagName, [Bool])] -> Tree FlagAssignment
    build :: FlagAssignment -> [(FlagName, [Bool])] -> Tree FlagAssignment
build FlagAssignment
assigned [] = FlagAssignment -> [Tree FlagAssignment] -> Tree FlagAssignment
forall a. a -> [Tree a] -> Tree a
Node FlagAssignment
assigned []
    build FlagAssignment
assigned ((FlagName
fn, [Bool]
vals) : [(FlagName, [Bool])]
unassigned) =
      FlagAssignment -> [Tree FlagAssignment] -> Tree FlagAssignment
forall a. a -> [Tree a] -> Tree a
Node FlagAssignment
assigned ([Tree FlagAssignment] -> Tree FlagAssignment)
-> [Tree FlagAssignment] -> Tree FlagAssignment
forall a b. (a -> b) -> a -> b
$ (Bool -> Tree FlagAssignment) -> [Bool] -> [Tree FlagAssignment]
forall a b. (a -> b) -> [a] -> [b]
map (\Bool
v -> FlagAssignment -> [(FlagName, [Bool])] -> Tree FlagAssignment
build (FlagName -> Bool -> FlagAssignment -> FlagAssignment
insertFlagAssignment FlagName
fn Bool
v FlagAssignment
assigned) [(FlagName, [Bool])]
unassigned) [Bool]
vals

    tryAll :: Monoid a => [Either a b] -> Either a b
    tryAll :: forall a b. Monoid a => [Either a b] -> Either a b
tryAll = (Either a b -> Either a b -> Either a b)
-> Either a b -> [Either a b] -> Either a b
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Either a b -> Either a b -> Either a b
forall a b. Monoid a => Either a b -> Either a b -> Either a b
mp Either a b
forall a b. Monoid a => Either a b
mz

    -- special version of `mplus' for our local purposes
    mp :: Monoid a => Either a b -> Either a b -> Either a b
    mp :: forall a b. Monoid a => Either a b -> Either a b -> Either a b
mp m :: Either a b
m@(Right b
_) Either a b
_ = Either a b
m
    mp Either a b
_ m :: Either a b
m@(Right b
_) = Either a b
m
    mp (Left a
xs) (Left a
ys) = a -> Either a b
forall a b. a -> Either a b
Left (a
xs a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
ys)

    -- `mzero'
    mz :: Monoid a => Either a b
    mz :: forall a b. Monoid a => Either a b
mz = a -> Either a b
forall a b. a -> Either a b
Left a
forall a. Monoid a => a
mempty

    env :: FlagAssignment -> FlagName -> Either FlagName Bool
    env :: FlagAssignment -> FlagName -> Either FlagName Bool
env FlagAssignment
flags FlagName
flag = (Either FlagName Bool
-> (Bool -> Either FlagName Bool)
-> Maybe Bool
-> Either FlagName Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (FlagName -> Either FlagName Bool
forall a b. a -> Either a b
Left FlagName
flag) Bool -> Either FlagName Bool
forall a b. b -> Either a b
Right (Maybe Bool -> Either FlagName Bool)
-> (FlagAssignment -> Maybe Bool)
-> FlagAssignment
-> Either FlagName Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FlagName -> FlagAssignment -> Maybe Bool
lookupFlagAssignment FlagName
flag) FlagAssignment
flags

-- | Transforms a 'CondTree' by putting the input under the "then" branch of a
-- conditional that is True when Buildable is True. If 'addBuildableCondition'
-- can determine that Buildable is always True, it returns the input unchanged.
-- If Buildable is always False, it returns the empty 'CondTree'.
addBuildableCondition
  :: (Eq v, Monoid a)
  => (a -> BuildInfo)
  -> CondTree v a
  -> CondTree v a
addBuildableCondition :: forall v a.
(Eq v, Monoid a) =>
(a -> BuildInfo) -> CondTree v a -> CondTree v a
addBuildableCondition a -> BuildInfo
getInfo CondTree v a
t =
  case (a -> Bool) -> CondTree v a -> Condition v
forall v a. Eq v => (a -> Bool) -> CondTree v a -> Condition v
extractCondition (BuildInfo -> Bool
buildable (BuildInfo -> Bool) -> (a -> BuildInfo) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> BuildInfo
getInfo) CondTree v a
t of
    Lit Bool
True -> CondTree v a
t
    Lit Bool
False -> a -> [CondBranch v a] -> CondTree v a
forall v a. a -> [CondBranch v a] -> CondTree v a
CondNode a
forall a. Monoid a => a
mempty []
    Condition v
c -> a -> [CondBranch v a] -> CondTree v a
forall v a. a -> [CondBranch v a] -> CondTree v a
CondNode a
forall a. Monoid a => a
mempty [Condition v -> CondTree v a -> CondBranch v a
forall v a. Condition v -> CondTree v a -> CondBranch v a
condIfThen Condition v
c CondTree v a
t]

-- | This is a special version of 'addBuildableCondition' for the 'PDTagged'
-- type.
--
-- It is not simply a specialisation. It is more complicated than it
-- ought to be because of the way the 'PDTagged' monoid instance works. The
-- @mempty = 'PDNull'@ forgets the component type, which has the effect of
-- completely deleting components that are not buildable.
--
-- See <https://github.com/haskell/cabal/pull/4094> for more details.
addBuildableConditionPDTagged
  :: Eq v
  => CondTree v PDTagged
  -> CondTree v PDTagged
addBuildableConditionPDTagged :: forall v. Eq v => CondTree v PDTagged -> CondTree v PDTagged
addBuildableConditionPDTagged CondTree v PDTagged
t =
  case (PDTagged -> Bool) -> CondTree v PDTagged -> Condition v
forall v a. Eq v => (a -> Bool) -> CondTree v a -> Condition v
extractCondition (BuildInfo -> Bool
buildable (BuildInfo -> Bool) -> (PDTagged -> BuildInfo) -> PDTagged -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PDTagged -> BuildInfo
getInfo) CondTree v PDTagged
t of
    Lit Bool
True -> CondTree v PDTagged
t
    Lit Bool
False -> (PDTagged -> PDTagged)
-> CondTree v PDTagged -> CondTree v PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData PDTagged -> PDTagged
deleteConstraints CondTree v PDTagged
t
    Condition v
c -> PDTagged -> [CondBranch v PDTagged] -> CondTree v PDTagged
forall v a. a -> [CondBranch v a] -> CondTree v a
CondNode PDTagged
forall a. Monoid a => a
mempty [Condition v
-> CondTree v PDTagged
-> CondTree v PDTagged
-> CondBranch v PDTagged
forall v a.
Condition v -> CondTree v a -> CondTree v a -> CondBranch v a
condIfThenElse Condition v
c CondTree v PDTagged
t ((PDTagged -> PDTagged)
-> CondTree v PDTagged -> CondTree v PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData PDTagged -> PDTagged
deleteConstraints CondTree v PDTagged
t)]
  where
    deleteConstraints :: PDTagged -> PDTagged
deleteConstraints (Lib Library
lib) = Library -> PDTagged
Lib (ASetter Library Library [Dependency] [Dependency]
-> [Dependency] -> Library -> Library
forall s t a b. ASetter s t a b -> b -> s -> t
L.set ASetter Library Library [Dependency] [Dependency]
forall a. HasBuildInfo a => Lens' a [Dependency]
Lens' Library [Dependency]
L.targetBuildDepends [Dependency]
forall a. Monoid a => a
mempty Library
lib)
    deleteConstraints (SubComp UnqualComponentName
unqualName Component
comp) = UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
unqualName (ASetter Component Component [Dependency] [Dependency]
-> [Dependency] -> Component -> Component
forall s t a b. ASetter s t a b -> b -> s -> t
L.set ASetter Component Component [Dependency] [Dependency]
forall a. HasBuildInfo a => Lens' a [Dependency]
Lens' Component [Dependency]
L.targetBuildDepends [Dependency]
forall a. Monoid a => a
mempty Component
comp)
    deleteConstraints PDTagged
PDNull = PDTagged
PDNull

    getInfo :: PDTagged -> BuildInfo
    getInfo :: PDTagged -> BuildInfo
getInfo (Lib Library
l) = Library -> BuildInfo
libBuildInfo Library
l
    getInfo (SubComp UnqualComponentName
_ Component
c) = Component -> BuildInfo
componentBuildInfo Component
c
    getInfo PDTagged
PDNull = BuildInfo
forall a. Monoid a => a
mempty

-- Note: extracting buildable conditions.
-- --------------------------------------
--
-- If the conditions in a cond tree lead to Buildable being set to False, then
-- none of the dependencies for this cond tree should actually be taken into
-- account. On the other hand, some of the flags may only be decided in the
-- solver, so we cannot necessarily make the decision whether a component is
-- Buildable or not prior to solving.
--
-- What we are doing here is to partially evaluate a condition tree in order to
-- extract the condition under which Buildable is True. The predicate determines
-- whether data under a 'CondTree' is buildable.

-- | Extract conditions matched by the given predicate from all cond trees in a
-- 'GenericPackageDescription'.
extractConditions
  :: (BuildInfo -> Bool)
  -> GenericPackageDescription
  -> [Condition ConfVar]
extractConditions :: (BuildInfo -> Bool)
-> GenericPackageDescription -> [Condition ConfVar]
extractConditions BuildInfo -> Bool
f GenericPackageDescription
gpkg =
  [[Condition ConfVar]] -> [Condition ConfVar]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
    [ (Library -> Bool) -> CondTree ConfVar Library -> Condition ConfVar
forall v a. Eq v => (a -> Bool) -> CondTree v a -> Condition v
extractCondition (BuildInfo -> Bool
f (BuildInfo -> Bool) -> (Library -> BuildInfo) -> Library -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Library -> BuildInfo
libBuildInfo) (CondTree ConfVar Library -> Condition ConfVar)
-> [CondTree ConfVar Library] -> [Condition ConfVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (CondTree ConfVar Library) -> [CondTree ConfVar Library]
forall a. Maybe a -> [a]
maybeToList (GenericPackageDescription -> Maybe (CondTree ConfVar Library)
condLibrary GenericPackageDescription
gpkg)
    , (Library -> Bool) -> CondTree ConfVar Library -> Condition ConfVar
forall v a. Eq v => (a -> Bool) -> CondTree v a -> Condition v
extractCondition (BuildInfo -> Bool
f (BuildInfo -> Bool) -> (Library -> BuildInfo) -> Library -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Library -> BuildInfo
libBuildInfo) (CondTree ConfVar Library -> Condition ConfVar)
-> ((UnqualComponentName, CondTree ConfVar Library)
    -> CondTree ConfVar Library)
-> (UnqualComponentName, CondTree ConfVar Library)
-> Condition ConfVar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, CondTree ConfVar Library)
-> CondTree ConfVar Library
forall a b. (a, b) -> b
snd ((UnqualComponentName, CondTree ConfVar Library)
 -> Condition ConfVar)
-> [(UnqualComponentName, CondTree ConfVar Library)]
-> [Condition ConfVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar Library)]
condSubLibraries GenericPackageDescription
gpkg
    , (Executable -> Bool)
-> CondTree ConfVar Executable -> Condition ConfVar
forall v a. Eq v => (a -> Bool) -> CondTree v a -> Condition v
extractCondition (BuildInfo -> Bool
f (BuildInfo -> Bool)
-> (Executable -> BuildInfo) -> Executable -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> BuildInfo
buildInfo) (CondTree ConfVar Executable -> Condition ConfVar)
-> ((UnqualComponentName, CondTree ConfVar Executable)
    -> CondTree ConfVar Executable)
-> (UnqualComponentName, CondTree ConfVar Executable)
-> Condition ConfVar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, CondTree ConfVar Executable)
-> CondTree ConfVar Executable
forall a b. (a, b) -> b
snd ((UnqualComponentName, CondTree ConfVar Executable)
 -> Condition ConfVar)
-> [(UnqualComponentName, CondTree ConfVar Executable)]
-> [Condition ConfVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar Executable)]
condExecutables GenericPackageDescription
gpkg
    , (TestSuite -> Bool)
-> CondTree ConfVar TestSuite -> Condition ConfVar
forall v a. Eq v => (a -> Bool) -> CondTree v a -> Condition v
extractCondition (BuildInfo -> Bool
f (BuildInfo -> Bool)
-> (TestSuite -> BuildInfo) -> TestSuite -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TestSuite -> BuildInfo
testBuildInfo) (CondTree ConfVar TestSuite -> Condition ConfVar)
-> ((UnqualComponentName, CondTree ConfVar TestSuite)
    -> CondTree ConfVar TestSuite)
-> (UnqualComponentName, CondTree ConfVar TestSuite)
-> Condition ConfVar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, CondTree ConfVar TestSuite)
-> CondTree ConfVar TestSuite
forall a b. (a, b) -> b
snd ((UnqualComponentName, CondTree ConfVar TestSuite)
 -> Condition ConfVar)
-> [(UnqualComponentName, CondTree ConfVar TestSuite)]
-> [Condition ConfVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar TestSuite)]
condTestSuites GenericPackageDescription
gpkg
    , (Benchmark -> Bool)
-> CondTree ConfVar Benchmark -> Condition ConfVar
forall v a. Eq v => (a -> Bool) -> CondTree v a -> Condition v
extractCondition (BuildInfo -> Bool
f (BuildInfo -> Bool)
-> (Benchmark -> BuildInfo) -> Benchmark -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Benchmark -> BuildInfo
benchmarkBuildInfo) (CondTree ConfVar Benchmark -> Condition ConfVar)
-> ((UnqualComponentName, CondTree ConfVar Benchmark)
    -> CondTree ConfVar Benchmark)
-> (UnqualComponentName, CondTree ConfVar Benchmark)
-> Condition ConfVar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, CondTree ConfVar Benchmark)
-> CondTree ConfVar Benchmark
forall a b. (a, b) -> b
snd ((UnqualComponentName, CondTree ConfVar Benchmark)
 -> Condition ConfVar)
-> [(UnqualComponentName, CondTree ConfVar Benchmark)]
-> [Condition ConfVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar Benchmark)]
condBenchmarks GenericPackageDescription
gpkg
    ]

freeVars :: CondTree ConfVar a -> [FlagName]
freeVars :: forall a. CondTree ConfVar a -> [FlagName]
freeVars CondTree ConfVar a
t = [FlagName
f | PackageFlag FlagName
f <- CondTree ConfVar a -> [ConfVar]
forall {b} {a}. CondTree b a -> [b]
freeVars' CondTree ConfVar a
t]
  where
    freeVars' :: CondTree b a -> [b]
freeVars' (CondNode a
_ [CondBranch b a]
ifs) = (CondBranch b a -> [b]) -> [CondBranch b a] -> [b]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CondBranch b a -> [b]
compfv [CondBranch b a]
ifs
    compfv :: CondBranch b a -> [b]
compfv (CondBranch Condition b
c CondTree b a
ct Maybe (CondTree b a)
mct) = Condition b -> [b]
forall {a}. Condition a -> [a]
condfv Condition b
c [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++ CondTree b a -> [b]
freeVars' CondTree b a
ct [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++ [b] -> (CondTree b a -> [b]) -> Maybe (CondTree b a) -> [b]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] CondTree b a -> [b]
freeVars' Maybe (CondTree b a)
mct
    condfv :: Condition a -> [a]
condfv Condition a
c = case Condition a
c of
      Var a
v -> [a
v]
      Lit Bool
_ -> []
      CNot Condition a
c' -> Condition a -> [a]
condfv Condition a
c'
      COr Condition a
c1 Condition a
c2 -> Condition a -> [a]
condfv Condition a
c1 [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ Condition a -> [a]
condfv Condition a
c2
      CAnd Condition a
c1 Condition a
c2 -> Condition a -> [a]
condfv Condition a
c1 [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ Condition a -> [a]
condfv Condition a
c2

------------------------------------------------------------------------------

-- | A set of targets with their package dependencies
newtype TargetSet a = TargetSet [(DependencyMap, a)]

-- | Combine the target-specific dependencies in a TargetSet to give the
-- dependencies for the package as a whole.
overallDependencies :: ComponentRequestedSpec -> TargetSet PDTagged -> DependencyMap
overallDependencies :: ComponentRequestedSpec -> TargetSet PDTagged -> DependencyMap
overallDependencies ComponentRequestedSpec
enabled (TargetSet [(DependencyMap, PDTagged)]
targets) = [DependencyMap] -> DependencyMap
forall a. Monoid a => [a] -> a
mconcat [DependencyMap]
depss
  where
    ([DependencyMap]
depss, [PDTagged]
_) = [(DependencyMap, PDTagged)] -> ([DependencyMap], [PDTagged])
forall a b. [(a, b)] -> ([a], [b])
unzip ([(DependencyMap, PDTagged)] -> ([DependencyMap], [PDTagged]))
-> [(DependencyMap, PDTagged)] -> ([DependencyMap], [PDTagged])
forall a b. (a -> b) -> a -> b
$ ((DependencyMap, PDTagged) -> Bool)
-> [(DependencyMap, PDTagged)] -> [(DependencyMap, PDTagged)]
forall a. (a -> Bool) -> [a] -> [a]
filter (PDTagged -> Bool
removeDisabledSections (PDTagged -> Bool)
-> ((DependencyMap, PDTagged) -> PDTagged)
-> (DependencyMap, PDTagged)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DependencyMap, PDTagged) -> PDTagged
forall a b. (a, b) -> b
snd) [(DependencyMap, PDTagged)]
targets
    removeDisabledSections :: PDTagged -> Bool
    -- UGH. The embedded componentName in the 'Component's here is
    -- BLANK.  I don't know whose fault this is but I'll use the tag
    -- instead. -- ezyang
    removeDisabledSections :: PDTagged -> Bool
removeDisabledSections (Lib Library
_) =
      ComponentRequestedSpec -> ComponentName -> Bool
componentNameRequested
        ComponentRequestedSpec
enabled
        (LibraryName -> ComponentName
CLibName LibraryName
LMainLibName)
    removeDisabledSections (SubComp UnqualComponentName
t Component
c) =
      -- Do NOT use componentName
      ComponentRequestedSpec -> ComponentName -> Bool
componentNameRequested ComponentRequestedSpec
enabled (ComponentName -> Bool) -> ComponentName -> Bool
forall a b. (a -> b) -> a -> b
$
        case Component
c of
          CLib Library
_ -> LibraryName -> ComponentName
CLibName (UnqualComponentName -> LibraryName
LSubLibName UnqualComponentName
t)
          CFLib ForeignLib
_ -> UnqualComponentName -> ComponentName
CFLibName UnqualComponentName
t
          CExe Executable
_ -> UnqualComponentName -> ComponentName
CExeName UnqualComponentName
t
          CTest TestSuite
_ -> UnqualComponentName -> ComponentName
CTestName UnqualComponentName
t
          CBench Benchmark
_ -> UnqualComponentName -> ComponentName
CBenchName UnqualComponentName
t
    removeDisabledSections PDTagged
PDNull = Bool
True

-- | Collect up the targets in a TargetSet of tagged targets, storing the
-- dependencies as we go.
flattenTaggedTargets :: TargetSet PDTagged -> (Maybe Library, [(UnqualComponentName, Component)])
flattenTaggedTargets :: TargetSet PDTagged
-> (Maybe Library, [(UnqualComponentName, Component)])
flattenTaggedTargets (TargetSet [(DependencyMap, PDTagged)]
targets) = ((DependencyMap, PDTagged)
 -> (Maybe Library, [(UnqualComponentName, Component)])
 -> (Maybe Library, [(UnqualComponentName, Component)]))
-> (Maybe Library, [(UnqualComponentName, Component)])
-> [(DependencyMap, PDTagged)]
-> (Maybe Library, [(UnqualComponentName, Component)])
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (DependencyMap, PDTagged)
-> (Maybe Library, [(UnqualComponentName, Component)])
-> (Maybe Library, [(UnqualComponentName, Component)])
untag (Maybe Library
forall a. Maybe a
Nothing, []) [(DependencyMap, PDTagged)]
targets
  where
    untag :: (DependencyMap, PDTagged)
-> (Maybe Library, [(UnqualComponentName, Component)])
-> (Maybe Library, [(UnqualComponentName, Component)])
untag (DependencyMap
depMap, PDTagged
pdTagged) (Maybe Library, [(UnqualComponentName, Component)])
accum = case (PDTagged
pdTagged, (Maybe Library, [(UnqualComponentName, Component)])
accum) of
      (Lib Library
_, (Just Library
_, [(UnqualComponentName, Component)]
_)) -> String -> (Maybe Library, [(UnqualComponentName, Component)])
forall a. String -> a
userBug String
"Only one library expected"
      (Lib Library
l, (Maybe Library
Nothing, [(UnqualComponentName, Component)]
comps)) -> (Library -> Maybe Library
forall a. a -> Maybe a
Just (Library -> Maybe Library) -> Library -> Maybe Library
forall a b. (a -> b) -> a -> b
$ Library -> Library
forall a. HasBuildInfo a => a -> a
redoBD Library
l, [(UnqualComponentName, Component)]
comps)
      (SubComp UnqualComponentName
n Component
c, (Maybe Library
mb_lib, [(UnqualComponentName, Component)]
comps))
        | ((UnqualComponentName, Component) -> Bool)
-> [(UnqualComponentName, Component)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((UnqualComponentName -> UnqualComponentName -> Bool
forall a. Eq a => a -> a -> Bool
== UnqualComponentName
n) (UnqualComponentName -> Bool)
-> ((UnqualComponentName, Component) -> UnqualComponentName)
-> (UnqualComponentName, Component)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, Component) -> UnqualComponentName
forall a b. (a, b) -> a
fst) [(UnqualComponentName, Component)]
comps ->
            String -> (Maybe Library, [(UnqualComponentName, Component)])
forall a. String -> a
userBug (String -> (Maybe Library, [(UnqualComponentName, Component)]))
-> String -> (Maybe Library, [(UnqualComponentName, Component)])
forall a b. (a -> b) -> a -> b
$ String
"There exist several components with the same name: '" String -> String -> String
forall a. [a] -> [a] -> [a]
++ UnqualComponentName -> String
forall a. Pretty a => a -> String
prettyShow UnqualComponentName
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"'"
        | Bool
otherwise -> (Maybe Library
mb_lib, (UnqualComponentName
n, Component -> Component
forall a. HasBuildInfo a => a -> a
redoBD Component
c) (UnqualComponentName, Component)
-> [(UnqualComponentName, Component)]
-> [(UnqualComponentName, Component)]
forall a. a -> [a] -> [a]
: [(UnqualComponentName, Component)]
comps)
      (PDTagged
PDNull, (Maybe Library, [(UnqualComponentName, Component)])
x) -> (Maybe Library, [(UnqualComponentName, Component)])
x -- actually this should not happen, but let's be liberal
      where
        redoBD :: L.HasBuildInfo a => a -> a
        redoBD :: forall a. HasBuildInfo a => a -> a
redoBD = ASetter a a [Dependency] [Dependency] -> [Dependency] -> a -> a
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter a a [Dependency] [Dependency]
forall a. HasBuildInfo a => Lens' a [Dependency]
Lens' a [Dependency]
L.targetBuildDepends ([Dependency] -> a -> a) -> [Dependency] -> a -> a
forall a b. (a -> b) -> a -> b
$ DependencyMap -> [Dependency]
fromDepMap DependencyMap
depMap

------------------------------------------------------------------------------
-- Convert GenericPackageDescription to PackageDescription
--

data PDTagged
  = Lib Library
  | SubComp UnqualComponentName Component
  | PDNull
  deriving (Int -> PDTagged -> String -> String
[PDTagged] -> String -> String
PDTagged -> String
(Int -> PDTagged -> String -> String)
-> (PDTagged -> String)
-> ([PDTagged] -> String -> String)
-> Show PDTagged
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PDTagged -> String -> String
showsPrec :: Int -> PDTagged -> String -> String
$cshow :: PDTagged -> String
show :: PDTagged -> String
$cshowList :: [PDTagged] -> String -> String
showList :: [PDTagged] -> String -> String
Show)

instance Monoid PDTagged where
  mempty :: PDTagged
mempty = PDTagged
PDNull
  mappend :: PDTagged -> PDTagged -> PDTagged
mappend = PDTagged -> PDTagged -> PDTagged
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup PDTagged where
  PDTagged
PDNull <> :: PDTagged -> PDTagged -> PDTagged
<> PDTagged
x = PDTagged
x
  PDTagged
x <> PDTagged
PDNull = PDTagged
x
  Lib Library
l <> Lib Library
l' = Library -> PDTagged
Lib (Library
l Library -> Library -> Library
forall a. Semigroup a => a -> a -> a
<> Library
l')
  SubComp UnqualComponentName
n Component
x <> SubComp UnqualComponentName
n' Component
x' | UnqualComponentName
n UnqualComponentName -> UnqualComponentName -> Bool
forall a. Eq a => a -> a -> Bool
== UnqualComponentName
n' = UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
n (Component
x Component -> Component -> Component
forall a. Semigroup a => a -> a -> a
<> Component
x')
  PDTagged
_ <> PDTagged
_ = String -> PDTagged
forall a. String -> a
cabalBug String
"Cannot combine incompatible tags"

instance L.HasBuildInfo PDTagged where
  buildInfo :: Lens' PDTagged BuildInfo
buildInfo BuildInfo -> f BuildInfo
f PDTagged
x = case PDTagged
x of
    Lib Library
lib -> Library -> PDTagged
Lib (Library -> PDTagged) -> f Library -> f PDTagged
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LensLike f Library Library BuildInfo BuildInfo
forall a. HasBuildInfo a => Lens' a BuildInfo
Lens' Library BuildInfo
L.buildInfo BuildInfo -> f BuildInfo
f Library
lib
    SubComp UnqualComponentName
name Component
comp -> UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
name (Component -> PDTagged) -> f Component -> f PDTagged
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LensLike f Component Component BuildInfo BuildInfo
forall a. HasBuildInfo a => Lens' a BuildInfo
Lens' Component BuildInfo
L.buildInfo BuildInfo -> f BuildInfo
f Component
comp
    PDTagged
PDNull -> PDTagged
PDNull PDTagged -> f BuildInfo -> f PDTagged
forall a b. a -> f b -> f a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ BuildInfo -> f BuildInfo
f BuildInfo
forall a. Monoid a => a
mempty

-- | Create a package description with all configurations resolved.
--
-- This function takes a `GenericPackageDescription` and several environment
-- parameters and tries to generate `PackageDescription` by finding a flag
-- assignment that result in satisfiable dependencies.
--
-- It takes as inputs a not necessarily complete specifications of flags
-- assignments, an optional package index as well as platform parameters.  If
-- some flags are not assigned explicitly, this function will try to pick an
-- assignment that causes this function to succeed.  The package index is
-- optional since on some platforms we cannot determine which packages have
-- been installed before.  When no package index is supplied, every dependency
-- is assumed to be satisfiable, therefore all not explicitly assigned flags
-- will get their default values.
--
-- This function will fail if it cannot find a flag assignment that leads to
-- satisfiable dependencies.  (It will not try alternative assignments for
-- explicitly specified flags.)  In case of failure it will return the missing
-- dependencies that it encountered when trying different flag assignments.
-- On success, it will return the package description and the full flag
-- assignment chosen.
--
-- Note that this drops any stanzas which have @buildable: False@.  While
-- this is arguably the right thing to do, it means we give bad error
-- messages in some situations, see #3858.
finalizePD
  :: FlagAssignment
  -- ^ Explicitly specified flag assignments
  -> ComponentRequestedSpec
  -> (Dependency -> DependencySatisfaction)
  -- ^ Is a given dependency satisfiable from the set of
  -- available packages?  If this is unknown then use
  -- True.
  -> Platform
  -- ^ The 'Arch' and 'OS'
  -> CompilerInfo
  -- ^ Compiler information
  -> [PackageVersionConstraint]
  -- ^ Additional constraints
  -> GenericPackageDescription
  -> Either
      [MissingDependency]
      (PackageDescription, FlagAssignment)
  -- ^ Either missing dependencies or the resolved package
  -- description along with the flag assignments chosen.
finalizePD :: FlagAssignment
-> ComponentRequestedSpec
-> (Dependency -> DependencySatisfaction)
-> Platform
-> CompilerInfo
-> [PackageVersionConstraint]
-> GenericPackageDescription
-> Either [MissingDependency] (PackageDescription, FlagAssignment)
finalizePD
  FlagAssignment
userflags
  ComponentRequestedSpec
enabled
  Dependency -> DependencySatisfaction
satisfyDep
  (Platform Arch
arch OS
os)
  CompilerInfo
impl
  [PackageVersionConstraint]
constraints
  (GenericPackageDescription PackageDescription
pkg Maybe Version
_ver [PackageFlag]
flags Maybe (CondTree ConfVar Library)
mb_lib0 [(UnqualComponentName, CondTree ConfVar Library)]
sub_libs0 [(UnqualComponentName, CondTree ConfVar ForeignLib)]
flibs0 [(UnqualComponentName, CondTree ConfVar Executable)]
exes0 [(UnqualComponentName, CondTree ConfVar TestSuite)]
tests0 [(UnqualComponentName, CondTree ConfVar Benchmark)]
bms0) = do
    (targetSet, flagVals) <-
      [(FlagName, [Bool])]
-> ComponentRequestedSpec
-> OS
-> Arch
-> CompilerInfo
-> [PackageVersionConstraint]
-> [CondTree ConfVar PDTagged]
-> ([Dependency] -> DepTestRslt)
-> Either [MissingDependency] (TargetSet PDTagged, FlagAssignment)
resolveWithFlags [(FlagName, [Bool])]
flagChoices ComponentRequestedSpec
enabled OS
os Arch
arch CompilerInfo
impl [PackageVersionConstraint]
constraints [CondTree ConfVar PDTagged]
condTrees [Dependency] -> DepTestRslt
check
    let
      (mb_lib, comps) = flattenTaggedTargets targetSet
      mb_lib' = (Library -> Library) -> Maybe Library -> Maybe Library
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Library -> Library
libFillInDefaults Maybe Library
mb_lib
      comps' = (((UnqualComponentName, Component) -> Component)
 -> [(UnqualComponentName, Component)] -> [Component])
-> [(UnqualComponentName, Component)]
-> ((UnqualComponentName, Component) -> Component)
-> [Component]
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((UnqualComponentName, Component) -> Component)
-> [(UnqualComponentName, Component)] -> [Component]
forall a b. (a -> b) -> [a] -> [b]
map [(UnqualComponentName, Component)]
comps (((UnqualComponentName, Component) -> Component) -> [Component])
-> ((UnqualComponentName, Component) -> Component) -> [Component]
forall a b. (a -> b) -> a -> b
$ \(UnqualComponentName
n, Component
c) ->
        (Library -> Component)
-> (ForeignLib -> Component)
-> (Executable -> Component)
-> (TestSuite -> Component)
-> (Benchmark -> Component)
-> Component
-> Component
forall a.
(Library -> a)
-> (ForeignLib -> a)
-> (Executable -> a)
-> (TestSuite -> a)
-> (Benchmark -> a)
-> Component
-> a
foldComponent
          ( \Library
l ->
              Library -> Component
CLib
                (Library -> Library
libFillInDefaults Library
l)
                  { libName = LSubLibName n
                  , libExposed = False
                  }
          )
          (\ForeignLib
l -> ForeignLib -> Component
CFLib (ForeignLib -> ForeignLib
flibFillInDefaults ForeignLib
l){foreignLibName = n})
          (\Executable
e -> Executable -> Component
CExe (Executable -> Executable
exeFillInDefaults Executable
e){exeName = n})
          (\TestSuite
t -> TestSuite -> Component
CTest (TestSuite -> TestSuite
testFillInDefaults TestSuite
t){testName = n})
          (\Benchmark
b -> Benchmark -> Component
CBench (Benchmark -> Benchmark
benchFillInDefaults Benchmark
b){benchmarkName = n})
          Component
c
      (sub_libs', flibs', exes', tests', bms') = partitionComponents comps'
    return
      ( pkg
          { library = mb_lib'
          , subLibraries = sub_libs'
          , foreignLibs = flibs'
          , executables = exes'
          , testSuites = tests'
          , benchmarks = bms'
          }
      , flagVals
      )
    where
      -- Combine lib, exes, and tests into one list of @CondTree@s with tagged data
      condTrees :: [CondTree ConfVar PDTagged]
condTrees =
        Maybe (CondTree ConfVar PDTagged) -> [CondTree ConfVar PDTagged]
forall a. Maybe a -> [a]
maybeToList ((CondTree ConfVar Library -> CondTree ConfVar PDTagged)
-> Maybe (CondTree ConfVar Library)
-> Maybe (CondTree ConfVar PDTagged)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Library -> PDTagged)
-> CondTree ConfVar Library -> CondTree ConfVar PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData Library -> PDTagged
Lib) Maybe (CondTree ConfVar Library)
mb_lib0)
          [CondTree ConfVar PDTagged]
-> [CondTree ConfVar PDTagged] -> [CondTree ConfVar PDTagged]
forall a. [a] -> [a] -> [a]
++ ((UnqualComponentName, CondTree ConfVar Library)
 -> CondTree ConfVar PDTagged)
-> [(UnqualComponentName, CondTree ConfVar Library)]
-> [CondTree ConfVar PDTagged]
forall a b. (a -> b) -> [a] -> [b]
map (\(UnqualComponentName
name, CondTree ConfVar Library
tree) -> (Library -> PDTagged)
-> CondTree ConfVar Library -> CondTree ConfVar PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData (UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
name (Component -> PDTagged)
-> (Library -> Component) -> Library -> PDTagged
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Library -> Component
CLib) CondTree ConfVar Library
tree) [(UnqualComponentName, CondTree ConfVar Library)]
sub_libs0
          [CondTree ConfVar PDTagged]
-> [CondTree ConfVar PDTagged] -> [CondTree ConfVar PDTagged]
forall a. [a] -> [a] -> [a]
++ ((UnqualComponentName, CondTree ConfVar ForeignLib)
 -> CondTree ConfVar PDTagged)
-> [(UnqualComponentName, CondTree ConfVar ForeignLib)]
-> [CondTree ConfVar PDTagged]
forall a b. (a -> b) -> [a] -> [b]
map (\(UnqualComponentName
name, CondTree ConfVar ForeignLib
tree) -> (ForeignLib -> PDTagged)
-> CondTree ConfVar ForeignLib -> CondTree ConfVar PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData (UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
name (Component -> PDTagged)
-> (ForeignLib -> Component) -> ForeignLib -> PDTagged
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignLib -> Component
CFLib) CondTree ConfVar ForeignLib
tree) [(UnqualComponentName, CondTree ConfVar ForeignLib)]
flibs0
          [CondTree ConfVar PDTagged]
-> [CondTree ConfVar PDTagged] -> [CondTree ConfVar PDTagged]
forall a. [a] -> [a] -> [a]
++ ((UnqualComponentName, CondTree ConfVar Executable)
 -> CondTree ConfVar PDTagged)
-> [(UnqualComponentName, CondTree ConfVar Executable)]
-> [CondTree ConfVar PDTagged]
forall a b. (a -> b) -> [a] -> [b]
map (\(UnqualComponentName
name, CondTree ConfVar Executable
tree) -> (Executable -> PDTagged)
-> CondTree ConfVar Executable -> CondTree ConfVar PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData (UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
name (Component -> PDTagged)
-> (Executable -> Component) -> Executable -> PDTagged
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> Component
CExe) CondTree ConfVar Executable
tree) [(UnqualComponentName, CondTree ConfVar Executable)]
exes0
          [CondTree ConfVar PDTagged]
-> [CondTree ConfVar PDTagged] -> [CondTree ConfVar PDTagged]
forall a. [a] -> [a] -> [a]
++ ((UnqualComponentName, CondTree ConfVar TestSuite)
 -> CondTree ConfVar PDTagged)
-> [(UnqualComponentName, CondTree ConfVar TestSuite)]
-> [CondTree ConfVar PDTagged]
forall a b. (a -> b) -> [a] -> [b]
map (\(UnqualComponentName
name, CondTree ConfVar TestSuite
tree) -> (TestSuite -> PDTagged)
-> CondTree ConfVar TestSuite -> CondTree ConfVar PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData (UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
name (Component -> PDTagged)
-> (TestSuite -> Component) -> TestSuite -> PDTagged
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TestSuite -> Component
CTest) CondTree ConfVar TestSuite
tree) [(UnqualComponentName, CondTree ConfVar TestSuite)]
tests0
          [CondTree ConfVar PDTagged]
-> [CondTree ConfVar PDTagged] -> [CondTree ConfVar PDTagged]
forall a. [a] -> [a] -> [a]
++ ((UnqualComponentName, CondTree ConfVar Benchmark)
 -> CondTree ConfVar PDTagged)
-> [(UnqualComponentName, CondTree ConfVar Benchmark)]
-> [CondTree ConfVar PDTagged]
forall a b. (a -> b) -> [a] -> [b]
map (\(UnqualComponentName
name, CondTree ConfVar Benchmark
tree) -> (Benchmark -> PDTagged)
-> CondTree ConfVar Benchmark -> CondTree ConfVar PDTagged
forall a b v. (a -> b) -> CondTree v a -> CondTree v b
mapTreeData (UnqualComponentName -> Component -> PDTagged
SubComp UnqualComponentName
name (Component -> PDTagged)
-> (Benchmark -> Component) -> Benchmark -> PDTagged
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Benchmark -> Component
CBench) CondTree ConfVar Benchmark
tree) [(UnqualComponentName, CondTree ConfVar Benchmark)]
bms0

      flagChoices :: [(FlagName, [Bool])]
flagChoices = (PackageFlag -> (FlagName, [Bool]))
-> [PackageFlag] -> [(FlagName, [Bool])]
forall a b. (a -> b) -> [a] -> [b]
map (\(MkPackageFlag FlagName
n String
_ Bool
d Bool
manual) -> (FlagName
n, Bool -> FlagName -> Bool -> [Bool]
d2c Bool
manual FlagName
n Bool
d)) [PackageFlag]
flags
      d2c :: Bool -> FlagName -> Bool -> [Bool]
d2c Bool
manual FlagName
n Bool
b = case FlagName -> FlagAssignment -> Maybe Bool
lookupFlagAssignment FlagName
n FlagAssignment
userflags of
        Just Bool
val -> [Bool
val]
        Maybe Bool
Nothing
          | Bool
manual -> [Bool
b]
          | Bool
otherwise -> [Bool
b, Bool -> Bool
not Bool
b]
      -- flagDefaults = map (\(n,x:_) -> (n,x)) flagChoices
      check :: [Dependency] -> DepTestRslt
check [Dependency]
ds =
        let missingDeps :: [MissingDependency]
missingDeps =
              [ Dependency -> MissingDependencyReason -> MissingDependency
MissingDependency Dependency
dependency MissingDependencyReason
reason
              | (Dependency
dependency, Unsatisfied MissingDependencyReason
reason) <-
                  (Dependency -> (Dependency, DependencySatisfaction))
-> [Dependency] -> [(Dependency, DependencySatisfaction)]
forall a b. (a -> b) -> [a] -> [b]
map (\Dependency
dependency -> (Dependency
dependency, Dependency -> DependencySatisfaction
satisfyDep Dependency
dependency)) [Dependency]
ds
              ]
         in if [MissingDependency] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [MissingDependency]
missingDeps
              then DepTestRslt
DepOk
              else [MissingDependency] -> DepTestRslt
MissingDeps [MissingDependency]
missingDeps

{-
let tst_p = (CondNode [1::Int] [Distribution.Package.Dependency "a" AnyVersion] [])
let tst_p2 = (CondNode [1::Int] [Distribution.Package.Dependency "a" (EarlierVersion (Version [1,0] [])), Distribution.Package.Dependency "a" (LaterVersion (Version [2,0] []))] [])

let p_index = Distribution.Simple.PackageIndex.fromList [Distribution.Package.PackageIdentifier "a" (Version [0,5] []), Distribution.Package.PackageIdentifier "a" (Version [2,5] [])]
let look = not . null . Distribution.Simple.PackageIndex.lookupDependency p_index
let looks ds = mconcat $ map (\d -> if look d then DepOk else MissingDeps [d]) ds
resolveWithFlags [] Distribution.System.Linux Distribution.System.I386 (Distribution.Compiler.GHC,Version [6,8,2] []) [tst_p] looks   ===>  Right ...
resolveWithFlags [] Distribution.System.Linux Distribution.System.I386 (Distribution.Compiler.GHC,Version [6,8,2] []) [tst_p2] looks  ===>  Left ...
-}

-- | Flatten a generic package description by ignoring all conditions and just
-- join the field descriptors into on package description.  Note, however,
-- that this may lead to inconsistent field values, since all values are
-- joined into one field, which may not be possible in the original package
-- description, due to the use of exclusive choices (if ... else ...).
--
-- TODO: One particularly tricky case is defaulting.  In the original package
-- description, e.g., the source directory might either be the default or a
-- certain, explicitly set path.  Since defaults are filled in only after the
-- package has been resolved and when no explicit value has been set, the
-- default path will be missing from the package description returned by this
-- function.
flattenPackageDescription :: GenericPackageDescription -> PackageDescription
flattenPackageDescription :: GenericPackageDescription -> PackageDescription
flattenPackageDescription
  (GenericPackageDescription PackageDescription
pkg Maybe Version
_ [PackageFlag]
_ Maybe (CondTree ConfVar Library)
mlib0 [(UnqualComponentName, CondTree ConfVar Library)]
sub_libs0 [(UnqualComponentName, CondTree ConfVar ForeignLib)]
flibs0 [(UnqualComponentName, CondTree ConfVar Executable)]
exes0 [(UnqualComponentName, CondTree ConfVar TestSuite)]
tests0 [(UnqualComponentName, CondTree ConfVar Benchmark)]
bms0) =
    PackageDescription
pkg
      { library = mlib
      , subLibraries = reverse sub_libs
      , foreignLibs = reverse flibs
      , executables = reverse exes
      , testSuites = reverse tests
      , benchmarks = reverse bms
      }
    where
      mlib :: Maybe Library
mlib = CondTree ConfVar Library -> Library
f (CondTree ConfVar Library -> Library)
-> Maybe (CondTree ConfVar Library) -> Maybe Library
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (CondTree ConfVar Library)
mlib0
        where
          f :: CondTree ConfVar Library -> Library
          f :: CondTree ConfVar Library -> Library
f CondTree ConfVar Library
lib = (Library -> Library
libFillInDefaults (Library -> Library)
-> (CondTree ConfVar Library -> Library)
-> CondTree ConfVar Library
-> Library
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CondTree ConfVar Library -> Library
forall a v. Semigroup a => CondTree v a -> a
ignoreConditions (CondTree ConfVar Library -> Library)
-> CondTree ConfVar Library -> Library
forall a b. (a -> b) -> a -> b
$ CondTree ConfVar Library
lib){libName = LMainLibName}
      sub_libs :: [Library]
sub_libs = (UnqualComponentName, CondTree ConfVar Library) -> Library
flattenLib ((UnqualComponentName, CondTree ConfVar Library) -> Library)
-> [(UnqualComponentName, CondTree ConfVar Library)] -> [Library]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(UnqualComponentName, CondTree ConfVar Library)]
sub_libs0
      flibs :: [ForeignLib]
flibs = (UnqualComponentName, CondTree ConfVar ForeignLib) -> ForeignLib
flattenFLib ((UnqualComponentName, CondTree ConfVar ForeignLib) -> ForeignLib)
-> [(UnqualComponentName, CondTree ConfVar ForeignLib)]
-> [ForeignLib]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(UnqualComponentName, CondTree ConfVar ForeignLib)]
flibs0
      exes :: [Executable]
exes = (UnqualComponentName, CondTree ConfVar Executable) -> Executable
flattenExe ((UnqualComponentName, CondTree ConfVar Executable) -> Executable)
-> [(UnqualComponentName, CondTree ConfVar Executable)]
-> [Executable]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(UnqualComponentName, CondTree ConfVar Executable)]
exes0
      tests :: [TestSuite]
tests = (UnqualComponentName, CondTree ConfVar TestSuite) -> TestSuite
flattenTst ((UnqualComponentName, CondTree ConfVar TestSuite) -> TestSuite)
-> [(UnqualComponentName, CondTree ConfVar TestSuite)]
-> [TestSuite]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(UnqualComponentName, CondTree ConfVar TestSuite)]
tests0
      bms :: [Benchmark]
bms = (UnqualComponentName, CondTree ConfVar Benchmark) -> Benchmark
flattenBm ((UnqualComponentName, CondTree ConfVar Benchmark) -> Benchmark)
-> [(UnqualComponentName, CondTree ConfVar Benchmark)]
-> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(UnqualComponentName, CondTree ConfVar Benchmark)]
bms0

      flattenLib :: (UnqualComponentName, CondTree ConfVar Library) -> Library
      flattenLib :: (UnqualComponentName, CondTree ConfVar Library) -> Library
flattenLib (UnqualComponentName
n, CondTree ConfVar Library
t) =
        Library -> Library
libFillInDefaults (Library -> Library) -> Library -> Library
forall a b. (a -> b) -> a -> b
$
          (CondTree ConfVar Library -> Library
forall a v. Semigroup a => CondTree v a -> a
ignoreConditions CondTree ConfVar Library
t)
            { libName = LSubLibName n
            , libExposed = False
            }

      flattenFLib :: (UnqualComponentName, CondTree ConfVar ForeignLib) -> ForeignLib
      flattenFLib :: (UnqualComponentName, CondTree ConfVar ForeignLib) -> ForeignLib
flattenFLib (UnqualComponentName
n, CondTree ConfVar ForeignLib
t) =
        ForeignLib -> ForeignLib
flibFillInDefaults (ForeignLib -> ForeignLib) -> ForeignLib -> ForeignLib
forall a b. (a -> b) -> a -> b
$
          (CondTree ConfVar ForeignLib -> ForeignLib
forall a v. Semigroup a => CondTree v a -> a
ignoreConditions CondTree ConfVar ForeignLib
t)
            { foreignLibName = n
            }

      flattenExe :: (UnqualComponentName, CondTree ConfVar Executable) -> Executable
      flattenExe :: (UnqualComponentName, CondTree ConfVar Executable) -> Executable
flattenExe (UnqualComponentName
n, CondTree ConfVar Executable
t) =
        Executable -> Executable
exeFillInDefaults (Executable -> Executable) -> Executable -> Executable
forall a b. (a -> b) -> a -> b
$
          (CondTree ConfVar Executable -> Executable
forall a v. Semigroup a => CondTree v a -> a
ignoreConditions CondTree ConfVar Executable
t)
            { exeName = n
            }

      flattenTst :: (UnqualComponentName, CondTree ConfVar TestSuite) -> TestSuite
      flattenTst :: (UnqualComponentName, CondTree ConfVar TestSuite) -> TestSuite
flattenTst (UnqualComponentName
n, CondTree ConfVar TestSuite
t) =
        TestSuite -> TestSuite
testFillInDefaults (TestSuite -> TestSuite) -> TestSuite -> TestSuite
forall a b. (a -> b) -> a -> b
$
          (CondTree ConfVar TestSuite -> TestSuite
forall a v. Semigroup a => CondTree v a -> a
ignoreConditions CondTree ConfVar TestSuite
t)
            { testName = n
            }

      flattenBm :: (UnqualComponentName, CondTree ConfVar Benchmark) -> Benchmark
      flattenBm :: (UnqualComponentName, CondTree ConfVar Benchmark) -> Benchmark
flattenBm (UnqualComponentName
n, CondTree ConfVar Benchmark
t) =
        Benchmark -> Benchmark
benchFillInDefaults (Benchmark -> Benchmark) -> Benchmark -> Benchmark
forall a b. (a -> b) -> a -> b
$
          (CondTree ConfVar Benchmark -> Benchmark
forall a v. Semigroup a => CondTree v a -> a
ignoreConditions CondTree ConfVar Benchmark
t)
            { benchmarkName = n
            }

-- This is in fact rather a hack.  The original version just overrode the
-- default values, however, when adding conditions we had to switch to a
-- modifier-based approach.  There, nothing is ever overwritten, but only
-- joined together.
--
-- This is the cleanest way i could think of, that doesn't require
-- changing all field parsing functions to return modifiers instead.
libFillInDefaults :: Library -> Library
libFillInDefaults :: Library -> Library
libFillInDefaults lib :: Library
lib@(Library{libBuildInfo :: Library -> BuildInfo
libBuildInfo = BuildInfo
bi}) =
  Library
lib{libBuildInfo = biFillInDefaults bi}

flibFillInDefaults :: ForeignLib -> ForeignLib
flibFillInDefaults :: ForeignLib -> ForeignLib
flibFillInDefaults flib :: ForeignLib
flib@(ForeignLib{foreignLibBuildInfo :: ForeignLib -> BuildInfo
foreignLibBuildInfo = BuildInfo
bi}) =
  ForeignLib
flib{foreignLibBuildInfo = biFillInDefaults bi}

exeFillInDefaults :: Executable -> Executable
exeFillInDefaults :: Executable -> Executable
exeFillInDefaults exe :: Executable
exe@(Executable{buildInfo :: Executable -> BuildInfo
buildInfo = BuildInfo
bi}) =
  Executable
exe{buildInfo = biFillInDefaults bi}

testFillInDefaults :: TestSuite -> TestSuite
testFillInDefaults :: TestSuite -> TestSuite
testFillInDefaults tst :: TestSuite
tst@(TestSuite{testBuildInfo :: TestSuite -> BuildInfo
testBuildInfo = BuildInfo
bi}) =
  TestSuite
tst{testBuildInfo = biFillInDefaults bi}

benchFillInDefaults :: Benchmark -> Benchmark
benchFillInDefaults :: Benchmark -> Benchmark
benchFillInDefaults bm :: Benchmark
bm@(Benchmark{benchmarkBuildInfo :: Benchmark -> BuildInfo
benchmarkBuildInfo = BuildInfo
bi}) =
  Benchmark
bm{benchmarkBuildInfo = biFillInDefaults bi}

biFillInDefaults :: BuildInfo -> BuildInfo
biFillInDefaults :: BuildInfo -> BuildInfo
biFillInDefaults BuildInfo
bi =
  if [SymbolicPath Pkg ('Dir Source)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (BuildInfo -> [SymbolicPath Pkg ('Dir Source)]
hsSourceDirs BuildInfo
bi)
    then BuildInfo
bi{hsSourceDirs = [sameDirectory]}
    else BuildInfo
bi

-- Walk a 'GenericPackageDescription' and apply @onBuildInfo@/@onSetupBuildInfo@
-- to all nested 'BuildInfo'/'SetupBuildInfo' values.
transformAllBuildInfos
  :: (BuildInfo -> BuildInfo)
  -> (SetupBuildInfo -> SetupBuildInfo)
  -> GenericPackageDescription
  -> GenericPackageDescription
transformAllBuildInfos :: (BuildInfo -> BuildInfo)
-> (SetupBuildInfo -> SetupBuildInfo)
-> GenericPackageDescription
-> GenericPackageDescription
transformAllBuildInfos BuildInfo -> BuildInfo
onBuildInfo SetupBuildInfo -> SetupBuildInfo
onSetupBuildInfo =
  ASetter
  GenericPackageDescription
  GenericPackageDescription
  BuildInfo
  BuildInfo
-> (BuildInfo -> BuildInfo)
-> GenericPackageDescription
-> GenericPackageDescription
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter
  GenericPackageDescription
  GenericPackageDescription
  BuildInfo
  BuildInfo
forall a. HasBuildInfos a => Traversal' a BuildInfo
Traversal' GenericPackageDescription BuildInfo
L.traverseBuildInfos BuildInfo -> BuildInfo
onBuildInfo
    (GenericPackageDescription -> GenericPackageDescription)
-> (GenericPackageDescription -> GenericPackageDescription)
-> GenericPackageDescription
-> GenericPackageDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASetter
  GenericPackageDescription
  GenericPackageDescription
  SetupBuildInfo
  SetupBuildInfo
-> (SetupBuildInfo -> SetupBuildInfo)
-> GenericPackageDescription
-> GenericPackageDescription
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over (LensLike
  Identity
  GenericPackageDescription
  GenericPackageDescription
  PackageDescription
  PackageDescription
Lens' GenericPackageDescription PackageDescription
L.packageDescription LensLike
  Identity
  GenericPackageDescription
  GenericPackageDescription
  PackageDescription
  PackageDescription
-> ((SetupBuildInfo -> Identity SetupBuildInfo)
    -> PackageDescription -> Identity PackageDescription)
-> ASetter
     GenericPackageDescription
     GenericPackageDescription
     SetupBuildInfo
     SetupBuildInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike
  Identity
  PackageDescription
  PackageDescription
  (Maybe SetupBuildInfo)
  (Maybe SetupBuildInfo)
Lens' PackageDescription (Maybe SetupBuildInfo)
L.setupBuildInfo LensLike
  Identity
  PackageDescription
  PackageDescription
  (Maybe SetupBuildInfo)
  (Maybe SetupBuildInfo)
-> ((SetupBuildInfo -> Identity SetupBuildInfo)
    -> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo))
-> (SetupBuildInfo -> Identity SetupBuildInfo)
-> PackageDescription
-> Identity PackageDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SetupBuildInfo -> Identity SetupBuildInfo)
-> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse) SetupBuildInfo -> SetupBuildInfo
onSetupBuildInfo

-- | Walk a 'GenericPackageDescription' and apply @f@ to all nested
-- @build-depends@ fields.
transformAllBuildDepends
  :: (Dependency -> Dependency)
  -> GenericPackageDescription
  -> GenericPackageDescription
transformAllBuildDepends :: (Dependency -> Dependency)
-> GenericPackageDescription -> GenericPackageDescription
transformAllBuildDepends Dependency -> Dependency
f =
  ASetter
  GenericPackageDescription
  GenericPackageDescription
  Dependency
  Dependency
-> (Dependency -> Dependency)
-> GenericPackageDescription
-> GenericPackageDescription
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over (ASetter
  GenericPackageDescription
  GenericPackageDescription
  BuildInfo
  BuildInfo
forall a. HasBuildInfos a => Traversal' a BuildInfo
Traversal' GenericPackageDescription BuildInfo
L.traverseBuildInfos ASetter
  GenericPackageDescription
  GenericPackageDescription
  BuildInfo
  BuildInfo
-> ((Dependency -> Identity Dependency)
    -> BuildInfo -> Identity BuildInfo)
-> ASetter
     GenericPackageDescription
     GenericPackageDescription
     Dependency
     Dependency
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike Identity BuildInfo BuildInfo [Dependency] [Dependency]
forall a. HasBuildInfo a => Lens' a [Dependency]
Lens' BuildInfo [Dependency]
L.targetBuildDepends LensLike Identity BuildInfo BuildInfo [Dependency] [Dependency]
-> ((Dependency -> Identity Dependency)
    -> [Dependency] -> Identity [Dependency])
-> (Dependency -> Identity Dependency)
-> BuildInfo
-> Identity BuildInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Dependency -> Identity Dependency)
-> [Dependency] -> Identity [Dependency]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse) Dependency -> Dependency
f
    (GenericPackageDescription -> GenericPackageDescription)
-> (GenericPackageDescription -> GenericPackageDescription)
-> GenericPackageDescription
-> GenericPackageDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASetter
  GenericPackageDescription
  GenericPackageDescription
  Dependency
  Dependency
-> (Dependency -> Dependency)
-> GenericPackageDescription
-> GenericPackageDescription
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over (LensLike
  Identity
  GenericPackageDescription
  GenericPackageDescription
  PackageDescription
  PackageDescription
Lens' GenericPackageDescription PackageDescription
L.packageDescription LensLike
  Identity
  GenericPackageDescription
  GenericPackageDescription
  PackageDescription
  PackageDescription
-> ((Dependency -> Identity Dependency)
    -> PackageDescription -> Identity PackageDescription)
-> ASetter
     GenericPackageDescription
     GenericPackageDescription
     Dependency
     Dependency
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike
  Identity
  PackageDescription
  PackageDescription
  (Maybe SetupBuildInfo)
  (Maybe SetupBuildInfo)
Lens' PackageDescription (Maybe SetupBuildInfo)
L.setupBuildInfo LensLike
  Identity
  PackageDescription
  PackageDescription
  (Maybe SetupBuildInfo)
  (Maybe SetupBuildInfo)
-> ((Dependency -> Identity Dependency)
    -> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo))
-> (Dependency -> Identity Dependency)
-> PackageDescription
-> Identity PackageDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SetupBuildInfo -> Identity SetupBuildInfo)
-> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse ((SetupBuildInfo -> Identity SetupBuildInfo)
 -> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo))
-> ((Dependency -> Identity Dependency)
    -> SetupBuildInfo -> Identity SetupBuildInfo)
-> (Dependency -> Identity Dependency)
-> Maybe SetupBuildInfo
-> Identity (Maybe SetupBuildInfo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike
  Identity SetupBuildInfo SetupBuildInfo [Dependency] [Dependency]
Lens' SetupBuildInfo [Dependency]
L.setupDepends LensLike
  Identity SetupBuildInfo SetupBuildInfo [Dependency] [Dependency]
-> ((Dependency -> Identity Dependency)
    -> [Dependency] -> Identity [Dependency])
-> (Dependency -> Identity Dependency)
-> SetupBuildInfo
-> Identity SetupBuildInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Dependency -> Identity Dependency)
-> [Dependency] -> Identity [Dependency]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse) Dependency -> Dependency
f

-- | Walk a 'GenericPackageDescription' and apply @f@ to all nested
-- @build-depends@ fields.
transformAllBuildDependsN
  :: ([Dependency] -> [Dependency])
  -> GenericPackageDescription
  -> GenericPackageDescription
transformAllBuildDependsN :: ([Dependency] -> [Dependency])
-> GenericPackageDescription -> GenericPackageDescription
transformAllBuildDependsN [Dependency] -> [Dependency]
f =
  ASetter
  GenericPackageDescription
  GenericPackageDescription
  [Dependency]
  [Dependency]
-> ([Dependency] -> [Dependency])
-> GenericPackageDescription
-> GenericPackageDescription
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over (ASetter
  GenericPackageDescription
  GenericPackageDescription
  BuildInfo
  BuildInfo
forall a. HasBuildInfos a => Traversal' a BuildInfo
Traversal' GenericPackageDescription BuildInfo
L.traverseBuildInfos ASetter
  GenericPackageDescription
  GenericPackageDescription
  BuildInfo
  BuildInfo
-> LensLike Identity BuildInfo BuildInfo [Dependency] [Dependency]
-> ASetter
     GenericPackageDescription
     GenericPackageDescription
     [Dependency]
     [Dependency]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike Identity BuildInfo BuildInfo [Dependency] [Dependency]
forall a. HasBuildInfo a => Lens' a [Dependency]
Lens' BuildInfo [Dependency]
L.targetBuildDepends) [Dependency] -> [Dependency]
f
    (GenericPackageDescription -> GenericPackageDescription)
-> (GenericPackageDescription -> GenericPackageDescription)
-> GenericPackageDescription
-> GenericPackageDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASetter
  GenericPackageDescription
  GenericPackageDescription
  [Dependency]
  [Dependency]
-> ([Dependency] -> [Dependency])
-> GenericPackageDescription
-> GenericPackageDescription
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over (LensLike
  Identity
  GenericPackageDescription
  GenericPackageDescription
  PackageDescription
  PackageDescription
Lens' GenericPackageDescription PackageDescription
L.packageDescription LensLike
  Identity
  GenericPackageDescription
  GenericPackageDescription
  PackageDescription
  PackageDescription
-> (([Dependency] -> Identity [Dependency])
    -> PackageDescription -> Identity PackageDescription)
-> ASetter
     GenericPackageDescription
     GenericPackageDescription
     [Dependency]
     [Dependency]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike
  Identity
  PackageDescription
  PackageDescription
  (Maybe SetupBuildInfo)
  (Maybe SetupBuildInfo)
Lens' PackageDescription (Maybe SetupBuildInfo)
L.setupBuildInfo LensLike
  Identity
  PackageDescription
  PackageDescription
  (Maybe SetupBuildInfo)
  (Maybe SetupBuildInfo)
-> (([Dependency] -> Identity [Dependency])
    -> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo))
-> ([Dependency] -> Identity [Dependency])
-> PackageDescription
-> Identity PackageDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SetupBuildInfo -> Identity SetupBuildInfo)
-> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse ((SetupBuildInfo -> Identity SetupBuildInfo)
 -> Maybe SetupBuildInfo -> Identity (Maybe SetupBuildInfo))
-> LensLike
     Identity SetupBuildInfo SetupBuildInfo [Dependency] [Dependency]
-> ([Dependency] -> Identity [Dependency])
-> Maybe SetupBuildInfo
-> Identity (Maybe SetupBuildInfo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike
  Identity SetupBuildInfo SetupBuildInfo [Dependency] [Dependency]
Lens' SetupBuildInfo [Dependency]
L.setupDepends) [Dependency] -> [Dependency]
f