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

Author: ocharles

.github/workflows/lints.yml

@@ -0,0 +1,32 @@
+name: "Lints"
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches:
+      - master
+
+  push:
+    branches:
+      - master
+
+defaults:
+  run:
+    shell: bash
+
+# do we really want nixos-unstable?
+env:
+  NIX_PATH: "nixpkgs=channel:nixos-unstable"
+  REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+jobs:
+  deadnix:
+    runs-on: [self-hosted, linux]
+    steps:
+      - uses: actions/checkout@v3
+      - run: |
+          nix run github:astro/deadnix -- --edit --no-lambda-pattern-names
+          TMPFILE=$(mktemp)
+          git diff >"${TMPFILE}"
+          git stash -u && git stash drop
+          nix-shell -p reviewdog --run "reviewdog -f=diff -f.diff.strip=1 -reporter=github-pr-review < \"${TMPFILE}\""

.github/workflows/pipeline.yml

@@ -123,6 +123,13 @@ jobs:
       - name: "Run tests with ghc8107: End-2-end test of hix project initialization and flakes development shell ..."
         run: "./test/tests.sh ghc8107 hix"
 
+#  template:
+#    runs-on: [self-hosted, linux]
+#    steps:
+#      - uses: actions/checkout@v3
+#      - name: "Run tests with ghc8107: End-2-end test of hix project initialization and flakes development shell ..."
+#        run: "./test/tests.sh ghc8107 template"
+
   docs:
     runs-on: [self-hosted, linux]
     steps:

.gitignore

@@ -78,7 +78,6 @@ cabal.sandbox.config
 *.hp
 *.eventlog
 .stack-work/
-cabal.project.local
 cabal.project.local~
 .HTF/
 .ghc.environment.*

build.nix

@@ -25,7 +25,7 @@ in rec {
 
   tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (
     pkgs.recurseIntoAttrs ({
-      cabal-latest = tool compiler-nix-name "cabal" { inherit evalPackages; };
+      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) {
       hlint-latest = tool compiler-nix-name "hlint" {
         inherit evalPackages;
@@ -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) {
@@ -62,6 +61,11 @@ in rec {
         inherit evalPackages;
         src = pkgs.haskell-nix.sources."hls-2.0";
       };
+    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.8" < 0) {
+      "hls-22" = tool compiler-nix-name "haskell-language-server" {
+        inherit evalPackages;
+        src = pkgs.haskell-nix.sources."hls-2.2";
+      };
     })
   );
 
@@ -73,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)
-      nix-tools = haskell.internal-nix-tools;
-      cabal-install = haskell.internal-cabal-install;
+      # Update scripts use the internal nix-tools (compiled with a fixed GHC version)
+      nix-tools = haskell.nix-tools-unchecked;
       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)
-      nix-tools = haskell.internal-nix-tools;
-      cabal-install = haskell.internal-cabal-install;
+      # Update scripts use the internal nix-tools (compiled with a fixed GHC version)
+      nix-tools = haskell.nix-tools-unchecked;
       inherit (haskell) cabal-issue-8352-workaround;
     };
     update-pins = haskell.callPackage ./scripts/update-pins.nix {};

builder/Setup.ghcjs.hs

@@ -122,7 +122,7 @@ linkCLib libname desc lbi = do
                 -- getTempRet0/setTempRet0 are for 64bit legalization.
                 , "-s", "EXPORTED_RUNTIME_METHODS=['printErr','addFunction','removeFunction','getTempRet0','setTempRet0']"
                 --
-                , "-s", "EXPORTED_FUNCTIONS=['" <> intercalate "', '" exfns <> "']"
+                , "-s", "EXPORTED_FUNCTIONS=[" <> intercalate ", " (map (\f -> "'" <> f <> "'") exfns) <> "]"
                 ] ++ libs ++ libDirs ++ extraLibs
 
 postBuildHook :: Args -> BuildFlags -> PackageDescription -> LocalBuildInfo -> IO ()

builder/comp-builder.nix

