Make it easier to access executable components (#565)

This overlay helps accessing common executable components.
Typically we want to make these available in a nix-shell
created with shellFor.  In most cases the package name
will be the same as the executable, but we have a
`toolPackageName` mapping to help when it is not.

```
# To get a single tool:
haskell-nix.tool "cabal" "3.2.0.0"

# This does the same thing as:
(haskell-nix.hackage-package {
  name = "cabal-install"
  version = "3.2.0.0"
}).components.exes.cabal

# To get an attr set containing multiple tools:
haskell-nix.tools { cabal = "3.2.0.0"; hlint = "2.2.11"; }

# To add tools to a shell:
shellFor { tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; }; }
```

When used in shellFor the tools will be compiled with the same version
of ghc used in the shell (the build ghc in the case of cross
compilation).

Instead of a version string we can use an attr set containing
arguments that will be passed to `cabalProject`.

For instance to specify the ghc used to compile. Use:

```
haskell-nix.tool "cabal" {
  version = "3.2.0.0";
  ghc = haskell-nix.compiler.ghc883;
}
```

Author: hamishmack

build.nix

@@ -16,6 +16,17 @@ let
 in rec {
   tests = import ./test/default.nix { inherit pkgs ifdLevel; };
 
+  tools = pkgs.recurseIntoAttrs
+    (pkgs.lib.mapAttrs (_: ghc:
+      let
+        tool = name: version: pkgs.buildPackages.haskell-nix.tool name { inherit version ghc; };
+      in pkgs.recurseIntoAttrs {
+          cabal-32 = tool "cabal" "3.2.0.0";
+          ghcide   = tool "ghcide" "object-code";
+        } // pkgs.lib.optionalAttrs (ghc.version == "8.6.5") {
+          cabal-30 = tool "cabal" "3.0.0.0";
+        }) { inherit (pkgs.buildPackages.haskell-nix.compiler) ghc865 ghc883; });
+
   # Scripts for keeping Hackage and Stackage up to date, and CI tasks.
   # The dontRecurseIntoAttrs prevents these from building on hydra
   # as not all of them can work in restricted eval mode (as they

builder/default.nix

@@ -51,8 +51,9 @@ let
 
   # Same as haskellPackages.shellFor in nixpkgs.
   shellFor = haskellLib.weakCallPackage pkgs ./shell-for.nix {
-    inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib;
+    inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages;
     inherit (buildPackages) glibcLocales;
+    buildGHC = ghc.passthru.buildGHC or ghc;
   };
 
   # Same as haskellPackages.ghcWithPackages and ghcWithHoogle in nixpkgs.

builder/shell-for.nix

@@ -1,4 +1,4 @@
-{ lib, stdenv, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib }:
+{ lib, stdenv, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, buildGHC }:
 
 { packages ? ps:
     let
@@ -9,6 +9,7 @@
 , additional ? _: []
 , withHoogle ? true
 , exactDeps ? false
+, tools ? {}
 , ... } @ args:
 
 let
@@ -74,7 +75,7 @@ let
     # inherit (hsPkgs) hoogle;
   };
 
