feat: remove packageDeps and base everything on comp collection

src/Stack/Build/ConstructPlan.hs

@@ -31,7 +31,7 @@ import           Stack.Constants ( compilerOptionsCabalFlag )
 import           Stack.Package
                    ( applyForceCustomBuild, buildableExes
                    , hasBuildableMainLibrary, packageUnknownTools
-                   , processPackageDependencies
+                   , processPackageDependenciesToList
                    )
 import           Stack.Prelude hiding ( loadPackage )
 import           Stack.SourceMap ( getPLIVersion, mkProjectPackage )
@@ -1002,7 +1002,7 @@ addPackageDeps ::
 addPackageDeps package = do
   ctx <- ask
   checkAndWarnForUnknownTools package
-  deps <- processPackageDependencies package $ \depname (DepValue range depType) -> do
+  deps <- processPackageDependenciesToList package $ \depname (DepValue range depType) -> do
     eres <- getCachedDepOrAddDep depname
     let getLatestApplicableVersionAndRev :: M (Maybe (Version, BlobKey))
         getLatestApplicableVersionAndRev = do

src/Stack/Component.hs

@@ -191,10 +191,10 @@ gatherComponentToolsAndDepsFromCabal legacyBuildTools buildTools targetDeps =
 -- for them.
 processDependencies :: ( Monad m
                        , HasField "buildInfo" component StackBuildInfo )
-  => (PackageName -> DepValue -> m [resT] -> m [resT])
+  => (PackageName -> DepValue -> m (t resT) -> m (t resT))
   -> component
-  -> m [resT]
-  -> m [resT]
+  -> m (t resT)
+  -> m (t resT)
 processDependencies iteratorFn component resAction = Map.foldrWithKey' iteratorFn resAction componentDeps
   where
     componentDeps = buildInfo.sbiDependency

src/Stack/Dot.hs

@@ -36,7 +36,7 @@ import           Stack.Build.Source
                    ( loadCommonPackage, loadLocalPackage, loadSourceMap )
 import           Stack.Build.Target( NeedTargets (..), parseTargets )
 import           Stack.Constants ( wiredInPackages )
-import           Stack.Package ( Package (..) )
+import           Stack.Package ( Package (..), setOfPackageDeps )
 import           Stack.Prelude hiding ( Display (..), pkgName, loadPackage )
 import qualified Stack.Prelude ( pkgName )
 import           Stack.Runners
@@ -189,7 +189,7 @@ createDependencyGraph dotOpts = do
             pure ( Set.empty
                  , DotPayload (Just version) (Just $ Right BSD3) Nothing )
         | otherwise =
-            fmap (packageAllDeps &&& makePayload loc)
+            fmap (setOfPackageDeps &&& makePayload loc)
                  (loadPackage loc flags ghcOptions cabalConfigOpts)
   resolveDependencies (dotDependencyDepth dotOpts) graph depLoader
  where
@@ -433,15 +433,15 @@ createDepLoader sourceMap globalDumpMap globalIdMap loadPackageDeps pkgName =
    where
     loadDeps pp = do
       pkg <- loadCommonPackage (ppCommon pp)
-      pure (packageAllDeps pkg, payloadFromLocal pkg Nothing)
+      pure (setOfPackageDeps pkg, payloadFromLocal pkg Nothing)
 
   dependencyDeps =
     loadDeps <$> Map.lookup pkgName (smDeps sourceMap)
    where
     loadDeps DepPackage{dpLocation=PLMutable dir} = do
       pp <- mkProjectPackage YesPrintWarnings dir False
       pkg <- loadCommonPackage (ppCommon pp)
-      pure (packageAllDeps pkg, payloadFromLocal pkg (Just $ PLMutable dir))
+      pure (setOfPackageDeps pkg, payloadFromLocal pkg (Just $ PLMutable dir))
 
     loadDeps dp@DepPackage{dpLocation=PLImmutable loc} = do
       let common = dpCommon dp
