Add compiler-nix-name to cabalProject

docs/user-guide.md

@@ -94,11 +94,11 @@ If your project has a `cabal.project` you can add a `default.nix` like this:
 
 ```nix
 { pkgs ? import <nixpkgs> (import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {}).nixpkgsArgs
-, haskellCompiler ? "ghc865"
+, compiler-nix-name ? "ghc865"
 }:
   pkgs.haskell-nix.cabalProject {
     src = pkgs.haskell-nix.haskellLib.cleanGit { src = ./.; };
-    ghc = pkgs.buildPackages.pkgs.haskell-nix.compiler.${haskellCompiler};
+    inherit compiler-nix-name;
     # pkg-def-extras = [
     #   # Additional packages ontop of all those listed in `cabal.project`
     # ];

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

@@ -7,7 +7,9 @@
 , 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
 , cabalProject  ? null # Cabal project file (when null uses "${src}/cabal.project")
-, ghc           ? defaults.ghc
+, compiler-nix-name ? null # Nix name of the ghc compiler as a string eg. "ghc883"
+, 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
@@ -31,11 +33,31 @@ assert (if (builtins.compareVersions cabal-install.version "2.4.0.0") < 0
          then throw "cabal-install (current version: ${cabal-install.version}) needs to be at least 2.4 for plan-to-nix to work without cabal-to-nix"
          else true);
 
-assert (if ghc.isHaskellNixCompiler or false then true
-  else throw ("It is likely you used `haskell.compiler.X` instead of `haskell-nix.compiler.X`"
-    + pkgs.lib.optionalString (name != null) (" for " + name)));
+let
+  forName = pkgs.lib.optionalString (name != null) (" for " + name);
+
+  ghc' =
+    if ghcOverride != null
+      then ghcOverride
+      else
+        if ghc != null
+          then __trace ("WARNING: A `ghc` argument was passed" + forName
+            + " this has been deprecated in favour of `compiler-nix-name`. "
+            + "Using `ghc` will break cross compilation setups, as haskell.nix can not"
+            + "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
+              then pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}"
+              else defaults.ghc;
+
+in
+  assert (if ghc'.isHaskellNixCompiler or false then true
+    else throw ("It is likely you used `haskell.compiler.X` instead of `haskell-nix.compiler.X`"
+      + forName));
 
 let
+  ghc = ghc';
   maybeCleanedSource =
     if haskellLib.canCleanSource src
     then haskellLib.cleanSourceWith {

overlays/bootstrap.nix

@@ -384,7 +384,7 @@ in {
             # to build ghcs from source.
             alex-project = hackage-project {
                 # Only a boot compiler is suitable here
-                ghc = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
+                ghcOverride = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
                 inherit (bootstrap.packages) cabal-install nix-tools hpack;
                 name = "alex"; version = "3.2.4";
                 index-state = final.haskell-nix.internalHackageIndexState;
@@ -393,7 +393,7 @@ in {
             alex = bootstrap.packages.alex-project.hsPkgs.alex.components.exes.alex;
             happy-project = hackage-project {
                 # Only a boot compiler is suitable here
-                ghc = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
+                ghcOverride = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
                 inherit (bootstrap.packages) cabal-install nix-tools hpack;
                 name = "happy"; version = "1.19.11";
                 index-state = final.haskell-nix.internalHackageIndexState;
@@ -402,7 +402,7 @@ in {
             happy = bootstrap.packages.happy-project.hsPkgs.happy.components.exes.happy;
             hscolour-project = hackage-project {
                 # Only a boot compiler is suitable here
-                ghc = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
+                ghcOverride = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
                 inherit (bootstrap.packages) cabal-install nix-tools hpack;
                 name = "hscolour"; version = "1.24.4";
                 index-state = final.haskell-nix.internalHackageIndexState;

overlays/ghc-packages.nix

@@ -172,7 +172,7 @@ in rec {
         if __pathExists materializedPath
           then materializedPath
           else null;
-      ghc = final.buildPackages.haskell-nix.compiler.${ghcName};
+      ghcOverride = final.buildPackages.haskell-nix.compiler.${ghcName};
       configureArgs = "--disable-tests"; # avoid failures satisfying bytestring package tests dependencies
     })
     ghc-extra-pkgs-cabal-projects;

overlays/haskell.nix

@@ -463,7 +463,10 @@ final: prev: {
                 { plan-pkgs = plan.pkgs;
                   pkg-def-extras = args.pkg-def-extras or [];
                   modules = (args.modules or [])
-                          ++ final.lib.optional (args ? ghc) { ghc.package = args.ghc; };
+                          ++ final.lib.optional (args ? ghcOverride || args ? ghc)
+                              { ghc.package = args.ghcOverride or args.ghc; }
+                          ++ final.lib.optional (args ? compiler-nix-name)
+                              { compiler.nix-name = args.compiler-nix-name; };
                   extra-hackages = args.extra-hackages or [];
                 };
             in { inherit (pkg-set.config) hsPkgs; inherit pkg-set; plan-nix = plan.nix; };

test/compiler-nix-name/Main.hs

@@ -0,0 +1,5 @@
+{-# LANGUAGE CPP #-}
+module Main where
+
+main :: IO ()
+main = print __GLASGOW_HASKELL__

test/compiler-nix-name/compiler-nix-name.cabal

@@ -0,0 +1,11 @@
+cabal-version:       >=1.10
+name:                compiler-nix-name
+version:             0.1.0.0
+license:             PublicDomain
+author:              Hamish Mackenzie
+build-type:          Simple
+
+executable compiler-nix-name
+  main-is:             Main.hs
+  build-depends:       base >=4.13 && <4.14
+  default-language:    Haskell2010

test/compiler-nix-name/default.nix

@@ -0,0 +1,40 @@
+{ stdenv, haskell-nix, recurseIntoAttrs, testSrc }:
+
+with stdenv.lib;
+
+let
+  project = haskell-nix.cabalProject' {
+    src = testSrc "compiler-nix-name";
+    compiler-nix-name = "ghc883";
+  };
+
+  packages = project.hsPkgs;
+  compiler-nix-name =
+    packages.compiler-nix-name.components.exes.compiler-nix-name;
+
+in recurseIntoAttrs {
+  ifdInputs = {
+    inherit (project) plan-nix;
+  };
+
+  run = stdenv.mkDerivation {
+    name = "compiler-nix-name-test";
+
+    buildCommand = ''
+      exe="${compiler-nix-name}/bin/compiler-nix-name${stdenv.hostPlatform.extensions.executable}"
+      if [[ "$(${toString compiler-nix-name.config.testWrapper} $exe)" != "808" ]]; then
+        echo "Unexpected GHC version" >& 2
+        false
+      else
+        touch $out
+      fi
+    '';
+
+    meta.platforms = platforms.all;
+
+    passthru = {
+      # Used for debugging with nix repl
+      inherit project packages;
+    };
+  };
+}

test/default.nix

@@ -176,6 +176,7 @@ let
     stack-source-repo = callTest ./stack-source-repo {};
     lookup-sha256 = callTest ./lookup-sha256 {};
     extra-hackage = callTest ./extra-hackage {};
+    compiler-nix-name = callTest ./compiler-nix-name {};
 
     unit = unitTests;
   };