Make the Derived Path family of types inductive for dynamic derivations

We want to be able to write down `foo.drv^bar.drv^baz`:
`foo.drv^bar.drv` is the dynamic derivation (since it is itself a
derivation output, `bar.drv` from `foo.drv`).

To that end, we create `Single{Derivation,BuiltPath}` types, that are
very similar except instead of having multiple outputs (in a set or
map), they have a single one. This is for everything to the left of the
rightmost `^`.

`NixStringContextElem` has an analogous change, and now can reuse
`SingleDerivedPath` at the top level. In fact, if we ever get rid of
`DrvDeep`, `NixStringContextElem` could be replaced with
`SingleDerivedPath` entirely!

Important note: some JSON formats have changed.

We already can *produce* dynamic derivations, but we can't refer to them
directly. Today, we can merely express building or example at the top
imperatively over time by building `foo.drv^bar.drv`, and then with a
second nix invocation doing `<result-from-first>^baz`, but this is not
declarative. The ethos of Nix of being able to write down the full plan
everything you want to do, and then execute than plan with a single
command, and for that we need the new inductive form of these types.

Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>

6 files changed, 26 insertions, 21 deletions

diff --git a/src/nix/app.cc b/src/nix/app.cc
index e0f68b4fc..16a921194 100644
--- a/src/nix/app.cc
+++ b/src/nix/app.cc
@@ -25,7 +25,8 @@ StringPairs resolveRewrites(
             if (experimentalFeatureSettings.isEnabled(Xp::CaDerivations))
                 for (auto & [ outputName, outputPath ] : drvDep->outputs)
                     res.emplace(
-                        DownstreamPlaceholder::unknownCaOutput(drvDep->drvPath, outputName).render(),
+                        DownstreamPlaceholder::unknownCaOutput(
+                            drvDep->drvPath->outPath(), outputName).render(),
                         store.printStorePath(outputPath)
                     );
     return res;
@@ -65,7 +66,7 @@ UnresolvedApp InstallableValue::toApp(EvalState & state)
                 [&](const NixStringContextElem::DrvDeep & d) -> DerivedPath {
                     /* We want all outputs of the drv */
                     return DerivedPath::Built {
-                        .drvPath = d.drvPath,
+                        .drvPath = makeConstantStorePathRef(d.drvPath),
                         .outputs = OutputsSpec::All {},
                     };
                 },
@@ -106,7 +107,7 @@ UnresolvedApp InstallableValue::toApp(EvalState & state)
         auto program = outPath + "/bin/" + mainProgram;
         return UnresolvedApp { App {
             .context = { DerivedPath::Built {
-                .drvPath = drvPath,
+                .drvPath = makeConstantStorePathRef(drvPath),
                 .outputs = OutputsSpec::Names { outputName },
             } },
             .program = program,
diff --git a/src/nix/build.cc b/src/nix/build.cc
index ad1842a4e..479100186 100644
--- a/src/nix/build.cc
+++ b/src/nix/build.cc
@@ -9,18 +9,18 @@
 
 using namespace nix;
 
-nlohmann::json derivedPathsToJSON(const DerivedPaths & paths, ref<Store> store)
+static nlohmann::json derivedPathsToJSON(const DerivedPaths & paths, Store & store)
 {
     auto res = nlohmann::json::array();
     for (auto & t : paths) {
-        std::visit([&res, store](const auto & t) {
+        std::visit([&](const auto & t) {
             res.push_back(t.toJSON(store));
         }, t.raw());
     }
     return res;
 }
 
-nlohmann::json builtPathsWithResultToJSON(const std::vector<BuiltPathWithResult> & buildables, ref<Store> store)
+static nlohmann::json builtPathsWithResultToJSON(const std::vector<BuiltPathWithResult> & buildables, const Store & store)
 {
     auto res = nlohmann::json::array();
     for (auto & b : buildables) {
@@ -125,7 +125,7 @@ struct CmdBuild : InstallablesCommand, MixDryRun, MixJSON, MixProfile
             printMissing(store, pathsToBuild, lvlError);
 
             if (json)
-                logger->cout("%s", derivedPathsToJSON(pathsToBuild, store).dump());
+                logger->cout("%s", derivedPathsToJSON(pathsToBuild, *store).dump());
 
             return;
         }
@@ -136,7 +136,7 @@ struct CmdBuild : InstallablesCommand, MixDryRun, MixJSON, MixProfile
             installables,
             repair ? bmRepair : buildMode);
 
-        if (json) logger->cout("%s", builtPathsWithResultToJSON(buildables, store).dump());
+        if (json) logger->cout("%s", builtPathsWithResultToJSON(buildables, *store).dump());
 
         if (outLink != "")
             if (auto store2 = store.dynamic_pointer_cast<LocalFSStore>())
diff --git a/src/nix/bundle.cc b/src/nix/bundle.cc
index bcc00d490..5a80f0308 100644
--- a/src/nix/bundle.cc
+++ b/src/nix/bundle.cc
@@ -109,7 +109,7 @@ struct CmdBundle : InstallableValueCommand
 
         store->buildPaths({
             DerivedPath::Built {
-                .drvPath = drvPath,
+                .drvPath = makeConstantStorePathRef(drvPath),
                 .outputs = OutputsSpec::All { },
             },
         });
diff --git a/src/nix/develop.cc b/src/nix/develop.cc
index 195eeaa21..c033804e4 100644
--- a/src/nix/develop.cc
+++ b/src/nix/develop.cc
@@ -235,7 +235,7 @@ static StorePath getDerivationEnvironment(ref<Store> store, ref<Store> evalStore
     /* Build the derivation. */
     store->buildPaths(
         { DerivedPath::Built {
-            .drvPath = shellDrvPath,
+            .drvPath = makeConstantStorePathRef(shellDrvPath),
             .outputs = OutputsSpec::All { },
         }},
         bmNormal, evalStore);
diff --git a/src/nix/flake.cc b/src/nix/flake.cc
index 3ce1de44a..83b74c8ca 100644
--- a/src/nix/flake.cc
+++ b/src/nix/flake.cc
@@ -544,9 +544,9 @@ struct CmdFlakeCheck : FlakeCommand
                                             *attr2.value, attr2.pos);
                                         if (drvPath && attr_name == settings.thisSystem.get()) {
                                             drvPaths.push_back(DerivedPath::Built {
-                                                    .drvPath = *drvPath,
-                                                        .outputs = OutputsSpec::All { },
-                                                        });
+                                                .drvPath = makeConstantStorePathRef(*drvPath),
+                                                .outputs = OutputsSpec::All { },
+                                            });
                                         }
                                     }
                                 }
diff --git a/src/nix/log.cc b/src/nix/log.cc
index aaf829764..9a9bd30f9 100644
--- a/src/nix/log.cc
+++ b/src/nix/log.cc
@@ -33,6 +33,17 @@ struct CmdLog : InstallableCommand
 
         auto b = installable->toDerivedPath();
 
+        // For compat with CLI today, TODO revisit
+        auto oneUp = std::visit(overloaded {
+            [&](const DerivedPath::Opaque & bo) {
+                return make_ref<SingleDerivedPath>(bo);
+            },
+            [&](const DerivedPath::Built & bfd) {
+                return bfd.drvPath;
+            },
+        }, b.path.raw());
+        auto path = resolveDerivedPath(*store, *oneUp);
+
         RunPager pager;
         for (auto & sub : subs) {
             auto * logSubP = dynamic_cast<LogStore *>(&*sub);
@@ -42,14 +53,7 @@ struct CmdLog : InstallableCommand
             }
             auto & logSub = *logSubP;
 
-            auto log = std::visit(overloaded {
-                [&](const DerivedPath::Opaque & bo) {
-                    return logSub.getBuildLog(bo.path);
-                },
-                [&](const DerivedPath::Built & bfd) {
-                    return logSub.getBuildLog(bfd.drvPath);
-                },
-            }, b.path.raw());
+            auto log = logSub.getBuildLog(path);
             if (!log) continue;
             stopProgressBar();
             printInfo("got build log for '%s' from '%s'", installable->what(), logSub.getUri());