Remove internal deps on default ghc and stackage

build.nix

@@ -9,23 +9,22 @@ in
 , nixpkgsArgs ? haskellNix.nixpkgsArgs
 , pkgs ? import nixpkgs nixpkgsArgs
 , ifdLevel ? 1000
+, compiler-nix-name ? "ghc865"
 }:
 
 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 (compiler-nix-name != "ghc8101") {
+      ghcide-object-code = tool compiler-nix-name "ghcide" "object-code";
     }
   );
 
@@ -34,8 +33,8 @@ in rec {
   # as not all of them can work in restricted eval mode (as they
   # are not pure).
   maintainer-scripts = pkgs.dontRecurseIntoAttrs {
-    update-hackage = haskell.callPackage ./scripts/update-hackage.nix {};
-    update-stackage = haskell.callPackage ./scripts/update-stackage.nix {};
+    update-hackage = haskell.callPackage ./scripts/update-hackage.nix { inherit compiler-nix-name; };
+    update-stackage = haskell.callPackage ./scripts/update-stackage.nix { inherit compiler-nix-name; };
     update-pins = haskell.callPackage ./scripts/update-pins.nix {};
     update-docs = pkgs.buildPackages.callPackage ./scripts/update-docs.nix {
       generatedOptions = pkgs.callPackage ./scripts/options-doc.nix { };
@@ -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
@@ -94,7 +94,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";

changelog.md

@@ -1,6 +1,13 @@
 This file contains a summary of changes to Haskell.nix and `nix-tools`
 that will impact users.
 
+## July ?, 2019
+* Removes most internal use of defaultCompilerNixName and adds warnings
+  advising how to do the same to code that uses haskell.nix.
+  Code using `haskell-nix` attributes `cabal-install`, `nix-tools`, `alex`,
+  `happy` must be updated to use one of `haskell-nix.cabal-install.ghc865`,
+  `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }`
+
 ## June 25, 2019
 * Haddock docs are now built in their own derivation when needed (not as part
   of the component build).

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; };
+            build = import ./build.nix { inherit pkgs ifdLevel compiler-nix-name; };
         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;
         })

default.nix

@@ -1,10 +1,11 @@
 let haskellNix = {
       checkMaterialization ? false,  # Allows us to easily switch on materialization checking
-      defaultCompilerNixName ? null, # Quick way to override the default compiler e.g. "ghc883"
       system ? builtins.currentSystem,
       sourcesOverride ? {},
       ... }@args: rec {
-    sources = (import ./nix/sources.nix) // sourcesOverride;
+    sources = { nixpkgs-default = sources.nixpkgs; }
+      // (import ./nix/sources.nix)
+      // sourcesOverride;
 
     config   = import ./config.nix;
     overlays = [ allOverlays.combined ] ++ (
@@ -18,16 +19,23 @@ let haskellNix = {
         )]
         else []
     ) ++ (
-      if defaultCompilerNixName != null
+      if args ? defaultCompilerNixName
         then [(
           final: prev: {
             haskell-nix = prev.haskell-nix // {
-              inherit defaultCompilerNixName;
+              userCompilerNixName = args.defaultCompilerNixName;
             };
           }
         )]
         else []
-    );
+    ) ++ [(
+      final: prev: {
+        haskell-nix = prev.haskell-nix // {
+          inherit overlays;
+          sources = prev.haskell-nix.sources // sourcesOverride;
+        };
+      }
+    )];
     allOverlays = import ./overlays args;
     nixpkgsArgs = { inherit config overlays system; };
     pkgs = import sources.nixpkgs-default nixpkgsArgs;
@@ -44,7 +52,6 @@ in haskellNixV1 // {
   __functor = _: {
       version ? 2,
       checkMaterialization ? false,  # Allows us to easily switch on materialization checking
-      defaultCompilerNixName ? null, # Quick way to override the default compiler e.g. "ghc883"
       system ? builtins.currentSystem,
       sourcesOverride ? {},
       ... }@args:

lib/call-cabal-project-to-nix.nix

@@ -1,4 +1,4 @@
-{ dotCabal, pkgs, runCommand, nix-tools, cabal-install, ghc, hpack, symlinkJoin, cacert, index-state-hashes, haskellLib, materialize }@defaults:
+{ dotCabal, pkgs, runCommand, evalPackages, symlinkJoin, cacert, index-state-hashes, haskellLib, materialize }@defaults:
 let readIfExists = src: fileName:
       let origSrcDir = src.origSrcSubDir or src;
       in
