Safe Haskell	Safe-Inferred
Language	GHC2021

Stack.Types.SourceMap

Contents

Different source map types
Helper types

Description

A sourcemap maps a package name to how it should be built, including source code, flags, options, etc. This module contains various stages of source map construction. See the build_overview.md doc for details on these stages.

Synopsis

data SMWanted = SMWanted {
- smwCompiler :: !WantedCompiler
- smwProject :: !(Map PackageName ProjectPackage)
- smwDeps :: !(Map PackageName DepPackage)
- smwSnapshotLocation :: !RawSnapshotLocation
}
data SMActual global = SMActual {
- smaCompiler :: !ActualCompiler
- smaProject :: !(Map PackageName ProjectPackage)
- smaDeps :: !(Map PackageName DepPackage)
- smaGlobal :: !(Map PackageName global)
}
data Target
- = TargetAll !PackageType
- | TargetComps !(Set NamedComponent)
data PackageType
- = PTProject
- | PTDependency
data SMTargets = SMTargets {
- smtTargets :: !(Map PackageName Target)
- smtDeps :: !(Map PackageName DepPackage)
}
data SourceMap = SourceMap {
- smTargets :: !SMTargets
- smCompiler :: !ActualCompiler
- smProject :: !(Map PackageName ProjectPackage)
- smDeps :: !(Map PackageName DepPackage)
- smGlobal :: !(Map PackageName GlobalPackage)
}
data FromSnapshot
- = FromSnapshot
- | NotFromSnapshot
data DepPackage = DepPackage {
- dpCommon :: !CommonPackage
- dpLocation :: !PackageLocation
- dpHidden :: !Bool
- dpFromSnapshot :: !FromSnapshot
}
data ProjectPackage = ProjectPackage {
- ppCommon :: !CommonPackage
- ppCabalFP :: !(Path Abs File)
- ppResolvedDir :: !(ResolvedPath Dir)
}
ppComponents :: MonadIO m => ProjectPackage -> m (Set NamedComponent)
ppComponentsMaybe :: MonadIO m => (NamedComponent -> Maybe NamedComponent) -> ProjectPackage -> m (Set NamedComponent)
ppGPD :: MonadIO m => ProjectPackage -> m GenericPackageDescription
ppRoot :: ProjectPackage -> Path Abs Dir
ppVersion :: MonadIO m => ProjectPackage -> m Version
data CommonPackage = CommonPackage {
- cpGPD :: !(IO GenericPackageDescription)
- cpName :: !PackageName
- cpFlags :: !(Map FlagName Bool)
- cpGhcOptions :: ![Text]
- cpCabalConfigOpts :: ![Text]
- cpHaddocks :: !Bool
}
newtype GlobalPackageVersion = GlobalPackageVersion Version
data GlobalPackage
- = GlobalPackage !Version
- | ReplacedGlobalPackage ![PackageName]
isReplacedGlobal :: GlobalPackage -> Bool
newtype SourceMapHash = SourceMapHash SHA256
smRelDir :: MonadThrow m => SourceMapHash -> m (Path Rel Dir)

Different source map types

data SMWanted Source #

A source map with information on the wanted (but not actual) compiler. This is derived by parsing the stack.yaml file for packages, extra-deps, their configuration (e.g., flags and options), and parsing the snapshot it refers to. It does not include global packages or any information from the command line.

Invariant: a PackageName appears in either smwProject or smwDeps, but not both.

Constructors

SMWanted
Fields smwCompiler :: !WantedCompiler smwProject :: !(Map PackageName ProjectPackage) smwDeps :: !(Map PackageName DepPackage) smwSnapshotLocation :: !RawSnapshotLocation Where this snapshot is loaded from.

data SMActual global Source #

Adds in actual compiler information to SMWanted, in particular the contents of the global package database.

Invariant: a PackageName appears in only one of the Maps.

Constructors

SMActual
Fields smaCompiler :: !ActualCompiler smaProject :: !(Map PackageName ProjectPackage) smaDeps :: !(Map PackageName DepPackage) smaGlobal :: !(Map PackageName global)

data Target Source #

How a package is intended to be built

Constructors

TargetAll !PackageType	Build all of the default components.
TargetComps !(Set NamedComponent)	Only build specific components

data PackageType Source #

Constructors

PTProject
PTDependency

Instances

Instances details

