Try #1775:

Author: iohk-bors[bot]

builder/comp-builder.nix

@@ -8,7 +8,6 @@ let self =
 , setup
 , src
 , flags
-, revision
 , cabalFile
 , cabal-generator
 , patches ? []
@@ -246,12 +245,12 @@ let
         && x.identifier.name or "" != "hsc2hs")
       (map
         (p: if builtins.isFunction p
-          then p { inherit  (package.identifier) version; inherit revision; }
+          then p { inherit  (package.identifier) version; }
           else p) build-tools))) ++
     lib.optional (pkgconfig != []) buildPackages.cabalPkgConfigWrapper;
 
   # Unfortunately, we need to wrap ghc commands for cabal builds to
-  # work in the nix-shell. See ../doc/removing-with-package-wrapper.md.
+  # work in the nix-shell. See ../docs/dev/removing-with-package-wrapper.md.
   shellWrappers = ghcForComponent {
     componentName = fullName;
     inherit configFiles enableDWARF;
@@ -301,11 +300,11 @@ let
             ''
         );
     }
-    # patches can (if they like) depend on the version and revision of the package.
+    # patches can (if they like) depend on the version of the package.
     // lib.optionalAttrs (patches != []) {
       patches = map (p:
         if builtins.isFunction p
-          then p { inherit (package.identifier) version; inherit revision; }
+          then p { inherit (package.identifier) version; }
           else p
         ) patches;
     }
@@ -319,7 +318,7 @@ let
 
   haddock = haddockBuilder {
     inherit componentId component package flags commonConfigureFlags
-      commonAttrs revision doHaddock
+      commonAttrs doHaddock
       doHoogle hyperlinkSource quickjump setupHaddockFlags
       needsProfiling configFiles preHaddock postHaddock pkgconfig;
 

builder/haddock-builder.nix

@@ -4,7 +4,6 @@
 , component
 , package
 , flags
-, revision
 , commonAttrs
 , preHaddock
 , postHaddock

builder/hspkg-builder.nix

@@ -9,8 +9,7 @@ config:
 , name
 , sha256
 , src
-, revision
-, revisionSha256
+, cabalFile
 , patches
 
 , shellHook
@@ -48,12 +47,6 @@ let
         # repository.
         inputMap.${__head baseUrlMatch} + "/package/${__elemAt baseUrlMatch 1}"
     else pkg.src;
-  cabalFile = if revision == null || revision == 0 || bundledSrc != null then null else
-    fetchurl {
-      name = "${name}-${toString revision}.cabal";
-      url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal";
-      sha256 = revisionSha256;
-    };
 
   defaultSetupSrc = if stdenv.hostPlatform.isGhcjs then ./Setup.ghcjs.hs else ./Setup.hs;
 
@@ -134,12 +127,12 @@ let
         extraSrcFiles = components.setup.extraSrcFiles ++ [ "Setup.hs" "Setup.lhs" ];
         pkgconfig = if components ? library then components.library.pkgconfig or [] else [];
       };
-      inherit package name src flags revision patches defaultSetupSrc;
+      inherit package name src flags patches defaultSetupSrc;
       inherit (pkg) preUnpack postUnpack;
     };
 
   buildComp = allComponent: componentId: component: comp-builder {
-    inherit allComponent componentId component package name src flags setup cabalFile cabal-generator patches revision
+    inherit allComponent componentId component package name src flags setup cabalFile cabal-generator patches
             shellHook
             ;
   };

lib/cabal-project-parser.nix

@@ -121,99 +121,6 @@ let
         initialText
         ++ (builtins.map (x: x.otherText) repoBlocks));
     };
