Update tests to make compiler-nix-name explicit

Author: hamishmack

build.nix

@@ -9,23 +9,22 @@ in
 , nixpkgsArgs ? haskellNix.nixpkgsArgs
 , pkgs ? import nixpkgs nixpkgsArgs
 , ifdLevel ? 1000
+, compiler-nix-name
 }:
 
 let
   haskell = pkgs.haskell-nix;
   buildHaskell = pkgs.buildPackages.haskell-nix;
-  tool = buildHaskell.tool;
+  tool = buildHaskell.tool';
 in rec {
-  tests = import ./test/default.nix { inherit pkgs ifdLevel; };
+  tests = import ./test/default.nix { inherit pkgs ifdLevel compiler-nix-name; };
 
   tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (
     pkgs.recurseIntoAttrs {
-      ghcide-020 = tool "ghcide" "0.2.0";
-    } // pkgs.lib.optionalAttrs (buildHaskell.defaultCompilerNixName == "ghc865") {
-      cabal-30 = tool "cabal" "3.0.0.0";
-    } // pkgs.lib.optionalAttrs (buildHaskell.defaultCompilerNixName != "ghc8101") {
-      cabal-32 = tool "cabal" "3.2.0.0";
-      ghcide-object-code = tool "ghcide" "object-code";
+      ghcide-020 = tool compiler-nix-name "ghcide" "0.2.0";
+      cabal-32 = tool compiler-nix-name "cabal" "3.2.0.0";
+    } // pkgs.lib.optionalAttrs (buildHaskell.defaddultCompilerNixName != "ghc8101") {
+      ghcide-object-code = tool compiler-nix-name "ghcide" "object-code";
     }
   );
 