@@ -17,12 +17,15 @@ in
 , cabalProject         ? readIfExists src cabalProjectFileName
 , cabalProjectLocal    ? readIfExists src "${cabalProjectFileName}.local"
 , cabalProjectFreeze   ? readIfExists src "${cabalProjectFileName}.freeze"
-, compiler-nix-name ? null # Nix name of the ghc compiler as a string eg. "ghc883"
+, caller               ? "callCabalProjectToNix" # Name of the calling funcion for better warning messages
+, compiler-nix-name ? # Nix name of the ghc compiler as a string eg. "ghc883"
+    pkgs.haskell-nix.defaultCompilerNixNameWithWarning (default:
+        "While building ${if name != null then "${name} " else ""}(using ${default}).  "
+      + "Please consider adding `compiler-nix-name = \"${default}\";` to the call to `${caller}`.")
 , ghc           ? null # Deprecated in favour of `compiler-nix-name`
 , ghcOverride   ? null # Used when we need to set ghc explicitly during bootstrapping
-, nix-tools     ? defaults.nix-tools
-, hpack         ? defaults.hpack
-, cabal-install ? defaults.cabal-install
+, nix-tools     ? evalPackages.haskell-nix.nix-tools.${compiler-nix-name}
+, cabal-install ? evalPackages.haskell-nix.cabal-install.${compiler-nix-name}
 , configureArgs ? "" # Extra arguments to pass to `cabal v2-configure`.
                      # `--enable-tests --enable-benchmarks` are included by default.
                      # If the tests and benchmarks are not needed and they
@@ -56,7 +59,6 @@ let
             + "pick the correct `ghc` package from the respective buildPackages. "
             + "For example use `compiler-nix-name = \"ghc865\";` for ghc 8.6.5") ghc
           else
-            if compiler-nix-name != null
               # Do note that `pkgs = final.buildPackages` in the `overlays/haskell.nix`
               # call to this file. And thus `pkgs` here is the proper `buildPackages`
               # set and we do not need, nor should pick the compiler from another level
@@ -65,8 +67,7 @@ let
               #
               # > The option `packages.Win32.package.identifier.name' is used but not defined.
               #
-              then pkgs.haskell-nix.compiler."${compiler-nix-name}"
-              else defaults.ghc;
+              pkgs.haskell-nix.compiler."${compiler-nix-name}";
 
 in
   assert (if ghc'.isHaskellNixCompiler or false then true
@@ -386,7 +387,7 @@ let
   } // pkgs.lib.optionalAttrs (checkMaterialization != null) {
     inherit checkMaterialization;
   }) (pkgs.evalPackages.runCommand (if name == null then "plan-to-nix-pkgs" else name + "-plan-to-nix-pkgs") {
-    nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg hpack cabal-install pkgs.evalPackages.rsync ];
+    nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install pkgs.evalPackages.rsync ];
     # Needed or stack-to-nix will die on unicode inputs
     LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";
     LANG = "en_US.UTF-8";

lib/call-stack-to-nix.nix

@@ -5,7 +5,7 @@
  *
  * see also `call-cabal-project-to-nix`!
  */
-{ runCommand, nix-tools, pkgs, mkCacheFile, materialize, haskellLib }:
+{ runCommand, pkgs, mkCacheFile, materialize, haskellLib }:
 { name ? src.name or null # optional name for better error messages
 , src
 , stackYaml ? "stack.yaml"
@@ -15,6 +15,7 @@
 , resolverSha256 ? 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
+, nix-tools ? pkgs.haskell-nix.nix-tools.${pkgs.haskell-nix.internalDefaultCompilerNixName}
 , ... }:
 let
   inherit (haskellLib.fetchResolver {

lib/stack-cache-generator.nix

@@ -1,6 +1,6 @@
 # Generate cache entries for dependencies of package defined in `src`
 
-{ pkgs, haskellLib, nix-tools }:
+{ pkgs, haskellLib }:
 { src
 , stackYaml    ? "stack.yaml"
 , sha256map    ? null
@@ -14,6 +14,8 @@
     then { location, tag, ...}: sha256map."${location}"."${tag}"
     else _: null
 , resolverSha256 ? null
+, checkMaterialization ? null
+, nix-tools ? pkgs.haskell-nix.nix-tools.${pkgs.haskell-nix.internalDefaultCompilerNixName}
 , ...
 }:
 let