Refactoring package to component centered design

.gitignore

@@ -45,6 +45,9 @@ stan.html
 # macOS-related
 .DS_Store
 
+# VS Code workspace settings
+.vscode
+
 # VS Code Counter (Visual Studio Code Extension)-related
 .VSCodeCounter
 

.hlint.yaml

@@ -57,13 +57,21 @@
   # the GHC2021 set. Other extensions can be added, if need be.
   - name:
     - NoImplicitPrelude
+    - ConstraintKinds
     - DataKinds
     - DefaultSignatures
+    - DeriveDataTypeable
+    - DeriveGeneric
     - DerivingStrategies
+    - DisambiguateRecordFields
+    - DuplicateRecordFields
+    - FlexibleContexts
     - GADTs
+    - GeneralizedNewtypeDeriving
     - LambdaCase
     - MultiWayIf
     - OverloadedLists
+    - OverloadedRecordDot
     - OverloadedStrings
     - QuasiQuotes
     - RecordWildCards

.stan.toml

@@ -52,7 +52,7 @@
 
 # Anti-pattern: Data.ByteString.Char8.pack
 [[ignore]]
-  id = "OBS-STAN-0203-fki0nd-1111:21"
+  id = "OBS-STAN-0203-fki0nd-1120:21"
 # ✦ Description:   Usage of 'pack' function that doesn't handle Unicode characters
 #  ✦ Category:      #AntiPattern
 #  ✦ File:          src\Stack\Build\Execute.hs
@@ -63,7 +63,7 @@
 
 # Anti-pattern: Data.ByteString.Char8.pack
 [[ignore]]
-  id = "OBS-STAN-0203-fki0nd-2656:3"
+  id = "OBS-STAN-0203-fki0nd-2662:3"
 # ✦ Description:   Usage of 'pack' function that doesn't handle Unicode characters
 # ✦ Category:      #AntiPattern
 # ✦ File:          src\Stack\Build\Execute.hs

src/Stack/Build.hs

@@ -30,7 +30,7 @@ import           Stack.Build.Installed ( getInstalled, toInstallMap )
 import           Stack.Build.Source ( localDependencies, projectLocalPackages )
 import           Stack.Build.Target ( NeedTargets (..) )
 import           Stack.FileWatch ( fileWatch, fileWatchPoll )
-import           Stack.Package ( resolvePackage )
+import           Stack.Package ( packageExes, resolvePackage )
 import           Stack.Prelude hiding ( loadPackage )
 import           Stack.Runners ( ShouldReexec (..), withConfig, withEnvConfig )
 import           Stack.Setup ( withNewLocalBuildTargets )

src/Stack/Build/ConstructPlan.hs

@@ -28,7 +28,10 @@ import           Stack.Build.Cache ( tryGetFlagCache )
 import           Stack.Build.Haddock ( shouldHaddockDeps )
 import           Stack.Build.Source ( loadLocalPackage )
 import           Stack.Constants ( compilerOptionsCabalFlag )
-import           Stack.Package ( applyForceCustomBuild )
+import           Stack.Package
+                   ( applyForceCustomBuild, hasMainBuildableLibrary
+                   , packageExes, packageUnknownTools
+                   )
 import           Stack.Prelude hiding ( loadPackage )
 import           Stack.SourceMap ( getPLIVersion, mkProjectPackage )
 import           Stack.Types.Build
@@ -45,6 +48,7 @@ import           Stack.Types.BuildConfig
                    ( BuildConfig (..), HasBuildConfig (..), stackYamlL )
 import           Stack.Types.BuildOpts
                    ( BuildOpts (..), BuildOptsCLI (..), BuildSubset (..) )
+import           Stack.Types.CompCollection ( collectionMember )
 import           Stack.Types.Compiler ( WhichCompiler (..) )
 import           Stack.Types.CompilerPaths
                    ( CompilerPaths (..), HasCompiler (..) )