@@ -483,13 +483,14 @@ projectPackageDependencies ::
 projectPackageDependencies dotOpts locals =
   map (\lp -> let pkg = localPackageToPackage lp
                   pkgDir = parent $ lpCabalFile lp
+                  packageDepsSet = setOfPackageDeps pkg
                   loc = PLMutable $ ResolvedPath (RelFilePath "N/A") pkgDir
-              in  (packageName pkg, (deps pkg, lpPayload pkg loc)))
+              in  (packageName pkg, (deps pkg packageDepsSet, lpPayload pkg loc)))
       locals
  where
-  deps pkg = if dotIncludeExternal dotOpts
-               then Set.delete (packageName pkg) (packageAllDeps pkg)
-               else Set.intersection localNames (packageAllDeps pkg)
+  deps pkg packageDepsSet = if dotIncludeExternal dotOpts
+               then Set.delete (packageName pkg) packageDepsSet
+               else Set.intersection localNames packageDepsSet
   localNames = Set.fromList $ map (packageName . lpPackage) locals
   lpPayload pkg loc =
     DotPayload (Just $ packageVersion pkg)

src/Stack/Ghci.hs

@@ -52,6 +52,7 @@ import           Stack.Package
                    , buildableForeignLibs, hasBuildableMainLibrary
                    , getPackageOpts, packageFromPackageDescription
                    , readDotBuildinfo, resolvePackageDescription
+                   , listOfPackageDeps
                    )
 import           Stack.PackageFile ( getPackageFile )
 import           Stack.Prelude
@@ -1201,7 +1202,7 @@ getExtraLoadDeps loadAllDeps localMap targets =
   getDeps :: PackageName -> [PackageName]
   getDeps name =
     case M.lookup name localMap of
-      Just lp -> M.keys (packageDeps (lpPackage lp)) -- FIXME just Local?
+      Just lp -> listOfPackageDeps (lpPackage lp) -- FIXME just Local?
       _ -> []
   go ::
        PackageName
@@ -1212,7 +1213,7 @@ getExtraLoadDeps loadAllDeps localMap targets =
       (Just (Just _), _) -> pure True
       (Just Nothing, _) | not loadAllDeps -> pure False
       (_, Just lp) -> do
-        let deps = M.keys (packageDeps (lpPackage lp))
+        let deps = listOfPackageDeps (lpPackage lp)
         shouldLoad <- or <$> mapM go deps
         if shouldLoad
           then do

src/Stack/Package.hs

@@ -26,7 +26,9 @@ module Stack.Package
   , buildableTestSuites
   , buildableBenchmarks
   , getPackageOpts
-  , processPackageDependencies
+  , processPackageDependenciesToList
+  , listOfPackageDeps
+  , setOfPackageDeps
   ) where
 
 import           Data.Foldable ( Foldable (..) )
@@ -47,8 +49,7 @@ import           Distribution.PackageDescription
                    , GenericPackageDescription (..), HookedBuildInfo
                    , Library (..), PackageDescription (..), PackageFlag (..)
                    , SetupBuildInfo (..), TestSuite (..), allLibraries
-                   , buildType, depPkgName, depVerRange, libraryNameString
-                   , maybeToLibraryName
+                   , buildType, depPkgName, depVerRange, maybeToLibraryName
                    )
 import           Distribution.Pretty ( prettyShow )
 import           Distribution.Simple.PackageDescription ( readHookedBuildInfo )
@@ -86,7 +87,7 @@ import           Stack.Types.BuildConfig
                    ( HasBuildConfig (..), getProjectWorkDir )
 import           Stack.Types.CompCollection
                    ( CompCollection, foldAndMakeCollection
-                   , getBuildableSetText, foldComponentToList
+                   , getBuildableSetText, foldComponentToAnotherCollection
                    )
 import           Stack.Types.Compiler ( ActualCompiler (..) )
 import           Stack.Types.CompilerPaths ( cabalVersionL )
