Make a solving exe dep specify what exes are drawn from the package

Before there was simply a bool for lib vs exe, now the exe case as a
`Maybe UnqualComponentName` for specific exe vs wildcard

Author: Ericson2314

cabal-install/Distribution/Solver/Modular/Builder.hs

@@ -269,7 +269,7 @@ buildTree idx (IndependentGoals ind) igs =
   where
     -- Should a top-level goal allowed to be an executable style
     -- dependency? Well, I don't think it would make much difference
-    topLevelGoal qpn = OpenGoal (Simple (Dep False {- not exe -} qpn (Constrained [])) ()) UserGoal
+    topLevelGoal qpn = OpenGoal (Simple (Dep DRLib qpn (Constrained [])) ()) UserGoal
 
     qpns | ind       = makeIndependent igs
          | otherwise = L.map (Q (PackagePath DefaultNamespace QualToplevel)) igs

cabal-install/Distribution/Solver/Modular/Dependency.hs

@@ -21,6 +21,7 @@ module Distribution.Solver.Modular.Dependency (
   , FlaggedDeps
   , FlaggedDep(..)
   , Dep(..)
+  , DepRole(..)
   , showDep
   , flattenFlaggedDeps
   , QualifyOptions(..)
@@ -53,6 +54,7 @@ import qualified Data.List as L
 import Language.Haskell.Extension (Extension(..), Language(..))
 
 import Distribution.Text
+import Distribution.Types.UnqualComponentName
 
 import Distribution.Solver.Modular.ConflictSet (ConflictSet, ConflictMap)
 import Distribution.Solver.Modular.Flag
@@ -166,8 +168,23 @@ flattenFlaggedDeps = concatMap aux
 type TrueFlaggedDeps  qpn = FlaggedDeps Component qpn
 type FalseFlaggedDeps qpn = FlaggedDeps Component qpn
 
--- | Is this dependency on an executable
-type IsExe = Bool
+
+-- | Why do we depend on this package? The role of a dependency package is the
+-- components to be used from that package.
+--
+-- If 'Nothing', then we depend on all executables in the package. If 'Just
+-- name', then we depend on the executable with that name in the package.
+--
+-- TODO: add a similar field for 'Library' if allow depending on named
+-- libraries.
+data DepRole = DRLib
+             | DRExe (Maybe UnqualComponentName)
+  deriving (Eq, Show)
+
+showDepRole :: DepRole -> String
+showDepRole DRLib = ""
+showDepRole (DRExe Nothing) = " (all exes) "
+showDepRole (DRExe (Just n)) = " (exe: " ++ display n ++ ") "
 
 -- | A dependency (constraint) associates a package name with a
 -- constrained instance.
@@ -176,22 +193,20 @@ type IsExe = Bool
 -- is used both to record the dependencies as well as who's doing the
 -- depending; having a 'Functor' instance makes bugs where we don't distinguish
 -- these two far too likely. (By rights 'Dep' ought to have two type variables.)
-data Dep qpn = Dep IsExe qpn (CI qpn)  -- ^ dependency on a package (possibly for executable
+data Dep qpn = Dep DepRole qpn (CI qpn)  -- ^ dependency on a package (possibly for executable
              | Ext  Extension          -- ^ dependency on a language extension
              | Lang Language           -- ^ dependency on a language version
              | Pkg  PkgconfigName VR   -- ^ dependency on a pkg-config package
   deriving (Eq, Show)
 
 showDep :: Dep QPN -> String
-showDep (Dep is_exe qpn (Fixed i v)            ) =
+showDep (Dep role qpn (Fixed i v)            ) =
   (if P qpn /= v then showVar v ++ " => " else "") ++
-  showQPN qpn ++
-  (if is_exe then " (exe) " else "") ++ "==" ++ showI i
-showDep (Dep is_exe qpn (Constrained [(vr, v)])) =
-  showVar v ++ " => " ++ showQPN qpn ++
-  (if is_exe then " (exe) " else "") ++ showVR vr
-showDep (Dep is_exe qpn ci                     ) =
-  showQPN qpn ++ (if is_exe then " (exe) " else "") ++ showCI ci
+  showQPN qpn ++ showDepRole role ++ "==" ++ showI i
+showDep (Dep role qpn (Constrained [(vr, v)])) =
+  showVar v ++ " => " ++ showQPN qpn ++ showDepRole role ++ showVR vr
+showDep (Dep role qpn ci                     ) =
+  showQPN qpn ++ showDepRole role ++ showCI ci
 showDep (Ext ext)   = "requires " ++ display ext
 showDep (Lang lang) = "requires " ++ display lang
 showDep (Pkg pn vr) = "requires pkg-config package "
@@ -243,11 +258,12 @@ qualifyDeps QO{..} (Q pp@(PackagePath ns q) pn) = go
     goD (Ext  ext)    _    = Ext  ext
     goD (Lang lang)   _    = Lang lang
     goD (Pkg pkn vr)  _    = Pkg pkn vr
-    goD (Dep is_exe dep ci) comp
-      | is_exe      = Dep is_exe (Q (PackagePath ns (QualExe pn dep)) dep) (fmap (Q pp) ci)
-      | qBase  dep  = Dep is_exe (Q (PackagePath ns (QualBase  pn)) dep) (fmap (Q pp) ci)
-      | qSetup comp = Dep is_exe (Q (PackagePath ns (QualSetup pn)) dep) (fmap (Q pp) ci)
-      | otherwise   = Dep is_exe (Q (PackagePath ns inheritedQ) dep) (fmap (Q pp) ci)
+    goD (Dep role dep ci) comp
+      | DRExe _ <- role = goQ $ Q (PackagePath ns (QualExe   pn dep)) dep
+      | qBase dep       = goQ $ Q (PackagePath ns (QualBase  pn))     dep
+      | qSetup comp     = goQ $ Q (PackagePath ns (QualSetup pn))     dep
+      | otherwise       = goQ $ Q (PackagePath ns inheritedQ)         dep
+      where goQ qual = Dep role qual (fmap (Q pp) ci)
 
     -- If P has a setup dependency on Q, and Q has a regular dependency on R, then
     -- we say that the 'Setup' qualifier is inherited: P has an (indirect) setup
@@ -290,7 +306,7 @@ unqualifyDeps = go
     go1 (Simple dep comp)    = Simple (goD dep) comp
 
     goD :: Dep QPN -> Dep PN
-    goD (Dep is_exe qpn ci) = Dep is_exe (unq qpn) (fmap unq ci)
+    goD (Dep role qpn ci) = Dep role (unq qpn) (fmap unq ci)
     goD (Ext  ext)   = Ext ext
     goD (Lang lang)  = Lang lang
     goD (Pkg pn vr)  = Pkg pn vr
@@ -362,7 +378,7 @@ instance ResetVar CI where
   resetVar v (Constrained vrs) = Constrained (L.map (\ (x, y) -> (x, resetVar v y)) vrs)
 
 instance ResetVar Dep where
-  resetVar v (Dep is_exe qpn ci) = Dep is_exe qpn (resetVar v ci)
+  resetVar v (Dep role qpn ci) = Dep role qpn (resetVar v ci)
   resetVar _ (Ext ext)    = Ext ext
   resetVar _ (Lang lang)  = Lang lang
   resetVar _ (Pkg pn vr)  = Pkg pn vr

cabal-install/Distribution/Solver/Modular/IndexConversion.hs

@@ -94,7 +94,7 @@ convIPId pn' idx ipid =
     Nothing  -> Nothing
     Just ipi -> let i = I (pkgVersion (sourcePackageId ipi)) (Inst ipid)
                     pn = pkgName (sourcePackageId ipi)
-                in  Just (D.Simple (Dep False pn (Fixed i (P pn'))) ())
+                in  Just (D.Simple (Dep DRLib pn (Fixed i (P pn'))) ())
                 -- NB: something we pick up from the
                 -- InstalledPackageIndex is NEVER an executable
 
@@ -297,12 +297,11 @@ convBranch pkg os arch cinfo pi@(PI pn _) fds comp getInfo ipns sexes (CondBranc
 
 -- | Convert a Cabal dependency on a library to a solver-specific dependency.
 convLibDep :: PN -> Dependency -> Dep PN
-convLibDep pn' (Dependency pn vr) = Dep False {- not exe -} pn (Constrained [(vr, P pn')])
+convLibDep pn' (Dependency pn vr) = Dep DRLib pn (Constrained [(vr, P pn')])
 
 -- | Convert a Cabal dependency on a executable (build-tools) to a solver-specific dependency.
--- TODO do something about the name of the exe component itself
 convExeDep :: PN -> ExeDependency -> Dep PN
-convExeDep pn' (ExeDependency pn _ vr) = Dep True pn (Constrained [(vr, P pn')])
+convExeDep pn' (ExeDependency pn en vr) = Dep (DRExe en) pn (Constrained [(vr, P pn')])
 
 -- | Convert setup dependencies
 convSetupBuildInfo :: PI PN -> SetupBuildInfo -> FlaggedDeps Component PN

cabal-install/Distribution/Solver/Modular/Validate.hs

@@ -153,8 +153,8 @@ validate = cata go
       let qdeps = qualifyDeps qo qpn deps
       -- the new active constraints are given by the instance we have chosen,
       -- plus the dependency information we have for that instance
-      -- TODO: is the False here right?
-      let newactives = Dep False {- not exe -} qpn (Fixed i (P qpn)) : L.map (resetVar (P qpn)) (extractDeps pfa psa qdeps)
+      -- TODO: is lib-only right here right?
+      let newactives = Dep DRLib qpn (Fixed i (P qpn)) : L.map (resetVar (P qpn)) (extractDeps pfa psa qdeps)
       -- We now try to extend the partial assignment with the new active constraints.
       let mnppa = extend extSupported langSupported pkgPresent (P qpn) ppa newactives
       -- In case we continue, we save the scoped dependencies