-
-  # Parse and replace repository
-  # This works in a similar way to the `source-repository-package` but we are
-  # able to simply replace the `repository` blocks with local `file:/nix/store` ones.
-  # This works because `cabal configure` does not include any of the `/nix/sore/`
-  # paths in the `plan.json` (so materialized plan-nix will still work as expeced).
-  # See tests/unit.nix for examples of input and output.
-  parseRepositoryBlock = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: block:
-    let
-      lines = pkgs.lib.splitString "\n" block;
-      # The first line will contain the repository name.
-      x = span (pkgs.lib.strings.hasPrefix " ") (__tail lines);
-      attrs = parseBlockLines x.fst;
-      sha256 = attrs."--sha256" or (
-        if sha256map != null
-          then sha256map."${attrs.url}"
-          else null);
-    in rec {
-      # This is `some-name` from the `repository some-name` line in the `cabal.project` file.
-      name = __head lines;
-      # The $HOME/.cabal/packages/${name} after running `cabal v2-update` to download the repository
-      repoContents = if inputMap ? ${attrs.url}
-        # If there is an input use it to make `file:` url and create a suitable `.cabal/packages/${name}` directory
-        then evalPackages.runCommand name ({
-          nativeBuildInputs = [ cabal-install ] ++ evalPackages.haskell-nix.cabal-issue-8352-workaround;
-          preferLocalBuild = true;
-        }) ''
-            HOME=$(mktemp -d)
-            mkdir -p $HOME/.cabal/packages/${name}
-            cat <<EOF > $HOME/.cabal/config
-            repository ${name}
-              url: file:${inputMap.${attrs.url}}
-              ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}
-              ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}
-              ${pkgs.lib.optionalString (attrs ? key-threshold) "key-threshold: ${attrs.key-threshold}"}
-            EOF
-
-            cabal v2-update ${name}
-            cp -r $HOME/.cabal/packages/${name} $out
-        ''
-        else evalPackages.runCommand name ({
-          nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ] ++ evalPackages.haskell-nix.cabal-issue-8352-workaround;
-          LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";
-          LANG = "en_US.UTF-8";
-          preferLocalBuild = true;
-        } // pkgs.lib.optionalAttrs (sha256 != null) {
-          outputHashMode = "recursive";
-          outputHashAlgo = "sha256";
-          outputHash = sha256;
-        }) ''
-            HOME=$(mktemp -d)
-            mkdir -p $HOME/.cabal/packages/${name}
-            cat <<EOF > $HOME/.cabal/config
-            repository ${name}
-              url: ${attrs.url}
-              ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}
-              ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}
-              ${pkgs.lib.optionalString (attrs ? key-threshold) "key-threshold: ${attrs.key-threshold}"}
-            EOF
-
-            export SSL_CERT_FILE=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt
-            cabal v2-update ${name}
-            cp -r $HOME/.cabal/packages/${name} $out
-        '';
-      # Output of hackage-to-nix
-      hackage = import (
-        evalPackages.runCommand ("hackage-to-nix-" + name) {
-          nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ];
-          LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";
-          LANG = "en_US.UTF-8";
-          preferLocalBuild = true;
-        } ''
-          mkdir -p $out
-          hackage-to-nix $out ${repoContents}/01-index.tar ${attrs.url}
-        '');
-      # Directory to `lndir` when constructing a suitable $HOME/.cabal dir
-      repo = {
-        ${name} = repoContents;
-      };
-    };
-
-  parseRepositories = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: projectFile:
-    let
-      # This will leave the name of repository in the first line of each block
-      blocks = pkgs.lib.splitString "\nrepository " ("\n" + projectFile);
-      repoBlocks = builtins.map (parseRepositoryBlock evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools) (pkgs.lib.lists.drop 1 blocks);
-    in {
-      extra-hackages = pkgs.lib.lists.map (block: block.hackage) repoBlocks;
-      repos = pkgs.lib.lists.foldl' (x: block: x // block.repo) {} repoBlocks;
-    };
-
 in {
-  inherit parseIndexState parseSourceRepositoryPackages parseRepositories
-    # These are only exposed for tests
-    parseSourceRepositoryPackageBlock parseRepositoryBlock;
+  inherit parseIndexState parseSourceRepositoryPackages;
 }

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

@@ -70,7 +70,7 @@ in
 }@args:
 
 let
-  inherit (evalPackages.haskell-nix) materialize dotCabal;
+  inherit (evalPackages.haskell-nix) materialize mkLocalHackageRepo;
 
   # These defaults are hear rather than in modules/cabal-project.nix to make them
   # lazy enough to avoid infinite recursion issues.
@@ -261,10 +261,6 @@ let
       sourceRepoPackageResult = pkgs.haskell-nix.haskellLib.parseSourceRepositoryPackages
         cabalProjectFileName sha256map source-repo-override projectFile;
 
-      # Parse the `repository` blocks
-      repoResult = pkgs.haskell-nix.haskellLib.parseRepositories
-        evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;
-
       # we need the repository content twice:
       # * at eval time (below to build the fixed project file)
       #   Here we want to use evalPackages.fetchgit, so one can calculate