@@ -67,8 +71,8 @@ import           Stack.Types.NamedComponent ( exeComponents, renderComponent )
 import           Stack.Types.Package
                    ( ExeName (..), InstallLocation (..), Installed (..)
                    , InstalledMap, LocalPackage (..), Package (..)
-                   , PackageLibraries (..), PackageSource (..), installedVersion
-                   , packageIdentifier, psVersion, runMemoizedWith
+                   , PackageSource (..), installedVersion, packageIdentifier
+                   , psVersion, runMemoizedWith
                    )
 import           Stack.Types.ParentMap ( ParentMap )
 import           Stack.Types.Platform ( HasPlatform (..) )
@@ -1162,10 +1166,7 @@ addPackageDeps package = do
   -- make sure we consider sub-libraries as libraries too
   packageHasLibrary :: Package -> Bool
   packageHasLibrary p =
-    not (Set.null (packageSubLibraries p)) ||
-    case packageLibraries p of
-      HasLibraries _ -> True
-      NoLibraries -> False
+    hasMainBuildableLibrary p || not (null (packageSubLibraries p))
 
 checkDirtiness ::
      PackageSource
@@ -1334,8 +1335,8 @@ checkAndWarnForUnknownTools p = do
   -- Check whether the tool is on the PATH or a package executable before
   -- warning about it.
   warnings <-
-    fmap catMaybes $ forM unknownTools $ \name@(ExeName toolName) ->
-      runMaybeT $ notOnPath toolName *> notPackageExe toolName *> warn name
+    fmap catMaybes $ forM unknownTools $ \toolName ->
+      runMaybeT $ notOnPath toolName *> notPackageExe toolName *> warn toolName
   tell mempty { wWarnings = (map toolWarningText warnings ++) }
   pure ()
  where
@@ -1349,8 +1350,9 @@ checkAndWarnForUnknownTools p = do
     skipIf $ isRight eFound
   -- From Cabal 1.12, build-tools can specify another executable in the same
   -- package.
-  notPackageExe toolName = MaybeT $ skipIf $ toolName `Set.member` packageExes p
-  warn name = MaybeT . pure . Just $ ToolWarning name (packageName p)
+  notPackageExe toolName =
+    MaybeT $ skipIf $ collectionMember toolName (packageExecutables p)
+  warn name = MaybeT . pure . Just $ ToolWarning (ExeName name) (packageName p)
   skipIf p' = pure $ if p' then Nothing else Just ()
 
 -- | Warn about tools in the snapshot definition. States the tool name

src/Stack/Build/Execute.hs

@@ -64,6 +64,7 @@ import           Distribution.Types.UnqualComponentName
                    ( mkUnqualComponentName )
 import           Distribution.Verbosity ( showForCabal )
 import           Distribution.Version ( mkVersion )
+import           GHC.Records ( getField )
 import           Path
                    ( PathException, (</>), addExtension, filename
                    , isProperPrefixOf, parent, parseRelDir, parseRelFile
@@ -124,7 +125,11 @@ import           Stack.Coverage
                    , generateHpcUnifiedReport, updateTixFile
                    )
 import           Stack.GhcPkg ( ghcPkg, unregisterGhcPkgIds )
-import           Stack.Package ( buildLogPath )
+import           Stack.Package
+                   ( buildLogPath, hasMainBuildableLibrary
+                   , mainLibraryHasExposedModules, packageExes
+                   , packageSubLibrariesNameSet
+                   )
 import           Stack.PackageDump ( conduitDumpPackage, ghcPkgDescribe )
 import           Stack.Prelude
 import           Stack.Types.ApplyGhcOptions ( ApplyGhcOptions (..) )
@@ -144,6 +149,10 @@ import           Stack.Types.BuildOpts
                    , CabalVerbosity (..), HaddockOpts (..)
                    , ProgressBarFormat (..), TestOpts (..)
                    )