@@ -47,11 +46,10 @@ in rec {
     # use)
     check-hydra = pkgs.buildPackages.callPackage ./scripts/check-hydra.nix {};
     check-closure-size = pkgs.buildPackages.callPackage ./scripts/check-closure-size.nix {
-      # Includes cabal-install and hpack since these are commonly used.
+      # Includes cabal-install since this is commonly used.
       nix-tools = pkgs.linkFarm "common-tools" [
-        { name = "nix-tools";     path = haskell.nix-tools; }
-        { name = "cabal-install"; path = haskell.cabal-install; }
-        { name = "hpack";         path = haskell.haskellPackages.hpack.components.exes.hpack; }
+        { name = "nix-tools";     path = haskell.nix-tools.${compiler-nix-name}; }
+        { name = "cabal-install"; path = haskell.cabal-install.${compiler-nix-name}; }
       ];
     };
     check-materialization-concurrency = pkgs.buildPackages.callPackage ./scripts/check-materialization-concurrency/check.nix {};

builder/default.nix

@@ -1,4 +1,4 @@
-{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, fetchurl, pkgconfig, nonReinstallablePkgs, hsPkgs }:
+{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, fetchurl, pkgconfig, nonReinstallablePkgs, hsPkgs, compiler }:
 
 let
   # Builds a single component of a package.
@@ -45,6 +45,7 @@ let
   hoogleLocal = let
     nixpkgsHoogle = import (pkgs.path + /pkgs/development/haskell-modules/hoogle.nix);
   in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool "hoogle" {
+        compiler-nix-name = compiler.nix-name;
         version = "5.0.17.15";
         index-state = pkgs.haskell-nix.internalHackageIndexState;
       }
@@ -59,9 +60,8 @@ let
 
   # Same as haskellPackages.shellFor in nixpkgs.
   shellFor = haskellLib.weakCallPackage pkgs ./shell-for.nix {
-    inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages;
+    inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;
     inherit (buildPackages) glibcLocales;
-    buildGHC = ghc.passthru.buildGHC or ghc;
   };
 
   # Same as haskellPackages.ghcWithPackages and ghcWithHoogle in nixpkgs.

builder/shell-for.nix

@@ -1,4 +1,4 @@
-{ lib, stdenv, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, buildGHC }:
+{ lib, stdenv, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, compiler }:
 
 { packages ? ps:
     let
@@ -93,7 +93,7 @@ in
     nativeBuildInputs = [ ghcEnv ]
       ++ nativeBuildInputs
       ++ mkDrvArgs.nativeBuildInputs or []
-      ++ lib.attrValues (buildPackages.haskell-nix.toolsForGhc buildGHC tools);
+      ++ lib.attrValues (buildPackages.haskell-nix.tools' compiler.nix-name tools);
     phases = ["installPhase"];
     installPhase = "echo $nativeBuildInputs $buildInputs > $out";
     LANG = "en_US.UTF-8";

ci.nix

@@ -12,8 +12,8 @@
     "R1909" = "nixpkgs-1909";
     "R2003" = "nixpkgs-2003";
   };
-  compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (defaultCompilerNixName: _:
-    (import ./default.nix { inherit checkMaterialization defaultCompilerNixName; }).nixpkgsArgs) ({
+  compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (compiler-nix-name: _:
+    (import ./default.nix { inherit checkMaterialization; }).nixpkgsArgs) ({
     ghc865 = {};
   } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2003") {
     ghc883 = {};
@@ -24,11 +24,11 @@
     linux = "x86_64-linux";
     darwin = "x86_64-darwin";
   };
-  crossSystems = nixpkgsName: nixpkgs: compilerNixName: system:
+  crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: system:
     # 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" && compilerNixName != "ghc8101") {
+    in lib.optionalAttrs (system == "x86_64-linux" && compiler-nix-name != "ghc8101") {
     # Windows cross compilation is currently broken on macOS
     inherit (lib.systems.examples) mingwW64;
   } // lib.optionalAttrs (system == "x86_64-linux") {
@@ -41,32 +41,32 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
   let pinnedNixpkgsSrc = sources.${nixpkgs-pin};
       # We need this for generic nixpkgs stuff at the right version
       genericPkgs = import pinnedNixpkgsSrc {};
-  in dimension "GHC version" (compilerNixNames nixpkgsName genericPkgs) (compilerNixName: nixpkgsArgs:
+  in dimension "GHC version" (compilerNixNames nixpkgsName genericPkgs) (compiler-nix-name: nixpkgsArgs:
     dimension "System" (systems genericPkgs) (systemName: system:
       let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });
-          build = import ./build.nix { inherit pkgs ifdLevel; };
+          build = import ./build.nix { inherit pkgs ifdLevel compiler-nix-name; };
           platformFilter = platformFilterGeneric pkgs system;
       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 tools maintainer-scripts maintainer-script-cache;
-          ghc = pkgs.buildPackages.haskell-nix.compiler."${compilerNixName}";
+          ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";
         } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {
-          iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;
+          iserv-proxy = pkgs.ghc-extra-packages."${compiler-nix-name}".iserv-proxy.components.exes.iserv-proxy;
         } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
           hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
         });
       }
       //
-      dimension "Cross system" (crossSystems nixpkgsName genericPkgs compilerNixName system) (crossSystemName: crossSystem:
+      dimension "Cross system" (crossSystems nixpkgsName genericPkgs compiler-nix-name system) (crossSystemName: crossSystem:
         # Cross builds
         let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });
             build = import ./build.nix { inherit pkgs ifdLevel; };
         in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) {
-          ghc = pkgs.buildPackages.haskell-nix.compiler."${compilerNixName}";
+          ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";
           # TODO: look into cross compiling ghc itself
-          # ghc = pkgs.haskell-nix.compiler."${compilerNixName}";
+          # ghc = pkgs.haskell-nix.compiler."${compiler-nix-name}";
           # TODO: look into making tools work when cross compiling
           # inherit (build) tools;
           # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513
@@ -78,8 +78,8 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
                 inherit (build.tests) haskellNixRoots;
               };
         } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
