core/pkgs/top-level/splice.nix

193 lines
6.8 KiB
Nix
Raw Normal View History

2024-05-02 00:46:19 +00:00
# The `splicedPackages' package set, and its use by `callPackage`
#
# The `buildPackages` pkg set is a new concept, and the vast majority package
# expression (the other *.nix files) are not designed with it in mind. This
# presents us with a problem with how to get the right version (build-time vs
# run-time) of a package to a consumer that isn't used to thinking so cleverly.
#
# The solution is to splice the package sets together as we do below, so every
# `callPackage`d expression in fact gets both versions. Each derivation (and
# each derivation's outputs) consists of the run-time version, augmented with
# a `__spliced.buildHost` field for the build-time version, and
# `__spliced.hostTarget` field for the run-time version.
#
# For performance reasons, rather than uniformally splice in all cases, we only
# do so when `pkgs` and `buildPackages` are distinct. The `actuallySplice`
# parameter there the boolean value of that equality check.
lib: pkgs: actuallySplice:
let
spliceReal =
2024-06-30 08:16:52 +00:00
{
pkgsBuildBuild,
pkgsBuildHost,
pkgsBuildTarget,
pkgsHostHost,
pkgsHostTarget,
pkgsTargetTarget,
2024-05-02 00:46:19 +00:00
}:
let
mash =
# Other pkgs sets
2024-06-30 08:16:52 +00:00
pkgsBuildBuild
// pkgsBuildTarget
// pkgsHostHost
// pkgsTargetTarget
2024-05-02 00:46:19 +00:00
# The same pkgs sets one probably intends
2024-06-30 08:16:52 +00:00
// pkgsBuildHost
// pkgsHostTarget;
2024-05-02 00:46:19 +00:00
merge = name: {
inherit name;
value =
let
defaultValue = mash.${name};
# `or {}` is for the non-derivation attsert splicing case, where `{}` is the identity.
valueBuildBuild = pkgsBuildBuild.${name} or { };
valueBuildHost = pkgsBuildHost.${name} or { };
valueBuildTarget = pkgsBuildTarget.${name} or { };
valueHostHost = pkgsHostHost.${name} or { };
valueHostTarget = pkgsHostTarget.${name} or { };
valueTargetTarget = pkgsTargetTarget.${name} or { };
2024-06-30 08:16:52 +00:00
augmentedValue = defaultValue // {
2024-05-02 00:46:19 +00:00
__spliced =
(lib.optionalAttrs (pkgsBuildBuild ? ${name}) { buildBuild = valueBuildBuild; })
2024-06-30 08:16:52 +00:00
// (lib.optionalAttrs (pkgsBuildHost ? ${name}) { buildHost = valueBuildHost; })
// (lib.optionalAttrs (pkgsBuildTarget ? ${name}) { buildTarget = valueBuildTarget; })
// (lib.optionalAttrs (pkgsHostHost ? ${name}) { hostHost = valueHostHost; })
// (lib.optionalAttrs (pkgsHostTarget ? ${name}) { hostTarget = valueHostTarget; })
// (lib.optionalAttrs (pkgsTargetTarget ? ${name}) { targetTarget = valueTargetTarget; });
2024-05-02 00:46:19 +00:00
};
# Get the set of outputs of a derivation. If one derivation fails to
# evaluate we don't want to diverge the entire splice, so we fall back
# on {}
2024-06-30 08:16:52 +00:00
tryGetOutputs =
value0:
2024-05-02 00:46:19 +00:00
let
inherit (builtins.tryEval value0) success value;
in
getOutputs (lib.optionalAttrs success value);
2024-06-30 08:16:52 +00:00
getOutputs =
value: lib.genAttrs (value.outputs or (lib.optional (value ? out) "out")) (output: value.${output});
2024-05-02 00:46:19 +00:00
in
# The derivation along with its outputs, which we recur
2024-06-30 08:16:52 +00:00
# on to splice them together.
if lib.isDerivation defaultValue then
augmentedValue
// spliceReal {
pkgsBuildBuild = tryGetOutputs valueBuildBuild;
pkgsBuildHost = tryGetOutputs valueBuildHost;
pkgsBuildTarget = tryGetOutputs valueBuildTarget;
pkgsHostHost = tryGetOutputs valueHostHost;
pkgsHostTarget = getOutputs valueHostTarget;
pkgsTargetTarget = tryGetOutputs valueTargetTarget;
# Just recur on plain attrsets
}
else if lib.isAttrs defaultValue then
spliceReal {
pkgsBuildBuild = valueBuildBuild;
pkgsBuildHost = valueBuildHost;
pkgsBuildTarget = valueBuildTarget;
pkgsHostHost = valueHostHost;
pkgsHostTarget = valueHostTarget;
pkgsTargetTarget = valueTargetTarget;
# Don't be fancy about non-derivations. But we could have used used
# `__functor__` for functions instead.
}
else
defaultValue;
2024-05-02 00:46:19 +00:00
};
in
lib.listToAttrs (map merge (lib.attrNames mash));
splicePackages =
2024-06-30 08:16:52 +00:00
{
pkgsBuildBuild,
pkgsBuildHost,
pkgsBuildTarget,
pkgsHostHost,
pkgsHostTarget,
pkgsTargetTarget,
}@args:
2024-05-02 00:46:19 +00:00
if actuallySplice then spliceReal args else pkgsHostTarget;
2024-06-30 08:16:52 +00:00
splicedPackages =
splicePackages {
2024-05-02 00:46:19 +00:00
inherit (pkgs)
2024-06-30 08:16:52 +00:00
pkgsBuildBuild
pkgsBuildHost
pkgsBuildTarget
pkgsHostHost
pkgsHostTarget
2024-05-02 00:46:19 +00:00
pkgsTargetTarget
;
2024-06-30 08:16:52 +00:00
}
// {
# These should never be spliced under any circumstances
inherit (pkgs)
pkgsBuildBuild
pkgsBuildHost
pkgsBuildTarget
pkgsHostHost
pkgsHostTarget
pkgsTargetTarget
buildPackages
pkgs
targetPackages
;
inherit (pkgs.stdenv) buildPlatform targetPlatform hostPlatform;
};
2024-05-02 00:46:19 +00:00
2024-06-30 08:16:52 +00:00
splicedPackagesWithXorg =
splicedPackages
// builtins.removeAttrs splicedPackages.xorg [
"callPackage"
"newScope"
"overrideScope"
"packages"
];
2024-05-02 00:46:19 +00:00
in
{
inherit splicePackages;
# We use `callPackage' to be able to omit function arguments that can be
# obtained `pkgs` or `buildPackages` and their `xorg` package sets. Use
# `newScope' for sets of packages in `pkgs' (see e.g. `gnome' below).
callPackage = pkgs.newScope { };
callPackages = lib.callPackagesWith splicedPackagesWithXorg;
newScope = extra: lib.callPackageWith (splicedPackagesWithXorg // extra);
# prefill 2 fields of the function for convenience
makeScopeWithSplicing = lib.makeScopeWithSplicing splicePackages pkgs.newScope;
2024-06-30 08:16:52 +00:00
makeScopeWithSplicing' = lib.makeScopeWithSplicing' {
inherit splicePackages;
inherit (pkgs) newScope;
};
2024-05-02 00:46:19 +00:00
# generate 'otherSplices' for 'makeScopeWithSplicing'
2024-06-30 08:16:52 +00:00
generateSplicesForMkScope =
attr:
2024-05-02 00:46:19 +00:00
let
split = X: lib.splitString "." "${X}.${attr}";
in
{
# nulls should never be reached
selfBuildBuild = lib.attrByPath (split "pkgsBuildBuild") null pkgs;
selfBuildHost = lib.attrByPath (split "pkgsBuildHost") null pkgs;
selfBuildTarget = lib.attrByPath (split "pkgsBuildTarget") null pkgs;
selfHostHost = lib.attrByPath (split "pkgsHostHost") null pkgs;
selfHostTarget = lib.attrByPath (split "pkgsHostTarget") null pkgs;
selfTargetTarget = lib.attrByPath (split "pkgsTargetTarget") { } pkgs;
};
# Haskell package sets need this because they reimplement their own
# `newScope`.
2024-06-30 08:16:52 +00:00
__splicedPackages = splicedPackages // {
recurseForDerivations = false;
};
2024-05-02 00:46:19 +00:00
}