Fix "follows" paths in subordinate lockfiles

Author: RealityAnomaly

src/libexpr/flake/flake.cc

@@ -317,20 +317,24 @@ LockedFlake lockFlake(
 
         std::vector<FlakeRef> parents;
 
+        // isFlake = whether we are currently inside a subordinate flake
+        // inputDepth = inputs deep we are relative to the current root or subordinate flake
         std::function<void(
             const FlakeInputs & flakeInputs,
             std::shared_ptr<Node> node,
             const InputPath & inputPathPrefix,
-            std::shared_ptr<const Node> oldNode)>
+            std::shared_ptr<const Node> oldNode,
+            const bool isFlake, const int inputDepth)>
             computeLocks;
 
         computeLocks = [&](
             const FlakeInputs & flakeInputs,
             std::shared_ptr<Node> node,
             const InputPath & inputPathPrefix,
-            std::shared_ptr<const Node> oldNode)
+            std::shared_ptr<const Node> oldNode,
+            const bool isFlake, const int inputDepth)
         {
-            debug("computing lock file node '%s'", printInputPath(inputPathPrefix));
+            debug("computing lock file node '%s' (depth %i)", printInputPath(inputPathPrefix), inputDepth);
 
             /* Get the overrides (i.e. attributes of the form
                'inputs.nixops.inputs.nixpkgs.url = ...'). */
@@ -371,11 +375,21 @@ LockedFlake lockFlake(
                        path we haven't processed yet. */
                     if (input.follows) {
                         InputPath target;
-                        if (hasOverride || input.absolute)
+                        if (hasOverride || input.absolute) {
                             /* 'follows' from an override is relative to the
-                               root of the graph. */
-                            target = *input.follows;
-                        else {
+                               root of the graph, but we need to fix up the path for subordinate lockfiles */
+                            if (isFlake) {
+                                target = inputPathPrefix;
+
+                                int subtract = inputDepth;
+                                if (subtract == 0) subtract = 1;
+
+                                for (int i = 0; i < subtract; i++) target.pop_back();
+                                for (auto & i : *input.follows) target.push_back(i);
+                            } else {
+                                target = *input.follows;
+                            }
+                        } else {
                             /* Otherwise, it's relative to the current flake. */
                             target = inputPathPrefix;
                             for (auto & i : *input.follows) target.push_back(i);
@@ -425,7 +439,7 @@ LockedFlake lockFlake(
                         if (hasChildUpdate) {
                             auto inputFlake = getFlake(
                                 state, oldLock->lockedRef, false, flakeCache);
-                            computeLocks(inputFlake.inputs, childNode, inputPath, oldLock);
+                            computeLocks(inputFlake.inputs, childNode, inputPath, oldLock, isFlake, inputDepth + 1);
                         } else {
                             /* No need to fetch this flake, we can be
                                lazy. However there may be new overrides on the
@@ -447,7 +461,7 @@ LockedFlake lockFlake(
                                 }
                             }
 
-                            computeLocks(fakeInputs, childNode, inputPath, oldLock);
+                            computeLocks(fakeInputs, childNode, inputPath, oldLock, isFlake, inputDepth + 1);
                         }
 
                     } else {
@@ -489,7 +503,9 @@ LockedFlake lockFlake(
                                 oldLock
                                 ? std::dynamic_pointer_cast<const Node>(oldLock)
                                 : LockFile::read(
-                                    inputFlake.sourceInfo->actualPath + "/" + inputFlake.lockedRef.subdir + "/flake.lock").root);
+                                    inputFlake.sourceInfo->actualPath + "/" + inputFlake.lockedRef.subdir + "/flake.lock").root,
+                                // Increment input depth if we're entering a non-lockfile flake
+                                true, oldLock ? inputDepth + 1 : inputDepth);
                         }
 
                         else {
@@ -509,7 +525,7 @@ LockedFlake lockFlake(
 
         computeLocks(
             flake.inputs, newLockFile.root, {},
-            lockFlags.recreateLockFile ? nullptr : oldLockFile.root);
+            lockFlags.recreateLockFile ? nullptr : oldLockFile.root, false, 0);
 
         for (auto & i : lockFlags.inputOverrides)
             if (!overridesUsed.count(i.first))