+import           Stack.Types.CompCollection
+                   ( collectionKeyValueList, collectionLookup
+                   , getBuildableListText
+                   )
 import           Stack.Types.Compiler
                    ( ActualCompiler (..), WhichCompiler (..)
                    , compilerVersionString, getGhcVersion, whichCompilerL
@@ -152,6 +161,7 @@ import           Stack.Types.CompilerPaths
                    ( CompilerPaths (..), GhcPkgExe (..), HasCompiler (..)
                    , cabalVersionL, cpWhich, getCompilerPath, getGhcPkgExe
                    )
+import qualified Stack.Types.Component as Component
 import           Stack.Types.Config
                    ( Config (..), HasConfig (..), buildOptsL, stackRootL )
 import           Stack.Types.ConfigureOpts
@@ -175,9 +185,8 @@ import           Stack.Types.NamedComponent
                    )
 import           Stack.Types.Package
                    ( InstallLocation (..), Installed (..), InstalledMap
-                   , LocalPackage (..), Package (..), PackageLibraries (..)
-                   , installedPackageIdentifier, packageIdentifier
-                   , runMemoizedWith
+                   , LocalPackage (..), Package (..), installedPackageIdentifier
+                   , packageIdentifier, runMemoizedWith
                    )
 import           Stack.Types.PackageFile ( PackageWarning (..) )
 import           Stack.Types.Platform ( HasPlatform (..) )
@@ -1713,7 +1722,7 @@ singleBuild
     && not isFinalBuild
        -- Works around haddock failing on bytestring-builder since it has no
        -- modules when bytestring is new enough.
-    && packageHasExposedModules package
+    && mainLibraryHasExposedModules package
        -- Special help for the curator tool to avoid haddocks that are known
        -- to fail
     && maybe True (Set.notMember pname . curatorSkipHaddock) mcurator
@@ -1748,11 +1757,8 @@ singleBuild
     (hasLib, hasSubLib, hasExe) = case taskType of
       TTLocalMutable lp ->
         let package = lpPackage lp
-            hasLibrary =
-              case packageLibraries package of
-                NoLibraries -> False
-                HasLibraries _ -> True
-            hasSubLibraries = not . Set.null $ packageSubLibraries package
+            hasLibrary = hasMainBuildableLibrary package
+            hasSubLibraries = not . null $ packageSubLibraries package
             hasExecutables =
               not . Set.null $ exesToBuild executableBuildStatuses lp
         in  (hasLibrary, hasSubLibraries, hasExecutables)
@@ -1797,9 +1803,9 @@ singleBuild
     -- However, we must unregister any such library in the new snapshot, in case
     -- it was built with different flags.
     let
-      subLibNames = Set.toList $ case taskType of
-        TTLocalMutable lp -> packageSubLibraries $ lpPackage lp
-        TTRemotePackage _ p _ -> packageSubLibraries p
+      subLibNames = Set.toList $ packageSubLibrariesNameSet $ case taskType of
+        TTLocalMutable lp -> lpPackage lp
+        TTRemotePackage _ p _ -> p
       toMungedPackageId :: Text -> MungedPackageId
       toMungedPackageId subLib =
         let subLibName = LSubLibName $ mkUnqualComponentName $ T.unpack subLib
@@ -2038,13 +2044,9 @@ singleBuild
 
         cabal0 keep KeepTHLoading $ "haddock" : args
 
-    let hasLibrary =
-          case packageLibraries package of
-            NoLibraries -> False
-            HasLibraries _ -> True
-        packageHasComponentSet f = not $ Set.null $ f package
-        hasSubLibraries = packageHasComponentSet packageSubLibraries
-        hasExecutables = packageHasComponentSet packageExes
+    let hasLibrary = hasMainBuildableLibrary package
+        hasSubLibraries = not $ null $ packageSubLibraries package
+        hasExecutables = not $ null $ packageExecutables package
         shouldCopy =
              not isFinalBuild
           && (hasLibrary || hasSubLibraries || hasExecutables)
