Use mkAliasDefinitions to copy package overrides

Author: hamishmack

lib/default.nix

@@ -614,4 +614,6 @@ in {
       }";
 
   types = import ./types.nix { inherit lib; };
+
+  addPackageKeys = x: x // { package-keys = builtins.attrNames x.packages; };
 }

modules/component-driver.nix

@@ -1,4 +1,4 @@
-{ config, pkgs, lib, haskellLib, buildModules, ... }:
+{ config, options, pkgs, lib, haskellLib, buildModules, ... }:
 let
   builder = haskellLib.weakCallPackage pkgs ../builder {
     inherit haskellLib;
@@ -120,6 +120,6 @@ in
       pkgsBuildBuild = buildModules.config.hsPkgs;
     } //
     lib.mapAttrs
-      (_name: pkg: if pkg == null then null else builder.build-package config pkg)
+      (name: pkg: if !(options.packages.${name}.isDefined or true) || pkg == null then null else builder.build-package config pkg)
       (config.packages // lib.genAttrs (config.nonReinstallablePkgs ++ config.bootPkgs) (_: null));
 }

modules/configuration-nix.nix

@@ -14,7 +14,8 @@ let
     if builtins.compareVersions version v >= 0
       then patch
       else null;
-in {
+  addPackageKeys = x: x // { package-keys = builtins.attrNames x.packages; };
+in addPackageKeys {
   # terminfo doesn't list libtinfo in its cabal file. We could ignore
   # this if we used the terminfo shipped with GHC, but this package is
   # reinstallable so we'd rather have it defined in the plan.

modules/plan.nix

@@ -29,10 +29,22 @@ in
   # combined or replaced. We seed the package Options with an empty set forcing the
   # default values.
   options = {
-    packages = mkOption {
-      type = attrsOf package;
+    use-package-keys = mkOption {
+      type = bool;
+      default = false;
     };
-
+    package-keys = mkOption {
+      type = listOf str;
+      default = [];
+    };
+    packages = if !config.use-package-keys
+      then mkOption {
+        type = attrsOf package;
+      }
+      else genAttrs config.package-keys (n:
+          mkOption {
+            type = package;
+          });
     compiler = {
       version = mkOption {
         type = str;
@@ -61,7 +73,11 @@ in
     };
   };
 
-  config = let module = config.plan.pkg-def config.hackage.configs; in {
+  config =
+  let
+    module = config.plan.pkg-def config.hackage.configs;
+    addPackageKeys = x: x // { package-keys = builtins.attrNames x.packages; };
+  in addPackageKeys {
     inherit (module) compiler;
     packages = lib.mapAttrs (name: { revision, ... }@revArgs: { system, compiler, flags, pkgs, hsPkgs, errorHandler, pkgconfPkgs, ... }@modArgs:
 

overlays/haskell.nix

@@ -788,28 +788,12 @@ final: prev: {
                       ] ++ final.lib.optionals (builtins.compareVersions config.compiler.version "8.11" < 0) [
                         "ghcjs-prim" "ghcjs-th"]);
                     })
-                    ({config, ...}: {
+                    ({config, options, ...}: {
+                      use-package-keys = true;
+                      package-keys = map (p: p.pkg-name) plan-json.install-plan ++ map (p: to-key p) plan-json.install-plan;
                       packages = final.lib.listToAttrs (map (p: {
                         name = to-key p;
-                        value = {
-                            components = final.lib.optionalAttrs (config.packages ? ${p.pkg-name}) (
-                              let
-                                inherit (config.packages.${p.pkg-name}) components;
-                                mapOptions = c:
-                                  builtins.mapAttrs (_: x: final.lib.mkOverride 990 x)
-                                    (builtins.removeAttrs c ["buildable" "planned" "depends" "build-tools" "libs"]) //
-                                  builtins.mapAttrs (_n: x: final.lib.mkOverride 90 x) (
-                                    final.lib.filterAttrs (n: x: builtins.elem n ["depends" "build-tools" "libs"] && builtins.length x != 0) c);
-                              in
-                                final.lib.optionalAttrs (components.library or null != null) {
-                                  library = mapOptions components.library;
-                                } // final.lib.optionalAttrs (components.setup or null != null) {
-                                  setup = mapOptions components.setup;
-                                } // builtins.mapAttrs (_ctype: cs: builtins.mapAttrs (_cname: c: mapOptions c) cs) (builtins.removeAttrs components ["library" "setup"]));
-                          } // builtins.mapAttrs (n: _:
-                            final.lib.mkIf (config.packages ? ${p.pkg-name}) (final.lib.mkOverride (if n == "src" then (if config.packages.${p.pkg-name}.src != null then 90 else 10000) else 995) config.packages.${p.pkg-name}.${n}))
-                            ((import ../modules/package-options.nix   { inherit haskellLib; inherit (final) lib; }).options //
-                             (import ../modules/component-options.nix { inherit haskellLib; inherit (final) lib; }).options // { src = {}; });
+                        value = final.lib.modules.mkAliasDefinitions (options.packages.${p.pkg-name});
                       }) (final.lib.filter (p: to-key p != p.pkg-name) plan-json.install-plan));
                     })
                     ({lib, ...}: {

overlays/windows.nix

@@ -56,7 +56,7 @@ final: prev:
           # Therefore let's enable doCrossCheck here!
           doCrossCheck = pkgs.stdenv.hostPlatform.isWindows;
         };
-      in {
+      in prev.haskell-nix.haskellLib.addPackageKeys {
         packages = {
 
           # Apply https://github.com/haskell/cabal/pull/6055

test/coverage-no-libs/default.nix

@@ -6,11 +6,6 @@ let
   projectArgs = {
     inherit evalPackages;
     src = testSrc "coverage-no-libs";
-    modules = [{
-      # Package has no exposed modules which causes
-      #   haddock: No input file(s)
-      packages.bytestring-builder.doHaddock = false;
-    }];
   };
 
   # We can easily select a different compiler when using cabal,

test/coverage/default.nix

@@ -8,10 +8,6 @@ let
     src = testSrc "coverage";
     cabalProjectLocal = builtins.readFile ../cabal.project.local;
     modules = [{
-      # Package has no exposed modules which causes
-      #   haddock: No input file(s)
-      packages.bytestring-builder.doHaddock = false;
-
       # Coverage
       packages.pkga.components.library.doCoverage = true;
       packages.pkgb.components.library.doCoverage = true;

test/setup-deps/default.nix

@@ -8,11 +8,6 @@ let
     inherit compiler-nix-name evalPackages;
     src = evalPackages.haskell-nix.haskellLib.cleanGit { src = ../..; name = "setup-deps"; subDir = "test/setup-deps"; };
     cabalProjectLocal = builtins.readFile ../cabal.project.local;
-    modules = [{
-      # Package has no exposed modules which causes
-      #   haddock: No input file(s)
-      packages.bytestring-builder.doHaddock = false;
-    }];
   };
 
   meta = {

test/shell-for-setup-deps/default.nix

@@ -7,11 +7,6 @@ let
     inherit compiler-nix-name evalPackages;
     src = testSrc "shell-for-setup-deps";
     cabalProjectLocal = builtins.readFile ../cabal.project.local;
-    modules = [{
-      # Package has no exposed modules which causes
-      #   haddock: No input file(s)
-      packages.bytestring-builder.doHaddock = false;
-    }];
   };
 
   env = project.shellFor {