Skip to content

Commit 8395417

Browse files
andreabediniandreabedini
authored
Fix nix devshell (#2260)
* Reformat * Replace nixUnstable with nixVersions.latest * Refactor devShells * Improve formatting * Remove unused bindings * Other small improvements in flake.nix - rename compiler to defaultCompiler - avoid using `with` above traceHydraJobs
1 parent 54c84fc commit 8395417

File tree

2 files changed

+168
-169
lines changed

2 files changed

+168
-169
lines changed

‎flake.nix

Lines changed: 167 additions & 168 deletions
Original file line numberDiff line numberDiff line change
@@ -77,13 +77,6 @@
7777
{ self
7878
, nixpkgs
7979
, nixpkgs-unstable
80-
, nixpkgs-2105
81-
, nixpkgs-2111
82-
, nixpkgs-2205
83-
, nixpkgs-2211
84-
, nixpkgs-2305
85-
, nixpkgs-2311
86-
, nixpkgs-2405
8780
, flake-compat
8881
, ...
8982
}@inputs:
@@ -92,24 +85,24 @@
9285

9386
ifdLevel = 3;
9487
runningHydraEvalTest = false;
95-
compiler = "ghc928";
88+
defaultCompiler = "ghc928";
9689
config = import ./config.nix;
9790

9891
inherit (nixpkgs) lib;
9992

10093
traceNames = prefix: builtins.mapAttrs (n: v:
10194
if builtins.isAttrs v
102-
then if v ? type && v.type == "derivation"
103-
then builtins.trace (prefix + n) v
104-
else traceNames (prefix + n + ".") v
105-
else v);
95+
then if v ? type && v.type == "derivation"
96+
then builtins.trace (prefix + n) v
97+
else traceNames (prefix + n + ".") v
98+
else v);
10699

107100
traceHydraJobs = x: x // { inherit (traceNames "" x) hydraJobs; };
108101

