Lazy trees

.github/workflows/ci.yml

@@ -208,3 +208,23 @@ jobs:
       # Only meson packages that don't have a tests.run derivation.
       # Those that have it are already built and tested as part of nix flake check.
       - run: nix build -L .#hydraJobs.build.{nix-cmd,nix-main}.$(nix-instantiate --eval --expr builtins.currentSystem | sed -e 's/"//g')
+
+  flake_regressions:
+    needs: vm_tests
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout nix
+        uses: actions/checkout@v4
+      - name: Checkout flake-regressions
+        uses: actions/checkout@v4
+        with:
+          repository: DeterminateSystems/flake-regressions
+          path: flake-regressions
+      - name: Checkout flake-regressions-data
+        uses: actions/checkout@v4
+        with:
+          repository: DeterminateSystems/flake-regressions-data
+          path: flake-regressions/tests
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+      - run: nix build --out-link ./new-nix && PATH=$(pwd)/new-nix/bin:$PATH scripts/flake-regressions.sh

scripts/flake-regressions.sh

@@ -0,0 +1,33 @@
+#! /usr/bin/env bash
+
+set -e
+
+echo "Nix version:"
+nix --version
+
+cd flake-regressions
+
+status=0
+
+flakes=$(find tests -mindepth 3 -maxdepth 3 -type d -not -path '*/.*' | sort | head -n50)
+
+echo "Running flake tests..."
+
+for flake in $flakes; do
+
+    # This test has a bad flake.lock that doesn't include
+    # `lastModified` for its nixpkgs input. (#10612)
+    if [[ $flake == tests/the-nix-way/nome/0.1.2 ]]; then
+        continue
+    fi
+
+    if ! REGENERATE=0 ./eval-flake.sh "$flake"; then
+        status=1
+        echo "❌ $flake"
+    else
+        echo "✅ $flake"
+    fi
+
+done
+
+exit "$status"

src/libcmd/common-eval-args.cc

@@ -26,8 +26,8 @@ EvalSettings evalSettings {
                 // FIXME `parseFlakeRef` should take a `std::string_view`.
                 auto flakeRef = parseFlakeRef(std::string { rest }, {}, true, false);
                 debug("fetching flake search path element '%s''", rest);
-                auto storePath = flakeRef.resolve(store).fetchTree(store).first;
-                return store->toRealPath(storePath);
+                auto [accessor, _] = flakeRef.resolve(store).lazyFetch(store);
+                return SourcePath(accessor);
             },
         },
     },
@@ -224,15 +224,15 @@ SourcePath lookupFileArg(EvalState & state, std::string_view s, const Path * bas
     if (EvalSettings::isPseudoUrl(s)) {
         auto accessor = fetchers::downloadTarball(
             EvalSettings::resolvePseudoUrl(s)).accessor;
-        auto storePath = fetchToStore(*state.store, SourcePath(accessor), FetchMode::Copy);
-        return state.rootPath(CanonPath(state.store->toRealPath(storePath)));
+        state.registerAccessor(accessor);
+        return SourcePath(accessor);
     }
 
     else if (hasPrefix(s, "flake:")) {
         experimentalFeatureSettings.require(Xp::Flakes);
         auto flakeRef = parseFlakeRef(std::string(s.substr(6)), {}, true, false);
-        auto storePath = flakeRef.resolve(state.store).fetchTree(state.store).first;
-        return state.rootPath(CanonPath(state.store->toRealPath(storePath)));
+        auto [accessor, _] = flakeRef.resolve(state.store).lazyFetch(state.store);
+        return SourcePath(accessor);
     }
 
     else if (s.size() > 2 && s.at(0) == '<' && s.at(s.size() - 1) == '>') {

src/libexpr/call-flake.nix

@@ -38,13 +38,34 @@ let
       (key: node:
         let
 
+          parentNode = allNodes.${getInputByPath lockFile.root node.parent};
+
           sourceInfo =
             if overrides ? ${key}
             then
               overrides.${key}.sourceInfo
+            else if node.locked.type == "path" && builtins.substring 0 1 node.locked.path != "/"
+            then
+              parentNode.sourceInfo // {
+                # FIXME
+                outPath = parentNode.sourceInfo.outPath + ("/" + node.locked.path);
+              }
             else
               # FIXME: remove obsolete node.info.
-              fetchTree (node.info or {} // removeAttrs node.locked ["dir"]);
+              let
+                tree = fetchTree (node.info or {} // removeAttrs node.locked ["dir"]);
+              in
+                # Apply patches.
+                tree // (
+                  if node.patchFiles or [] == []
+                  then {}
+                  else {
+                    outPath = builtins.patch {
+                      src = tree;
+                      patchFiles =
+                        map (patchFile: parentNode + ("/" + patchFile)) node.patchFiles;
+                    };
+                  });
 
           subdir = overrides.${key}.dir or node.locked.dir or "";
 

src/libexpr/eval-cache.cc

@@ -621,6 +621,9 @@ string_t AttrCursor::getStringWithContext()
                         [&](const NixStringContextElem::Opaque & o) -> const StorePath & {
                             return o.path;
                         },
+                        [&](const NixStringContextElem::SourceAccessor & a) -> const StorePath & {
+                            assert(false); // FIXME
+                        },
                     }, c.raw);
                     if (!root->state.store->isValidPath(path)) {
                         valid = false;

src/libexpr/eval-settings.hh

@@ -2,6 +2,7 @@
 ///@file
 
 #include "config.hh"
+#include "source-path.hh"
 
 namespace nix {
 
@@ -17,11 +18,8 @@ struct EvalSettings : Config
      *
      * The return value is (a) whether the entry was valid, and, if so,
      * what does it map to.
-     *
-     * @todo Return (`std::optional` of) `SourceAccssor` or something
-     * more structured instead of mere `std::string`?
      */
-    using LookupPathHook = std::optional<std::string>(ref<Store> store, std::string_view);
+    using LookupPathHook = std::optional<SourcePath>(ref<Store> store, std::string_view);
 
     /**
      * Map from "scheme" to a `LookupPathHook`.