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

Author: ocharles

build.nix

@@ -42,12 +42,12 @@ in rec {
       };
     } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.4" < 0) {
       stack = tool compiler-nix-name "stack" { version = "2.9.3"; inherit evalPackages; };
-      hls-latest = tool compiler-nix-name "haskell-language-server" {
+    } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.6" < 0) {
+      hls-latest = tool compiler-nix-name "haskell-language-server" rec {
         inherit evalPackages;
-        version =
-          if __compareVersions haskell.compiler.${compiler-nix-name}.version "9.0" < 0
-            then "1.8.0.0"
-            else "latest";
+        src = pkgs.haskell-nix.sources."hls-1.10";
+        cabalProject = __readFile (src + "/cabal.project");
+        sha256map."https://github.com/pepeiborra/ekg-json"."7a0af7a8fd38045fd15fb13445bdcc7085325460" = "sha256-fVwKxGgM0S4Kv/4egVAAiAjV7QB5PBqMVMCfsv7otIQ=";
       };
     })
   );

builder/comp-builder.nix

@@ -14,6 +14,7 @@ let self =
 
 , preUnpack ? component.preUnpack, postUnpack ? component.postUnpack
 , configureFlags ? component.configureFlags
+, prePatch ? component.prePatch, postPatch ? component.postPatch
 , preConfigure ? component.preConfigure, postConfigure ? component.postConfigure
 , setupBuildFlags ? component.setupBuildFlags
 , preBuild ? component.preBuild , postBuild ? component.postBuild
@@ -43,9 +44,6 @@ let self =
 
 , enableStatic ? component.enableStatic
 , enableShared ? ghc.enableShared && component.enableShared && !haskellLib.isCrossHost
-               # on x86 we'll use shared libraries, even with musl m(
-               # ghc's internal linker seems to be broken on x86.
-               && !(stdenv.hostPlatform.isMusl && !stdenv.hostPlatform.isx86)
 , enableDeadCodeElimination ? component.enableDeadCodeElimination
 , writeHieFiles ? component.writeHieFiles
 
@@ -290,7 +288,7 @@ let
             lib.optionalString (cabal-generator == "hpack") ''
               ${buildPackages.haskell-nix.internal-nix-tools}/bin/hpack
             ''
-        );
+        ) + lib.optionalString (prePatch != null) "\n${prePatch}";
     }
     # patches can (if they like) depend on the version of the package.
     // lib.optionalAttrs (patches != []) {
@@ -302,7 +300,7 @@ let
     }
     // haskellLib.optionalHooks {
       # These are hooks are needed to set up the source for building and running haddock
-      inherit preUnpack postUnpack preConfigure postConfigure;
+      inherit preUnpack postUnpack postPatch preConfigure postConfigure;
     }
     // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc") {
       LOCALE_ARCHIVE = "${buildPackages.glibcLocales}/lib/locale/locale-archive";

builder/default.nix

@@ -1,4 +1,19 @@
-{ pkgs, buildPackages, evalPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, nonReinstallablePkgs, hsPkgs, compiler, inputMap }:
+# While creating the nix build plan, we take care to create package derivations
+# that do not include any reference to the plan itself or how it is created.
+#
+# This allows haskell.nix to share packages between plans (at least when they
+# have identical dependencies). If the package derivations included the hash of
+# the plan derivation, different plans would always produce different packages
+# and there could not be any sharing of packages between plans.
+#
+# Any wrangling of the project dependencies (e.g. fetching package indices,
+# source-repository-packages or any other asset required for building) *has* to
+# be performed during planning. The nix build plan will import any remote asset
+# through a fixed-output derivations (i.e. a call to a fetcher).
+#
+# tl;dr: the builder must not re-introduce any reference to the build plan.
+
+{ pkgs, buildPackages, evalPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, nonReinstallablePkgs, hsPkgs, compiler }:
 
 let
   # Builds a single component of a package.
@@ -85,7 +100,7 @@ in {
   # Build a Haskell package from its config.
   # TODO: this pkgs is the adjusted pkgs, but pkgs.pkgs is unadjusted
   build-package = haskellLib.weakCallPackage pkgs ./hspkg-builder.nix {
-    inherit haskellLib ghc compiler-nix-name comp-builder setup-builder inputMap;
+    inherit haskellLib ghc compiler-nix-name comp-builder setup-builder;
   };
 
   inherit shellFor makeConfigFiles;

builder/hspkg-builder.nix

@@ -1,4 +1,4 @@
-{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, runCommand, comp-builder, setup-builder, inputMap }:
+{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, runCommand, comp-builder, setup-builder }:
 
 config:
 { flags
@@ -24,24 +24,9 @@ let
       "ghc902/stm-2.5.0.0" = "/libraries/stm";
       "ghc902/filepath-1.4.2.1" = "/libraries/filepath";
     }."${compiler-nix-name}/${name}" or null;
-  baseUrlMatch =
-    let
-      # All the urls that should contain the source
-      srcUrls = lib.optional (pkg.src ? url) pkg.src.url ++ pkg.src.urls or [];
-    in __head (
-        # Look for one that matches the expected pattern
-        builtins.filter (x: x != null) (
-          map (__match "(.*)/package/([^/]*)") srcUrls)
-        # Return null if none do
-        ++ [null]);
   src =
     if bundledSrc != null
       then ghc.configured-src + bundledSrc
-    else if baseUrlMatch != null && inputMap ? ${__head baseUrlMatch}
-      then
-        # Use the copy of the package that is in the inputMap for this
-        # repository.
-        inputMap.${__head baseUrlMatch} + "/package/${__elemAt baseUrlMatch 1}"
     else pkg.src;
 
   cabalFile = if package-description-override == null || bundledSrc != null then null else package-description-override;

ci.nix

@@ -51,13 +51,13 @@
         ghc8107 = false;
         ghc902 = false;
         ghc927 = false;
-        ghc944 = false;
+        ghc945 = false;
       } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {
         ghc884 = false;
         ghc8107 = true;
         ghc902 = false;
         ghc927 = true;
-        ghc944 = true;
+        ghc945 = true;
         ghc961 = true;
       }));
   crossSystems = nixpkgsName: nixpkgs: compiler-nix-name:
