{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
module Distribution.Solver.Modular.Validate (validateTree) where
import Control.Monad (foldM, mzero, liftM2)
import Control.Monad.Reader (MonadReader, Reader, runReader, local, asks)
import Data.Either (lefts)
import Data.Function (on)
import qualified Data.List as L
import qualified Data.Set as S
import Language.Haskell.Extension (Extension, Language)
import Data.Map.Strict as M
import Distribution.Compiler (CompilerInfo(..))
import Distribution.Solver.Modular.Assignment
import qualified Distribution.Solver.Modular.ConflictSet as CS
import Distribution.Solver.Modular.Dependency
import Distribution.Solver.Modular.Flag
import Distribution.Solver.Modular.Index
import Distribution.Solver.Modular.Package
import Distribution.Solver.Modular.Tree
import Distribution.Solver.Modular.Version
import qualified Distribution.Solver.Modular.WeightedPSQ as W
import Distribution.Solver.Types.PackagePath
import Distribution.Solver.Types.PkgConfigDb (PkgConfigDb, pkgConfigPkgIsPresent)
import Distribution.Types.LibraryName
import Distribution.Types.PkgconfigVersionRange
data ValidateState = VS {
ValidateState -> Extension -> Bool
supportedExt :: Extension -> Bool,
ValidateState -> Language -> Bool
supportedLang :: Language -> Bool,
ValidateState
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
presentPkgs :: Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool),
ValidateState -> Index
index :: Index,
ValidateState
-> Map
(Qualified PackageName) (FlaggedDeps (Qualified PackageName))
saved :: Map QPN (FlaggedDeps QPN),
ValidateState -> PreAssignment
pa :: PreAssignment,
ValidateState
-> Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
availableComponents :: Map QPN (Map ExposedComponent ComponentInfo),
ValidateState
-> Map (Qualified PackageName) ComponentDependencyReasons
requiredComponents :: Map QPN ComponentDependencyReasons,
ValidateState -> QualifyOptions
qualifyOptions :: QualifyOptions
}
newtype Validate a = Validate (Reader ValidateState a)
deriving ((forall a b. (a -> b) -> Validate a -> Validate b)
-> (forall a b. a -> Validate b -> Validate a) -> Functor Validate
forall a b. a -> Validate b -> Validate a
forall a b. (a -> b) -> Validate a -> Validate b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Validate a -> Validate b
fmap :: forall a b. (a -> b) -> Validate a -> Validate b
$c<$ :: forall a b. a -> Validate b -> Validate a
<$ :: forall a b. a -> Validate b -> Validate a
Functor, Functor Validate
Functor Validate =>
(forall a. a -> Validate a)
-> (forall a b. Validate (a -> b) -> Validate a -> Validate b)
-> (forall a b c.
(a -> b -> c) -> Validate a -> Validate b -> Validate c)
-> (forall a b. Validate a -> Validate b -> Validate b)
-> (forall a b. Validate a -> Validate b -> Validate a)
-> Applicative Validate
forall a. a -> Validate a
forall a b. Validate a -> Validate b -> Validate a
forall a b. Validate a -> Validate b -> Validate b
forall a b. Validate (a -> b) -> Validate a -> Validate b
forall a b c.
(a -> b -> c) -> Validate a -> Validate b -> Validate c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> Validate a
pure :: forall a. a -> Validate a
$c<*> :: forall a b. Validate (a -> b) -> Validate a -> Validate b
<*> :: forall a b. Validate (a -> b) -> Validate a -> Validate b
$cliftA2 :: forall a b c.
(a -> b -> c) -> Validate a -> Validate b -> Validate c
liftA2 :: forall a b c.
(a -> b -> c) -> Validate a -> Validate b -> Validate c
$c*> :: forall a b. Validate a -> Validate b -> Validate b
*> :: forall a b. Validate a -> Validate b -> Validate b
$c<* :: forall a b. Validate a -> Validate b -> Validate a
<* :: forall a b. Validate a -> Validate b -> Validate a
Applicative, Applicative Validate
Applicative Validate =>
(forall a b. Validate a -> (a -> Validate b) -> Validate b)
-> (forall a b. Validate a -> Validate b -> Validate b)
-> (forall a. a -> Validate a)
-> Monad Validate
forall a. a -> Validate a
forall a b. Validate a -> Validate b -> Validate b
forall a b. Validate a -> (a -> Validate b) -> Validate b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. Validate a -> (a -> Validate b) -> Validate b
>>= :: forall a b. Validate a -> (a -> Validate b) -> Validate b
$c>> :: forall a b. Validate a -> Validate b -> Validate b
>> :: forall a b. Validate a -> Validate b -> Validate b
$creturn :: forall a. a -> Validate a
return :: forall a. a -> Validate a
Monad, MonadReader ValidateState)
runValidate :: Validate a -> ValidateState -> a
runValidate :: forall a. Validate a -> ValidateState -> a
runValidate (Validate Reader ValidateState a
r) = Reader ValidateState a -> ValidateState -> a
forall r a. Reader r a -> r -> a
runReader Reader ValidateState a
r
data PreAssignment = PA PPreAssignment FAssignment SAssignment
type PPreAssignment = Map QPN MergedPkgDep
data PkgDep = PkgDep (DependencyReason QPN) (PkgComponent QPN) CI
type ComponentDependencyReasons = Map ExposedComponent (DependencyReason QPN)
data MergedPkgDep =
MergedDepFixed ExposedComponent (DependencyReason QPN) I
| MergedDepConstrained [VROrigin]
type VROrigin = (VR, ExposedComponent, DependencyReason QPN)
type Conflict = (ConflictSet, FailReason)
validate :: Tree d c -> Validate (Tree d c)
validate :: forall d c. Tree d c -> Validate (Tree d c)
validate = Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
go
where
go :: Tree d c -> Validate (Tree d c)
go :: forall d c. Tree d c -> Validate (Tree d c)
go (PChoice Qualified PackageName
qpn RevDepMap
rdm c
gr WeightedPSQ [Weight] POption (Tree d c)
ts) = Qualified PackageName
-> RevDepMap
-> c
-> WeightedPSQ [Weight] POption (Tree d c)
-> Tree d c
forall d c.
Qualified PackageName
-> RevDepMap
-> c
-> WeightedPSQ [Weight] POption (Tree d c)
-> Tree d c
PChoice Qualified PackageName
qpn RevDepMap
rdm c
gr (WeightedPSQ [Weight] POption (Tree d c) -> Tree d c)
-> Validate (WeightedPSQ [Weight] POption (Tree d c))
-> Validate (Tree d c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (POption -> Tree d c -> Validate (Tree d c))
-> WeightedPSQ [Weight] POption (Tree d c)
-> Validate (WeightedPSQ [Weight] POption (Tree d c))
forall (f :: * -> *) k v v' w.
Applicative f =>
(k -> v -> f v') -> WeightedPSQ w k v -> f (WeightedPSQ w k v')
W.traverseWithKey (\POption
k -> Qualified PackageName
-> POption -> Validate (Tree d c) -> Validate (Tree d c)
forall d c.
Qualified PackageName
-> POption -> Validate (Tree d c) -> Validate (Tree d c)
goP Qualified PackageName
qpn POption
k (Validate (Tree d c) -> Validate (Tree d c))
-> (Tree d c -> Validate (Tree d c))
-> Tree d c
-> Validate (Tree d c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
go) WeightedPSQ [Weight] POption (Tree d c)
ts
go (FChoice FN (Qualified PackageName)
qfn RevDepMap
rdm c
gr WeakOrTrivial
b FlagType
m Bool
d WeightedPSQ [Weight] Bool (Tree d c)
ts) =
do
PA _ pfa _ <- (ValidateState -> PreAssignment) -> Validate PreAssignment
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ValidateState -> PreAssignment
pa
case M.lookup qfn pfa of
Just Bool
rb ->
case Bool -> WeightedPSQ [Weight] Bool (Tree d c) -> Maybe (Tree d c)
forall k w v. Eq k => k -> WeightedPSQ w k v -> Maybe v
W.lookup Bool
rb WeightedPSQ [Weight] Bool (Tree d c)
ts of
Just Tree d c
t -> FN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
forall d c.
FN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goF FN (Qualified PackageName)
qfn Bool
rb (Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
go Tree d c
t)
Maybe (Tree d c)
Nothing -> Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (m :: * -> *) a. Monad m => a -> m a
return (Tree d c -> Validate (Tree d c))
-> Tree d c -> Validate (Tree d c)
forall a b. (a -> b) -> a -> b
$ ConflictSet -> FailReason -> Tree d c
forall d c. ConflictSet -> FailReason -> Tree d c
Fail (Var (Qualified PackageName) -> ConflictSet
varToConflictSet (FN (Qualified PackageName) -> Var (Qualified PackageName)
forall qpn. FN qpn -> Var qpn
F FN (Qualified PackageName)
qfn)) (FN (Qualified PackageName) -> FailReason
MalformedFlagChoice FN (Qualified PackageName)
qfn)
Maybe Bool
Nothing ->
FN (Qualified PackageName)
-> RevDepMap
-> c
-> WeakOrTrivial
-> FlagType
-> Bool
-> WeightedPSQ [Weight] Bool (Tree d c)
-> Tree d c
forall d c.
FN (Qualified PackageName)
-> RevDepMap
-> c
-> WeakOrTrivial
-> FlagType
-> Bool
-> WeightedPSQ [Weight] Bool (Tree d c)
-> Tree d c
FChoice FN (Qualified PackageName)
qfn RevDepMap
rdm c
gr WeakOrTrivial
b FlagType
m Bool
d (WeightedPSQ [Weight] Bool (Tree d c) -> Tree d c)
-> Validate (WeightedPSQ [Weight] Bool (Tree d c))
-> Validate (Tree d c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bool -> Tree d c -> Validate (Tree d c))
-> WeightedPSQ [Weight] Bool (Tree d c)
-> Validate (WeightedPSQ [Weight] Bool (Tree d c))
forall (f :: * -> *) k v v' w.
Applicative f =>
(k -> v -> f v') -> WeightedPSQ w k v -> f (WeightedPSQ w k v')
W.traverseWithKey (\Bool
k -> FN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
forall d c.
FN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goF FN (Qualified PackageName)
qfn Bool
k (Validate (Tree d c) -> Validate (Tree d c))
-> (Tree d c -> Validate (Tree d c))
-> Tree d c
-> Validate (Tree d c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
go) WeightedPSQ [Weight] Bool (Tree d c)
ts
go (SChoice SN (Qualified PackageName)
qsn RevDepMap
rdm c
gr WeakOrTrivial
b WeightedPSQ [Weight] Bool (Tree d c)
ts) =
do
PA _ _ psa <- (ValidateState -> PreAssignment) -> Validate PreAssignment
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ValidateState -> PreAssignment
pa
case M.lookup qsn psa of
Just Bool
rb ->
case Bool -> WeightedPSQ [Weight] Bool (Tree d c) -> Maybe (Tree d c)
forall k w v. Eq k => k -> WeightedPSQ w k v -> Maybe v
W.lookup Bool
rb WeightedPSQ [Weight] Bool (Tree d c)
ts of
Just Tree d c
t -> SN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
forall d c.
SN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goS SN (Qualified PackageName)
qsn Bool
rb (Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
go Tree d c
t)
Maybe (Tree d c)
Nothing -> Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (m :: * -> *) a. Monad m => a -> m a
return (Tree d c -> Validate (Tree d c))
-> Tree d c -> Validate (Tree d c)
forall a b. (a -> b) -> a -> b
$ ConflictSet -> FailReason -> Tree d c
forall d c. ConflictSet -> FailReason -> Tree d c
Fail (Var (Qualified PackageName) -> ConflictSet
varToConflictSet (SN (Qualified PackageName) -> Var (Qualified PackageName)
forall qpn. SN qpn -> Var qpn
S SN (Qualified PackageName)
qsn)) (SN (Qualified PackageName) -> FailReason
MalformedStanzaChoice SN (Qualified PackageName)
qsn)
Maybe Bool
Nothing ->
SN (Qualified PackageName)
-> RevDepMap
-> c
-> WeakOrTrivial
-> WeightedPSQ [Weight] Bool (Tree d c)
-> Tree d c
forall d c.
SN (Qualified PackageName)
-> RevDepMap
-> c
-> WeakOrTrivial
-> WeightedPSQ [Weight] Bool (Tree d c)
-> Tree d c
SChoice SN (Qualified PackageName)
qsn RevDepMap
rdm c
gr WeakOrTrivial
b (WeightedPSQ [Weight] Bool (Tree d c) -> Tree d c)
-> Validate (WeightedPSQ [Weight] Bool (Tree d c))
-> Validate (Tree d c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bool -> Tree d c -> Validate (Tree d c))
-> WeightedPSQ [Weight] Bool (Tree d c)
-> Validate (WeightedPSQ [Weight] Bool (Tree d c))
forall (f :: * -> *) k v v' w.
Applicative f =>
(k -> v -> f v') -> WeightedPSQ w k v -> f (WeightedPSQ w k v')
W.traverseWithKey (\Bool
k -> SN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
forall d c.
SN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goS SN (Qualified PackageName)
qsn Bool
k (Validate (Tree d c) -> Validate (Tree d c))
-> (Tree d c -> Validate (Tree d c))
-> Tree d c
-> Validate (Tree d c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
go) WeightedPSQ [Weight] Bool (Tree d c)
ts
go (GoalChoice RevDepMap
rdm PSQ (Goal (Qualified PackageName)) (Tree d c)
ts) = RevDepMap
-> PSQ (Goal (Qualified PackageName)) (Tree d c) -> Tree d c
forall d c.
RevDepMap
-> PSQ (Goal (Qualified PackageName)) (Tree d c) -> Tree d c
GoalChoice RevDepMap
rdm (PSQ (Goal (Qualified PackageName)) (Tree d c) -> Tree d c)
-> Validate (PSQ (Goal (Qualified PackageName)) (Tree d c))
-> Validate (Tree d c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Tree d c -> Validate (Tree d c))
-> PSQ (Goal (Qualified PackageName)) (Tree d c)
-> Validate (PSQ (Goal (Qualified PackageName)) (Tree d c))
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)
-> PSQ (Goal (Qualified PackageName)) a
-> f (PSQ (Goal (Qualified PackageName)) b)
traverse Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
go PSQ (Goal (Qualified PackageName)) (Tree d c)
ts
go (Done RevDepMap
rdm d
s ) = Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RevDepMap -> d -> Tree d c
forall d c. RevDepMap -> d -> Tree d c
Done RevDepMap
rdm d
s)
go (Fail ConflictSet
c FailReason
fr ) = Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ConflictSet -> FailReason -> Tree d c
forall d c. ConflictSet -> FailReason -> Tree d c
Fail ConflictSet
c FailReason
fr)
goP :: QPN -> POption -> Validate (Tree d c) -> Validate (Tree d c)
goP :: forall d c.
Qualified PackageName
-> POption -> Validate (Tree d c) -> Validate (Tree d c)
goP qpn :: Qualified PackageName
qpn@(Q PackagePath
_pp PackageName
pn) (POption I
i Maybe PackagePath
_) Validate (Tree d c)
r = do
PA ppa pfa psa <- (ValidateState -> PreAssignment) -> Validate PreAssignment
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ValidateState -> PreAssignment
pa
extSupported <- asks supportedExt
langSupported <- asks supportedLang
pkgPresent <- asks presentPkgs
idx <- asks index
svd <- asks saved
aComps <- asks availableComponents
rComps <- asks requiredComponents
qo <- asks qualifyOptions
let (PInfo deps comps _ mfr) = idx ! pn ! i
let qdeps = QualifyOptions
-> Qualified PackageName
-> FlaggedDeps PackageName
-> FlaggedDeps (Qualified PackageName)
qualifyDeps QualifyOptions
qo Qualified PackageName
qpn FlaggedDeps PackageName
deps
let newactives = FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractAllDeps FAssignment
pfa SAssignment
psa FlaggedDeps (Qualified PackageName)
qdeps
let mnppa = (Extension -> Bool)
-> (Language -> Bool)
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
-> [LDep (Qualified PackageName)]
-> PPreAssignment
-> Either Conflict PPreAssignment
extend Extension -> Bool
extSupported Language -> Bool
langSupported Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
pkgPresent [LDep (Qualified PackageName)]
newactives
(PPreAssignment -> Either Conflict PPreAssignment)
-> Either Conflict PPreAssignment -> Either Conflict PPreAssignment
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< PI (Qualified PackageName)
-> PPreAssignment -> Either Conflict PPreAssignment
extendWithPackageChoice (Qualified PackageName -> I -> PI (Qualified PackageName)
forall qpn. qpn -> I -> PI qpn
PI Qualified PackageName
qpn I
i) PPreAssignment
ppa
let nsvd = Qualified PackageName
-> FlaggedDeps (Qualified PackageName)
-> Map
(Qualified PackageName) (FlaggedDeps (Qualified PackageName))
-> Map
(Qualified PackageName) (FlaggedDeps (Qualified PackageName))
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Qualified PackageName
qpn FlaggedDeps (Qualified PackageName)
qdeps Map (Qualified PackageName) (FlaggedDeps (Qualified PackageName))
svd
case mfr of
Just FailReason
fr ->
Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConflictSet -> FailReason -> Tree d c
forall d c. ConflictSet -> FailReason -> Tree d c
Fail (Var (Qualified PackageName) -> ConflictSet
varToConflictSet (Qualified PackageName -> Var (Qualified PackageName)
forall qpn. qpn -> Var qpn
P Qualified PackageName
qpn)) FailReason
fr)
Maybe FailReason
Nothing ->
let newDeps :: Either Conflict (PPreAssignment, Map QPN ComponentDependencyReasons)
newDeps :: Either
Conflict
(PPreAssignment,
Map (Qualified PackageName) ComponentDependencyReasons)
newDeps = do
nppa <- Either Conflict PPreAssignment
mnppa
rComps' <- extendRequiredComponents qpn aComps rComps newactives
checkComponentsInNewPackage (M.findWithDefault M.empty qpn rComps) qpn comps
return (nppa, rComps')
in case Either
Conflict
(PPreAssignment,
Map (Qualified PackageName) ComponentDependencyReasons)
newDeps of
Left (ConflictSet
c, FailReason
fr) ->
Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConflictSet -> FailReason -> Tree d c
forall d c. ConflictSet -> FailReason -> Tree d c
Fail ConflictSet
c FailReason
fr)
Right (PPreAssignment
nppa, Map (Qualified PackageName) ComponentDependencyReasons
rComps') ->
(ValidateState -> ValidateState)
-> Validate (Tree d c) -> Validate (Tree d c)
forall a.
(ValidateState -> ValidateState) -> Validate a -> Validate a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\ ValidateState
s -> ValidateState
s { pa = PA nppa pfa psa
, saved = nsvd
, availableComponents = M.insert qpn comps aComps
, requiredComponents = rComps'
}) Validate (Tree d c)
r
goF :: QFN -> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goF :: forall d c.
FN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goF qfn :: FN (Qualified PackageName)
qfn@(FN Qualified PackageName
qpn Flag
_f) Bool
b Validate (Tree d c)
r = do
PA ppa pfa psa <- (ValidateState -> PreAssignment) -> Validate PreAssignment
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ValidateState -> PreAssignment
pa
extSupported <- asks supportedExt
langSupported <- asks supportedLang
pkgPresent <- asks presentPkgs
svd <- asks saved
aComps <- asks availableComponents
rComps <- asks requiredComponents
let qdeps = Map (Qualified PackageName) (FlaggedDeps (Qualified PackageName))
svd Map (Qualified PackageName) (FlaggedDeps (Qualified PackageName))
-> Qualified PackageName -> FlaggedDeps (Qualified PackageName)
forall k a. Ord k => Map k a -> k -> a
! Qualified PackageName
qpn
let npfa = FN (Qualified PackageName) -> Bool -> FAssignment -> FAssignment
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert FN (Qualified PackageName)
qfn Bool
b FAssignment
pfa
let newactives = Var (Qualified PackageName)
-> Bool
-> FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractNewDeps (FN (Qualified PackageName) -> Var (Qualified PackageName)
forall qpn. FN qpn -> Var qpn
F FN (Qualified PackageName)
qfn) Bool
b FAssignment
npfa SAssignment
psa FlaggedDeps (Qualified PackageName)
qdeps
mNewRequiredComps = Qualified PackageName
-> Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
-> Map (Qualified PackageName) ComponentDependencyReasons
-> [LDep (Qualified PackageName)]
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
extendRequiredComponents Qualified PackageName
qpn Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
aComps Map (Qualified PackageName) ComponentDependencyReasons
rComps [LDep (Qualified PackageName)]
newactives
let mnppa = (Extension -> Bool)
-> (Language -> Bool)
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
-> [LDep (Qualified PackageName)]
-> PPreAssignment
-> Either Conflict PPreAssignment
extend Extension -> Bool
extSupported Language -> Bool
langSupported Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
pkgPresent [LDep (Qualified PackageName)]
newactives PPreAssignment
ppa
case liftM2 (,) mnppa mNewRequiredComps of
Left (ConflictSet
c, FailReason
fr) -> Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConflictSet -> FailReason -> Tree d c
forall d c. ConflictSet -> FailReason -> Tree d c
Fail ConflictSet
c FailReason
fr)
Right (PPreAssignment
nppa, Map (Qualified PackageName) ComponentDependencyReasons
rComps') ->
(ValidateState -> ValidateState)
-> Validate (Tree d c) -> Validate (Tree d c)
forall a.
(ValidateState -> ValidateState) -> Validate a -> Validate a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\ ValidateState
s -> ValidateState
s { pa = PA nppa npfa psa, requiredComponents = rComps' }) Validate (Tree d c)
r
goS :: QSN -> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goS :: forall d c.
SN (Qualified PackageName)
-> Bool -> Validate (Tree d c) -> Validate (Tree d c)
goS qsn :: SN (Qualified PackageName)
qsn@(SN Qualified PackageName
qpn Stanza
_f) Bool
b Validate (Tree d c)
r = do
PA ppa pfa psa <- (ValidateState -> PreAssignment) -> Validate PreAssignment
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ValidateState -> PreAssignment
pa
extSupported <- asks supportedExt
langSupported <- asks supportedLang
pkgPresent <- asks presentPkgs
svd <- asks saved
aComps <- asks availableComponents
rComps <- asks requiredComponents
let qdeps = Map (Qualified PackageName) (FlaggedDeps (Qualified PackageName))
svd Map (Qualified PackageName) (FlaggedDeps (Qualified PackageName))
-> Qualified PackageName -> FlaggedDeps (Qualified PackageName)
forall k a. Ord k => Map k a -> k -> a
! Qualified PackageName
qpn
let npsa = SN (Qualified PackageName) -> Bool -> SAssignment -> SAssignment
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert SN (Qualified PackageName)
qsn Bool
b SAssignment
psa
let newactives = Var (Qualified PackageName)
-> Bool
-> FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractNewDeps (SN (Qualified PackageName) -> Var (Qualified PackageName)
forall qpn. SN qpn -> Var qpn
S SN (Qualified PackageName)
qsn) Bool
b FAssignment
pfa SAssignment
npsa FlaggedDeps (Qualified PackageName)
qdeps
mNewRequiredComps = Qualified PackageName
-> Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
-> Map (Qualified PackageName) ComponentDependencyReasons
-> [LDep (Qualified PackageName)]
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
extendRequiredComponents Qualified PackageName
qpn Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
aComps Map (Qualified PackageName) ComponentDependencyReasons
rComps [LDep (Qualified PackageName)]
newactives
let mnppa = (Extension -> Bool)
-> (Language -> Bool)
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
-> [LDep (Qualified PackageName)]
-> PPreAssignment
-> Either Conflict PPreAssignment
extend Extension -> Bool
extSupported Language -> Bool
langSupported Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
pkgPresent [LDep (Qualified PackageName)]
newactives PPreAssignment
ppa
case liftM2 (,) mnppa mNewRequiredComps of
Left (ConflictSet
c, FailReason
fr) -> Tree d c -> Validate (Tree d c)
forall a. a -> Validate a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConflictSet -> FailReason -> Tree d c
forall d c. ConflictSet -> FailReason -> Tree d c
Fail ConflictSet
c FailReason
fr)
Right (PPreAssignment
nppa, Map (Qualified PackageName) ComponentDependencyReasons
rComps') ->
(ValidateState -> ValidateState)
-> Validate (Tree d c) -> Validate (Tree d c)
forall a.
(ValidateState -> ValidateState) -> Validate a -> Validate a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\ ValidateState
s -> ValidateState
s { pa = PA nppa pfa npsa, requiredComponents = rComps' }) Validate (Tree d c)
r
checkComponentsInNewPackage :: ComponentDependencyReasons
-> QPN
-> Map ExposedComponent ComponentInfo
-> Either Conflict ()
checkComponentsInNewPackage :: ComponentDependencyReasons
-> Qualified PackageName
-> Map ExposedComponent ComponentInfo
-> Either Conflict ()
checkComponentsInNewPackage ComponentDependencyReasons
required Qualified PackageName
qpn Map ExposedComponent ComponentInfo
providedComps =
case ComponentDependencyReasons
-> [(ExposedComponent, DependencyReason (Qualified PackageName))]
forall k a. Map k a -> [(k, a)]
M.toList (ComponentDependencyReasons
-> [(ExposedComponent, DependencyReason (Qualified PackageName))])
-> ComponentDependencyReasons
-> [(ExposedComponent, DependencyReason (Qualified PackageName))]
forall a b. (a -> b) -> a -> b
$ [ExposedComponent]
-> ComponentDependencyReasons -> ComponentDependencyReasons
forall k v. Ord k => [k] -> Map k v -> Map k v
deleteKeys (Map ExposedComponent ComponentInfo -> [ExposedComponent]
forall k a. Map k a -> [k]
M.keys Map ExposedComponent ComponentInfo
providedComps) ComponentDependencyReasons
required of
(ExposedComponent
missingComp, DependencyReason (Qualified PackageName)
dr) : [(ExposedComponent, DependencyReason (Qualified PackageName))]
_ ->
Conflict -> Either Conflict ()
forall a b. a -> Either a b
Left (Conflict -> Either Conflict ()) -> Conflict -> Either Conflict ()
forall a b. (a -> b) -> a -> b
$ ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason)
-> Conflict
mkConflict ExposedComponent
missingComp DependencyReason (Qualified PackageName)
dr ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason
NewPackageIsMissingRequiredComponent
[] ->
let failures :: [Conflict]
failures = [Either Conflict ()] -> [Conflict]
forall a b. [Either a b] -> [a]
lefts
[ case () of
()
_ | ComponentInfo -> IsVisible
compIsVisible ComponentInfo
compInfo IsVisible -> IsVisible -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> IsVisible
IsVisible Bool
False ->
Conflict -> Either Conflict ()
forall a b. a -> Either a b
Left (Conflict -> Either Conflict ()) -> Conflict -> Either Conflict ()
forall a b. (a -> b) -> a -> b
$ ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason)
-> Conflict
mkConflict ExposedComponent
comp DependencyReason (Qualified PackageName)
dr ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason
NewPackageHasPrivateRequiredComponent
| ComponentInfo -> IsBuildable
compIsBuildable ComponentInfo
compInfo IsBuildable -> IsBuildable -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> IsBuildable
IsBuildable Bool
False ->
Conflict -> Either Conflict ()
forall a b. a -> Either a b
Left (Conflict -> Either Conflict ()) -> Conflict -> Either Conflict ()
forall a b. (a -> b) -> a -> b
$ ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason)
-> Conflict
mkConflict ExposedComponent
comp DependencyReason (Qualified PackageName)
dr ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason
NewPackageHasUnbuildableRequiredComponent
| Bool
otherwise -> () -> Either Conflict ()
forall a b. b -> Either a b
Right ()
| let merged :: Map
ExposedComponent
(DependencyReason (Qualified PackageName), ComponentInfo)
merged = (DependencyReason (Qualified PackageName)
-> ComponentInfo
-> (DependencyReason (Qualified PackageName), ComponentInfo))
-> ComponentDependencyReasons
-> Map ExposedComponent ComponentInfo
-> Map
ExposedComponent
(DependencyReason (Qualified PackageName), ComponentInfo)
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
M.intersectionWith (,) ComponentDependencyReasons
required Map ExposedComponent ComponentInfo
providedComps
, (ExposedComponent
comp, (DependencyReason (Qualified PackageName)
dr, ComponentInfo
compInfo)) <- Map
ExposedComponent
(DependencyReason (Qualified PackageName), ComponentInfo)
-> [(ExposedComponent,
(DependencyReason (Qualified PackageName), ComponentInfo))]
forall k a. Map k a -> [(k, a)]
M.toList Map
ExposedComponent
(DependencyReason (Qualified PackageName), ComponentInfo)
merged ]
in case [Conflict]
failures of
Conflict
failure : [Conflict]
_ -> Conflict -> Either Conflict ()
forall a b. a -> Either a b
Left Conflict
failure
[] -> () -> Either Conflict ()
forall a b. b -> Either a b
Right ()
where
mkConflict :: ExposedComponent
-> DependencyReason QPN
-> (ExposedComponent -> DependencyReason QPN -> FailReason)
-> Conflict
mkConflict :: ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason)
-> Conflict
mkConflict ExposedComponent
comp DependencyReason (Qualified PackageName)
dr ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason
mkFailure =
(Var (Qualified PackageName) -> ConflictSet -> ConflictSet
CS.insert (Qualified PackageName -> Var (Qualified PackageName)
forall qpn. qpn -> Var qpn
P Qualified PackageName
qpn) (DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
dr), ExposedComponent
-> DependencyReason (Qualified PackageName) -> FailReason
mkFailure ExposedComponent
comp DependencyReason (Qualified PackageName)
dr)
deleteKeys :: Ord k => [k] -> Map k v -> Map k v
deleteKeys :: forall k v. Ord k => [k] -> Map k v -> Map k v
deleteKeys [k]
ks Map k v
m = (k -> Map k v -> Map k v) -> Map k v -> [k] -> Map k v
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
L.foldr k -> Map k v -> Map k v
forall k a. Ord k => k -> Map k a -> Map k a
M.delete Map k v
m [k]
ks
extractAllDeps :: FAssignment -> SAssignment -> FlaggedDeps QPN -> [LDep QPN]
FAssignment
fa SAssignment
sa FlaggedDeps (Qualified PackageName)
deps = do
d <- FlaggedDeps (Qualified PackageName)
deps
case d of
Simple LDep (Qualified PackageName)
sd Component
_ -> LDep (Qualified PackageName) -> [LDep (Qualified PackageName)]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return LDep (Qualified PackageName)
sd
Flagged FN (Qualified PackageName)
qfn FInfo
_ FlaggedDeps (Qualified PackageName)
td FlaggedDeps (Qualified PackageName)
fd -> case FN (Qualified PackageName) -> FAssignment -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup FN (Qualified PackageName)
qfn FAssignment
fa of
Maybe Bool
Nothing -> [LDep (Qualified PackageName)]
forall a. [a]
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Just Bool
True -> FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractAllDeps FAssignment
fa SAssignment
sa FlaggedDeps (Qualified PackageName)
td
Just Bool
False -> FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractAllDeps FAssignment
fa SAssignment
sa FlaggedDeps (Qualified PackageName)
fd
Stanza SN (Qualified PackageName)
qsn FlaggedDeps (Qualified PackageName)
td -> case SN (Qualified PackageName) -> SAssignment -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup SN (Qualified PackageName)
qsn SAssignment
sa of
Maybe Bool
Nothing -> [LDep (Qualified PackageName)]
forall a. [a]
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Just Bool
True -> FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractAllDeps FAssignment
fa SAssignment
sa FlaggedDeps (Qualified PackageName)
td
Just Bool
False -> []
extractNewDeps :: Var QPN -> Bool -> FAssignment -> SAssignment -> FlaggedDeps QPN -> [LDep QPN]
Var (Qualified PackageName)
v Bool
b FAssignment
fa SAssignment
sa = FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
go
where
go :: FlaggedDeps QPN -> [LDep QPN]
go :: FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
go FlaggedDeps (Qualified PackageName)
deps = do
d <- FlaggedDeps (Qualified PackageName)
deps
case d of
Simple LDep (Qualified PackageName)
_ Component
_ -> [LDep (Qualified PackageName)]
forall a. [a]
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Flagged FN (Qualified PackageName)
qfn' FInfo
_ FlaggedDeps (Qualified PackageName)
td FlaggedDeps (Qualified PackageName)
fd
| Var (Qualified PackageName)
v Var (Qualified PackageName) -> Var (Qualified PackageName) -> Bool
forall a. Eq a => a -> a -> Bool
== FN (Qualified PackageName) -> Var (Qualified PackageName)
forall qpn. FN qpn -> Var qpn
F FN (Qualified PackageName)
qfn' -> if Bool
b then FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractAllDeps FAssignment
fa SAssignment
sa FlaggedDeps (Qualified PackageName)
td else FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractAllDeps FAssignment
fa SAssignment
sa FlaggedDeps (Qualified PackageName)
fd
| Bool
otherwise -> case FN (Qualified PackageName) -> FAssignment -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup FN (Qualified PackageName)
qfn' FAssignment
fa of
Maybe Bool
Nothing -> [LDep (Qualified PackageName)]
forall a. [a]
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Just Bool
True -> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
go FlaggedDeps (Qualified PackageName)
td
Just Bool
False -> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
go FlaggedDeps (Qualified PackageName)
fd
Stanza SN (Qualified PackageName)
qsn' FlaggedDeps (Qualified PackageName)
td
| Var (Qualified PackageName)
v Var (Qualified PackageName) -> Var (Qualified PackageName) -> Bool
forall a. Eq a => a -> a -> Bool
== SN (Qualified PackageName) -> Var (Qualified PackageName)
forall qpn. SN qpn -> Var qpn
S SN (Qualified PackageName)
qsn' -> if Bool
b then FAssignment
-> SAssignment
-> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
extractAllDeps FAssignment
fa SAssignment
sa FlaggedDeps (Qualified PackageName)
td else []
| Bool
otherwise -> case SN (Qualified PackageName) -> SAssignment -> Maybe Bool
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup SN (Qualified PackageName)
qsn' SAssignment
sa of
Maybe Bool
Nothing -> [LDep (Qualified PackageName)]
forall a. [a]
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Just Bool
True -> FlaggedDeps (Qualified PackageName)
-> [LDep (Qualified PackageName)]
go FlaggedDeps (Qualified PackageName)
td
Just Bool
False -> []
extend :: (Extension -> Bool)
-> (Language -> Bool)
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
-> [LDep QPN]
-> PPreAssignment
-> Either Conflict PPreAssignment
extend :: (Extension -> Bool)
-> (Language -> Bool)
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
-> [LDep (Qualified PackageName)]
-> PPreAssignment
-> Either Conflict PPreAssignment
extend Extension -> Bool
extSupported Language -> Bool
langSupported Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
pkgPresent [LDep (Qualified PackageName)]
newactives PPreAssignment
ppa = (PPreAssignment
-> LDep (Qualified PackageName) -> Either Conflict PPreAssignment)
-> PPreAssignment
-> [LDep (Qualified PackageName)]
-> Either Conflict PPreAssignment
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM PPreAssignment
-> LDep (Qualified PackageName) -> Either Conflict PPreAssignment
extendSingle PPreAssignment
ppa [LDep (Qualified PackageName)]
newactives
where
extendSingle :: PPreAssignment -> LDep QPN -> Either Conflict PPreAssignment
extendSingle :: PPreAssignment
-> LDep (Qualified PackageName) -> Either Conflict PPreAssignment
extendSingle PPreAssignment
a (LDep DependencyReason (Qualified PackageName)
dr (Ext Extension
ext )) =
if Extension -> Bool
extSupported Extension
ext then PPreAssignment -> Either Conflict PPreAssignment
forall a b. b -> Either a b
Right PPreAssignment
a
else Conflict -> Either Conflict PPreAssignment
forall a b. a -> Either a b
Left (DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
dr, Extension -> FailReason
UnsupportedExtension Extension
ext)
extendSingle PPreAssignment
a (LDep DependencyReason (Qualified PackageName)
dr (Lang Language
lang)) =
if Language -> Bool
langSupported Language
lang then PPreAssignment -> Either Conflict PPreAssignment
forall a b. b -> Either a b
Right PPreAssignment
a
else Conflict -> Either Conflict PPreAssignment
forall a b. a -> Either a b
Left (DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
dr, Language -> FailReason
UnsupportedLanguage Language
lang)
extendSingle PPreAssignment
a (LDep DependencyReason (Qualified PackageName)
dr (Pkg PkgconfigName
pn PkgconfigVersionRange
vr)) =
case (\PkgconfigName -> PkgconfigVersionRange -> Bool
f -> PkgconfigName -> PkgconfigVersionRange -> Bool
f PkgconfigName
pn PkgconfigVersionRange
vr) ((PkgconfigName -> PkgconfigVersionRange -> Bool) -> Bool)
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
-> Maybe Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
pkgPresent of
Just Bool
True -> PPreAssignment -> Either Conflict PPreAssignment
forall a b. b -> Either a b
Right PPreAssignment
a
Just Bool
False -> Conflict -> Either Conflict PPreAssignment
forall a b. a -> Either a b
Left (DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
dr, PkgconfigName -> PkgconfigVersionRange -> FailReason
MissingPkgconfigPackage PkgconfigName
pn PkgconfigVersionRange
vr)
Maybe Bool
Nothing -> Conflict -> Either Conflict PPreAssignment
forall a b. a -> Either a b
Left (DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
dr, PkgconfigName -> PkgconfigVersionRange -> FailReason
MissingPkgconfigProgram PkgconfigName
pn PkgconfigVersionRange
vr)
extendSingle PPreAssignment
a (LDep DependencyReason (Qualified PackageName)
dr (Dep dep :: PkgComponent (Qualified PackageName)
dep@(PkgComponent Qualified PackageName
qpn ExposedComponent
_) CI
ci)) =
let mergedDep :: MergedPkgDep
mergedDep = MergedPkgDep
-> Qualified PackageName -> PPreAssignment -> MergedPkgDep
forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault ([VROrigin] -> MergedPkgDep
MergedDepConstrained []) Qualified PackageName
qpn PPreAssignment
a
in case (\ MergedPkgDep
x -> Qualified PackageName
-> MergedPkgDep -> PPreAssignment -> PPreAssignment
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Qualified PackageName
qpn MergedPkgDep
x PPreAssignment
a) (MergedPkgDep -> PPreAssignment)
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) PPreAssignment
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MergedPkgDep
-> PkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
merge MergedPkgDep
mergedDep (DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> PkgDep
PkgDep DependencyReason (Qualified PackageName)
dr PkgComponent (Qualified PackageName)
dep CI
ci) of
Left (ConflictSet
c, (ConflictingDep
d, ConflictingDep
d')) -> Conflict -> Either Conflict PPreAssignment
forall a b. a -> Either a b
Left (ConflictSet
c, ConflictingDep -> ConflictingDep -> FailReason
ConflictingConstraints ConflictingDep
d ConflictingDep
d')
Right PPreAssignment
x -> PPreAssignment -> Either Conflict PPreAssignment
forall a b. b -> Either a b
Right PPreAssignment
x
extendWithPackageChoice :: PI QPN -> PPreAssignment -> Either Conflict PPreAssignment
extendWithPackageChoice :: PI (Qualified PackageName)
-> PPreAssignment -> Either Conflict PPreAssignment
extendWithPackageChoice (PI Qualified PackageName
qpn I
i) PPreAssignment
ppa =
let mergedDep :: MergedPkgDep
mergedDep = MergedPkgDep
-> Qualified PackageName -> PPreAssignment -> MergedPkgDep
forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault ([VROrigin] -> MergedPkgDep
MergedDepConstrained []) Qualified PackageName
qpn PPreAssignment
ppa
newChoice :: PkgDep
newChoice = DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> PkgDep
PkgDep (Qualified PackageName
-> Map Flag FlagValue
-> Set Stanza
-> DependencyReason (Qualified PackageName)
forall qpn.
qpn -> Map Flag FlagValue -> Set Stanza -> DependencyReason qpn
DependencyReason Qualified PackageName
qpn Map Flag FlagValue
forall k a. Map k a
M.empty Set Stanza
forall a. Set a
S.empty)
(Qualified PackageName
-> ExposedComponent -> PkgComponent (Qualified PackageName)
forall qpn. qpn -> ExposedComponent -> PkgComponent qpn
PkgComponent Qualified PackageName
qpn (LibraryName -> ExposedComponent
ExposedLib LibraryName
LMainLibName))
(I -> CI
Fixed I
i)
in case (\ MergedPkgDep
x -> Qualified PackageName
-> MergedPkgDep -> PPreAssignment -> PPreAssignment
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Qualified PackageName
qpn MergedPkgDep
x PPreAssignment
ppa) (MergedPkgDep -> PPreAssignment)
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) PPreAssignment
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MergedPkgDep
-> PkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
merge MergedPkgDep
mergedDep PkgDep
newChoice of
Left (ConflictSet
c, (ConflictingDep
d, ConflictingDep
_d')) ->
Conflict -> Either Conflict PPreAssignment
forall a b. a -> Either a b
Left (ConflictSet
c, ConflictingDep -> FailReason
NewPackageDoesNotMatchExistingConstraint ConflictingDep
d)
Right PPreAssignment
x -> PPreAssignment -> Either Conflict PPreAssignment
forall a b. b -> Either a b
Right PPreAssignment
x
merge :: MergedPkgDep -> PkgDep -> Either (ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
merge :: MergedPkgDep
-> PkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
merge (MergedDepFixed ExposedComponent
comp1 DependencyReason (Qualified PackageName)
vs1 I
i1) (PkgDep DependencyReason (Qualified PackageName)
vs2 (PkgComponent Qualified PackageName
p ExposedComponent
comp2) ci :: CI
ci@(Fixed I
i2))
| I
i1 I -> I -> Bool
forall a. Eq a => a -> a -> Bool
== I
i2 = MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. b -> Either a b
Right (MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep)
-> MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. (a -> b) -> a -> b
$ ExposedComponent
-> DependencyReason (Qualified PackageName) -> I -> MergedPkgDep
MergedDepFixed ExposedComponent
comp1 DependencyReason (Qualified PackageName)
vs1 I
i1
| Bool
otherwise =
(ConflictSet, (ConflictingDep, ConflictingDep))
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. a -> Either a b
Left ( (ConflictSet -> ConflictSet -> ConflictSet
CS.union (ConflictSet -> ConflictSet -> ConflictSet)
-> (DependencyReason (Qualified PackageName) -> ConflictSet)
-> DependencyReason (Qualified PackageName)
-> DependencyReason (Qualified PackageName)
-> ConflictSet
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet) DependencyReason (Qualified PackageName)
vs1 DependencyReason (Qualified PackageName)
vs2
, ( DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> ConflictingDep
ConflictingDep DependencyReason (Qualified PackageName)
vs1 (Qualified PackageName
-> ExposedComponent -> PkgComponent (Qualified PackageName)
forall qpn. qpn -> ExposedComponent -> PkgComponent qpn
PkgComponent Qualified PackageName
p ExposedComponent
comp1) (I -> CI
Fixed I
i1)
, DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> ConflictingDep
ConflictingDep DependencyReason (Qualified PackageName)
vs2 (Qualified PackageName
-> ExposedComponent -> PkgComponent (Qualified PackageName)
forall qpn. qpn -> ExposedComponent -> PkgComponent qpn
PkgComponent Qualified PackageName
p ExposedComponent
comp2) CI
ci ) )
merge (MergedDepFixed ExposedComponent
comp1 DependencyReason (Qualified PackageName)
vs1 i :: I
i@(I Ver
v Loc
_)) (PkgDep DependencyReason (Qualified PackageName)
vs2 (PkgComponent Qualified PackageName
p ExposedComponent
comp2) ci :: CI
ci@(Constrained VR
vr))
| VR -> Ver -> Bool
checkVR VR
vr Ver
v = MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. b -> Either a b
Right (MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep)
-> MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. (a -> b) -> a -> b
$ ExposedComponent
-> DependencyReason (Qualified PackageName) -> I -> MergedPkgDep
MergedDepFixed ExposedComponent
comp1 DependencyReason (Qualified PackageName)
vs1 I
i
| Bool
otherwise =
(ConflictSet, (ConflictingDep, ConflictingDep))
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. a -> Either a b
Left ( Qualified PackageName
-> Ver
-> DependencyReason (Qualified PackageName)
-> VR
-> DependencyReason (Qualified PackageName)
-> ConflictSet
createConflictSetForVersionConflict Qualified PackageName
p Ver
v DependencyReason (Qualified PackageName)
vs1 VR
vr DependencyReason (Qualified PackageName)
vs2
, ( DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> ConflictingDep
ConflictingDep DependencyReason (Qualified PackageName)
vs1 (Qualified PackageName
-> ExposedComponent -> PkgComponent (Qualified PackageName)
forall qpn. qpn -> ExposedComponent -> PkgComponent qpn
PkgComponent Qualified PackageName
p ExposedComponent
comp1) (I -> CI
Fixed I
i)
, DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> ConflictingDep
ConflictingDep DependencyReason (Qualified PackageName)
vs2 (Qualified PackageName
-> ExposedComponent -> PkgComponent (Qualified PackageName)
forall qpn. qpn -> ExposedComponent -> PkgComponent qpn
PkgComponent Qualified PackageName
p ExposedComponent
comp2) CI
ci ) )
merge (MergedDepConstrained [VROrigin]
vrOrigins) (PkgDep DependencyReason (Qualified PackageName)
vs2 (PkgComponent Qualified PackageName
p ExposedComponent
comp2) ci :: CI
ci@(Fixed i :: I
i@(I Ver
v Loc
_))) =
[VROrigin]
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
go [VROrigin]
vrOrigins
where
go :: [VROrigin] -> Either (ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
go :: [VROrigin]
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
go [] = MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. b -> Either a b
Right (ExposedComponent
-> DependencyReason (Qualified PackageName) -> I -> MergedPkgDep
MergedDepFixed ExposedComponent
comp2 DependencyReason (Qualified PackageName)
vs2 I
i)
go ((VR
vr, ExposedComponent
comp1, DependencyReason (Qualified PackageName)
vs1) : [VROrigin]
vros)
| VR -> Ver -> Bool
checkVR VR
vr Ver
v = [VROrigin]
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
go [VROrigin]
vros
| Bool
otherwise =
(ConflictSet, (ConflictingDep, ConflictingDep))
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. a -> Either a b
Left ( Qualified PackageName
-> Ver
-> DependencyReason (Qualified PackageName)
-> VR
-> DependencyReason (Qualified PackageName)
-> ConflictSet
createConflictSetForVersionConflict Qualified PackageName
p Ver
v DependencyReason (Qualified PackageName)
vs2 VR
vr DependencyReason (Qualified PackageName)
vs1
, ( DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> ConflictingDep
ConflictingDep DependencyReason (Qualified PackageName)
vs1 (Qualified PackageName
-> ExposedComponent -> PkgComponent (Qualified PackageName)
forall qpn. qpn -> ExposedComponent -> PkgComponent qpn
PkgComponent Qualified PackageName
p ExposedComponent
comp1) (VR -> CI
Constrained VR
vr)
, DependencyReason (Qualified PackageName)
-> PkgComponent (Qualified PackageName) -> CI -> ConflictingDep
ConflictingDep DependencyReason (Qualified PackageName)
vs2 (Qualified PackageName
-> ExposedComponent -> PkgComponent (Qualified PackageName)
forall qpn. qpn -> ExposedComponent -> PkgComponent qpn
PkgComponent Qualified PackageName
p ExposedComponent
comp2) CI
ci ) )
merge (MergedDepConstrained [VROrigin]
vrOrigins) (PkgDep DependencyReason (Qualified PackageName)
vs2 (PkgComponent Qualified PackageName
_ ExposedComponent
comp2) (Constrained VR
vr)) =
MergedPkgDep
-> Either
(ConflictSet, (ConflictingDep, ConflictingDep)) MergedPkgDep
forall a b. b -> Either a b
Right ([VROrigin] -> MergedPkgDep
MergedDepConstrained ([VROrigin] -> MergedPkgDep) -> [VROrigin] -> MergedPkgDep
forall a b. (a -> b) -> a -> b
$
[VROrigin]
vrOrigins [VROrigin] -> [VROrigin] -> [VROrigin]
forall a. [a] -> [a] -> [a]
++ [(VR
vr, ExposedComponent
comp2, DependencyReason (Qualified PackageName)
vs2)])
createConflictSetForVersionConflict :: QPN
-> Ver
-> DependencyReason QPN
-> VR
-> DependencyReason QPN
-> ConflictSet
createConflictSetForVersionConflict :: Qualified PackageName
-> Ver
-> DependencyReason (Qualified PackageName)
-> VR
-> DependencyReason (Qualified PackageName)
-> ConflictSet
createConflictSetForVersionConflict Qualified PackageName
pkg
Ver
conflictingVersion
versionDR :: DependencyReason (Qualified PackageName)
versionDR@(DependencyReason Qualified PackageName
p1 Map Flag FlagValue
_ Set Stanza
_)
VR
conflictingVersionRange
versionRangeDR :: DependencyReason (Qualified PackageName)
versionRangeDR@(DependencyReason Qualified PackageName
p2 Map Flag FlagValue
_ Set Stanza
_) =
let hasFlagsOrStanzas :: DependencyReason qpn -> Bool
hasFlagsOrStanzas (DependencyReason qpn
_ Map Flag FlagValue
fs Set Stanza
ss) = Bool -> Bool
not (Map Flag FlagValue -> Bool
forall k a. Map k a -> Bool
M.null Map Flag FlagValue
fs) Bool -> Bool -> Bool
|| Bool -> Bool
not (Set Stanza -> Bool
forall a. Set a -> Bool
S.null Set Stanza
ss)
in
if Qualified PackageName
p1 Qualified PackageName -> Qualified PackageName -> Bool
forall a. Eq a => a -> a -> Bool
== Qualified PackageName
pkg Bool -> Bool -> Bool
&& Bool -> Bool
not (DependencyReason (Qualified PackageName) -> Bool
forall {qpn}. DependencyReason qpn -> Bool
hasFlagsOrStanzas DependencyReason (Qualified PackageName)
versionDR) Bool -> Bool -> Bool
&& Bool -> Bool
not (DependencyReason (Qualified PackageName) -> Bool
forall {qpn}. DependencyReason qpn -> Bool
hasFlagsOrStanzas DependencyReason (Qualified PackageName)
versionRangeDR)
then let cs1 :: ConflictSet
cs1 = Qualified PackageName
-> OrderedVersionRange
-> DependencyReason (Qualified PackageName)
-> ConflictSet
dependencyReasonToConflictSetWithVersionConflict
Qualified PackageName
p2
(VR -> OrderedVersionRange
CS.OrderedVersionRange VR
conflictingVersionRange)
DependencyReason (Qualified PackageName)
versionDR
cs2 :: ConflictSet
cs2 = Qualified PackageName
-> Ver -> DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSetWithVersionConstraintConflict
Qualified PackageName
pkg Ver
conflictingVersion DependencyReason (Qualified PackageName)
versionRangeDR
in ConflictSet
cs1 ConflictSet -> ConflictSet -> ConflictSet
`CS.union` ConflictSet
cs2
else DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
versionRangeDR ConflictSet -> ConflictSet -> ConflictSet
`CS.union` DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
versionDR
extendRequiredComponents :: QPN
-> Map QPN (Map ExposedComponent ComponentInfo)
-> Map QPN ComponentDependencyReasons
-> [LDep QPN]
-> Either Conflict (Map QPN ComponentDependencyReasons)
extendRequiredComponents :: Qualified PackageName
-> Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
-> Map (Qualified PackageName) ComponentDependencyReasons
-> [LDep (Qualified PackageName)]
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
extendRequiredComponents Qualified PackageName
eqpn Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
available = (Map (Qualified PackageName) ComponentDependencyReasons
-> LDep (Qualified PackageName)
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons))
-> Map (Qualified PackageName) ComponentDependencyReasons
-> [LDep (Qualified PackageName)]
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM Map (Qualified PackageName) ComponentDependencyReasons
-> LDep (Qualified PackageName)
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
extendSingle
where
extendSingle :: Map QPN ComponentDependencyReasons
-> LDep QPN
-> Either Conflict (Map QPN ComponentDependencyReasons)
extendSingle :: Map (Qualified PackageName) ComponentDependencyReasons
-> LDep (Qualified PackageName)
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
extendSingle Map (Qualified PackageName) ComponentDependencyReasons
required (LDep DependencyReason (Qualified PackageName)
dr (Dep (PkgComponent Qualified PackageName
qpn ExposedComponent
comp) CI
_)) =
let compDeps :: ComponentDependencyReasons
compDeps = ComponentDependencyReasons
-> Qualified PackageName
-> Map (Qualified PackageName) ComponentDependencyReasons
-> ComponentDependencyReasons
forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault ComponentDependencyReasons
forall k a. Map k a
M.empty Qualified PackageName
qpn Map (Qualified PackageName) ComponentDependencyReasons
required
success :: Either a (Map (Qualified PackageName) ComponentDependencyReasons)
success = Map (Qualified PackageName) ComponentDependencyReasons
-> Either
a (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. b -> Either a b
Right (Map (Qualified PackageName) ComponentDependencyReasons
-> Either
a (Map (Qualified PackageName) ComponentDependencyReasons))
-> Map (Qualified PackageName) ComponentDependencyReasons
-> Either
a (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. (a -> b) -> a -> b
$ (ComponentDependencyReasons
-> ComponentDependencyReasons -> ComponentDependencyReasons)
-> Qualified PackageName
-> ComponentDependencyReasons
-> Map (Qualified PackageName) ComponentDependencyReasons
-> Map (Qualified PackageName) ComponentDependencyReasons
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
M.insertWith ComponentDependencyReasons
-> ComponentDependencyReasons -> ComponentDependencyReasons
forall k a. Ord k => Map k a -> Map k a -> Map k a
M.union Qualified PackageName
qpn (ExposedComponent
-> DependencyReason (Qualified PackageName)
-> ComponentDependencyReasons
-> ComponentDependencyReasons
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert ExposedComponent
comp DependencyReason (Qualified PackageName)
dr ComponentDependencyReasons
compDeps) Map (Qualified PackageName) ComponentDependencyReasons
required
in
case Qualified PackageName
-> Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
-> Maybe (Map ExposedComponent ComponentInfo)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Qualified PackageName
qpn Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
available of
Just Map ExposedComponent ComponentInfo
comps ->
case ExposedComponent
-> Map ExposedComponent ComponentInfo -> Maybe ComponentInfo
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup ExposedComponent
comp Map ExposedComponent ComponentInfo
comps of
Maybe ComponentInfo
Nothing ->
Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. a -> Either a b
Left (Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons))
-> Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. (a -> b) -> a -> b
$ Qualified PackageName
-> ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (Qualified PackageName -> ExposedComponent -> FailReason)
-> Conflict
mkConflict Qualified PackageName
qpn ExposedComponent
comp DependencyReason (Qualified PackageName)
dr Qualified PackageName -> ExposedComponent -> FailReason
PackageRequiresMissingComponent
Just ComponentInfo
compInfo
| ComponentInfo -> IsVisible
compIsVisible ComponentInfo
compInfo IsVisible -> IsVisible -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> IsVisible
IsVisible Bool
False
, Qualified PackageName
eqpn Qualified PackageName -> Qualified PackageName -> Bool
forall a. Eq a => a -> a -> Bool
/= Qualified PackageName
qpn
->
Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. a -> Either a b
Left (Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons))
-> Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. (a -> b) -> a -> b
$ Qualified PackageName
-> ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (Qualified PackageName -> ExposedComponent -> FailReason)
-> Conflict
mkConflict Qualified PackageName
qpn ExposedComponent
comp DependencyReason (Qualified PackageName)
dr Qualified PackageName -> ExposedComponent -> FailReason
PackageRequiresPrivateComponent
| ComponentInfo -> IsBuildable
compIsBuildable ComponentInfo
compInfo IsBuildable -> IsBuildable -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> IsBuildable
IsBuildable Bool
False ->
Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. a -> Either a b
Left (Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons))
-> Conflict
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. (a -> b) -> a -> b
$ Qualified PackageName
-> ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (Qualified PackageName -> ExposedComponent -> FailReason)
-> Conflict
mkConflict Qualified PackageName
qpn ExposedComponent
comp DependencyReason (Qualified PackageName)
dr Qualified PackageName -> ExposedComponent -> FailReason
PackageRequiresUnbuildableComponent
| Bool
otherwise -> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall {a}.
Either a (Map (Qualified PackageName) ComponentDependencyReasons)
success
Maybe (Map ExposedComponent ComponentInfo)
Nothing -> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall {a}.
Either a (Map (Qualified PackageName) ComponentDependencyReasons)
success
extendSingle Map (Qualified PackageName) ComponentDependencyReasons
required LDep (Qualified PackageName)
_ = Map (Qualified PackageName) ComponentDependencyReasons
-> Either
Conflict (Map (Qualified PackageName) ComponentDependencyReasons)
forall a b. b -> Either a b
Right Map (Qualified PackageName) ComponentDependencyReasons
required
mkConflict :: QPN
-> ExposedComponent
-> DependencyReason QPN
-> (QPN -> ExposedComponent -> FailReason)
-> Conflict
mkConflict :: Qualified PackageName
-> ExposedComponent
-> DependencyReason (Qualified PackageName)
-> (Qualified PackageName -> ExposedComponent -> FailReason)
-> Conflict
mkConflict Qualified PackageName
qpn ExposedComponent
comp DependencyReason (Qualified PackageName)
dr Qualified PackageName -> ExposedComponent -> FailReason
mkFailure =
(Var (Qualified PackageName) -> ConflictSet -> ConflictSet
CS.insert (Qualified PackageName -> Var (Qualified PackageName)
forall qpn. qpn -> Var qpn
P Qualified PackageName
qpn) (DependencyReason (Qualified PackageName) -> ConflictSet
dependencyReasonToConflictSet DependencyReason (Qualified PackageName)
dr), Qualified PackageName -> ExposedComponent -> FailReason
mkFailure Qualified PackageName
qpn ExposedComponent
comp)
validateTree :: CompilerInfo -> Index -> Maybe PkgConfigDb -> Tree d c -> Tree d c
validateTree :: forall d c.
CompilerInfo -> Index -> Maybe PkgConfigDb -> Tree d c -> Tree d c
validateTree CompilerInfo
cinfo Index
idx Maybe PkgConfigDb
pkgConfigDb Tree d c
t = Validate (Tree d c) -> ValidateState -> Tree d c
forall a. Validate a -> ValidateState -> a
runValidate (Tree d c -> Validate (Tree d c)
forall d c. Tree d c -> Validate (Tree d c)
validate Tree d c
t) VS {
supportedExt :: Extension -> Bool
supportedExt = (Extension -> Bool)
-> ([Extension] -> Extension -> Bool)
-> Maybe [Extension]
-> Extension
-> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool -> Extension -> Bool
forall a b. a -> b -> a
const Bool
True)
(\ [Extension]
es -> let s :: Set Extension
s = [Extension] -> Set Extension
forall a. Ord a => [a] -> Set a
S.fromList [Extension]
es in \ Extension
x -> Extension -> Set Extension -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member Extension
x Set Extension
s)
(CompilerInfo -> Maybe [Extension]
compilerInfoExtensions CompilerInfo
cinfo)
, supportedLang :: Language -> Bool
supportedLang = (Language -> Bool)
-> ([Language] -> Language -> Bool)
-> Maybe [Language]
-> Language
-> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool -> Language -> Bool
forall a b. a -> b -> a
const Bool
True)
((Language -> [Language] -> Bool) -> [Language] -> Language -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Language -> [Language] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
L.elem)
(CompilerInfo -> Maybe [Language]
compilerInfoLanguages CompilerInfo
cinfo)
, presentPkgs :: Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
presentPkgs = PkgConfigDb -> PkgconfigName -> PkgconfigVersionRange -> Bool
pkgConfigPkgIsPresent (PkgConfigDb -> PkgconfigName -> PkgconfigVersionRange -> Bool)
-> Maybe PkgConfigDb
-> Maybe (PkgconfigName -> PkgconfigVersionRange -> Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe PkgConfigDb
pkgConfigDb
, index :: Index
index = Index
idx
, saved :: Map (Qualified PackageName) (FlaggedDeps (Qualified PackageName))
saved = Map (Qualified PackageName) (FlaggedDeps (Qualified PackageName))
forall k a. Map k a
M.empty
, pa :: PreAssignment
pa = PPreAssignment -> FAssignment -> SAssignment -> PreAssignment
PA PPreAssignment
forall k a. Map k a
M.empty FAssignment
forall k a. Map k a
M.empty SAssignment
forall k a. Map k a
M.empty
, availableComponents :: Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
availableComponents = Map (Qualified PackageName) (Map ExposedComponent ComponentInfo)
forall k a. Map k a
M.empty
, requiredComponents :: Map (Qualified PackageName) ComponentDependencyReasons
requiredComponents = Map (Qualified PackageName) ComponentDependencyReasons
forall k a. Map k a
M.empty
, qualifyOptions :: QualifyOptions
qualifyOptions = Index -> QualifyOptions
defaultQualifyOptions Index
idx
}