input-output-hk · hamishmack · Sep 12, 2023 · Aug 8, 2023 · Aug 9, 2023 · Aug 9, 2023
diff --git a/build.nix b/build.nix
@@ -43,13 +43,12 @@ in rec {
             "ghc8107" = "3.4.1";
           }.${compiler-nix-name} or "latest";
       };
-    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.6" < 0) {
+    } // pkgs.lib.optionalAttrs (
+             __compareVersions haskell.compiler.${compiler-nix-name}.version "9.2" >= 0
+          && __compareVersions haskell.compiler.${compiler-nix-name}.version "9.6" < 0) {
       stack =
         tool compiler-nix-name "stack" {
-          version =
-            if __compareVersions haskell.compiler.${compiler-nix-name}.version "9.2" < 0
-              then "2.9.3.1"
-              else "2.11.1";
+          version = "2.11.1";
           inherit evalPackages;
         };
     } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.6" < 0) {
@@ -78,17 +77,15 @@ in rec {
     update-hackage = import ./scripts/update-hackage.nix {
       inherit (pkgs) stdenv lib writeScript coreutils glibc git
         openssh nixFlakes gawk bash curl findutils;
-      # Update scripts use the internal nix-tools and cabal-install (compiled with a fixed GHC version)
+      # Update scripts use the internal nix-tools (compiled with a fixed GHC version)
       nix-tools = haskell.nix-tools-unchecked;
-      cabal-install = haskell.internal-cabal-install;
       inherit (haskell) update-index-state-hashes cabal-issue-8352-workaround;
     };
     update-stackage = haskell.callPackage ./scripts/update-stackage.nix {
       inherit (pkgs) stdenv lib writeScript coreutils glibc git
         openssh nixFlakes gawk bash curl findutils;
-      # Update scripts use the internal nix-tools and cabal-install (compiled with a fixed GHC version)
+      # Update scripts use the internal nix-tools (compiled with a fixed GHC version)
       nix-tools = haskell.nix-tools-unchecked;
-      cabal-install = haskell.internal-cabal-install;
       inherit (haskell) cabal-issue-8352-workaround;
     };
     update-pins = haskell.callPackage ./scripts/update-pins.nix {};

diff --git a/builder/comp-builder.nix b/builder/comp-builder.nix
@@ -39,6 +39,7 @@ let self =
 
 , dontPatchELF ? component.dontPatchELF
 , dontStrip ? component.dontStrip
+, dontUpdateAutotoolsGnuConfigScripts ? component.dontUpdateAutotoolsGnuConfigScripts
 , hardeningDisable ? component.hardeningDisable
 
 , enableStatic ? component.enableStatic
@@ -187,15 +188,23 @@ let
         "--with-ar=${stdenv.cc.bintools.targetPrefix}ar"
         "--with-strip=${stdenv.cc.bintools.targetPrefix}strip"
       ]