-          remote-iserv = pkgs.ghc-extra-packages."${compilerNixName}".remote-iserv.components.exes.remote-iserv;
-          iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;
+          remote-iserv = pkgs.ghc-extra-packages."${compiler-nix-name}".remote-iserv.components.exes.remote-iserv;
+          iserv-proxy = pkgs.ghc-extra-packages."${compiler-nix-name}".iserv-proxy.components.exes.iserv-proxy;
         } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
           hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
         })

lib/call-stack-to-nix.nix

@@ -14,10 +14,7 @@
 , stack-sha256 ? null
 , materialized ? null # Location of a materialized copy of the nix files
 , checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material
-, compiler-nix-name ? pkgs.haskell-nix.defaultCompilerNixNameTODO # We should get this from stack.yaml
-, nix-tools ? pkgs.haskell-nix.nix-tools-set {
-    inherit compiler-nix-name checkMaterialization;
-  }
+, nix-tools ? pkgs.haskell-nix.nix-tools.${pkgs.haskell-nix.defaultCompilerNixNameTODO}
 , ... }:
 let
   subDir' = src.origSubDir or "";

modules/component-driver.nix

@@ -3,7 +3,7 @@ let
   builder = haskellLib.weakCallPackage pkgs ../builder {
     inherit haskellLib;
     ghc = config.ghc.package;
-    inherit (config) nonReinstallablePkgs hsPkgs;
+    inherit (config) nonReinstallablePkgs hsPkgs compiler;
   };
 
 in

overlays/haskell.nix