Show PackageType Source #
Instance details Defined in Stack.Types.SourceMap Methods showsPrec :: Int -> PackageType -> ShowS # show :: PackageType -> String # showList :: [PackageType] -> ShowS #
Eq PackageType Source #
Instance details Defined in Stack.Types.SourceMap Methods (==) :: PackageType -> PackageType -> Bool # (/=) :: PackageType -> PackageType -> Bool #

data SMTargets Source #

Builds on an SMActual by resolving the targets specified on the command line, potentially adding in new dependency packages in the process.

Constructors

SMTargets
Fields smtTargets :: !(Map PackageName Target) smtDeps :: !(Map PackageName DepPackage)

data SourceMap Source #

The final source map, taking an SMTargets and applying all command line flags and GHC options.

Constructors

SourceMap

Fields

smTargets :: !SMTargets
Doesn't need to be included in the hash, does not affect the source map.
smCompiler :: !ActualCompiler
Need to hash the compiler version _and_ its installation path. Ideally there would be some kind of output from GHC telling us some unique ID for the compiler itself.
smProject :: !(Map PackageName ProjectPackage)
Doesn't need to be included in hash, doesn't affect any of the packages that get stored in the snapshot database.
smDeps :: !(Map PackageName DepPackage)
Need to hash all of the immutable dependencies, can ignore the mutable dependencies.
smGlobal :: !(Map PackageName GlobalPackage)
Doesn't actually need to be hashed, implicitly captured by smCompiler. Can be broken if someone installs new global packages. We can document that as not supported, _or_ we could actually include all of this in the hash and make Stack more resilient.

Helper types

data FromSnapshot Source #

Flag showing if package comes from a snapshot needed to ignore dependency bounds between such packages

Constructors

FromSnapshot
NotFromSnapshot

Instances

Instances details

Show FromSnapshot Source #
Instance details Defined in Stack.Types.SourceMap Methods showsPrec :: Int -> FromSnapshot -> ShowS # show :: FromSnapshot -> String # showList :: [FromSnapshot] -> ShowS #

data DepPackage Source #

A view of a dependency package, specified in stack.yaml

Constructors

DepPackage
Fields dpCommon :: !CommonPackage dpLocation :: !PackageLocation dpHidden :: !Bool Should the package be hidden after registering? Affects the script interpreter's module name import parser. dpFromSnapshot :: !FromSnapshot Needed to ignore bounds between snapshot packages See https://github.com/commercialhaskell/stackage/issues/3185

data ProjectPackage Source #

A view of a project package needed for resolving components

Constructors

ProjectPackage
Fields ppCommon :: !CommonPackage ppCabalFP :: !(Path Abs File) ppResolvedDir :: !(ResolvedPath Dir)

ppComponents :: MonadIO m => ProjectPackage -> m (Set NamedComponent) Source #

All components available in the given ProjectPackage

ppComponentsMaybe :: MonadIO m => (NamedComponent -> Maybe NamedComponent) -> ProjectPackage -> m (Set NamedComponent) Source #

ppGPD :: MonadIO m => ProjectPackage -> m GenericPackageDescription Source #

ppRoot :: ProjectPackage -> Path Abs Dir Source #

Root directory for the given ProjectPackage

ppVersion :: MonadIO m => ProjectPackage -> m Version Source #

Version for the given 'ProjectPackage

data CommonPackage Source #

Settings common to dependency packages (DepPackage) and project packages (ProjectPackage).

Constructors

CommonPackage
Fields cpGPD :: !(IO GenericPackageDescription) cpName :: !PackageName cpFlags :: !(Map FlagName Bool) overrides default flags cpGhcOptions :: ![Text] cpCabalConfigOpts :: ![Text] cpHaddocks :: !Bool Should Haddock documentation be built for this package?

newtype GlobalPackageVersion Source #

Constructors

GlobalPackageVersion Version

data GlobalPackage Source #

A view of a package installed in the global package database also could include marker for a replaced global package (could be replaced because of a replaced dependency)

Constructors

GlobalPackage !Version
ReplacedGlobalPackage ![PackageName]

Instances

Instances details

Eq GlobalPackage Source #
Instance details Defined in Stack.Types.SourceMap Methods (==) :: GlobalPackage -> GlobalPackage -> Bool # (/=) :: GlobalPackage -> GlobalPackage -> Bool #

isReplacedGlobal :: GlobalPackage -> Bool Source #

newtype SourceMapHash Source #

A unique hash for the immutable portions of a SourceMap.

Constructors

SourceMapHash SHA256

smRelDir :: MonadThrow m => SourceMapHash -> m (Path Rel Dir) Source #

Returns relative directory name with source map's hash