@@ -72,13 +72,18 @@
        )) {
     inherit (lib.systems.examples) ghcjs;
   } // lib.optionalAttrs (nixpkgsName == "unstable"
-      && ((system == "x86_64-linux"  && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc926" "ghc927" "ghc944" "ghc961"])
+      && ((system == "x86_64-linux"  && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc926" "ghc927" "ghc945" "ghc961"])
        || (system == "x86_64-darwin" && __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" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923" "ghc924" "ghc926" "ghc927" "ghc944" "ghc961"]) {
+  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923" "ghc924" "ghc926" "ghc927" "ghc945" "ghc961"]) {
     # 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" && __elem compiler-nix-name ["ghc927"]) {
+    # 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" && __elem compiler-nix-name ["ghc927" "ghc944" "ghc961"]) {
+    inherit (lib.systems.examples) aarch64-multiplatform-musl;
   };
   isDisabled = d: d.meta.disabled or false;
 in

compiler/ghc/default.nix

@@ -231,8 +231,7 @@ let
   # value for us.
   installStage1 = useHadrian && (haskell-nix.haskellLib.isCrossTarget || stdenv.targetPlatform.isMusl);
 
-  inherit ((buildPackages.haskell-nix.cabalProject {
-      compiler-nix-name = "ghc8107";
+  hadrian = buildPackages.haskell-nix.tool "ghc8107" "hadrian" {
       compilerSelection = p: p.haskell.compiler;
       index-state = buildPackages.haskell-nix.internalHackageIndexState;
       # Verions of hadrian that comes with 9.6 depends on `time`
@@ -242,15 +241,23 @@ let
         else if builtins.compareVersions ghc-version "9.6" < 0
           then ../../materialized/ghc8107/hadrian-ghc94
         else ../../materialized/ghc8107/hadrian-ghc96;
+      modules = [{
+        # Apply the patches in a way that does not require using somethin
+        # like `srcOnly`. The problem with `pkgs.srcOnly` was that it had to run
+        # on a platform at eval time.
+        packages.hadrian.prePatch = ''
+          cd ..
+        '';
+        packages.hadrian.patches = ghc-patches;
+        packages.hadrian.postPatch = ''
+          cd hadrian
+        '';
+      }];        
       src = haskell-nix.haskellLib.cleanSourceWith {
-        src = buildPackages.srcOnly {
-          name = "hadrian";
-          inherit src;
-          patches = ghc-patches;
-        };
+        inherit src;
         subDir = "hadrian";
       };
-    }).hsPkgs.hadrian.components.exes) hadrian;
+    };
 
   # For a discription of hadrian command line args
   # see https://gitlab.haskell.org/ghc/ghc/blob/master/hadrian/README.md

docs/dev/installing-nix-tools.md

@@ -6,10 +6,12 @@ To build the latest `nix-tools` and store the result at `./nt`, run:
 nix build -f https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz pkgs.haskell-nix.nix-tools.ghc884 --out-link nt
 ```
 
-If you would like to then install `nix-tools` into your profile, run:
+If you would like to then install `nix-tools` into your profile, run an install
+command:
 
 ```shell
 nix-env -i ./nt
+nix profile install ./nt
 ```
 
 ## Optional: Installing via [Haskell.nix][] source

docs/troubleshooting.md

@@ -15,7 +15,14 @@ If you think you are doing all of these and you still find you're building GHC,
 ### Why am I building lots of Haskell packages?
 
 We don't generally cache much of Hackage (there's a lot of it!), except for the parts which are used by our tests.
-So this is expected, unfortunately.
+So this is expected, unfortunately. However, if you are building from a recent branch without significant dependencies 
+changes, most of those dependencies should be cached and you should not be building core things like `Cabal` or `ghc-lib`.
+
+If this happens, chances are nix cache are either:
+* Incorrectly configured: Check the aforementioned links,
+* Overriding global configuration in `/etc/nix/nix.conf` with local `~/.config/nix/nix.conf`. This can happen if for example
+  one project is using `nix flake` with some locally configured repositories, while another project is not. 
+  Use `nix show-config` to check which caches are defined, then update or remove `~/.config/nix/nix.conf`.
 
 ### How do I prevent the evaluation-time dependencies of my project from being garbage-collected?
 

flake.lock

@@ -11,6 +11,7 @@
     nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };
     flake-compat = { url = "github:input-output-hk/flake-compat/hkm/gitlab-fix"; flake = false; };
     flake-utils = { url = "github:hamishmack/flake-utils/hkm/nested-hydraJobs"; };
+    "hls-1.10" = { url = "github:haskell/haskell-language-server/1.10.0.0"; flake = false; };
     tullia = {
       url = "github:input-output-hk/tullia";
       inputs.nixpkgs.follows = "nixpkgs";