@@ -141,7 +142,6 @@ packageFromPackageDescription
       { packageName = name
       , packageVersion = pkgVersion pkgId
       , packageLicense = licenseRaw pkg
-      , packageDeps = deps
       , packageGhcOptions = packageConfigGhcOptions packageConfig
       , packageCabalConfigOpts = packageConfigCabalConfigOpts packageConfig
       , packageFlags = packageConfigFlags packageConfig
@@ -158,7 +158,6 @@ packageFromPackageDescription
           foldAndMakeCollection stackBenchmarkFromCabal $ benchmarks pkgNoMod
       , packageExecutables =
           foldAndMakeCollection stackExecutableFromCabal $ executables pkg
-      , packageAllDeps = M.keysSet deps
       , packageSubLibDeps = subLibDeps
       , packageBuildType = buildType pkg
       , packageSetupDeps = msetupDeps
@@ -168,41 +167,12 @@ packageFromPackageDescription
       , packageBenchmarkEnabled = packageConfigEnableBenchmarks packageConfig
       }
  where
-  extraLibNames = S.union subLibNames foreignLibNames
-
-  subLibNames
-    = S.fromList
-    $ map (T.pack . Cabal.unUnqualComponentName)
-    $ mapMaybe (libraryNameString . libName) -- this is a design bug in the
-                                             -- Cabal API: this should
-                                             -- statically be known to exist
-    $ filter (buildable . libBuildInfo)
-    $ subLibraries pkg
-
-  foreignLibNames
-    = S.fromList
-    $ map (T.pack . Cabal.unUnqualComponentName . foreignLibName)
-    $ filter (buildable . foreignLibBuildInfo)
-    $ foreignLibs pkg
-
   -- Gets all of the modules, files, build files, and data files that constitute
   -- the package. This is primarily used for dirtiness checking during build, as
   -- well as use by "stack ghci"
   pkgId = package pkg
   name = pkgName pkgId
 
-  (_unknownTools, knownTools) = packageDescTools pkg
-
-  deps = M.filterWithKey (const . not . isMe) (M.unionsWith (<>)
-    [ asLibrary <$> packageDependencies pkg
-    -- We include all custom-setup deps - if present - in the package deps
-    -- themselves. Stack always works with the invariant that there will be a
-    -- single installed package relating to a package name, and this applies at
-    -- the setup dependency level as well.
-    , asLibrary <$> fromMaybe M.empty msetupDeps
-    , knownTools
-    ])
-
   msetupDeps = fmap
     (M.fromList . map (depPkgName &&& depVerRange) . setupDepends)
     (setupBuildInfo pkg)
@@ -220,11 +190,6 @@ packageFromPackageDescription
     , dvType = AsLibrary
     }
 