-    ) ++ [ # other flags
+    ) # Starting with ghc 9.10 the `ld command` will no longer be in the GHC `settings` file.
+      # We need to start passing it explicitly to setup like we do for `ar` and `strip`.
+      ++ lib.optional (!stdenv.hostPlatform.isGhcjs && builtins.compareVersions defaults.ghc.version "9.8" >= 0)
+        "--with-ld=${stdenv.cc.bintools.targetPrefix}ld"
+      ++ lib.optionals (stdenv.hostPlatform.isGhcjs) [
+        "--with-gcc=${buildPackages.emscripten}/bin/emcc"
+        "--with-ld=${buildPackages.emscripten}/bin/emcc"
+      ]
+      ++ [ # other flags
       (disableFeature dontStrip "executable-stripping")
       (disableFeature dontStrip "library-stripping")
       (enableFeature enableLibraryProfiling "library-profiling")
       (enableFeature enableProfiling "profiling")
       (enableFeature enableStatic "static")
       (enableFeature enableShared "shared")
       (enableFeature doCoverage "coverage")
-      (enableFeature enableLibraryForGhci "library-for-ghci")
+      (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
@@ -222,7 +231,7 @@ let
       ++ lib.optionals useLLVM [
         "--ghc-option=-fPIC" "--gcc-option=-fPIC"
         ]
-      ++ map (o: ''--ghc${lib.optionalString stdenv.hostPlatform.isGhcjs "js"}-options="${o}"'') ghcOptions
+      ++ map (o: ''--ghc${lib.optionalString (stdenv.hostPlatform.isGhcjs && builtins.compareVersions defaults.ghc.version "9" < 0) "js"}-options="${o}"'') ghcOptions
       ++ lib.optional (
         # GHC 9.2 cross compiler built with older versions of GHC seem to have problems
         # with unique conters.  Perhaps because the name changed for the counters.
@@ -260,8 +269,9 @@ let
                      if builtins.isFunction shellHook then shellHook { inherit package shellWrappers; }
                      else abort "shellHook should be a string or a function";
 
-  exeExt = if stdenv.hostPlatform.isGhcjs then ".jsexe/all.js" else
-    stdenv.hostPlatform.extensions.executable;
+  exeExt = if stdenv.hostPlatform.isGhcjs && builtins.compareVersions defaults.ghc.version "9.8" < 0
+    then ".jsexe/all.js"
+    else stdenv.hostPlatform.extensions.executable;
   exeName = componentId.cname + exeExt;
   testExecutable = "dist/build/${componentId.cname}/${exeName}";
 
@@ -317,6 +327,9 @@ let
     // lib.optionalAttrs stdenv.hostPlatform.isMusl {
       # This fixes musl compilation of TH code that depends on C++ (for instance TH code that uses the double-conversion package)
       LD_LIBRARY_PATH="${pkgs.buildPackages.gcc-unwrapped.lib}/x86_64-unknown-linux-musl/lib";
+    }
+    // lib.optionalAttrs dontUpdateAutotoolsGnuConfigScripts {
+      inherit dontUpdateAutotoolsGnuConfigScripts;
     };
 
   haddock = haddockBuilder {
@@ -531,7 +544,7 @@ let
               # we assume that if the SETUP_HS command fails and the following line was found in the error
               # log, that it was the only error. Hence if we do _not_ find the line, grep will fail and this derivation
               # will be marked as failure.
-              cat $SETUP_ERR | grep 'Error: Setup: No executables and no library found\. Nothing to do\.'
+              cat $SETUP_ERR | grep 'No executables and no library found\. Nothing to do\.'
             fi
             ''}
       ${lib.optionalString (haskellLib.isLibrary componentId) ''
@@ -583,13 +596,13 @@ let
               '')
         }
       ''}