109102
# systems supported by haskell.nix
110103
systems = [
111104
"x86_64-linux"
112-
] ++ (if runningHydraEvalTest then [] else [
105+
] ++ (if runningHydraEvalTest then [ ] else [
113106
"x86_64-darwin"
114107
"aarch64-darwin"
115108
]);
@@ -128,190 +121,196 @@
128121
filterDerivations;
129122

130123
flake = {
131-
inherit config;
132-
overlay = self.overlays.combined;
133-
overlays = import ./overlays { sources = inputs; };
124+
inherit config;
125+
overlay = self.overlays.combined;
126+
overlays = import ./overlays { sources = inputs; };
134127

135-
internal = {
136-
nixpkgsArgs = {
137-
inherit config;
138-
overlays = [ self.overlay ];
139-
};
128+
internal = {
129+
nixpkgsArgs = {
130+
inherit config;
131+
overlays = [ self.overlay ];
132+
};
140133

141-
sources = inputs;
134+
sources = inputs;
142135

143-
overlaysOverrideable =
144-
lib.warn
145-
"Using this attribute is deprecated. Import ${./overlays} directly or use the flake overlays output with override-inut."
146-
(import ./overlays);
136+
overlaysOverrideable =
137+
lib.warn
138+
"Using this attribute is deprecated. Import ${./overlays} directly or use the flake overlays output with override-inut."
139+
(import ./overlays);
147140

148-
# Compatibility with old default.nix
149-
compat =
150-
lib.warn
151-
"Using this attribute is deprecated. You can pass the same arguments to ${./default.nix} instead"
152-
(import ./default.nix);
153-
};
141+
# Compatibility with old default.nix
142+
compat =
143+
lib.warn
144+
"Using this attribute is deprecated. You can pass the same arguments to ${./default.nix} instead"
145+
(import ./default.nix);
146+
};
154147

155-
legacyPackages = forEachSystem (system:
156-
import nixpkgs {
157-
inherit config;
158-
overlays = [ self.overlay ];
159-
localSystem = { inherit system; };
160-
});
148+
legacyPackages = forEachSystem (system:
149+
import nixpkgs {
150+
inherit config;
151+
overlays = [ self.overlay ];
152+
localSystem = { inherit system; };
153+
});
161154

162-
legacyPackagesUnstable = forEachSystem (system:
163-
import nixpkgs-unstable {
164-
inherit config;
165-
overlays = [ self.overlay ];
166-
localSystem = { inherit system; };
167-
});
155+
legacyPackagesUnstable = forEachSystem (system:
156+
import nixpkgs-unstable {
157+
inherit config;
158+
overlays = [ self.overlay ];
159+
localSystem = { inherit system; };
160+
});
168161

169-
# Exposed so CI can check that `allow-import-from-derivation=false` works
170-
# for core of haskell.nix E.g. this should always work:
171-
# nix build .#roots.x86_64-linux --accept-flake-config --option allow-import-from-derivation false
172-
roots = forEachSystem (system:
173-
self.legacyPackagesUnstable.${system}.haskell-nix.roots compiler);
162+
# Exposed so CI can check that `allow-import-from-derivation=false` works
163+
# for core of haskell.nix E.g. this should always work:
164+
# nix build .#roots.x86_64-linux --accept-flake-config --option allow-import-from-derivation false
165+
roots = forEachSystem (system:
166+
self.legacyPackagesUnstable.${system}.haskell-nix.roots defaultCompiler);
174167

175-
# Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix
176-
# uses IFD heavily, you have to have the ability to build for all platforms
177-
# supported by haskell.nix, e.g. with remote builders, in order to check this flake.
178-
# If you want to run the tests for just your platform, run `./test/tests.sh` or
179-
# `nix-build -A checks.$PLATFORM`
180-
checks = forEachSystemPkgs (pkgs:
181-
builtins.listToAttrs (
182-
map
183-
(pkg: { name = pkg.name; value = pkg; })
184-
(lib.collect
185-
lib.isDerivation
186-
(import ./test {
187-
haskellNix.sources = inputs;
188-
haskellNix.nixpkgsArgs = nixpkgsArgs;
189-
compiler-nix-name = compiler;
190-
inherit pkgs;
191-
})
168+
# Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix
169+
# uses IFD heavily, you have to have the ability to build for all platforms
170+
# supported by haskell.nix, e.g. with remote builders, in order to check this flake.
171+
# If you want to run the tests for just your platform, run `./test/tests.sh` or
172+
# `nix-build -A checks.$PLATFORM`
173+
checks = forEachSystemPkgs (pkgs:
174+
builtins.listToAttrs (
175+
map
176+
(pkg: { name = pkg.name; value = pkg; })
177+
(lib.collect
178+
lib.isDerivation
179+
(import ./test {
180+
haskellNix.sources = inputs;
181+
haskellNix.nixpkgsArgs = nixpkgsArgs;
182+
compiler-nix-name = defaultCompiler;
183+
inherit pkgs;
184+
})
192185
)
193-
)
186+
)
187+
);
188+
189+
# NOTE: these are the hix cli utilities, which is a separate thing from
190+
# the hix.nix overlays (which extends haskell.nix with hixProject).
191+
packages = forEachSystemPkgs (pkgs:
192+
(import ./hix/default.nix { inherit pkgs; }).apps
194193
);
195194

196-
# NOTE: these are the hix cli utilities, which is a separate thing from
197-
# the hix.nix overlays (which extends haskell.nix with hixProject).
198-
packages = forEachSystemPkgs (pkgs:
199-
(import ./hix/default.nix { inherit pkgs; }).apps
200-
);
201-
apps = forEachSystemPkgs (pkgs:
202-
builtins.mapAttrs (name: exe: {
203-
type = "app";
204-
program = exe + "/bin/${name}";
205-
}) pkgs.haskell-nix.nix-tools-unchecked.exes
206-
);
195+
apps = forEachSystemPkgs (pkgs:
196+
builtins.mapAttrs
197+
(name: exe: {
198+
type = "app";
199+
program = exe + "/bin/${name}";
200+
})
201+
pkgs.haskell-nix.nix-tools-unchecked.exes
202+
);
207203

208-
allJobs = forEachSystem (system:
209-
stripAttrsForHydra (filterDerivations (
210-
# This is awkward.
211-
import ./ci.nix {
212-
inherit ifdLevel system;
213-
haskellNix = self;
214-
})));
204+
allJobs = forEachSystem (system:
205+
stripAttrsForHydra (filterDerivations (
206+
# This is awkward.
207+
import ./ci.nix {
208+
inherit ifdLevel system;
209+
haskellNix = self;
210+
}
211+
)));
215212

216-
requiredJobs = forEachSystem (system:
217-
let
218-
inherit (self.legacyPackages.${system}) releaseTools;
219-
in
220-
lib.concatMapAttrs (nixpkgsVer:
221-
lib.concatMapAttrs (compiler-nix-name:
222-
lib.concatMapAttrs (crossPlatform: ghcJobs:
223-
let
224-
name = "required-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}";
225-
value = releaseTools.aggregate {
213+
requiredJobs = forEachSystem (system:
214+
let
215+
inherit (self.legacyPackages.${system}) releaseTools;
216+
in
217+
lib.concatMapAttrs
218+
(nixpkgsVer:
219+
lib.concatMapAttrs (compiler-nix-name:
220+
lib.concatMapAttrs (crossPlatform: ghcJobs:
221+
let
222+
name = "required-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}";
223+
value = releaseTools.aggregate {
226224
name = "haskell.nix-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}";
227225
meta.description = "All ${nixpkgsVer} ${compiler-nix-name} ${crossPlatform} jobs";
228226
constituents = lib.collect lib.isDerivation ghcJobs;
229-
};
230-
in
231-
lib.optionalAttrs
232-
(crossPlatform != "recurseForDerivations" && crossPlatform != "meta")
233-
{ ${name} = value; })
227+
};
228+
in
229+
lib.optionalAttrs
230+
(crossPlatform != "recurseForDerivations" && crossPlatform != "meta")
231+
{ ${name} = value; })
234232
)
235233
)
236234
self.allJobs.${system}
237-
);
235+
);
238236

239-
hydraJobs = forEachSystem (system:
240-
let
241-
# Include hydraJobs from nix-tools subflake.
242-
# NOTE: These derivations do not depend on the haskell.nix in ./. but
243-
# on the version of haskell.nix locked in the subflake. They are
244-
# evaluated within their own flake and independently of anything
245-
# else. Here we only expose them in the main flake.
246-
nix-tools-hydraJobs =
247-
let cf = callFlake {
248-
inherit system;
249-
pkgs = self.legacyPackages.${system};
250-
src = ./nix-tools;
251-
};
252-
in cf.defaultNix.hydraJobs;
253-
in
254-
self.allJobs.${system}
237+
hydraJobs = forEachSystem (system:
238+
let
239+
# Include hydraJobs from nix-tools subflake.
240+
# NOTE: These derivations do not depend on the haskell.nix in ./. but
241+
# on the version of haskell.nix locked in the subflake. They are
242+
# evaluated within their own flake and independently of anything
243+
# else. Here we only expose them in the main flake.
244+
nix-tools-hydraJobs =
245+
let
246+
cf = callFlake {
247+
inherit system;
248+
pkgs = self.legacyPackages.${system};
249+
src = ./nix-tools;
250+
};
251+
in
252+
cf.defaultNix.hydraJobs;
253+
in
254+
self.allJobs.${system}
255255
// lib.optionalAttrs (ifdLevel > 2)
256-
{ nix-tools = nix-tools-hydraJobs.${system} or {}; }
257-
);
256+
{ nix-tools = nix-tools-hydraJobs.${system} or { }; }
257+
);
258258

259-
devShells = forEachSystemPkgs (pkgs:
260-
let inherit (pkgs) mkShell nixUnstable cabal-install haskell-nix;
261-
in {
262-
default =
263-
mkShell {
264-
buildInputs = [
265-
nixUnstable
266-
cabal-install
267-
haskell-nix.compiler.${compiler}
268-
];
269-
};
259+
devShells = forEachSystemPkgs (pkgs:
260+
let
261+
mkHaskellNixShell = compiler-nix-name:
262+
pkgs.mkShell {
263+
buildInputs = [
264+
pkgs.nixVersions.latest
265+
pkgs.haskell-nix.cabal-install.${compiler-nix-name}
266+
pkgs.haskell-nix.compiler.${compiler-nix-name}
267+
];
268+
};
269+
shells = lib.genAttrs (
270+
# Exclude old versions of GHC to speed up `nix flake check`
271+
lib.attrNames (
272+
lib.removeAttrs pkgs.haskell-nix.compiler
273+
([ "ghc844" ] ++
274+
[ "ghc861" "ghc862" "ghc863" "ghc864" ] ++
275+
[ "ghc881" "ghc882" "ghc883" ] ++
276+
[ "ghc8101" "ghc8102" "ghc8103" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" ] ++
277+
[ "ghc901" ] ++ [ "ghc921" "ghc922" "ghc923" ])
278+
))
279+
mkHaskellNixShell;
280+
in
281+
shells // { default = shells.${defaultCompiler}; });
282+
};
283+
284+
in
285+
traceHydraJobs (lib.recursiveUpdate flake (lib.optionalAttrs (ifdLevel > 2)
286+
(
287+
let pkgs = nixpkgs.legacyPackages."x86_64-linux"; in
288+
{
289+
hydraJobs.nix-tools = pkgs.releaseTools.aggregate {
290+
name = "nix-tools";
291+
constituents = (if runningHydraEvalTest then [ ] else [
292+
"aarch64-darwin.nix-tools.static.zipped.nix-tools-static"
293+
"x86_64-darwin.nix-tools.static.zipped.nix-tools-static"
294+
"aarch64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd"
295+
"x86_64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd"
296+
]) ++ [
297+
"x86_64-linux.nix-tools.static.zipped.nix-tools-static"
298+
"x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64"
299+
"x86_64-linux.nix-tools.static.zipped.nix-tools-static-no-ifd"
300+
"x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64-no-ifd"
301+
(pkgs.writeText "gitrev" (self.rev or "0000000000000000000000000000000000000000"))
302+
];
303+
};
270304
}
271-
//
272-
builtins.mapAttrs
273-
(compiler-nix-name: compiler:
274-
mkShell {
275-
buildInputs = [
276-
compiler
277-
haskell-nix.cabal-install.${compiler-nix-name}
278-
];
279-
})
280-
( # Exclude old versions of GHC to speed up `nix flake check`
281-
builtins.removeAttrs haskell-nix.compiler
282-
[ "ghc844"
283-
"ghc861" "ghc862" "ghc863" "ghc864"
284-
"ghc881" "ghc882" "ghc883"
285-
"ghc8101" "ghc8102" "ghc8103" "ghc8104" "ghc8105" "ghc8106" "ghc810420210212"
286-
"ghc901"
287-
"ghc921" "ghc922" "ghc923"])
288-
);
289-
}; in with (import nixpkgs { system = "x86_64-linux"; });
290-
traceHydraJobs (lib.recursiveUpdate flake (lib.optionalAttrs (ifdLevel > 2) {
291-
hydraJobs.nix-tools = pkgs.releaseTools.aggregate {
292-
name = "nix-tools";
293-
constituents = (if runningHydraEvalTest then [] else [
294-
"aarch64-darwin.nix-tools.static.zipped.nix-tools-static"
295-
"x86_64-darwin.nix-tools.static.zipped.nix-tools-static"
296-
"aarch64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd"
297-
"x86_64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd"
298-
]) ++ [
299-
"x86_64-linux.nix-tools.static.zipped.nix-tools-static"
300-
"x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64"
301-
"x86_64-linux.nix-tools.static.zipped.nix-tools-static-no-ifd"
302-
"x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64-no-ifd"
303-
(writeText "gitrev" (self.rev or "0000000000000000000000000000000000000000"))
304-
];
305-
};
306-
}));
305+
)));
307306

308307
# --- Flake Local Nix Configuration ----------------------------
309308
nixConfig = {
310309
# This sets the flake to use the IOG nix cache.
311310
# Nix should ask for permission before using it,
312311
# but remove it here if you do not want it to.
313-
extra-substituters = ["https://cache.iog.io"];
314-
extra-trusted-public-keys = ["hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="];
312+
extra-substituters = [ "https://cache.iog.io" ];
313+
extra-trusted-public-keys = [ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=" ];
315314
allow-import-from-derivation = "true";
316315
};
317316
}

0 commit comments

Comments
 (0)