Build nonReinstallablePkgs from pre-existing packages in plan.json (input-output-hk#2207)

Author: pranaysashank

changelog.md

@@ -1,6 +1,47 @@
 This file contains a summary of changes to Haskell.nix and `nix-tools`
 that will impact users.
 
+## Jun 5, 2024
+
+Haskell.nix now respects the `pre-existing` packages selected
+by the cabal planner.  The selection made by the planner
+is used to set `nonReinstallablePkgs`.
+
+Instead setting `nonReinstallablePkgs` and `reinstallableLibGhc`
+haskell.nix projects should add `constraints` to the cabal project.
+
+For instance to force the use of the `pre-exising` `text`
+package add:
+
+```
+  constraints: text installed
+```
+
+To make sure `text` is reinstalled use:
+
+```
+  constraints: text source
+```
+
+The `pre-existing` `ghc` will now be used by default as
+that is what `cabal` will choose (haskell.nix used to choose
+`reinstallableLibGhc=true` by default).
+
+To allow cabal to choose reinstalling `ghc` add:
+
+```
+  allow-boot-library-installs: True
+```
+
+To force cabal to choose reinstalling:
+
+```
+  constraints: ghc source
+  allow-boot-library-installs: True
+```
+
+It may also need `allow-newer: ghc:Cabal`
+
 ## Mar 27, 2023
 
 Haskell.nix will no longer parse the `cabal.project` file to

lib/default.nix

@@ -335,7 +335,19 @@ in {
 
   # Converts from a `compoent.depends` value to a library derivation.
   # In the case of sublibs the `depends` value should already be the derivation.
-  dependToLib = d: d.components.library or d;
+  dependToLib = d:
+    # Do simplify this to `d.components.library or d`, as that
+    # will not give a good error message if the `.library`
+    # is missing (happens if the package is unplanned,
+    # but has overrides).
+    # It would be nice to put an `assert` here, but there is
+    # currently no good way to get the name of the dependency
+    # when it is not in the plan.  The attribute path of
+    # `d` in the `nix` error should include the name
+    # eg. `packages.Cabal.components.library`.
+    if d ? components
+      then d.components.library
+      else d;
 
   projectOverlays = import ./project-overlays.nix {
     inherit lib haskellLib;

modules/component-driver.nix

@@ -10,6 +10,11 @@ let
 in
 
 {
+  # Packages in that are `pre-existing` in the cabal plan
+  options.preExistingPkgs = lib.mkOption {
+    type = lib.types.listOf lib.types.str;
+    default = [];
+  };
   # This has a slightly modified option type. We will *overwrite* any previous
   # setting of nonRelocatablePkgs, instead of merging them.  Otherwise you
   # have no chance of removing packages retroactively.  We might improve this
@@ -53,7 +58,11 @@ in
   #
   # without reinstallable-lib:ghc, this is significantly larger.
 
-  config.nonReinstallablePkgs =
+  config.nonReinstallablePkgs = if config.preExistingPkgs != []
+   then ["rts"] ++ config.preExistingPkgs
+    ++ lib.optionals (builtins.compareVersions config.compiler.version "8.11" < 0 && pkgs.stdenv.hostPlatform.isGhcjs) [
+      "ghcjs-prim" "ghcjs-th"]
+   else
     [ "rts" "ghc-prim" "integer-gmp" "integer-simple" "base"
       "array"
       "ghc-boot-th" "template-haskell"

nix-tools/nix-tools/plan2nix/Plan2Nix.hs

@@ -85,7 +85,7 @@ plan2nix args Plan { packages, extras, components, compilerVersion, compilerPack
   -- called from the toplevel project directory.
   cwd <- getCurrentDirectory
   extrasNix <- fmap (mkNonRecSet  . concat) . forM (Map.toList extras) $ \case
-    (_name, Just (Package v flags (Just (LocalPath folder)) False)) ->
+    (_name, Just (Package v flags (Just (LocalPath folder)) False _)) ->
       do cabalFiles <- findCabalFiles (argHpackUse args) folder
          forM cabalFiles $ \cabalFile ->
            let pkg = cabalFilePkgName cabalFile
@@ -95,7 +95,7 @@ plan2nix args Plan { packages, extras, components, compilerVersion, compilerPack
            in do createDirectoryIfMissing True (takeDirectory nixFile)
                  writeDoc nixFile . prettyNix =<< cabal2nix True (argDetailLevel args) src cabalFile
                  return $ fromString pkg $= mkPath False nix
-    (_name, Just (Package v flags (Just (DVCS (Git url rev) subdirs)) False)) ->
+    (_name, Just (Package v flags (Just (DVCS (Git url rev) subdirs)) False _)) ->
       fmap concat . forM subdirs $ \subdir ->
       do cacheHits <- liftIO $ cacheHits (argCacheFile args) url rev subdir
          case cacheHits of
@@ -109,11 +109,14 @@ plan2nix args Plan { packages, extras, components, compilerVersion, compilerPack
                return $ fromString pkg $= mkPath False nix
     _ -> return []
   let flags = concatMap (\case
-          (name, Just (Package _v f _hasDescriptionOverride _)) -> flags2nix name f
+          (name, Just (Package _v f _hasDescriptionOverride _ _)) -> flags2nix name f
           _ -> []) $ Map.toList extras
       -- Set the `planned` option for all components in the plan.
       planned = map (\name -> name <> ".planned" $=
         ("lib" @. "mkOverride" @@ mkInt 900 @@ mkBool True)) $ Set.toList components
+      preExisting = concatMap (\case
+          (name, Just (Package _ _ _ _ True)) -> [mkStr name]
+          _ -> []) $ Map.toList packages
 
   return $ mkNonRecSet [
     "pkgs" $= ("hackage" ==> mkNonRecSet
@@ -126,7 +129,10 @@ plan2nix args Plan { packages, extras, components, compilerVersion, compilerPack
       ])
     , "extras" $= ("hackage" ==> mkNonRecSet [ "packages" $= extrasNix ])
     , "modules" $= mkList [
-        mkParamset [("lib", Nothing)] True ==> mkNonRecSet [ "packages" $= mkNonRecSet flags ]
+        mkNonRecSet [
+          "preExistingPkgs" $= mkList preExisting
+        ]
+      , mkParamset [("lib", Nothing)] True ==> mkNonRecSet [ "packages" $= mkNonRecSet flags ]
       , mkParamset [("lib", Nothing)] True ==> mkNonRecSet [ "packages" $= mkNonRecSet planned ]
       ]
     ]
@@ -200,6 +206,7 @@ value2plan plan = Plan { packages, components, extras, compilerVersion, compiler
           . KeyMap.toList $ KeyMap.mapMaybe (^? _Bool) $ pkg ^. key "flags" . _Object
       , packageSrc      = Nothing
       , packageHasDescriptionOverride = isJust (pkg ^? key "pkg-cabal-sha256")
+      , packagePreExisting = False
       }
 
     (_, "inplace") -> Just $ Package
@@ -208,6 +215,7 @@ value2plan plan = Plan { packages, components, extras, compilerVersion, compiler
           . KeyMap.toList $ KeyMap.mapMaybe (^? _Bool) $ pkg ^. key "flags" . _Object
       , packageSrc      = Nothing
       , packageHasDescriptionOverride = isJust (pkg ^? key "pkg-cabal-sha256")
+      , packagePreExisting = False
       }
     -- Until we figure out how to force Cabal to reconfigure just about any package
     -- this here might be needed, so that we get the pre-existing packages as well.
@@ -220,6 +228,7 @@ value2plan plan = Plan { packages, components, extras, compilerVersion, compiler
       , packageFlags    = Map.empty
       , packageSrc      = Nothing
       , packageHasDescriptionOverride = isJust (pkg ^? key "pkg-cabal-sha256") -- likely this is always false
+      , packagePreExisting = True
       }
     _ -> Nothing
 

nix-tools/nix-tools/plan2nix/Plan2Nix/Plan.hs

@@ -47,4 +47,5 @@ data Package = Package
   , packageFlags :: HashMap VarName Bool
   , packageSrc :: Maybe PkgSrc
   , packageHasDescriptionOverride :: Bool
+  , packagePreExisting :: Bool
   } deriving (Show)