flake lock: fix relative inputs in nested flakes

When computeLocks() keeps an existing flake input without
refetching it, it recurses into that flake's inputs using the
parent flake's source path. That value is only used to resolve
relative 'path:' inputs, so it is harmless unless the kept flake
has one. When it does (e.g. a flake with a "path:./sub" input
that is itself a transitive input), the relative input is
resolved against the parent flake's tree instead of the kept
flake's, and locking then fails to find the input's flake.nix.

Force a refetch of the kept flake when it has a relative input,
so its real source path is available to resolve that input.
Flakes without relative inputs stay on the lazy path unchanged.

Fixes #14762.

Author: nhooey

doc/manual/rl-next/flake-lock-nested-relative-inputs.md

@@ -0,0 +1,9 @@
+---
+synopsis: "Fix locking of relative `path:` inputs in deeply nested flakes"
+issues: [14762]
+---
+
+Locking a flake that transitively depends on a flake with a relative `path:`
+input (three or more levels deep) no longer fails with
+`path '.../flake.nix' does not exist`. The relative input is now resolved
+against the correct flake's source tree.

src/libflake/flake.cc

@@ -638,6 +638,18 @@ LockedFlake lockFlake(
                                those. */
                             for (auto & i : oldLock->inputs) {
                                 if (auto lockedNode = std::get_if<0>(&i.second)) {
+                                    /* A relative path input (e.g. 'path:./foo')
+                                       can only be resolved against the source
+                                       tree of *this* flake. In the lazy path we
+                                       don't have that tree, so the input would
+                                       be resolved against the parent flake's
+                                       tree instead -- wrong when this flake is
+                                       itself a nested input. Refetch so we get
+                                       the correct source path. See #14762. */
+                                    if ((*lockedNode)->lockedRef.input.isRelative()) {
+                                        mustRefetch = true;
+                                        break;
+                                    }
                                     fakeInputs.emplace(
                                         i.first,
                                         FlakeInput{

tests/functional/flakes/relative-paths.sh

@@ -172,3 +172,45 @@ EOF
   nix eval --json .#nestedFlake1.nestedFlake2 --no-eval-cache
   nix eval --json .#nestedFlake1.nestedFlake2 --no-eval-cache
 )
+
+# https://github.com/NixOS/nix/issues/14762
+# A relative 'path:' input nested under a flake that is itself kept from an
+# existing lock (the lazy "keep" path) must be resolved against that flake's
+# source tree, not its parent's. This only goes wrong at three levels:
+# top -> middle -> library, where 'library' has a relative 'subflake' input.
+n14762="$TEST_ROOT/issue-14762"
+rm -rf "$n14762"
+mkdir -p "$n14762/library/subflake" "$n14762/middle" "$n14762/top"
+
+cat > "$n14762/library/subflake/flake.nix" <<EOF
+{ outputs = _: { }; }
+EOF
+cat > "$n14762/library/flake.nix" <<EOF
+{
+  inputs.subflake.url = "path:./subflake";
+  outputs = _: { };
+}
+EOF
+cat > "$n14762/middle/flake.nix" <<EOF
+{
+  inputs.library.url = "path:$n14762/library";
+  outputs = _: { };
+}
+EOF
+cat > "$n14762/top/flake.nix" <<EOF
+{
+  inputs.middle.url = "path:$n14762/middle";
+  outputs = _: { };
+}
+EOF
+
+# These are plain 'path:' inputs with no fingerprint, so fetching them is
+# uncacheable (as on master); disable the test-only barf, like other tests do.
+
+# Establish the middle flake's lock first, so that when the top flake locks,
+# 'library' is taken from middle's lock via the lazy "keep" path.
+_NIX_TEST_BARF_ON_UNCACHEABLE='' nix flake lock "$n14762/middle"
+
+# Previously failed: "path '.../subflake/flake.nix' does not exist".
+_NIX_TEST_BARF_ON_UNCACHEABLE='' nix flake update --flake "$n14762/top"
+[[ -e "$n14762/top/flake.lock" ]]