@@ -323,12 +323,14 @@ final: prev: {
               if type == "cabal"
               then
                 final.buildPackages.haskell-nix.callCabalToNix {
+                  compiler-nix-name = final.haskell-nix.defaultCompilerNixNameTODO;
                   src = repoWithSubdir;
                   inherit name cabal-file;
                 }
               else if type == "stack"
               then
                 (final.buildPackages.haskell-nix.callStackToNix {
+                  compiler-nix-name = final.haskell-nix.defaultCompilerNixNameTODO;
                   src = repoWithSubdir;
                   inherit name subdir;
                 }).projectNix

test/buildable/default.nix

@@ -1,9 +1,10 @@
-{ stdenv, cabalProject', haskellLib, recurseIntoAttrs, testSrc }:
+{ stdenv, cabalProject', haskellLib, recurseIntoAttrs, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
 let
   project = cabalProject' {
+    inherit compiler-nix-name;
     index-state = "2020-05-25T00:00:00Z";
     src = testSrc "buildable";
     modules = [ { packages.buildable-test.flags.exclude-broken = true; } ];

test/cabal-22/default.nix

@@ -1,9 +1,10 @@
-{ stdenv, mkCabalProjectPkgSet, cabalProject', haskellLib, util, recurseIntoAttrs, testSrc }:
+{ stdenv, mkCabalProjectPkgSet, cabalProject', haskellLib, util, recurseIntoAttrs, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
 let
   project = cabalProject' {
+    inherit compiler-nix-name;
     src = testSrc "cabal-22";
   };
 

test/cabal-hpack/default.nix

@@ -1,5 +1,5 @@
 # Test a package set
-{ stdenv, util, mkCabalProjectPkgSet, project', haskellLib, recurseIntoAttrs, testSrc }:
+{ stdenv, util, mkCabalProjectPkgSet, project', haskellLib, recurseIntoAttrs, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
@@ -13,6 +13,7 @@ let
   ];
 
   project = project' {
+    inherit compiler-nix-name;
     src = testSrc "cabal-hpack";
     inherit modules;
   };

test/cabal-simple-prof/default.nix

@@ -1,5 +1,5 @@
 # Test a package set
-{ stdenv, util, cabalProject', haskellLib, recurseIntoAttrs, testSrc }:
+{ stdenv, util, cabalProject', haskellLib, recurseIntoAttrs, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
@@ -16,6 +16,7 @@ let
   ];
 
   project = cabalProject' {
+    inherit compiler-nix-name;
     src = testSrc "cabal-simple-prof";
     inherit modules;
   };

test/cabal-simple/default.nix

@@ -1,5 +1,5 @@
 # Test a package set
-{ stdenv, util, mkCabalProjectPkgSet, project', haskellLib, recurseIntoAttrs, testSrc }:
+{ stdenv, util, mkCabalProjectPkgSet, project', haskellLib, recurseIntoAttrs, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
@@ -13,6 +13,7 @@ let
   ];
 
   project = project' {
+    inherit compiler-nix-name;
     src = testSrc "cabal-simple";
     inherit modules;
   };

test/cabal-source-repo/default.nix

@@ -1,9 +1,10 @@
-{ stdenv, cabalProject', recurseIntoAttrs, haskellLib, testSrc }:
+{ stdenv, cabalProject', recurseIntoAttrs, haskellLib, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
 let
   project = cabalProject' {
+    inherit compiler-nix-name;
     index-state = "2020-05-25T00:00:00Z";
     src = testSrc "cabal-source-repo";
   };

test/cabal-sublib/default.nix

@@ -1,5 +1,5 @@
 # Test a package set
-{ stdenv, util, cabalProject', haskellLib, recurseIntoAttrs, testSrc }:
+{ stdenv, util, cabalProject', haskellLib, recurseIntoAttrs, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
@@ -14,6 +14,7 @@ let
 
   # The ./pkgs.nix works for linux & darwin, but not for windows
   project = cabalProject' {
+    inherit compiler-nix-name;
     src = testSrc "cabal-sublib";
     inherit modules;
   };

test/call-cabal-project-to-nix/default.nix

@@ -1,11 +1,12 @@
-{ stdenv, mkCabalProjectPkgSet, callCabalProjectToNix, importAndFilterProject, recurseIntoAttrs, haskellLib, testSrc }:
+{ stdenv, mkCabalProjectPkgSet, callCabalProjectToNix, importAndFilterProject, recurseIntoAttrs, haskellLib, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
 let
   # This test could use cabalProject', but it does so that it
   # tests using callCabalProjectToNix and importAndFilterProject
   callProjectResults = callCabalProjectToNix {
+    inherit compiler-nix-name;
     index-state = "2020-05-25T00:00:00Z";
     # reuse the cabal-simple test project
     src = testSrc "cabal-simple";

test/default.nix

@@ -1,9 +1,9 @@
-{ haskellNix ? import ../default.nix { defaultCompilerNixName = compiler-nix-name; inherit checkMaterialization; }
+{ haskellNix ? import ../default.nix { inherit checkMaterialization; }
 , pkgs ? import nixpkgs nixpkgsArgs
 , nixpkgs ? haskellNix.sources.nixpkgs-default
 , nixpkgsArgs ? haskellNix.nixpkgsArgs
 , ifdLevel ? 1000
-, compiler-nix-name ? pkgs.haskell-nix.defaultCompilerNixName
+, compiler-nix-name
 , checkMaterialization ? false
 }:
 
@@ -151,46 +151,43 @@ let
 
   # All tests.
   allTests = {
-    cabal-simple = callTest ./cabal-simple { inherit util; };
-    cabal-simple-prof = callTest ./cabal-simple-prof { inherit util; };
-    cabal-sublib = callTest ./cabal-sublib { inherit util; };
-    cabal-22 = callTest ./cabal-22 { inherit util; };
+    cabal-simple = callTest ./cabal-simple { inherit util compiler-nix-name; };
+    cabal-simple-prof = callTest ./cabal-simple-prof { inherit util compiler-nix-name; };
+    cabal-sublib = callTest ./cabal-sublib { inherit util compiler-nix-name; };
+    cabal-22 = callTest ./cabal-22 { inherit util compiler-nix-name; };
     with-packages = callTest ./with-packages { inherit util; };
     builder-haddock = callTest ./builder-haddock {};
     stack-simple = callTest ./stack-simple {};
     stack-local-resolver = callTest ./stack-local-resolver {};
     snapshots = callTest ./snapshots {};
     shell-for = callTest ./shell-for {};
-    shell-for-setup-deps = callTest ./shell-for-setup-deps {};
-    setup-deps = import ./setup-deps { inherit pkgs; };
+    shell-for-setup-deps = callTest ./shell-for-setup-deps { inherit compiler-nix-name; };
+    setup-deps = import ./setup-deps { inherit pkgs compiler-nix-name; };
     callStackToNix = callTest ./call-stack-to-nix {};
-    callCabalProjectToNix = callTest ./call-cabal-project-to-nix {};
-    cabal-source-repo = callTest ./cabal-source-repo {};
-    buildable = callTest ./buildable {};
-    project-flags-cabal = callTest ./project-flags/cabal.nix {};
+    callCabalProjectToNix = callTest ./call-cabal-project-to-nix { inherit compiler-nix-name; };
+    cabal-source-repo = callTest ./cabal-source-repo { inherit compiler-nix-name; };
+    buildable = callTest ./buildable { inherit compiler-nix-name; };
+    project-flags-cabal = callTest ./project-flags/cabal.nix { inherit compiler-nix-name; };
     project-flags-stack = callTest ./project-flags/stack.nix {};
-    ghc-options-cabal = callTest ./ghc-options/cabal.nix {};
+    ghc-options-cabal = callTest ./ghc-options/cabal.nix { inherit compiler-nix-name; };
     ghc-options-stack = callTest ./ghc-options/stack.nix {};
-    exe-only = callTest ./exe-only { inherit util; };
+    exe-only = callTest ./exe-only { inherit util compiler-nix-name; };
     stack-source-repo = callTest ./stack-source-repo {};
-    extra-hackage = callTest ./extra-hackage {};
-  #  compiler-nix-name = callTest ./compiler-nix-name {};
-    hls-cabal = callTest ./haskell-language-server/cabal.nix {};
-    hls-stack = callTest ./haskell-language-server/stack.nix {};
-    cabal-hpack = callTest ./cabal-hpack { inherit util; };
+    extra-hackage = callTest ./extra-hackage { inherit compiler-nix-name; };
+    compiler-nix-name = callTest ./compiler-nix-name {};
+    hls-cabal = callTest ./haskell-language-server/cabal.nix { inherit compiler-nix-name; };
+    hls-stack = callTest ./haskell-language-server/stack.nix { inherit compiler-nix-name; };
+    cabal-hpack = callTest ./cabal-hpack { inherit util compiler-nix-name; };
+    index-state = callTest ./index-state { inherit compiler-nix-name; };
 
     unit = unitTests;
   } // lib.optionalAttrs (!stdenv.hostPlatform.isGhcjs && compiler-nix-name != "ghc8101" ) {
     # Pandoc does not build with ghcjs or ghc 8.10.1 yet (lookup-sha256 and fully-static build pandoc)
-    lookup-sha256 = callTest ./lookup-sha256 {};
+    lookup-sha256 = callTest ./lookup-sha256 { inherit compiler-nix-name; };
     fully-static = callTest ./fully-static { inherit (pkgs) buildPackages; };
-  } // lib.optionalAttrs (compiler-nix-name != "ghc8101") {
-    # This test makes a plan for building cabal 3.2 using index-states that will
-    # never work with ghc 8.10.1
-    index-state = callTest ./index-state {};
   } // lib.optionalAttrs (!pkgs.haskell-nix.haskellLib.isCrossHost) {
     # Haddock is not included with cross compilers currently
-    sublib-docs = callTest ./sublib-docs { inherit util; };
+    sublib-docs = callTest ./sublib-docs { inherit util compiler-nix-name; };
   };
 
   # This is the same as allTests, but filter out all the key/vaules from the

test/exe-only/default.nix

@@ -1,10 +1,11 @@
 # Test a package set
-{ stdenv, util, haskell-nix, recurseIntoAttrs, haskellLib, testSrc }:
+{ stdenv, util, haskell-nix, recurseIntoAttrs, haskellLib, testSrc, compiler-nix-name }:
 
 with stdenv.lib;
 
 let
   project = haskell-nix.cabalProject' {
+    inherit compiler-nix-name;
     src = testSrc "exe-only";
   };