-  -- Is the package dependency mentioned here me: either the package name
-  -- itself, or the name of one of the sub libraries
-  isMe name' =  name' == name
-             || fromString (packageNameString name') `S.member` extraLibNames
-
 toInternalPackageMungedName :: Package -> Text -> Text
 toInternalPackageMungedName pkg =
     T.pack
@@ -799,9 +764,6 @@ applyForceCustomBuild cabalVersion package
   | forceCustomBuild =
       package
         { packageBuildType = Custom
-        , packageDeps =
-            M.insertWith (<>) "Cabal" (DepValue cabalVersionRange AsLibrary) $
-              packageDeps package
         , packageSetupDeps = Just $ M.fromList
             [ ("Cabal", cabalVersionRange)
             , ("base", anyVersion)
@@ -866,12 +828,13 @@ buildableBenchmarks :: Package -> Set Text
 buildableBenchmarks pkg = getBuildableSetText (packageBenchmarks pkg)
 
 -- | This is a fonction to iterate in a monad over all
--- package component's dependencies, and yield a list of results.
-processPackageDependencies :: (Monad m)
+-- package component's dependencies, and yield a collection of results (used with list and set).
+processPackageDependencies :: (Monad m, Monoid (targetedCollection resT))
   => Package
+  -> (resT -> targetedCollection resT -> targetedCollection resT)
   -> (PackageName -> DepValue -> m resT)
-  -> m [resT]
-processPackageDependencies pkg fn = do
+  -> m (targetedCollection resT)
+processPackageDependencies pkg combineResults fn = do
   let asPackageNameSet accessor = S.map (mkPackageName . T.unpack) $ getBuildableSetText $ accessor pkg
   let (!subLibNames, !foreignLibNames) = (asPackageNameSet packageSubLibraries, asPackageNameSet packageForeignLibraries)
   let shouldIgnoreDep (packageNameV :: PackageName)
@@ -884,8 +847,8 @@ processPackageDependencies pkg fn = do
         | otherwise = do
           resList <- resListInMonad
           newResElement <- fn packageName depValue
-          pure $ newResElement : resList 
-  let compProcessor target = foldComponentToList (target pkg) (processDependencies innerIterator)
+          pure $ combineResults newResElement resList
+  let compProcessor target = foldComponentToAnotherCollection (target pkg) (processDependencies innerIterator)
   let asLibrary range = DepValue
         { dvVersionRange = range
         , dvType = AsLibrary
@@ -899,9 +862,22 @@ processPackageDependencies pkg fn = do
         . compProcessor packageExecutables
         . (if packageBenchmarkEnabled pkg then compProcessor packageBenchmarks else id)
         . (if packageTestEnabled pkg then compProcessor packageTestSuites else id)
-        . packageSetupDepsProcessor 
-              
+        . packageSetupDepsProcessor
+
   let initialValue = case packageLibrary pkg of
-        Nothing -> pure []
-        Just comp -> processDependencies innerIterator comp (pure [])
+        Nothing -> pure mempty
+        Just comp -> processDependencies innerIterator comp (pure mempty)
   processAllComp initialValue
+
+-- | Iterate/fold on all the package dependencies, components, setup deps and all.
+processPackageDependenciesToList :: Monad m => Package -> (PackageName -> DepValue -> m resT) -> m [resT]
+processPackageDependenciesToList pkg = processPackageDependencies pkg (:)
+
+-- | List all package's dependencies in a "free" context through the identity monad.
+listOfPackageDeps :: Package -> [PackageName]
+listOfPackageDeps pkg = do
+  runIdentity $ processPackageDependenciesToList pkg (\pn _ -> pure pn)
+-- | The set of package's dependencies.
+setOfPackageDeps :: Package -> Set PackageName
+setOfPackageDeps pkg = do
+  runIdentity $ processPackageDependencies pkg S.insert (\pn _ -> pure pn)

src/Stack/Types/CompCollection.hs

@@ -23,7 +23,7 @@ module Stack.Types.CompCollection
   , collectionLookup
   , collectionKeyValueList
   , collectionMember
-  , foldComponentToList
+  , foldComponentToAnotherCollection
   )
 where
 import qualified Data.HashMap.Strict as HM
@@ -159,9 +159,9 @@ collectionKeyValueList haystack =
 collectionMember :: Text -> CompCollection component -> Bool
 collectionMember needle haystack = isJust $ collectionLookup needle haystack
 
-foldComponentToList :: (Monad m)
+foldComponentToAnotherCollection :: (Monad m)
   => CompCollection component
-  -> (component -> m [b] -> m [b])
-  -> m [b]
-  -> m [b]
-foldComponentToList collection fn initialValue = HM.foldr' fn initialValue (asNameMap $ buildableOnes collection)
+  -> (component -> m (t b) -> m (t b))
+  -> m (t b)
+  -> m (t b)
+foldComponentToAnotherCollection collection fn initialValue = HM.foldr' fn initialValue (asNameMap $ buildableOnes collection)

src/Stack/Types/Package.hs

@@ -155,11 +155,6 @@ data Package = Package
     -- ^ Version of the package
   , packageLicense :: !(Either SPDX.License License)
     -- ^ The license the package was released under.
-  , packageDeps :: !(Map PackageName DepValue)
-    -- ^ Packages that the package depends on, both as libraries and build
-    -- tools.
-  , packageAllDeps :: !(Set PackageName)
-    -- ^ Original dependencies (not sieved).
   , packageSubLibDeps :: !(Map MungedPackageName DepValue)
     -- ^ Original sub-library dependencies (not sieved).
   , packageGhcOptions :: ![Text]