git.iko.soy/haskell.nix
on iko/ghcjs-patch-master help sign in
Use nix module system to check project arguments (#1087)

* Use nix module system to check project arguments This change uses the nix module system for the arguments to: * `cabalProject'` * `cabalProject` * `stackProject'` * `stackProject` This will: * Give an error when the name or type of an argument is incorrect (currently misnamed args are quietly ignored). * Fixes a problem with `projectCross` not having a way to pass different args to `cabalProject` for different platforms. We can now use: `({pkgs, ...}: { cabalProjectLocal = if pkgs.stdenv.hostPlatform.isX then ... })`

commit4f449d37f5c17284db93fff9761967d92221f574 authorHamish Mackenzie <Hamish.Mackenzie@iohk.io> dateThu 8 Apr 2021, 12:06 (6 years ago) parent1b9b05b
7 files changed+302−29
compare with iko/ghcjs-patch-master
unifiedsplit
changelog.md+5 lib/call-cabal-project-to-nix.nix+10−2 lib/default.nix+17 modules/cabal-project.nix+140 modules/stack-project.nix+112 overlays/bootstrap.nix+1−8 overlays/haskell.nix+17−19
changelog.md+5
@@ -1,6 +1,11 @@
11This file contains a summary of changes to Haskell.nix and `nix-tools`
22that will impact users.
33
4+## Apr 8, 2021
5+* Project arguments are now validated with the Nix module system.
6+ If unexpected argments are passed to a project function this may now
7+ result in an error.
8+
49## Feb 22, 2021
510* Add `.dwarf` to build any component with DWARF dubug info on linux
611 (ghc >=8.10.2).
lib/call-cabal-project-to-nix.nix+10−2
@@ -21,8 +21,6 @@ in
2121, caller ? "callCabalProjectToNix" # Name of the calling function for better warning messages
2222, ghc ? null # Deprecated in favour of `compiler-nix-name`
2323, ghcOverride ? null # Used when we need to set ghc explicitly during bootstrapping
24−, nix-tools ? evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name} # When building cabal projects we use the nix-tools
25−, cabal-install ? evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name} # and cabal-install compiled with matching ghc version
2624, configureArgs ? "" # Extra arguments to pass to `cabal v2-configure`.
2725 # `--enable-tests --enable-benchmarks` are included by default.
2826 # If the tests and benchmarks are not needed and they
@@ -43,6 +41,16 @@ in
4341}@args:
4442
4543let
44+ # These defaults are hear rather than in modules/cabal-project.nix to make them
45+ # lazy enough to avoid infinite recursion issues.
46+ # Using null as the default also improves performance as they are not forced by the
47+ # nix module system for `nix-tools-unchecked` and `cabal-install-unchecked`.
48+ nix-tools = if args.nix-tools or null != null
49+ then args.nix-tools
50+ else evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name};
51+ cabal-install = if args.cabal-install or null != null
52+ then args.cabal-install
53+ else evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name};
4654 forName = pkgs.lib.optionalString (name != null) (" for " + name);
4755 nameAndSuffix = suffix: if name == null then suffix else name + "-" + suffix;
4856
lib/default.nix+17
@@ -333,4 +333,21 @@ in {
333333 }
334334 else src.origSrc or src; # If there is a subDir and origSrc (but no filter) use origSrc
335335 };
336+
337+ # Run evalModules passing the project function argument (m) as a module along with
338+ # the the a projectType module (../modules/cabal-project.nix or ../modules/stack-project.nix).
339+ # The resulting config is then passed to the project function's implementation.
340+ evalProjectModule = projectType: m: f: f
341+ (lib.evalModules {
342+ modules = [m] ++ [
343+ # Include ../modules/cabal-project.nix or ../modules/stack-project.nix
344+ (import projectType)
345+ # Pass the pkgs to the modules
346+ ({ config, lib, ... }: {
347+ _module.args = {
348+ inherit pkgs;
349+ };
350+ })
351+ ];
352+ }).config;
336353}
modules/cabal-project.nixnew file+140
@@ -0,0 +1,140 @@
1+{ lib, config, pkgs, haskellLib, ... }:
2+with lib;
3+with types;
4+let readIfExists = src: fileName:
5+ let origSrcDir = src.origSrcSubDir or src;
6+ in
7+ if builtins.elem ((__readDir origSrcDir)."${fileName}" or "") ["regular" "symlink"]
8+ then __readFile (origSrcDir + "/${fileName}")
9+ else null;
10+in {
11+ options = {
12+ # Used by callCabalProjectToNix
13+ name = mkOption {
14+ type = nullOr str;
15+ default = config.src.name or null;
16+ description = "Optional name for better error messages";
17+ };
18+ src = mkOption {
19+ type = either path package;
20+ };
21+ compiler-nix-name = mkOption {
22+ type = str;
23+ description = "The name of the ghc compiler to use eg. \"ghc884\"";
24+ };
25+ index-state = mkOption {
26+ type = nullOr str;
27+ default = null;
28+ description = "Hackage index-state, eg. \"2019-10-10T00:00:00Z\"";
29+ };
30+ index-sha256 = mkOption {
31+ type = nullOr str;
32+ default = null;
33+ description = "The hash of the truncated hackage index-state";
34+ };
35+ plan-sha256 = mkOption {
36+ type = nullOr str;
37+ default = null;
38+ description = "The hash of the plan-to-nix output (makes the plan-to-nix step a fixed output derivation)";
39+ };
40+ materialized = mkOption {
41+ type = nullOr (either path package);
42+ default = null;
43+ description = "Location of a materialized copy of the nix files";
44+ };
45+ checkMaterialization = mkOption {
46+ type = nullOr bool;
47+ default = null;
48+ description = "If true the nix files will be generated used to check plan-sha256 and material";
49+ };
50+ cabalProjectFileName = mkOption {
51+ type = str;
52+ default = "cabal.project";
53+ };
54+ cabalProject = mkOption {
55+ type = nullOr str;
56+ default = readIfExists config.src config.cabalProjectFileName;
57+ };
58+ cabalProjectLocal = mkOption {
59+ type = nullOr str;
60+ default = readIfExists config.src "${config.cabalProjectFileName}.local";
61+ };
62+ cabalProjectFreeze = mkOption {
63+ type = nullOr str;
64+ default = readIfExists config.src "${config.cabalProjectFileName}.freeze";
65+ };
66+ caller = mkOption {
67+ type = str;
68+ default = "callCabalProjectToNix";
69+ description = "Name of the calling function for better warning messages";
70+ };
71+ ghc = mkOption {
72+ type = nullOr package;
73+ default = null;
74+ description = "Deprecated in favour of `compiler-nix-name`";
75+ };
76+ ghcOverride = mkOption {
77+ type = nullOr package;
78+ default = null;
79+ description = "Used when we need to set ghc explicitly during bootstrapping";
80+ };
81+ # The defaults for `nix-tools` and `cabal-install` are in `call-cabal-project-to-nix.nix`
82+ # to make sure it is not evaluated too strictly (which would lead to infinite recursion).
83+ nix-tools = mkOption {
84+ type = nullOr package;
85+ default = null;
86+ description = "nix-tools to use when converting the `plan.json` to nix";
87+ };
88+ cabal-install = mkOption {
89+ type = nullOr package;
90+ default = null;
91+ description = "cabal-install to use when running `cabal configure`";
92+ };
93+ configureArgs = mkOption {
94+ type = nullOr str;
95+ default = "";
96+ description = ''
97+ Extra arguments to pass to `cabal v2-configure`.
98+ `--enable-tests --enable-benchmarks` are included by default.
99+ If the tests and benchmarks are not needed and they
100+ cause the wrong plan to be chosen, then we can use
101+ `configureArgs = "--disable-tests --disable-benchmarks";`
102+ '';
103+ };
104+ sha256map = mkOption {
105+ type = nullOr unspecified;
106+ default = null;
107+ description = ''
108+ An alternative to adding `--sha256` comments into the
109+ cabal.project file:
110+ sha256map =
111+ { "https://github.com/jgm/pandoc-citeproc"."0.17"
112+ = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };
113+ '';
114+ };
115+ lookupSha256 = mkOption {
116+ type = nullOr unspecified;
117+ default = if config.sha256map != null
118+ then { location, tag, ...}: config.sha256map.${location}.${tag}
119+ else _: null;
120+ };
121+ extra-hackage-tarballs = mkOption {
122+ type = nullOr (listOf unspecified);
123+ default = [];
124+ };
125+
126+ # Used by mkCabalProjectPkgSet
127+ pkg-def-extras = mkOption {
128+ type = nullOr (listOf unspecified);
129+ default = [];
130+ };
131+ modules = mkOption {
132+ type = nullOr (listOf unspecified);
133+ default = [];
134+ };
135+ extra-hackages = mkOption {
136+ type = nullOr (listOf unspecified);
137+ default = [];
138+ };
139+ };
140+}
modules/stack-project.nixnew file+112
@@ -0,0 +1,112 @@
1+{ lib, config, pkgs, haskellLib, ... }:
2+with lib;
3+with types;
4+{
5+ options = {
6+ # Used by callStackToNix
7+ name = mkOption {
8+ type = nullOr str;
9+ default = config.src.name or null;
10+ description = "Optional name for better error messages";
11+ };
12+ src = mkOption {
13+ type = either path package;
14+ };
15+ stackYaml = mkOption {
16+ type = str;
17+ default = "stack.yaml";
18+ };
19+ ignorePackageYaml = mkOption {
20+ type = bool;
21+ default = false;
22+ };
23+ cache = mkOption {
24+ type = nullOr unspecified;
25+ default = null;
26+ };
27+ stack-sha256 = mkOption {
28+ type = nullOr str;
29+ default = null;
30+ };
31+ resolverSha256 = mkOption {
32+ type = nullOr str;
33+ default = null;
34+ };
35+ materialized = mkOption {
36+ type = nullOr (either path package);
37+ default = null;
38+ description = "Location of a materialized copy of the nix files";
39+ };
40+ checkMaterialization = mkOption {
41+ type = nullOr bool;
42+ default = null;
43+ description = "If true the nix files will be generated used to check plan-sha256 and material";
44+ };
45+ caller = mkOption {
46+ type = str;
47+ default = "callCabalProjectToNix";
48+ description = "Name of the calling function for better warning messages";
49+ };
50+ nix-tools = mkOption {
51+ type = nullOr package;
52+ default = pkgs.evalPackages.haskell-nix.internal-nix-tools;
53+ description = "nix-tools to use when converting the `plan.json` to nix";
54+ };
55+
56+ # Used by mkStackPkgSet
57+ pkg-def-extras = mkOption {
58+ type = nullOr (listOf unspecified);
59+ default = [];
60+ };
61+ modules = mkOption {
62+ type = nullOr (listOf unspecified);
63+ default = [];
64+ };
65+ extra-hackages = mkOption {
66+ type = nullOr (listOf unspecified);
67+ default = [];
68+ };
69+
70+ # Used in stack-cache-generator.nix
71+ sha256map = mkOption {
72+ type = nullOr unspecified;
73+ default = null;
74+ description = ''
75+ An alternative to adding `# nix-sha256:` comments into the
76+ stack.yaml file:
77+ sha256map =
78+ { "https://github.com/jgm/pandoc-citeproc"."0.17"
79+ = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };
80+ '';
81+ };
82+ lookupSha256 = mkOption {
83+ type = nullOr unspecified;
84+ default = if config.sha256map != null
85+ then { location, tag, ...}: config.sha256map.${location}.${tag}
86+ else _: null;
87+ };
88+ branchMap = mkOption {
89+ type = nullOr unspecified;
90+ default = null;
91+ description = "A way to specify in which branch a git commit can be found";
92+ };
93+ lookupBranch = mkOption {
94+ type = nullOr unspecified;
95+ default = if config.branchMap != null
96+ then { location, tag, ...}: config.branchMap.${location}.${tag} or null
97+ else _: null;
98+ };
99+
100+ # Used by stackProject itself
101+ compiler-nix-name = mkOption {
102+ type = nullOr str;
103+ description = "The name of the ghc compiler to use eg. \"ghc884\"";
104+ default = null;
105+ };
106+ ghc = mkOption {
107+ type = nullOr package;
108+ default = null;
109+ description = "Deprecated in favour of `compiler-nix-name`";
110+ };
111+ };
112+}
overlays/bootstrap.nix+1−8
@@ -632,10 +632,6 @@ in {
632632 name = "cabal-install";
633633 version = "3.4.0.0";
634634 index-state = final.haskell-nix.internalHackageIndexState;
635− # When building cabal-install (only happens when checking materialization)
636− # disable checking of the tools used to avoid infinite recursion.
637− cabal-install = final.evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name};
638− nix-tools = final.evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name};
639635 materialized = ../materialized + "/${compiler-nix-name}/cabal-install";
640636 } // args)).getComponent "exe:cabal";
641637 nix-tools-set = { compiler-nix-name, ... }@args:
@@ -648,6 +644,7 @@ in {
648644 else args.compiler-nix-name;
649645 project =
650646 final.haskell-nix.cabalProject ({
647+ caller = "nix-tools-set";
651648 name = "nix-tools";
652649 src = final.haskell-nix.sources.nix-tools;
653650 # This is a handy way to use a local git clone of nix-tools when developing
@@ -657,10 +654,6 @@ in {
657654 allow-newer: Cabal:base, cryptohash-sha512:base, haskeline:base
658655 index-state: ${final.haskell-nix.internalHackageIndexState}
659656 '';
660− # When building cabal-install (only happens when checking materialization)
661− # disable checking of the tools used to avoid infinite recursion.
662− cabal-install = final.evalPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name};
663− nix-tools = final.evalPackages.haskell-nix.nix-tools-unchecked.${compiler-nix-name};
664657 materialized = ../materialized + "/${compiler-nix-name}/nix-tools";
665658 modules = [{
666659 packages.transformers-compat.components.library.doExactConfig = true;
overlays/haskell.nix+17−19
@@ -496,6 +496,7 @@ final: prev: {
496496 # separately from the hsPkgs. The advantage is that the you can get the
497497 # plan-nix without building the project.
498498 cabalProject' =
499+ projectModule: haskellLib.evalProjectModule ../modules/cabal-project.nix projectModule (
499500 { src, compiler-nix-name, ... }@args':
500501 let
501502 args = { caller = "cabalProject'"; } // args';
@@ -515,10 +516,9 @@ final: prev: {
515516 { inherit compiler-nix-name plan-pkgs;
516517 pkg-def-extras = args.pkg-def-extras or [];
517518 modules = (args.modules or [])
518− ++ final.lib.optional (args ? ghcOverride || args ? ghc)
519− { ghc.package = args.ghcOverride or args.ghc; }
520− ++ final.lib.optional (args ? compiler-nix-name)
521− { compiler.nix-name = final.lib.mkForce args.compiler-nix-name; };
519+ ++ final.lib.optional (args.ghcOverride != null || args.ghc != null)
520+ { ghc.package = if args.ghcOverride != null then args.ghcOverride else args.ghc; }
521+ ++ [ { compiler.nix-name = final.lib.mkForce args.compiler-nix-name; } ];
522522 extra-hackages = args.extra-hackages or [];
523523 };
524524
@@ -531,9 +531,9 @@ final: prev: {
531531 tools = final.buildPackages.haskell-nix.tools pkg-set.config.compiler.nix-name;
532532 roots = final.haskell-nix.roots pkg-set.config.compiler.nix-name;
533533 projectFunction = haskell-nix: haskell-nix.cabalProject';
534− projectArgs = args';
534+ inherit projectModule;
535535 };
536− in project;
536+ in project);
537537
538538
539539 # Take `hsPkgs` from the `rawProject` and update all the packages and
@@ -583,7 +583,7 @@ final: prev: {
583583 projectCoverageReport = haskellLib.projectCoverageReport project (map (pkg: pkg.coverageReport) (final.lib.attrValues (haskellLib.selectProjectPackages hsPkgs)));
584584
585585 projectCross = (final.lib.mapAttrs (_: pkgs:
586− rawProject.projectFunction pkgs.haskell-nix rawProject.projectArgs
586+ rawProject.projectFunction pkgs.haskell-nix rawProject.projectModule
587587 ) final.pkgsCross) // { recurseForDerivations = false; };
588588
589589 # Like `.hsPkgs.${packageName}` but when compined with `getComponent` any
@@ -684,25 +684,23 @@ final: prev: {
684684 inherit (rawProject.hsPkgs) makeConfigFiles ghcWithHoogle ghcWithPackages shellFor;
685685 });
686686
687− cabalProject =
688− { src, compiler-nix-name, ... }@args':
689− let
690− args = { caller = "hackage-package"; } // args';
691− p = cabalProject' args;
687+ cabalProject = args: let p = cabalProject' args;
692688 in p.hsPkgs // p;
693689
694690 stackProject' =
691+ projectModule: haskellLib.evalProjectModule ../modules/stack-project.nix projectModule (
695692 { src, ... }@args:
696− let callProjectResults = callStackToNix ({ inherit cache; } // args);
693+ let callProjectResults = callStackToNix (args
694+ // final.lib.optionalAttrs (args.cache == null) { inherit cache; });
697695 generatedCache = genStackCache args;
698− cache = args.cache or generatedCache;
696+ cache = if args.cache != null then args.cache else generatedCache;
699697 in let pkg-set = mkStackPkgSet
700698 { stack-pkgs = importAndFilterProject callProjectResults;
701699 pkg-def-extras = (args.pkg-def-extras or []);
702700 modules = final.lib.singleton (mkCacheModule cache)
703701 ++ (args.modules or [])
704− ++ final.lib.optional (args ? ghc) { ghc.package = args.ghc; }
705− ++ final.lib.optional (args ? compiler-nix-name)
702+ ++ final.lib.optional (args.ghc != null) { ghc.package = args.ghc; }
703+ ++ final.lib.optional (args.compiler-nix-name != null)
706704 { compiler.nix-name = final.lib.mkForce args.compiler-nix-name; };
707705 };
708706
@@ -714,9 +712,9 @@ final: prev: {
714712 tools = final.buildPackages.haskell-nix.tools pkg-set.config.compiler.nix-name;
715713 roots = final.haskell-nix.roots pkg-set.config.compiler.nix-name;
716714 projectFunction = haskell-nix: haskell-nix.stackProject';
717− projectArgs = args;
715+ inherit projectModule;
718716 };
719− in project;
717+ in project);
720718
721719 stackProject = args: let p = stackProject' args;
722720 in p.hsPkgs // p;
@@ -732,7 +730,7 @@ final: prev: {
732730 # used (as it will use a default `cabal.project`).
733731 project' = { src, projectFileName ? null, ... }@args':
734732 let
735− args = { caller = "project'"; } // args';
733+ args = { caller = "project'"; } // final.lib.filterAttrs (n: _: n != "projectFileName") args';
736734 dir = __readDir (src.origSrcSubDir or src);
737735 exists = fileName: builtins.elem (dir.${fileName} or "") ["regular" "symlink"];
738736 stackYamlExists = exists "stack.yaml";