-  mkDrvArgs = builtins.removeAttrs args ["packages" "additional" "withHoogle"];
+  mkDrvArgs = builtins.removeAttrs args ["packages" "additional" "withHoogle" "tools"];
 in
   stdenv.mkDerivation (mkDrvArgs // {
     name = mkDrvArgs.name or name;
@@ -84,7 +85,8 @@ in
       ++ lib.optional withHoogle' hoogleIndex;
     nativeBuildInputs = [ ghcEnv ]
       ++ nativeBuildInputs
-      ++ mkDrvArgs.nativeBuildInputs or [];
+      ++ mkDrvArgs.nativeBuildInputs or []
+      ++ lib.attrValues (buildPackages.haskell-nix.toolsForGhc buildGHC tools);
     phases = ["installPhase"];
     installPhase = "echo $nativeBuildInputs $buildInputs > $out";
     LANG = "en_US.UTF-8";

ci.nix

@@ -41,7 +41,7 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
       # Native builds
       # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?
       native = pkgs.recurseIntoAttrs {
-        inherit (build) tests maintainer-scripts maintainer-script-cache;
+        inherit (build) tests tools maintainer-scripts maintainer-script-cache;
         hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
         iserv-proxy = pkgs.ghc-extra-packages.ghc865.iserv-proxy.components.exes.iserv-proxy;
         ghc = pkgs.recurseIntoAttrs pkgs.haskell-nix.compiler;
@@ -53,6 +53,8 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
       let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });
           build = import ./build.nix { inherit pkgs ifdLevel; };
       in pkgs.recurseIntoAttrs {
+        # TODO: look into making tools work when cross compiling
+        # inherit (build) tools;
         hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
         iserv-proxy = pkgs.ghc-extra-packages.ghc865.iserv-proxy.components.exes.iserv-proxy;
         remote-iserv = pkgs.ghc-extra-packages.ghc865.remote-iserv.components.exes.remote-iserv;

docs/reference/library.md

@@ -366,9 +366,11 @@ shellFor =
 | Argument       | Type | Description         |
 |----------------|------|---------------------|
 | `packages`     | Function | Package selection function. It takes a list of [Haskell packages](#haskell-package) and returns a subset of these packages. |
-| `withHoogle` | Boolean | Whether to build a Hoogle documentation index and provide the `hoogle` command. |
-| `exactDeps` | Boolean | Prevents the Cabal solver from choosing any package dependency other than what are in the package set. |
-| `{ ... }` | Attrset | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |
+| `additional`   | Function | Similar to `packages`, but the selected packages are built and included in `ghc-pkg list` (not just their dependencies). |
+| `withHoogle`   | Boolean  | Whether to build a Hoogle documentation index and provide the `hoogle` command. |
+| `exactDeps`    | Boolean  | Prevents the Cabal solver from choosing any package dependency other than what are in the package set. |
+| `tools`        | Function | AttrSet of tools to make available e.g. `{ cabal = "3.2.0.0"; }` or `{ cabal = { version = "3.2.0.0"; }; }` |
+| `{ ... }`      | Attrset  | All the other arguments are passed to [`mkDerivation`](https://nixos.org/nixpkgs/manual/#sec-using-stdenv). |
 
 **Return value**: a derivation
 

docs/user-guide/development.md

@@ -66,8 +66,14 @@ in
     withHoogle = true;
 
     # You might want some extra tools in the shell (optional).
+
+    # Some common tools can be added with the `tools` argument
+    tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; };
+    # See overlays/tools.nix for more details
+
+    # Some you may need to get some other way.
     buildInputs = with pkgs.haskellPackages;
-      [ hlint stylish-haskell ghcid ];
+      [ ghcid ];
 
     # Prevents cabal from choosing alternate plans, so that
     # *all* dependencies are provided by Nix.

lib/default.nix

@@ -199,4 +199,12 @@ with haskellLib;
   # This is the same as isCrossHost but for use when building ghc itself
   isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform
     && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl);
+
+  # Takes a version number or attr set of arguments (for cabalProject)
+  # and conversios it to an attr set of argments.  This allows
+  # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }
+  versionOrArgsToArgs = versionOrArgs:
+    if lib.isAttrs versionOrArgs
+      then versionOrArgs
+      else { version = versionOrArgs; };
 }

overlays/default.nix

@@ -13,6 +13,7 @@
     (import ./windows.nix)
     (import ./armv6l-linux.nix)
     (import ./musl.nix)
+    (import ./tools.nix)
     # Restore nixpkgs haskell and haskellPackages
     (_: super: { inherit (super.haskell-nix-super) haskell haskellPackages; })
 ]

overlays/tools.nix