@@ -40,6 +40,7 @@ let self =
 
 , dontPatchELF ? component.dontPatchELF
 , dontStrip ? component.dontStrip
+, dontUpdateAutotoolsGnuConfigScripts ? component.dontUpdateAutotoolsGnuConfigScripts
 , hardeningDisable ? component.hardeningDisable
 
 , enableStatic ? component.enableStatic
@@ -188,15 +189,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
@@ -223,7 +232,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.
@@ -261,8 +270,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}";
 
@@ -295,10 +305,8 @@ let
         (if cabalFile != null
           then ''cp -v $cabalFilePath ${package.identifier.name}.cabal''
           else
-            # When building hpack package we use the internal nix-tools
-            # (compiled with a fixed GHC version)
             lib.optionalString (cabal-generator == "hpack") ''
-              ${buildPackages.haskell-nix.internal-nix-tools}/bin/hpack
+              ${buildPackages.haskell-nix.nix-tools-unchecked}/bin/hpack
             ''
         ) + lib.optionalString (prePatch != null) "\n${prePatch}";
     }
@@ -320,6 +328,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 {
@@ -534,7 +545,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) ''
@@ -586,13 +597,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})
@@ -609,8 +620,8 @@ let
               # Also include C++ and mcfgthreads DLLs for GHC 9.4.1 and newer
               lib.optionals (builtins.compareVersions defaults.ghc.version "9.4.1" >= 0)
                 [ buildPackages.gcc-unwrapped
-                  # Find the versions of mfcgthreads used by stdenv.cc
-                  (pkgs.threadsCrossFor or (x: windows.mfcgthreads) stdenv.cc.version).package
+                  # Find the versions of mcfgthreads used by stdenv.cc
+                  (pkgs.threadsCrossFor or (_x: { package = pkgs.windows.mcfgthreads; }) pkgs.stdenv.cc.version).package
                 ])}; do
           find "$p" -iname '*.dll' -exec ln -s {} $out/bin \;
         done

builder/haddock-builder.nix

@@ -121,9 +121,7 @@ let
     '';
 
     installPhase =
-      let
-        target-pkg-and-db = "${ghc.targetPrefix}ghc-pkg -v0 --package-db $out/package.conf.d";
-      in ''
+      ''
         html="dist/doc/html/${package.identifier.name}"
 
         if [ -d "$html" ]; then

builder/make-config-files.nix

@@ -37,11 +37,7 @@ let
   #            pkg id for z-{pkg name}-z-{sublib name}.  As we do not provide the
   #            sublib name to exactDep, as we don't have access to it at the call-site,
   #            we resort to a bit of globbing, which (as pkg db's should contain only
-  #            a single package) work.
-
-  getLibComponent = dep:
-       dep.components.library # Regular package dependency
-    or dep;                   # or a sublib
+  #            a single package) work.                   # or a sublib
 
   # Work our suitable packageCfgDir subdirectory
   isGhcjs        = ghc.isGhcjs or false;

ci-lib.nix

@@ -1,8 +1,5 @@
-{
-  # Generic nixpkgs, use *only* for lib functions that are stable across versions
-  pkgs,
-  lib ? pkgs.lib
-}: rec {
+{ lib }:
+rec {
   inherit (import ./dimension.nix) dimension;
 
   # A filter for removing packages that aren't supported on the current platform
@@ -23,7 +20,7 @@
   # Keep derivations and attrsets with 'recurseForDerivations'. This ensures that we match the
   # derivations that Hercules will see, and prevents Hydra from trying to pick up all sorts of bad stuff
   # (like attrsets that contain themselves!).
-  filterDerivations = filterAttrsOnlyRecursive (n: attrs: lib.isDerivation attrs || attrs.recurseForDerivations or false);
+  filterDerivations = filterAttrsOnlyRecursive (_n: attrs: lib.isDerivation attrs || attrs.recurseForDerivations or false);
 
   # A version of 'filterAttrsRecursive' that doesn't recurse into derivations. This prevents us from going into an infinite
   # loop with the 'out' attribute on derivations.