Remove internal deps on default ghc and stackage

build.nix

@@ -5,27 +5,26 @@
 let
   haskellNix = (import ./default.nix {});
 in
-{ nixpkgs ? haskellNix.sources.nixpkgs-default
+{ nixpkgs ? haskellNix.sources.nixpkgs
 , 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;
 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";
     }
   );
 
@@ -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.
@@ -44,7 +44,7 @@ let
 
   hoogleLocal = let
     nixpkgsHoogle = import (pkgs.path + /pkgs/development/haskell-modules/hoogle.nix);
-  in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool "hoogle" {
+  in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool compiler.nix-name "hoogle" {
         version = "5.0.17.15";
         index-state = pkgs.haskell-nix.internalHackageIndexState;
       }
@@ -59,9 +59,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,28 @@
 This file contains a summary of changes to Haskell.nix and `nix-tools`
 that will impact users.
 
+## July ?, 2019
+* Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead.
+* Removed `./nixpkgs` directory, use  `(import ./. {}).sources`
+  or `./nix/sources.nix` instead.
+* Removes V1 interface for details on how to fix old code see:
+    https://github.com/input-output-hk/haskell.nix/issues/709
+* Removed defaultCompilerNixName.
+* cabalProject, cabalProject', hackage-project and hackage-package
+  now require a `compiler-nix-name` argument.
+* `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument.
+  New functions `p.tool` and `p.tools` (where p is a project) do not.
+  Like `shellFor { tools = ... }` they will use the compiler nix name
+  from the project (including stack projects where it is derived from
+  the resolver).
+* `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use
+  `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`.
+* `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes
+  the hpack exe now).
+* `haskell-nix.cabal-install` -> 
+  `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }`
+* `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots`
+
 ## June 25, 2019
 * Haddock docs are now built in their own derivation when needed (not as part
   of the component build).

ci-lib.nix

@@ -1,6 +1,6 @@
 let
   # Generic nixpkgs, use *only* for lib functions that are stable across versions
-  pkgs = import (import ./nixpkgs/default.nix).nixpkgs-default {};
+  pkgs = import (import ./nix/sources.nix).nixpkgs {};
   lib = pkgs.lib;
 in rec {
   inherit (import ./dimension.nix) dimension;

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;
+          hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit compiler-nix-name; }).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
@@ -75,13 +75,13 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
               then build.tests
               else pkgs.recurseIntoAttrs {
                 # Even on aarch64 we still want to build the pinned files
-                inherit (build.tests) haskellNixRoots;
+                inherit (build.tests) roots;
               };
         } // 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;
+          hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit compiler-nix-name; }).components.exes.hello;
         })
       )
     )

default.nix

@@ -1,56 +1,28 @@
-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;
-
-    config   = import ./config.nix;
-    overlays = [ allOverlays.combined ] ++ (
-      if checkMaterialization == true
-        then [(
-          final: prev: {
-            haskell-nix = prev.haskell-nix // {
-              checkMaterialization = true;
-            };
-          }
-        )]
-        else []
-    ) ++ (
-      if defaultCompilerNixName != null
-        then [(
-          final: prev: {
-            haskell-nix = prev.haskell-nix // {
-              inherit defaultCompilerNixName;
-            };
-          }
-        )]
-        else []
-    );
-    allOverlays = import ./overlays args;
-    nixpkgsArgs = { inherit config overlays system; };
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
-  };
-
-  v1DeprecationMessage = "Version 1 is deprecated: use version 2 (nixpkgs arguments are available as the `nixpkgsArgs` attribute of version 2)";
-  haskellNixV1 = (haskellNix {}).nixpkgsArgs // {
-    overlays = builtins.trace v1DeprecationMessage (haskellNix {}).nixpkgsArgs.overlays;
-  };
-  haskellNixV2 = haskellNix;
-
-# If no arguments, then you get V1
-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:
-    if version == 1
-    then haskellNixV1
-    else if version == 2
-    then haskellNixV2 args
-    else builtins.throw ("haskell.nix: unknown version: " + (builtins.toString version));
+{ checkMaterialization ? false  # Allows us to easily switch on materialization checking
+, system ? builtins.currentSystem
+, sourcesOverride ? {}
+, ... }@args: rec {
+  sources  = (import ./nix/sources.nix) // sourcesOverride;
+  config   = import ./config.nix;
+  overlays = [ allOverlays.combined ] ++ (
+    if checkMaterialization == true
+      then [(
+        final: prev: {
+          haskell-nix = prev.haskell-nix // {
+            checkMaterialization = true;
+          };
+        }
+      )]
+      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 nixpkgsArgs;
 }

docs/troubleshooting.md

@@ -66,6 +66,7 @@ So this is expected, unfortunately.
 
 ### How do I prevent the evaluation-time dependencies of my project from being garbage-collected?
 
-The `haskellNixRoots` attribute should include all the evaluation-time dependencies.
+The `haskell-nix.roots "ghc883"` should include all the evaluation-time dependencies
+and the main build time dependecies of a project using ghc 8.8.3.
 So you can add that to the relevant GC root.
 In practice, if you're using a CI system like Hydra/Hercules, this means adding it to a job in `release.nix`/`ci.nix`.

docs/tutorials/getting-started.md

@@ -52,6 +52,8 @@ Add `default.nix`:
     name = "haskell-nix-project";
     src = ./.;
   };
+  # For `cabal.project` based projects specify the GHC version to use.
+  compiler-nix-name = "ghc883"; # Not used for `stack.yaml` based projects.
 }
 ```
 

