Merge branch 'master' of github.com:input-output-hk/haskell.nix into circuithub

Author: ocharles

.github/workflows/lints.yml

@@ -25,7 +25,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - run: |
-          nix run github:astro/deadnix -- --edit --no-lambda-pattern-names
+          nix run github:astro/deadnix -- --edit --no-lambda-pattern-names --exclude materialized
           TMPFILE=$(mktemp)
           git diff >"${TMPFILE}"
           git stash -u && git stash drop

build.nix

@@ -26,7 +26,7 @@ in rec {
   tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (
     pkgs.recurseIntoAttrs ({
       cabal-latest = tool compiler-nix-name "cabal" { inherit evalPackages; cabalProjectLocal = builtins.readFile ./test/cabal.project.local; };
-    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.6" < 0) {
+    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.8" < 0) {
       hlint-latest = tool compiler-nix-name "hlint" {
         inherit evalPackages;
         version = {
@@ -51,20 +51,45 @@ in rec {
           version = "2.11.1";
           inherit evalPackages;
         };
-    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.6" < 0) {
-      "hls-110" = tool compiler-nix-name "haskell-language-server" {
+    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.0" < 0) {
+      # This version will build for ghc < 9.8, but we are only going to test it for
+      # ghc < 9.0 (since newer versions do not work with ghc 8.10.7).
+      "hls-22" = tool compiler-nix-name "haskell-language-server" {
         inherit evalPackages;
-        src = pkgs.haskell-nix.sources."hls-1.10";
+        src = pkgs.haskell-nix.sources."hls-2.2";
       };
-    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.8" < 0) {
-      "hls-20" = tool compiler-nix-name "haskell-language-server" {
+    } // pkgs.lib.optionalAttrs (
+      __compareVersions haskell.compiler.${compiler-nix-name}.version "9.0" >= 0 &&
+      __compareVersions haskell.compiler.${compiler-nix-name}.version "9.8" < 0
+    ) {
+      "hls-23" = tool compiler-nix-name "haskell-language-server" {
         inherit evalPackages;
-        src = pkgs.haskell-nix.sources."hls-2.0";
+        src = pkgs.haskell-nix.sources."hls-2.3";
       };
-    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.8" < 0) {
-      "hls-22" = tool compiler-nix-name "haskell-language-server" {
+    } // pkgs.lib.optionalAttrs (
+      __compareVersions haskell.compiler.${compiler-nix-name}.version "9.0" >= 0 &&
+      __compareVersions haskell.compiler.${compiler-nix-name}.version "9.9" < 0
+    ) {
+      "hls-24" = tool compiler-nix-name "haskell-language-server" {
         inherit evalPackages;
-        src = pkgs.haskell-nix.sources."hls-2.2";
+        src = pkgs.haskell-nix.sources."hls-2.4";
+        # Even though this is in the cabal.project it is inside a condional
+        # and so haskell.nix cannot parse it properly.  Luckily adding it
+        # again seems to work fine.
+        cabalProjectLocal = ''
+          repository head.hackage.ghc.haskell.org
+            url: https://ghc.gitlab.haskell.org/head.hackage/
+            secure: True
+            key-threshold: 3
+            root-keys:
+               f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89
+               26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329
+               7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d
+            --sha256: sha256-aVI93DtHziicNn2mGli0YE+bC5BeT7mOQQETp2Thi68=
+
+          if impl(ghc < 9.7)
+            active-repositories: hackage.haskell.org
+        '';
       };
     })
   );

builder/comp-builder.nix

@@ -45,6 +45,7 @@ let self =
 
 , enableStatic ? component.enableStatic
 , enableShared ? ghc.enableShared && component.enableShared && !haskellLib.isCrossHost
+, enableExecutableDynamic ? component.enableExecutableDynamic && !stdenv.hostPlatform.isMusl
 , enableDeadCodeElimination ? component.enableDeadCodeElimination
 , writeHieFiles ? component.writeHieFiles
 
@@ -80,7 +81,7 @@ let self =
 , enableSeparateDataOutput ? component.enableSeparateDataOutput
 
 # Prelinked ghci libraries; will make iserv faster; especially for static builds.
-, enableLibraryForGhci ? true
+, enableLibraryForGhci ? component.enableLibraryForGhci
 
 # Debug
 , enableDebugRTS ? false
@@ -204,14 +205,14 @@ let
       (enableFeature enableProfiling "profiling")
       (enableFeature enableStatic "static")
       (enableFeature enableShared "shared")
+      (enableFeature enableExecutableDynamic "executable-dynamic")
       (enableFeature doCoverage "coverage")
       (enableFeature (enableLibraryForGhci && !stdenv.hostPlatform.isGhcjs) "library-for-ghci")
     ] ++ lib.optionals (stdenv.hostPlatform.isMusl && (haskellLib.isExecutableType componentId)) [
       # These flags will make sure the resulting executable is statically linked.
       # If it uses other libraries it may be necessary for to add more
       # `--ghc-option=-optl=-L` options to the `configureFlags` of the
       # component.
-      "--disable-executable-dynamic"
       "--ghc-option=-optl=-pthread"
       "--ghc-option=-optl=-static"
     ] ++ lib.optional enableSeparateDataOutput "--datadir=$data/share/${ghc.name}"

builder/make-config-files.nix

@@ -62,15 +62,27 @@ let
     ${target-pkg} init $configFiles/${packageCfgDir}
 
     ${lib.concatStringsSep "\n" (lib.mapAttrsToList flagsAndConfig {
-      "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") (lib.flatten component.libs)
-        # On windows also include `bin` directories that may contain DLLs
-        ++ lib.optionals (stdenv.hostPlatform.isWindows)
-          (map (p: "${lib.getBin p}/bin")
-               (lib.flatten component.libs ++ lib.concatLists component.pkgconfig));
+      "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") (lib.flatten component.libs);
       "extra-include-dirs" = map (p: "${lib.getDev p}/include") (lib.flatten component.libs);
       "extra-framework-dirs" = lib.optionals (stdenv.hostPlatform.isDarwin)
         (map (p: "${p}/Library/Frameworks") component.frameworks);
     })}
+    ${
+      # On windows also include `bin` directories that may contain DLLs
+      # It might be tempting to use `builtins.pathExists` here instead of `if [ -d ]`,
+      # however that would cause this detivation to depend on the output of the
+      # library derivation.
+      lib.concatStringsSep "\n" (map (p:
+        let binDir = "${lib.getBin p}/bin";
+        in ''
+          if [ -d ${binDir} ]; then
+            ${lib.concatStringsSep "\n" (lib.mapAttrsToList flagsAndConfig {
+              "extra-lib-dirs" = [binDir];
+            })}
+          fi
+      '') (lib.optionals (stdenv.hostPlatform.isWindows)
+          (lib.flatten component.libs ++ lib.concatLists component.pkgconfig))
+    )}
 
     unwrappedGhc=${ghc}
     ghcDeps=${ghc.cachedDeps
@@ -234,4 +246,4 @@ in {
     sed -i 's|/nix/store/|''${pkgroot}/../../../|' $configFiles/${packageCfgDir}/*.conf
     ${target-pkg} -v0 --package-db $configFiles/${packageCfgDir} recache
   '';
-}
+}

ci.nix

@@ -24,9 +24,6 @@
     "unstable" = inputs.nixpkgs-unstable;
   };
 
-  ghc980X = pkgs: "ghc980${__substring 0 8 pkgs.haskell-nix.sources.ghc980.lastModifiedDate}";
-  ghc99X = pkgs: "ghc99${__substring 0 8 pkgs.haskell-nix.sources.ghc99.lastModifiedDate}";
-
   nixpkgsArgs = {
     # set checkMaterialization as per top-level argument
     overlays = [
@@ -47,75 +44,61 @@
     };
   };
 
-  compilerNixNames = nixpkgsName: nixpkgs:
-    # Include only the GHC versions that are supported by haskell.nix
-    nixpkgs.lib.filterAttrs (compiler-nix-name: _:
-        # We have less x86_64-darwin build capacity so build fewer GhC versions
-        (system != "x86_64-darwin" || (
-           !builtins.elem compiler-nix-name ["ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))
-      &&
-        # aarch64-darwin requires ghc 8.10.7
-        (system != "aarch64-darwin" || (
-           !builtins.elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))
-      &&
-        # aarch64-linux requires ghc 8.8.4
-        (system != "aarch64-linux" || (
-           !builtins.elem compiler-nix-name ["ghc865" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]
-        )))
-    (builtins.mapAttrs (_compiler-nix-name: runTests: {
-      inherit runTests;
+  compilerNixNames = nixpkgsName: nixpkgs: builtins.listToAttrs (
+    (lib.mapAttrsToList (compiler-nix-name: runTests: {
+      name = nixpkgs.haskell-nix.resolve-compiler-name compiler-nix-name;
+      value = { inherit runTests; };
     }) (
       # GHC version to cache and whether to run the tests against them.
       # This list of GHC versions should include everything for which we
       # have a ./materialized/ghcXXX directory containing the materialized
       # cabal-install and nix-tools plans.  When removing a ghc version
       # from here (so that is no longer cached) also remove ./materialized/ghcXXX.
       # Update supported-ghc-versions.md to reflect any changes made here.
-      nixpkgs.lib.optionalAttrs (nixpkgsName == "R2211") {
-        ghc8107 = false;
-        ghc902 = false;
-        ghc928 = false;
-        ghc947 = false;
-      } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2305") {
-        ghc8107 = false;
-        ghc902 = false;
-        ghc928 = false;
-        ghc947 = false;
-        ghc962 = false;
+      nixpkgs.lib.optionalAttrs (nixpkgsName == "R2305") {
+        ghc810 = false;
+        ghc90 = false;
+        ghc92 = false;
+        ghc94 = false;
+        ghc96 = false;
+        ghc98 = false;
       } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {
-        ghc884 = false;
-        ghc8107 = true;
-        ghc902 = false;
-        ghc928 = true;
-        ghc947 = true;
-        ghc962 = true;
-        ghc9820230704 = true;
-        ${ghc980X nixpkgs} = true;
-        ${ghc99X nixpkgs} = true;
-      }));
+        ghc810 = true;
+        ghc90 = false;
+        ghc92 = true;
+        ghc94 = true;
+        ghc96 = true;
+        ghc98 = true;
+        ghc98X = true;
+        ghc99 = true;
+      })));
   crossSystems = nixpkgsName: nixpkgs: compiler-nix-name:
     # 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 (nixpkgsName == "unstable"
-      && ((system == "x86_64-linux"  && builtins.elem compiler-nix-name ["ghc8107" "ghc962" (ghc980X nixpkgs) (ghc99X nixpkgs)])
-       || (system == "aarch64-linux" && builtins.elem compiler-nix-name ["ghc8107" "ghc962" (ghc980X nixpkgs) (ghc99X nixpkgs)])
-       || (system == "x86_64-darwin" && builtins.elem compiler-nix-name ["ghc8107" "ghc962" (ghc980X nixpkgs) (ghc99X nixpkgs)])
-       || (system == "aarch64-darwin" && builtins.elem compiler-nix-name ["ghc8107" "ghc962" (ghc980X nixpkgs) (ghc99X nixpkgs)])
+      && ((system == "x86_64-linux"  && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc947"])
+       || (system == "aarch64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc947"])
+       || (system == "x86_64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc947"])
+       || (system == "aarch64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc947"])
        )) {
     inherit (lib.systems.examples) ghcjs;
   } // lib.optionalAttrs (nixpkgsName == "unstable"
-      && ((system == "x86_64-linux"  && builtins.elem compiler-nix-name ["ghc8107" "ghc902" "ghc926" "ghc927" "ghc928" "ghc947" "ghc962" (ghc980X nixpkgs) (ghc99X nixpkgs)])
+      && ((system == "x86_64-linux"  && !builtins.elem compiler-nix-name ["ghc884"])
        || (system == "x86_64-darwin" && builtins.elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity
     inherit (lib.systems.examples) mingwW64;
-  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && builtins.elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923" "ghc924" "ghc926" "ghc927" "ghc928" "ghc947" "ghc962" (ghc980X nixpkgs) (ghc99X nixpkgs)]) {
+  } // lib.optionalAttrs (nixpkgsName == "unstable"
+      && ((system == "x86_64-linux"  && !builtins.elem compiler-nix-name ["ghc884" "ghc8107" "ghc902" "ghc928"])
+       || (system == "x86_64-darwin" && builtins.elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity
+    inherit (lib.systems.examples) ucrt64;
+  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc884"]) {
     # Musl cross only works on linux
     # aarch64 cross only works on linux
     inherit (lib.systems.examples) musl64 aarch64-multiplatform;
   } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && builtins.elem compiler-nix-name ["ghc927" "ghc928"]) {
     # TODO fix this for the compilers we build with hadrian (ghc >=9.4)
     inherit (lib.systems.examples) aarch64-multiplatform-musl;
-  } // lib.optionalAttrs (system == "aarch64-linux" && nixpkgsName == "unstable" && builtins.elem compiler-nix-name ["ghc927" "ghc928" "ghc947" "ghc962" (ghc980X nixpkgs) (ghc99X nixpkgs)]) {
+  } // lib.optionalAttrs (system == "aarch64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc884" "ghc8107" "ghc902"]) {
     inherit (lib.systems.examples) aarch64-multiplatform-musl;
   };
   isDisabled = d: d.meta.disabled or false;
@@ -134,7 +117,7 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: pinnedNixpkgsSrc:
           ghc = pkgs.buildPackages.haskell-nix.compiler.${compiler-nix-name};
         } // pkgs.lib.optionalAttrs runTests {
           inherit (build) tests tools maintainer-scripts maintainer-script-cache;
-        } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {
+        } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
           inherit (pkgs.haskell-nix.iserv-proxy-exes.${compiler-nix-name}) iserv-proxy;
         } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
           hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit evalPackages compiler-nix-name; }).getComponent "exe:hello";
@@ -152,8 +135,7 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: pinnedNixpkgsSrc:
             # ghc = pkgs.haskell-nix.compiler.${compiler-nix-name};
             # TODO: look into making tools work when cross compiling
             # inherit (build) tools;
-          } // pkgs.lib.optionalAttrs (runTests && crossSystemName != "aarch64-multiplatform") {
-            # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513
+          } // pkgs.lib.optionalAttrs runTests {
             inherit (build) tests;
         })
         # GHCJS builds its own template haskell runner.

compiler/ghc/default.nix

@@ -242,10 +242,14 @@ let
 
   hadrian =
     let
-      compiler-nix-name = if buildPackages.haskell.compiler ? "ghc928"
-        then "ghc928"
-        else "ghc8107";
-    in buildPackages.pinned-haskell-nix.tool compiler-nix-name "hadrian" {
+      compiler-nix-name =
+        if builtins.compareVersions ghc-version "9.4.7" < 0
+          then "ghc928"
+          else "ghc962";
+    in
+      assert (buildPackages.haskell.compiler ? ${compiler-nix-name}
+        || throw "Expected pkgs.haskell.compiler.${compiler-nix-name} for building hadrian");
+    buildPackages.pinned-haskell-nix.tool compiler-nix-name "hadrian" {
       compilerSelection = p: p.haskell.compiler;
       index-state = buildPackages.haskell-nix.internalHackageIndexState;
       # Verions of hadrian that comes with 9.6 depends on `time`
@@ -436,9 +440,11 @@ stdenv.mkDerivation (rec {
         done
     '' + lib.optionalString (src-spec.version != ghc-version) ''
         substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'
+        substituteInPlace configure.ac --replace 'RELEASE=YES' 'RELEASE=NO'
         echo '${ghc-version}' > VERSION
     '' + lib.optionalString (ghc-version-date != null) ''
         substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'
+        substituteInPlace configure.ac --replace 'RELEASE=YES' 'RELEASE=NO'
         echo '${ghc-version-date}' > VERSION_DATE
     '' + lib.optionalString (ghc-commit-id != null) ''
         echo '${ghc-commit-id}' > GIT_COMMIT_ID
@@ -486,7 +492,8 @@ stdenv.mkDerivation (rec {
 
   hardeningDisable = [ "format" ]
                    ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"
-                   ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+                   ++ lib.optional stdenv.targetPlatform.isMusl "pie"
+                   ++ lib.optional enableDWARF "fortify";
 
   postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''
     # Patch rts.conf to ensure libnuma can be found