@@ -2093,10 +2095,10 @@ singleBuild
     let ident = PackageIdentifier (packageName package) (packageVersion package)
     -- only pure the sub-libraries to cache them if we also cache the main
     -- library (that is, if it exists)
-    (mpkgid, subLibsPkgIds) <- case packageLibraries package of
-      HasLibraries _ -> do
+    (mpkgid, subLibsPkgIds) <- if hasMainBuildableLibrary package
+      then do
         subLibsPkgIds <- fmap catMaybes $
-          forM (Set.toList $ packageSubLibraries package) $ \subLib -> do
+          forM (getBuildableListText $ packageSubLibraries package) $ \subLib -> do
             let subLibName = MungedPackageName
                   (packageName package)
                   (LSubLibName $ mkUnqualComponentName $ T.unpack subLib)
@@ -2112,10 +2114,10 @@ singleBuild
         case mpkgid of
           Nothing -> throwM $ Couldn'tFindPkgId $ packageName package
           Just pkgid -> pure (Library ident pkgid Nothing, subLibsPkgIds)
-      NoLibraries -> do
+      else do
         markExeInstalled (taskLocation task) pkgId -- TODO unify somehow
                                                    -- with writeFlagCache?
-        pure (Executable ident, []) -- don't pure sub-libraries in this case
+        pure (Executable ident, []) -- don't pure sublibs in this case
 
     case taskType of
       TTRemotePackage Immutable _ loc ->
@@ -2276,7 +2278,9 @@ singleTest topts testsToRun ac ee task installedMap = do
 
         let suitesToRun
               = [ testSuitePair
-                | testSuitePair <- Map.toList $ packageTests package
+                | testSuitePair <-
+                    (fmap . fmap) (getField @"interface") <$>
+                      collectionKeyValueList $ packageTestSuites package
                 , let testName = fst testSuitePair
                 , testName `elem` testsToRun
                 ]
@@ -2485,9 +2489,11 @@ singleTest topts testsToRun ac ee task installedMap = do
         when needHpc $ do
           let testsToRun' = map f testsToRun
               f tName =
-                  case Map.lookup tName (packageTests package) of
-                    Just C.TestSuiteLibV09{} -> tName <> "Stub"
-                    _ -> tName
+                case getField @"interface" <$> mComponent of
+                  Just C.TestSuiteLibV09{} -> tName <> "Stub"
+                  _ -> tName
+               where
+                mComponent = collectionLookup tName (packageTestSuites package)
           generateHpcReport pkgDir package testsToRun'
 
         bs <- liftIO $
@@ -2696,17 +2702,17 @@ primaryComponentOptions ::
 primaryComponentOptions executableBuildStatuses lp =
   -- TODO: get this information from target parsing instead, which will allow
   -- users to turn off library building if desired