docs/tutorials/materialization.md

@@ -40,8 +40,9 @@ file that looks like this:
 
 ```nix
 let inherit (import ./. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
+    pkgs = import sources.nixpkgs nixpkgsArgs;
     hlint = pkgs.haskell-nix.hackage-package {
+      compiler-nix-name = "ghc883";
       name = "hlint";
       version = "2.2.11";
     };
@@ -64,8 +65,9 @@ inputs.  For cabal projects this means we must specify the
 
 ```nix
 let inherit (import ./. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
+    pkgs = import sources.nixpkgs nixpkgsArgs;
     hlint = pkgs.haskell-nix.hackage-package {
+      compiler-nix-name = "ghc883";
       name = "hlint";
       version = "2.2.11";
       index-state = "2020-04-15T00:00:00Z";
@@ -92,8 +94,9 @@ stack projects)
 
 ```nix
 let inherit (import ./. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
+    pkgs = import sources.nixpkgs nixpkgsArgs;
     hlint = pkgs.haskell-nix.hackage-package {
+      compiler-nix-name = "ghc883";
       name = "hlint";
       version = "2.2.11";
       index-state = "2020-04-15T00:00:00Z";
@@ -121,8 +124,9 @@ To capture the nix we can do something like:
 
 ```nix
 let inherit (import ./. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
+    pkgs = import sources.nixpkgs nixpkgsArgs;
     hlint = pkgs.haskell-nix.hackage-package {
+      compiler-nix-name = "ghc883";
       name = "hlint";
       version = "2.2.11";
       index-state = "2020-04-15T00:00:00Z";
@@ -155,8 +159,9 @@ If we choose to add the `checkMaterialization` flag you would have:
 
 ```nix
 let inherit (import ./. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
+    pkgs = import sources.nixpkgs nixpkgsArgs;
     hlint = pkgs.haskell-nix.hackage-package {
+      compiler-nix-name = "ghc883";
       name = "hlint";
       version = "2.2.10";
       index-state = "2020-04-15T00:00:00Z";
@@ -199,8 +204,9 @@ For instance:
 
 ```nix
 let inherit (import ./. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
+    pkgs = import sources.nixpkgs nixpkgsArgs;
     hlint = pkgs.haskell-nix.hackage-project {
+      compiler-nix-name = "ghc883";
       name = "hlint";
       version = "2.2.10";
       index-state = "2020-04-15T00:00:00Z";
@@ -236,9 +242,10 @@ a non-existing path is now an error:
 
 ```nix
 let inherit (import ./. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default nixpkgsArgs;
+    pkgs = import sources.nixpkgs nixpkgsArgs;
     hlintPlan = /nix/store/kk047cqsjvbj4w8psv4l05abdcnyrqdc-hlint-plan-to-nix-pkgs;
     hlint = pkgs.haskell-nix.hackage-package {
+      compiler-nix-name = "ghc883";
       name = "hlint";
       version = "2.2.11";
       index-state = "2020-04-15T00:00:00Z";

examples/cardano-sl-mingw32.nix

@@ -1,3 +1,3 @@
 let inherit (import ../. {}) sources nixpkgsArgs;
-    pkgs = import sources.nixpkgs-default (nixpkgsArgs // { crossSystem.config = "x86_64-pc-mingw32"; });
+    pkgs = import sources.nixpkgs (nixpkgsArgs // { crossSystem.config = "x86_64-pc-mingw32"; });
 in (pkgs.haskell-nix.stackProject (import ./cardano-sl-args.nix)).cardano-sl.components.all