@@ -0,0 +1,102 @@
+# This overlay helps accessing common executable components.
+# Typically we want to make these available in a nix-shell
+# created with shellFor.  In most cases the package name
+# will be the same as the executable, but we have a
+# `toolPackageName` mapping to help when it is not.
+#
+# To get a single tool:
+#   haskell-nix.tool "cabal" "3.2.0.0"
+#
+# This does the same thing as:
+#   (haskell-nix.hackage-package {
+#     name = "cabal-install"
+#     version = "3.2.0.0"
+#   }).components.exes.cabal
+#
+# To get an attr set containing multiple tools:
+#   haskell-nix.tools { cabal = "3.2.0.0"; hlint = "2.2.11"; }
+#
+# To add tools to a shell:
+#   shellFor { tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; }; }
+#
+# When used in shellFor the tools will be compiled with the same version
+# of ghc used in the shell (the build ghc in the case of cross compilation).
+#
+# Instead of a version string we can use an attr set containing
+# arguments that will be passed to `cabalProject`.
+#
+# For instance to specify the ghc used to compile. Use:
+#   haskell-nix.tool "cabal" {
+#      version = "3.2.0.0";
+#      ghc = haskell-nix.compiler.ghc883;
+#   }
+#
+self: super:
+let
+  inherit (self) lib;
+
+in { haskell-nix = super.haskell-nix // {
+
+  # Some times the package name in hackage is not the same as tool name.
+  toolPackageName = {
+    cabal = "cabal-install";
+  };
+
+  hackage-tool = { name, ... }@args:
+    (self.haskell-nix.hackage-package
+      (args // { name = self.haskell-nix.toolPackageName."${name}" or name; }))
+        .components.exes."${name}";
+
+  tool = name: versionOrArgs:
+    let
+      args = self.haskell-nix.haskellLib.versionOrArgsToArgs versionOrArgs;
+    in
+      (if self.haskell-nix.custom-tools ? "${name}"
+          && self.haskell-nix.custom-tools."${name}" ? "${args.version}"
+        then self.haskell-nix.custom-tools."${name}"."${args.version}"
+        else self.haskell-nix.hackage-tool) (args // { inherit name; });
+
+  tools = lib.mapAttrs self.haskell-nix.tool;
+
+  # Like `tools` but allows default ghc to be specified
+  toolsForGhc = ghc: toolSet:
+    self.haskell-nix.tools (
+      lib.mapAttrs (name: versionOrArgs:
+        # Add default ghc if not specified in the args
+        { inherit ghc; }
+          // self.haskell-nix.haskellLib.versionOrArgsToArgs versionOrArgs
+      ) toolSet
+    );
+
+  # Tools not in hackage yet
+  custom-tools = {
+    ghcide.object-code = args:
+        (self.haskell-nix.cabalProject (args // {
+          name = "ghcide";
+          src = self.fetchFromGitHub {
+            owner = "mpickering";
+            repo = "ghcide";
+            rev = "706c59c97c25c66798815c1dc3ee6885a298918a";
+            sha256 = "0d158xifwvz0y69ah98ckxakzqpz229mq7rpf2bpbmwhnpw3jmm6";
+          };
+          modules = [({config, ...}: {
+            packages.ghcide.configureFlags = [ "--enable-executable-dynamic" ];
+            nonReinstallablePkgs = [ "Cabal" "array" "base" "binary" "bytestring" "containers" "deepseq"
+                                     "directory" "filepath" "ghc" "ghc-boot" "ghc-boot-th" "ghc-compact"
+                                     "ghc-heap" "ghc-prim" "ghci" "haskeline" "hpc" "integer-gmp"
+                                     "libiserv" "mtl" "parsec" "pretty" "process" "rts" "stm"
+                                     "template-haskell" "terminfo" "text" "time" "transformers" "unix"
+                                     "xhtml"
+                                   ];
+          })];
+          pkg-def-extras = [
+                 (hackage: {
+              packages = {
+                "alex" = (((hackage.alex)."3.2.5").revisions).default;
+                "happy" = (((hackage.happy)."1.19.12").revisions).default;
+              };
+            })
+          ];
+        })).ghcide.components.exes.ghcide;
+  };
+}; }