Merge branch 'master' into support-cabal-doctest

Author: angerman

build.nix

@@ -16,6 +16,18 @@ let
 in rec {
   tests = import ./test/default.nix { inherit pkgs ifdLevel; };
 
+  tools = pkgs.lib.optionalAttrs (ifdLevel >= 3)
+    (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
@@ -25,12 +37,7 @@ in rec {
     update-stackage = haskell.callPackage ./scripts/update-stackage.nix {};
     update-pins = haskell.callPackage ./scripts/update-pins.nix {};
     update-docs = pkgs.buildPackages.callPackage ./scripts/update-docs.nix {
-      generatedOptions = import ./scripts/options-doc.nix {
-        # nixpkgs 19.09 changes "Option has no description" from an
-        # error into a warning. That is quite helpful when hardly any
-        # of our options are documented, thanks @oxij.
-        pkgs = import (import ./nixpkgs/default.nix).nixpkgs-1909 {};
-      };
+      generatedOptions = pkgs.callPackage ./scripts/options-doc.nix { };
     };
     # Because this is going to be used to test caching on hydra, it must not
     # use the darcs package from the haskell.nix we are testing.  For that reason

builder/default.nix

@@ -39,10 +39,9 @@ let
 
 
   hoogleLocal = let
-    # Use the latest default nixpkgs hoogle.nix, as the 19.03 one does not work with cross compilers
-    nixpkgsHoogleLocal = import ((import (import ../nixpkgs).nixpkgs-default {}).path + /pkgs/development/haskell-modules/hoogle.nix);
+    nixpkgsHoogle = import (pkgs.path + /pkgs/development/haskell-modules/hoogle.nix);
   in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.haskellPackages.hoogle.components.exes.hoogle }:
-    haskellLib.weakCallPackage pkgs nixpkgsHoogleLocal {
+    haskellLib.weakCallPackage pkgs nixpkgsHoogle { 
       # For musl we can use haddock from the buildGHC
       ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl
         then ghc.buildGHC
@@ -52,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/make-config-files.nix

@@ -179,9 +179,5 @@ in { identifier, component, fullName, flags ? {} }:
       sed -i -E "/^ ./{H;$!d} ; x ; s,^dynamic-library-dirs:.*,dynamic-library-dirs: $dynamicLinksDir," $f
     done
   '' + ''
-    # Use ''${pkgroot} relative paths so that we can relocate the package database
-    # along with referenced packages and still have it work on systems with
-    # or without nix installed.
-    sed -i 's|/nix/store/|''${pkgroot}/../../../|' $out/${packageCfgDir}/*.conf
     ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache
   '')

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,12 +85,17 @@ 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";
     LOCALE_ARCHIVE = lib.optionalString (stdenv.hostPlatform.libc == "glibc") "${glibcLocales}/lib/locale/locale-archive";
 
+    # This helps tools like `ghcide` (that use the ghc api) to find
+    # the correct global package DB.
+    NIX_GHC_LIBDIR = ghcEnv + "/" + configFiles.libDir;
+
     passthru = (mkDrvArgs.passthru or {}) // {
       ghc = ghcEnv;
       inherit configFiles;

ci-lib.nix

@@ -30,16 +30,16 @@ in rec {
   # TODO: Surely this shouldn't be necessary. I think normal 'filterAttrsRecursive' will effectively cause infinite loops
   # if you keep derivations and your predicate forces the value of the attribute, as this then triggers a loop on the
   # 'out' attribute. Weird.
+  # To make this function faster, unwanted attributes are mapped to {} instead of being
+  # removed. This keeps the function lazy and avoids unwanted evaluation of sibling
+  # derivations.
   filterAttrsOnlyRecursive = pred: set:
-    lib.listToAttrs (
-      lib.concatMap (name:
-        let v = set.${name}; in
-        if pred name v then [
-          (lib.nameValuePair name (
-            if builtins.isAttrs v && !lib.isDerivation v then filterAttrsOnlyRecursive pred v
+    lib.mapAttrs (name: v:
+      if pred name v
+        then
+          if builtins.isAttrs v
+              && !lib.isDerivation v
+            then filterAttrsOnlyRecursive pred v
             else v
-          ))
-        ] else []
-      ) (builtins.attrNames set)
-    );
+        else {}) set;
 }

ci.nix

@@ -8,8 +8,8 @@ let
   inherit (import ./ci-lib.nix) dimension platformFilterGeneric filterAttrsOnlyRecursive;
   inherit (import ./default.nix {}) sources nixpkgsArgs;
   nixpkgsVersions = {
-    "R1903" = "nixpkgs-1903";
     "R1909" = "nixpkgs-1909";
+    "R2003" = "nixpkgs-2003";
   };
   systems = nixpkgs: nixpkgs.lib.filterAttrs (_: v: builtins.elem v supportedSystems) {
     # I wanted to take these from 'lib.systems.examples', but apparently there isn't one for linux!
@@ -20,8 +20,8 @@ let
     # We need to use the actual nixpkgs version we're working with here, since the values
     # of 'lib.systems.examples' are not understood between all versions
     let lib = nixpkgs.lib;
-    in lib.optionalAttrs (system == "x86_64-linux" || nixpkgsName == "R1903") {
-    # Windows cross compilation is currently broken on macOS for nixpkgs 19.09 (works on 19.03)
+    in lib.optionalAttrs (system == "x86_64-linux") {
+    # Windows cross compilation is currently broken on macOS
     inherit (lib.systems.examples) mingwW64;
   } // lib.optionalAttrs (system == "x86_64-linux") {
     # Musl cross only works on linux
@@ -37,29 +37,50 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
     let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });
         build = import ./build.nix { inherit pkgs ifdLevel; };
         platformFilter = platformFilterGeneric pkgs system;
+        compilers = {
+          inherit (pkgs.haskell-nix.compiler) ghc865 ghc883;
+        };
     in filterAttrsOnlyRecursive (_: v: platformFilter v) {
       # 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;
+      native = pkgs.recurseIntoAttrs ({
+        inherit (build) tests tools maintainer-scripts maintainer-script-cache;
+        ghc = pkgs.recurseIntoAttrs compilers;
+      } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {
+        iserv-proxy = pkgs.recurseIntoAttrs (
+          pkgs.lib.mapAttrs (ghcName: _:
+            pkgs.ghc-extra-packages."${ghcName}".iserv-proxy.components.exes.iserv-proxy
+          ) compilers);
+      } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
         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;
-      };
+      });
     }
     //
     dimension "Cross system" (crossSystems nixpkgsName genericPkgs system) (crossSystemName: crossSystem:
       # Cross builds
       let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });
           build = import ./build.nix { inherit pkgs ifdLevel; };
-      in pkgs.recurseIntoAttrs {
+      in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) {
+        ghc = pkgs.recurseIntoAttrs compilers;
+        # TODO: look into making tools work when cross compiling
+        # inherit (build) tools;
+      } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
+        remote-iserv = pkgs.recurseIntoAttrs (
+          pkgs.lib.mapAttrs (ghcName: _:
+            pkgs.ghc-extra-packages."${ghcName}".remote-iserv.components.exes.remote-iserv
+          ) compilers);
+        iserv-proxy = pkgs.recurseIntoAttrs (
+          pkgs.lib.mapAttrs (ghcName: _:
+            pkgs.ghc-extra-packages."${ghcName}".iserv-proxy.components.exes.iserv-proxy
+          ) compilers);
+      } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
         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;
       }
       //
       # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513
-      pkgs.lib.optionalAttrs (crossSystemName != "aarch64-multiplatform") build.tests
+      pkgs.lib.optionalAttrs (crossSystemName != "aarch64-multiplatform") {
+        inherit (build) tests;
+      })
     )
   )
 )

compiler/ghc/default.nix

@@ -42,13 +42,7 @@
   # specific flavour and falls back to ghc default values.
   ghcFlavour ? stdenv.lib.optionalString haskell-nix.haskellLib.isCrossTarget (
     if useLLVM
-      then (
-        # TODO check if the issues with qemu and Aarch32 persist. See
-        # https://github.com/input-output-hk/haskell.nix/pull/411/commits/1986264683067198e7fdc1d665351622b664712e
-        if stdenv.targetPlatform.isAarch32
-          then "quick-cross"
-          else "perf-cross"
-      )
+      then "perf-cross"
       else "perf-cross-ncg"
     )
 
@@ -104,9 +98,6 @@ let
     GhcRtsHcOpts += -fPIC
   '' + stdenv.lib.optionalString targetPlatform.useAndroidPrebuilt ''
     EXTRA_CC_OPTS += -std=gnu99
-  '' + stdenv.lib.optionalString useLLVM ''
-    GhcStage2HcOpts += -fast-llvm
-    GhcLibHcOpts += -fast-llvm
   '' + stdenv.lib.optionalString (!enableTerminfo) ''
     WITH_TERMINFO=NO
   ''
@@ -218,13 +209,13 @@ in let configured-src = stdenv.mkDerivation (rec {
             "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"
         ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [
             "--enable-bootstrap-with-devel-snapshot"
+        ] ++ stdenv.lib.optionals (disableLargeAddressSpace) [
+            "--disable-large-address-space"
         ] ++ stdenv.lib.optionals (targetPlatform.isAarch32) [
             "CFLAGS=-fuse-ld=gold"
             "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
             "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-        ] ++ stdenv.lib.optionals (disableLargeAddressSpace) [
-            "--disable-large-address-space"
-        ];
+        ] ;
 
         outputs = [ "out" ];
         phases = [ "unpackPhase" "patchPhase" ]

config.nix

@@ -6,6 +6,9 @@
   wine.build = "wine64";
   wine.release = "stable";
 
+  # This is marked insecure on 20.03, but many packages still depend on it
+  permittedInsecurePackages = [ "openssl-1.0.2u" ];
+
   # sadly we need to patch GHC a bit.
   packageOverrides = ps: with ps; let
   in rec {

default.nix

@@ -1,6 +1,6 @@
 let haskellNix = rec {
     sources = {
-      inherit (import ./nixpkgs/default.nix) nixpkgs-1903 nixpkgs-1909 nixpkgs-default;
+      inherit (import ./nixpkgs/default.nix) nixpkgs-1909 nixpkgs-2003 nixpkgs-default;
     };
 
     config   = import ./config.nix;

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