Change types to prepare the way for CA derivations

We've added the variant to `DerivationOutput` to support them, but made
`DerivationOutput::path` partial to avoid actually implementing them.

With this chage, we can all collaborate on "just" removing
`DerivationOutput::path` calls to implement CA derivations.

src/libstore/derivations.cc

@@ -8,15 +8,20 @@
 
 namespace nix {
 
-StorePath DerivationOutput::path(const Store & store, std::string_view drvName) const
+std::optional<StorePath> DerivationOutput::pathOpt(const Store & store, std::string_view drvName) const
 {
     return std::visit(overloaded {
-        [](DerivationOutputInputAddressed doi) {
+        [](DerivationOutputInputAddressed doi) -> std::optional<StorePath> {
-            return doi.path;
+            return { doi.path };
+        },
+        [&](DerivationOutputFixed dof) -> std::optional<StorePath> {
+            return {
+                store.makeFixedOutputPath(dof.hash.method, dof.hash.hash, drvName)
+            };
+        },
+        [](DerivationOutputFloating dof) -> std::optional<StorePath> {
+            return std::nullopt;
         },
-        [&](DerivationOutputFixed dof) {
-            return store.makeFixedOutputPath(dof.hash.method, dof.hash.hash, drvName);
-        }
     }, output);
 }
 
@@ -128,14 +133,21 @@ static DerivationOutput parseDerivationOutput(const Store & store, istringstream
         }
         const HashType hashType = parseHashType(hashAlgo);
 
-        return DerivationOutput {
+        return hash != ""
-            .output = DerivationOutputFixed {
+            ? DerivationOutput {
-                .hash = FixedOutputHash {
+                  .output = DerivationOutputFixed {
-                    .method = std::move(method),
+                      .hash = FixedOutputHash {
-                    .hash = Hash(hash, hashType),
+                          .method = std::move(method),
-                },
+                          .hash = Hash(hash, hashType),
-            }
+                      },
-        };
+                  }
+               }
+            : DerivationOutput {
+                  .output = DerivationOutputFloating {
+                      .method = std::move(method),
+                      .hashType = std::move(hashType),
+                  },
+              };
     } else
         return DerivationOutput {
             .output = DerivationOutputInputAddressed {
@@ -292,6 +304,10 @@ string Derivation::unparse(const Store & store, bool maskOutputs,
                 s += ','; printUnquotedString(s, dof.hash.printMethodAlgo());
                 s += ','; printUnquotedString(s, dof.hash.hash.to_string(Base16, false));
             },
+            [&](DerivationOutputFloating dof) {
+                s += ','; printUnquotedString(s, makeFileIngestionPrefix(dof.method) + printHashType(dof.hashType));
+                s += ','; printUnquotedString(s, "");
+            },
         }, i.second.output);
         s += ')';
     }
@@ -439,14 +455,21 @@ static DerivationOutput readDerivationOutput(Source & in, const Store & store)
             hashAlgo = string(hashAlgo, 2);
         }
         auto hashType = parseHashType(hashAlgo);
-        return DerivationOutput {
+        return hash != ""
-            .output = DerivationOutputFixed {
+            ? DerivationOutput {
-                .hash = FixedOutputHash {
+                  .output = DerivationOutputFixed {
-                    .method = std::move(method),
+                      .hash = FixedOutputHash {
-                    .hash = Hash(hash, hashType),
+                          .method = std::move(method),
-                },
+                          .hash = Hash(hash, hashType),
-            }
+                      },
-        };
+                  }
+               }
+            : DerivationOutput {
+                  .output = DerivationOutputFloating {
+                      .method = std::move(method),
+                      .hashType = std::move(hashType),
+                  },
+              };
     } else
         return DerivationOutput {
             .output = DerivationOutputInputAddressed {
@@ -514,6 +537,10 @@ void writeDerivation(Sink & out, const Store & store, const BasicDerivation & dr
                 out << dof.hash.printMethodAlgo()
                     << dof.hash.hash.to_string(Base16, false);
             },
+            [&](DerivationOutputFloating dof) {
+                out << (makeFileIngestionPrefix(dof.method) + printHashType(dof.hashType))
+                    << "";
+            },
         }, i.second.output);
     }
     writeStorePaths(store, out, drv.inputSrcs);

src/libstore/derivations.hh

@@ -15,6 +15,8 @@ namespace nix {
 
 struct DerivationOutputInputAddressed
 {
+    /* Will need to become `std::optional<StorePath>` once input-addressed
+       derivations are allowed to depend on cont-addressed derivations */
     StorePath path;
 };
 
@@ -23,13 +25,28 @@ struct DerivationOutputFixed
     FixedOutputHash hash; /* hash used for expected hash computation */
 };
 
+struct DerivationOutputFloating
+{
+    /* information used for expected hash computation */
+    FileIngestionMethod method;
+    HashType hashType;
+};
+
 struct DerivationOutput
 {
     std::variant<
         DerivationOutputInputAddressed,
-        DerivationOutputFixed
+        DerivationOutputFixed,
+        DerivationOutputFloating
     > output;
-    StorePath path(const Store & store, std::string_view drvName) const;
+    std::optional<HashType> hashAlgoOpt(const Store & store) const;
+    std::optional<StorePath> pathOpt(const Store & store, std::string_view drvName) const;
+    /* DEPRECATED: Remove after CA drvs are fully implemented */
+    StorePath path(const Store & store, std::string_view drvName) const {
+        auto p = pathOpt(store, drvName);
+        if (!p) throw Error("floating content-addressed derivations are not yet implemented");
+        return *p;
+    }
 };
 
 typedef std::map<string, DerivationOutput> DerivationOutputs;

src/nix/show-derivation.cc

@@ -78,6 +78,9 @@ struct CmdShowDerivation : InstallablesCommand
                             outputObj.attr("hashAlgo", dof.hash.printMethodAlgo());
                             outputObj.attr("hash", dof.hash.hash.to_string(Base16, false));
                         },
+                        [&](DerivationOutputFloating dof) {
+                            outputObj.attr("hashAlgo", makeFileIngestionPrefix(dof.method) + printHashType(dof.hashType));
+                        },
                     }, output.second.output);
                 }
             }