-     ( case packageLibraries package of
-         NoLibraries -> []
-         HasLibraries names -> map
-           T.unpack
-           ( T.append "lib:" (T.pack (packageNameString (packageName package)))
-           : map (T.append "flib:") (Set.toList names)
-           )
+     ( if hasMainBuildableLibrary package
+         then map T.unpack
+           $ T.append "lib:" (T.pack (packageNameString (packageName package)))
+           : map
+               (T.append "flib:")
+               (getBuildableListText (packageForeignLibraries package))
+         else []
      )
   ++ map
        (T.unpack . T.append "lib:")
-       (Set.toList $ packageSubLibraries package)
+       (getBuildableListText $ packageSubLibraries package)
   ++ map
        (T.unpack . T.append "exe:")
        (Set.toList $ exesToBuild executableBuildStatuses lp)

src/Stack/Build/Source.hs

@@ -24,7 +24,11 @@ import qualified Distribution.PackageDescription as C
 import qualified Pantry.SHA256 as SHA256
 import           Stack.Build.Cache ( tryGetBuildCache )
 import           Stack.Build.Haddock ( shouldHaddockDeps )
-import           Stack.Package ( resolvePackage )
+import           Stack.Package
+                   ( hasMainBuildableLibrary, packageBenchmarks, packageExes
+                   , resolvePackage
+                   )
+import           Stack.PackageFile ( getPackageFile )
 import           Stack.Prelude
 import           Stack.SourceMap
                    ( DumpedGlobalPackage, checkFlagsUsedThrowing
@@ -40,6 +44,7 @@ import           Stack.Types.BuildOpts
                    , TestOpts (..), boptsCLIAllProgOptions
                    )
 import           Stack.Types.CabalConfigKey ( CabalConfigKey (..) )
+import           Stack.Types.CompCollection ( getBuildableSetText )
 import           Stack.Types.CompilerPaths ( HasCompiler, getCompilerPath )
 import           Stack.Types.Config ( Config (..), HasConfig (..), buildOptsL )
 import           Stack.Types.Curator ( Curator (..) )
@@ -52,10 +57,11 @@ import           Stack.Types.NamedComponent
                    ( NamedComponent (..), isCSubLib, splitComponents )
 import           Stack.Types.Package
                    ( FileCacheInfo (..), LocalPackage (..), Package (..)
-                   , PackageConfig (..), PackageLibraries (..)
-                   , dotCabalGetPath, memoizeRefWith, runMemoizedWith
+                   , PackageConfig (..), dotCabalGetPath, memoizeRefWith
+                   , runMemoizedWith
                    )
-import           Stack.Types.PackageFile ( PackageWarning, getPackageFiles )
+import           Stack.Types.PackageFile
+                   ( PackageComponentFile (..), PackageWarning )
 import           Stack.Types.Platform ( HasPlatform (..) )
 import           Stack.Types.SourceMap
                    ( CommonPackage (..), DepPackage (..), ProjectPackage (..)
@@ -315,7 +321,7 @@ loadLocalPackage pp = do
             ( packageExes pkg
             , if    boptsTests bopts
                  && maybe True (Set.notMember name . curatorSkipTest) mcurator
-                then Map.keysSet (packageTests pkg)
+                then getBuildableSetText (packageTestSuites pkg)
                 else Set.empty
             , if    boptsBenchmarks bopts
                  && maybe
@@ -334,13 +340,9 @@ loadLocalPackage pp = do
         -- individual executables or library") is resolved, 'hasLibrary' is only
         -- relevant if the library is part of the target spec.
         Just _ ->
-          let hasLibrary =
-                case packageLibraries pkg of
-                  NoLibraries -> False
-                  HasLibraries _ -> True
-          in     hasLibrary
-              || not (Set.null nonLibComponents)
-              || not (Set.null $ packageSubLibraries pkg)
+             hasMainBuildableLibrary pkg
+          || not (Set.null nonLibComponents)
+          || not (null $ packageSubLibraries pkg)
 
       filterSkippedComponents =
         Set.filter (not . (`elem` boptsSkipComponents bopts))
@@ -422,7 +424,7 @@ loadLocalPackage pp = do
       -- must not be buildable.
     , lpUnbuildable = toComponents
         (exes `Set.difference` packageExes pkg)
-        (tests `Set.difference` Map.keysSet (packageTests pkg))
+        (tests `Set.difference` getBuildableSetText (packageTestSuites pkg))
         (benches `Set.difference` packageBenchmarks pkg)
     }
 
@@ -499,8 +501,8 @@ getPackageFilesForTargets ::
   -> Set NamedComponent
   -> RIO env (Map NamedComponent (Set (Path Abs File)), [PackageWarning])
 getPackageFilesForTargets pkg cabalFP nonLibComponents = do
-  (components',compFiles,otherFiles,warnings) <-
-    getPackageFiles (packageFiles pkg) cabalFP
+  PackageComponentFile components' compFiles otherFiles warnings <-
+    getPackageFile pkg cabalFP
   let necessaryComponents =
         Set.insert CLib $ Set.filter isCSubLib (M.keysSet components')
       components = necessaryComponents `Set.union` nonLibComponents