Include hsPkgs."${name}-${version}"

Author: hamishmack

lib/load-cabal-plan.nix

@@ -22,7 +22,7 @@ let
   lookupDependency = hsPkgs: d:
     pkgs.lib.optional (by-id.${d}.type != "pre-existing") (
         if by-id.${d}.component-name or "lib" == "lib"
-          then hsPkgs.${d} or hsPkgs.${by-id.${d}.pkg-name}
+          then hsPkgs.${d} or hsPkgs."${by-id.${d}.pkg-name}-${by-id.${d}.pkg-version}" or hsPkgs.${by-id.${d}.pkg-name}
           else hsPkgs.${d}.components.sublibs.${pkgs.lib.removePrefix "lib:" by-id.${d}.component-name});
   # Lookup an executable dependency in `hsPkgs.pkgsBuildBuild`
   lookupExeDependency = hsPkgs: d:
@@ -157,4 +157,4 @@ in {
     (import ../modules/install-plan/planned.nix { inherit getComponents; })
     (import ../modules/install-plan/redirect.nix)
   ];
-}
+}

modules/install-plan/redirect.nix

@@ -1,6 +1,45 @@
 # Add `hsPkgs.${pkg-name}` based on the available targets in the plan.
-{pkgs, lib, config, ...}: {
-  hsPkgs = builtins.removeAttrs (builtins.mapAttrs (packageName: packageTargets:
+{pkgs, lib, config, ...}:
+let
+  redirect = redirectName: packageTargets:
+    let
+      componentsByName = builtins.listToAttrs (map (x: { name = x.component-name; value = x.available; }) packageTargets);
+      lookupComponent = collectionName: name: available:
+        let attrPath =
+          if collectionName == ""
+            then "${redirectName}.components.library"
+            else "${redirectName}.components.${collectionName}.${name}";
+        in if builtins.length available != 1
+          then throw "Multiple avaialble targets for ${attrPath}"
+        else if builtins.isString (builtins.head available)
+          then throw "${builtins.head available} looking for ${attrPath}"
+        else if collectionName == ""
+          then config.hsPkgs.${(builtins.head available).id}.components.library
+        else config.hsPkgs.${(builtins.head available).id}.components.${collectionName}.${name};
+      componentsWithPrefix = collectionName: prefix:
+        lib.listToAttrs (lib.concatLists (lib.mapAttrsToList (n: available:
+          lib.optional (lib.hasPrefix "${prefix}:" n && (builtins.length available != 1 || !builtins.elem (builtins.head available) ["TargetNotBuildable" "TargetNotLocal"])) (
+            let
+              name = lib.removePrefix "${prefix}:" n;
+              value = lookupComponent collectionName name available;
+            in { inherit name value; }
+          )) componentsByName));
+    in rec {
+      isRedirect = true;
+      identifier = rec { name = (builtins.head packageTargets).pkg-name; version = (builtins.head packageTargets).pkg-version; id = "${name}-${version}"; };
+      components =
+        lib.mapAttrs componentsWithPrefix pkgs.haskell-nix.haskellLib.componentPrefix
+        // lib.optionalAttrs (componentsByName ? lib) {
+          library = lookupComponent "" "" componentsByName.lib;
+        };
+      checks = pkgs.recurseIntoAttrs (builtins.mapAttrs
+        (_: d: pkgs.haskell-nix.haskellLib.check d)
+          (lib.filterAttrs (_: d: d.config.doCheck) components.tests));
+    };
+in {
+  hsPkgs =
+    # Redirects with just the package name
+    builtins.removeAttrs (builtins.mapAttrs (packageName: packageTargets:
       let
         byVersion = builtins.groupBy (x: x.pkg-version) packageTargets;
         versions = builtins.attrNames byVersion;
@@ -13,39 +52,9 @@
             components = err;
             checks = err;
           }
-        else let
-            componentsByName = builtins.listToAttrs (map (x: { name = x.component-name; value = x.available; }) packageTargets);
-            lookupComponent = collectionName: name: available:
-              let attrPath =
-                if collectionName == ""
-                  then "${packageName}.components.library"
-                  else "${packageName}.components.${collectionName}.${name}";
-              in if builtins.length available != 1
-                then throw "Multiple avaialble targets for ${attrPath}"
-              else if builtins.isString (builtins.head available)
-                then throw "${builtins.head available} looking for ${attrPath}"
-              else if collectionName == ""
-                then config.hsPkgs.${(builtins.head available).id}.components.library
-              else config.hsPkgs.${(builtins.head available).id}.components.${collectionName}.${name};
-            componentsWithPrefix = collectionName: prefix:
-              lib.listToAttrs (lib.concatLists (lib.mapAttrsToList (n: available:
-                lib.optional (lib.hasPrefix "${prefix}:" n && (builtins.length available != 1 || !builtins.elem (builtins.head available) ["TargetNotBuildable" "TargetNotLocal"])) (
-                  let
-                    name = lib.removePrefix "${prefix}:" n;
-                    value = lookupComponent collectionName name available;
-                  in { inherit name value; }
-                )) componentsByName));
-          in rec {
-              isRedirect = true;
-              identifier = rec { name = packageName; version = builtins.head versions; id = "${name}-${version}"; };
-              components =
-                lib.mapAttrs componentsWithPrefix pkgs.haskell-nix.haskellLib.componentPrefix
-                // lib.optionalAttrs (componentsByName ? lib) {
-                  library = lookupComponent "" "" componentsByName.lib;
-                };
-              checks = pkgs.recurseIntoAttrs (builtins.mapAttrs
-                (_: d: pkgs.haskell-nix.haskellLib.check d)
-                  (lib.filterAttrs (_: d: d.config.doCheck) components.tests));
-            })
-          (builtins.groupBy (x: x.pkg-name) config.plan-json.targets)) config.preExistingPkgs;
+        else redirect packageName packageTargets) (builtins.groupBy (x: x.pkg-name) config.plan-json.targets)) config.preExistingPkgs
+
+    # Redirect for `${name}-${version}`
+    // builtins.mapAttrs (packageNameAndVersion: packageTargets: redirect packageNameAndVersion packageTargets)
+          (builtins.groupBy (x: "${x.pkg-name}-${x.pkg-version}") config.plan-json.targets);
 }