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>

1 files changed, 30 insertions, 17 deletions

diff --git a/src/libstore/path-with-outputs.cc b/src/libstore/path-with-outputs.cc
index 869b490ad..81f360f3a 100644
--- a/src/libstore/path-with-outputs.cc
+++ b/src/libstore/path-with-outputs.cc
@@ -16,10 +16,16 @@ std::string StorePathWithOutputs::to_string(const Store & store) const
 DerivedPath StorePathWithOutputs::toDerivedPath() const
 {
     if (!outputs.empty()) {
-        return DerivedPath::Built { path, OutputsSpec::Names { outputs } };
+        return DerivedPath::Built {
+            .drvPath = makeConstantStorePathRef(path),
+            .outputs = OutputsSpec::Names { outputs },
+        };
     } else if (path.isDerivation()) {
         assert(outputs.empty());
-        return DerivedPath::Built { path, OutputsSpec::All { } };
+        return DerivedPath::Built {
+            .drvPath = makeConstantStorePathRef(path),
+            .outputs = OutputsSpec::All { },
+        };
     } else {
         return DerivedPath::Opaque { path };
     }
@@ -34,29 +40,36 @@ std::vector<DerivedPath> toDerivedPaths(const std::vector<StorePathWithOutputs>
 }
 
 
-std::variant<StorePathWithOutputs, StorePath> StorePathWithOutputs::tryFromDerivedPath(const DerivedPath & p)
+StorePathWithOutputs::ParseResult StorePathWithOutputs::tryFromDerivedPath(const DerivedPath & p)
 {
     return std::visit(overloaded {
-        [&](const DerivedPath::Opaque & bo) -> std::variant<StorePathWithOutputs, StorePath> {
+        [&](const DerivedPath::Opaque & bo) -> StorePathWithOutputs::ParseResult {
             if (bo.path.isDerivation()) {
                 // drv path gets interpreted as "build", not "get drv file itself"
                 return bo.path;
             }
             return StorePathWithOutputs { bo.path };
         },
-        [&](const DerivedPath::Built & bfd) -> std::variant<StorePathWithOutputs, StorePath> {
-            return StorePathWithOutputs {
-                .path = bfd.drvPath,
-                // Use legacy encoding of wildcard as empty set
-                .outputs = std::visit(overloaded {
-                    [&](const OutputsSpec::All &) -> StringSet {
-                        return {};
-                    },
-                    [&](const OutputsSpec::Names & outputs) {
-                        return static_cast<StringSet>(outputs);
-                    },
-                }, bfd.outputs.raw()),
-            };
+        [&](const DerivedPath::Built & bfd) -> StorePathWithOutputs::ParseResult {
+            return std::visit(overloaded {
+                [&](const SingleDerivedPath::Opaque & bo) -> StorePathWithOutputs::ParseResult {
+                    return StorePathWithOutputs {
+                        .path = bo.path,
+                        // Use legacy encoding of wildcard as empty set
+                        .outputs = std::visit(overloaded {
+                            [&](const OutputsSpec::All &) -> StringSet {
+                                return {};
+                            },
+                            [&](const OutputsSpec::Names & outputs) {
+                                return static_cast<StringSet>(outputs);
+                            },
+                        }, bfd.outputs.raw()),
+                    };
+                },
+                [&](const SingleDerivedPath::Built &) -> StorePathWithOutputs::ParseResult {
+                    return std::monostate {};
+                },
+            }, bfd.drvPath->raw());
         },
     }, p.raw());
 }