-      ${(lib.optionalString (haskellLib.isTest componentId || haskellLib.isBenchmark componentId) ''
+      ${(lib.optionalString (haskellLib.isTest componentId || haskellLib.isBenchmark componentId || (haskellLib.isExe componentId && stdenv.hostPlatform.isGhcjs)) ''
         mkdir -p $out/bin
         if [ -f ${testExecutable} ]; then
           mkdir -p $(dirname $out/bin/${exeName})
           ${lib.optionalString stdenv.buildPlatform.isLinux "sync"}
-          ${if stdenv.hostPlatform.isGhcjs then ''
-            cat <(echo \#!${lib.getBin buildPackages.nodejs-18_x}/bin/node) ${testExecutable} >| $out/bin/${exeName}
+          ${if stdenv.hostPlatform.isGhcjs && builtins.compareVersions defaults.ghc.version "9.8" < 0 then ''
+            cat <(echo \#!/usr/bin/env node) ${testExecutable} >| $out/bin/${exeName}
             chmod +x $out/bin/${exeName}
           '' else ''
              cp -r ${testExecutable} $(dirname $out/bin/${exeName})

diff --git a/ci.nix b/ci.nix
@@ -24,6 +24,9 @@
     "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 = [
@@ -49,15 +52,15 @@
     nixpkgs.lib.filterAttrs (compiler-nix-name: _:
         # We have less x86_64-darwin build capacity so build fewer GhC versions
         (system != "x86_64-darwin" || (
-           !__elem compiler-nix-name ["ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))
+           !builtins.elem compiler-nix-name ["ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))
       &&
         # aarch64-darwin requires ghc 8.10.7
         (system != "aarch64-darwin" || (
-           !__elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))
+           !builtins.elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))
       &&
         # aarch64-linux requires ghc 8.8.4
         (system != "aarch64-linux" || (
-           !__elem compiler-nix-name ["ghc865" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]
+           !builtins.elem compiler-nix-name ["ghc865" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]
         )))
     (builtins.mapAttrs (compiler-nix-name: runTests: {
       inherit runTests;
@@ -87,30 +90,32 @@
         ghc947 = true;
         ghc962 = true;
         ghc9820230704 = true;
+        ${ghc980X nixpkgs} = true;
+        ${ghc99X nixpkgs} = 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" "ghc9820230704"])
-       || (system == "aarch64-linux" && builtins.elem compiler-nix-name ["ghc8107" "ghc962" "ghc9820230704"])
-       || (system == "x86_64-darwin" && builtins.elem compiler-nix-name ["ghc8107" "ghc962" "ghc9820230704"])
-       || (system == "aarch64-darwin" && builtins.elem compiler-nix-name ["ghc8107" "ghc962" "ghc9820230704"])
+      && ((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)])
        )) {
     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" "ghc9820230704"])
+      && ((system == "x86_64-linux"  && builtins.elem compiler-nix-name ["ghc8107" "ghc902" "ghc926" "ghc927" "ghc928" "ghc947" "ghc962" (ghc980X nixpkgs) (ghc980X nixpkgs)])
        || (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" "ghc9820230704"]) {
+  } // 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) (ghc980X nixpkgs)]) {
     # 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" "ghc9820230704"]) {
+  } // lib.optionalAttrs (system == "aarch64-linux" && nixpkgsName == "unstable" && builtins.elem compiler-nix-name ["ghc927" "ghc928" "ghc947" "ghc962" (ghc980X nixpkgs) (ghc980X nixpkgs)]) {
     inherit (lib.systems.examples) aarch64-multiplatform-musl;
   };
   isDisabled = d: d.meta.disabled or false;

diff --git a/compiler/ghc/default.nix b/compiler/ghc/default.nix
@@ -72,6 +72,7 @@ let self =
 
 , ghc-version ? src-spec.version
 , ghc-version-date ? null
+, ghc-commit-id ? null
 , src-spec
 , ghc-patches ? []
 
@@ -239,18 +240,25 @@ let
   # value for us.
   installStage1 = useHadrian && (haskell-nix.haskellLib.isCrossTarget || stdenv.targetPlatform.isMusl);
 
-  hadrian = buildPackages.pinned-haskell-nix.tool "ghc8107" "hadrian" {
+  hadrian =
+    let
+      compiler-nix-name = if buildPackages.haskell.compiler ? "ghc928"
+        then "ghc928"
+        else "ghc8107";
+    in 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`
       materialized =
         if builtins.compareVersions ghc-version "9.4" < 0
-          then ../../materialized/ghc8107/hadrian-ghc92
+          then ../../materialized/${compiler-nix-name}/hadrian-ghc92
         else if builtins.compareVersions ghc-version "9.6" < 0
-          then ../../materialized/ghc8107/hadrian-ghc94
+          then ../../materialized/${compiler-nix-name}/hadrian-ghc94
         else if builtins.compareVersions ghc-version "9.8" < 0
-          then ../../materialized/ghc8107/hadrian-ghc96
-        else ../../materialized/ghc8107/hadrian-ghc98;
+          then ../../materialized/${compiler-nix-name}/hadrian-ghc96
+        else if builtins.compareVersions ghc-version "9.9" < 0
+          then ../../materialized/${compiler-nix-name}/hadrian-ghc98
+        else ../../materialized/${compiler-nix-name}/hadrian-ghc99;
       modules = [{
         # Apply the patches in a way that does not require using something
         # like `srcOnly`. The problem with `pkgs.srcOnly` was that it had to run
@@ -263,10 +271,6 @@ let
           cd hadrian
         '';
       }];
-      cabalProject = ''
-        packages:
-          .
-      '';
       cabalProjectLocal = null;
       cabalProjectFreeze = null;
       src = haskell-nix.haskellLib.cleanSourceWith {
@@ -278,6 +282,7 @@ let
           filterPath = { path, ... }: path;
         };
         subDir = "hadrian";
+        includeSiblings = true;
       };
     };
 
@@ -372,6 +377,7 @@ stdenv.mkDerivation (rec {
         export CC="${targetCC}/bin/emcc"
         export CXX="${targetCC}/bin/em++"
         export LD="${targetCC}/bin/emcc"
+        export NM="${targetCC}/share/emscripten/emnm"
         export EM_CACHE=$(mktemp -d)
         mv config.sub.ghcjs config.sub
     ''
@@ -434,9 +440,11 @@ stdenv.mkDerivation (rec {
     '' + lib.optionalString (ghc-version-date != null) ''
         substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'
         echo '${ghc-version-date}' > VERSION_DATE
+    '' + lib.optionalString (ghc-commit-id != null) ''
+        echo '${ghc-commit-id}' > GIT_COMMIT_ID
     ''
       # The official ghc 9.2.3 tarball requires booting.
-      + lib.optionalString (ghc-version == "9.2.3" || ghc-version == "9.8.20230704") ''
+      + lib.optionalString (ghc-version == "9.2.3" || ghc-version == "9.8.20230704" || src-spec.needsBooting or false) ''
         python3 ./boot
     '';
 
@@ -644,7 +652,7 @@ stdenv.mkDerivation (rec {
         for a in libraries/*/*.cabal.in utils/*/*.cabal.in compiler/ghc.cabal.in; do
           ${hadrian}/bin/hadrian ${hadrianArgs} "''${a%.*}"
         done
-      '' + lib.optionalString (builtins.compareVersions ghc-version "9.8.1" >= 0) ''
+      '' + lib.optionalString (ghc-version == "9.8.20230704") ''
         for a in bytearray-access-ops.txt.pp addr-access-ops.txt.pp primops.txt; do
           ${hadrian}/bin/hadrian ${hadrianArgs} _build/stage0/compiler/build/$a
           cp _build/stage0/compiler/build/$a compiler/GHC/Builtin/$a

diff --git a/flake.lock b/flake.lock
diff --git a/flake.nix b/flake.nix
@@ -10,6 +10,14 @@
     nixpkgs-2211 = { url = "github:NixOS/nixpkgs/nixpkgs-22.11-darwin"; };
     nixpkgs-2305 = { url = "github:NixOS/nixpkgs/nixpkgs-23.05-darwin"; };
     nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };
+    ghc980 = {
+      flake = false;
+      url = "git+https://gitlab.haskell.org/ghc/ghc?ref=ghc-9.8&submodules=1";
+    };
+    ghc99 = {
+      flake = false;
+      url = "git+https://gitlab.haskell.org/ghc/ghc?submodules=1";
+    };
     flake-compat = { url = "github:input-output-hk/flake-compat/hkm/gitlab-fix"; flake = false; };
     "hls-1.10" = { url = "github:haskell/haskell-language-server/1.10.0.0"; flake = false; };
     "hls-2.0" = { url = "github:haskell/haskell-language-server/2.0.0.1"; flake = false; };

diff --git a/lib/call-cabal-project-to-nix.nix b/lib/call-cabal-project-to-nix.nix
@@ -11,6 +11,7 @@
 , cabalProjectFileName ? "cabal.project"
 , cabalProject         ? null
 , cabalProjectLocal    ? null
+, cabalProjectDefaults ? null
 , cabalProjectFreeze   ? null
 , caller               ? "callCabalProjectToNix" # Name of the calling function for better warning messages
 , compilerSelection    ? p: p.haskell-nix.compiler
@@ -138,6 +139,10 @@ in let
         -- Added from `cabalProjectLocal` argument to the `cabalProject` function
         ${cabalProjectLocal}
       ''
+      + pkgs.lib.optionalString (cabalProjectDefaults != null) ''
+        -- Added from `cabalProjectDefaults` argument to the `cabalProject` function
+        ${cabalProjectDefaults}
+      ''
     }
   '';