@@ -278,7 +274,6 @@ let
       sourceReposBuild = builtins.map (x: (fetchPackageRepo pkgs.fetchgit x).fetched) sourceRepoPackageResult.sourceRepos;
     in {
       sourceRepos = sourceReposBuild;
-      inherit (repoResult) repos extra-hackages;
       makeFixedProjectFile = ''
         cp -f ${evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project
       '' +
@@ -456,6 +451,44 @@ let
     '';
   };
 
+  fakeCurl = inputMap:
+    let inputMapFile = evalPackages.writeTextFile {
+          name = "fakeCurlInputMap";
+          text = ''
+          ${builtins.concatStringsSep "\n" (pkgs.lib.mapAttrsToList f inputMap)}
+          '';
+        };
+        f = name: index: "${name}\tfile://${index}";
+    in
+      evalPackages.writeShellApplication {
+        name = "curl";
+        text = ''
+          declare -a ARGS
+          ARGS=("''${@}")
+          while read -r uri path; do
+            ARGS=("''${ARGS[@]/$uri/$path}")
+          done <${inputMapFile}
+          ${pkgs.curl}/bin/curl "''${ARGS[@]}" >/dev/null
+          echo 200
+        '';
+      };
+
+  hackageRepo = { index-state, sha256 }:
+    assert sha256 != null;
+    let at = builtins.replaceStrings [ ":" ] [ "" ] index-state;
+    in mkLocalHackageRepo {
+      name = "hackage.haskell.org";
+      index = pkgs.fetchurl {
+        name = "01-index.tar.gz-at-${at}";
+        url = "https://hackage.haskell.org/01-index.tar.gz";
+        downloadToTemp = true;
+        postFetch =
+          "${nix-tools}/bin/truncate-index -o $out -i $downloadedFile -s ${index-state}";
+        outputHashAlgo = "sha256";
+        outputHash = sha256;
+      };
+    };
+
   plan-nix = materialize ({
     inherit materialized;
     sha256 = plan-sha256;
@@ -484,6 +517,8 @@ let
       "freeze"  # The `cabal.project.freeze` file created by `cabal v2-freeze`
     ];
   } ''
+    set -e
+
     tmp=$(mktemp -d)
     cd $tmp
     # if cleanedSource is empty, this means it's a new
@@ -527,23 +562,31 @@ let
     export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt
     export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt
 
-    # Using `cabal v2-freeze` will configure the project (since
-    # it is not configured yet), taking the existing `cabal.project.freeze`
-    # file into account.  Then it "writes out a freeze file which
-    # records all of the versions and flags that are picked" (from cabal docs).
+    export CABAL_DIR=$(mktemp -d)
+
+    cat >$CABAL_DIR/config <<EOF
+    repository hackage.haskell.org
+      url: http://hackage.haskell.org/
+      secure: True
+      root-keys: aaa
+      key-threshold: 0
+    EOF
+    cat $CABAL_DIR/config
+
+    echo "Installing fake curl"
+    PATH=${
+      fakeCurl ({
+        "http://hackage.haskell.org" = hackageRepo { index-state = cached-index-state; sha256 = index-sha256-found; };
+      } // inputMap)
+    }/bin:$PATH
+
+    cabal update \
+        -w ${ghc.targetPrefix}ghc \
+        --with-ghc-pkg=${ghc.targetPrefix}ghc-pkg
+
     echo "Using index-state ${index-state-found}"
-    HOME=${
-      # This creates `.cabal` directory that is as it would have
-      # been at the time `cached-index-state`.  We may include
-      # some packages that will be excluded by `index-state-found`
-      # which is used by cabal (cached-index-state >= index-state-found).
-      dotCabal {
-        inherit cabal-install nix-tools extra-hackage-tarballs;
-        extra-hackage-repos = fixedProject.repos;
-        index-state = cached-index-state;
-        sha256 = index-sha256-found;
-      }
-    } cabal v2-freeze ${
+
+    make-install-plan ${
           # Setting the desired `index-state` here in case it is not
           # in the cabal.project file. This will further restrict the
           # packages used by the solver (cached-index-state >= index-state-found).
@@ -596,6 +639,11 @@ let
     # as they should not be in the output hash (they may change slightly
     # without affecting the nix).
     find $out \( -type f -or -type l \) ! -name '*.nix' -delete
+
+    # Make the revised cabal files available (after the delete step avove)
+    echo "Moving cabal files from $tmp${subDir'}/dist-newstyle/cabal-files to $out${subDir'}/cabal-files"
+    mv $tmp${subDir'}/dist-newstyle/cabal-files $out${subDir'}/cabal-files
+
     # Remove empty dirs
     find $out -type d -empty -delete
 
@@ -606,5 +654,5 @@ in {
   projectNix = plan-nix;
   index-state = index-state-found;
   inherit src;
-  inherit (fixedProject) sourceRepos extra-hackages;
+  inherit (fixedProject) sourceRepos;
 }